00001
00002
00003 #ifndef __Pickler
00004 #define __Pickler
00005
00006 #include <iostream>
00007 #include <string>
00008 #include <vector>
00009 #include <map>
00010 #include "tpt_typedefs.h"
00011 #include "num_read_write.h"
00012 #include <cassert>
00013
00014 namespace tpt
00015 {
00018 ::uint64_t getFileSize(const std::string& fname);
00019
00025 void binwrite(std::ostream& out, char data);
00026 void binwrite(std::ostream& out, unsigned char data);
00027 void binwrite(std::ostream& out, unsigned short data);
00028 void binwrite(std::ostream& out, unsigned int data);
00029 void binwrite(std::ostream& out, unsigned long data);
00030 void binwrite(std::ostream& out, size_t data);
00031 void binwrite(std::ostream& out, unsigned long long data);
00032 void binwrite(std::ostream& out, std::string const& data);
00033 void binwrite(std::ostream& out, float data);
00034
00035 void binread(std::istream& in, char &data);
00036 void binread(std::istream& in, unsigned char &data);
00037 void binread(std::istream& in, unsigned short &data);
00038 void binread(std::istream& in, unsigned int &data);
00039 void binread(std::istream& in, unsigned long &data);
00040 void binread(std::istream& in, size_t &data);
00041 void binread(std::istream& in, unsigned long long &data);
00042 void binread(std::istream& in, std::string &data);
00043 void binread(std::istream& in, float &data);
00044
00045 char const *binread(char const* p, uint16_t& buf);
00046 char const *binread(char const* p, uint32_t& buf);
00047 char const *binread(char const* p, uint64_t& buf);
00048 char const *binread(char const* p, float& buf);
00049 #ifdef __clang__
00050 char const *binread(char const* p, size_t& buf);
00051 #endif
00052
00053 std::ostream& write(std::ostream& out, char x);
00054 std::ostream& write(std::ostream& out, unsigned char x);
00055 std::ostream& write(std::ostream& out, short x);
00056 std::ostream& write(std::ostream& out, unsigned short x);
00057 std::ostream& write(std::ostream& out, long x);
00058 std::ostream& write(std::ostream& out, size_t x);
00059 std::ostream& write(std::ostream& out, float x);
00060
00061 std::istream& read(std::istream& in, char& x);
00062 std::istream& read(std::istream& in, unsigned char& x);
00063 std::istream& read(std::istream& in, short& x);
00064 std::istream& read(std::istream& in, unsigned short& x);
00065 std::istream& read(std::istream& in, long& x);
00066 std::istream& read(std::istream& in, size_t& x);
00067 std::istream& read(std::istream& in, float& x);
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079 template<typename K, typename V>
00080 void binwrite(std::ostream& out, std::pair<K,V> const& data);
00081
00082 template<typename K, typename V>
00083 void binread(std::istream& in, std::pair<K,V>& data);
00084
00085 template<typename K, typename V>
00086 char const* binread(char const* p, std::pair<K,V>& data);
00087
00088 template<typename V>
00089 char const* binread(char const* p, std::vector<V>& v);
00090
00091
00092 template<typename K, typename V>
00093 char const* binread(char const* p, std::pair<K,V>& data)
00094 {
00095 #ifdef VERIFY_TIGHT_PACKING
00096 assert(p);
00097 #endif
00098 p = binread(p,data.first);
00099 p = binread(p,data.second);
00100 return p;
00101 }
00102
00103 template<typename V>
00104 char const* binread(char const* p, std::vector<V>& v)
00105 {
00106 size_t vsize;
00107 #ifdef VERIFY_TIGHT_PACKING
00108 assert(p);
00109 #endif
00110 p = binread(p, vsize);
00111 v.resize(vsize);
00112 for (size_t i = 0; i < vsize; ++i)
00113 p = binread(p,v[i]);
00114 return p;
00115 }
00116
00117 template<typename T>
00118 T read(std::istream& in)
00119 {
00120 T ret;
00121 read(in,ret);
00122 return ret;
00123 }
00124
00125 template<typename T>
00126 T binread(std::istream& in)
00127 {
00128 T ret;
00129 binread(in,ret);
00130 return ret;
00131 }
00132
00133
00134 template<typename T>
00135 void
00136 binwrite(std::ostream& out, std::vector<T> const& data)
00137 {
00138 binwrite(out,data.size());
00139 for (size_t i = 0; i < data.size(); i++)
00140 { binwrite(out,data[i]); }
00141 }
00142
00143 template<typename T>
00144 void
00145 binread(std::istream& in, std::vector<T>& data)
00146 {
00147 size_t s;
00148 binread(in,s);
00149 data.resize(s);
00150 for (size_t i = 0; i < s; i++)
00151 { binread(in,data[i]); }
00152 }
00153
00154 template<typename K, typename V>
00155 void
00156 binread(std::istream& in, std::map<K,V>& data)
00157 {
00158 size_t s; K k; V v;
00159 binread(in,s);
00160 data.clear();
00161
00162
00163 for (size_t i = 0; i < s; i++)
00164 {
00165 binread(in,k);
00166 binread(in,v);
00167 data[k] = v;
00168
00169 }
00170 }
00171
00172 template<typename K, typename V>
00173 void
00174 binwrite(std::ostream& out, std::map<K,V> const& data)
00175 {
00176 binwrite(out,data.size());
00177 for (typename std::map<K,V>::const_iterator m = data.begin();
00178 m != data.end(); m++)
00179 {
00180 binwrite(out,m->first);
00181 binwrite(out,m->second);
00182 }
00183 }
00184
00185 template<typename K, typename V>
00186 void
00187 binwrite(std::ostream& out, std::pair<K,V> const& data)
00188 {
00189 binwrite(out,data.first);
00190 binwrite(out,data.second);
00191 }
00192
00193 template<typename K, typename V>
00194 void
00195 binread(std::istream& in, std::pair<K,V>& data)
00196 {
00197 binread(in,data.first);
00198 binread(in,data.second);
00199 }
00200
00201
00202 template<typename WHATEVER>
00203 char const*
00204 binread(char const* p, WHATEVER* buf)
00205 {
00206 #ifdef VERIFY_TIGHT_PACKING
00207 assert(p);
00208 #endif
00209 return binread(p,*buf);
00210 }
00211
00212 }
00213 #endif