Geant4 Cross Reference |
1 // Copyright (C) 2010, Guy Barrand. All rights 2 // See the file tools.license for terms. 3 4 #ifndef tools_sg_mf 5 #define tools_sg_mf 6 7 // mf for multiple field. 8 9 #include "bmf" 10 11 #include "../stype" 12 #include "../cstr" 13 #include "../io/iwbuf" 14 #include "../io/irbuf" 15 #include "../HEADER" 16 17 namespace tools { 18 namespace sg { 19 20 template <class T> 21 class mf : public bmf<T> { 22 typedef bmf<T> parent; 23 public: 24 static const std::string& s_class() { 25 static const std::string s_v("tools::sg::m 26 return s_v; 27 } 28 virtual void* cast(const std::string& a_clas 29 if(void* p = cmp_cast< mf<T> >(this,a_clas 30 return parent::cast(a_class); 31 } 32 virtual const std::string& s_cls() const {re 33 public: 34 virtual bool write(io::iwbuf& a_buffer) { 35 const std::vector<T>& vec = parent::m_valu 36 return a_buffer.write_vec((uint32)vec.size 37 } 38 virtual bool read(io::irbuf& a_buffer) { 39 std::vector<T>& vec = parent::m_values; 40 return a_buffer.read_std_vec(vec); 41 } 42 virtual bool dump(std::ostream& a_out) { 43 const std::vector<T>& vec = parent::m_valu 44 a_out << "size : " << vec.size() << std::e 45 typedef typename std::vector<T>::const_ite 46 for(cit_t it=vec.begin();it!=vec.end();++i 47 a_out << " " << (*it) << std::endl; 48 } 49 return true; 50 } 51 virtual bool s_value(std::string& a_s) const 52 virtual bool s2value(const std::string&) {re 53 public: 54 mf(){} 55 mf(const T& a_v):parent(a_v){} 56 mf(const std::vector<T>& a_v):parent(a_v){} 57 virtual ~mf(){} 58 public: 59 mf(const mf& a_from):parent(a_from){} 60 mf& operator=(const mf& a_from){ 61 //typedef typename parent::iterator bmf_t; 62 parent::operator=(a_from); 63 return *this; 64 } 65 public: 66 mf& operator=(const std::vector<T>& a_from){ 67 parent::operator=(a_from); 68 return *this; 69 } 70 mf& operator=(const T& a_v){ 71 parent::operator=(a_v); 72 return *this; 73 } 74 }; 75 76 class mf_string : public bmf<std::string> { 77 TOOLS_HEADER(mf_string,tools::sg::mf_string, 78 public: 79 virtual bool write(io::iwbuf& a_buffer) { 80 return a_buffer.write_vec(m_values); 81 } 82 virtual bool read(io::irbuf& a_buffer) { 83 std::vector<std::string>& vec = parent::m_ 84 return a_buffer.read_vec(vec); 85 } 86 virtual bool dump(std::ostream& a_out) { 87 const std::vector<std::string>& vec = pare 88 a_out << "size : " << vec.size() << std::e 89 std::vector<std::string>::const_iterator i 90 for(it=vec.begin();it!=vec.end();++it) { 91 a_out << " \"" << (*it) << "\"" << std: 92 } 93 return true; 94 } 95 virtual bool s_value(std::string& a_s) const 96 virtual bool s2value(const std::string&) {re 97 public: 98 mf_string():parent(){} 99 mf_string(const std::string& a_v):parent(a_v 100 mf_string(const std::vector<std::string>& a_ 101 virtual ~mf_string(){} 102 public: 103 mf_string(const mf_string& a_from):parent(a_ 104 mf_string& operator=(const mf_string& a_from 105 parent::operator=(a_from); 106 return *this; 107 } 108 public: 109 mf_string& operator=(const std::vector<std:: 110 parent::operator=(a_value); 111 return *this; 112 } 113 mf_string& operator=(const char* a_cstr){ 114 parent::operator=(a_cstr); 115 return *this; 116 } 117 }; 118 119 //exa tools::sg::entries.mf_vec<entry_type> 120 121 template <class T> 122 class mf_enum : public bmf<T> { 123 typedef bmf<T> parent; 124 public: 125 static const std::string& s_class() { 126 static const std::string s_v("tools::sg::m 127 return s_v; 128 } 129 virtual void* cast(const std::string& a_clas 130 if(void* p = cmp_cast< mf_enum<T> >(this,a 131 return parent::cast(a_class); 132 } 133 virtual const std::string& s_cls() const {re 134 public: 135 virtual bool write(io::iwbuf& a_buffer) { 136 const std::vector<T>& vec = parent::m_valu 137 std::vector<int16> v; //an enum can be neg 138 typedef typename std::vector<T>::const_ite 139 for(cit_t it=vec.begin();it!=vec.end();++i 140 return a_buffer.write_vec((uint32)v.size() 141 } 142 virtual bool read(io::irbuf& a_buffer) { 143 std::vector<int16> v; //an enum can be neg 144 if(!a_buffer.read_std_vec(v)) return false 145 std::vector<T>& vec = parent::m_values; 146 vec.clear(); 147 std::vector<int16>::const_iterator it; 148 for(it=v.begin();it!=v.end();++it) vec.pus 149 return true; 150 } 151 virtual bool dump(std::ostream& a_out) { 152 const std::vector<T>& vec = parent::m_valu 153 a_out << "size : " << vec.size() << std::e 154 typedef typename std::vector<T>::const_ite 155 for(cit_t it=vec.begin();it!=vec.end();++i 156 a_out << " " << (*it) << std::endl; 157 } 158 return true; 159 } 160 virtual bool s_value(std::string& a_s) const 161 virtual bool s2value(const std::string&) {re 162 public: 163 mf_enum():parent(){} 164 mf_enum(const T& a_v):parent(a_v){} 165 mf_enum(const std::vector<T>& a_v):parent(a_ 166 virtual ~mf_enum(){} 167 public: 168 mf_enum(const mf_enum& a_from):parent(a_from 169 mf_enum& operator=(const mf_enum& a_from){ 170 parent::operator=(a_from); 171 return *this; 172 } 173 }; 174 175 //exa mf_vec<colorf,float> 176 177 ////////////////////////////////////////////// 178 //the three below funcs are for : 179 // mf_vec< std::vector<std::string> ,std::str 180 ////////////////////////////////////////////// 181 inline std::ostream& operator<<(std::ostream& 182 //for mf_vec::dump. 183 return a_out; 184 } 185 186 inline bool set_from_vec(std::vector<std::stri 187 //for mf_vec::read(io::irbuf&) 188 return false; 189 } 190 191 inline const std::string* get_data(const std:: 192 return vec_data(a_v); 193 } 194 ////////////////////////////////////////////// 195 ////////////////////////////////////////////// 196 ////////////////////////////////////////////// 197 198 199 template <class T,class TT> 200 class mf_vec : public bmf<T> { 201 typedef bmf<T> parent; 202 public: 203 static const std::string& s_class() { 204 static const std::string s_v("tools::sg::m 205 return s_v; 206 } 207 virtual void* cast(const std::string& a_clas 208 if(void* p = cmp_cast< mf_vec<T,TT> >(this 209 return parent::cast(a_class); 210 } 211 virtual const std::string& s_cls() const {re 212 public: 213 virtual bool write(io::iwbuf& a_buffer) { 214 const std::vector<T>& vec = parent::m_valu 215 typedef typename std::vector<TT> vec_t; 216 std::vector<vec_t> vec_vec; 217 typedef typename std::vector<T>::const_ite 218 for(cit_t it=vec.begin();it!=vec.end();++i 219 220 const T& v = (*it); 221 size_t num = v.size(); 222 const TT* d = get_data(v); 223 224 std::vector<TT> std_vec(num); 225 for(size_t i=0;i<num;i++) std_vec[i] = d 226 227 vec_vec.push_back(std_vec); 228 } 229 return a_buffer.write_std_vec_vec(vec_vec) 230 } 231 virtual bool read(io::irbuf& a_buffer) { 232 std::vector<T>& vec = parent::m_values; 233 vec.clear(); 234 typedef typename std::vector<TT> vec_t; 235 std::vector<vec_t> vec_vec; 236 if(!a_buffer.read_std_vec_vec(vec_vec)) re 237 typedef typename std::vector<vec_t>::itera 238 for(_it_t it=vec_vec.begin();it!=vec_vec.e 239 T x; 240 // x colorf, *it = std::vector<float> 241 // x vecs, *it = std::vector<std::string 242 if(!set_from_vec(x,*it)) {vec.clear();re 243 vec.push_back(x); 244 } 245 return true; 246 } 247 virtual bool dump(std::ostream& a_out) { 248 const std::vector<T>& vec = parent::m_valu 249 a_out << "size : " << vec.size() << std::e 250 typedef typename std::vector<T>::const_ite 251 for(cit_t it=vec.begin();it!=vec.end();++i 252 a_out << " " << (*it) << std::endl; 253 } 254 return true; 255 } 256 virtual bool s_value(std::string& a_s) const 257 virtual bool s2value(const std::string&) {re 258 public: 259 mf_vec():parent(){} 260 mf_vec(const T& a_v):parent(a_v){} 261 mf_vec(const std::vector<T>& a_v):parent(a_v 262 virtual ~mf_vec(){} 263 public: 264 mf_vec(const mf_vec& a_from):parent(a_from){ 265 mf_vec& operator=(const mf_vec& a_from){ 266 parent::operator=(a_from); 267 return *this; 268 } 269 }; 270 271 template <class T> 272 class mf_std_vec : public bmf< std::vector<T> 273 typedef bmf< std::vector<T> > parent; 274 public: 275 static const std::string& s_class() { 276 static const std::string s_v("tools::sg::m 277 return s_v; 278 } 279 virtual void* cast(const std::string& a_clas 280 if(void* p = cmp_cast< mf_std_vec<T> >(thi 281 return parent::cast(a_class); 282 } 283 virtual const std::string& s_cls() const {re 284 public: 285 virtual bool write(io::iwbuf& a_buffer) { 286 //used in exlib/sg/text_freetype::unitext 287 const std::vector< std::vector<T> >& vec = 288 return a_buffer.write_std_vec_vec(vec); 289 } 290 virtual bool read(io::irbuf& a_buffer) { 291 std::vector< std::vector<T> >& vec = paren 292 return a_buffer.read_std_vec_vec(vec); 293 } 294 virtual bool dump(std::ostream& a_out) { 295 const std::vector< std::vector<T> >& vec = 296 a_out << "size : " << vec.size() << std::e 297 typedef typename std::vector< std::vector< 298 for(cit_t it=vec.begin();it!=vec.end();++i 299 //a_out << " " << (*it) << std::endl; 300 } 301 return true; 302 } 303 virtual bool s_value(std::string& a_s) const 304 virtual bool s2value(const std::string&) {re 305 public: 306 mf_std_vec():parent(){} 307 mf_std_vec(const T& a_v):parent(a_v){} 308 mf_std_vec(const std::vector<T>& a_v):parent 309 virtual ~mf_std_vec(){} 310 public: 311 mf_std_vec(const mf_std_vec& a_from):parent( 312 mf_std_vec& operator=(const mf_std_vec& a_fr 313 parent::operator=(a_from); 314 return *this; 315 } 316 }; 317 318 }} 319 320 #endif