RegistryManagerList.h

/* START_LICENSE_HEADER

Copyright (C) 2000 Martin Piper, original design and program code
Copyright (C) 2001 Replica Software

This program file is copyright (C) Replica Software and can only be used under license.
For more information visit: http://www.replicanet.com/
Or email: info@replicanet.com

END_LICENSE_HEADER */
#include "RNPlatform/Inc/MemoryTracking.h"
#ifndef __REGISTRYMANAGERLIST_H__
#define __REGISTRYMANAGERLIST_H__

#include <assert.h>

#include <list>

namespace RNReplicaNet
{

template <class T> class RegistryManagerList
{
public:
    enum Direction
    {
        kForward=0,
        kBackward,
        kUndefined
    };

    RegistryManagerList()
    {
        mDirection = kUndefined;
    }

    virtual ~RegistryManagerList()
    {
    }

    void AddItem(T *item)
    {
        mItems.push_back(item);
    }

    void AddItemHead(T *item)
    {
        mItems.push_front(item);
    }

    void RemoveItem(T *item)
    {
        typename std::list<T *>::iterator tst,ten;

        tst = mItems.begin();
        ten = mItems.end();

        while(tst != ten)
        {
            T *titem = *tst;
            if (titem == item)
            {
                if (mDirection != kUndefined)
                {
                    if (tst == st)
                    {
                        if (mDirection == kForward)
                        {
                            st++;
                            mItems.erase(tst);
                            return;
                        }

                        if (mDirection == kBackward)
                        {
                            st--;
                            mItems.erase(tst);
                            st++;
                            return;
                        }
                    }
                }
                mItems.erase(tst);
                return;
            }
            tst++;
        }
    }

    void RemoveItem(void)
    {
        assert(mDirection != kUndefined && "RegistryManagerList::RemoveItem() used when BeginIterate() or EndIterate() not used or Iterate() reached the ned of the list");

        typename std::list<T *>::iterator tst;

        if (mDirection == kForward)
        {
            st--;
            tst = st;
            st++;
            mItems.erase(tst);
            return;
        }

        if (mDirection == kBackward)
        {
            tst = st;
            st++;
            mItems.erase(tst);
        }
    }

    void BeginIterate(void)
    {
        mDirection = kForward;
        st = mItems.begin();
    }

    void EndIterate(void)
    {
        mDirection = kBackward;
        st = mItems.end();
    }

    T *Iterate(void)
    {
        assert(mDirection != kUndefined && "RegistryManagerList::Iterate() used when BeginIterate() or EndIterate() not used or Iterate() reached the end of the list");

        if (mDirection == kForward)
        {
            if (st != mItems.end())
            {
                T *tclass = *st;
                st++;
                return tclass;
            }
        }

        if (mDirection == kBackward)
        {
            if (st != mItems.begin())
            {
                st--;
                T *tclass = *st;
                return tclass;
            }
        }

#ifdef _DEBUG
        mDirection = kUndefined;
#endif
        return 0;
    }

    bool IsEmpty(void) const
    {
        return mItems.empty();
    }

private:

    std::list<T *> mItems;          
    typename std::list<T *>::iterator st;   
    Direction mDirection;
};

} // namespace RNReplicaNet

#endif