Boost/Serialization ‐ Portable Binary Archives (PBA)

/** tutorial_pba_0.cpp
 *
 * (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
 *
 * Use, modification and distribution is subject to the Boost Software
 * License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 *
 */

/**
 * The intent of this program is to serve as a tutorial for
 * users of the portable binary archive in the framework of 
 * the Boost/Serialization library. 
 *
 * This quick start example shows how to store some variables
 * of basic types (bool, integer, floating point numbers, STL string) 
 * using the portable binary archive format associated to a 
 * standard output file stream.
 *
 */

#include <string>
#include <fstream>

#include <boost/cstdint.hpp>
#include <boost/archive/portable_binary_oarchive.hpp>

int main (void)
{
  // The name for the example data file :  
  std::string filename = "pba_0.data"; 

  // Some variables of various primitive types :
  bool        b              = true;
  char        c              = 'B';
  uint32_t    answer         = 42;
  float       computing_time = 7.5e6;
  double      e              = 2.71828182845905;
  std::string slogan         = "DON'T PANIC";
  
  // Open an output file stream in binary mode :
  std::ofstream fout (filename.c_str (), std::ios_base::binary);
  
  {
    // Create an output portable binary archive attached to the output file :
    boost::archive::portable_binary_oarchive opba (fout);
    
    // Store (serializing) variables :
    opba & b & c & answer & computing_time & e & slogan;
  }

  return 0;   
}

// end of tutorial_pba_0.cpp

/** tutorial_pba_1.cpp
 *
 * (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
 *
 * Use, modification and distribution is subject to the Boost Software
 * License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 *
 */

/**
 * The intent of this program is to serve as a tutorial for
 * users of the portable binary archive in the framework of 
 * the Boost/Serialization package. 
 *
 * This quick start example shows how to load some variables
 * of basic types (bool, integer, floating point numbers, STL string) 
 * using the portable binary archive format associated to a 
 * standard input file stream. 
 *
 */

#include <iostream>
#include <string>
#include <fstream>

#include <boost/cstdint.hpp>
#include <boost/archive/portable_binary_iarchive.hpp>

int main (void)
{
  using namespace std;

  // The name for the example data file :  
  string filename = "pba_0.data"; 

  // Some variables of various types :
  bool     b;
  char     c;
  uint32_t answer;
  float    computing_time;
  double   e;
  string   slogan;
   
  // Open an input file stream in binary mode :
  ifstream fin (filename.c_str (), ios_base::binary);
  
  {
    // Create an input portable binary archive attached to the input file :
    boost::archive::portable_binary_iarchive ipba (fin);
    
    // Loading (de-serializing) variables using the same 
    // order than for serialization (see tutorial_pba_0.cpp) :
    ipba & b & c & answer & computing_time & e & slogan;
  }

  cout.precision (15);
  cout << "Variable 'b' is              : " << b << " " << "(bool)" << endl;
  cout << "Variable 'c' is              : '" << c << "' " << " " << "(char)" << endl;
  cout << "Variable 'answer' is         : " << answer  << " " << "(unsigned 32-bit integer)" << endl;
  cout << "Variable 'computing_time' is : " << computing_time  << " " << "(single precision 32-bit float)" << endl;
  cout << "Variable 'e' is              : " << e  << " " << "(double precision 64-bit float)" << endl;
  cout << "Variable 'slogan' is         : \"" << slogan  << "\" " << "(std::string)" << endl;

  return 0;   
}

// end of tutorial_pba_1.cpp

/** tutorial_pba_2.cpp
 *
 * (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
 *
 * Use, modification and distribution is subject to the Boost Software
 * License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 *
 */

/**
 * The intent of this program is to serve as a tutorial for
 * users of the portable binary archive in the framework of 
 * the Boost/Serialization library. 
 *
 * This sample program shows how to use a portable binary archive 
 * to store/load floating point numbers including non-finite and 
 * special (denormalized) values.
 *
 */

#include <string>
#include <fstream>
#include <limits>

#include <boost/archive/portable_binary_oarchive.hpp>
#include <boost/archive/portable_binary_iarchive.hpp>

int main (void)
{
  using namespace std;

  // The name for the example data file :  
  string filename = "pba_2.data"; 

  {
    // A normal single precision floating point number :
    float pi = 3.14159265; 

    // Single precision zeroed floating point number :
    float zero = 0.0;

    // A denormalized single precision floating point number :
    float tiny = 1.e-40;
    
    // A single precision floating point number with `+Infinity' value :
    float plus_infinity = numeric_limits<float>::infinity ();
    
    // A single precision floating point number with `-Infinity' value :
    float minus_infinity = -numeric_limits<float>::infinity ();
    
    // A single precision `Not-a-Number' (NaN):
    float nan = numeric_limits<float>::quiet_NaN ();
    
    // Open an output file stream in binary mode :
    ofstream fout (filename.c_str (), ios_base::binary);
    
    {
      // Create an output portable binary archive attached to the output file :
      boost::archive::portable_binary_oarchive opba (fout);
      
      // Store (serialize) variables :
      opba & pi & zero & tiny & plus_infinity & minus_infinity & nan;
    }
  }

  { 
    // Single precision floating point numbers to be loaded :
    float x[6];

    // Open an input file stream in binary mode :
    ifstream fin (filename.c_str (), ios_base::binary);
  
    {
      // Create an input portable binary archive attached to the input file :
      boost::archive::portable_binary_iarchive ipba (fin);
      
      // Load (de-serialize) variables using the same 
      // order than for serialization :
      for (int i = 0; i < 6; ++i)
	{
	  ipba & x[i];
	}
    }

    // Print :
    for (int i = 0; i < 6; ++i)
      {
	cout.precision (8);
	cout << "Loaded x[" << i << "] = " << x[i];
	switch (fp::fpclassify(x[i]))
	  {
	  case FP_NAN: cout << " (NaN)"; break;
	  case FP_INFINITE: cout << " (infinite)"; break;
	  case FP_SUBNORMAL: cout << " (denormalized)"; break;
	  case FP_NORMAL:  cout << " (normalized)"; break;
	  }
	cout << endl;
      }
  }

  return 0;   
}

// end of tutorial_pba_2.cpp

/** tutorial_pba_3.cpp
 *
 * (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
 *
 * Use, modification and distribution is subject to the Boost Software
 * License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 *
 */

/**
 * The intent of this program is to serve as a tutorial for
 * users of the portable binary archive in the framework of 
 * the Boost/Serialization library. 
 *
 * This sample program shows how to use a portable binary archive 
 * and prevent the serialization of non-finite floating numbers.
 *
 */

#include <string>
#include <fstream>
#include <limits>

#include <boost/archive/portable_binary_oarchive.hpp>

int main (void)
{
  using namespace std;

  // The name for the example data file :  
  string filename = "pba_3.data"; 

  try 
    {
      // An array of single precision floating numbers:
      float x[5]; 
      x[0] = 3.14159;  // Pi
      x[1] = 6.022e22; // Avogadro constant
      x[2] = 1.6e-19;  // Electron charge magnitude
      x[3] = 1.e-40;   // A tiny (denormalized) value
      x[4] = numeric_limits<float>::infinity (); // This will fail while serializing...

      // Open an output file stream in binary mode :
      ofstream fout (filename.c_str (), ios_base::binary);
    
      {
	// Create an output portable binary archive attached to the output file,
	// using the special 'boost::archive::no_infnan' flag :
	boost::archive::portable_binary_oarchive opba (fout, boost::archive::no_infnan);
	
	// Store (serialize) variables :
	for (int i = 0; i < 5; ++i)
	  {
	    clog << "Serializing value : " << x[i] << " ... ";
	    opba & x[i];
	    clog << "Ok !" << endl;
	  }
      }
    }
  catch (exception & x)
    {
      cerr << "ERROR: " << x.what () << endl;
      return 1;
    }

  return 0;   
}

// end of tutorial_pba_3.cpp

/** tutorial_pba_4.cpp
 *
 * (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
 *
 * Use, modification and distribution is subject to the Boost Software
 * License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 *
 */

/**
 * The intent of this program is to serve as a tutorial for
 * users of the portable binary archive in the framework of 
 * the Boost/Serialization library. 
 *
 * This sample program shows how to use a portable binary archive 
 * to store/load integer numbers of various sizes using the Boost 
 * portable integer typedefs.
 *
 */

#include <string>
#include <fstream>

#include <boost/cstdint.hpp>
#include <boost/archive/portable_binary_oarchive.hpp>
#include <boost/archive/portable_binary_iarchive.hpp>

int main (void)
{
  using namespace std;

  // The name for the example data file :  
  string filename = "pba_4.data"; 

  {
    // Some integer numbers :
    bool t = true;
    char c = 'c';
    unsigned char u = 'u';
    int8_t   b = -3; // char
    uint8_t  B = +6; // unsigned char 
    int16_t  s = -16;
    uint16_t S = +32;
    int32_t  l = -128;
    uint32_t L = +127;
    int64_t  ll = -1024;
    uint64_t LL = +2048;

    // Open an output file stream in binary mode :
    ofstream fout (filename.c_str (), ios_base::binary);
    
    {
      // Create an output portable binary archive attached to the output file :
      boost::archive::portable_binary_oarchive opba (fout);
      
      // Store (serialize) variables :
      opba & t & c & u & b & B & s & S & l & L & ll & LL;
    }
  }

  { 
    // Single precision floating numbers to be loaded :
    // Some integer numbers :
    bool t;
    char c;
    unsigned char u;
    int8_t   b;
    uint8_t  B;
    int16_t  s;
    uint16_t S;
    int32_t  l;
    uint32_t L;
    int64_t  ll;
    uint64_t LL;

    // Open an input file stream in binary mode :
    ifstream fin (filename.c_str (), ios_base::binary);
  
    {
      // Create an input portable binary archive attached to the input file :
      boost::archive::portable_binary_iarchive ipba (fin);
      
      // Load (de-serialize) variables using the same 
      // order than for serialization :
      ipba & t & c & u & b & B & s & S & l & L & ll & LL;
    }

    clog << "t  = " << t << " (bool)" << endl;
    clog << "c  = '" << c << "' (char)" << endl;
    clog << "u  = '" << u << "' (unsigned char)" << endl;
    clog << "b  = " << (int) b << " (int8_t)" << endl;
    clog << "B  = " << (int) B << " (uint8_t)" << endl;
    clog << "s  = " << s << " (int16_t)" << endl;
    clog << "S  = " << S << " (uint16_t)" << endl;
    clog << "l  = " << l << " (int32_t)" << endl;
    clog << "L  = " << L << " (uint32_t)" << endl;
    clog << "ll = " << ll << " (int64_t)" << endl;
    clog << "LL = " << LL << " (uint64_t)" << endl;
  }

  return 0;   
}

// end of tutorial_pba_4.cpp

/** tutorial_pba_5.cpp
 *
 * (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
 *
 * Use, modification and distribution is subject to the Boost Software
 * License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 *
 */

/**
 * The intent of this program is to serve as a tutorial for
 * users of the portable binary archive in the framework of 
 * the Boost/Serialization library. 
 *
 * This sample program shows how to use a portable binary archive 
 * to store/load data in a memory buffer.
 *
 */

#include <string>
#include <vector>

#include <boost/iostreams/stream.hpp>
#include <boost/iostreams/device/back_inserter.hpp>
#include <boost/iostreams/device/array.hpp>

#include <boost/cstdint.hpp>
#include <boost/archive/portable_binary_oarchive.hpp>
#include <boost/archive/portable_binary_iarchive.hpp>

int main (void)
{
  using namespace std;

  // The memory buffer is implemented using a STL vector :
  typedef std::vector<char> buffer_type;
  buffer_type buffer; 

  {
    // Some data to be stored :
    bool    t = true;
    char    c = 'c';
    int16_t s = +16;
    int32_t l = -128;
    int64_t ll = +10000000000;
    float   pi = 3.14159;
    double  nan = numeric_limits<double>::quiet_NaN ();
    string  hello = "World !";

    buffer.reserve (1024); // pre-allocate some memory

    // The output stream interface to the buffer :
    boost::iostreams::stream<boost::iostreams::back_insert_device<buffer_type> > output_stream (buffer);

    {    
      // Create an output portable binary archive attached to the output file :
      boost::archive::portable_binary_oarchive opba (output_stream);
      
      // Store (serialize) variables :
      opba & t & c & s & l & ll & pi & nan & hello;
    }

  }

  clog << "Buffer content is " << buffer.size () << " bytes : " << endl << "  ";
  for (int i = 0; i < buffer.size (); ++i)
    {
      clog << (int) ((unsigned char) buffer[i]) << ' '; 
      if ((i + 1) % 20 == 0) clog << endl << "  ";
    }
  clog << endl;

  { 
    // Some data to be loaded :
    bool    t;
    char    c;
    int16_t s;
    int32_t l;
    int64_t ll;
    float   pi;
    double  nan;
    string  hello;

    // The input stream interface to the buffer :
    boost::iostreams::stream<boost::iostreams::array_source> input_stream (&buffer[0], 
									   buffer.size ());

    {
      // Create an input portable binary archive attached to the input file :
      boost::archive::portable_binary_iarchive ipba (input_stream);
      
      // Load (de-serialize) variables :
      ipba & t & c & s & l & ll & pi & nan & hello;
    }

    clog << "Loaded values from the buffer are: " << endl;
    clog << "  t  = " << t << " (bool)" << endl;
    clog << "  c  = '" << c << "' (char)" << endl;
    clog << "  s  = " << s << " (int16_t)" << endl;
    clog << "  l  = " << l << " (int32_t)" << endl;
    clog << "  ll = " << ll << " (int64_t)" << endl;
    clog << "  pi = " << pi << " (float)" << endl;
    clog << "  nan = " << nan << " (double)" << endl;
    clog << "  hello = \"" << hello << "\" (std::string)" << endl;
  }

  return 0;   
}

// end of tutorial_pba_5.cpp

/** tutorial_pba_6.cpp
 *
 * (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
 *
 * Use, modification and distribution is subject to the Boost Software
 * License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 *
 */

/**
 * The intent of this program is to serve as a tutorial for
 * users of the portable binary archive in the framework of
 * the Boost/Serialization library.
 *
 * This sample program shows how to use a portable binary archive
 * associated to a memory buffer to copy a non-copyable object.
 *
 */

#include <iostream>
#include <string>
#include <sstream>
#include <vector>

#include <boost/utility.hpp>
#include <boost/iostreams/stream.hpp>
#include <boost/iostreams/device/back_inserter.hpp>
#include <boost/iostreams/device/array.hpp>

#include <boost/cstdint.hpp>
#include <boost/archive/portable_binary_oarchive.hpp>
#include <boost/archive/portable_binary_iarchive.hpp>

using namespace std;

/* A foo noncopyable class */
struct foo : boost::noncopyable
{
  uint32_t status;
  double   value;
  double   special;

  string to_string () const
  {
    ostringstream sout;
    sout << "foo={status=" << status << "; value=" << value  << "; special=" << special<< "}";
    return sout.str();
  }

  template<class Archive>
  void serialize (Archive & ar, const unsigned int version)
  {
    ar & status;
    ar & value;
    ar & special;
    return;
  }

};

// A templatized copy function for Boost/Serialization equipped classes.
// Here we use PBAs associated to a memory buffer :
template <class Serializable>
void copy (const Serializable & source, Serializable & target)
{
  namespace io = boost::iostreams;
  namespace ba = boost::archive;
  if (&source == &target) return; // self-copy guard
  typedef std::vector<char> buffer_type;
  buffer_type buffer;
  buffer.reserve (1024);
  {
    io::stream<io::back_insert_device<buffer_type> > output_stream (buffer);
    ba::portable_binary_oarchive opba (output_stream);
    opba & source;
  }
  {
    io::stream<io::array_source> input_stream (&buffer[0], buffer.size ());
    ba::portable_binary_iarchive ipba (input_stream);
    ipba & target;
  }
  return;
}

int main (void)
{
  // Some instance of the 'foo' class :
  foo dummy;
  dummy.status = 1;
  dummy.value = 3.14159;
  dummy.special = numeric_limits<double>::quiet_NaN ();
  clog << "dummy is : " << dummy.to_string () << endl;

  // Another instance of the 'foo' class :
  foo clone;

  /* The following instruction is forbidden because foo 
     inherits 'boost::noncopyable' :
   
   clone = dummy; // this ends in a compilation error.
   
   */

  // Anyway, we can use this workaround :
  copy (dummy, clone);
  clog << "clone is : " << clone.to_string () << endl;

  return 0;
}

// end of tutorial_pba_6.cpp

/** tutorial_pba_7.cpp
 *
 * (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
 *
 * Use, modification and distribution is subject to the Boost Software
 * License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 *
 */

/**
 * The intent of this program is to serve as a tutorial for
 * users of the portable binary archive in the framework of 
 * the Boost/Serialization library. 
 *
 * This example shows how the default behaviour of standard 
 * I/O streams does not support the read/write operations of 
 * non-finite floating point values in a portable way.
 *
 */

#include <string>
#include <iostream>
#include <sstream>
#include <limits>

using namespace std;

int main (void)
{
  {
    float x = numeric_limits<float>::infinity ();
    double y = numeric_limits<double>::quiet_NaN ();
    cout.precision (8);
    cout << "x = " << x << endl;
    cout.precision (16);
    cout << "y = " << y << endl;
  }

  {
    string input ("inf nan");
    istringstream iss (input);
    float x; 
    double y;
    iss >> x >> y;
    if (! iss)
      {
	cerr << "Cannot read 'x' or 'y' : non finite values are not supported !" << endl;
      }
  }
  return 0;
}

// end of tutorial_pba_7.cpp

/** tutorial_pba_8.cpp
 *
 * (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
 *
 * Use, modification and distribution is subject to the Boost Software
 * License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 *
 */

/**
 * The intent of this program is to serve as a tutorial for
 * users of the portable binary archive in the framework of 
 * the Boost/Serialization library. 
 *
 * This example shows how to store some variables
 * of basic types (bool, integer, floating point numbers, STL string) 
 * using the text or XML archive format associated to a 
 * standard output file stream supporting portable non-finite
 * floating point values.
 *
 */

#include <string>
#include <fstream>
#include <limits>
#include <locale>

#include <boost/cstdint.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/archive/codecvt_null.hpp>
#include <boost/math/special_functions/nonfinite_num_facets.hpp>

using namespace std;

void do_text_out (void)
{
  // The name for the example data text file :  
  string filename = "pba_8.txt"; 

  // Some variables of various primitive types :
  bool        b         = true;
  char        c         = 'B';
  uint32_t    answer    = 42;
  float       value     = numeric_limits<float>::infinity ();
  double      precision = numeric_limits<double>::quiet_NaN ();
  string      question  = "What makes you think she's a witch?";
  
  // Open an output file stream :
  ofstream fout (filename.c_str ());

  // Prepare the output file stream for inf/NaN support :
  locale default_locale (locale::classic (),
			 new boost::archive::codecvt_null<char>);
  locale infnan_locale (default_locale,
			new boost::math::nonfinite_num_put<char>);
  fout.imbue (infnan_locale);
  
  {
    // Create an output text archive attached to the output file :
    boost::archive::text_oarchive ota (fout, boost::archive::no_codecvt);
    
    // Store (serializing) variables :
    ota & b & c & answer & value & precision & question;
  }

  return;   
}

void do_xml_out (void)
{
  // The name for the example data XML file :  
  string filename = "pba_8.xml"; 

  // Some variables of various primitive types :
  bool        b         = true;
  char        c         = 'B';
  uint32_t    answer    = 42;
  float       value     = numeric_limits<float>::infinity ();
  double      precision = numeric_limits<double>::quiet_NaN ();
  string      question  = "What makes you think she's a witch?";
  
  // Open an output file stream :
  ofstream fout (filename.c_str ());

  // Prepare the output file stream for inf/NaN support :
  locale default_locale (locale::classic (),
			 new boost::archive::codecvt_null<char>);
  locale infnan_locale (default_locale,
			new boost::math::nonfinite_num_put<char>);
  fout.imbue (infnan_locale);
   
  {
    // Create an output text archive attached to the output file :
    boost::archive::xml_oarchive oxa (fout, boost::archive::no_codecvt);
    
    // Store (serializing) variables :
    oxa & BOOST_SERIALIZATION_NVP(b)
      & BOOST_SERIALIZATION_NVP(c)
      & BOOST_SERIALIZATION_NVP(answer)
      & BOOST_SERIALIZATION_NVP(value)
      & BOOST_SERIALIZATION_NVP(precision) 
      & BOOST_SERIALIZATION_NVP(question);
  }

  return;   
}

int main (void)
{
  do_text_out ();
  do_xml_out ();
  return 0;
}

// end of tutorial_pba_8.cpp

/** tutorial_pba_9.cpp
 *
 * (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
 *
 * Use, modification and distribution is subject to the Boost Software
 * License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 *
 */

/**
 * The intent of this program is to serve as a tutorial for
 * users of the portable binary archive in the framework of 
 * the Boost/Serialization library. 
 *
 * This example shows how to load some variables of basic 
 * types (bool, char, integer, floating point numbers, STL string) 
 * using the text or XML archive format associated to a 
 * standard file input stream supporting portable non-finite
 * floating point values.
 *
 */

#include <string>
#include <fstream>
#include <limits>
#include <locale>

#include <boost/cstdint.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/archive/codecvt_null.hpp>
#include <boost/math/special_functions/nonfinite_num_facets.hpp>

using namespace std;

void do_text_in (void)
{
  // The name for the example data text file :  
  string filename = "pba_8.txt"; 
  // Some variables of various primitive types :
  bool        b;
  char        c;
  uint32_t    answer;
  float       value;
  double      precision;
  string      question;
  
  // Open an input file stream :
  ifstream fin (filename.c_str ());

  // Prepare the input file stream for inf/NaN support :
  locale default_locale (locale::classic (),
			 new boost::archive::codecvt_null<char>);
  locale infnan_locale (default_locale,
			new boost::math::nonfinite_num_get<char>);
  fin.imbue (infnan_locale);
 
  {
    // Create an input text archive attached to the input file :
    boost::archive::text_iarchive ita (fin, boost::archive::no_codecvt);
    
    // Store (serializing) variables :
    ita & b & c & answer & value & precision & question;
  }

  clog << "Loaded values from text archive are: " << endl;
  clog << "  b         = " << b << endl;
  clog << "  c         = '" << c << "'" <<  endl;
  clog << "  answer    = " << answer << endl;
  clog << "  value     = " << value << endl;
  clog << "  precision = " << precision << endl;
  clog << "  question  = \"" << question << "\"" << endl;

  return;   
}

void do_xml_in (void)
{
  // The name for the example data text file :  
  string filename = "pba_8.xml"; 

  // Some variables of various primitive types :
  bool        b;
  char        c;
  uint32_t    answer;
  float       value;
  double      precision;
  string      question;
  
  // Open an input file stream :
  ifstream fin (filename.c_str ());

  // Prepare the input file stream for inf/NaN support :
  locale default_locale (locale::classic (),
			 new boost::archive::codecvt_null<char>);
  locale infnan_locale (default_locale,
			new boost::math::nonfinite_num_get<char>);
  fin.imbue (infnan_locale);

  {
    // Create an output text archive attached to the output file :
    boost::archive::xml_iarchive ixa (fin, boost::archive::no_codecvt);
    
    // Store (serializing) variables :
    ixa & BOOST_SERIALIZATION_NVP(b)
      & BOOST_SERIALIZATION_NVP(c)
      & BOOST_SERIALIZATION_NVP(answer)
      & BOOST_SERIALIZATION_NVP(value)
      & BOOST_SERIALIZATION_NVP(precision) 
      & BOOST_SERIALIZATION_NVP(question);
  }

  clog << "Loaded values from XML archive are: " << endl;
  clog << "  b         = " << b << endl;
  clog << "  c         = '" << c << "'" <<  endl;
  clog << "  answer    = " << answer << endl;
  clog << "  value     = " << value << endl;
  clog << "  precision = " << precision << endl;
  clog << "  question  = \"" << question << "\"" << endl;

  return;   
}

int main (void)
{
  do_text_in ();
  do_xml_in ();
  return 0;
}

// end of tutorial_pba_9.cpp

/** tutorial_pba_10.cpp
 *
 * (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
 *
 * Use, modification and distribution is subject to the Boost Software
 * License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 *
 */

/**
 * The intent of this program is to serve as a tutorial for
 * users of the portable binary archive in the framework of 
 * the Boost/Serialization library. 
 *
 * This example shows how use PBAs combined with on-the-fly 
 * compressed I/O streams.
 *
 */

#include <string>
#include <fstream>
#include <limits>
#include <vector>

#include <boost/cstdint.hpp>
#include <boost/archive/portable_binary_oarchive.hpp>
#include <boost/archive/portable_binary_iarchive.hpp>
#include <boost/iostreams/filtering_stream.hpp>
#include <boost/iostreams/filter/gzip.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/vector.hpp>

using namespace std;

class data_type
{
private:
  friend class boost::serialization::access;
  template<class Archive>
  void serialize (Archive & ar, const unsigned int version);
public:
  void print (ostream & out, const string & title) const;
public:
  vector<double> values;
  data_type ();
};

data_type::data_type () : values ()
{
  return;
}

void data_type::print (ostream & out, const string & title) const
{
  out << endl;
  out << title << " :" << endl;
  for (int i = 0; i < this->values.size (); ++i)
    {
      out.precision (16);
      out.width (18);
      out << this->values [i] << ' ' ;
      if ((i%4) == 3) clog << endl;
    }
  out << endl;
  return;
}
  
template<class Archive>
void data_type::serialize (Archive & ar, const unsigned int version)
{
  ar & values;
  return;
}

void do_gzipped_out (void)
{
  // The name for the output data file :  
  string filename = "pba_10.data.gz"; 

  // A data structure to be stored :
  data_type my_data;

  // Fill the vector with arbitrary (possibly non-finite) values :
  size_t dim = 1000;
  my_data.values.reserve (dim);
  for (int i = 0; i < dim; ++i)
    {      
      double val = (i + 1) * (1.0 + 3 * numeric_limits<double>::epsilon ());
      if (i == 4) val = numeric_limits<double>::quiet_NaN ();
      if (i == 23) val = numeric_limits<double>::infinity ();
      if (i == 73) val = -numeric_limits<double>::infinity ();
      if (i == 90) val = 0.0;
      my_data.values.push_back (val);
    }

  // Print:
  my_data.print (clog, "Stored data");

  // Create an output filtering stream :
  boost::iostreams::filtering_ostream zout;
  zout.push (boost::iostreams::gzip_compressor ());
  
  // Open an output file stream in binary mode :
  ofstream fout (filename.c_str (), ios_base::binary);
  zout.push (fout);

  // Save to PBA :
  {
    // Create an output portable binary archive attached to the output file :
    boost::archive::portable_binary_oarchive opba (zout);
    
    // Store (serializing) the data :
    opba & my_data;
  }

  // Clean termination of the streams :
  zout.flush ();
  zout.reset ();

  return;   
}

void do_gzipped_in (void)
{
  // The name for the input data file :  
  string filename = "pba_10.data.gz"; 

  // A data structure to be loaded :
  data_type my_data;

  // Create an input filtering stream :
  boost::iostreams::filtering_istream zin;
  zin.push (boost::iostreams::gzip_decompressor ());
  
  // Open an input file stream in binary mode :
  ifstream fin (filename.c_str (), ios_base::binary);
  zin.push (fin);

  // Load from PBA :
  {
    // Create an input portable binary archive attached to the input file :
    boost::archive::portable_binary_iarchive ipba (zin);
    
    // Load (deserializing) the data :
    ipba & my_data;
  }

  // Print:
  my_data.print (clog, "Loaded data");

  return;   
}

int main (void)
{
  do_gzipped_out (); 
  do_gzipped_in ();
  return 0;
}

// end of tutorial_pba_10.cpp

/** tutorial_pba_11.cpp
 *
 * (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
 *
 * Use, modification and distribution is subject to the Boost Software
 * License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 *
 */

/**
 * The intent of this program is to serve as a tutorial for
 * users of the portable binary archive in the framework of 
 * the Boost/Serialization library. 
 *
 * This example program compares the times needed to serialize
 * and deserialize some large amount of data using PBA and 
 * text archives.
 *
 */

#include <string>
#include <fstream>
#include <vector>

#include <boost/archive/portable_binary_oarchive.hpp>
#include <boost/archive/portable_binary_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_real_distribution.hpp>
#include <boost/timer.hpp>

using namespace std;

class data_type
{
private:
  friend class boost::serialization::access;
  template<class Archive>
  void serialize (Archive & ar, const unsigned int version);
public:
  void print (ostream & out, const string & title) const;
public:
  vector<double> values;
  data_type ();
};

data_type::data_type () : values ()
{
  return;
}

void data_type::print (ostream & out, const string & title) const
{
  out << endl;
  out << title << " :" << endl;
  bool skip = false;
  for (int i = 0; i < this->values.size (); ++i)
    {
      if ((i >= 12) && (i < (int) this->values.size () - 8)) 
	{
	  if (! skip) out << " ..." << endl;
	  skip = true;
	  continue;
	}
      out.precision (16);
      out.width (18);
      out << this->values [i] << ' ' ;
      if ((i%4) == 3) clog << endl;
    }
  out << endl;
  return;
}
  
template<class Archive>
void data_type::serialize (Archive & ar, const unsigned int version)
{
  ar & values;
  return;
}

double do_pba_out (const data_type & a_data)
{
  string filename = "pba_11.data"; 
  ofstream fout (filename.c_str (), ios_base::binary);
  boost::timer io_timer;    
  {
    boost::archive::portable_binary_oarchive opba (fout);
    opba & a_data;
  }
  return io_timer.elapsed ();
}

double do_pba_in (data_type & a_data)
{
  string filename = "pba_11.data"; 
  ifstream fin (filename.c_str (), ios_base::binary);
  boost::timer io_timer;    
  {
    boost::archive::portable_binary_iarchive ipba (fin);
    ipba & a_data;
  }
  return io_timer.elapsed ();
}

double do_text_out (const data_type & a_data)
{
  string filename = "pba_11.txt"; 
  ofstream fout (filename.c_str ());
  boost::timer io_timer;    
  {
    boost::archive::text_oarchive ota (fout);
    ota & a_data;
  }
  return io_timer.elapsed ();
}

double do_text_in (data_type & a_data)
{
  string filename = "pba_11.txt"; 
  ifstream fin (filename.c_str ());
  boost::timer io_timer;    
  {
    boost::archive::text_iarchive ita (fin);
    ita & a_data;
  }
  return io_timer.elapsed ();
}

int main (void)
{
  double elapsed_time_pba_out; 
  double elapsed_time_text_out; 
  double elapsed_time_pba_in; 
  double elapsed_time_text_in; 
  data_type my_data; // A data structure to be stored then loaded.

  {
    // Fill the vector with random values :
    size_t dim = 10000000;
    my_data.values.reserve (dim);
    boost::random::mt19937 rng;
    boost::random::uniform_real_distribution<> flat (0.0, 100.0);
    for (int i = 0; i < dim; ++i)
      {      
	double val = flat (rng);
	my_data.values.push_back (val);
      }
    my_data.print (clog, "Stored data in PBA and text archive");
  }

  {
    // Store in PBA :
    elapsed_time_pba_out = do_pba_out (my_data);
  }

  {
    // Store in text archive :
    elapsed_time_text_out = do_text_out (my_data);
  }     

  {
    my_data.values.clear ();
    // Load from PBA :
    elapsed_time_pba_in = do_pba_in (my_data);
    my_data.print (clog, "Loaded data from PBA");
  }

  {
    my_data.values.clear ();
    // Load from text archive :
    elapsed_time_text_in = do_text_in (my_data);
    my_data.print (clog, "Loaded data from text archive");
  }
  
  clog << "PBA  store I/O elapsed time : " << elapsed_time_pba_out  << " (second)" << endl;
  clog << "Text store I/O elapsed time : " << elapsed_time_text_out << " (second)" << endl;  
  clog << "PBA  load  I/O elapsed time : " << elapsed_time_pba_in   << " (second)" << endl;
  clog << "Text load  I/O elapsed time : " << elapsed_time_text_in  << " (second)" << endl;

  return 0;
}

// end of tutorial_pba_11.cpp