pinocchio  2.5.0
A fast and flexible implementation of Rigid Body Dynamics algorithms and their analytical derivatives
archive.hpp
1 //
2 // Copyright (c) 2017-2019 CNRS INRIA
3 //
4 
5 #ifndef __pinocchio_serialization_archive_hpp__
6 #define __pinocchio_serialization_archive_hpp__
7 
8 #include "pinocchio/serialization/fwd.hpp"
9 
10 #include <fstream>
11 #include <string>
12 #include <sstream>
13 #include <stdexcept>
14 #include <boost/archive/text_oarchive.hpp>
15 #include <boost/archive/text_iarchive.hpp>
16 #include <boost/archive/xml_iarchive.hpp>
17 #include <boost/archive/xml_oarchive.hpp>
18 #include <boost/archive/binary_iarchive.hpp>
19 #include <boost/archive/binary_oarchive.hpp>
20 
21 // Handle NAN inside TXT or XML archives
22 #include <boost/math/special_functions/nonfinite_num_facets.hpp>
23 
24 namespace pinocchio
25 {
26  namespace serialization
27  {
28 
37  template<typename T>
38  inline void loadFromText(T & object,
39  const std::string & filename)
40  {
41  std::ifstream ifs(filename.c_str());
42  if(ifs)
43  {
44  std::locale const new_loc(ifs.getloc(), new boost::math::nonfinite_num_get<char>);
45  ifs.imbue(new_loc);
46  boost::archive::text_iarchive ia(ifs,boost::archive::no_codecvt);
47  ia >> object;
48  }
49  else
50  {
51  const std::string exception_message(filename + " does not seem to be a valid file.");
52  throw std::invalid_argument(exception_message);
53  }
54  }
55 
64  template<typename T>
65  inline void saveToText(const T & object,
66  const std::string & filename)
67  {
68  std::ofstream ofs(filename.c_str());
69  if(ofs)
70  {
71  boost::archive::text_oarchive oa(ofs);
72  oa & object;
73  }
74  else
75  {
76  const std::string exception_message(filename + " does not seem to be a valid file.");
77  throw std::invalid_argument(exception_message);
78  }
79  }
80 
89  template<typename T>
90  inline void loadFromStringStream(T & object,
91  std::istringstream & is)
92  {
93  boost::archive::text_iarchive ia(is,boost::archive::no_codecvt);
94  ia >> object;
95  }
96 
105  template<typename T>
106  inline void saveToStringStream(const T & object,
107  std::stringstream & ss)
108  {
109  boost::archive::text_oarchive oa(ss);
110  oa & object;
111  }
112 
121  template<typename T>
122  inline void loadFromString(T & object,
123  const std::string & str)
124  {
125  std::istringstream is(str);
126  loadFromStringStream(object,is);
127  }
128 
138  template<typename T>
139  inline std::string saveToString(const T & object)
140  {
141  std::stringstream ss;
142  saveToStringStream(object,ss);
143  return ss.str();
144  }
145 
155  template<typename T>
156  inline void loadFromXML(T & object,
157  const std::string & filename,
158  const std::string & tag_name)
159  {
160  PINOCCHIO_CHECK_INPUT_ARGUMENT(!tag_name.empty());
161 
162  std::ifstream ifs(filename.c_str());
163  if(ifs)
164  {
165  std::locale const new_loc(ifs.getloc(), new boost::math::nonfinite_num_get<char>);
166  ifs.imbue(new_loc);
167  boost::archive::xml_iarchive ia(ifs,boost::archive::no_codecvt);
168  ia >> boost::serialization::make_nvp(tag_name.c_str(),object);
169  }
170  else
171  {
172  const std::string exception_message(filename + " does not seem to be a valid file.");
173  throw std::invalid_argument(exception_message);
174  }
175  }
176 
186  template<typename T>
187  inline void saveToXML(const T & object,
188  const std::string & filename,
189  const std::string & tag_name)
190  {
191  PINOCCHIO_CHECK_INPUT_ARGUMENT(!tag_name.empty());
192 
193  std::ofstream ofs(filename.c_str());
194  if(ofs)
195  {
196  boost::archive::xml_oarchive oa(ofs);
197  oa & boost::serialization::make_nvp(tag_name.c_str(),object);
198  }
199  else
200  {
201  const std::string exception_message(filename + " does not seem to be a valid file.");
202  throw std::invalid_argument(exception_message);
203  }
204  }
205 
214  template<typename T>
215  inline void loadFromBinary(T & object,
216  const std::string & filename)
217  {
218  std::ifstream ifs(filename.c_str(), std::ios::binary);
219  if(ifs)
220  {
221  boost::archive::binary_iarchive ia(ifs);
222  ia >> object;
223  }
224  else
225  {
226  const std::string exception_message(filename + " does not seem to be a valid file.");
227  throw std::invalid_argument(exception_message);
228  }
229  }
230 
239  template<typename T>
240  void saveToBinary(const T & object,
241  const std::string & filename)
242  {
243  std::ofstream ofs(filename.c_str(), std::ios::binary);
244  if(ofs)
245  {
246  boost::archive::binary_oarchive oa(ofs);
247  oa & object;
248  }
249  else
250  {
251  const std::string exception_message(filename + " does not seem to be a valid file.");
252  throw std::invalid_argument(exception_message);
253  }
254  }
255 
256  }
257 } // namespace pinocchio
258 
259 #endif // ifndef __pinocchio_serialization_archive_hpp__
Main pinocchio namespace.
Definition: treeview.dox:24