RegistryManagerMap.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 __REGISTRYMANAGERMAP_H__
#define __REGISTRYMANAGERMAP_H__

#include <assert.h>

#include <map>

namespace RNReplicaNet
{

template <class I,class T,class C=std::less<I> > class RegistryManagerMap
{
public:
    enum Direction
    {
        kForward=0,
        kBackward,
        kUndefined
    };

    RegistryManagerMap()
    {
        mDirection = kUndefined;
        st = mItems.end();
    }

    virtual ~RegistryManagerMap()
    {
    }

    bool AddItem(const I &index,const T *item)
    {
        typedef typename std::map<I,T*,C>::iterator theIter;
        typename std::pair<theIter,bool> aMapResult;
        aMapResult = mItems.insert(std::pair<I,T*>(index,(T*)item));
        return aMapResult.second;
    }

    T* FindItem(const I &index)
    {
        typename std::map<I,T*,C>::iterator found;

        found = mItems.find(index);

        if (found != mItems.end())
        {
            st = found;
            mDirection = kUndefined;
            return (*found).second;
        }
        return 0;
    }

    T* FindItemNoIterator(const I &index)
    {
        typename std::map<I,T*,C>::iterator found;

        found = mItems.find(index);

        if (found != mItems.end())
        {
            return (*found).second;
        }
        return 0;
    }

    bool RemoveItem(const I &index)
    {
        typename std::map<I,T*,C>::iterator found;

        found = mItems.find(index);

        if (found != mItems.end())
        {
            if (mDirection != kUndefined)
            {
                if (found == st)
                {
                    if (mDirection == kForward)
                    {
                        st++;
                        mItems.erase(found);
                        return true;
                    }

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

    void RemoveItem(void)
    {
        switch(mDirection)
        {
            default:
            {
                assert(false && "Undefined direction state");
                break;
            }

            case kUndefined:
            {
                // No direction so it was probably a find so remove the iterator where it is at.
                mItems.erase(st);
                st = mItems.end();
                break;
            }

            case kForward:
            {
                typename std::map<I,T*,C>::iterator tst;
                st--;
                tst = st;
                st++;
                mItems.erase(tst);
                break;
            }

            case kBackward:
            {
                typename std::map<I,T*,C>::iterator tst;
                tst = st;
                st++;
                mItems.erase(tst);
                break;
            }
        }
    }

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

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

    T *Iterate(I *index = 0)
    {
        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).second;
                if (index)
                {
                    *index = (*st).first;
                }
                st++;
                return tclass;
            }
        }

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

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

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

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

    void Clear(void)
    {
        mItems.clear();
        st = mItems.end();
    }

private:

    std::map<I,T*,C> mItems;                    
    typename std::map<I,T*,C>::iterator st;     
    Direction mDirection;
};

} // namespace RNReplicaNet

#endif