---

vaarray.hpp

Go to the documentation of this file.

#if !defined(_VAARRAY_HPP)
#define _VAARRAY_HPP
//============================================================================= 
//
// XDFLengine library
//
//----------------------------------------------------------------------------- 
//  VAARRAY.HPP
//----------------------------------------------------------------------------- 
//_____________________________________________________________________________
//
//  Copyright (C) 2003 Guillaume Baurand. All Rights Reserved.
//
//  This file is part of the XDFLengine project.
//
//  The XDFLengine 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
//  USA.
//
//  For more information, 
//      contact  : guillaume@baurand.net 
//      or visit : http://xdflengine.sourceforge.net
//
//============================================================================= 

#   include "config/commonincs.hpp"



BEGIN_XDFLENGINE_NS

//============================================================================= 
template<class T_CLASS >
class XDFLENGINE_EXPORT VAelem
{
    public:
    T_CLASS             m_pObject;
    VAelem*             m_pBefore;
    VAelem*             m_pAfter;
    char*               m_pszKey;
} ;

//============================================================================= 





//============================================================================= 
//  CLASS VAARRAY
//----------------------------------------------------------------------------- 
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template<class T_CLASS >
class XDFLENGINE_EXPORT VAarray
{

    private: //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

        VAelem<T_CLASS >*               m_pFirstElem;
        VAelem<T_CLASS >*               m_pLastElem;
        VAelem<T_CLASS >*               m_pCurElem;
        //mutable   VAelem<T_CLASS >*       m_pRefElem;
        unsigned int                    m_uiSize;
        
        
    private: //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    //_________________________________________________________________________
    //  CREATEELEM
    //-------------------------------------------------------------------------
    
    VAelem<T_CLASS>* createElem( T_CLASS  p_pObject=0, const char* p_pszKey=0) const
    {
        //---------------------------------------------------------------------
        VAelem<T_CLASS>*    l_pElem=0;
        //---------------------------------------------------------------------

        l_pElem = new VAelem<T_CLASS>;
        l_pElem->m_pObject = p_pObject;
        l_pElem->m_pBefore = 0;
        l_pElem->m_pAfter = 0;
        l_pElem->m_pszKey = importCharBuffer( 0, p_pszKey);

        return l_pElem;     
    }

    //_________________________________________________________________________
    //  DELETEELEM
    //-------------------------------------------------------------------------
    
    void deleteElem( VAelem<T_CLASS>* p_pElem) const
    {
        p_pElem->m_pszKey = releaseCharBuffer( p_pElem->m_pszKey);
        delete p_pElem;
    }

    //_________________________________________________________________________
    //  DELETEELEM
    //-------------------------------------------------------------------------
    
    VAelem<T_CLASS>* removeElem( VAelem<T_CLASS>* p_pElem) 
    {
        //if( m_pRefElem == p_pElem) m_pRefElem=p_pElem->m_pAfter;
        if( m_pCurElem == p_pElem) m_pCurElem=p_pElem->m_pAfter;

        if( p_pElem->m_pBefore) p_pElem->m_pBefore->m_pAfter = p_pElem->m_pAfter;
        else m_pFirstElem = p_pElem->m_pAfter;

        if( p_pElem->m_pAfter) p_pElem->m_pAfter->m_pBefore = p_pElem->m_pBefore;
        else m_pLastElem = p_pElem->m_pBefore;

        m_uiSize--;

        p_pElem->m_pAfter=0;
        p_pElem->m_pBefore=0;

        return p_pElem;
    }

    //_________________________________________________________________________
    //  INSERTELEM
    //-------------------------------------------------------------------------
    
    void insertElem( VAelem<T_CLASS>* p_pElem, VAelem<T_CLASS>* p_pRefElem=0, bool p_fBefore=false)
    {
        if(!p_pRefElem) p_pRefElem = m_pLastElem;
        if(!p_pRefElem)
        {
            m_pLastElem = p_pElem;
            m_pFirstElem = p_pElem;
        }
        else
        {
            if( p_fBefore)
            {
                p_pElem->m_pBefore = 0;
                if( p_pRefElem->m_pBefore)
                {
                    p_pRefElem->m_pBefore->m_pAfter = p_pElem;
                    p_pElem->m_pBefore = p_pRefElem->m_pBefore;
                }
                else
                {
                    m_pFirstElem=p_pElem;
                }
                p_pRefElem->m_pBefore = p_pElem;
                p_pElem->m_pAfter = p_pRefElem;
            }
            else
            {
                p_pElem->m_pAfter = 0;
                if( p_pRefElem->m_pAfter)
                {
                    p_pRefElem->m_pAfter->m_pBefore=p_pElem;
                    p_pElem->m_pAfter=p_pRefElem->m_pAfter;
                }
                else
                {
                    m_pLastElem=p_pElem;
                }
                p_pRefElem->m_pAfter=p_pElem;
                p_pElem->m_pBefore = p_pRefElem;
            }
        }

        m_uiSize++;
    }  


    //_________________________________________________________________________
    //  GETELEM
    //-------------------------------------------------------------------------
    
    VAelem<T_CLASS>* getElem ( unsigned int p_uiIndex, VAelem<T_CLASS>* p_pRefElem=0) const
    {
        //---------------------------------------------------------------------
        unsigned int i;
        VAelem<T_CLASS>* p_pCurElem;
        //---------------------------------------------------------------------

        if( ! p_pRefElem ) p_pRefElem = m_pFirstElem;
        if( empty() ) return 0;
        if( p_uiIndex > m_uiSize-1 ) return 0;

        p_pCurElem = m_pFirstElem;
        for( i=0 ; i<p_uiIndex ; i++) p_pCurElem = p_pCurElem->m_pAfter;        
        return p_pCurElem;
    }

    //_________________________________________________________________________
    //  GETELEM
    //------------------------------------------------------------------------- 
    VAelem<T_CLASS>* getElem ( const char* p_pszKey, unsigned int p_uiIndex, VAelem<T_CLASS>* p_pRefElem=0) const
    {
        //---------------------------------------------------------------------
        unsigned int l_uiCurIndex;
        VAelem<T_CLASS>* l_pCurElem;
        //unsigned int l_uiItrts=0;
        //---------------------------------------------------------------------
        //if( ! m_pRefElem ) m_pRefElem = m_pFirstElem;
        if( ! p_pRefElem ) p_pRefElem = m_pFirstElem ; //m_pRefElem;
        if( empty() ) return 0;
        if( p_uiIndex > m_uiSize-1 ) return 0;

        l_pCurElem = p_pRefElem;
        l_uiCurIndex = p_uiIndex;
        while( true)
        {
            if( l_pCurElem->m_pszKey )
            {
                if ( strcmp( l_pCurElem->m_pszKey, p_pszKey)==0 ) 
                {
                    if( !l_uiCurIndex)
                    {
                        //m_pRefElem = l_pCurElem;
                        return l_pCurElem;
                    }
                    else l_uiCurIndex--;
                    //l_uiItrts=0;
                }
            }
            if(l_pCurElem->m_pAfter) l_pCurElem = l_pCurElem->m_pAfter; 
            else return 0; //l_pCurElem = m_pFirstElem;
            //l_uiItrts++;
            //if(l_uiItrts >= m_uiSize) return 0;
        }
    }

    //_________________________________________________________________________
    //  COUNTITEM
    //-------------------------------------------------------------------------
    unsigned int countElem(  const char* p_pszKey) const
    {
        //---------------------------------------------------------------------
        unsigned int l_uiCount=0;
        VAelem<T_CLASS>* l_pCurElem;
        //---------------------------------------------------------------------

        l_uiCount=0;
        l_pCurElem = m_pFirstElem; 
        while(true)
        {
            if(! l_pCurElem) return l_uiCount;
            if( strcmp( l_pCurElem->m_pszKey, p_pszKey) ==0 ) l_uiCount++;
            l_pCurElem = l_pCurElem->m_pAfter;
        }
    }


    public: //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


// constructor and destructor

    //_________________________________________________________________________
    //  CREATEELEM
    //-------------------------------------------------------------------------
    
    VAarray<T_CLASS>()
    {
        m_pFirstElem=0;
        m_pLastElem=0;
        m_uiSize=0;
        //m_pRefElem=0;
        //DEBUG_CREATE(VAarray)
    }

    //_________________________________________________________________________
    //  CREATEELEM
    //-------------------------------------------------------------------------
    
    ~VAarray<T_CLASS>()
    {
        //DEBUG_DEL(VAarray)
        flush();
    }


// LIFO stack related functions

    //_________________________________________________________________________
    //  CREATEELEM
    //-------------------------------------------------------------------------
    
    T_CLASS  top() const
    {
        if( m_pLastElem) return m_pLastElem->m_pObject;
        else return 0;
    }

    //_________________________________________________________________________
    //  CREATEELEM
    //-------------------------------------------------------------------------
    
    T_CLASS  bottom() const
    {
        if( m_pFirstElem) return m_pFirstElem->m_pObject;
        else return 0;
    }
        
    //_________________________________________________________________________
    //  CREATEELEM
    //-------------------------------------------------------------------------
    
    T_CLASS  pop()
    {
        //---------------------------------------------------------------------
        T_CLASS  l_pRetObject=0;
        //---------------------------------------------------------------------

        if( m_pLastElem)
        {
            l_pRetObject = m_pLastElem->m_pObject;
            deleteElem( removeElem( m_pLastElem));
        }
        return l_pRetObject;
    }

    //_________________________________________________________________________
    //  CREATEELEM
    //-------------------------------------------------------------------------
    
    void push( T_CLASS  p_pObject)
    {
        insertElem( createElem( p_pObject));
    }

    //_________________________________________________________________________
    //  CREATEELEM
    //-------------------------------------------------------------------------
    
    bool empty() const
    {
        if(m_uiSize==0) return true;
        else return false;

    }


// FIFO queue related function

    //_________________________________________________________________________
    //  FIRST
    //-------------------------------------------------------------------------
    
    T_CLASS  first() const
    {
        return top();
    }

    //_________________________________________________________________________
    //  LAST
    //-------------------------------------------------------------------------
    
    T_CLASS  last() const
    {
        return bottom();
    }

    //_________________________________________________________________________
    //  ENQUEUE
    //-------------------------------------------------------------------------
    
    void enqueue( T_CLASS  p_pObject)
    {
        insertElem( createElem( p_pObject), m_pFirstElem, true);
    }

    //_________________________________________________________________________
    //  DEQUEUE
    //-------------------------------------------------------------------------
    
    T_CLASS  dequeue()
    {
        return pop();
    }


// vector related functions

    //_________________________________________________________________________
    //  SIZE
    //-------------------------------------------------------------------------
    
    unsigned int size() const
    {
        return m_uiSize;
    }

    //_________________________________________________________________________
    //  GET
    //-------------------------------------------------------------------------
    
    T_CLASS  get( unsigned int p_uiIndex) const
    {
        //---------------------------------------------------------------------
        VAelem<T_CLASS>* l_pElem = 0;
        //---------------------------------------------------------------------

        l_pElem=getElem( p_uiIndex);
        if(l_pElem) return l_pElem->m_pObject;
        return 0;
    }

    //_________________________________________________________________________
    //  INSERT
    //-------------------------------------------------------------------------
    
    void insert( T_CLASS  p_pObject, unsigned int p_uiIndex, bool p_fBefore)
    {
        //---------------------------------------------------------------------
        VAelem<T_CLASS>* l_pElem = 0;
        //---------------------------------------------------------------------

        insertElem( createElem( p_pObject), getElem( p_uiIndex), p_fBefore);
    }

    //_________________________________________________________________________
    //  REMOVE
    //-------------------------------------------------------------------------
    
    T_CLASS  remove( unsigned int p_uiIndex)
    {
        //---------------------------------------------------------------------
        VAelem<T_CLASS>*        l_pElem = 0;
        T_CLASS     l_pObject = 0;
        //---------------------------------------------------------------------

        l_pElem = getElem( p_uiIndex);
        if(l_pElem)
        {
            l_pObject = l_pElem->m_pObject;
            deleteElem( removeElem( l_pElem));
        }
        return l_pObject;
    }


// map related functions

    //_________________________________________________________________________
    //  GET
    //-------------------------------------------------------------------------
    
    T_CLASS  get( const char*   p_pszKey, unsigned int p_uiIndex=0) const
    {
        //---------------------------------------------------------------------
        VAelem<T_CLASS>*        l_pElem = 0;
        //---------------------------------------------------------------------

        l_pElem = getElem( p_pszKey, p_uiIndex);
        if( l_pElem) return l_pElem->m_pObject;
        else return 0;
    }

    //_________________________________________________________________________
    //  ADD
    //-------------------------------------------------------------------------
    
    void add( T_CLASS  p_pObject, const char*   p_pszKey)
    {
        insertElem( createElem( p_pObject, p_pszKey));
    }

    //_________________________________________________________________________
    //  REMOVE
    //-------------------------------------------------------------------------
    
    T_CLASS  remove( const char*    p_pszKey, unsigned int p_uiIndex=0)
    {
        //---------------------------------------------------------------------
        VAelem<T_CLASS>*        l_pElem = 0;
        T_CLASS     l_pObject = 0;
        //---------------------------------------------------------------------

        l_pElem = getElem( p_pszKey, p_uiIndex);
        if( l_pElem)
        {
            l_pObject = l_pElem->m_pObject;
            deleteElem( removeElem( l_pElem));
        }
        return l_pObject;
    }

// sequence


    //_________________________________________________________________________
    //  moveFirst
    //-------------------------------------------------------------------------
    void moveFirst()
    {
        m_pCurElem=m_pFirstElem;
    }


    //_________________________________________________________________________
    //  moveLast
    //-------------------------------------------------------------------------
    void moveLast()
    {
        m_pCurElem=m_pLastElem;
    }


    //_________________________________________________________________________
    //  moveNext
    //-------------------------------------------------------------------------
    void moveNext()
    {
        if(m_pCurElem) m_pCurElem = m_pCurElem->m_pAfter;
    }


    //_________________________________________________________________________
    //  movePrevious
    //-------------------------------------------------------------------------
    void movePrevious()
    {
        if(m_pCurElem)  m_pCurElem = m_pCurElem->m_pBefore;
    }


    //_________________________________________________________________________
    //  current
    //-------------------------------------------------------------------------
    T_CLASS current()
    {
        if(m_pCurElem) return m_pCurElem->m_pObject;
        else return 0;
    }


// keys management

    //_________________________________________________________________________
    //  GETKEY
    //-------------------------------------------------------------------------
    
    const char* getKey( unsigned int p_uiIndex) const
    {
        //---------------------------------------------------------------------
        VAelem<T_CLASS>*        l_pElem = 0;
        //---------------------------------------------------------------------

        l_pElem = getElem( p_uiIndex);
        if( l_pElem) return exportCharBuffer(l_pElem->m_pszKey);
        else return 0;
    }

    //_________________________________________________________________________
    //  SETKEY
    //-------------------------------------------------------------------------
    
    void setKey( unsigned int p_uiIndex, const char* p_pszNewKey)
    {
        //---------------------------------------------------------------------
        VAelem<T_CLASS>*        l_pElem = 0;
        //---------------------------------------------------------------------

        l_pElem = getElem( p_uiIndex);
        if( l_pElem)
        {
            importCharBuffer(l_pElem->m_pszKey, p_pszNewKey);;
        }
    }

    //_________________________________________________________________________
    //  count
    //-------------------------------------------------------------------------
    unsigned int count( const char* p_pszKey) const
    {
        return countElem( p_pszKey);
    }

// flush

    //_________________________________________________________________________
    //  FLUSH
    //-------------------------------------------------------------------------
    
    void flush()
    {
        while(!empty()) deleteElem( removeElem( m_pLastElem));
    }


    //_____________________________________________________________________
    //  IMPORTCHARBUFFER
    //--------------------------------------------------------------------- 
    char* importCharBuffer( char* p_pszOldBuffer,const char* p_pszNewBuffer) const
    {
        char* l_pszBuffer;

        if( p_pszOldBuffer) 
        {
            if( strlen( p_pszOldBuffer) >= strlen( p_pszNewBuffer) )
            {
                strcpy( p_pszOldBuffer, p_pszNewBuffer);
                l_pszBuffer = p_pszOldBuffer;
            }
            else
            {
                l_pszBuffer = (char*) realloc( p_pszOldBuffer, strlen(p_pszNewBuffer)+1);
                strcpy( l_pszBuffer, p_pszNewBuffer);
            }
        }
        else
        {
            if(p_pszNewBuffer)
            {
                l_pszBuffer = (char*) malloc( strlen(p_pszNewBuffer)+1);
                strcpy( l_pszBuffer, p_pszNewBuffer);
            }
            else l_pszBuffer = 0;
        }

        return l_pszBuffer;
    }


};
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//=============================================================================




END_XDFLENGINE_NS

#endif

---