enumerator.h

Go to the documentation of this file.

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

#ifndef BALL_CONCEPT_ENUMERATOR_H
#define BALL_CONCEPT_ENUMERATOR_H

#ifndef BALL_COMMON_H
# include <BALL/common.h>
#endif

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

#ifndef BALL_COMMON_RTTI_H
# include <BALL/COMMON/rtti.h>
#endif

#ifndef BALL_CONCEPT_FORWARDITERATOR_H
# include <BALL/CONCEPT/forwardIterator.h>
#endif

#include <vector>
#include <list>
#include <algorithm>

namespace BALL
{

  class BALL_EXPORT EnumeratorIndex
    : private std::vector<Position>
  {
    public:

    class BALL_EXPORT IncompatibleIndex
      : public Exception::GeneralException
    {
      public:

      IncompatibleIndex(const char* file, int line);
    };


      
    EnumeratorIndex();

    template <typename Variant, typename VariantIterator>
    EnumeratorIndex(const std::list<std::pair<VariantIterator, std::vector<Variant> > >& variant_list);

    ~EnumeratorIndex();


    const EnumeratorIndex& operator = (const EnumeratorIndex& rhs);

    const EnumeratorIndex& operator = (Position index);

    template <typename Variant, typename VariantIterator>
    const EnumeratorIndex& operator = (const std::list<std::pair<VariantIterator, std::vector<Variant> > >& variant_list);


    const std::vector<Size>& getModulus() const;

    Size getModulus(Position pos) const;
      
    EnumeratorIndex& operator ++ ();

    EnumeratorIndex& operator -- ();

    Position operator [] (Position pos) const;

    Position& operator [] (Position pos);

    Size getSize() const;

    EnumeratorIndex& operator << (Size modulus);
    

    bool operator == (const EnumeratorIndex& rhs) const;

    bool operator != (const EnumeratorIndex& rhs) const;

    bool operator > (const EnumeratorIndex& rhs) const;

    bool operator < (const EnumeratorIndex& rhs) const;
        
    bool operator >= (const EnumeratorIndex& rhs) const;

    bool operator <= (const EnumeratorIndex& rhs) const;

    private:
    std::vector<Size> modulus_;
    std::vector<Size> base_multipliers_;
  };


  template <typename Variant, typename VariantIterator>
  EnumeratorIndex::EnumeratorIndex(const std::list<std::pair<VariantIterator, std::vector<Variant> > >& variant_list)
    : std::vector<Position>(variant_list.size()),
      modulus_(variant_list.size()),
      base_multipliers_(variant_list.size())
  { 
    this->operator = (variant_list);
  }


  template <typename Variant, typename VariantIterator>
  const EnumeratorIndex& EnumeratorIndex::operator = 
    (const std::list<std::pair<VariantIterator, std::vector<Variant> > >& variant_list)
  { 
    resize(variant_list.size());
    modulus_.resize(variant_list.size());
    base_multipliers_.resize(variant_list.size());

    // compute the base multipliers for later usage 
    Index i;
    Size multiplier = 1;
    typename std::list<std::pair<VariantIterator, std::vector<Variant> > >::const_iterator list_it = variant_list.begin();
    for (i = (Size)(size() - 1); i >= 0; i--, list_it++)
    {
      operator[](i) = 0;
      modulus_[i] = (Size)list_it->second.size();

      base_multipliers_[i] = multiplier;
      multiplier *= modulus_[i];
    }
    
    return *this;
  }


  template <class Container, class SiteIterator, class Variant>
  class Enumerator
  { 
    protected:
    class IteratorTraits_;
    
    public:

      
    typedef void (*MutatorFunction) (Variant&, const Variant&);

    typedef std::vector<Variant> VariantVector;

    typedef std::pair<SiteIterator, VariantVector> Site;

    typedef std::list<Site> SiteList;

    typedef ForwardIterator<Enumerator<Container, SiteIterator, Variant>, Container, EnumeratorIndex*, IteratorTraits_>
      Iterator;

    typedef ConstForwardIterator<Enumerator<Container, SiteIterator, Variant>, Container, EnumeratorIndex*, IteratorTraits_>
      ConstIterator;


    Enumerator();

    Enumerator(Container& container);

    Enumerator(Container& container, MutatorFunction mutator);

    ~Enumerator()
    {
    }


    void addVariants(const SiteIterator& it, const VariantVector& variants)
    {
      variant_sites_.push_back(Site(it, variants));
      position_ = variant_sites_;
    }

    void deleteVariants(const SiteIterator& it, const VariantVector& variants)
    {
      typename SiteList::iterator var_it;
      var_it = std::find(variant_sites_.begin(), variant_sites_.end(), Site(it, variants));
      if (var_it != variant_sites_.end())
      {
        variant_sites_.erase(var_it);
      }
      position_ = variant_sites_;
    }

    Size countVariants()
    {
      Size total = 1;
      typename SiteList::iterator it;
      for (it = variant_sites_.begin(); it != variant_sites_.end(); ++it)
      {
        total *= it->second.size();
      }
      return total;
    }

    Container& getCurrent();

    void createCombination(const Position index);

    void createCombination(const EnumeratorIndex& index);

    
    Iterator begin();

    Iterator end();

    ConstIterator begin() const;

    ConstIterator end() const;

    protected:

    friend class IteratorTraits_;

    class IteratorTraits_
    {
      friend class Enumerator<Container, SiteIterator, Variant>;
      
      public:
        
      typedef Enumerator<Container, SiteIterator, Variant>
        ContainerType;

      typedef Enumerator<Container, SiteIterator, Variant>* 
        ContainerPointer;

      typedef const Enumerator<Container, SiteIterator, Variant>* 
        ContainerConstPointer;

      typedef EnumeratorIndex
        IteratorPosition;

      typedef Container
        ValueType;

      IteratorTraits_()
        : bound_(0),  
          position_(),
          past_the_end_(false)
      {
      }
        
      IteratorTraits_(const ContainerType& enumerator)
        : bound_(const_cast<ContainerPointer>(&enumerator)),
          position_(enumerator.variant_sites_),
          past_the_end_(false)
      {
      }
      
      ContainerConstPointer getContainer() const  
      {
        return bound_;
      }
      
      ContainerPointer getContainer()
      {
        return bound_;
      }

      bool isSingular() const
      {
        return (bound_ == 0);
      }
 
      IteratorPosition& getPosition()
      {
        return position_;
      }

      const IteratorPosition& getPosition() const
      {
        return position_;
      }

      bool operator == (const IteratorTraits_& traits) const
      {
        return ((bound_ == traits.bound_) && (position_ == traits.position_) && (past_the_end_ == traits.past_the_end_));
      }

      bool operator != (const IteratorTraits_& traits) const
      {
        return ((bound_ != traits.bound_) || (position_ != traits.position_) || (past_the_end_ != traits.past_the_end_));
      }

      bool isValid() const
      {
        return (bound_ != 0);
      }

      void invalidate()
      {
        bound_ = 0;
        position_ = 0;
        past_the_end_ = false;
      }

      void toBegin()
      {
        position_ = 0;
        past_the_end_ = false;
      }

      bool isBegin() const
      {
        return (position_ == EnumeratorIndex()) && (past_the_end_ == false);
      }
      
      void toEnd()
      {
        position_ = 0;
        past_the_end_ = true;
      }
      
      bool isEnd() const
      {
        return past_the_end_;
      }
      
      ValueType& getData()
      {
        validate();
        return bound_->getCurrent();
      }
      
      const ValueType& getData() const
      {
        // This is logically const only!
        const_cast<typename Enumerator<Container, SiteIterator, Variant>::IteratorTraits_*>(this)->validate();
        return bound_->getCurrent();
      }
      
      void forward()
      {
        try
        {
          ++position_;
        }
        catch (Exception::IndexOverflow&)
        {
          past_the_end_ = true;
          position_ = 0;
        }
      }
      
      void validate()
      {
        if (!bound_->is_valid_position_
            || (position_ != bound_->position_))
        {
          bound_->createCombination(position_);
        }
      }

      protected:
      ContainerPointer  bound_;
      EnumeratorIndex   position_;
      bool              past_the_end_;
    };

    // the default mutation method (calling asignment operator)
    static inline void defaultAssign_(Variant& a, const Variant& b)
    {
      a = b;
    }

    void mutate_(SiteIterator& it, const Variant& v)
    {
      mutator_(*it, v);
    }

    Container&      container_;
    MutatorFunction mutator_;
    SiteList        variant_sites_;
    EnumeratorIndex position_;
    bool            is_valid_position_;
  };

  template <typename Container, typename SiteIterator, typename Variant>
  Enumerator<Container, SiteIterator, Variant>::Enumerator()
    : container_(const_cast<Container&>(RTTI::getDefault<Container>())),
      mutator_(0)
  {
  }
    
  template <typename Container, typename SiteIterator, typename Variant>
  Enumerator<Container, SiteIterator, Variant>::Enumerator(Container& container)
    : container_(container),
      mutator_(defaultAssign_)
  {
  }
    
  template <typename Container, typename SiteIterator, typename Variant>
  BALL_INLINE
  Enumerator<Container, SiteIterator, Variant>::Enumerator
    (Container& container, typename Enumerator<Container, SiteIterator, Variant>::MutatorFunction mutator)
    : container_(container),
      mutator_(mutator)
  {
  }


  template <typename Container, typename SiteIterator, typename Variant>
  BALL_INLINE
  Container& Enumerator<Container, SiteIterator, Variant>::getCurrent()
  {
    return container_;
  }
  
  template <typename Container, typename SiteIterator, typename Variant>
  void Enumerator<Container, SiteIterator, Variant>::createCombination(const Position index)
  {
    try
    {
      position_ = index;
      createCombination(position_);
    }
    catch (EnumeratorIndex::IncompatibleIndex&)
    {
      throw Exception::IndexOverflow(__FILE__, __LINE__, index);
    }
  }

  template <typename Container, typename SiteIterator, typename Variant>
  void Enumerator<Container, SiteIterator, Variant>::createCombination(const EnumeratorIndex& index)
  {
    if (&index != &position_)
    {
      position_ = index;
    }

    typename SiteList::iterator it = variant_sites_.begin();
    Position i((Position)(index.getSize() - 1));
    for (; it != variant_sites_.end(); ++it, --i)
    {
      mutate_(it->first, it->second[index[i]]);
    }
    
    is_valid_position_ = true;
  }

  template <typename Container, typename SiteIterator, typename Variant>
  BALL_INLINE
  typename Enumerator<Container, SiteIterator, Variant>::Iterator Enumerator<Container, SiteIterator, Variant>::begin()
  {
    return Iterator::begin(*this);
  }

  template <typename Container, typename SiteIterator, typename Variant>
  BALL_INLINE
  typename Enumerator<Container, SiteIterator, Variant>::Iterator Enumerator<Container, SiteIterator, Variant>::end()
  {
    return Iterator::end(*this);
  }

  template <typename Container, typename VariantConstIterator, typename Variant>
  BALL_INLINE
  typename Enumerator<Container, VariantConstIterator, Variant>::ConstIterator Enumerator<Container, VariantConstIterator, Variant>::begin() const
  {
    return ConstIterator::begin(*this);
  }

  template <typename Container, typename VariantConstIterator, typename Variant>
  BALL_INLINE
  typename Enumerator<Container, VariantConstIterator, Variant>::ConstIterator Enumerator<Container, VariantConstIterator, Variant>::end() const
  {
    return ConstIterator::end(*this);
  }

  
# ifndef BALL_NO_INLINE_FUNCTIONS
#   include <BALL/CONCEPT/enumerator.iC>
# endif

}

#endif // BALL_CONCEPT_ENUMERATOR_H