iterator.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_KERNEL_ITERATOR_H
#define BALL_KERNEL_ITERATOR_H

#ifndef BALL_CONCEPT_BIDIRECTIONALITERATOR_H
# include <BALL/CONCEPT/bidirectionalIterator.h>
#endif

#ifndef BALL_CONCEPT_COMPOSITE_H
# include <BALL/CONCEPT/composite.h>
#endif


#define BALL_KERNEL_DEFINE_ITERATOR_CREATORS(Type) \
Type##Iterator \
begin##Type () \
{ \
  return Type##Iterator::begin(*this); \
} \
 \
Type##Iterator \
end##Type () \
{ \
  return Type##Iterator::end(*this); \
} \
 \
Type##ReverseIterator \
rbegin##Type () \
{ \
  return Type##ReverseIterator(end##Type ()); \
} \
 \
Type##ReverseIterator \
rend##Type () \
{ \
  return Type##ReverseIterator(begin##Type ()); \
} \
 \
Type##ConstIterator \
begin##Type () const \
{ \
  return Type##ConstIterator::begin(*this); \
} \
 \
Type##ConstIterator \
end##Type () const \
{ \
  return Type##ConstIterator::end(*this); \
} \
 \
Type##ConstReverseIterator \
rbegin##Type () const \
{ \
  return Type##ConstReverseIterator(end##Type ()); \
} \
 \
Type##ConstReverseIterator \
rend##Type () const \
{ \
  return Type##ConstReverseIterator(begin##Type ()); \
}

namespace BALL 
{
  class BALL_EXPORT CompositeIteratorTraits
  {
    public:


    inline CompositeIteratorTraits();

    inline CompositeIteratorTraits(const Composite& composite);

    inline CompositeIteratorTraits(const CompositeIteratorTraits& traits);

    inline ~CompositeIteratorTraits() {}



    inline CompositeIteratorTraits& operator = (const CompositeIteratorTraits& traits);


    Composite* getContainer() { return bound_; }
  
    inline const Composite* getContainer() const { return bound_; }


    inline bool operator == (const CompositeIteratorTraits& traits) const;

    inline bool operator != (const CompositeIteratorTraits& traits) const;

    inline bool isValid() const { return ((bound_ != 0) && composite_iterator_.isValid()); }

    inline bool isSingular() const { return (bound_ == 0); }
  
    inline bool isBegin() const;

    inline bool isEnd() const 
    { 
      return composite_iterator_.isEnd(); 
    }

    inline bool isRBegin() const;
      
    inline bool isREnd() const;
  
    inline Composite::CompositeIterator& getPosition() { return composite_iterator_; }
  
    inline const Composite::CompositeIterator& getPosition() const { return composite_iterator_; }
  
    inline void invalidate();

    inline void toBegin();

    inline void toEnd();

    inline Composite& getData();
  
    inline const Composite& getData() const;
  
    inline void forward();
  
    inline void backward();
      
    inline void toRBegin();

    inline void toREnd();

    inline void setPredicate(const UnaryPredicate<Composite>& predicate) { predicate_ = &predicate; }
      
    inline const UnaryPredicate<Composite>* getPredicate() const { return predicate_; }


    protected:

    Composite* bound_;

    Composite::CompositeIterator composite_iterator_;

    const UnaryPredicate<Composite>* predicate_;
  };

  inline CompositeIteratorTraits::CompositeIteratorTraits()
    : bound_(0),
      composite_iterator_(),
      predicate_(0)
  {
  }
    
  inline CompositeIteratorTraits::CompositeIteratorTraits(const Composite& composite)
    : bound_(const_cast<Composite*>(&composite)),
      composite_iterator_(const_cast<Composite&>(composite).beginComposite()),
      predicate_(0)
  {
  }
    
  inline CompositeIteratorTraits::CompositeIteratorTraits(const CompositeIteratorTraits& traits)
    : bound_(traits.bound_),
      composite_iterator_(traits.composite_iterator_),
      predicate_(traits.predicate_)
  {
  }

  inline CompositeIteratorTraits& CompositeIteratorTraits::operator = (const CompositeIteratorTraits& traits)
  {
    bound_ = traits.bound_;
    composite_iterator_ = traits.composite_iterator_;
    predicate_ = traits.predicate_;
    return *this;
  }

  inline bool CompositeIteratorTraits::operator == (const CompositeIteratorTraits& traits) const
  {
    return ((composite_iterator_ == traits.composite_iterator_) && (bound_ == traits.bound_));
  }

  inline bool CompositeIteratorTraits::operator != (const CompositeIteratorTraits& traits) const
  {
    return !this->operator == (traits);
  }

  inline void CompositeIteratorTraits::invalidate()
  {
    bound_ = 0;
    composite_iterator_.invalidate();
  }

  inline void CompositeIteratorTraits::toBegin()
  {
    BALL_PRECONDITION_EXCEPTION((bound_ != 0), "cannot move unbound iterator to begin")
    composite_iterator_ = bound_->beginComposite();
    while (+composite_iterator_ && (predicate_->operator () (*composite_iterator_) == false))
    {
      ++composite_iterator_;
    }
  }

  inline bool CompositeIteratorTraits::isBegin() const
  {
    if (isSingular())
    {
      return false;
    }

    try
    {
      Composite::CompositeIterator sub_iterator(bound_->beginComposite());
      while (+sub_iterator && (predicate_->operator () (*sub_iterator) == false))
      {
        ++sub_iterator;
      }
      return (composite_iterator_ == sub_iterator);
    }
    catch (Exception::Precondition&)
    {
    }

    return false;
  }

  inline void CompositeIteratorTraits::toEnd()
  {
    composite_iterator_.toEnd();
  }

  inline Composite& CompositeIteratorTraits::getData()
  {
    return const_cast<Composite&>(*composite_iterator_);
  }

  inline const Composite& CompositeIteratorTraits::getData() const
  {
    return *composite_iterator_;
  }

  inline void CompositeIteratorTraits::forward()
  {
    ++composite_iterator_;
    while (+composite_iterator_ && (predicate_->operator () (*composite_iterator_) == false))
    {
      ++composite_iterator_;
    }
  }

  inline void CompositeIteratorTraits::toRBegin()
  {
    BALL_PRECONDITION_EXCEPTION(!isSingular(), "cannot move singular iterator to reverse begin")
    composite_iterator_ = --bound_->endComposite();
    while (+composite_iterator_ && (predicate_->operator () (*composite_iterator_) == false))
    {
      --composite_iterator_;
    }
  }

  inline bool CompositeIteratorTraits::isRBegin() const
  {
    if (isSingular())
    {
      return false;
    }
    Composite::CompositeIterator sub_iterator = --bound_->endComposite();

    while (+sub_iterator && (predicate_->operator () (*sub_iterator) == false))
    {
      --sub_iterator;
    }
    return (composite_iterator_ == sub_iterator);
  }

  inline void CompositeIteratorTraits::toREnd()
  {
    composite_iterator_.toREnd();
  }

  inline bool CompositeIteratorTraits::isREnd() const
  {
    if (isSingular())
    {
      return false;
    }
    return composite_iterator_.isREnd();
  }

  inline void CompositeIteratorTraits::backward()
  {
    --composite_iterator_;
    while (+composite_iterator_ && (predicate_->operator () (*composite_iterator_) == false))
    {
      --composite_iterator_;
    }
  }
} // namespace BALL

#endif // BALL_KERNEL_ITERATOR_H