PolyBoRi
|
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