src/Serialize/serializer.cc

   1
   2 /*
   3  * File:   serializer.cc
   4  * Author: hamed
   5  *
   6  * Created on September 7, 2017, 3:38 PM
   7  */
   8
   9 #include "serializer.h"
  10 #include "unistd.h"
  11 #include "fcntl.h"
  12 #include "boolean.h"
  13
  14 #define SERIALBUFFERLENGTH 4096
  15
  16 Serializer::Serializer(const char *file) :
  17         buffer((char *) ourmalloc(SERIALBUFFERLENGTH)),
  18         bufferoffset(0),
  19         bufferlength(SERIALBUFFERLENGTH) {
  20         filedesc = open(file, O_WRONLY | O_CREAT | O_TRUNC, 0666);
  21         if (filedesc < 0) {
  22                 exit(-1);
  23         }
  24 }
  25
  26 void Serializer::flushBuffer() {
  27         ssize_t datatowrite = bufferoffset;
  28         ssize_t index = 0;
  29         while(datatowrite) {
  30                 ssize_t byteswritten = write(filedesc, &buffer[index], datatowrite);
  31                 if (byteswritten == -1)
  32                         exit(-1);
  33                 datatowrite -= byteswritten;
  34                 index += byteswritten;
  35         }
  36         bufferoffset=0;
  37 }
  38
  39 Serializer::~Serializer() {
  40         flushBuffer();
  41         if (-1 == close(filedesc)) {
  42                 exit(-1);
  43         }
  44         ourfree(buffer);
  45 }
  46
  47 void Serializer::mywrite(const void *__buf, size_t __n) {
  48         char *towrite=(char *) __buf;
  49         if (__n > SERIALBUFFERLENGTH *2) {
  50                 if (bufferoffset != 0)
  51                         flushBuffer();
  52                 while (__n > 0) {
  53                         ssize_t result=write(filedesc, &towrite, __n);
  54                         if (result != (ssize_t) __n)
  55                                 exit(-1);
  56                         towrite += result;
  57                         __n -= result;
  58                 }
  59         } else {
  60                 do  {
  61                         uint spacefree = bufferlength-bufferoffset;
  62                         uint datatowrite = spacefree > __n ? __n : spacefree;
  63                         memcpy(&buffer[bufferoffset], towrite, datatowrite);
  64                         bufferoffset += datatowrite;
  65
  66                         if (spacefree < __n) {
  67                                 flushBuffer();
  68                                 __n -= datatowrite;
  69                                 towrite += datatowrite;
  70                         } else if (spacefree == __n) {
  71                                 flushBuffer();
  72                                 return;
  73                         } else {
  74                                 return;
  75                         }
  76                 } while(true);
  77         }
  78 }
  79
  80
  81 void serializeBooleanEdge(Serializer *serializer, BooleanEdge be, bool isTopLevel) {
  82         if (be == BooleanEdge(NULL)) {
  83                 return;
  84         }
  85         be.getBoolean()->serialize(serializer);
  86         ASTNodeType type = BOOLEANEDGE;
  87         serializer->mywrite(&type, sizeof(ASTNodeType));
  88         Boolean *boolean = be.getRaw();
  89         serializer->mywrite(&boolean, sizeof(Boolean *));
  90         serializer->mywrite(&isTopLevel, sizeof(bool));
  91 }