#ifndef VLCINDEXITER_HEADER
#define VLCINDEXITER_HEADER 1
////////////////////////////////////////////////////////////////////////////
//! file="amma/Logic/Index/LCIndexIter.hh"
//! lib=VLIndex
//! author="Charles Galambos"
//! docentry="Logic.Index"
//! date="14/5/96"
//! rcsid="$Id: LCIndexIter.hh,v 1.17 2000/07/13 09:56:28 ees1cg Exp $"

#include "amma/Logic2/LSymbIter.hh"
#include "amma/Logic2/LIndex.hh"
#include "amma/HashIter.hh"

//#include "amma/Logic2/LCIndIterBase.hh"
#define CINDITERDEBUG 0

///////////////////////////////////////////////
//! userlevel=Develop
//: VLCIndex iterator.

class VLCIndexIter 
  : public VLSymbIter 
{
public:
  inline VLCIndexIter(const VLCIndexIter &ind);
  //: Copy constructor.
  
  inline VLCIndexIter(const VLCIndex &ind);
  //: Construct from an Index.

  inline VLCIndexIter(const VLIndexBaseC &ind);
  //: Construct from an Index.
  
#if CINDITERDEBUG
  virtual BooleanT First(void);
  virtual BooleanT Next(void);
#else
  virtual BooleanT First(void) { return iter.First(); }
  virtual BooleanT Next(void) { return iter.Next(); }  
#endif
  
  virtual VLSymbC &SymbData(void);
  //: Get data as symbol.
  
  inline RCWrapBaseC &Data(void);
  //: Get User data.
  
  inline const RCWrapBaseC &Data(void) const;
  //: Get User data.

  const VLSymbC &Key(void) const;
  //: Access key.
  
  inline virtual BooleanT IsElm(void) const;
  //: Is Element ?
  
  virtual void Dump(void);
  //: Dump to stdout.
  
protected:
  HashIterC<VLSymbC,VLCIndex::SymbBnd> iter;
};

/////////////////////////////////////////////
//! userlevel=Develop
//: VLCIndex iterator.

template<class T>
class VLIndexIter 
  : public VLCIndexIter 
{
public:
  inline VLIndexIter(const VLIndex<T> &ind) 
    : VLCIndexIter(ind) 
  {}
  //: Constructor.
  
  inline VLIndexIter(const VLIndexIter<T> &oth) 
    : VLCIndexIter(oth) 
  {}
  //: Copy constructor.
  
  // VLSymb &SymbData(void) { return *(STATIC_CAST(VLSymb *,(Iter.Data()).Val)); }
  inline T &Data(void) { return *(static_cast<T *>(&VLCIndexIter::Data())); }
  //: Access data.
};

/////////////////////////////////////////

inline 
VLCIndexIter::VLCIndexIter(const VLCIndexIter &ind)  
  : VLSymbIter(ind),
    iter(ind.iter)
{}

inline 
VLCIndexIter::VLCIndexIter(const VLCIndex &ind)
  : iter(ind.symbs)
{}

inline 
VLCIndexIter::VLCIndexIter(const VLIndexBaseC &ind)
  : iter(ind.Body().symbs)
{}

inline
VLSymbC &VLCIndexIter::SymbData(void) 
{ return iter.Data().expr; }

inline 
RCWrapBaseC &VLCIndexIter::Data(void) 
{ return iter.Data().val; }

inline 
const VLSymbC &VLCIndexIter::Key(void) const
{ return iter.Data().expr; }

inline 
const RCWrapBaseC &VLCIndexIter::Data(void) const
{ return iter.Data().val; }

inline 
BooleanT VLCIndexIter::IsElm(void) const
{ return iter.IsElm(); }


#endif