PolyBoRi
COrderedIter.h
Go to the documentation of this file.
1 // -*- c++ -*-
2 //*****************************************************************************
97 //*****************************************************************************
98 
99 
100 // include basic definitions
101 #include "pbori_defs.h"
102 #include "pbori_algo.h"
103 
104 
105 #include "BoolePolynomial.h"
106 #include "OrderedManager.h"
107 #include "CDelayedTermIter.h"
108 #include "CBidirectTermIter.h"
109 #include <algorithm>
110 
111 #include "CStackSelector.h"
112 #include "CTermGenerator.h"
113 
114 #ifndef COrderedIter_h_
115 #define COrderedIter_h_
116 
118 
119 
120 template <class NavigatorType>
121 class CAbstractStackBase {
122 public:
123  typedef NavigatorType navigator;
124 
125  typedef CAbstractStackBase<NavigatorType> self;
126  typedef CTermStackBase<NavigatorType, self> iterator_core;
127  typedef PBORI_SHARED_PTR(iterator_core) core_pointer;
128 
129  virtual void increment() = 0;
130  virtual core_pointer copy() const = 0;
131 
132  virtual ~CAbstractStackBase() {}
133 };
134 
135 
136 
137 template <class StackType>
138 class CWrappedStack:
139  public StackType {
140 public:
141  typedef StackType base;
142  typedef CWrappedStack<StackType> self;
143 
144  typedef typename base::navigator navigator;
145 
146  typedef typename base::iterator_core iterator_core;
147  typedef PBORI_SHARED_PTR(iterator_core) core_pointer;
148 
149  template <class MgrType>
150  CWrappedStack(navigator navi, const MgrType& mgr):
151  base(navi, mgr) {
152  base::init();
153  }
154  CWrappedStack(): base() {}
155  CWrappedStack(const self& rhs): base(rhs) {}
156 
157 
158  core_pointer copy() const {
159  return core_pointer(new self(*this));
160  }
161 
162 };
163 
164 
165 // template<class SequenceType>
166 // void get_term(BooleMonomial& monom, const SequenceType& seq) {
167 
168 // typename SequenceType::const_reverse_iterator start(seq.rbegin()),
169 // finish(seq.rend());
170 
171 // while (start != finish){
172 // monom.changeAssign(*start);
173 // ++start;
174 // }
175 // }
176 
177 
178 // template<class SequenceType>
179 // void get_term(BooleExponent& termexp, const SequenceType& seq) {
180 
181 // termexp.reserve(seq.deg());
182 // typename SequenceType::const_iterator start(seq.begin()),
183 // finish(seq.end());
184 
185 // while (start != finish){
186 // termexp.push_back(*start);
187 // ++start;
188 // }
189 // }
190 
191 
192 // template<class SequenceType>
193 // void get_term(typename CTypes::size_type& termdeg, const SequenceType& seq) {
194 
195 // termdeg = seq.deg();
196 // }
197 
198 template <class NavigatorType, class MonomType>
199 class COrderedIter:
200  public boost::iterator_facade<
201  COrderedIter<NavigatorType, MonomType>,
202  MonomType, std::forward_iterator_tag, MonomType
203  > {
204 
205 public:
206 
207  typedef COrderedIter<NavigatorType, MonomType> self;
208  typedef CAbstractStackBase<NavigatorType> stack_base;
209  typedef CTermStackBase<NavigatorType, stack_base> iterator_core;
210 
212  typedef CTermGenerator<MonomType> term_generator;
213 
214  typedef typename iterator_core::const_iterator const_iterator;
215  typedef typename iterator_core::const_reverse_iterator
216  const_reverse_iterator;
217  typedef typename iterator_core::size_type size_type;
218  typedef typename iterator_core::idx_type idx_type;
219 
220 
222  typedef NavigatorType navigator;
223 
224  // Store shared pointer of iterator
225  typedef PBORI_SHARED_PTR(iterator_core) core_pointer;
226 
228  typedef bool bool_type;
229 
230  // Constructor
231  COrderedIter(core_pointer rhs,
232  const term_generator & getTerm):
233  m_getTerm(getTerm), p_iter(rhs) {}
234 
235  // Destructor
236  ~COrderedIter() {}
237 
238  bool equal(const self& rhs) const {
239  return p_iter->equal(*rhs.p_iter); }
240 
242  void increment() {
243  if (!p_iter.unique()) {
244  core_pointer tmp(p_iter->copy());
245  p_iter = tmp;
246  }
247 
248  p_iter->increment();
249  }
250 
252  bool_type isOne() const { return p_iter->isOne(); }
253 
255  bool_type isZero() const { return p_iter->isZero(); }
256 
258  bool_type isEnd() const { return isZero(); }
259 
261  MonomType dereference() const {
262 
263  return m_getTerm(*p_iter);
264  }
265 
266  const_iterator begin() const { return p_iter->begin(); }
267  const_iterator end() const { return p_iter->end(); }
268  const_reverse_iterator rbegin() const { return p_iter->rbegin(); }
269  const_reverse_iterator rend() const { return p_iter->rend(); }
270 
271  size_type deg() const { return p_iter->deg(); }
272  idx_type firstIndex() const { return *begin(); }
273 
275  navigator navigation() const {
276  return p_iter->navigation();
277  }
278 
279 protected:
281  term_generator m_getTerm;
282 
284  core_pointer p_iter;
285 };
286 
287 
288 template <class OrderType, class NavigatorType, class MonomType>
289 class CGenericOrderedIter:
290  public COrderedIter<NavigatorType, MonomType> {
291 public:
292  typedef CAbstractStackBase<NavigatorType> stack_base;
293  typedef typename CStackSelector<OrderType, NavigatorType, stack_base>::type
294  ordered_iter_base;
295  typedef CWrappedStack<ordered_iter_base> ordered_iter_type;
296 
297  typedef COrderedIter<NavigatorType, MonomType> base;
298  typedef typename base::iterator_core iterator_core;
299  typedef typename base::core_pointer core_pointer;
300 
301  typedef typename base::term_generator term_generator;
302 
303  template <class MgrType>
304  CGenericOrderedIter(NavigatorType navi, const MgrType& gen):
305  base( core_pointer(new ordered_iter_type(navi, gen) ), gen) {}
306  CGenericOrderedIter(): base( core_pointer(new ordered_iter_type()),
307  term_generator() ) {}
308 
309  CGenericOrderedIter(const CGenericOrderedIter& rhs): base(rhs) {}
310 };
311 
312 template <class OrderType, class NavigatorType>
313 class CGenericOrderedIter<OrderType, NavigatorType, BooleExponent> :
314  public COrderedIter<NavigatorType, BooleExponent> {
315 public:
316  typedef CAbstractStackBase<NavigatorType> stack_base;
317  typedef typename CStackSelector<OrderType, NavigatorType, stack_base>::type
318  ordered_iter_base;
319  typedef CWrappedStack<ordered_iter_base> ordered_iter_type;
320 
321  typedef COrderedIter<NavigatorType, BooleExponent> base;
322  typedef typename base::iterator_core iterator_core;
323  typedef typename base::core_pointer core_pointer;
324 
325  typedef typename base::term_generator term_generator;
326 
327  template <class MgrType>
328  CGenericOrderedIter(NavigatorType navi, const MgrType& mgr):
329  base( core_pointer(new ordered_iter_type(navi, mgr)),
330  term_generator() ) {}
331 
332  CGenericOrderedIter(): base( core_pointer(new ordered_iter_type()),
333  term_generator() ) {}
334 
335  CGenericOrderedIter(const CGenericOrderedIter& rhs): base(rhs) {}
336 };
337 
339 
340 #endif