---

t_algo.h

Go to the documentation of this file.

/* liblookdb: t_algo.h - cut down std::algorithm equivalent 
    Copyright (C) 1998-2001 LOOK Systems

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

    This library 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
#ifndef LIBLOOKDB_T_ALGO_H
#define LIBLOOKDB_T_ALGO_H

// $Id: t_algo.h,v 1.8 2001/07/04 15:53:22 clive Exp $

// pick up compiler specifics
#include "lookcompileropts.h"

namespace look {

template<class tIter, class tBody> inline
tIter LookTLfind(tIter first, tIter last, const tBody& val)
{
        for (; first != last; ++first)
        {
                if( *first == val )
                {
                        break;
                }
        }
        return first;
}


template<class tIter, class tBody> inline
tIter LookTLfindByPtr(tIter first, tIter last, const tBody* val)
{
        for (; first != last; ++first)
        {
                if( *first != NULL && (val == *first || **first == *val) )
                {
                        break;
                }
        }
        return first;
}


template<class tList, class tBody> inline
void LookTLremoveMatching(tList& theList, const tBody& val)
{
        typename tList::iterator anIter = theList.begin();

        while( anIter != theList.end() )
        {
                if( *anIter == val )
                {
                        // hoorah! erase returns the next iterator, ie == iter++
                        anIter = theList.erase( anIter );
                }
                else
                {
                        anIter++;
                }
        }
}


template<class containerClass> inline
void ClearAndDestroy( containerClass& aContainer )
{
// the container must contain pointers
        typename containerClass::iterator anIter;

        for( anIter = aContainer.begin();
                anIter != aContainer.end();
                anIter++ )
        {
                delete *anIter;
        }
        aContainer.clear();
}

// if you use this, the class must have GetNewCopy defined
// CThing* GetNewCopy( void )
// {
//    return new CThing( *this );
// }


template<class containerClass> inline
void CopyAsNew( containerClass& theToContainer,
        const containerClass& theFromContainer )
{
// the container must contain pointers
        typename containerClass::const_iterator anIter;

        for( anIter = theFromContainer.begin();
                anIter != theFromContainer.end();
                anIter++ )
        {
                typename containerClass::value_type anItem = (*anIter)->GetNewCopy();
                theToContainer.push_back( anItem );
        }
}

// index : like find except return position.
// return -1 for not found

template<class tList, class tBody> inline
int LookTLindex(tList& aList, const tBody& val)
{
        int end = aList.size();
        for( int loop = 0; loop < end; loop++ )
        {
                if( aList.at( loop ) == val )
                {
                        return loop;
                }
        }
        return -1;
}


template<class tList, class tBody> inline
int LookTLindexByPtr(tList& aList, const tBody* val)
{
        int end = aList.size();
        for( int loop = 0; loop < end; loop++ )
        {
                tBody* test = aList.at( loop );
                if( test != NULL && ( val == test || *val == *test ) )
                {
                        return loop;
                }
        }
        return -1;
}

// lists equal - are two lists identical?

template<class tList> inline
bool LookTLlistsEqual(const tList& aList, const tList& bList)
{
        if( aList.size() != bList.size() )
        {
                return false;
        }

        typename tList::const_iterator aIter = aList.begin();
        typename tList::const_iterator bIter = bList.begin();

        for( ; aIter != aList.end(); aIter++, bIter++ )
        {
                if( *aIter != *bIter )
                {
                        return false;
                }
        }

        return true;
}


} // end of "look" namespace
#endif

---