PolyBoRi
COrderedIter.h
Go to the documentation of this file.
00001 // -*- c++ -*-
00002 //*****************************************************************************
00013 //*****************************************************************************
00014 
00015 #ifndef polybori_iterators_COrderedIter_h_
00016 #define polybori_iterators_COrderedIter_h_
00017 
00018 // include basic definitions
00019 #include <polybori/pbori_defs.h>
00020 #include <polybori/routines/pbori_algo.h>
00021 
00022  
00023 #include <polybori/BoolePolynomial.h>
00024 #include "CBidirectTermIter.h"
00025 #include <algorithm>
00026 
00027 #include "CStackSelector.h"
00028 #include "CTermGenerator.h"
00029 
00030 
00031 BEGIN_NAMESPACE_PBORI
00032 
00033 template <class NavigatorType>
00034 class CAbstractStackBase {
00035 public:
00036   typedef NavigatorType navigator;
00037 
00038   typedef CAbstractStackBase<NavigatorType> self;
00039   typedef CTermStackBase<NavigatorType, self> iterator_core;
00040   typedef boost::shared_ptr<iterator_core> core_pointer;
00041 
00042   virtual void increment() = 0;
00043   virtual core_pointer copy() const = 0;
00044 
00045   virtual ~CAbstractStackBase() {}
00046 };
00047 
00048 
00049 
00050 template <class StackType>
00051 class CWrappedStack:
00052   public StackType {
00053 public:
00054   typedef StackType base;
00055   typedef CWrappedStack<StackType> self;
00056 
00057   typedef typename base::navigator navigator;
00058 
00059   typedef typename base::iterator_core iterator_core;
00060   typedef boost::shared_ptr<iterator_core> core_pointer;
00061 
00062   template <class MgrType>
00063   CWrappedStack(navigator navi, const MgrType& mgr):
00064     base(navi, mgr) {
00065     base::init();
00066   }
00067   //  CWrappedStack(): base() {}
00068   CWrappedStack(const self& rhs): base(rhs) {}
00069 
00070 
00071   core_pointer copy() const {
00072     return core_pointer(new self(*this));
00073   }
00074 
00075 };
00076 
00077 
00078 // template<class SequenceType>
00079 // void get_term(BooleMonomial& monom, const SequenceType& seq) {
00080 
00081 //   typename SequenceType::const_reverse_iterator start(seq.rbegin()), 
00082 //     finish(seq.rend());
00083 
00084 //   while (start != finish){
00085 //     monom.changeAssign(*start);
00086 //     ++start;
00087 //   }
00088 // }
00089 
00090 
00091 // template<class SequenceType>
00092 // void get_term(BooleExponent& termexp, const SequenceType& seq) {
00093 
00094 //   termexp.reserve(seq.deg());
00095 //   typename SequenceType::const_iterator start(seq.begin()), 
00096 //     finish(seq.end());
00097 
00098 //   while (start != finish){
00099 //     termexp.push_back(*start);
00100 //     ++start;
00101 //   }
00102 // }
00103 
00104 
00105 // template<class SequenceType>
00106 // void get_term(typename CTypes::size_type& termdeg, const SequenceType& seq) {
00107 
00108 //   termdeg = seq.deg();
00109 // }
00110 
00111 template <class NavigatorType, class MonomType>
00112 class COrderedIter:
00113   public boost::iterator_facade<
00114   COrderedIter<NavigatorType, MonomType>,
00115   MonomType, std::forward_iterator_tag, MonomType
00116   > {
00117 
00118 public:
00119 
00120   typedef COrderedIter<NavigatorType, MonomType> self;
00121   typedef CAbstractStackBase<NavigatorType> stack_base;
00122   typedef CTermStackBase<NavigatorType, stack_base> iterator_core;
00123 
00125   typedef CTermGenerator<MonomType> term_generator;
00126 
00127   typedef typename iterator_core::const_iterator const_iterator;
00128   typedef typename iterator_core::const_reverse_iterator 
00129   const_reverse_iterator;
00130   typedef typename iterator_core::size_type size_type;
00131   typedef typename iterator_core::deg_type deg_type;
00132   typedef typename iterator_core::idx_type idx_type;
00133 
00134 
00136   typedef NavigatorType navigator;
00137  
00138   // Store shared pointer of iterator
00139   typedef boost::shared_ptr<iterator_core> core_pointer;
00140 
00142   typedef bool bool_type;
00143 
00144   // Constructor
00145   COrderedIter(core_pointer rhs, 
00146                const term_generator & getTerm):
00147     m_getTerm(getTerm), p_iter(rhs) {}
00148 
00149   // Destructor
00150   ~COrderedIter() {}
00151 
00152   bool equal(const self& rhs) const { 
00153     return  p_iter->equal(*rhs.p_iter); }
00154 
00156   void increment() {
00157     if (!p_iter.unique()) {
00158       core_pointer tmp(p_iter->copy());
00159       p_iter = tmp;
00160     }
00161 
00162     p_iter->increment(); 
00163   }
00164 
00166   bool_type isOne() const { return p_iter->isOne(); }
00167 
00169   bool_type isZero() const { return p_iter->isZero(); }
00170 
00172   bool_type isEnd() const { return isZero(); }
00173 
00175   MonomType dereference() const { 
00176 
00177     return m_getTerm(*p_iter);
00178   }
00179 
00180   const_iterator begin() const { return p_iter->begin(); }
00181   const_iterator end() const { return p_iter->end(); }
00182   const_reverse_iterator rbegin() const { return p_iter->rbegin(); }
00183   const_reverse_iterator rend() const { return p_iter->rend(); }
00184 
00185   deg_type deg() const { return p_iter->deg(); }
00186   idx_type firstIndex() const { return *begin(); }
00187 
00189   navigator navigation() const {
00190     return p_iter->navigation();
00191   }
00192 
00193 protected:
00195   term_generator m_getTerm;
00196 
00198   core_pointer p_iter;
00199 };
00200 
00201 
00202 template <class OrderType, class NavigatorType, class MonomType>
00203 class CGenericOrderedIter:
00204   public COrderedIter<NavigatorType, MonomType> {
00205 public:
00206   typedef CAbstractStackBase<NavigatorType> stack_base;
00207   typedef typename CStackSelector<OrderType, NavigatorType, stack_base>::type
00208   ordered_iter_base;
00209   typedef CWrappedStack<ordered_iter_base> ordered_iter_type;
00210 
00211   typedef COrderedIter<NavigatorType, MonomType> base;
00212   typedef typename base::iterator_core iterator_core;
00213   typedef typename base::core_pointer core_pointer;
00214 
00215   typedef typename base::term_generator term_generator;
00216 
00217   template <class MgrType>
00218   CGenericOrderedIter(NavigatorType navi, const MgrType& gen): 
00219     base( core_pointer(new ordered_iter_type(navi, gen) ), gen) {}
00220 //   CGenericOrderedIter(): base( core_pointer(new ordered_iter_type()),
00221 //                                term_generator() ) {}
00222 
00223   CGenericOrderedIter(const CGenericOrderedIter& rhs): base(rhs) {}
00224 };
00225 
00226 template <class OrderType, class NavigatorType>
00227 class CGenericOrderedIter<OrderType, NavigatorType, BooleExponent> :
00228   public COrderedIter<NavigatorType, BooleExponent> {
00229 public:
00230   typedef CAbstractStackBase<NavigatorType> stack_base;
00231   typedef typename CStackSelector<OrderType, NavigatorType, stack_base>::type
00232   ordered_iter_base;
00233   typedef CWrappedStack<ordered_iter_base> ordered_iter_type;
00234 
00235   typedef COrderedIter<NavigatorType, BooleExponent> base;
00236   typedef typename base::iterator_core iterator_core;
00237   typedef typename base::core_pointer core_pointer;
00238 
00239   typedef typename base::term_generator term_generator;
00240 
00241   template <class MgrType>
00242   CGenericOrderedIter(NavigatorType navi, const MgrType& mgr): 
00243     base( core_pointer(new ordered_iter_type(navi, mgr)),
00244                        term_generator() ) {}
00245 
00246 //   CGenericOrderedIter(): base( core_pointer(new ordered_iter_type()),
00247 //                               term_generator() ) {}
00248 
00249   CGenericOrderedIter(const CGenericOrderedIter& rhs): base(rhs) {}
00250 };
00251 
00252 END_NAMESPACE_PBORI
00253 
00254 #endif