---

Connection.cpp

Go to the documentation of this file.

// /******************************************************************************\
// *
// * File:          Connection.cpp
// * Creation date: May 17, 2001 13:11
// * Author:        ClassBuilder
// *                XXXX
// * Purpose:       Method implementations of class 'DOConnection'
// *
// * Modifications: @INSERT_MODIFICATIONS(* )
// * June 29, 2001 11:41 WERS
// *     Deleted method 'LastInsertId'
// *     Updated return type of method 'LastInsertId'
// * May 18, 2001 10:04 WERS
// *     Updated code of method 'GetHdl'
// *     Updated code of method 'Connect'
// * May 17, 2001 15:19 WERS
// *     Added member 'm_database'
// *     Updated code of method 'Connect'
// * May 17, 2001 14:26 WERS
// *     Updated code of method 'GetHdl'
// * May 17, 2001 14:26 WERS
// *     Deleted method 'GetHandle'
// *     Added method 'GetHdl'
// *     Updated member 'm_handle'
// * May 17, 2001 14:24 WERS
// *     Deleted method 'Disconnect'
// *     Added relation 'Connection(DOConnection) <>-->> Query(DOQuery)'
// *     Updated code of method 'ConstructorInclude'
// *     Updated code of method '~DOConnection'
// * May 17, 2001 14:02 WERS
// *     Deleted method 'DOConnection'
// *     Added method 'DOConnection'
// * May 17, 2001 14:01 WERS
// *     Deleted inheritance 'DOConnection'
// *     Added member 'm_username'
// *     Added member 'm_password'
// *     Added member 'm_hostname'
// *     Updated code of method 'GetHandle'
// *     Updated code of method 'Disconnect'
// *     Updated code of method '~DOConnection'
// *     Updated code of method 'DOConnection'
// *     Updated member 'm_handle'
// * May 17, 2001 13:57 WERS
// *     Added method 'GetHandle'
// *     Added method 'Disconnect'
// *     Added method 'Connect'
// *     Added member 'm_handle'
// *     Updated code of method 'DOConnection'
// * May 17, 2001 13:40 WERS
// *     Added method 'DOConnection'
// * May 17, 2001 13:11 WERS
// *     Added method 'DestructorInclude'
// *     Added method 'ConstructorInclude'
// *     Added method '~DOConnection'
// *     Added inheritance 'DOConnection'
// *
// *
// \******************************************************************************/
//@START_USER1

/* --------------------------------------------------------------
Copyright (C) 2001 LifeLine Networks BV <soap2corba@lifeline.nl>

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 2 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, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-------------------------------------------------------------- */

//@END_USER1


// Master include file
#include "DbObjects.h"


//@START_USER2
//@END_USER2


// Static members


DOConnection::DOConnection() //@INIT_51
    : m_handle()
    , m_hostname()
    , m_password()
    , m_username()
    , m_database()
{//@CODE_51
    ConstructorInclude();

    // Put in your own code
}//@CODE_51


DOConnection::~DOConnection()
{//@CODE_34
    DestructorInclude();

    mysql_close (&m_handle);
}//@CODE_34


void DOConnection::Connect()
{//@CODE_49
    if (mysql_connect (&m_handle, m_hostname, m_username, m_password) != NULL) {
        mysql_select_db (&m_handle, m_database);
    }
    
}//@CODE_49


MYSQL* DOConnection::GetHdl()
{//@CODE_146
    return &m_handle;
}//@CODE_146


//{{AFX DO NOT EDIT CODE BELOW THIS LINE !!!

void DOConnection::ConstructorInclude()
{
    // INIT_MULTI_OWNED_ACTIVE(DOConnection, Connection, DOQuery, Query)
   
    _firstQuery = (DOQuery*)0;
    _lastQuery = (DOQuery*)0;
    _countQuery = 0;
}


void DOConnection::DestructorInclude()
{
    // EXIT_MULTI_OWNED_ACTIVE(DOConnection, Connection, DOQuery, Query)
    { for (DOQuery* item = GetFirstQuery(); item; item = GetFirstQuery())
          delete item; }
}


// Methods for the relation(s) of the class
// METHODS_MULTI_OWNED_ACTIVE(DOConnection, Connection, DOQuery, Query)
void DOConnection::AddQueryFirst(DOQuery* item)
{
    
    assert(this);

    assert(item);
    assert(item->_refConnection == (DOConnection*)0);

    _countQuery++;

    item->_refConnection = this;

    if (_firstQuery)
    {
        _firstQuery->_prevConnection = item;
        item->_nextConnection = _firstQuery;
        _firstQuery = item;
    }
    else
        _firstQuery = _lastQuery = item; 
}

void DOConnection::AddQueryLast(DOQuery* item)
{
    
    assert(this);

    assert(item);
    assert(item->_refConnection == (DOConnection*)0);

    _countQuery++;

    item->_refConnection = this;

    if (_lastQuery)
    {
        _lastQuery->_nextConnection = item;
        item->_prevConnection = _lastQuery;
        _lastQuery = item;
    }
    else
        _firstQuery = _lastQuery = item; 
}

void DOConnection::AddQueryAfter(DOQuery* item, DOQuery* pos)
{
    
    assert(this);

    assert(item);
    assert(item->_refConnection == (DOConnection*)0);

    assert(pos);
    assert(pos->_refConnection == this);

    _countQuery++;

    item->_refConnection = this;
    item->_prevConnection = pos;
    item->_nextConnection = pos->_nextConnection;
    pos->_nextConnection  = item;

    if (item->_nextConnection)
        item->_nextConnection->_prevConnection = item;
    else
        _lastQuery = item; 
}

void DOConnection::AddQueryBefore(DOQuery* item, DOQuery* pos)
{
    
    assert(this);

    assert(item);
    assert(item->_refConnection == (DOConnection*)0);

    assert(pos);
    assert(pos->_refConnection == this);

    _countQuery++;

    item->_refConnection = this;
    item->_nextConnection = pos;
    item->_prevConnection = pos->_prevConnection;
    pos->_prevConnection  = item;

    if (item->_prevConnection)
        item->_prevConnection->_nextConnection = item;
    else
        _firstQuery = item; 
}

void DOConnection::RemoveQuery(DOQuery* item)
{
    
    assert(this);

    assert(item);
    assert(item->_refConnection == this);

    DOConnection::QueryIterator::Check(item);

    _countQuery--;

    if (item->_nextConnection)
        item->_nextConnection->_prevConnection = item->_prevConnection;
    else
        _lastQuery = item->_prevConnection;

    if (item->_prevConnection)
        item->_prevConnection->_nextConnection = item->_nextConnection;
    else
        _firstQuery = item->_nextConnection;

    item->_prevConnection = (DOQuery*)0;
    item->_nextConnection = (DOQuery*)0;
    item->_refConnection = (DOConnection*)0; 
}

void DOConnection::DeleteAllQuery()
{
    
    assert(this);

    for (DOQuery* item = GetFirstQuery(); item; item = GetFirstQuery())
          delete item; 
}

void DOConnection::ReplaceQuery(DOQuery* item, DOQuery* newItem)
{
    
    assert(this);

    assert(item);
    assert(item->_refConnection == this);

    assert(newItem);
    assert(newItem->_refConnection == (DOConnection*)0);

    DOConnection::QueryIterator::Check(item, newItem);

    if (item->_nextConnection)
        item->_nextConnection->_prevConnection = newItem;
    else
        _lastQuery = newItem;

    if (item->_prevConnection)
        item->_prevConnection->_nextConnection = newItem;
    else
        _firstQuery = newItem;

    newItem->_nextConnection = item->_nextConnection;
    newItem->_prevConnection = item->_prevConnection;
    item->_nextConnection = (DOQuery*)0;
    item->_prevConnection = (DOQuery*)0;

    item->_refConnection = (DOConnection*)0;
    newItem->_refConnection = this; 
}

DOQuery* DOConnection::GetFirstQuery() const
{
    
    assert(this);
    return _firstQuery; 
}

DOQuery* DOConnection::GetLastQuery() const
{
    
    assert(this);
    return _lastQuery; 
}

DOQuery* DOConnection::GetNextQuery(DOQuery* pos) const
{
    
    assert(this);

    if (pos == (DOQuery*)0)
        return _firstQuery;

    assert(pos);
    assert(pos->_refConnection == this);

    return pos->_nextConnection; 
}

DOQuery* DOConnection::GetPrevQuery(DOQuery* pos) const
{
    
    assert(this);

    if (pos == (DOQuery*)0)
        return _lastQuery;

    assert(pos);
    assert(pos->_refConnection == this);

    return pos->_prevConnection; 
}

int DOConnection::GetQueryCount() const
{
    
    assert(this);
    return _countQuery; 
}

void DOConnection::MoveQueryFirst(DOQuery* item)
{
    
    assert(item);
    assert(item->_refConnection);
    item->_refConnection->RemoveQuery(item);
    AddQueryFirst(item); 
}

void DOConnection::MoveQueryLast(DOQuery* item)
{
    
    assert(item);
    assert(item->_refConnection);
    item->_refConnection->RemoveQuery(item);
    AddQueryLast(item); 
}

void DOConnection::MoveQueryAfter(DOQuery* item, DOQuery* pos)
{
    
    assert(item);
    assert(item->_refConnection);
    item->_refConnection->RemoveQuery(item);
    AddQueryAfter(item, pos); 
}

void DOConnection::MoveQueryBefore(DOQuery* item, DOQuery* pos)
{
    
    assert(item);
    assert(item->_refConnection);
    item->_refConnection->RemoveQuery(item);
    AddQueryBefore(item, pos); 
}

void DOConnection::SortQuery(int (*comp)(DOQuery*, DOQuery*))
{
    
    for (DOQuery* a = GetFirstQuery(); a; a = GetNextQuery(a))
    {
        DOQuery* b = GetNextQuery(a);

        while (b && (comp(a, b) > 0))
        {
            DOQuery* c = GetPrevQuery(a);
            while (c && (comp(c, b) > 0))
                c = GetPrevQuery(c);

            if (c)
                MoveQueryAfter(b, c);
            else
                MoveQueryFirst(b);

            b = GetNextQuery(a);
        }
    } 
}
// METHODS_ITERATOR_MULTI_ACTIVE(DOConnection, Connection, DOQuery, Query)
DOConnection::QueryIterator* DOConnection::QueryIterator::_first = 0;
DOConnection::QueryIterator* DOConnection::QueryIterator::_last = 0;

DOConnection::QueryIterator::QueryIterator(
    const DOConnection* iterConnection,
    int (DOQuery::*method)() const,
    DOQuery* refQuery)
{
    assert(iterConnection);

    _iterConnection = iterConnection;
    _refQuery = _prevQuery = _nextQuery = refQuery;
    _prev = (QueryIterator*)0;
    _next = (QueryIterator*)0;
    _method = method;
    if (_last)
    {
        _last->_next = this;
        _prev = _last;
        _last = this;
    }
    else
        _first = _last = this;
}

DOConnection::QueryIterator::QueryIterator(
    const DOConnection& iterConnection,
    int (DOQuery::*method)() const,
    DOQuery* refQuery)
{
    assert(&iterConnection);

    _iterConnection = &iterConnection;
    _refQuery = _prevQuery = _nextQuery = refQuery;
    _prev = (QueryIterator*)0;
    _next = (QueryIterator*)0;
    _method = method;
    if (_last)
    {
        _last->_next = this;
        _prev = _last;
        _last = this;
    }
    else
        _first = _last = this;
}

DOConnection::QueryIterator::QueryIterator(
    const QueryIterator& iterator,
    int (DOQuery::*method)() const)
{
    _iterConnection = iterator._iterConnection;
    _refQuery = iterator._refQuery;
    _prevQuery = iterator._prevQuery;
    _nextQuery = iterator._nextQuery;
    _prev = (QueryIterator*)0;
    _next = (QueryIterator*)0;
    _method = method;
    if (_last)
    {
        _last->_next = this;
        _prev = _last;
        _last = this;
    }
    else
        _first = _last = this;
}

DOConnection::QueryIterator::~QueryIterator()
{
    if (_next)
        _next->_prev = _prev;
    else
        _last = _prev;

    if (_prev)
        _prev->_next = _next;
    else
        _first = _next;
}

void DOConnection::QueryIterator::Check(DOQuery* itemQuery)
{
    for (QueryIterator* item = _first; item; item = item->_next)
    {
        if (item->_prevQuery == itemQuery)
        {
            item->_prevQuery = item->_iterConnection->GetNextQuery(item->_prevQuery);
            item->_refQuery = 0;
        }
        if (item->_nextQuery == itemQuery)
        {
            item->_nextQuery = item->_iterConnection->GetPrevQuery(item->_nextQuery);
            item->_refQuery = 0;
        }
    }
}

void DOConnection::QueryIterator::Check(DOQuery* itemQuery, DOQuery* newItemQuery)
{
    for (QueryIterator* item = _first; item; item = item->_next)
    {
        if (item->_refQuery == itemQuery)
        {
            item->_refQuery = item->_prevQuery = item->_nextQuery = newItemQuery;
        }
        if (item->_prevQuery == itemQuery)
        {
            item->_prevQuery = newItemQuery;
            item->_refQuery = 0;
        }
        if (item->_nextQuery == itemQuery)
        {
            item->_nextQuery = newItemQuery;
            item->_refQuery = 0;
        }
    }
}

//}}AFX DO NOT EDIT CODE ABOVE THIS LINE !!!

//@START_USER3

---