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