baseIterator.h

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: baseIterator.h,v 1.33 2003/08/26 08:04:06 oliver Exp $
//

#ifndef BALL_CONCEPT_BASEITERATOR_H
#define BALL_CONCEPT_BASEITERATOR_H

#ifndef BALL_CONFIG_CONFIG_H
# include <BALL/CONFIG/config.h>
#endif

#ifndef BALL_COMMON_GLOBAL_H
# include <BALL/COMMON/global.h>
#endif

#ifndef BALL_COMMON_EXCEPTION_H
# include <BALL/COMMON/exception.h>
#endif

namespace BALL 
{

  template <typename Container, typename DataType, typename Position, typename Traits>
  class BaseIterator
  {
    public:


    typedef DataType  value_type;
    typedef Position  difference_type;
    typedef const DataType* pointer;
    typedef const DataType& reference;
    typedef std::input_iterator_tag iterator_category;


    BALL_INLINE BaseIterator()  {}
  
    BALL_INLINE BaseIterator(const BaseIterator& iterator) 
      : traits_(iterator.traits_)
    {
    }

    BALL_INLINE ~BaseIterator()  {}


    BALL_INLINE BaseIterator& operator = (const BaseIterator& iterator) 
    {
      traits_ = iterator.traits_;
      return *this;
    }
      
    BALL_INLINE void swap(BaseIterator& iterator)  { std::swap(traits_, iterator.traits_); }


    BALL_INLINE void invalidate()  { traits_.invalidate(); }

    BALL_INLINE void setTraits(const Traits& traits)  { traits_ = traits; }

    BALL_INLINE const Traits& getTraits() const  { return traits_; }

    BALL_INLINE Traits& getTraits()  { return traits_; }

    BALL_INLINE const Container* getContainer() const  { return traits_.getContainer(); }


    BALL_INLINE operator const Position& () const  { return traits_.getPosition(); }

    BALL_INLINE reference operator * () const  { return (reference)traits_.getData(); }

    BALL_INLINE pointer operator -> () const  { return (pointer)&traits_.getData(); }


    BALL_INLINE bool operator == (const BaseIterator& iterator) const  { return (traits_ == iterator.traits_); }

    BALL_INLINE bool operator != (const BaseIterator& iterator) const  { return !(traits_ == iterator.traits_); }

    BALL_INLINE bool isSingular() const  { return traits_.isSingular(); }

    BALL_INLINE bool isValid() const  { return traits_.isValid(); }

    BALL_INLINE bool operator + () const  { return traits_.isValid(); }

    BALL_INLINE bool operator - () const  { return !traits_.isValid(); }

    protected:

    BALL_INLINE BaseIterator(const Container& container) 
      : traits_(container)
    {
    }

    private:

    Traits traits_;
  };


} // namespace BALL

#endif // BALL_CONCEPT_BASEITERATOR_H

---