• Main Page
  • Related Pages
  • Namespaces
  • Classes
  • Files
  • File List
  • File Members

COrderedIter.h

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

Generated on Tue Sep 14 2010 for PolyBoRi by  doxygen 1.7.1