Packets/VectorParser.cti

   1 // $Id$
   2 //
   3 // Copyright (C) 2006
   4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
   5 // Competence Center NETwork research (NET), St. Augustin, GERMANY
   6 //     Stefan Bund <g0dil@berlios.de>
   7 //
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 2 of the License, or
  11 // (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the
  20 // Free Software Foundation, Inc.,
  21 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22
  23 /** \file
  24     \brief VectorParser inline template implementation */
  25
  26 #include "VectorParser.ih"
  27
  28 // Custom includes
  29
  30 #define prefix_ inline
  31 ///////////////////////////////cti.p///////////////////////////////////////
  32
  33 ///////////////////////////////////////////////////////////////////////////
  34 // senf::VectorParser<ElementParser,Sizer>
  35
  36 template <class ElementParser, class Sizer>
  37 prefix_ senf::VectorParser<ElementParser,Sizer>::VectorParser(data_iterator i, state_type s)
  38     : PacketParserBase(i,s), sizer_()
  39 {}
  40
  41 template <class ElementParser, class Sizer>
  42 prefix_ senf::VectorParser<ElementParser,Sizer>::VectorParser(Sizer sizer, data_iterator i,
  43                                                               state_type s)
  44     : PacketParserBase(i,s), sizer_(sizer)
  45 {}
  46
  47 template <class ElementParser, class Sizer>
  48 prefix_ typename senf::VectorParser<ElementParser,Sizer>::size_type
  49 senf::VectorParser<ElementParser,Sizer>::bytes()
  50     const
  51 {
  52     return size()*ElementParser::fixed_bytes + sizer_.bytes(i(),state());
  53 }
  54
  55 // Container interface
  56
  57 template <class ElementParser, class Sizer>
  58 prefix_ typename senf::VectorParser<ElementParser,Sizer>::size_type
  59 senf::VectorParser<ElementParser,Sizer>::size()
  60     const
  61 {
  62     return sizer_.size(i(),state());
  63 }
  64
  65 template <class ElementParser, class Sizer>
  66 prefix_ bool senf::VectorParser<ElementParser,Sizer>::empty()
  67     const
  68 {
  69     return size()==0;
  70 }
  71
  72 template <class ElementParser, class Sizer>
  73 prefix_ typename senf::VectorParser<ElementParser,Sizer>::iterator
  74 senf::VectorParser<ElementParser,Sizer>::begin()
  75     const
  76 {
  77     return iterator(sizer_.begin(i(),state()),state());
  78 }
  79
  80 template <class ElementParser, class Sizer>
  81 prefix_ typename senf::VectorParser<ElementParser,Sizer>::iterator
  82 senf::VectorParser<ElementParser,Sizer>::end()
  83     const
  84 {
  85     return boost::next(begin(),size());
  86 }
  87
  88 template <class ElementParser, class Sizer>
  89 prefix_ typename senf::VectorParser<ElementParser,Sizer>::value_type
  90 senf::VectorParser<ElementParser,Sizer>::operator[](difference_type i)
  91     const
  92 {
  93     return begin()[i];
  94 }
  95
  96 template <class ElementParser, class Sizer>
  97 prefix_ typename senf::VectorParser<ElementParser,Sizer>::value_type
  98 senf::VectorParser<ElementParser,Sizer>::front()
  99     const
 100 {
 101     return begin()[0];
 102 }
 103
 104 template <class ElementParser, class Sizer>
 105 prefix_ typename senf::VectorParser<ElementParser,Sizer>::value_type
 106 senf::VectorParser<ElementParser,Sizer>::back()
 107     const
 108 {
 109     return begin()[size()-1];
 110 }
 111
 112 // Mutators
 113
 114 template <class ElementParser, class Sizer>
 115 template <class Value>
 116 prefix_ void senf::VectorParser<ElementParser,Sizer>::push_back(Value value, size_type n)
 117     const
 118 {
 119     container c (*this);
 120     c.push_back(value,n);
 121 }
 122
 123 template <class ElementParser, class Sizer>
 124 prefix_ void senf::VectorParser<ElementParser,Sizer>::push_back_space(size_type n)
 125     const
 126 {
 127     container c (*this);
 128     c.push_back_space(n);
 129 }
 130
 131 template <class ElementParser, class Sizer>
 132 template <class Value>
 133 prefix_ void senf::VectorParser<ElementParser,Sizer>::push_front(Value value, size_type n)
 134     const
 135 {
 136     container c (*this);
 137     c.push_front(value,n);
 138 }
 139
 140 template <class ElementParser, class Sizer>
 141 prefix_ void senf::VectorParser<ElementParser,Sizer>::push_front_space(size_type n)
 142     const
 143 {
 144     container c (*this);
 145     c.push_front_space(n);
 146 }
 147
 148 template <class ElementParser, class Sizer>
 149 prefix_ void senf::VectorParser<ElementParser,Sizer>::resize(size_type n)
 150     const
 151 {
 152     container c (*this);
 153     c.resize(n);
 154 }
 155
 156 template <class ElementParser, class Sizer>
 157 template <class Value>
 158 prefix_ void senf::VectorParser<ElementParser,Sizer>::resize(size_type n, Value value)
 159     const
 160 {
 161     container c (*this);
 162     c.resize(n,value);
 163 }
 164
 165 ///////////////////////////////////////////////////////////////////////////
 166 // senf::SimpleSizeParser<SizeParser,offset>
 167
 168 template <class SizeParser, unsigned Distance>
 169 prefix_ typename senf::detail::VectorNParser_Sizer<SizeParser,Distance>::size_type
 170 senf::detail::VectorNParser_Sizer<SizeParser,Distance>::size(iterator i, state_type s)
 171     const
 172 {
 173     return SizeParser(boost::prior(i, Distance), s).value();
 174 }
 175
 176 template <class SizeParser, unsigned Distance>
 177 prefix_ void senf::detail::VectorNParser_Sizer<SizeParser,Distance>::size(iterator i,
 178                                                                           state_type s,
 179                                                                           size_type v)
 180     const
 181 {
 182     SizeParser(boost::prior(i, Distance), s).value(v);
 183 }
 184
 185 template <class SizeParser, unsigned Distance>
 186 prefix_ typename senf::detail::VectorNParser_Sizer<SizeParser,Distance>::iterator
 187 senf::detail::VectorNParser_Sizer<SizeParser,Distance>::begin(iterator i, state_type s)
 188     const
 189 {
 190     return i;
 191 }
 192
 193 template <class SizeParser, unsigned Distance>
 194 prefix_ typename senf::detail::VectorNParser_Sizer<SizeParser,Distance>::size_type
 195 senf::detail::VectorNParser_Sizer<SizeParser,Distance>::bytes(iterator i, state_type s)
 196     const
 197 {
 198     return 0;
 199 }
 200
 201 template <class SizeParser, unsigned Distance>
 202 prefix_ void senf::detail::VectorNParser_Sizer<SizeParser,Distance>::init(iterator i,
 203                                                                           state_type s)
 204     const
 205 {}
 206
 207 ///////////////////////////////////////////////////////////////////////////
 208 // senf::VectorParser_wrapper<Parser,SizeParser,Container>
 209
 210 // structors and default members
 211
 212 // hm ... be careful here ! the data() member is called in an incompletely intitialized
 213 // instance. However, data() only depends on state_ which is initialized before the call. YOU MUST
 214 // NOT CHANGE THE ORDERING OF THE DATA MEMBERS
 215 template <class ElementParser, class Sizer>
 216 prefix_ senf::VectorParser_Container<ElementParser,Sizer>::
 217 VectorParser_Container(parser_type const & vector)
 218     : sizer_ (vector.sizer_), state_ (vector.state()),
 219       i_ (std::distance(data().begin(),vector.i()))
 220 {}
 221
 222 // accessors
 223
 224 template <class ElementParser, class Sizer>
 225 prefix_ typename senf::VectorParser_Container<ElementParser,Sizer>::size_type
 226 senf::VectorParser_Container<ElementParser,Sizer>::size()
 227     const
 228 {
 229     return sizer_.size(i(),state());
 230 }
 231
 232 template <class ElementParser, class Sizer>
 233 prefix_ bool senf::VectorParser_Container<ElementParser,Sizer>::empty()
 234     const
 235 {
 236     return size() == 0;
 237 }
 238
 239 template <class ElementParser, class Sizer>
 240 prefix_ typename senf::VectorParser_Container<ElementParser,Sizer>::iterator
 241 senf::VectorParser_Container<ElementParser,Sizer>::begin()
 242     const
 243 {
 244     return iterator(sizer_.begin(i(),state()),state());
 245 }
 246
 247 template <class ElementParser, class Sizer>
 248 prefix_ typename senf::VectorParser_Container<ElementParser,Sizer>::iterator
 249 senf::VectorParser_Container<ElementParser,Sizer>::end()
 250     const
 251 {
 252     return boost::next(begin(),size());
 253 }
 254
 255 template <class ElementParser, class Sizer>
 256 prefix_ typename senf::VectorParser_Container<ElementParser,Sizer>::value_type
 257 senf::VectorParser_Container<ElementParser,Sizer>::operator[](difference_type i)
 258     const
 259 {
 260     return begin()[i];
 261 }
 262
 263 template <class ElementParser, class Sizer>
 264 prefix_ typename senf::VectorParser_Container<ElementParser,Sizer>::value_type
 265 senf::VectorParser_Container<ElementParser,Sizer>::front()
 266     const
 267 {
 268     return begin()[0];
 269 }
 270
 271 template <class ElementParser, class Sizer>
 272 prefix_ typename senf::VectorParser_Container<ElementParser,Sizer>::value_type
 273 senf::VectorParser_Container<ElementParser,Sizer>::back()
 274     const
 275 {
 276     return begin()[size()-1];
 277 }
 278
 279 // Mutators
 280
 281 template <class ElementParser, class Sizer>
 282 template <class Value>
 283 prefix_ void senf::VectorParser_Container<ElementParser,Sizer>::insert(iterator pos,
 284                                                                        Value const & t)
 285 {
 286     *shift(pos) << t;
 287 }
 288
 289 template <class ElementParser, class Sizer>
 290 prefix_ void senf::VectorParser_Container<ElementParser,Sizer>::erase(iterator pos, size_type n)
 291 {
 292     data().erase(pos.raw(),boost::next(pos.raw(),n*ElementParser::fixed_bytes));
 293     setSize(size()-n);
 294 }
 295
 296 template <class ElementParser, class Sizer>
 297 prefix_ void senf::VectorParser_Container<ElementParser,Sizer>::erase(iterator f, iterator l)
 298 {
 299     erase(f,std::distance(f,l));
 300 }
 301
 302 template <class ElementParser, class Sizer>
 303 prefix_ void senf::VectorParser_Container<ElementParser,Sizer>::clear()
 304 {
 305     erase(begin(),end());
 306 }
 307
 308 template <class ElementParser, class Sizer>
 309 template <class Value>
 310 prefix_ void senf::VectorParser_Container<ElementParser,Sizer>::push_back(Value value,
 311                                                                           size_type n)
 312 {
 313     insert(end(),n,value);
 314 }
 315
 316 template <class ElementParser, class Sizer>
 317 prefix_ void senf::VectorParser_Container<ElementParser,Sizer>::push_back_space(size_type n)
 318 {
 319     shift(end(),n);
 320 }
 321
 322 template <class ElementParser, class Sizer>
 323 template <class Value>
 324 prefix_ void senf::VectorParser_Container<ElementParser,Sizer>::push_front(Value value,
 325                                                                            size_type n)
 326 {
 327     insert(begin(),n,value);
 328 }
 329
 330 template <class ElementParser, class Sizer>
 331 prefix_ void senf::VectorParser_Container<ElementParser,Sizer>::push_front_space(size_type n)
 332 {
 333     shift(begin(),n);
 334 }
 335
 336 // Parser interface
 337
 338 template <class ElementParser, class Sizer>
 339 prefix_ typename senf::VectorParser_Container<ElementParser,Sizer>::parser_type
 340 senf::VectorParser_Container<ElementParser,Sizer>::parser()
 341     const
 342 {
 343     return parser_type(i(),state());
 344 }
 345
 346 template <class ElementParser, class Sizer>
 347 prefix_ typename senf::VectorParser_Container<ElementParser,Sizer>::data_iterator
 348 senf::VectorParser_Container<ElementParser,Sizer>::i()
 349     const
 350 {
 351     return boost::next(data().begin(),i_);
 352 }
 353
 354 template <class ElementParser, class Sizer>
 355 prefix_ typename senf::VectorParser_Container<ElementParser,Sizer>::state_type
 356 senf::VectorParser_Container<ElementParser,Sizer>::state()
 357     const
 358 {
 359     return state_;
 360 }
 361
 362 template <class ElementParser, class Sizer>
 363 prefix_ senf::PacketData &
 364 senf::VectorParser_Container<ElementParser,Sizer>::data()
 365     const
 366 {
 367     return *state_;
 368 }
 369
 370 template <class ElementParser, class Sizer>
 371 prefix_ typename senf::VectorParser_Container<ElementParser,Sizer>::size_type
 372 senf::VectorParser_Container<ElementParser,Sizer>::bytes()
 373     const
 374 {
 375     return size()*ElementParser::fixed_bytes + sizer_.bytes(i(),state());
 376 }
 377
 378 // private members
 379
 380 template <class ElementParser, class Sizer>
 381 prefix_ void senf::VectorParser_Container<ElementParser,Sizer>::setSize(size_type value)
 382 {
 383     sizer_.size(i(),state(),value);
 384 }
 385
 386 /////////////////////////////cti.e///////////////////////////////////////
 387 #undef prefix_
 388
 389 \f
 390 // Local Variables:
 391 // mode: c++
 392 // fill-column: 100
 393 // c-file-style: "senf"
 394 // indent-tabs-mode: nil
 395 // ispell-local-dictionary: "american"
 396 // compile-command: "scons -u test"
 397 // comment-column: 40
 398 // End: