pinocchio  2.6.0
A fast and flexible implementation of Rigid Body Dynamics algorithms and their analytical derivatives
archive.hpp
1 //
2 // Copyright (c) 2017-2021 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 #include <boost/asio/streambuf.hpp>
22 
23 // Handle NAN inside TXT or XML archives
24 #include <boost/math/special_functions/nonfinite_num_facets.hpp>
25 
26 namespace pinocchio
27 {
28  namespace serialization
29  {
30 
39  template<typename T>
40  inline void loadFromText(T & object,
41  const std::string & filename)
42  {
43  std::ifstream ifs(filename.c_str());
44  if(ifs)
45  {
46  std::locale const new_loc(ifs.getloc(), new boost::math::nonfinite_num_get<char>);
47  ifs.imbue(new_loc);
48  boost::archive::text_iarchive ia(ifs,boost::archive::no_codecvt);
49  ia >> object;
50  }
51  else
52  {
53  const std::string exception_message(filename + " does not seem to be a valid file.");
54  throw std::invalid_argument(exception_message);
55  }
56  }
57 
66  template<typename T>
67  inline void saveToText(const T & object,
68  const std::string & filename)
69  {
70  std::ofstream ofs(filename.c_str());
71  if(ofs)
72  {
73  boost::archive::text_oarchive oa(ofs);
74  oa & object;
75  }
76  else
77  {
78  const std::string exception_message(filename + " does not seem to be a valid file.");
79  throw std::invalid_argument(exception_message);
80  }
81  }
82 
91  template<typename T>
92  inline void loadFromStringStream(T & object,
93  std::istringstream & is)
94  {
95  boost::archive::text_iarchive ia(is,boost::archive::no_codecvt);
96  ia >> object;
97  }
98 
107  template<typename T>
108  inline void saveToStringStream(const T & object,
109  std::stringstream & ss)
110  {
111  boost::archive::text_oarchive oa(ss);
112  oa & object;
113  }
114 
123  template<typename T>
124  inline void loadFromString(T & object,
125  const std::string & str)
126  {
127  std::istringstream is(str);
128  loadFromStringStream(object,is);
129  }
130 
140  template<typename T>
141  inline std::string saveToString(const T & object)
142  {
143  std::stringstream ss;
144  saveToStringStream(object,ss);
145  return ss.str();
146  }
147 
157  template<typename T>
158  inline void loadFromXML(T & object,
159  const std::string & filename,
160  const std::string & tag_name)
161  {
162  PINOCCHIO_CHECK_INPUT_ARGUMENT(!tag_name.empty());
163 
164  std::ifstream ifs(filename.c_str());
165  if(ifs)
166  {
167  std::locale const new_loc(ifs.getloc(), new boost::math::nonfinite_num_get<char>);
168  ifs.imbue(new_loc);
169  boost::archive::xml_iarchive ia(ifs,boost::archive::no_codecvt);
170  ia >> boost::serialization::make_nvp(tag_name.c_str(),object);
171  }
172  else
173  {
174  const std::string exception_message(filename + " does not seem to be a valid file.");
175  throw std::invalid_argument(exception_message);
176  }
177  }
178 
188  template<typename T>
189  inline void saveToXML(const T & object,
190  const std::string & filename,
191  const std::string & tag_name)
192  {
193  PINOCCHIO_CHECK_INPUT_ARGUMENT(!tag_name.empty());
194 
195  std::ofstream ofs(filename.c_str());
196  if(ofs)
197  {
198  boost::archive::xml_oarchive oa(ofs);
199  oa & boost::serialization::make_nvp(tag_name.c_str(),object);
200  }
201  else
202  {
203  const std::string exception_message(filename + " does not seem to be a valid file.");
204  throw std::invalid_argument(exception_message);
205  }
206  }
207 
216  template<typename T>
217  inline void loadFromBinary(T & object,
218  const std::string & filename)
219  {
220  std::ifstream ifs(filename.c_str(), std::ios::binary);
221  if(ifs)
222  {
223  boost::archive::binary_iarchive ia(ifs);
224  ia >> object;
225  }
226  else
227  {
228  const std::string exception_message(filename + " does not seem to be a valid file.");
229  throw std::invalid_argument(exception_message);
230  }
231  }
232 
241  template<typename T>
242  void saveToBinary(const T & object,
243  const std::string & filename)
244  {
245  std::ofstream ofs(filename.c_str(), std::ios::binary);
246  if(ofs)
247  {
248  boost::archive::binary_oarchive oa(ofs);
249  oa & object;
250  }
251  else
252  {
253  const std::string exception_message(filename + " does not seem to be a valid file.");
254  throw std::invalid_argument(exception_message);
255  }
256  }
257 
266  template<typename T>
267  inline void loadFromBinary(T & object,
268  boost::asio::streambuf & buffer)
269  {
270  boost::archive::binary_iarchive ia(buffer);
271  ia >> object;
272  }
273 
282  template<typename T>
283  void saveToBinary(const T & object,
284  boost::asio::streambuf & buffer)
285  {
286  boost::archive::binary_oarchive oa(buffer);
287  oa & object;
288  }
289 
290  }
291 } // namespace pinocchio
292 
293 #endif // ifndef __pinocchio_serialization_archive_hpp__
pinocchio
Main pinocchio namespace.
Definition: treeview.dox:24