Merge

[satune.git] / src / AST / table.cc

diff --git a/src/AST/table.cc b/src/AST/table.cc
index 3e8832784803ac64223d57421138eeb2bb53a259..838a53a2e641f6a64e98f003f4336f477ad4c432 100644 (file)
--- a/src/AST/table.cc
+++ b/src/AST/table.cc
@@ -4,10 +4,13 @@
 #include "tableentry.h"
 #include "set.h"
 #include "mutableset.h"
+#include "csolver.h"
+#include "serializer.h"
 
-Table::Table(Set **_domains, uint numDomain, Set *_range) : range(_range) {
-       initArrayInitSet(&domains, _domains, numDomain);
-       entries = allocHashSetTableEntry(HT_INITIAL_CAPACITY, HT_DEFAULT_FACTOR);
+Table::Table(Set **_domains, uint numDomain, Set *_range) :
+       domains(_domains, numDomain),
+       range(_range) {
+       entries = new HashsetTableEntry();
 }
 
 void Table::addNewTableEntry(uint64_t *inputs, uint inputSize, uint64_t result) {
@@ -16,24 +19,81 @@ void Table::addNewTableEntry(uint64_t *inputs, uint inputSize, uint64_t result)
                ASSERT(result == true || result == false);
 #endif
        TableEntry *tb = allocTableEntry(inputs, inputSize, result);
-       bool status = addHashSetTableEntry(entries, tb);
+       bool status = entries->add(tb);
        ASSERT(status);
 }
 
-TableEntry * Table::getTableEntry(uint64_t *inputs, uint inputSize) {
+TableEntry *Table::getTableEntry(uint64_t *inputs, uint inputSize) {
        TableEntry *temp = allocTableEntry(inputs, inputSize, -1);
-       TableEntry *result = getHashSetTableEntry(entries, temp);
+       TableEntry *result = entries->get(temp);
        deleteTableEntry(temp);
        return result;
 }
 
+Table *Table::clone(CSolver *solver, CloneMap *map) {
+       Table *t = (Table *) map->get(this);
+       if (t != NULL)
+               return t;
+       Set *array[domains.getSize()];
+       for (uint i = 0; i < domains.getSize(); i++) {
+               array[i] = domains.get(i)->clone(solver, map);
+       }
+       Set *rcopy = range != NULL ? range->clone(solver, map) : NULL;
+       t = solver->createTable(array, domains.getSize(), rcopy);
+       SetIteratorTableEntry *entryit = entries->iterator();
+       while (entryit->hasNext()) {
+               TableEntry *te = entryit->next();
+               solver->addTableEntry(t, &te->inputs[0], te->inputSize, te->output);
+       }
+       delete entryit;
+       map->put(this, t);
+       return t;
+}
+
 Table::~Table() {
-       deleteInlineArraySet(&domains);
-       HSIteratorTableEntry *iterator = iteratorTableEntry(entries);
-       while (hasNextTableEntry(iterator)) {
-               deleteTableEntry(nextTableEntry(iterator));
+       SetIteratorTableEntry *iterator = entries->iterator();
+       while (iterator->hasNext()) {
+               deleteTableEntry(iterator->next());
+       }
+       delete iterator;
+       delete entries;
+}
+
+
+
+void Table::serialize(Serializer* serializer){
+       if(serializer->isSerialized(this))
+               return;
+       serializer->addObject(this);
+       
+       uint size = domains.getSize();
+       for(uint i=0; i<size; i++){
+               Set* domain = domains.get(i);
+               domain->serialize(serializer);
        }
-       deleteIterTableEntry(iterator);
-       deleteHashSetTableEntry(entries);
+       if(range!= NULL)
+               range->serialize(serializer);
+       
+       ASTNodeType type = TABLETYPE;   
+       serializer->mywrite(&type, sizeof(ASTNodeType));
+       Table* This = this;
+       serializer->mywrite(&This, sizeof(Table*));
+       serializer->mywrite(&size, sizeof(uint));
+       for(uint i=0; i<size; i++){
+               Set* domain = domains.get(i);
+               serializer->mywrite(&domain, sizeof(Set*));
+       }
+       serializer->mywrite(&range, sizeof(Set*));
+       size = entries->getSize();
+       serializer->mywrite(&size, sizeof(uint));
+       SetIteratorTableEntry* iterator = getEntries();
+       while(iterator->hasNext()){
+               TableEntry* entry = iterator->next();
+               serializer->mywrite(&entry->output, sizeof(uint64_t));
+               serializer->mywrite(&entry->inputSize, sizeof(uint));
+               serializer->mywrite(entry->inputs, sizeof(uint64_t) * entry->inputSize);
+       }
+       delete iterator;
 }
 
+