src/Serialize/deserializer.cc

   1
   2 /*
   3  * File:   deserializer.cc
   4  * Author: hamed
   5  *
   6  * Created on September 7, 2017, 6:08 PM
   7  */
   8
   9 #include "deserializer.h"
  10 #include "csolver.h"
  11 #include "unistd.h"
  12 #include "fcntl.h"
  13
  14 Deserializer::Deserializer(const char* file):
  15         solver(new CSolver())
  16 {
  17         filedesc = open(file, O_RDONLY);
  18
  19         if (filedesc < 0) {
  20                 exit(-1);
  21         }
  22 }
  23
  24 Deserializer::~Deserializer() {
  25         delete solver;
  26 }
  27
  28 ssize_t Deserializer::myread(void* __buf, size_t __nbytes){
  29         return read (filedesc, __buf, __nbytes);
  30 }
  31
  32 CSolver * Deserializer::deserialize(){
  33         ASTNodeType nodeType;
  34         while(myread(&nodeType, sizeof(ASTNodeType) ) >0){
  35                 switch(nodeType){
  36                         case BOOLEANEDGE:
  37                                 deserializeBooleanEdge();
  38                                 break;
  39                         case BOOLEANVAR:
  40                                 deserializeBooleanVar();
  41                                 break;
  42                         case ORDERCONST:
  43                                 deserializeBooleanOrder();
  44                                 break;
  45                         case ORDERTYPE:
  46                                 deserializeOrder();
  47                                 break;
  48                         case SETTYPE:
  49                                 deserializeSet();
  50                                 break;
  51                         default:
  52                                 ASSERT(0);
  53                 }
  54         }
  55         return solver;
  56 }
  57
  58 void Deserializer::deserializeBooleanEdge(){
  59         Boolean *b;
  60         myread(&b, sizeof(Boolean*));
  61         BooleanEdge tmp(b);
  62         bool isNegated = tmp.isNegated();
  63         ASSERT(map.contains(tmp.getBoolean()));
  64         b = (Boolean*) map.get(tmp.getBoolean());
  65         BooleanEdge res(b);
  66         solver->addConstraint(isNegated?res.negate():res);
  67 }
  68
  69 void Deserializer::deserializeBooleanVar(){
  70         BooleanVar *b;
  71         myread(&b, sizeof(BooleanVar*));
  72         VarType vtype;
  73         myread(&vtype, sizeof(VarType));
  74         map.put(b, solver->getBooleanVar(vtype).getBoolean());
  75 }
  76
  77 void Deserializer::deserializeBooleanOrder(){
  78         BooleanOrder* bo_ptr;
  79         myread(&bo_ptr, sizeof(BooleanOrder*));
  80         Order* optr;
  81         myread(&optr, sizeof(Order*));
  82         uint64_t first;
  83         myread(&first, sizeof(uint64_t));
  84         uint64_t second;
  85         myread(&second, sizeof(uint64_t));
  86         ASSERT(map.contains(optr));
  87         Order* order  = (Order*) map.get(optr);
  88         map.put(bo_ptr, solver->orderConstraint(order, first, second).getBoolean());
  89 }
  90
  91 void Deserializer::deserializeOrder(){
  92         Order* o_ptr;
  93         myread(&o_ptr, sizeof(Order*));
  94         OrderType type;
  95         myread(&type, sizeof(OrderType));
  96         Set * set_ptr;
  97         myread(&set_ptr, sizeof(Set *));
  98         ASSERT(map.contains(set_ptr));
  99         Set* set  = (Set*) map.get(set_ptr);
 100         map.put(o_ptr, solver->createOrder(type, set));
 101 }
 102
 103 void Deserializer::deserializeSet(){
 104         Set *s_ptr;
 105         myread(&s_ptr, sizeof(Set*));
 106         VarType type;
 107         myread(&type, sizeof(VarType));
 108         bool isRange;
 109         myread(&isRange, sizeof(bool));
 110         uint64_t low;
 111         myread(&low, sizeof(uint64_t));
 112         uint64_t high;
 113         myread(&high, sizeof(uint64_t));
 114         uint size;
 115         myread(&size, sizeof(uint));
 116         Vector<uint64_t> members;
 117         for(uint i=0; i<size; i++){
 118                 uint64_t mem;
 119                 myread(&mem, sizeof(uint64_t));
 120                 members.push(mem);
 121         }
 122         Set *set = isRange? solver->createRangeSet(type, low, high):
 123                 solver->createSet(type, members.expose(), size);
 124         map.put(s_ptr, set);
 125 }