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

Go to the documentation of this file.

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

   Base abstract class for generic collection iterators.
   -------------------------------------------------------------------
   Author: Giancarlo Niccolai
   Begin: Sat, 01 Aug 2009 23:24:09 +0200

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

   See LICENSE file for licensing details.
*/

#ifndef flc_iterator_H
#define flc_iterator_H

#include <falcon/setup.h>
#include <falcon/types.h>
#include <falcon/falcondata.h>
#include <falcon/sequence.h>
#include <falcon/fassert.h>

namespace Falcon {
class Sequence;
class CoreTable;
class Garbageable;
class Item;

class FALCON_DYN_CLASS Iterator: public FalconData
{

public:
   typedef void(*t_deletor_func)(Iterator*);

private:
   Sequence* m_owner;

   typedef union t_position_holder {
      int64 pos;
      void* ptr;
   } u_idata;

   u_idata m_idata;

   t_deletor_func m_deletor;
   Iterator* m_next;

public:
   Iterator( Sequence* owner, bool tail = false ):
      m_owner( owner ),
      m_deletor(0),
      m_next(0)
   {
      m_idata.ptr = 0;
      owner->getIterator( *this, tail );
   }

   Iterator( const Iterator& other ):
      m_owner( other.m_owner ),
      m_deletor( other.m_deletor ),
      m_next(0)
   {
      m_idata.ptr = 0;
      m_owner->copyIterator( *this, other );
   }


public:
   virtual ~Iterator();
   virtual void gcMark( uint32 mark );
   virtual FalconData *clone() const;

   void deletor( t_deletor_func f ) { m_deletor = f; }
   t_deletor_func deletor() const { return m_deletor; }
   inline bool next() {
      fassert( m_owner != 0 );
      return m_owner->next( *this );
   }

   inline bool prev() {
      fassert( m_owner != 0 );
      return m_owner->prev( *this );
   }

   inline bool hasNext() const {
      return m_owner != 0 && m_owner->hasNext( *this );
   }

   inline bool hasPrev() const {
      return m_owner != 0 && m_owner->hasPrev( *this );
   }

   inline bool hasCurrent() const {
      return m_owner != 0 && m_owner->hasCurrent( *this );
   }

   inline Item &getCurrent() const {
      fassert( m_owner != 0 );
      return m_owner->getCurrent( *this );
   }

   inline Item &getCurrentKey() const {
      fassert( m_owner != 0 );
      return m_owner->getCurrentKey( *this );
   }

   inline bool isValid() const { return m_owner != 0; }
   inline bool isOwner( void *collection ) const { return collection == static_cast<void*>(m_owner); }

   inline bool equal( const Iterator &other ) const {
      fassert( m_owner != 0 );
      return m_owner == other.m_owner && m_owner->equalIterator( *this, other );
   }

   inline void erase() {
      fassert( m_owner != 0 );
      m_owner->erase( *this );
   }

   inline void insert( const Item &item ) {
      fassert( m_owner != 0 );
      m_owner->insert( *this, item );
   }

   void invalidate() { m_owner = 0; }

   Sequence* sequence() const { return m_owner; }

   void sequence( Sequence* s ) { m_owner = s; }

   void *data() const { return m_idata.ptr; }
   void data( void* dt ) { m_idata.ptr = dt; }

   int64 position() const { return m_idata.pos; }
   void position( int64 pos ) { m_idata.pos = pos; }
   
   Iterator* nextIter() const { return m_next; }
   void nextIter( Iterator* n ) { m_next = n; }
};

}

#endif /* ITERATOR_H_ */

---