PolyBoRi
COrderedIter.h
Go to the documentation of this file.
1 // -*- c++ -*-
2 //*****************************************************************************
13 //*****************************************************************************
14 
15 #ifndef polybori_iterators_COrderedIter_h_
16 #define polybori_iterators_COrderedIter_h_
17 
18 // include basic definitions
19 #include <polybori/pbori_defs.h>
21 
22 
24 #include "CBidirectTermIter.h"
25 #include <algorithm>
26 
27 #include "CStackSelector.h"
28 #include "CTermGenerator.h"
29 
30 
32 
33 template <class NavigatorType>
35 public:
36  typedef NavigatorType navigator;
37 
40  typedef boost::shared_ptr<iterator_core> core_pointer;
41 
42  virtual void increment() = 0;
43  virtual core_pointer copy() const = 0;
44 
45  virtual ~CAbstractStackBase() {}
46 };
47 
48 
49 
50 template <class StackType>
52  public StackType {
53 public:
54  typedef StackType base;
56 
57  typedef typename base::navigator navigator;
58 
59  typedef typename base::iterator_core iterator_core;
60  typedef boost::shared_ptr<iterator_core> core_pointer;
61 
62  template <class MgrType>
63  CWrappedStack(navigator navi, const MgrType& mgr):
64  base(navi, mgr) {
65  base::init();
66  }
67  // CWrappedStack(): base() {}
68  CWrappedStack(const self& rhs): base(rhs) {}
69 
70 
71  core_pointer copy() const {
72  return core_pointer(new self(*this));
73  }
74 
75 };
76 
77 
78 // template<class SequenceType>
79 // void get_term(BooleMonomial& monom, const SequenceType& seq) {
80 
81 // typename SequenceType::const_reverse_iterator start(seq.rbegin()),
82 // finish(seq.rend());
83 
84 // while (start != finish){
85 // monom.changeAssign(*start);
86 // ++start;
87 // }
88 // }
89 
90 
91 // template<class SequenceType>
92 // void get_term(BooleExponent& termexp, const SequenceType& seq) {
93 
94 // termexp.reserve(seq.deg());
95 // typename SequenceType::const_iterator start(seq.begin()),
96 // finish(seq.end());
97 
98 // while (start != finish){
99 // termexp.push_back(*start);
100 // ++start;
101 // }
102 // }
103 
104 
105 // template<class SequenceType>
106 // void get_term(typename CTypes::size_type& termdeg, const SequenceType& seq) {
107 
108 // termdeg = seq.deg();
109 // }
110 
111 template <class NavigatorType, class MonomType>
112 class COrderedIter:
113  public boost::iterator_facade<
114  COrderedIter<NavigatorType, MonomType>,
115  MonomType, std::forward_iterator_tag, MonomType
116  > {
117 
118 public:
119 
123 
126 
128  typedef typename iterator_core::const_reverse_iterator
133 
134 
136  typedef NavigatorType navigator;
137 
138  // Store shared pointer of iterator
139  typedef boost::shared_ptr<iterator_core> core_pointer;
140 
142  typedef bool bool_type;
143 
144  // Constructor
146  const term_generator & getTerm):
147  m_getTerm(getTerm), p_iter(rhs) {}
148 
149  // Destructor
151 
152  bool equal(const self& rhs) const {
153  return p_iter->equal(*rhs.p_iter); }
154 
156  void increment() {
157  if (!p_iter.unique()) {
158  core_pointer tmp(p_iter->copy());
159  p_iter = tmp;
160  }
161 
162  p_iter->increment();
163  }
164 
166  bool_type isOne() const { return p_iter->isOne(); }
167 
169  bool_type isZero() const { return p_iter->isZero(); }
170 
172  bool_type isEnd() const { return isZero(); }
173 
175  MonomType dereference() const {
176 
177  return m_getTerm(*p_iter);
178  }
179 
180  const_iterator begin() const { return p_iter->begin(); }
181  const_iterator end() const { return p_iter->end(); }
182  const_reverse_iterator rbegin() const { return p_iter->rbegin(); }
183  const_reverse_iterator rend() const { return p_iter->rend(); }
184 
185  deg_type deg() const { return p_iter->deg(); }
186  idx_type firstIndex() const { return *begin(); }
187 
190  return p_iter->navigation();
191  }
192 
193 protected:
196 
199 };
200 
201 
202 template <class OrderType, class NavigatorType, class MonomType>
204  public COrderedIter<NavigatorType, MonomType> {
205 public:
210 
214 
216 
217  template <class MgrType>
218  CGenericOrderedIter(NavigatorType navi, const MgrType& gen):
219  base( core_pointer(new ordered_iter_type(navi, gen) ), gen) {}
220 // CGenericOrderedIter(): base( core_pointer(new ordered_iter_type()),
221 // term_generator() ) {}
222 
224 };
225 
226 template <class OrderType, class NavigatorType>
227 class CGenericOrderedIter<OrderType, NavigatorType, BooleExponent> :
228  public COrderedIter<NavigatorType, BooleExponent> {
229 public:
234 
238 
240 
241  template <class MgrType>
242  CGenericOrderedIter(NavigatorType navi, const MgrType& mgr):
243  base( core_pointer(new ordered_iter_type(navi, mgr)),
244  term_generator() ) {}
245 
246 // CGenericOrderedIter(): base( core_pointer(new ordered_iter_type()),
247 // term_generator() ) {}
248 
250 };
251 
253 
254 #endif