binary_archive.hpp 3.71 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <cassert>
#include <iostream>
#include <sstream>
#include <string>

// Quick hack for definition of 'I' in <complex.h>
#undef I
#include <boost/filesystem.hpp>

#include <Eigen/Core>

namespace limbo {
    namespace serialize {

        class BinaryArchive {
        public:
            BinaryArchive(const std::string& dir_name) : _dir_name(dir_name) {}

            /// write an Eigen::Matrix*
20
            void save(const Eigen::MatrixXd& v, const std::string& object_name) const
21
22
23
24
25
26
27
28
29
30
            {
                _create_directory();

                std::ofstream out(fname(object_name).c_str(), std::ios::out | std::ios::binary | std::ios::trunc);
                _write_binary(out, v);
                out.close();
            }

            /// write a vector of Eigen::Vector*
            template <typename T>
31
            void save(const std::vector<T>& v, const std::string& object_name) const
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
            {
                _create_directory();

                std::stringstream s;

                int size = v.size();
                s.write((char*)(&size), sizeof(int));
                for (auto& x : v) {
                    _write_binary(s, x);
                }

                std::ofstream out(fname(object_name).c_str(), std::ios::out | std::ios::binary | std::ios::trunc);
                out << s.rdbuf();
                out.close();
            }

            /// load an Eigen matrix (or vector)
            template <typename M>
50
            void load(M& m, const std::string& object_name) const
51
52
53
54
55
56
57
58
            {
                std::ifstream in(fname(object_name).c_str(), std::ios::in | std::ios::binary);
                _read_binary(in, m);
                in.close();
            }

            /// load a vector of Eigen::Vector*
            template <typename V>
59
            void load(std::vector<V>& m_list, const std::string& object_name) const
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
            {
                m_list.clear();

                std::ifstream in(fname(object_name).c_str(), std::ios::in | std::ios::binary);

                int size;
                in.read((char*)(&size), sizeof(int));

                for (int i = 0; i < size; i++) {
                    V v;
                    _read_binary(in, v);
                    m_list.push_back(v);
                }
                in.close();
                assert(!m_list.empty());
            }

            std::string fname(const std::string& object_name) const
            {
                return _dir_name + "/" + object_name + ".bin";
            }

        protected:
            std::string _dir_name;

85
            void _create_directory() const
86
87
88
89
90
91
            {
                boost::filesystem::path my_path(_dir_name);
                boost::filesystem::create_directory(my_path);
            }

            template <class Matrix, class Stream>
92
            void _write_binary(Stream& out, const Matrix& matrix) const
93
94
95
96
97
98
99
100
            {
                typename Matrix::Index rows = matrix.rows(), cols = matrix.cols();
                out.write((char*)(&rows), sizeof(typename Matrix::Index));
                out.write((char*)(&cols), sizeof(typename Matrix::Index));
                out.write((char*)matrix.data(), rows * cols * sizeof(typename Matrix::Scalar));
            }

            template <class Matrix, class Stream>
101
            void _read_binary(Stream& in, Matrix& matrix) const
102
103
104
105
106
107
108
109
110
111
            {
                typename Matrix::Index rows = 0, cols = 0;
                in.read((char*)(&rows), sizeof(typename Matrix::Index));
                in.read((char*)(&cols), sizeof(typename Matrix::Index));
                matrix.resize(rows, cols);
                in.read((char*)matrix.data(), rows * cols * sizeof(typename Matrix::Scalar));
            }
        };
    } // namespace serialize
} // namespace limbo