RegistryManagerSet.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 */
#ifndef __REGISTRYMANAGERSET_H__
#define __REGISTRYMANAGERSET_H__
#include "RNPlatform/Inc/DLLExportAPI.h"

#include <assert.h>

#include <set>

namespace RNReplicaNet
{

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

    RegistryManagerSet()
    {
        mDirection = kUndefined;
    }

    virtual ~RegistryManagerSet()
    {
    }

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

    void RemoveItem(T *item)
    {
        typename std::set<T *,C>::iterator found = mItems.find(item);

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

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

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

        typename std::set<T *,C>::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 && "RegistryManagerSet::Iterate() used when BeginIterate() or EndIterate() not used or Iterate() reached the ned 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::set<T *,C> mItems;         
    typename std::set<T *,C>::iterator st;  
    Direction mDirection;
};

} // namespace RNReplicaNet

#endif

---