/home/gian/Progetti/falcon/core/include/falcon/itemlist.h

Go to the documentation of this file.

/*
   FALCON - The Falcon Programming Language.
   FILE: itemlist.h

   List of Falcon Items
   -------------------------------------------------------------------
   Author: Giancarlo Niccolai
   Begin: 2007-12-01

   -------------------------------------------------------------------
   (C) Copyright 2007: the FALCON developers (see list in AUTHORS file)

   See LICENSE file for licensing details.
*/

#ifndef flc_itemlist_H
#define flc_itemlist_H

#include <falcon/setup.h>
#include <falcon/basealloc.h>
#include <falcon/falcondata.h>
#include <falcon/sequence.h>
#include <falcon/item.h>
#include <falcon/iterator.h>
#include <falcon/mt.h>

namespace Falcon {

class ItemListElement;
class ItemList;
class Iterator;

class FALCON_DYN_CLASS ItemListElement: public BaseAlloc
{
   Item m_item;

   ItemListElement *m_next;
   ItemListElement *m_prev;


public:

   ItemListElement( const Item &itm, ItemListElement *p = 0, ItemListElement *n = 0 ):
      m_item( itm ),
      m_next( n ),
      m_prev( p )
   {}

  ~ItemListElement()
  {
  }

   const Item &item() const { return m_item; }
   Item &item() { return m_item; }

   void next( ItemListElement *n ) { m_next = n; }
   ItemListElement *next() const { return m_next; }

   void prev( ItemListElement *p ) { m_prev = p; }
   ItemListElement *prev() const { return m_prev; }
};


class FALCON_DYN_CLASS ItemList: public Sequence
{
private:
   uint32 m_size;
   ItemListElement *m_head;
   ItemListElement *m_tail;

   // temporary variable using during iter-erase
   Iterator* m_erasingIter;
   ItemListElement* m_disposingElem;

public:
   ItemList():
      m_size(0),
      m_head(0),
      m_tail(0),
      m_erasingIter(0),
      m_disposingElem(0)
   {}

   ItemList( const ItemList &l );

   virtual ~ItemList()
   {
      clear();
   }

   virtual FalconData *clone() const;

   virtual const Item &front() const;

   virtual const Item &back() const;

   ItemListElement *first() const;

   ItemListElement *last() const;

   virtual void append( const Item& itm ) { push_back( itm ); }
   virtual void prepend( const Item& itm ) { push_front( itm ); }

   void push_back( const Item &itm );

   void pop_back();

   void push_front( const Item &itm );

   void pop_front();

   virtual void clear();

   ItemListElement *erase( ItemListElement *elem );


   void insert( ItemListElement *elem, const Item &item );


   virtual bool empty() const { return m_size == 0; }

   uint32 size() const { return m_size; }

   virtual void gcMark( uint32 mark );

   // Deletion criterion.
   virtual bool onCriterion( Iterator* elem ) const;

   //========================================================
   // Iterator implementation.
   //========================================================
protected:

   virtual void getIterator( Iterator& tgt, bool tail = false ) const;
   virtual void copyIterator( Iterator& tgt, const Iterator& source ) const;

   virtual void insert( Iterator &iter, const Item &data );
   virtual void erase( Iterator &iter );
   virtual bool hasNext( const Iterator &iter ) const;
   virtual bool hasPrev( const Iterator &iter ) const;
   virtual bool hasCurrent( const Iterator &iter ) const;
   virtual bool next( Iterator &iter ) const;
   virtual bool prev( Iterator &iter ) const;
   virtual Item& getCurrent( const Iterator &iter );
   virtual Item& getCurrentKey( const Iterator &iter );
   virtual bool equalIterator( const Iterator &first, const Iterator &second ) const;
};


}

#endif

/* end of itemlist.h */

---