#ifndef _rooListIterators_h
#define _rooListIterators_h

#ifndef _rooCommon_h
#include "rooCommon.h"
#endif

//
// ROOT wrappers around ActiveSchema classes ( see ooas.h )
//

////////////////////////// Iterators ///////////////////////////////////////////
class rooAttributeItr 
{
protected:
   void* fImp;
   rooAttribute* fObj;

public:   
   rooAttributeItr();
   rooAttributeItr(void* imp) { setImp(imp); }
   virtual ~rooAttributeItr();
   void* getImp() const { return fImp; }
   void  setImp(void* imp) { fImp=imp; }
   rooAttributeItr(const rooAttributeItr&);

   rooAttributeItr &       operator=(const rooAttributeItr & in);
   Bool_t                  operator==(const rooAttributeItr & in) const;
   Bool_t                  operator!=(const rooAttributeItr & in) const;
   rooAttributeItr &       operator++();
   rooAttributeItr &       operator++(int);
   const rooAttribute&     operator*();
   rooAttribute*           elementP();

ClassDef(rooAttributeItr,0)   //  corresponds to attribute_iterator
};

////////////////////////////////////////////////////////////////////////////////
class rooInheritanceItr 
{
protected:
   void* fImp;
   rooInheritance* fObj;

public:
   rooInheritanceItr();
   virtual ~rooInheritanceItr();
   rooInheritanceItr(void* imp) { setImp(imp); }
   void  setImp(void* imp) { fImp=imp; }
   void* getImp() const { return fImp; }
   rooInheritanceItr(const rooInheritanceItr&);

   rooInheritanceItr &        operator=(const rooInheritanceItr &);
   Bool_t                     operator==(const rooInheritanceItr &) const;
   Bool_t                     operator!=(const rooInheritanceItr &) const;
   rooInheritanceItr &        operator++();
   rooInheritanceItr &        operator++(int);
   const rooInheritance&      operator*();
   rooInheritance*            elementP();

ClassDef(rooInheritanceItr,0)   // corresponds to inheritance_iterator
};

////////////////////////////////////////////////////////////////////////////////
class rooRelationshipItr 
{
protected:
   void* fImp;
   rooRelationship* fObj;

public:
   rooRelationshipItr();
   virtual ~rooRelationshipItr();
   rooRelationshipItr(void* imp) { setImp(imp); }
   void  setImp(void* imp) { fImp=imp; }
   void* getImp() const { return fImp; }
   rooRelationshipItr(const rooRelationshipItr&);   

   rooRelationshipItr &        operator=(const rooRelationshipItr &);
   Bool_t                      operator==(const rooRelationshipItr &) const;
   Bool_t                      operator!=(const rooRelationshipItr &) const;
   rooRelationshipItr &        operator++();
   rooRelationshipItr &        operator++(int);
   const rooRelationship&      operator*();
   rooRelationship*            elementP();

ClassDef(rooRelationshipItr,0)   // corresponds to relationship_iterator
};

////////////////////////////////////////////////////////////////////////////////
class rooCollectionTypeItr 
{
protected:
   void* fImp;
   rooCollectionType* fObj;

public:
   rooCollectionTypeItr();
   virtual ~rooCollectionTypeItr();
   rooCollectionTypeItr(void* imp) { setImp(imp); }
   void  setImp(void* imp) { fImp=imp; }
   void* getImp() const { return fImp; }
   rooCollectionTypeItr(const rooCollectionTypeItr&);

   rooCollectionTypeItr &       operator=(const rooCollectionTypeItr &);
   Bool_t                       operator==(const rooCollectionTypeItr &) const;
   Bool_t                       operator!=(const rooCollectionTypeItr &) const;
   rooCollectionTypeItr &       operator++();
   rooCollectionTypeItr &       operator++(int);
   const rooCollectionType&     operator*();
   rooCollectionType*           elementP();

ClassDef(rooCollectionTypeItr,0)   // corresponds to collection_type_iterator
};

////////////////////////////////////////////////////////////////////////////////
class rooRefTypeItr 
{
protected:
   void* fImp;
   rooRefType* fObj;

public:
   rooRefTypeItr();
   virtual ~rooRefTypeItr();
   rooRefTypeItr(void* imp) { setImp(imp); }
   void  setImp(void* imp) { fImp=imp; }
   void* getImp() const { return fImp; }
   rooRefTypeItr(const rooRefTypeItr&);

   rooRefTypeItr &        operator=(const rooRefTypeItr &);
   Bool_t                 operator==(const rooRefTypeItr &) const;
   Bool_t                 operator!=(const rooRefTypeItr &) const;
   rooRefTypeItr &        operator++();
   rooRefTypeItr &        operator++(int);
   const rooRefType&      operator*();
   rooRefType*            elementP();

ClassDef(rooRefTypeItr,0)   // corresponds to ref_type_iterator
};

////////////////////////////////////////////////////////////////////////////////
class rooPropertyItr 
{
protected:
   void* fImp;
   rooProperty* fObj;

public:
   rooPropertyItr();
   virtual ~rooPropertyItr();
   rooPropertyItr(void* imp) { setImp(imp); }
   void  setImp(void* imp) { fImp=imp; }
   void* getImp() const { return fImp; }
   rooPropertyItr(const rooPropertyItr&);

   rooPropertyItr &        operator=(const rooPropertyItr &);
   Bool_t                  operator==(const rooPropertyItr &) const;
   Bool_t                  operator!=(const rooPropertyItr &) const;
   rooPropertyItr &        operator++();
   rooPropertyItr &        operator++(int);
   const rooProperty&      operator*();
   rooProperty*            elementP();

ClassDef(rooPropertyItr,0)   // corresponds to property_iterator
};

////////////////////////////////////////////////////////////////////////////////
class rooModuleItr 
{
protected:
   void* fImp;
   rooModule* fObj;

public:
   rooModuleItr();
   virtual ~rooModuleItr();
   rooModuleItr(void* imp)  { setImp(imp); }
   void  setImp(void* imp) { fImp=imp; }
   void* getImp() const { return fImp; }
   rooModuleItr(const rooModuleItr&);

   rooModuleItr &        operator=(const rooModuleItr &);
   Bool_t                operator==(const rooModuleItr &) const;
   Bool_t                operator!=(const rooModuleItr &) const;
   rooModuleItr &        operator++();
   rooModuleItr &        operator++(int);
   const rooModule&      operator*();
   rooModule*            elementP();

ClassDef(rooModuleItr,0)   // corresponds to module_iterator
};

////////////////////////////////////////////////////////////////////////////////
class rooMetaObjectItr 
{
protected:
   void* fImp;
   rooMetaObject* fObj;

public:
   rooMetaObjectItr();
   virtual ~rooMetaObjectItr();
   rooMetaObjectItr(void* imp) { setImp(imp); }
   void  setImp(void* imp) { fImp=imp; }
   void* getImp() const { return fImp; }
   rooMetaObjectItr(const rooMetaObjectItr&);

   rooMetaObjectItr &              operator=(const rooMetaObjectItr &);
   virtual Bool_t                  operator==(const rooMetaObjectItr &) const;
   virtual Bool_t                  operator!=(const rooMetaObjectItr &) const;
   virtual rooMetaObjectItr &      operator++();
   virtual rooMetaObjectItr &      operator++(int);
   virtual const rooMetaObject &   operator*();
   virtual rooMetaObject*          elementP();

   Bool_t                          is_attr_iterator() const;
//   rooMetaObjectItr(rooMetaObject *moP);
//   rooMetaObjectItr(const rooMetaObjectItr &moI);
//   rooMetaObjectItr(const d_Attribute_list_const_iterator &);

ClassDef(rooMetaObjectItr,0) // corresponds to meta_object_iterator
};

////////////////////////////////////////////////////////////////////////////////
class rooTypeItr 
{
protected:
   void* fImp;
   rooType* fObj;

public:
   rooTypeItr();
   virtual ~rooTypeItr();
   rooTypeItr(void* imp) { setImp(imp); }
   void  setImp(void* imp) { fImp=imp; }
   void* getImp() const { return fImp; }
   rooTypeItr(const rooTypeItr&);

   rooTypeItr &             operator=(const rooTypeItr &);
   Bool_t                   operator==(const rooTypeItr &) const;
   Bool_t                   operator!=(const rooTypeItr &) const;
   rooTypeItr &             operator++();
   rooTypeItr &             operator++(int);
   const rooType &          operator*();
   rooType*                 elementP();
 
//   rooTypeItr(rooType *tP);
//   rooTypeItr(const rooTypeItr &tI);

ClassDef(rooTypeItr,0)  // corresponds to type_iterator
};

#endif // _rooListIterators_h