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
00116
00117
00118
00119
00120
00121
00122 std::vector<T>::clear();
00123 std::vector<T>::insert(std::vector<T>::begin(),o.begin(),o.end());
00124 return *this;
00125 }
00126
00127 vector_serializable<T>(const std::vector<T> &o):std::vector<T>(o) {}
00128 vector_serializable<T>():std::vector<T>() {}
00129
00130 void read( utils::CStream &in )
00131 {
00132 uint32_t n;
00133 in >> n;
00134 std::vector<T>::resize(n);
00135 for (typename std::vector<T>::iterator i=std::vector<T>::begin();i!=std::vector<T>::end();i++)
00136 in >> *i;
00137 }
00138 void write( utils::CStream &out ) const
00139 {
00140 out << static_cast<uint32_t>(std::vector<T>::size());
00141 for (typename std::vector<T>::const_iterator i=std::vector<T>::begin();i!=std::vector<T>::end();i++)
00142 out << *i;
00143 }
00144 };
00145
00148 template <class T>
00149 class deque_serializable : public std::deque<T>
00150 {
00151 public:
00152 void read( utils::CStream &in )
00153 {
00154 uint32_t i,n;
00155 in >> n;
00156 std::deque<T>::clear();
00157 for (i=0;i<n;i++)
00158 {
00159 T obj;
00160 std::deque<T>::push_back(obj);
00161 T & theObj = std::deque<T>::back();
00162 in >> theObj;
00163 }
00164 }
00165 void write( utils::CStream &out ) const
00166 {
00167 out << static_cast<uint32_t>(std::deque<T>::size());
00168 for (typename std::deque<T>::const_iterator i=std::deque<T>::begin();i!=std::deque<T>::end();i++)
00169 out << *i;
00170 }
00171 };
00172
00175 template <class T>
00176 class list_searchable_serializable : public list_searchable<T>
00177 {
00178 public:
00179 void read( utils::CStream &in )
00180 {
00181 uint32_t i,n;
00182 in >> n;
00183 list_searchable<T>::clear();
00184 for (i=0;i<n;i++)
00185 {
00186
00187 list_searchable<T>::push_back( T() );
00188 T & theObj = list_searchable<T>::back();
00189 in >> theObj;
00190 }
00191 }
00192 void write( utils::CStream &out ) const
00193 {
00194 out << static_cast<uint32_t>(list_searchable<T>::size());
00195 for (typename list_searchable<T>::const_iterator i=list_searchable<T>::begin();i!=list_searchable<T>::end();i++)
00196 out << *i;
00197 }
00198 };
00199
00202 template <class K,class V>
00203 class map_serializable: public std::map<K,V>
00204 {
00205 public:
00206 void read( utils::CStream &in )
00207 {
00208 uint32_t i,n;
00209 in >> n;
00210 std::map<K,V>::clear();
00211 for (i=0;i<n;i++)
00212 {
00213 K key_obj;
00214 in >> key_obj;
00215
00216 V &val_obj = std::map<K,V>::operator[] (key_obj);
00217 in >> val_obj;
00218 }
00219 }
00220 void write( utils::CStream &out ) const
00221 {
00222 out << static_cast<uint32_t>(std::map<K,V>::size());
00223 for (typename std::map<K,V>::const_iterator i=std::map<K,V>::begin();i!=std::map<K,V>::end();i++)
00224 out << i->first << i->second;
00225 }
00226 };
00227
00230 template <class K,class V>
00231 class multimap_serializable: public std::multimap<K,V>
00232 {
00233 public:
00234 void read( utils::CStream &in )
00235 {
00236 uint32_t i,n;
00237 in >> n;
00238 std::multimap<K,V>::clear();
00239 typename std::multimap<K,V>::iterator it;
00240 for (i=0;i<n;i++)
00241 {
00242 K key_obj;
00243 in >> key_obj;
00244
00245 it = std::multimap<K,V>::insert( std::pair<K,V>(key_obj,V()) );
00246 in >> it->second;
00247 }
00248 }
00249 void write( utils::CStream &out ) const
00250 {
00251 out << static_cast<uint32_t>(std::multimap<K,V>::size());
00252 for (typename std::multimap<K,V>::const_iterator i=std::multimap<K,V>::begin();i!=std::multimap<K,V>::end();i++)
00253 out << i->first << i->second;
00254 }
00255 };
00256
00257
00258
00261 template <class T>
00262 size_t find_in_vector(const T &value, const std::vector<T> &vect)
00263 {
00264 for (size_t i=0;i<vect.size();i++)
00265 if (vect[i]==value) return i;
00266 return std::string::npos;
00267 }
00268
00269
00270 }
00271 }
00272 #endif