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
145  COrderedIter(core_pointer rhs,
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 
189  navigator navigation() const {
190  return p_iter->navigation();
191  }
192 
193 protected:
195  term_generator m_getTerm;
196 
198  core_pointer p_iter;
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 
223  CGenericOrderedIter(const CGenericOrderedIter& rhs): base(rhs) {}
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 
249  CGenericOrderedIter(const CGenericOrderedIter& rhs): base(rhs) {}
250 };
251 
253 
254 #endif
boost::indirect_iterator< typename stack_type::const_iterator, typename navigator::value_type, boost::use_default, typename navigator::reference > const_iterator
Definition: CTermStack.h:156
NavigatorType navigator
Definition: COrderedIter.h:36
CWrappedStack< ordered_iter_base > ordered_iter_type
Definition: COrderedIter.h:233
CGenericOrderedIter(const CGenericOrderedIter &rhs)
Definition: COrderedIter.h:223
CStackSelector< OrderType, NavigatorType, stack_base >::type ordered_iter_base
Definition: COrderedIter.h:208
This class is just a wrapper for using variables for storing indices as interim data structure for Bo...
Definition: BooleExponent.h:34
deg_type deg() const
Definition: COrderedIter.h:185
#define END_NAMESPACE_PBORI
Finish project's namespace.
Definition: pbori_defs.h:77
term_generator m_getTerm
The functional which defines the dereferecing operation.
Definition: COrderedIter.h:195
base::core_pointer core_pointer
Definition: COrderedIter.h:213
base::term_generator term_generator
Definition: COrderedIter.h:239
boost::shared_ptr< iterator_core > core_pointer
Definition: COrderedIter.h:60
core_pointer p_iter
A shared pointer to the stack, which carries the current path.
Definition: COrderedIter.h:198
CTermGenerator< MonomType > term_generator
Type for functional, which generates actual term, for current path.
Definition: COrderedIter.h:125
#define BEGIN_NAMESPACE_PBORI
Start project's namespace.
Definition: pbori_defs.h:74
CWrappedStack< ordered_iter_base > ordered_iter_type
Definition: COrderedIter.h:209
void increment()
Incrementation.
Definition: COrderedIter.h:156
CTermStackBase< NavigatorType, stack_base > iterator_core
Definition: COrderedIter.h:122
idx_type firstIndex() const
Definition: COrderedIter.h:186
StackType base
Definition: COrderedIter.h:54
iterator_core::size_type size_type
Definition: COrderedIter.h:130
CAbstractStackBase< NavigatorType > stack_base
Definition: COrderedIter.h:206
COrderedIter(core_pointer rhs, const term_generator &getTerm)
Definition: COrderedIter.h:145
NavigatorType navigator
Fix type of direct iterator.
Definition: COrderedIter.h:136
COrderedIter< NavigatorType, BooleExponent > base
Definition: COrderedIter.h:235
iterator_core::const_iterator const_iterator
Definition: COrderedIter.h:127
on_same_type< block_prop, valid_tag, block_type, nonblock_type >::type type
The resulting type for iterator's stack.
Definition: CStackSelector.h:67
CAbstractStackBase< NavigatorType > stack_base
Definition: COrderedIter.h:121
CGenericOrderedIter(const CGenericOrderedIter &rhs)
Definition: COrderedIter.h:249
Definition: COrderedIter.h:34
CWrappedStack(navigator navi, const MgrType &mgr)
Definition: COrderedIter.h:63
CStackSelector< OrderType, NavigatorType, stack_base >::type ordered_iter_base
Definition: COrderedIter.h:232
MonomType dereference() const
Dereferencing operation.
Definition: COrderedIter.h:175
base::navigator navigator
Definition: COrderedIter.h:57
Definition: BoolePolynomial.h:63
boost::indirect_iterator< typename stack_type::const_reverse_iterator, typename navigator::value_type, boost::use_default, typename navigator::reference > const_reverse_iterator
Definition: CTermStack.h:166
navigator navigation() const
Get navigator of term start.
Definition: COrderedIter.h:189
navigator::idx_type idx_type
Type for indices.
Definition: CTermStack.h:138
base::iterator_core iterator_core
Definition: COrderedIter.h:236
iterator_core::const_reverse_iterator const_reverse_iterator
Definition: COrderedIter.h:129
base::core_pointer core_pointer
Definition: COrderedIter.h:237
boost::shared_ptr< iterator_core > core_pointer
Definition: COrderedIter.h:139
iterator_core::deg_type deg_type
Definition: COrderedIter.h:131
base::iterator_core iterator_core
Definition: COrderedIter.h:212
const_iterator end() const
Definition: COrderedIter.h:181
CTermStackBase< NavigatorType, self > iterator_core
Definition: COrderedIter.h:39
CGenericOrderedIter(NavigatorType navi, const MgrType &mgr)
Definition: COrderedIter.h:242
const_reverse_iterator rend() const
Definition: COrderedIter.h:183
virtual ~CAbstractStackBase()
Definition: COrderedIter.h:45
core_pointer copy() const
Definition: COrderedIter.h:71
iterator_core::idx_type idx_type
Definition: COrderedIter.h:132
navigator::size_type size_type
Type for lengths.
Definition: CTermStack.h:141
bool equal(const self &rhs) const
Definition: COrderedIter.h:152
CWrappedStack(const self &rhs)
Definition: COrderedIter.h:68
base::term_generator term_generator
Definition: COrderedIter.h:215
COrderedIter< NavigatorType, MonomType > base
Definition: COrderedIter.h:211
~COrderedIter()
Definition: COrderedIter.h:150
This class defines an iterator for the monomials in a Boolean polynomial.
Definition: CTermStack.h:126
Definition: COrderedIter.h:51
bool_type isEnd() const
Check, whether end of iteration is reached.
Definition: COrderedIter.h:172
boost::shared_ptr< iterator_core > core_pointer
Definition: COrderedIter.h:40
base::iterator_core iterator_core
Definition: COrderedIter.h:59
const_reverse_iterator rbegin() const
Definition: COrderedIter.h:182
CAbstractStackBase< NavigatorType > stack_base
Definition: COrderedIter.h:230
bool bool_type
Extract plain Boolean type.
Definition: COrderedIter.h:142
const_iterator begin() const
Definition: COrderedIter.h:180
Definition: COrderedIter.h:203
bool_type isZero() const
Determine whether term is zero (without explicit constructing)
Definition: COrderedIter.h:169
bool_type isOne() const
Determine whether term is one (without explicit constructing)
Definition: COrderedIter.h:166
CGenericOrderedIter(NavigatorType navi, const MgrType &gen)
Definition: COrderedIter.h:218
navigator::deg_type deg_type
Definition: CTermStack.h:142