00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028 #ifndef stl_extensions_H
00029 #define stl_extensions_H
00030
00031 #include <mrpt/utils/CSerializable.h>
00032 #include <mrpt/utils/CStream.h>
00033
00034 #include <set>
00035 #include <map>
00036 #include <list>
00037
00038 namespace mrpt
00039 {
00040 namespace utils
00041 {
00042
00043 template <class T> class vector_serializable;
00044 template <class T> class deque_serializable;
00045 template <class T> class list_searchable;
00046 template <class T> class list_searchable_serializable;
00047 template <class K,class V> class map_serializable;
00048
00049
00050
00051 typedef vector_serializable<int64_t> vector_long_serializable;
00052 typedef vector_serializable<int32_t> vector_int_serializable;
00053 typedef vector_serializable<float> vector_float_serializable;
00054 typedef vector_serializable<double> vector_double_serializable;
00055 typedef vector_serializable<uint16_t> vector_word_serializable;
00056 typedef vector_serializable<uint32_t> vector_uint_serializable;
00057 typedef vector_serializable<bool> vector_bool_serializable;
00058 typedef vector_serializable<uint8_t> vector_byte_serializable;
00059 typedef vector_serializable<size_t> vector_size_t_serializable;
00060
00061
00062
00063 #define DECLARE_STREAMING_FUNCTIONS(class_name) \
00064 template <class T> CStream& operator << (CStream& out, const class_name<T> &obj) \
00065 { obj.write(out); return out; } \
00066 template <class T> CStream& operator >> (CStream& in, class_name<T> &obj) \
00067 { obj.read(in); return in; }
00068
00069 #define DECLARE_STREAMING_FUNCTIONS2(class_name) \
00070 template <class T,class V> CStream& operator << (CStream& out, const class_name<T,V> &obj) \
00071 { obj.write(out); return out; } \
00072 template <class T,class V> CStream& operator >> (CStream& in, class_name<T,V> &obj) \
00073 { obj.read(in); return in; }
00074
00075 DECLARE_STREAMING_FUNCTIONS(vector_serializable)
00076 DECLARE_STREAMING_FUNCTIONS(deque_serializable)
00077 DECLARE_STREAMING_FUNCTIONS(list_searchable_serializable)
00078 DECLARE_STREAMING_FUNCTIONS2(map_serializable)
00079
00080
00083 template <class T>
00084 class list_searchable : public std::list<T>
00085 {
00086 public:
00087 void insert( const T &o ) { std::list<T>::push_back(o); }
00088
00089 typename std::list<T>::iterator find( const T& i )
00090 {
00091 for (typename std::list<T>::iterator it=std::list<T>::begin();it!=std::list<T>::end();it++)
00092 if (*it==i)
00093 return it;
00094 return std::list<T>::end();
00095 }
00096
00097 typename std::list<T>::const_iterator find( const T& i ) const
00098 {
00099 for (typename std::list<T>::const_iterator it=std::list<T>::begin();it!=std::list<T>::end();it++)
00100 if (*it==i)
00101 return it;
00102 return std::list<T>::end();
00103 }
00104
00105 };
00106
00109 template <class T>
00110 class vector_serializable : public std::vector<T>
00111 {
00112 public:
00113 vector_serializable<T> & operator =(const std::vector<T> &o )
00114 {
00115 std::vector<T>::resize(o.size());
00116 typename std::vector<T>::iterator me;
00117 typename std::vector<T>::const_iterator he;
00118 for (me=std::vector<T>::begin(),he=o.begin();me!=std::vector<T>::end();me++,he++)
00119 *me = *he;
00120 return *this;
00121 }
00122
00123 void read( utils::CStream &in )
00124 {
00125 uint32_t n;
00126 in >> n;
00127 std::vector<T>::resize(n);
00128 for (typename std::vector<T>::iterator i=std::vector<T>::begin();i!=std::vector<T>::end();i++)
00129 in >> *i;
00130 }
00131 void write( utils::CStream &out ) const
00132 {
00133 out << static_cast<uint32_t>(std::vector<T>::size());
00134 for (typename std::vector<T>::const_iterator i=std::vector<T>::begin();i!=std::vector<T>::end();i++)
00135 out << *i;
00136 }
00137 };
00138
00141 template <class T>
00142 class deque_serializable : public std::deque<T>
00143 {
00144 public:
00145 void read( utils::CStream &in )
00146 {
00147 uint32_t i,n;
00148 in >> n;
00149 std::deque<T>::clear();
00150 for (i=0;i<n;i++)
00151 {
00152 T obj;
00153 std::deque<T>::push_back(obj);
00154 T & theObj = std::deque<T>::back();
00155 in >> theObj;
00156 }
00157 }
00158 void write( utils::CStream &out ) const
00159 {
00160 out << static_cast<uint32_t>(std::deque<T>::size());
00161 for (typename std::deque<T>::const_iterator i=std::deque<T>::begin();i!=std::deque<T>::end();i++)
00162 out << *i;
00163 }
00164 };
00165
00168 template <class T>
00169 class list_searchable_serializable : public list_searchable<T>
00170 {
00171 public:
00172 void read( utils::CStream &in )
00173 {
00174 uint32_t i,n;
00175 in >> n;
00176 list_searchable<T>::clear();
00177 for (i=0;i<n;i++)
00178 {
00179
00180 list_searchable<T>::push_back( T() );
00181 T & theObj = list_searchable<T>::back();
00182 in >> theObj;
00183 }
00184 }
00185 void write( utils::CStream &out ) const
00186 {
00187 out << static_cast<uint32_t>(list_searchable<T>::size());
00188 for (typename list_searchable<T>::const_iterator i=list_searchable<T>::begin();i!=list_searchable<T>::end();i++)
00189 out << *i;
00190 }
00191 };
00192
00195 template <class K,class V>
00196 class map_serializable: public std::map<K,V>
00197 {
00198 public:
00199 void read( utils::CStream &in )
00200 {
00201 uint32_t i,n;
00202 in >> n;
00203 std::map<K,V>::clear();
00204 for (i=0;i<n;i++)
00205 {
00206 K key_obj;
00207 in >> key_obj;
00208
00209 V &val_obj = std::map<K,V>::operator[] (key_obj);
00210 in >> val_obj;
00211 }
00212 }
00213 void write( utils::CStream &out ) const
00214 {
00215 out << static_cast<uint32_t>(std::map<K,V>::size());
00216 for (typename std::map<K,V>::const_iterator i=std::map<K,V>::begin();i!=std::map<K,V>::end();i++)
00217 out << i->first << i->second;
00218 }
00219 };
00220
00223 template <class K,class V>
00224 class multimap_serializable: public std::multimap<K,V>
00225 {
00226 public:
00227 void read( utils::CStream &in )
00228 {
00229 uint32_t i,n;
00230 in >> n;
00231 std::multimap<K,V>::clear();
00232 typename std::multimap<K,V>::iterator it;
00233 for (i=0;i<n;i++)
00234 {
00235 K key_obj;
00236 in >> key_obj;
00237
00238 it = std::multimap<K,V>::insert( std::pair<K,V>(key_obj,V()) );
00239 in >> it->second;
00240 }
00241 }
00242 void write( utils::CStream &out ) const
00243 {
00244 out << static_cast<uint32_t>(std::multimap<K,V>::size());
00245 for (typename std::multimap<K,V>::const_iterator i=std::multimap<K,V>::begin();i!=std::multimap<K,V>::end();i++)
00246 out << i->first << i->second;
00247 }
00248 };
00249
00250
00251 }
00252 }
00253 #endif