Geant4 Cross Reference |
1 // Copyright (C) 2010, Guy Barrand. All rights 1 // Copyright (C) 2010, Guy Barrand. All rights reserved. 2 // See the file tools.license for terms. 2 // See the file tools.license for terms. 3 3 4 #ifndef tools_rroot_stl_vector 4 #ifndef tools_rroot_stl_vector 5 #define tools_rroot_stl_vector 5 #define tools_rroot_stl_vector 6 6 7 #include "buffer" 7 #include "buffer" 8 #include "cids" 8 #include "cids" 9 9 10 #include "../stype" 10 #include "../stype" 11 #include "../scast" 11 #include "../scast" 12 #include "../cids" 12 #include "../cids" 13 13 14 namespace tools { 14 namespace tools { 15 namespace rroot { 15 namespace rroot { 16 16 17 template <class T> 17 template <class T> 18 class stl_vector : public virtual iro, public 18 class stl_vector : public virtual iro, public std::vector<T> { 19 static const std::string& s_store_class() { 19 static const std::string& s_store_class() { 20 static const std::string s_v("vector<"+sty 20 static const std::string s_v("vector<"+stype(T())+">"); 21 return s_v; 21 return s_v; 22 } 22 } 23 public: 23 public: 24 static const std::string& s_class() { 24 static const std::string& s_class() { 25 static const std::string s_v("tools::rroot 25 static const std::string s_v("tools::rroot::stl_vector<"+stype(T())+">"); 26 return s_v; 26 return s_v; 27 } 27 } 28 public: //iro 28 public: //iro 29 virtual void* cast(const std::string& a_clas 29 virtual void* cast(const std::string& a_class) const { 30 if(void* p = cmp_cast< stl_vector<T> >(thi 30 if(void* p = cmp_cast< stl_vector<T> >(this,a_class)) return p; 31 return 0; 31 return 0; 32 } 32 } 33 virtual const std::string& s_cls() const {re 33 virtual const std::string& s_cls() const {return s_class();} 34 public: 34 public: 35 static cid id_class() {return stl_vector_cid 35 static cid id_class() {return stl_vector_cid()+_cid(T());} 36 virtual void* cast(cid a_class) const { 36 virtual void* cast(cid a_class) const { 37 if(void* p = cmp_cast< stl_vector<T> >(thi 37 if(void* p = cmp_cast< stl_vector<T> >(this,a_class)) {return p;} 38 return 0; 38 return 0; 39 } 39 } 40 virtual iro* copy() const {return new stl_ve 40 virtual iro* copy() const {return new stl_vector<T>(*this);} 41 virtual bool stream(buffer& a_buffer) { 41 virtual bool stream(buffer& a_buffer) { 42 std::vector<T>::clear(); 42 std::vector<T>::clear(); 43 43 44 short v; 44 short v; 45 unsigned int _s,_c; 45 unsigned int _s,_c; 46 if(!a_buffer.read_version(v,_s,_c)) return 46 if(!a_buffer.read_version(v,_s,_c)) return false; 47 47 48 //::printf("debug : stl_vector::stream<%s> 48 //::printf("debug : stl_vector::stream<%s> : version %d, byte count %d\n", 49 // stype(T()).c_str(),v,c); 49 // stype(T()).c_str(),v,c); 50 50 51 unsigned int num; 51 unsigned int num; 52 if(!a_buffer.read(num)) return false; 52 if(!a_buffer.read(num)) return false; 53 53 54 //::printf("debug : stl_vector : %d\n",num 54 //::printf("debug : stl_vector : %d\n",num); 55 55 56 if(num) { 56 if(num) { 57 T* vec = new T[num]; 57 T* vec = new T[num]; 58 if(!a_buffer.read_fast_array<T>(vec,num) 58 if(!a_buffer.read_fast_array<T>(vec,num)) { 59 delete [] vec; 59 delete [] vec; 60 return false; 60 return false; 61 } 61 } 62 std::vector<T>::resize(num); 62 std::vector<T>::resize(num); 63 T* pos = vec; 63 T* pos = vec; 64 for(unsigned int index=0;index<num;index 64 for(unsigned int index=0;index<num;index++,pos++) { 65 std::vector<T>::operator[](index) = *p 65 std::vector<T>::operator[](index) = *pos; 66 } 66 } 67 delete [] vec; 67 delete [] vec; 68 } 68 } 69 69 70 return a_buffer.check_byte_count(_s,_c,s_s 70 return a_buffer.check_byte_count(_s,_c,s_store_class()); 71 } 71 } 72 public: 72 public: 73 stl_vector(){ 73 stl_vector(){ 74 #ifdef TOOLS_MEM 74 #ifdef TOOLS_MEM 75 mem::increment(s_class().c_str()); 75 mem::increment(s_class().c_str()); 76 #endif 76 #endif 77 } 77 } 78 virtual ~stl_vector(){ 78 virtual ~stl_vector(){ 79 #ifdef TOOLS_MEM 79 #ifdef TOOLS_MEM 80 mem::decrement(s_class().c_str()); 80 mem::decrement(s_class().c_str()); 81 #endif 81 #endif 82 } 82 } 83 public: 83 public: 84 stl_vector(const stl_vector& a_from) 84 stl_vector(const stl_vector& a_from) 85 :iro(a_from) 85 :iro(a_from) 86 ,std::vector<T>(a_from) 86 ,std::vector<T>(a_from) 87 { 87 { 88 #ifdef TOOLS_MEM 88 #ifdef TOOLS_MEM 89 mem::increment(s_class().c_str()); 89 mem::increment(s_class().c_str()); 90 #endif 90 #endif 91 } 91 } 92 stl_vector& operator=(const stl_vector& a_fr 92 stl_vector& operator=(const stl_vector& a_from){ 93 std::vector<T>::operator=(a_from); 93 std::vector<T>::operator=(a_from); 94 return *this; 94 return *this; 95 } 95 } 96 }; 96 }; 97 97 98 template <class T> 98 template <class T> 99 class stl_vector_vector 99 class stl_vector_vector 100 :public virtual iro 100 :public virtual iro 101 ,public std::vector< std::vector<T> > 101 ,public std::vector< std::vector<T> > 102 { 102 { 103 static const std::string& s_store_class() { 103 static const std::string& s_store_class() { 104 static const std::string s_v("vector<vecto 104 static const std::string s_v("vector<vector<"+stype(T())+"> >"); 105 return s_v; 105 return s_v; 106 } 106 } 107 public: 107 public: 108 static const std::string& s_class() { 108 static const std::string& s_class() { 109 static const std::string s_v 109 static const std::string s_v 110 ("tools::rroot::stl_vector_vector<"+styp 110 ("tools::rroot::stl_vector_vector<"+stype(T())+">"); 111 return s_v; 111 return s_v; 112 } 112 } 113 public: //iro 113 public: //iro 114 virtual void* cast(const std::string& a_clas 114 virtual void* cast(const std::string& a_class) const { 115 if(void* p=cmp_cast< stl_vector_vector<T> 115 if(void* p=cmp_cast< stl_vector_vector<T> >(this,a_class)) return p; 116 return 0; 116 return 0; 117 } 117 } 118 virtual const std::string& s_cls() const {re 118 virtual const std::string& s_cls() const {return s_class();} 119 public: 119 public: 120 static cid id_class() {return stl_vector_vec 120 static cid id_class() {return stl_vector_vector_cid()+_cid(T());} 121 virtual void* cast(cid a_class) const { 121 virtual void* cast(cid a_class) const { 122 if(void* p = cmp_cast< stl_vector_vector<T 122 if(void* p = cmp_cast< stl_vector_vector<T> >(this,a_class)) {return p;} 123 return 0; 123 return 0; 124 } 124 } 125 virtual iro* copy() const {return new stl_ve 125 virtual iro* copy() const {return new stl_vector_vector<T>(*this);} 126 virtual bool stream(buffer& a_buffer) { 126 virtual bool stream(buffer& a_buffer) { 127 typedef typename std::vector<T> vec_t; 127 typedef typename std::vector<T> vec_t; 128 std::vector<vec_t>::clear(); 128 std::vector<vec_t>::clear(); 129 129 130 short v; 130 short v; 131 unsigned int _s,_c; 131 unsigned int _s,_c; 132 if(!a_buffer.read_version(v,_s,_c)) return 132 if(!a_buffer.read_version(v,_s,_c)) return false; 133 133 134 //::printf("debug : stl_vector_vector::str 134 //::printf("debug : stl_vector_vector::stream<%s> : version %d, byte count %d\n",stype(T()).c_str(),v,c); 135 135 136 unsigned int vecn; 136 unsigned int vecn; 137 if(!a_buffer.read(vecn)) return false; 137 if(!a_buffer.read(vecn)) return false; 138 138 139 std::vector<vec_t>::resize(vecn); 139 std::vector<vec_t>::resize(vecn); 140 //::printf("debug : stl_vector_vector : %d 140 //::printf("debug : stl_vector_vector : %d\n",vecn); 141 for(unsigned int veci=0;veci<vecn;veci++) 141 for(unsigned int veci=0;veci<vecn;veci++) { 142 vec_t& elem = std::vector<vec_t>::operat 142 vec_t& elem = std::vector<vec_t>::operator[](veci); 143 143 144 unsigned int num; 144 unsigned int num; 145 if(!a_buffer.read(num)) { 145 if(!a_buffer.read(num)) { 146 std::vector<vec_t>::clear(); 146 std::vector<vec_t>::clear(); 147 return false; 147 return false; 148 } 148 } 149 //::printf("debug : stl_vector_vector : 149 //::printf("debug : stl_vector_vector : index %d num %d\n",veci,num); 150 if(num) { 150 if(num) { 151 T* vec = new T[num]; 151 T* vec = new T[num]; 152 if(!a_buffer.read_fast_array<T>(vec,nu 152 if(!a_buffer.read_fast_array<T>(vec,num)) { 153 delete [] vec; 153 delete [] vec; 154 std::vector<vec_t>::clear(); 154 std::vector<vec_t>::clear(); 155 return false; 155 return false; 156 } 156 } 157 elem.resize(num); 157 elem.resize(num); 158 T* pos = vec; 158 T* pos = vec; 159 for(unsigned int index=0;index<num;ind 159 for(unsigned int index=0;index<num;index++,pos++) elem[index] = *pos; 160 delete [] vec; 160 delete [] vec; 161 } 161 } 162 } 162 } 163 163 164 return a_buffer.check_byte_count(_s,_c,s_s 164 return a_buffer.check_byte_count(_s,_c,s_store_class()); 165 } 165 } 166 public: 166 public: 167 stl_vector_vector(){ 167 stl_vector_vector(){ 168 #ifdef TOOLS_MEM 168 #ifdef TOOLS_MEM 169 mem::increment(s_class().c_str()); 169 mem::increment(s_class().c_str()); 170 #endif 170 #endif 171 } 171 } 172 virtual ~stl_vector_vector(){ 172 virtual ~stl_vector_vector(){ 173 #ifdef TOOLS_MEM 173 #ifdef TOOLS_MEM 174 mem::decrement(s_class().c_str()); 174 mem::decrement(s_class().c_str()); 175 #endif 175 #endif 176 } 176 } 177 public: 177 public: 178 stl_vector_vector(const stl_vector_vector& a 178 stl_vector_vector(const stl_vector_vector& a_from) 179 :iro(a_from) 179 :iro(a_from) 180 ,std::vector< std::vector<T> >(a_from) 180 ,std::vector< std::vector<T> >(a_from) 181 { 181 { 182 #ifdef TOOLS_MEM 182 #ifdef TOOLS_MEM 183 mem::increment(s_class().c_str()); 183 mem::increment(s_class().c_str()); 184 #endif 184 #endif 185 } 185 } 186 stl_vector_vector& operator=(const stl_vecto 186 stl_vector_vector& operator=(const stl_vector_vector& a_from){ 187 std::vector< std::vector<T> >::operator=(a 187 std::vector< std::vector<T> >::operator=(a_from); 188 return *this; 188 return *this; 189 } 189 } 190 }; 190 }; 191 191 192 class stl_vector_string : public virtual iro, 192 class stl_vector_string : public virtual iro, public std::vector<std::string> { 193 static const std::string& s_store_class() { 193 static const std::string& s_store_class() { 194 static const std::string s_v("vector<strin 194 static const std::string s_v("vector<string>"); 195 return s_v; 195 return s_v; 196 } 196 } 197 public: 197 public: 198 static const std::string& s_class() { 198 static const std::string& s_class() { 199 static const std::string s_v("tools::rroot 199 static const std::string s_v("tools::rroot::stl_vector_string"); 200 return s_v; 200 return s_v; 201 } 201 } 202 public: //iro 202 public: //iro 203 virtual void* cast(const std::string& a_clas 203 virtual void* cast(const std::string& a_class) const { 204 if(void* p = cmp_cast<stl_vector_string>(t 204 if(void* p = cmp_cast<stl_vector_string>(this,a_class)) return p; 205 return 0; 205 return 0; 206 } 206 } 207 virtual const std::string& s_cls() const {re 207 virtual const std::string& s_cls() const {return s_class();} 208 public: 208 public: 209 static cid id_class() {return stl_vector_str 209 static cid id_class() {return stl_vector_string_cid();} 210 virtual void* cast(cid a_class) const { 210 virtual void* cast(cid a_class) const { 211 if(void* p = cmp_cast<stl_vector_string>(t 211 if(void* p = cmp_cast<stl_vector_string>(this,a_class)) {return p;} 212 return 0; 212 return 0; 213 } 213 } 214 virtual iro* copy() const {return new stl_ve 214 virtual iro* copy() const {return new stl_vector_string(*this);} 215 virtual bool stream(buffer& a_buffer) { 215 virtual bool stream(buffer& a_buffer) { 216 std::vector<std::string>::clear(); 216 std::vector<std::string>::clear(); 217 217 218 //uint32 startpos = a_buffer.length(); 218 //uint32 startpos = a_buffer.length(); 219 219 220 //WARNING : not tested yet. 220 //WARNING : not tested yet. 221 221 222 short v; 222 short v; 223 unsigned int _s,_c; 223 unsigned int _s,_c; 224 if(!a_buffer.read_version(v,_s,_c)) return 224 if(!a_buffer.read_version(v,_s,_c)) return false; 225 225 226 //::printf("debug : stl_vector_string::str 226 //::printf("debug : stl_vector_string::stream : version %d, byte count %d\n",v,c); 227 227 228 unsigned int num; 228 unsigned int num; 229 if(!a_buffer.read(num)) return false; 229 if(!a_buffer.read(num)) return false; 230 230 231 //::printf("debug : stl_vector_string : %d 231 //::printf("debug : stl_vector_string : %d\n",num); 232 232 233 std::vector<std::string>::resize(num); 233 std::vector<std::string>::resize(num); 234 for(unsigned int index=0;index<num;index++ 234 for(unsigned int index=0;index<num;index++) { 235 std::string& vs = std::vector<std::strin 235 std::string& vs = std::vector<std::string>::operator[](index); 236 if(!a_buffer.read(vs)) { 236 if(!a_buffer.read(vs)) { 237 std::vector<std::string>::clear(); 237 std::vector<std::string>::clear(); 238 return false; 238 return false; 239 } 239 } 240 } 240 } 241 241 242 //a_buffer.set_offset(startpos+_c+sizeof(u 242 //a_buffer.set_offset(startpos+_c+sizeof(unsigned int)); 243 243 244 return a_buffer.check_byte_count(_s,_c,s_s 244 return a_buffer.check_byte_count(_s,_c,s_store_class()); 245 } 245 } 246 public: 246 public: 247 stl_vector_string(){ 247 stl_vector_string(){ 248 #ifdef TOOLS_MEM 248 #ifdef TOOLS_MEM 249 mem::increment(s_class().c_str()); 249 mem::increment(s_class().c_str()); 250 #endif 250 #endif 251 } 251 } 252 virtual ~stl_vector_string(){ 252 virtual ~stl_vector_string(){ 253 #ifdef TOOLS_MEM 253 #ifdef TOOLS_MEM 254 mem::decrement(s_class().c_str()); 254 mem::decrement(s_class().c_str()); 255 #endif 255 #endif 256 } 256 } 257 public: 257 public: 258 stl_vector_string(const stl_vector_string& a 258 stl_vector_string(const stl_vector_string& a_from) 259 :iro(a_from) 259 :iro(a_from) 260 ,std::vector<std::string>(a_from) 260 ,std::vector<std::string>(a_from) 261 { 261 { 262 #ifdef TOOLS_MEM 262 #ifdef TOOLS_MEM 263 mem::increment(s_class().c_str()); 263 mem::increment(s_class().c_str()); 264 #endif 264 #endif 265 } 265 } 266 stl_vector_string& operator=(const stl_vecto 266 stl_vector_string& operator=(const stl_vector_string& a_from){ 267 std::vector<std::string>::operator=(a_from 267 std::vector<std::string>::operator=(a_from); 268 return *this; 268 return *this; 269 } 269 } 270 }; 270 }; 271 271 272 }} 272 }} 273 273 274 #endif 274 #endif