Serializable ReferenceSpace

FunctionSpace/PermutationTree.cpp

@@ -8,7 +8,7 @@
 
 using namespace std;
 
-PermutationTree::PermutationTree(const vector<size_t>& refSequence){
+PermutationTree::PermutationTree(const std::vector<size_t>& refSequence){
   // Sequence size //
   sequenceSize = refSequence.size();
 
@@ -42,7 +42,7 @@ PermutationTree::PermutationTree(const char* stream){
   populateFromStream(stream);
 }
 
-PermutationTree::PermutationTree(const string& path){
+PermutationTree::PermutationTree(const std::string& path){
   // Read file //
   // Open Stream
   ifstream input;
@@ -68,7 +68,7 @@ PermutationTree::PermutationTree(const string& path){
 }
 
 void PermutationTree::populate(node_t* node,
-                               list<node_t*>& listOfLeaf){
+                               std::list<node_t*>& listOfLeaf){
   // Node Id //
   node->nodeId = nextNodeId;
   nextNodeId++;
@@ -176,7 +176,7 @@ void PermutationTree::unserialize(const char* stream, unlink_t* unlink){
          stream + otherIdStart + 2 * sizeof(size_t), sizeof(size_t));
 }
 
-void PermutationTree::rebuild(vector<unlink_t>& unlink){
+void PermutationTree::rebuild(std::vector<unlink_t>& unlink){
   // Almost linked nodes (node of node_t type but without connected nodes) //
   vector<node_t*> node(nextNodeId);
   for(size_t i = 0; i < nextNodeId; i++)
@@ -237,7 +237,7 @@ void PermutationTree::destroy(node_t* node){
 
 PermutationTree::node_t*
 PermutationTree::getLeaf(node_t* root,
-                         const vector<size_t>& sequence,
+                         const std::vector<size_t>& sequence,
                          size_t offset){
   // Number of son
   const size_t nSon = root->son.size();
@@ -262,8 +262,9 @@ PermutationTree::getLeaf(node_t* root,
   }
 }
 
-void PermutationTree::fillWithPermutation(size_t permutationId,
-                                          vector<size_t>& vectorToFill) const{
+void
+PermutationTree::fillWithPermutation(size_t permutationId,
+                                     std::vector<size_t>& vectorToFill) const{
   // Go from ith leaf to root                //
   // And fill vectorToFill from end to start //
 
@@ -400,7 +401,7 @@ std::pair<size_t, char*> PermutationTree::serialize(void) const{
   return pair<size_t, char*>(sSize, stream);
 }
 
-void PermutationTree::serialize(const string& path) const{
+void PermutationTree::serialize(const std::string& path) const{
   // Serialize into byte Stream
   std::pair<size_t, char*> stream  = serialize();
 

FunctionSpace/PermutationTree.h

@@ -123,7 +123,7 @@ class PermutationTree{
    @see PermutationTree:serialize(char*)
    **
 
-   @fn PermutationTree::PermutationTree(std::string path)
+   @fn PermutationTree::PermutationTree(const std::string& path)
    @param path A file path
 
    Instanciates a new PermutationTree by loading the file given in path
@@ -195,7 +195,7 @@ class PermutationTree{
    @return Returns a string describing this PermutationTree
    **
 
-   @fn PermutationTree::serialize(void)
+   @fn PermutationTree::serialize(void) const
 
    Serialize this PermutationTree into a byte stream
 
@@ -204,7 +204,7 @@ class PermutationTree{
    @li the second entry is a pointer to the allocated stream
    **
 
-   @fn PermutationTree::serialize(const std::string&)
+   @fn PermutationTree::serialize(const std::string&) const
    @param path A file path
 
    Serialize this PermutationTree into the given file path

FunctionSpace/ReferenceSpace.cpp

 #include <algorithm>
+#include <fstream>
 #include <sstream>
+#include <cstring>
 #include <set>
 
 #include "Exception.h"
@@ -13,6 +15,31 @@ ReferenceSpace::ReferenceSpace(void){
   // Derived Class                 //
 }
 
+ReferenceSpace::ReferenceSpace(const std::string& path){
+  // Read file //
+  // Open Stream
+  ifstream input;
+  input.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+  input.open(path.c_str(), std::ifstream::binary);
+
+  // Get size of stream (go to stream end)
+  input.seekg(0, std::ifstream::end);
+  const size_t size = input.tellg();
+
+  // Reset stream possition
+  input.seekg(0, std::ifstream::beg);
+
+  // Alloc byte stream & Read file
+  char* stream = new char[size];
+  input.read(stream, size);
+
+  // Init from stream
+  init(stream);
+
+  // Free stream
+  delete[] stream;
+}
+
 ReferenceSpace::~ReferenceSpace(void){
   delete pTree;
 }
@@ -68,6 +95,40 @@ void ReferenceSpace::init(void){
   getOrderedFace();
 }
 
+void ReferenceSpace::init(const char* stream){
+  // nVector
+  size_t offset = 0;
+
+  memcpy(&nVertex, stream + offset, sizeof(size_t));
+  offset += sizeof(size_t);
+
+  // Fef {Edge, Face} Node Idx
+  offset += unserialize(stream + offset, refEdgeNodeIdx);
+  offset += unserialize(stream + offset, refFaceNodeIdx);
+
+  // Permutation Tree
+  size_t tSize; // Tree Size
+
+  memcpy(&tSize, stream + offset, sizeof(size_t));
+  offset += sizeof(size_t);
+
+  pTree = new PermutationTree(stream + offset);
+  offset += tSize;
+
+  // RefSpace Node Id
+  offset += unserialize(stream + offset, refSpaceNodeId);
+
+  // Index mapping
+  offset += unserialize(stream + offset, ABCtoUVWIndex);
+  offset += unserialize(stream + offset, UVWtoABCIndex);
+
+  // Oredered {Edge, Face} Node Idx
+  offset += unserialize(stream + offset, orderedEdgeNodeIdx);
+  offset += unserialize(stream + offset, orderedFaceNodeIdx);
+
+  cout << offset << endl;
+}
+
 void ReferenceSpace::
 findCyclicPermutation(list<size_t>&          listOfTrueReferenceSpace,
                       list<vector<size_t> >& listOfRefNodeIndexPermutation,
@@ -844,3 +905,277 @@ string ReferenceSpace::toLatex(void) const{
 
   return stream.str();
 }
+
+std::pair<size_t, char*> ReferenceSpace::serialize(void) const{
+  // Serialize //
+  // refEdgeNodeIdx
+  pair<size_t, char*> sRefEdgeIdx = serialize(refEdgeNodeIdx);
+
+  // refFaceNodeIdx
+  pair<size_t, char*> sRefFaceIdx = serialize(refFaceNodeIdx);
+
+  // PermutationTree
+  pair<size_t, char*> sPTree = pTree->serialize();
+
+  // Reference Space
+  pair<size_t, char*> sRSpace = serialize(refSpaceNodeId);
+
+  // ABCtoUVW
+  pair<size_t, char*> sABCtoUVW = serialize(ABCtoUVWIndex);
+
+  // UVWtoUVW
+  pair<size_t, char*> sUVWtoABC = serialize(UVWtoABCIndex);
+
+  // orderedEdgeNodeIdx
+  pair<size_t, char*> sEdgeIdx = serialize(orderedEdgeNodeIdx);
+
+  // orderedEdgeNodeIdx
+  pair<size_t, char*> sFaceIdx = serialize(orderedFaceNodeIdx);
+
+  // Full Serialized Stream //
+  // Alloc (+ 1 * sizeof(size_t) for nVertex)
+  const size_t size = sizeof(size_t) + sRefEdgeIdx.first
+                                     + sRefFaceIdx.first
+                                     + sizeof(size_t) // pTree Size
+                                     + sPTree.first   // pTree
+                                     + sRSpace.first
+                                     + sABCtoUVW.first
+                                     + sUVWtoABC.first
+                                     + sEdgeIdx.first
+                                     + sFaceIdx.first;
+  char* stream = new char[size];
+
+  // Populate
+  size_t offset = 0;
+
+  memcpy(stream + offset, &nVertex, sizeof(size_t));
+  offset += sizeof(size_t);
+
+  memcpy(stream + offset, sRefEdgeIdx.second, sRefEdgeIdx.first);
+  offset += sRefEdgeIdx.first;
+
+  memcpy(stream + offset, sRefFaceIdx.second, sRefFaceIdx.first);
+  offset += sRefFaceIdx.first;
+
+  memcpy(stream + offset, &sPTree.first, sizeof(size_t)); // pTree size
+  offset += sizeof(size_t);
+
+  memcpy(stream + offset, sPTree.second, sPTree.first);   // pTree
+  offset += sPTree.first;
+
+  memcpy(stream + offset, sRSpace.second, sRSpace.first);
+  offset += sRSpace.first;
+
+  memcpy(stream + offset, sABCtoUVW.second, sABCtoUVW.first);
+  offset += sABCtoUVW.first;
+
+  memcpy(stream + offset, sUVWtoABC.second, sABCtoUVW.first);
+  offset += sABCtoUVW.first;
+
+  memcpy(stream + offset, sEdgeIdx.second, sEdgeIdx.first);
+  offset += sEdgeIdx.first;
+
+  memcpy(stream + offset, sFaceIdx.second, sFaceIdx.first);
+  offset += sFaceIdx.first;
+
+  // Free Temp
+  delete[] sRefEdgeIdx.second;
+  delete[] sRefFaceIdx.second;
+  delete[] sPTree.second;
+  delete[] sRSpace.second;
+  delete[] sABCtoUVW.second;
+  delete[] sUVWtoABC.second;
+  delete[] sEdgeIdx.second;
+  delete[] sFaceIdx.second;
+
+  // Return
+  return pair<size_t, char*>(size, stream);
+}
+
+void ReferenceSpace::serialize(const std::string& path) const{
+  // Serialize into byte Stream
+  std::pair<size_t, char*> stream  = serialize();
+
+  // Write byte stream
+  ofstream output;
+  output.exceptions(std::ofstream::failbit | std::ofstream::badbit);
+  output.open(path.c_str(), std::ofstream::binary);
+  output.write(stream.second, stream.first);
+  output.close();
+
+  // Free
+  delete[] stream.second;
+}
+
+std::pair<size_t, char*> ReferenceSpace::
+serialize(const std::vector<std::vector<size_t> >& source){
+  // Vector & Stream size //
+  size_t nVector   = source.size();
+  size_t totalSize = sizeof(size_t); // Init to header size (nVector)
+
+  for(size_t i = 0; i < nVector; i++)
+    totalSize += (source[i].size() + 1) * sizeof(size_t);
+                                // + 1 for subvector size header
+
+  // Alloc Stream //
+  char* stream = new char[totalSize];
+
+  // Header (nVector) //
+  memcpy(stream, &nVector, sizeof(size_t));
+
+  // SubVectors //
+  size_t tmpSize;
+  size_t offset = sizeof(size_t);
+
+  for(size_t i = 0; i < nVector; i++){
+    // SubVector size
+    tmpSize = source[i].size();
+    memcpy(stream + offset, &tmpSize, sizeof(size_t));
+    offset += sizeof(size_t);
+
+    // SubVector stored values
+    for(size_t j = 0; j < tmpSize; j++){
+      memcpy(stream + offset, &source[i][j], sizeof(size_t));
+      offset += sizeof(size_t);
+    }
+  }
+
+  // Return //
+  return pair<size_t, char*>(totalSize, stream);
+}
+
+std::pair<size_t, char*> ReferenceSpace::
+serialize(const std::vector<std::vector<std::vector<size_t> > >& source){
+  // Vector & Stream size //
+  size_t nVector   = source.size();
+  size_t totalSize = sizeof(size_t); // Init to header size (nVector)
+
+  for(size_t i = 0; i < nVector; i++){
+    totalSize += sizeof(size_t); // Subvector size header
+
+    for(size_t j = 0; j < source[i].size(); j++)
+      totalSize += (source[i][j].size() + 1) * sizeof(size_t);
+                                     // + 1 for subsubvector size header
+  }
+
+  // Alloc Stream //
+  char* stream = new char[totalSize];
+
+  // Header (nVector) //
+  memcpy(stream, &nVector, sizeof(size_t));
+
+  // SubVectors //
+  size_t tmpSize;
+  size_t tmpSubSize;
+  size_t offset = sizeof(size_t);
+
+  for(size_t i = 0; i < nVector; i++){
+    // SubVector size
+    tmpSize = source[i].size();
+    memcpy(stream + offset, &tmpSize, sizeof(size_t));
+    offset += sizeof(size_t);
+
+    for(size_t j = 0; j < tmpSize; j++){
+      // SubSubVector size
+      tmpSubSize = source[i][j].size();
+      memcpy(stream + offset, &tmpSubSize, sizeof(size_t));
+      offset += sizeof(size_t);
+
+      // SubSubVector stored values
+      for(size_t k = 0; k < tmpSubSize; k++){
+        memcpy(stream + offset, &source[i][j][k], sizeof(size_t));
+        offset += sizeof(size_t);
+      }
+    }
+  }
+
+  // Return //
+  return pair<size_t, char*>(totalSize, stream);
+}
+
+size_t ReferenceSpace::
+unserialize(const char* stream,
+            std::vector<std::vector<size_t> >& dest){
+  // Vector size //
+  size_t nVector;
+  size_t offset = 0;
+
+  memcpy(&nVector, stream + offset, sizeof(size_t));
+  offset += sizeof(size_t);
+
+  // Alloc Vector //
+  dest.resize(nVector);
+
+  // Populate //
+  size_t tmpSize;
+  size_t tmpVal;
+
+  for(size_t i = 0; i < nVector; i++){
+    // Subvector size
+    memcpy(&tmpSize, stream + offset, sizeof(size_t));
+    offset += sizeof(size_t);
+
+    // Alloc Subvector
+    dest[i].resize(tmpSize);
+
+    // Populate Subvector
+    for(size_t j = 0; j < tmpSize; j++){
+      memcpy(&tmpVal, stream + offset, sizeof(size_t));
+      offset += sizeof(size_t);
+
+      dest[i][j] = tmpVal;
+    }
+  }
+
+  // Return size //
+  return offset;
+}
+
+size_t ReferenceSpace::
+    unserialize(const char* stream,
+                std::vector<std::vector<std::vector<size_t> > >& dest){
+  // Vector size //
+  size_t nVector;
+  size_t offset = 0;
+
+  memcpy(&nVector, stream + offset, sizeof(size_t));
+  offset += sizeof(size_t);
+
+  // Alloc Vector //
+  dest.resize(nVector);
+
+  // Populate //
+  size_t tmpSize;
+  size_t tmpSubSize;
+  size_t tmpVal;
+
+  for(size_t i = 0; i < nVector; i++){
+    // Subvector size
+    memcpy(&tmpSize, stream + offset, sizeof(size_t));
+    offset += sizeof(size_t);
+
+    // Alloc Subvector
+    dest[i].resize(tmpSize);
+
+    // Populate Subvector
+    for(size_t j = 0; j < tmpSize; j++){
+      // Subsubvector size
+      memcpy(&tmpSubSize, stream + offset, sizeof(size_t));
+      offset += sizeof(size_t);
+
+      // Alloc Subsubvector
+      dest[i][j].resize(tmpSubSize);
+
+      // Populate Subsubvector
+      for(size_t k = 0; k < tmpSubSize; k++){
+        memcpy(&tmpVal, stream + offset,sizeof(size_t));
+        offset += sizeof(size_t);
+
+        dest[i][j][k] = tmpVal; // AT LAST !! (-:
+      }
+    }
+  }
+
+  // Return size //
+  return offset;
+}

FunctionSpace/ReferenceSpace.h

@@ -16,6 +16,8 @@
    This class represents the notion of Reference Space.
    A Reference Space is the set of all the permutations
    of the reference element of a particular geometrical entity.
+
+   @todo End ReferenceSpace DOC !!!
  */
 
 class ReferenceSpace{
@@ -56,6 +58,7 @@ class ReferenceSpace{
   std::vector<std::vector<std::vector<size_t> > > orderedFaceNodeIdx;
 
  public:
+  ReferenceSpace(const std::string& path);
   virtual ~ReferenceSpace(void);
 
   size_t getNReferenceSpace(void) const;
@@ -93,10 +96,14 @@ class ReferenceSpace{
   virtual std::string toString(void) const;
   virtual std::string toLatex(void) const;
 
+  std::pair<size_t, char*> serialize(void) const;
+  void                     serialize(const std::string& path) const;
+
  protected:
   ReferenceSpace(void);
 
   void init(void);
+  void init(const char* stream);
 
  private:
   void getOrderedEdge(void);
@@ -147,16 +154,36 @@ class ReferenceSpace{
                             const std::pair<size_t, size_t>& b);
 
   static void regularize(size_t dim, fullMatrix<double>& jac);
+
+  static std::pair<size_t, char*>
+    serialize(const std::vector<std::vector<size_t> >& source);
+
+  static std::pair<size_t, char*>
+    serialize(const std::vector<std::vector<std::vector<size_t> > >& source);
+
+  static size_t
+    unserialize(const char* stream,
+                std::vector<std::vector<size_t> >& dest);
+
+  static size_t
+    unserialize(const char* stream,
+                std::vector<std::vector<std::vector<size_t> > >& dest);
 };
 
 
 /**
    @internal
-   @fn ReferenceSpace::ReferenceSpace
+   @fn ReferenceSpace::ReferenceSpace(void)
    Instatiate a new ReferenceSpace
    @endinternal
    **
 
+   @fn ReferenceSpace::ReferenceSpace(const std::string&)
+   @param path A file path
+
+   Instanciates a new ReferenceSpace by loading the file in the given path
+   **
+
    @fn ReferenceSpace::~ReferenceSpace
    Deletes this ReferenceSpace
    **
@@ -201,6 +228,22 @@ class ReferenceSpace{
 
    @fn ReferenceSpace::toLatex
    @return Returns a string (of a Latex file) describing this ReferenceSpace
+   **
+
+   @fn ReferenceSpace::serialize(void) const
+
+   Serialize this ReferenceSpace into a byte stream
+
+   @return Returns a pair such that:
+   @li The first entry is the byte stream size
+   @li The second entry is a pointer the allocated byte stream
+   **
+
+   @fn ReferenceSpace::serialize(const std::string&) const
+   @param path A file path
+
+   Serialize this ReferenceSpace into the given file
+   **
  */
 
 //////////////////////