serialize.cpp 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455
  1. // This file is part of libigl, a simple c++ geometry processing library.
  2. //
  3. // Copyright (C) 2013 Alec Jacobson <alecjacobson@gmail.com>
  4. //
  5. // This Source Code Form is subject to the terms of the Mozilla Public License
  6. // v. 2.0. If a copy of the MPL was not distributed with this file, You can
  7. // obtain one at http://mozilla.org/MPL/2.0/.
  8. // ---------------------------------------------------------------------------
  9. // serialize.h
  10. // author: Christian Schüller <schuellchr@gmail.com>
  11. // -----------------------------------------------------------------------------
  12. #include "serialize.h"
  13. namespace igl
  14. {
  15. template <typename T>
  16. void serialize(const T& obj,const std::string& filename)
  17. {
  18. std::ofstream fout(filename.c_str(),std::ios::out | std::ios::binary);
  19. if(fout.is_open())
  20. {
  21. std::vector<char> buffer;
  22. serialize(obj,"obj",buffer);
  23. fout.write(&buffer[0],buffer.size());
  24. fout.close();
  25. }
  26. else
  27. {
  28. std::cerr << "Saving binary serialization failed!" << std::endl;
  29. }
  30. }
  31. template <typename T>
  32. void serialize(const T& obj,const std::string& objectName,std::vector<char>& buffer)
  33. {
  34. static_assert(detail::is_serializable<T>::value,"'igl::serialize': type is not serializable");
  35. // serialize object data
  36. size_t size = detail::getByteSize(obj);
  37. std::vector<char> tmp(size);
  38. detail::serialize(obj,tmp,tmp.begin());
  39. std::string objectType(typeid(obj).name());
  40. size_t curSize = buffer.size();
  41. size_t objSize = tmp.size();
  42. size_t newSize = curSize + detail::getByteSize(objectName) + detail::getByteSize(objectType) + sizeof(size_t)+objSize;
  43. buffer.resize(newSize);
  44. std::vector<char>::iterator iter = buffer.begin()+curSize;
  45. // serialize object header (name/type/size)
  46. detail::serialize(objectName,buffer,iter);
  47. detail::serialize(objectType,buffer,iter);
  48. detail::serialize(objSize,buffer,iter);
  49. // copy serilized data to buffer
  50. iter = std::copy(tmp.begin(),tmp.end(),iter);
  51. }
  52. template <typename T>
  53. void deserialize(T& obj,const std::string& filename)
  54. {
  55. std::ifstream file(filename.c_str(),std::ios::binary);
  56. if(file.is_open())
  57. {
  58. file.seekg(0,std::ios::end);
  59. int size = file.tellg();
  60. file.seekg(0,std::ios::beg);
  61. std::vector<char> buffer(size);
  62. file.read(&buffer[0],size);
  63. deserialize(obj,"obj",buffer);
  64. file.close();
  65. }
  66. else
  67. {
  68. std::cerr << "Loading binary serialization failed!" << std::endl;
  69. }
  70. }
  71. template <typename T>
  72. void deserialize(T& obj,const std::string& objectName,const std::vector<char>& buffer)
  73. {
  74. static_assert(detail::is_serializable<T>::value,"'igl::deserialize': type is not deserializable");
  75. // find suitable object header
  76. std::vector<char>::const_iterator iter = buffer.begin();
  77. while(iter != buffer.end())
  78. {
  79. std::string name;
  80. std::string type;
  81. size_t size;
  82. detail::deserialize(name,iter);
  83. detail::deserialize(type,iter);
  84. detail::deserialize(size,iter);
  85. if(name == objectName && type == typeid(obj).name())
  86. break;
  87. else
  88. iter+=size;
  89. }
  90. if(iter != buffer.end())
  91. detail::deserialize(obj,iter);
  92. else
  93. obj = T();
  94. }
  95. namespace detail
  96. {
  97. // fundamental types
  98. template <typename T>
  99. typename std::enable_if_t<std::is_fundamental<T>::value,size_t> getByteSize(const T& obj)
  100. {
  101. return sizeof(T);
  102. }
  103. template <typename T>
  104. std::enable_if_t<std::is_fundamental<T>::value> serialize(const T& obj,std::vector<char>& buffer,std::vector<char>::iterator& iter)
  105. {
  106. const uint8_t* ptr = reinterpret_cast<const uint8_t*>(&obj);
  107. iter = std::copy(ptr,ptr+sizeof(T),iter);
  108. }
  109. template <typename T>
  110. std::enable_if_t<std::is_fundamental<T>::value> deserialize(T& obj,std::vector<char>::const_iterator& iter)
  111. {
  112. uint8_t* ptr = reinterpret_cast<uint8_t*>(&obj);
  113. std::copy(iter,iter+sizeof(T),ptr);
  114. iter += sizeof(T);
  115. }
  116. // std::string
  117. size_t getByteSize(const std::string& obj)
  118. {
  119. return getByteSize(obj.length())+obj.length()*sizeof(uint8_t);
  120. }
  121. void serialize(const std::string& obj,std::vector<char>& buffer,std::vector<char>::iterator& iter)
  122. {
  123. detail::serialize(obj.length(),buffer,iter);
  124. for(const auto& cur : obj) { detail::serialize(cur,buffer,iter); }
  125. }
  126. void deserialize(std::string& obj,std::vector<char>::const_iterator& iter)
  127. {
  128. size_t size;
  129. detail::deserialize(size,iter);
  130. std::string str(size,'\0');
  131. for(size_t i=0; i<size; ++i)
  132. {
  133. detail::deserialize(str.at(i),iter);
  134. }
  135. obj = str;
  136. }
  137. // Serializable
  138. template <typename T>
  139. typename std::enable_if_t<std::is_base_of<Serializable,T>::value,size_t> getByteSize(const T& obj)
  140. {
  141. return sizeof(std::vector<char>::size_type);
  142. }
  143. template <typename T>
  144. std::enable_if_t<std::is_base_of<Serializable,T>::value> serialize(const T& obj,std::vector<char>& buffer,std::vector<char>::iterator& iter)
  145. {
  146. // data
  147. std::vector<char> tmp;
  148. obj.Serialize(tmp);
  149. // size
  150. size_t size = buffer.size();
  151. detail::serialize(tmp.size(),buffer,iter);
  152. size_t cur = iter - buffer.begin();
  153. buffer.resize(size+tmp.size());
  154. iter = buffer.begin()+cur;
  155. iter = std::copy(tmp.begin(),tmp.end(),iter);
  156. }
  157. template <typename T>
  158. std::enable_if_t<std::is_base_of<Serializable,T>::value> deserialize(T& obj,std::vector<char>::const_iterator& iter)
  159. {
  160. std::vector<char>::size_type size;
  161. detail::deserialize(size,iter);
  162. std::vector<char> tmp;
  163. tmp.resize(size);
  164. std::copy(iter,iter+size,tmp.begin());
  165. obj.Deserialize(tmp);
  166. iter += size;
  167. }
  168. // STL containers
  169. // std::pair
  170. template <typename T1,typename T2>
  171. size_t getByteSize(const std::pair<T1,T2>& obj)
  172. {
  173. return getByteSize(obj.first)+getByteSize(obj.second);
  174. }
  175. template <typename T1,typename T2>
  176. void serialize(const std::pair<T1,T2>& obj,std::vector<char>& buffer,std::vector<char>::iterator& iter)
  177. {
  178. detail::serialize(obj.first,buffer,iter);
  179. detail::serialize(obj.second,buffer,iter);
  180. }
  181. template <typename T1,typename T2>
  182. void deserialize(std::pair<T1,T2>& obj,std::vector<char>::const_iterator& iter)
  183. {
  184. detail::deserialize(obj.first,iter);
  185. detail::deserialize(obj.second,iter);
  186. }
  187. // std::vector
  188. template <typename T1,typename T2>
  189. size_t getByteSize(const std::vector<T1,T2>& obj)
  190. {
  191. return std::accumulate(obj.begin(),obj.end(),sizeof(size_t),[](const size_t& acc,const T1& cur) { return acc+getByteSize(cur); });
  192. }
  193. template <typename T1,typename T2>
  194. void serialize(const std::vector<T1,T2>& obj,std::vector<char>& buffer,std::vector<char>::iterator& iter)
  195. {
  196. size_t size = obj.size();
  197. detail::serialize(size,buffer,iter);
  198. for(const auto& cur : obj)
  199. {
  200. detail::serialize(cur,buffer,iter);
  201. }
  202. }
  203. template <typename T1,typename T2>
  204. void deserialize(std::vector<T1,T2>& obj,std::vector<char>::const_iterator& iter)
  205. {
  206. size_t size;
  207. detail::deserialize(size,iter);
  208. obj.resize(size);
  209. for(size_t i=0; i<size; ++i)
  210. {
  211. detail::deserialize(obj[i],iter);
  212. }
  213. }
  214. //std::set
  215. template <typename T>
  216. size_t getByteSize(const std::set<T>& obj)
  217. {
  218. return std::accumulate(obj.begin(),obj.end(),getByteSize(obj.size()),[](const size_t& acc,const T& cur) { return acc+getByteSize(cur); });
  219. }
  220. template <typename T>
  221. void serialize(const std::set<T>& obj,std::vector<char>& buffer,std::vector<char>::iterator& iter)
  222. {
  223. detail::serialize(obj.size(),buffer,iter);
  224. for(const auto& cur : obj) { detail::serialize(cur,buffer,iter); }
  225. }
  226. template <typename T>
  227. void deserialize(std::set<T>& obj,std::vector<char>::const_iterator& iter)
  228. {
  229. size_t size;
  230. detail::deserialize(size,iter);
  231. obj.clear();
  232. for(size_t i=0; i<size; ++i)
  233. {
  234. T val;
  235. detail::deserialize(val,iter);
  236. obj.insert(val);
  237. }
  238. }
  239. // std::map
  240. template <typename T1,typename T2>
  241. size_t getByteSize(const std::map<T1,T2>& obj)
  242. {
  243. return std::accumulate(obj.begin(),obj.end(),sizeof(size_t),[](const size_t& acc,const std::pair<T1,T2>& cur) { return acc+getByteSize(cur); });
  244. }
  245. template <typename T1,typename T2>
  246. void serialize(const std::map<T1,T2>& obj,std::vector<char>& buffer,std::vector<char>::iterator& iter)
  247. {
  248. detail::serialize(obj.size(),buffer,iter);
  249. for(const auto& cur : obj) { detail::serialize(cur,buffer,iter); }
  250. }
  251. template <typename T1,typename T2>
  252. void deserialize(std::map<T1,T2>& obj,std::vector<char>::const_iterator& iter)
  253. {
  254. size_t size;
  255. detail::deserialize(size,iter);
  256. obj.clear();
  257. for(size_t i=0; i<size; ++i)
  258. {
  259. std::pair<T1,T2> pair;
  260. detail::deserialize(pair,iter);
  261. obj.insert(pair);
  262. }
  263. }
  264. // Eigen types
  265. template<typename T,int R,int C,int P,int MR,int MC>
  266. size_t getByteSize(const Eigen::Matrix<T,R,C,P,MR,MC>& obj)
  267. {
  268. // space for numbers of rows,cols and data
  269. return 2*sizeof(Eigen::Matrix<T,R,C,P,MR,MC>::Index)+sizeof(T)*obj.rows()*obj.cols();
  270. }
  271. template<typename T,int R,int C,int P,int MR,int MC>
  272. void serialize(const Eigen::Matrix<T,R,C,P,MR,MC>& obj,std::vector<char>& buffer,std::vector<char>::iterator& iter)
  273. {
  274. detail::serialize(obj.rows(),buffer,iter);
  275. detail::serialize(obj.cols(),buffer,iter);
  276. size_t size = sizeof(T)*obj.rows()*obj.cols();
  277. const uint8_t* ptr = reinterpret_cast<const uint8_t*>(obj.data());
  278. iter = std::copy(ptr,ptr+size,iter);
  279. }
  280. template<typename T,int R,int C,int P,int MR,int MC>
  281. void deserialize(Eigen::Matrix<T,R,C,P,MR,MC>& obj,std::vector<char>::const_iterator& iter)
  282. {
  283. Eigen::Matrix<T,R,C,P,MR,MC>::Index rows,cols;
  284. detail::deserialize(rows,iter);
  285. detail::deserialize(cols,iter);
  286. size_t size = sizeof(T)*rows*cols;
  287. obj.resize(rows,cols);
  288. uint8_t* ptr = reinterpret_cast<uint8_t*>(obj.data());
  289. std::copy(iter,iter+size,ptr);
  290. iter+=size;
  291. }
  292. template<typename T,int P,typename I>
  293. size_t getByteSize(const Eigen::SparseMatrix<T,P,I>& obj)
  294. {
  295. // space for numbers of rows,cols,nonZeros and tripplets with data (rowIdx,colIdx,value)
  296. size_t size = sizeof(Eigen::SparseMatrix<T,P,I>::Index);
  297. return 3*size+(sizeof(T)+2*size)*obj.nonZeros();
  298. }
  299. template<typename T,int P,typename I>
  300. void serialize(const Eigen::SparseMatrix<T,P,I>& obj,std::vector<char>& buffer,std::vector<char>::iterator& iter)
  301. {
  302. detail::serialize(obj.rows(),buffer,iter);
  303. detail::serialize(obj.cols(),buffer,iter);
  304. detail::serialize(obj.nonZeros(),buffer,iter);
  305. for(int k=0;k<obj.outerSize();++k)
  306. {
  307. for(typename Eigen::SparseMatrix<T,P,I>::InnerIterator it(obj,k);it;++it)
  308. {
  309. detail::serialize(it.row(),buffer,iter);
  310. detail::serialize(it.col(),buffer,iter);
  311. detail::serialize(it.value(),buffer,iter);
  312. }
  313. }
  314. }
  315. template<typename T,int P,typename I>
  316. void deserialize(Eigen::SparseMatrix<T,P,I>& obj,std::vector<char>::const_iterator& iter)
  317. {
  318. Eigen::SparseMatrix<T,P,I>::Index rows,cols,nonZeros;
  319. detail::deserialize(rows,iter);
  320. detail::deserialize(cols,iter);
  321. detail::deserialize(nonZeros,iter);
  322. obj.resize(rows,cols);
  323. obj.setZero();
  324. std::vector<Eigen::Triplet<T,I> > triplets;
  325. for(int i=0;i<nonZeros;i++)
  326. {
  327. Eigen::SparseMatrix<T,P,I>::Index rowId,colId;
  328. detail::deserialize(rowId,iter);
  329. detail::deserialize(colId,iter);
  330. T value;
  331. detail::deserialize(value,iter);
  332. triplets.push_back(Eigen::Triplet<T,I>(rowId,colId,value));
  333. }
  334. obj.setFromTriplets(triplets.begin(),triplets.end());
  335. }
  336. // pointers
  337. template <typename T>
  338. std::enable_if_t<std::is_pointer<T>::value,size_t> getByteSize(const T& obj)
  339. {
  340. bool isNullPtr = (obj == NULL);
  341. size_t size = sizeof(bool);
  342. if(isNullPtr == false)
  343. size += getByteSize(*obj);
  344. return size;
  345. }
  346. template <typename T>
  347. std::enable_if_t<std::is_pointer<T>::value> serialize(const T& obj,std::vector<char>& buffer,std::vector<char>::iterator& iter)
  348. {
  349. bool isNullPtr = (obj == NULL);
  350. detail::serialize(isNullPtr,buffer,iter);
  351. if(isNullPtr == false)
  352. detail::serialize(*obj,buffer,iter);
  353. }
  354. template <typename T>
  355. std::enable_if_t<std::is_pointer<T>::value> deserialize(T& obj,std::vector<char>::const_iterator& iter)
  356. {
  357. bool isNullPtr;
  358. detail::deserialize(isNullPtr,iter);
  359. if(isNullPtr)
  360. {
  361. if(obj != NULL)
  362. {
  363. std::cout << "deserialization: possible memory leak for '" << typeid(obj).name() << "'" << std::endl;
  364. obj = NULL;
  365. }
  366. }
  367. else
  368. {
  369. if(obj != NULL)
  370. std::cout << "deserialization: possible memory leak for '" << typeid(obj).name() << "'" << std::endl;
  371. obj = new std::remove_pointer<T>::type();
  372. detail::deserialize(*obj,iter);
  373. }
  374. }
  375. }
  376. }