.. _program_listing_file_include_coal_serialization_archive.h:

Program Listing for File archive.h
==================================

|exhale_lsh| :ref:`Return to documentation for file <file_include_coal_serialization_archive.h>` (``include/coal/serialization/archive.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   //
   // Copyright (c) 2017-2024 CNRS INRIA
   // This file was borrowed from the Pinocchio library:
   // https://github.com/stack-of-tasks/pinocchio
   //
   
   #ifndef COAL_SERIALIZATION_ARCHIVE_H
   #define COAL_SERIALIZATION_ARCHIVE_H
   
   #include "coal/fwd.hh"
   
   #include <boost/serialization/nvp.hpp>
   #include <boost/archive/text_iarchive.hpp>
   #include <boost/archive/text_oarchive.hpp>
   #include <boost/archive/xml_iarchive.hpp>
   #include <boost/archive/xml_oarchive.hpp>
   #include <boost/archive/binary_iarchive.hpp>
   #include <boost/archive/binary_oarchive.hpp>
   
   #include <fstream>
   #include <string>
   #include <sstream>
   #include <stdexcept>
   
   #if BOOST_VERSION / 100 % 1000 == 78 && __APPLE__
   // See https://github.com/qcscine/utilities/issues/5#issuecomment-1246897049 for
   // further details
   
   #ifndef BOOST_ASIO_DISABLE_STD_ALIGNED_ALLOC
   #define DEFINE_BOOST_ASIO_DISABLE_STD_ALIGNED_ALLOC
   #define BOOST_ASIO_DISABLE_STD_ALIGNED_ALLOC
   #endif
   
   #include <boost/asio/streambuf.hpp>
   
   #ifdef DEFINE_BOOST_ASIO_DISABLE_STD_ALIGNED_ALLOC
   #undef BOOST_ASIO_DISABLE_STD_ALIGNED_ALLOC
   #endif
   
   #else
   #include <boost/asio/streambuf.hpp>
   #endif
   
   #include <boost/iostreams/device/array.hpp>
   #include <boost/iostreams/stream.hpp>
   #include <boost/iostreams/stream_buffer.hpp>
   
   // Handle NAN inside TXT or XML archives
   #include <boost/math/special_functions/nonfinite_num_facets.hpp>
   
   namespace coal {
   namespace serialization {
   
   template <typename T>
   inline void loadFromText(T& object, const std::string& filename) {
     std::ifstream ifs(filename.c_str());
     if (ifs) {
       std::locale const new_loc(ifs.getloc(),
                                 new boost::math::nonfinite_num_get<char>);
       ifs.imbue(new_loc);
       boost::archive::text_iarchive ia(ifs, boost::archive::no_codecvt);
       ia >> object;
     } else {
       const std::string exception_message(filename +
                                           " does not seem to be a valid file.");
       throw std::invalid_argument(exception_message);
     }
   }
   
   template <typename T>
   inline void saveToText(const T& object, const std::string& filename) {
     std::ofstream ofs(filename.c_str());
     if (ofs) {
       boost::archive::text_oarchive oa(ofs);
       oa & object;
     } else {
       const std::string exception_message(filename +
                                           " does not seem to be a valid file.");
       throw std::invalid_argument(exception_message);
     }
   }
   
   template <typename T>
   inline void loadFromStringStream(T& object, std::istringstream& is) {
     std::locale const new_loc(is.getloc(),
                               new boost::math::nonfinite_num_get<char>);
     is.imbue(new_loc);
     boost::archive::text_iarchive ia(is, boost::archive::no_codecvt);
     ia >> object;
   }
   
   template <typename T>
   inline void saveToStringStream(const T& object, std::stringstream& ss) {
     boost::archive::text_oarchive oa(ss);
     oa & object;
   }
   
   template <typename T>
   inline void loadFromString(T& object, const std::string& str) {
     std::istringstream is(str);
     loadFromStringStream(object, is);
   }
   
   template <typename T>
   inline std::string saveToString(const T& object) {
     std::stringstream ss;
     saveToStringStream(object, ss);
     return ss.str();
   }
   
   template <typename T>
   inline void loadFromXML(T& object, const std::string& filename,
                           const std::string& tag_name) {
     if (filename.empty()) {
       COAL_THROW_PRETTY("Tag name should not be empty.", std::invalid_argument);
     }
   
     std::ifstream ifs(filename.c_str());
     if (ifs) {
       std::locale const new_loc(ifs.getloc(),
                                 new boost::math::nonfinite_num_get<char>);
       ifs.imbue(new_loc);
       boost::archive::xml_iarchive ia(ifs, boost::archive::no_codecvt);
       ia >> boost::serialization::make_nvp(tag_name.c_str(), object);
     } else {
       const std::string exception_message(filename +
                                           " does not seem to be a valid file.");
       throw std::invalid_argument(exception_message);
     }
   }
   
   template <typename T>
   inline void saveToXML(const T& object, const std::string& filename,
                         const std::string& tag_name) {
     if (filename.empty()) {
       COAL_THROW_PRETTY("Tag name should not be empty.", std::invalid_argument);
     }
   
     std::ofstream ofs(filename.c_str());
     if (ofs) {
       boost::archive::xml_oarchive oa(ofs);
       oa& boost::serialization::make_nvp(tag_name.c_str(), object);
     } else {
       const std::string exception_message(filename +
                                           " does not seem to be a valid file.");
       throw std::invalid_argument(exception_message);
     }
   }
   
   template <typename T>
   inline void loadFromBinary(T& object, const std::string& filename) {
     std::ifstream ifs(filename.c_str(), std::ios::binary);
     if (ifs) {
       boost::archive::binary_iarchive ia(ifs);
       ia >> object;
     } else {
       const std::string exception_message(filename +
                                           " does not seem to be a valid file.");
       throw std::invalid_argument(exception_message);
     }
   }
   
   template <typename T>
   void saveToBinary(const T& object, const std::string& filename) {
     std::ofstream ofs(filename.c_str(), std::ios::binary);
     if (ofs) {
       boost::archive::binary_oarchive oa(ofs);
       oa & object;
     } else {
       const std::string exception_message(filename +
                                           " does not seem to be a valid file.");
       throw std::invalid_argument(exception_message);
     }
   }
   
   template <typename T>
   inline void loadFromBuffer(T& object, boost::asio::streambuf& buffer) {
     boost::archive::binary_iarchive ia(buffer);
     ia >> object;
   }
   
   template <typename T>
   void saveToBuffer(const T& object, boost::asio::streambuf& buffer) {
     boost::archive::binary_oarchive oa(buffer);
     oa & object;
   }
   
   }  // namespace serialization
   }  // namespace coal
   
   #endif  // ifndef COAL_SERIALIZATION_ARCHIVE_H