src/ccsolver.cc

   1 #include "csolver.h"
   2 #include "ccsolver.h"
   3
   4 #define CCSOLVER(solver) ((CSolver *)solver)
   5
   6 void *createCCSolver() {
   7         return (void *) new CSolver();
   8 }
   9 void deleteCCSolver(void *solver) {
  10         delete CCSOLVER(solver);
  11 }
  12
  13 void resetCCSolver(void *solver) {
  14         CCSOLVER(solver)->resetSolver();
  15 }
  16
  17 void *createSet(void *solver,unsigned int type, long *elements, unsigned int num) {
  18         return CCSOLVER(solver)->createSet((VarType) type, (uint64_t *)elements, (uint) num);
  19 }
  20
  21 void *createRangeSet(void *solver,unsigned int type, long lowrange, long highrange) {
  22         return CCSOLVER(solver)->createRangeSet((VarType) type, (uint64_t) lowrange, (uint64_t) highrange);
  23 }
  24
  25 void *createRangeVar(void *solver,unsigned int type, long lowrange, long highrange) {
  26         return CCSOLVER(solver)->createRangeVar((VarType) type, (uint64_t) lowrange, (uint64_t) highrange);
  27 }
  28
  29 void *createMutableSet(void *solver,unsigned int type) {
  30         return CCSOLVER(solver)->createMutableSet((VarType) type);
  31 }
  32
  33 void addItem(void *solver,void *set, long element) {
  34         CCSOLVER(solver)->addItem((MutableSet *) set, (uint64_t) element);
  35 }
  36
  37 void finalizeMutableSet(void *solver,void *set) {
  38         CCSOLVER(solver)->finalizeMutableSet((MutableSet *) set);
  39 }
  40
  41 void *getElementVar(void *solver,void *set) {
  42         return CCSOLVER(solver)->getElementVar((Set *) set);
  43 }
  44
  45 void *getElementConst(void *solver,unsigned int type, long value) {
  46         return CCSOLVER(solver)->getElementConst((VarType) type, (uint64_t) value);
  47 }
  48
  49 void *getElementRange (void *solver,void *element) {
  50         return CCSOLVER(solver)->getElementRange ((Element *) element);
  51 }
  52
  53 void *getBooleanVar(void *solver,unsigned int type) {
  54         return CCSOLVER(solver)->getBooleanVar((VarType) type).getRaw();
  55 }
  56
  57 void *getBooleanTrue(void *solver) {
  58         return CCSOLVER(solver)->getBooleanTrue().getRaw();
  59 }
  60
  61 void *getBooleanFalse(void *solver) {
  62         return CCSOLVER(solver)->getBooleanFalse().getRaw();
  63 }
  64
  65 void *createFunctionOperator(void *solver,unsigned int op, void *range,unsigned int overflowbehavior) {
  66         return CCSOLVER(solver)->createFunctionOperator((ArithOp) op, (Set *)range, (OverFlowBehavior) overflowbehavior);
  67 }
  68
  69 void *createPredicateOperator(void *solver,unsigned int op) {
  70         return CCSOLVER(solver)->createPredicateOperator((CompOp) op);
  71 }
  72
  73 void *createPredicateTable(void *solver,void *table, unsigned int behavior) {
  74         return CCSOLVER(solver)->createPredicateTable((Table *)table, (UndefinedBehavior) behavior);
  75 }
  76
  77 void *createTable(void *solver, void *range) {
  78         return CCSOLVER(solver)->createTable((Set *)range);
  79 }
  80
  81 void *createTableForPredicate(void *solver) {
  82         return CCSOLVER(solver)->createTableForPredicate();
  83 }
  84
  85 void addTableEntry(void *solver,void *table, void *inputs, unsigned int inputSize, long result) {
  86         CCSOLVER(solver)->addTableEntry((Table *)table, (uint64_t *)inputs, (uint) inputSize, (uint64_t) result);
  87 }
  88
  89 void *completeTable(void *solver,void *table, unsigned int behavior) {
  90         return CCSOLVER(solver)->completeTable((Table *) table, (UndefinedBehavior) behavior);
  91 }
  92
  93 void *applyFunction(void *solver,void *function, void **array, unsigned int numArrays, void *overflowstatus) {
  94         return CCSOLVER(solver)->applyFunction((Function *)function, (Element **)array, (uint) numArrays, BooleanEdge ((Boolean *)overflowstatus));
  95 }
  96
  97 void *applyPredicateTable(void *solver,void *predicate, void **inputs, unsigned int numInputs, void *undefinedStatus) {
  98         return CCSOLVER(solver)->applyPredicateTable((Predicate *)predicate, (Element **)inputs, (uint) numInputs, BooleanEdge((Boolean *) undefinedStatus)).getRaw();
  99 }
 100
 101 void *applyPredicate(void *solver,void *predicate, void **inputs, unsigned int numInputs) {
 102         return CCSOLVER(solver)->applyPredicate((Predicate *)predicate, (Element **)inputs, (uint) numInputs).getRaw();
 103 }
 104
 105 void *applyLogicalOperation(void *solver,unsigned int op, void **array, unsigned int asize) {
 106         BooleanEdge constr [asize];
 107         for (uint i = 0; i < asize; i++) {
 108                 constr[i] = BooleanEdge((Boolean *)array[i]);
 109         }
 110         return CCSOLVER(solver)->applyLogicalOperation((LogicOp) op, constr, (uint) asize).getRaw();
 111 }
 112
 113 void *applyExactlyOneConstraint(void *solver, void **array, unsigned int asize) {
 114         BooleanEdge constr [asize];
 115         for (uint i = 0; i < asize; i++) {
 116                 constr[i] = BooleanEdge((Boolean *)array[i]);
 117         }
 118         return CCSOLVER(solver)->applyExactlyOneConstraint( constr, (uint) asize).getRaw();
 119 }
 120
 121 void *applyAtMostOneConstraint(void *solver, void **array, unsigned int asize) {
 122         BooleanEdge constr [asize];
 123         for (uint i = 0; i < asize; i++) {
 124                 constr[i] = BooleanEdge((Boolean *)array[i]);
 125         }
 126         return CCSOLVER(solver)->applyAtMostOneConstraint( constr, (uint) asize).getRaw();
 127 }
 128
 129 void *applyLogicalOperationTwo(void *solver,unsigned int op, void *arg1, void *arg2) {
 130         return CCSOLVER(solver)->applyLogicalOperation((LogicOp) op, BooleanEdge((Boolean *) arg1), BooleanEdge((Boolean *) arg2)).getRaw();
 131 }
 132
 133 void *applyLogicalOperationOne(void *solver,unsigned int op, void *arg) {
 134         return CCSOLVER(solver)->applyLogicalOperation((LogicOp) op, BooleanEdge((Boolean *) arg)).getRaw();
 135 }
 136
 137 void addConstraint(void *solver,void *constraint) {
 138         CCSOLVER(solver)->addConstraint(BooleanEdge((Boolean *) constraint));
 139 }
 140
 141 void printConstraint(void *solver,void *constraint) {
 142         CCSOLVER(solver)->printConstraint(BooleanEdge((Boolean *) constraint));
 143 }
 144
 145 void *createOrder(void *solver,unsigned int type, void *set) {
 146         return CCSOLVER(solver)->createOrder((OrderType) type, (Set *)set);
 147 }
 148
 149 void *orderConstraint(void *solver,void *order, long first, long second) {
 150         return CCSOLVER(solver)->orderConstraint((Order *)order, (uint64_t) first, (uint64_t) second).getRaw();
 151 }
 152
 153 int solve(void *solver) {
 154         return CCSOLVER(solver)->solve();
 155 }
 156
 157 int solveIncremental(void *solver) {
 158         return CCSOLVER(solver)->solveIncremental();
 159 }
 160
 161 long getElementValue(void *solver,void *element) {
 162         return (long) CCSOLVER(solver)->getElementValue((Element *)element);
 163 }
 164
 165 void freezeElement(void *solver,void *element) {
 166         CCSOLVER(solver)->freezeElement((Element *)element);
 167 }
 168
 169 int getBooleanValue(void *solver, void *boolean) {
 170         return CCSOLVER(solver)->getBooleanValue(BooleanEdge((Boolean *) boolean));
 171 }
 172
 173 int getOrderConstraintValue(void *solver,void *order, long first, long second) {
 174         return CCSOLVER(solver)->getOrderConstraintValue((Order *)order, (uint64_t) first, (uint64_t) second);
 175 }
 176
 177 void printConstraints(void *solver) {
 178         CCSOLVER(solver)->printConstraints();
 179 }
 180
 181 void turnoffOptimizations(void *solver) {
 182         CCSOLVER(solver)->turnoffOptimizations();
 183 }
 184
 185
 186 void serialize(void *solver) {
 187         CCSOLVER(solver)->serialize();
 188 }
 189
 190
 191 void mustHaveValue(void *solver, void *element) {
 192         CCSOLVER(solver)->mustHaveValue( (Element *) element);
 193 }
 194
 195 void setInterpreter(void *solver, unsigned int type) {
 196         CCSOLVER(solver)->setInterpreter((InterpreterType)type);
 197 }
 198
 199 void *clone(void *solver) {
 200         return CCSOLVER(solver)->clone();
 201 }