src/sql/wsqltable.cpp

Go to the documentation of this file.

/*
    WORM - a DAL/ORM code generation framework
    Copyright (C) 2011  Erik Winn <erikwinnmail@yahoo.com>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "wsqltable.h"

namespace WSql {
    
WSqlTable::WSqlTable()
{
    _type = NORMAL;
    _isValid = false;
}
WSqlTable::WSqlTable( const std::string name )
{
    _type = NORMAL;
    _name = name;
    _isValid = false;
}

WSqlTable::WSqlTable( const WSqlTable &other )
{
    _type = other._type;
    _isValid = other._isValid;
    _name = other._name;
    _className = other._className;
    _columns = other._columns;
    _foreignKeys = other._foreignKeys;
    _referencedKeys = other._referencedKeys;
}
WSqlTable& WSqlTable::operator=( const WSqlTable& other )
{
    _type = other._type;
    _isValid = other._isValid;
    _name = other._name;
    _className = other._className;
    _columns = other._columns;
    _foreignKeys = other._foreignKeys;
    _referencedKeys = other._referencedKeys;
    return *this;
}
WSqlTable::~WSqlTable()
{
    _columns.clear();
    _foreignKeys.clear();
    _referencedKeys.clear();
}
bool WSqlTable::operator==( const WSqlTable &other ) const
{
    if(_isValid != other._isValid)
        return false;
    if(_type != other._type)
        return false;
    if ( _columns.size() !=  other._columns.size()
            || _name.compare( other._name ) != 0 )
        return false;

    std::vector<WSqlColumn>::const_iterator it;
    std::vector<WSqlColumn>::const_iterator ito = other._columns.begin();
    for ( it = _columns.begin();it != _columns.end();++it ) 
     {
         if ( ito == other._columns.end() || *( it ) != *( ito ) )
            return false;
        else
            ito++;
    }
    std::vector<WSqlForeignKey>::const_iterator fit;
    std::vector<WSqlForeignKey>::const_iterator fito = other._foreignKeys.begin();
    for ( fit = _foreignKeys.begin(); fit != _foreignKeys.end(); ++fit ) 
    {
        if (  fito == other._foreignKeys.end() || *( fit ) != *( fito ) )
            return false;
        else
            fito++;
    }
    std::vector<WSqlReferencedKey>::const_iterator rfit;
    std::vector<WSqlReferencedKey>::const_iterator rfito = other._referencedKeys.begin();
    for ( rfit = _referencedKeys.begin();rfit != _referencedKeys.end();++rfit ) 
    {
        if ( rfito == other._referencedKeys.end() || *( rfit ) != *( rfito ) )
            return false;
        else
            rfito++;
    }
    return true;
}

const std::string WSqlTable::columnName( int index ) const
{
    std::string strToReturn;
    int sz = _columns.size();
    if ( !sz || index < 0 || index > sz - 1 )
        return strToReturn;
    std::vector<WSqlColumn>::const_iterator it = _columns.begin();
    it += index;
    return it->columnName();
}

WSqlColumn WSqlTable::column( int index ) const
{
    WSqlColumn clmToReturn;
    int sz = _columns.size();
    if ( !sz || index < 0 || index > sz - 1 )
        return clmToReturn;
    std::vector<WSqlColumn>::const_iterator it = _columns.begin();
    it += index;
    return *it;
}

WSqlColumn WSqlTable::column( const std::string &fldname ) const
{
    WSqlColumn clmToReturn;
    if ( _columns.empty() )
        return clmToReturn;

    std::vector<WSqlColumn>::const_iterator it;
    for ( it = _columns.begin(); it != _columns.end(); ++it ) 
    {
        if ( it->columnName().compare( fldname ) == 0 ) 
        {
            clmToReturn = *it;
            break;
        }
    }
    return clmToReturn;
}

const std::vector<WSqlColumn>& WSqlTable::columns() const
{
    return _columns;
}
std::vector<std::string> WSqlTable::columnNames() const
{
    std::vector<std::string> vecToReturn;
    std::vector<WSqlColumn>::const_iterator it;
    for ( it = _columns.begin(); it != _columns.end(); ++it )
        vecToReturn.push_back( it->columnName() );
    return vecToReturn;
}

int WSqlTable::count() const
{
    return _columns.size();
}

int WSqlTable::indexOf( const std::string &columnname ) const
{
    int intToReturn = -1;
    if ( _columns.empty() )
        return intToReturn;
    int i = 0;
    std::vector<WSqlColumn>::const_iterator it;
    for ( it = _columns.begin(); it != _columns.end() ; ++it ) {
        if ( it->columnName().compare( columnname ) == 0 ) {
            intToReturn = i;
            break;
        }
        ++i;
    }
    return intToReturn;
}

void WSqlTable::append( const WSqlColumn& column )
{
    _columns.push_back( column );
}

void WSqlTable::replace( int pos, const WSqlColumn& column )
{
    insert( pos, column, true );
}

void WSqlTable::insert( int pos, const WSqlColumn& column, bool replace )
{
    int sz = _columns.size();
    if ( !sz || pos < 0 || pos > sz - 1 )
        return;
    std::vector<WSqlColumn>::iterator it = _columns.begin();
    it += pos;
    if ( replace )
        _columns.erase( it );
    _columns.insert( it, 1, column );
}

void WSqlTable::remove( int pos )
{
    int sz = _columns.size();
    if ( !sz || pos < 0 || pos > sz - 1 )
        return;
    std::vector<WSqlColumn>::iterator it = _columns.begin();
    it += pos;
    _columns.erase( it );
}

bool WSqlTable::isEmpty() const
{
    return _columns.empty();
}

WSqlForeignKey WSqlTable::foreignKey( const std::string columnname ) const
{
    std::vector<WSqlForeignKey>::const_iterator it = _foreignKeys.begin();
    for(;it != _foreignKeys.end(); ++it)
    {
        if (it->columnName().compare(columnname) == 0)
        {
            return *it;
        }
    }
    return WSqlForeignKey();
}

void WSqlTable::addForeignKey( const WSqlForeignKey& fk )
{
    _foreignKeys.push_back(fk);
}

const std::vector< WSqlForeignKey >& WSqlTable::foreignKeys() const
{
    return _foreignKeys;
}

void WSqlTable::removeForeignKey( const WSqlForeignKey& fk )
{
    std::vector<WSqlForeignKey>::iterator it = _foreignKeys.begin();
    for(;it != _foreignKeys.end(); ++it)
    {
        if (*(it) == fk)
        {
            _foreignKeys.erase(it);
            break;
        }
    }
}

void WSqlTable::removeForeignKey( int pos )
{
    int sz = _foreignKeys.size();
    if ( !sz || pos < 0 || pos > sz - 1 )
        return;
    std::vector<WSqlForeignKey>::iterator it = _foreignKeys.begin();
    it += pos;
    _foreignKeys.erase( it );
}

void WSqlTable::removeForeignKey( const std::string& keyname )
{
    if ( _foreignKeys.empty() )
        return;
    
    std::vector<WSqlForeignKey>::iterator it;
    for ( it = _foreignKeys.begin(); it != _foreignKeys.end(); ++it ) 
    {
        if ( it->keyName().compare( keyname ) == 0 ) 
        {
            _foreignKeys.erase(it);
            break;
        }
    }
}

WSqlReferencedKey WSqlTable::referencedKey( const std::string columnname ) const
{
    std::vector<WSqlReferencedKey>::const_iterator it = _referencedKeys.begin();
    for(;it != _referencedKeys.end(); ++it)
        if (it->columnName().compare(columnname) == 0)
            return *it;
    return WSqlReferencedKey(WSqlForeignKey());
}

void WSqlTable::addReferencedKey( const WSqlReferencedKey& fk )
{
    _referencedKeys.push_back(fk);
}

const std::vector< WSqlReferencedKey >& WSqlTable::referencedKeys() const
{
    return _referencedKeys;
}

void WSqlTable::removeReferencedKey( const WSqlReferencedKey& rk )
{
    std::vector<WSqlReferencedKey>::iterator it = _referencedKeys.begin();
    for(;it != _referencedKeys.end(); ++it)
    {
        if (*(it) == rk)
        {
            _referencedKeys.erase(it);
            break;
        }
    }
}

void WSqlTable::removeReferencedKey( int pos )
{
    int sz = _referencedKeys.size();
    if ( !sz || pos < 0 || pos > sz - 1 )
        return;
    std::vector<WSqlReferencedKey>::iterator it = _referencedKeys.begin();
    it += pos;
    _referencedKeys.erase( it );
}

void WSqlTable::removeReferencedKey( const std::string& columnname )
{
    if ( _referencedKeys.empty() )
        return;
    
    std::vector<WSqlReferencedKey>::iterator it;
    for ( it = _referencedKeys.begin(); it != _referencedKeys.end(); ++it ) 
    {
        if ( it->columnName().compare( columnname ) == 0 ) 
        {
            _referencedKeys.erase(it);
            break;
        }
    }
}

void WSqlTable::setName( const std::string& tablename )
{
    _name=tablename;
    _className=WSqlDataType::tableNameToClass(tablename);
}

} // namespace WSql