clinkedlist.h

//==========================================================================
//  CLINKEDLIST.H - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//  Declaration of the following classes:
//    cLinkedList        : linked list of pointers (cQueue-like interface)
//
//==========================================================================

/*--------------------------------------------------------------*
  Copyright (C) 1992-2008 Andras Varga
  Copyright (C) 2006-2008 OpenSim Ltd.

  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/

#ifndef __CLINKEDLIST_H
#define __CLINKEDLIST_H

#include "cownedobject.h"

NAMESPACE_BEGIN

#ifdef _MSC_VER
#pragma warning(push, 0)  // deprecation warnings inside the header
#endif

#if defined __GNUC__ && __GNUC__ == 4 && __GNUC_MINOR__ >= 3
// gcc-4.3.1 is broken: it insists on spitting out deprecation warnings for
// cLinkedList::Iterator when this header gets included anywhere, and
// cannot be convinced otherwise. #pragma GCC diagnostic does not work.
// So we better forget deprecation with that compiler.
#define CLINKEDLIST_DEPRECATED
#else
#define CLINKEDLIST_DEPRECATED  _OPPDEPRECATED
#endif

class SIM_API CLINKEDLIST_DEPRECATED cLinkedList : public cOwnedObject
{
    // a list elem
    struct Elem
    {
        void *item;
        Elem *prev, *next;
    };

  public:

    class CLINKEDLIST_DEPRECATED Iterator
    {
      private:
        Elem *p;

      public:
        Iterator(const cLinkedList& q, bool athead=true)
                {p = athead ? q.headp : q.tailp;}

        void init(const cLinkedList& q, bool athead=true)
                {p = athead ? q.headp : q.tailp;}

        void *operator()() const  {return p->item;}

        bool end() const   {return (bool)(p==NULL);}

        void *operator++(int)  {if (!p) return NULL; Elem *t=p; p=p->next; return t->item;}

        void *operator--(int)  {if (!p) return NULL; Elem *t=p; p=p->prev; return t->item;}
    };

    friend class Iterator;

  private:
    Elem *headp, *tailp;      // inserting at head, removal at tail
    int n;                    // number of items in list

    VoidDelFunc delfunc;      // user func to free up item (NULL-->delete)
    VoidDupFunc dupfunc;      // user func to dupl. item (NULL-->new+memcpy)
    size_t itemsize;          // used in making shallow copy if dupfunc==0
                              // if both dupfunc and itemsize are 0, we do
                              // no memory management (we treat pointers as
                              // mere pointers)

  private:
    void copy(const cLinkedList& other);

  protected:
    // internal use.
    // if both dupfunc and itemsize are 0, we do no memory management
    // (we treat pointers as mere pointers)
    Elem *find_llelem(void *item) const;

    // internal use
    void insbefore_llelem(Elem *p, void *item);

    // internal use
    void insafter_llelem(Elem *p, void *item);

    // internal use
    void *remove_llelem(Elem *p);

  public:

    cLinkedList(const cLinkedList& llist);

    explicit cLinkedList(const char *name=NULL);

    virtual ~cLinkedList();

    cLinkedList& operator=(const cLinkedList& queue);


    virtual cLinkedList *dup() const  {return new cLinkedList(*this);}

    virtual std::string info() const;

    virtual void parsimPack(cCommBuffer *buffer);

    virtual void parsimUnpack(cCommBuffer *buffer);


    void config( VoidDelFunc _delfunc, VoidDupFunc _dupfunc, size_t _itemsize=0);

    void insert(void *item);

    void insertBefore(void *where, void *item);

    void insertAfter(void *where, void *item);

    void *head() const  {return n!=0 ? headp->item : NULL;}

    void *tail() const  {return n!=0 ? tailp->item : NULL;}

    void *remove(void *item);

    void *pop();

    int getLength() const {return n;}

    bool isEmpty() const {return n==0;}

    int length() const {return getLength();}

    bool empty() const {return isEmpty();}

    bool contains(void *item) const  {return find_llelem(item)!=NULL;}

    void clear();
};

#ifdef _MSC_VER
#pragma warning(pop)
#endif


NAMESPACE_END


#endif