Bug fix: typos

[satune.git] / src / Serialize / serializer.cc

diff --git a/src/Serialize/serializer.cc b/src/Serialize/serializer.cc
index 301a312dd85924b6deed60bdb3cba74519a8527d..35bae4c5559c2c48069b750d81580f7a76d6e377 100644 (file)
--- a/src/Serialize/serializer.cc
+++ b/src/Serialize/serializer.cc
@@ -1,42 +1,91 @@
 
-/* 
+/*
  * File:   serializer.cc
  * Author: hamed
- * 
+ *
  * Created on September 7, 2017, 3:38 PM
  */
 
 #include "serializer.h"
 #include "unistd.h"
 #include "fcntl.h"
+#include "boolean.h"
 
-Serializer::Serializer(const char *file) {
-       filedesc = open(file, O_WRONLY | O_CREAT, 0666);
- 
+#define SERIALBUFFERLENGTH 4096
+
+Serializer::Serializer(const char *file) :
+       buffer((char *) ourmalloc(SERIALBUFFERLENGTH)),
+       bufferoffset(0),
+       bufferlength(SERIALBUFFERLENGTH) {
+       filedesc = open(file, O_WRONLY | O_CREAT | O_TRUNC, 0666);
        if (filedesc < 0) {
                exit(-1);
        }
 }
 
+void Serializer::flushBuffer() {
+       ssize_t datatowrite = bufferoffset;
+       ssize_t index = 0;
+       while (datatowrite) {
+               ssize_t byteswritten = write(filedesc, &buffer[index], datatowrite);
+               if (byteswritten == -1)
+                       exit(-1);
+               datatowrite -= byteswritten;
+               index += byteswritten;
+       }
+       bufferoffset = 0;
+}
+
 Serializer::~Serializer() {
-       if (-1 == close(filedesc)){
+       flushBuffer();
+       if (-1 == close(filedesc)) {
                exit(-1);
        }
+       ourfree(buffer);
 }
 
-void Serializer::mywrite(const void *__buf, size_t __n){
-       write (1, __buf, __n);
-       model_print("\n");
-       write (filedesc, __buf, __n);
+void Serializer::mywrite(const void *__buf, size_t __n) {
+       char *towrite = (char *) __buf;
+       if (__n > SERIALBUFFERLENGTH * 2) {
+               if (bufferoffset != 0)
+                       flushBuffer();
+               while (__n > 0) {
+                       ssize_t result = write(filedesc, &towrite, __n);
+                       if (result != (ssize_t) __n)
+                               exit(-1);
+                       towrite += result;
+                       __n -= result;
+               }
+       } else {
+               do  {
+                       uint spacefree = bufferlength - bufferoffset;
+                       uint datatowrite = spacefree > __n ? __n : spacefree;
+                       memcpy(&buffer[bufferoffset], towrite, datatowrite);
+                       bufferoffset += datatowrite;
+
+                       if (spacefree < __n) {
+                               flushBuffer();
+                               __n -= datatowrite;
+                               towrite += datatowrite;
+                       } else if (spacefree == __n) {
+                               flushBuffer();
+                               return;
+                       } else {
+                               return;
+                       }
+               } while (true);
+       }
 }
 
 
-void serializeBooleanEdge(Serializer* serializer, BooleanEdge& be){
-       if(serializer->isSerialized(be.getRaw()))
+void serializeBooleanEdge(Serializer *serializer, BooleanEdge be, bool isTopLevel) {
+       if (be == BooleanEdge(NULL)) {
                return;
-       serializer->addObject(be.getRaw());
-//     b->seralize(serializer);
+       }
+       be.getBoolean()->serialize(serializer);
        ASTNodeType type = BOOLEANEDGE;
        serializer->mywrite(&type, sizeof(ASTNodeType));
-       serializer->mywrite(be.getRaw(), sizeof(Boolean*));
-}
\ No newline at end of file
+       Boolean *boolean = be.getRaw();
+       serializer->mywrite(&boolean, sizeof(Boolean *));
+       serializer->mywrite(&isTopLevel, sizeof(bool));
+}