PolyBoRi
COrderedIter.h
Go to the documentation of this file.
00001 // -*- c++ -*-
00002 //*****************************************************************************
00097 //*****************************************************************************
00098 
00099 
00100 // include basic definitions
00101 #include "pbori_defs.h"
00102 #include "pbori_algo.h"
00103 
00104  
00105 #include "BoolePolynomial.h"
00106 #include "OrderedManager.h"
00107 #include "CDelayedTermIter.h"
00108 #include "CBidirectTermIter.h"
00109 #include <algorithm>
00110 
00111 #include "CStackSelector.h"
00112 #include "CTermGenerator.h"
00113 
00114 #ifndef COrderedIter_h_
00115 #define COrderedIter_h_
00116 
00117 BEGIN_NAMESPACE_PBORI
00118 
00119 
00120 template <class NavigatorType>
00121 class CAbstractStackBase {
00122 public:
00123   typedef NavigatorType navigator;
00124 
00125   typedef CAbstractStackBase<NavigatorType> self;
00126   typedef CTermStackBase<NavigatorType, self> iterator_core;
00127   typedef PBORI_SHARED_PTR(iterator_core) core_pointer;
00128 
00129   virtual void increment() = 0;
00130   virtual core_pointer copy() const = 0;
00131 
00132   virtual ~CAbstractStackBase() {}
00133 };
00134 
00135 
00136 
00137 template <class StackType>
00138 class CWrappedStack:
00139   public StackType {
00140 public:
00141   typedef StackType base;
00142   typedef CWrappedStack<StackType> self;
00143 
00144   typedef typename base::navigator navigator;
00145 
00146   typedef typename base::iterator_core iterator_core;
00147   typedef PBORI_SHARED_PTR(iterator_core) core_pointer;
00148 
00149   template <class MgrType>
00150   CWrappedStack(navigator navi, const MgrType& mgr):
00151     base(navi, mgr) {
00152     base::init();
00153   }
00154   CWrappedStack(): base() {}
00155   CWrappedStack(const self& rhs): base(rhs) {}
00156 
00157 
00158   core_pointer copy() const {
00159     return core_pointer(new self(*this));
00160   }
00161 
00162 };
00163 
00164 
00165 // template<class SequenceType>
00166 // void get_term(BooleMonomial& monom, const SequenceType& seq) {
00167 
00168 //   typename SequenceType::const_reverse_iterator start(seq.rbegin()), 
00169 //     finish(seq.rend());
00170 
00171 //   while (start != finish){
00172 //     monom.changeAssign(*start);
00173 //     ++start;
00174 //   }
00175 // }
00176 
00177 
00178 // template<class SequenceType>
00179 // void get_term(BooleExponent& termexp, const SequenceType& seq) {
00180 
00181 //   termexp.reserve(seq.deg());
00182 //   typename SequenceType::const_iterator start(seq.begin()), 
00183 //     finish(seq.end());
00184 
00185 //   while (start != finish){
00186 //     termexp.push_back(*start);
00187 //     ++start;
00188 //   }
00189 // }
00190 
00191 
00192 // template<class SequenceType>
00193 // void get_term(typename CTypes::size_type& termdeg, const SequenceType& seq) {
00194 
00195 //   termdeg = seq.deg();
00196 // }
00197 
00198 template <class NavigatorType, class MonomType>
00199 class COrderedIter:
00200   public boost::iterator_facade<
00201   COrderedIter<NavigatorType, MonomType>,
00202   MonomType, std::forward_iterator_tag, MonomType
00203   > {
00204 
00205 public:
00206 
00207   typedef COrderedIter<NavigatorType, MonomType> self;
00208   typedef CAbstractStackBase<NavigatorType> stack_base;
00209   typedef CTermStackBase<NavigatorType, stack_base> iterator_core;
00210 
00212   typedef CTermGenerator<MonomType> term_generator;
00213 
00214   typedef typename iterator_core::const_iterator const_iterator;
00215   typedef typename iterator_core::const_reverse_iterator 
00216   const_reverse_iterator;
00217   typedef typename iterator_core::size_type size_type;
00218   typedef typename iterator_core::idx_type idx_type;
00219 
00220 
00222   typedef NavigatorType navigator;
00223  
00224   // Store shared pointer of iterator
00225   typedef PBORI_SHARED_PTR(iterator_core) core_pointer;
00226 
00228   typedef bool bool_type;
00229 
00230   // Constructor
00231   COrderedIter(core_pointer rhs, 
00232                const term_generator & getTerm):
00233     m_getTerm(getTerm), p_iter(rhs) {}
00234 
00235   // Destructor
00236   ~COrderedIter() {}
00237 
00238   bool equal(const self& rhs) const { 
00239     return  p_iter->equal(*rhs.p_iter); }
00240 
00242   void increment() {
00243     if (!p_iter.unique()) {
00244       core_pointer tmp(p_iter->copy());
00245       p_iter = tmp;
00246     }
00247 
00248     p_iter->increment(); 
00249   }
00250 
00252   bool_type isOne() const { return p_iter->isOne(); }
00253 
00255   bool_type isZero() const { return p_iter->isZero(); }
00256 
00258   bool_type isEnd() const { return isZero(); }
00259 
00261   MonomType dereference() const { 
00262 
00263     return m_getTerm(*p_iter);
00264   }
00265 
00266   const_iterator begin() const { return p_iter->begin(); }
00267   const_iterator end() const { return p_iter->end(); }
00268   const_reverse_iterator rbegin() const { return p_iter->rbegin(); }
00269   const_reverse_iterator rend() const { return p_iter->rend(); }
00270 
00271   size_type deg() const { return p_iter->deg(); }
00272   idx_type firstIndex() const { return *begin(); }
00273 
00275   navigator navigation() const {
00276     return p_iter->navigation();
00277   }
00278 
00279 protected:
00281   term_generator m_getTerm;
00282 
00284   core_pointer p_iter;
00285 };
00286 
00287 
00288 template <class OrderType, class NavigatorType, class MonomType>
00289 class CGenericOrderedIter:
00290   public COrderedIter<NavigatorType, MonomType> {
00291 public:
00292   typedef CAbstractStackBase<NavigatorType> stack_base;
00293   typedef typename CStackSelector<OrderType, NavigatorType, stack_base>::type
00294   ordered_iter_base;
00295   typedef CWrappedStack<ordered_iter_base> ordered_iter_type;
00296 
00297   typedef COrderedIter<NavigatorType, MonomType> base;
00298   typedef typename base::iterator_core iterator_core;
00299   typedef typename base::core_pointer core_pointer;
00300 
00301   typedef typename base::term_generator term_generator;
00302 
00303   template <class MgrType>
00304   CGenericOrderedIter(NavigatorType navi, const MgrType& gen): 
00305     base( core_pointer(new ordered_iter_type(navi, gen) ), gen) {}
00306   CGenericOrderedIter(): base( core_pointer(new ordered_iter_type()),
00307                                term_generator() ) {}
00308 
00309   CGenericOrderedIter(const CGenericOrderedIter& rhs): base(rhs) {}
00310 };
00311 
00312 template <class OrderType, class NavigatorType>
00313 class CGenericOrderedIter<OrderType, NavigatorType, BooleExponent> :
00314   public COrderedIter<NavigatorType, BooleExponent> {
00315 public:
00316   typedef CAbstractStackBase<NavigatorType> stack_base;
00317   typedef typename CStackSelector<OrderType, NavigatorType, stack_base>::type
00318   ordered_iter_base;
00319   typedef CWrappedStack<ordered_iter_base> ordered_iter_type;
00320 
00321   typedef COrderedIter<NavigatorType, BooleExponent> base;
00322   typedef typename base::iterator_core iterator_core;
00323   typedef typename base::core_pointer core_pointer;
00324 
00325   typedef typename base::term_generator term_generator;
00326 
00327   template <class MgrType>
00328   CGenericOrderedIter(NavigatorType navi, const MgrType& mgr): 
00329     base( core_pointer(new ordered_iter_type(navi, mgr)),
00330                        term_generator() ) {}
00331 
00332   CGenericOrderedIter(): base( core_pointer(new ordered_iter_type()),
00333                               term_generator() ) {}
00334 
00335   CGenericOrderedIter(const CGenericOrderedIter& rhs): base(rhs) {}
00336 };
00337 
00338 END_NAMESPACE_PBORI
00339 
00340 #endif