#include "iterator.h"
#include "boolean.h"
+#include "element.h"
#include "csolver.h"
BooleanIterator::BooleanIterator(CSolver * _solver) :
index.push(topindex+1);
Boolean *newchild=logicop->inputs.get(topindex).getBoolean();
if (discovered.add(newchild)) {
- boolean.push(logicop->inputs.get(topindex).getBoolean());
+ boolean.push(newchild);
index.push(0);
}
break;
updateNext();
return b;
}
+
+ElementIterator::ElementIterator(CSolver *_solver) :
+ bit(_solver),
+ base(NULL),
+ baseindex(0) {
+
+}
+
+ElementIterator::~ElementIterator() {
+}
+
+bool ElementIterator::hasNext() {
+ return element.getSize() != 0;
+}
+
+void ElementIterator::updateNext() {
+ if (element.getSize() != 0) {
+ element.pop();
+ index.pop();
+ }
+
+ while(true) {
+ if (element.getSize() == 0) {
+ if (base != NULL) {
+ if (baseindex == base->inputs.getSize()) {
+ base = NULL;
+ continue;
+ } else {
+ Element * e = base->inputs.get(baseindex);
+ baseindex++;
+ if (discovered.add(e)) {
+ element.push(e);
+ index.push(0);
+ }
+ }
+ } else {
+ if (bit.hasNext()) {
+ Boolean *b=bit.next();
+ if (b->type == PREDICATEOP) {
+ base = (BooleanPredicate *)b;
+ baseindex=0;
+ }
+ continue;
+ } else
+ return;
+ }
+ }
+ Element *topelement=element.last();
+ uint topindex=index.last();
+ switch(topelement->type) {
+ case ELEMSET:
+ case ELEMCONST:
+ return;
+ case ELEMFUNCRETURN: {
+ ElementFunction * func=(ElementFunction*) topelement;
+ uint size=func->inputs.getSize();
+ if (topindex == size)
+ return;
+ index.pop();
+ index.push(topindex+1);
+ Element *newchild=func->inputs.get(topindex);
+ if (discovered.add(newchild)) {
+ element.push(newchild);
+ index.push(0);
+ }
+ break;
+ }
+ default:
+ ASSERT(0);
+ }
+ }
+}
+
+Element * ElementIterator::next() {
+ Element * e = element.last();
+ updateNext();
+ return e;
+}
bool hasNext();
Boolean * next();
CMEMALLOC;
+
private:
SetIteratorBooleanEdge * solverit;
HashsetBoolean discovered;
class ElementIterator {
public:
+ ElementIterator(CSolver *_solver);
+ ~ElementIterator();
+ bool hasNext();
+ Element * next();
CMEMALLOC;
+
private:
BooleanIterator bit;
-};
+ BooleanPredicate *base;
+ uint baseindex;
+ HashsetElement discovered;
+
+ Vector<Element *> element;
+ Vector<uint> index;
+ void updateNext();
+};
#endif
#include "transform.h"
class Preprocess : public Transform {
- public:
- Preprocess(CSolver *_solver);
- ~Preprocess();
- void doTransform();
-
- CMEMALLOC;
-private:
- HashsetBoolean toremove;
- void processBooleanVar(BooleanVar * b);
- void resolveBooleanVars();
+ public:
+ Preprocess(CSolver *_solver);
+ ~Preprocess();
+ void doTransform();
+
+ CMEMALLOC;
+ private:
+ HashsetBoolean toremove;
+ void processBooleanVar(BooleanVar * b);
+ void resolveBooleanVars();
};
#endif
typedef Hashset<OrderEdge *, uintptr_t, PTRSHIFT, order_edge_hash_function, order_edge_equals> HashsetOrderEdge;
typedef Hashset<OrderElement *, uintptr_t, PTRSHIFT, order_element_hash_function, order_element_equals> HashsetOrderElement;
typedef Hashset<Boolean *, uintptr_t, PTRSHIFT> HashsetBoolean;
+typedef Hashset<Element *, uintptr_t, PTRSHIFT> HashsetElement;
typedef SetIterator<Boolean *, uintptr_t, PTRSHIFT> SetIteratorBoolean;
typedef Hashtable<OrderNode *, HashsetOrderNode *, uintptr_t, PTRSHIFT> HashtableNodeToNodeSet;