SerialDefinitions.h

Go to the documentation of this file.

// (C) Copyright Renaud Detry   2007-2015.
// Distributed under the GNU General Public License and under the
// BSD 3-Clause License (See accompanying file LICENSE.txt).
 
/** @file */
 
#ifndef NUKLEI_SERIALDEFINITIONS_H
#define NUKLEI_SERIALDEFINITIONS_H
 
#include <nuklei/Serial.h>
#include <nuklei/BoostSerialization.h>
#include <nuklei/Match.h>
 
#include <boost/iostreams/filtering_stream.hpp>
#include <boost/iostreams/filter/gzip.hpp>
#include <boost/iostreams/device/file.hpp>
 
namespace nuklei {
  
  //const unsigned int bsFlags = 0;
  //static const unsigned int bsFlags = numify<unsigned int>(getenv("BSFLAGS"));
  
  // To compile a serialization stub, `serialize' methods have to be
  // instantiated through the whole class hierarchy, three times (once
  // for each boost archive -- xml, text, bin). This is painfully
  // slow, we no like slow, we do it once here rather than once in
  // each Product.
  
  template<typename T>
  void Serial::readObject(T &object, const std::string& filename,
                          const std::string &typeName)
  {
    NUKLEI_TRACE_BEGIN();
    Type type = typeFromName<Serial>(typeName);
    
    NUKLEI_UNIQUE_PTR<std::istream> ifs;
    if (type == BOOSTXML_COMPRESSED || type == BOOSTBIN_COMPRESSED)
    {
      {
        std::ifstream testIfs(filename.c_str());
        uint8_t byte1, byte2;
        testIfs.read((char*)(&byte1), 1);
        testIfs.read((char*)(&byte2), 1);
        if ((byte1) != 0x1f || (byte2) != 0x8b)
          throw SerialError("File does note appear to be GZIP");
      }
      NUKLEI_UNIQUE_PTR<boost::iostreams::filtering_istream>
      decompressingIfs(new boost::iostreams::filtering_istream);
      decompressingIfs->push(boost::iostreams::gzip_decompressor());
      decompressingIfs->push(boost::iostreams::file_source(filename));
      ifs = NUKLEI_MOVE(decompressingIfs);
    }
    else if (type == BOOSTXML || type == BOOSTBIN)
    {
      ifs.reset(new std::ifstream(filename.c_str()));
    }
    else throw SerialError(std::string("Unknown output format `") + typeName);
    
    NUKLEI_ASSERT(ifs->good());
    
    switch (type)
    {
      case BOOSTXML:
      case BOOSTXML_COMPRESSED:
      {
        NUKLEI_SERIALIZATION_XML_IARCHIVE ia(*ifs);
        ia & NUKLEI_SERIALIZATION_NVP(object);
        // This check always fails:
        //if (ifs->peek() != EOF) throw SerialError("EOF not reached");
        break;
      }
      case BOOSTBIN:
      case BOOSTBIN_COMPRESSED:
      {
        NUKLEI_SERIALIZATION_BINARY_IARCHIVE ia(*ifs);
        ia & NUKLEI_SERIALIZATION_NVP(object);
        if (ifs->peek() != EOF) throw SerialError("EOF not reached");
        break;
      }
      default:
      {
        throw SerialError(std::string("Unknown output format `") + typeName);
        break;
      }
    }
    NUKLEI_TRACE_END();
  }
  
  template<typename T>
  void Serial::writeObject(const T &object, const std::string& filename,
                           const std::string &typeName,
                           const int precision)
  {
    NUKLEI_TRACE_BEGIN();
    Type type = typeFromName<Serial>(typeName);
    
    NUKLEI_UNIQUE_PTR<std::ostream> ofs;
    if (type == BOOSTXML_COMPRESSED || type == BOOSTBIN_COMPRESSED)
    {
      NUKLEI_UNIQUE_PTR<boost::iostreams::filtering_ostream>
      decompressingOfs(new boost::iostreams::filtering_ostream);
      decompressingOfs->push(boost::iostreams::gzip_compressor());
      decompressingOfs->push(boost::iostreams::file_sink(filename));
      ofs = NUKLEI_MOVE(decompressingOfs);
    }
    else if (type == BOOSTXML || type == BOOSTBIN)
    {
      ofs.reset(new std::ofstream(filename.c_str()));
    }
    else throw SerialError(std::string("Unknown output format `") + typeName);
    
    NUKLEI_ASSERT(ofs->good());
    object.assertConsistency();
    
    switch (type)
    {
      case BOOSTXML:
      case BOOSTXML_COMPRESSED:
      {
        NUKLEI_SERIALIZATION_XML_OARCHIVE oa(*ofs);
        oa & NUKLEI_SERIALIZATION_NVP(object);
        break;
      }
      case BOOSTBIN:
      case BOOSTBIN_COMPRESSED:
      {
        NUKLEI_SERIALIZATION_BINARY_OARCHIVE oa(*ofs);
        oa & NUKLEI_SERIALIZATION_NVP(object);
        break;
      }
      default:
      {
        throw SerialError(std::string("Unknown output format `") + typeName + "'.");
        break;
      }
    }
    NUKLEI_TRACE_END();
  }
  
}
 
#endif