---

FBwLst.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
#ifndef FBwLSTH
#define FBwLSTH

//---------------------------------------------------------------------------
namespace fbwrap
{
using std::string;

template <class TNode > class SimListNode
{
    SimListNode *Next;
    bool mmanage;
    string name;
public:
    TNode *node;
    SimListNode(string pName,TNode *p,bool managed=true)
    {
        node=p;
        Next=NULL;
        mmanage=managed;
        name=pName;
    }
    //SimListNode<TNode>(string pName,TNode &p)
    //{
        //node=&p;
        //Next=NULL;
        //mmanage=false;
        //name=pName;
    //}
    SimListNode(string pName, const TNode &p)
    {
        node=new TNode(p);
        Next=NULL;
        mmanage=true;
        name=pName;
    }
    SimListNode *GetNext() const
    {
        return Next;
    }
    void SetNext(SimListNode *pNext)
    {
        Next=pNext;
    }
    string Name()
    {
        return name;
    }
    ~SimListNode()
    {
        if( node && mmanage)
        {
            delete node;
        }
    }
    SimListNode *operator++()
    {
        return Next;
    }
};

template <class TNode>
class SimListIterator
{
    SimListNode<TNode> *n;
public:
    SimListIterator()
    {
        n=NULL;
    }
    SimListIterator(SimListNode<TNode> *p)
    {
        n=p;
    }
    SimListIterator(const SimListIterator &p)
    {
        n=p.n;
    }
    SimListIterator &operator=(const SimListIterator &p)
    {
        n=p.n;
        return *this;
    }
    TNode *operator++()
    {
        if( n )
            n=n->GetNext();
        return n->node;
    }
    TNode  *operator++(int)
    {
        SimListNode<TNode> *p=n;
        if( n )
            n=n->GetNext();
        return p->node;
    }
    int operator==(const SimListIterator &p) const
    {
        return n==p.n;
    }
    int operator!=(const SimListIterator &p) const
    {
        return n!=p.n;
    }
    TNode &operator*()
    {
        return *(n->node);
    }
    string Name() const
    {
        return n->Name();
    }
};

template <class TNode> class SimList
{
    SimListNode<TNode> *Raiz;
    SimListNode<TNode> *Final;
    int count;

protected:
    int AppendNode(SimListNode<TNode> *x)
    {
        if( Raiz==NULL)
        {
            Raiz=Final=x;
        }
        else
        {
            Final->SetNext(x);
            Final=x;
        }
        return count++;
    }

public:
    typedef SimListIterator<TNode> Iterator;
    typedef SimListNode<TNode> node_type;
    SimList()
    {
        Raiz=Final=NULL;
        count=0;
    }
    int Append(string name,TNode *node)
    {
        if( Find(name) != NULL )
            return -1;
        node_type *x = new node_type(name,node);
        return AppendNode(x);
    }
    int Append(string name,node_type *node)
    {
        return AppendNode(node);
    }
    //int Append(string name,TNode &node)
    //{
        //if( Find(name) != NULL )
            //return -1;
        //SimListNode<TNode> *x = new SimListNode<TNode>(name,node);
    //}
    int Append(string name,const TNode &node)
    {
        if( Find(name) != NULL )
            return -1;
        node_type *x = new node_type(name,node);
        return AppendNode(x);
    }
    TNode *Find(int idx) const
    {
        SimListNode<TNode> *x;
        int i=0;
        for(x=Raiz;x!=NULL;x=x->GetNext(),i++)
        {
            if( i==idx )
                return x->node;
        }
        return NULL;
    }
    TNode *Find(const string pNam) const
    {
        node_type *x;
        for(x=Raiz; x!=NULL; x=x->GetNext())
        {
            if( x->Name()==pNam )
                return x->node;
        }
        return NULL;
    }
    TNode *operator[](const string pNam) const
    {
        return Find(pNam);
    }
    TNode *operator[](int idx) const
    {
        return Find(idx);
    }
    void Destroy()
    {
        while(Raiz != NULL)
        {
            Final=Raiz->GetNext();
            delete Raiz;
            Raiz=Final;
        }
        Raiz=Final=NULL;
        count=0;
    }
    int Count() const
    {
        return count;
    }
    ~SimList()
    {
        Destroy();
    }
    Iterator begin() const
    {
        return Iterator(Raiz);
    }
    Iterator end() const
    {
        return Iterator();
    }
    void Copy(const Iterator &b, const Iterator &e)
    {
        Destroy();
        for(Iterator i=b; i!=e; i++)
        {
            Append(i.Name(),*i);
        }
    }
    void Copy(const SimList &sl)
    {
        Destroy();
        for(Iterator i=sl.begin(); i!=sl.end(); i++)
        {
            Append(i.Name(),*i);
        }
    }
};


//-------------------------------------------------------------------------
};
#endif

---