Packets/ParseVec.cti

   1 // $Id$
   2 //
   3 // Copyright (C) 2006
   4 // Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
   5 // Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
   6 //     Stefan Bund <stefan.bund@fokus.fraunhofer.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 ParseVec inline template implementation */
  25
  26 #include "ParseVec.ih"
  27
  28 // Custom includes
  29
  30 #define prefix_ inline
  31 ///////////////////////////////cti.p///////////////////////////////////////
  32
  33 ///////////////////////////////////////////////////////////////////////////
  34 // senf::Parse_Vector<ElementParser,Sizer>
  35
  36 template <class ElementParser, class Sizer>
  37 prefix_ senf::Parse_Vector<ElementParser,Sizer>::Parse_Vector(data_iterator i, state_type s)
  38     : PacketParserBase(i,s), sizer_()
  39 {}
  40
  41 template <class ElementParser, class Sizer>
  42 prefix_ senf::Parse_Vector<ElementParser,Sizer>::Parse_Vector(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::Parse_Vector<ElementParser,Sizer>::size_type
  49 senf::Parse_Vector<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::Parse_Vector<ElementParser,Sizer>::size_type
  59 senf::Parse_Vector<ElementParser,Sizer>::size()
  60     const
  61 {
  62     return sizer_.size(i(),state());
  63 }
  64
  65 template <class ElementParser, class Sizer>
  66 prefix_ bool senf::Parse_Vector<ElementParser,Sizer>::empty()
  67     const
  68 {
  69     return size()==0;
  70 }
  71
  72 template <class ElementParser, class Sizer>
  73 prefix_ typename senf::Parse_Vector<ElementParser,Sizer>::iterator
  74 senf::Parse_Vector<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::Parse_Vector<ElementParser,Sizer>::iterator
  82 senf::Parse_Vector<ElementParser,Sizer>::end()
  83     const
  84 {
  85     return boost::next(begin(),size());
  86 }
  87
  88 template <class ElementParser, class Sizer>
  89 prefix_ typename senf::Parse_Vector<ElementParser,Sizer>::value_type
  90 senf::Parse_Vector<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::Parse_Vector<ElementParser,Sizer>::value_type
  98 senf::Parse_Vector<ElementParser,Sizer>::front()
  99     const
 100 {
 101     return begin()[0];
 102 }
 103
 104 template <class ElementParser, class Sizer>
 105 prefix_ typename senf::Parse_Vector<ElementParser,Sizer>::value_type
 106 senf::Parse_Vector<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::Parse_Vector<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::Parse_Vector<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::Parse_Vector<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::Parse_Vector<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::Parse_Vector<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::Parse_Vector<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>
 169 prefix_ typename senf::detail::Parse_VectorN_Sizer<SizeParser>::size_type
 170 senf::detail::Parse_VectorN_Sizer<SizeParser>::size(iterator i, state_type s)
 171     const
 172 {
 173     return SizeParser(i,s).value();
 174 }
 175
 176 template <class SizeParser>
 177 prefix_ void senf::detail::Parse_VectorN_Sizer<SizeParser>::size(iterator i, state_type s,
 178                                                               size_type v)
 179     const
 180 {
 181     SizeParser(i,s).value(v);
 182 }
 183
 184 template <class SizeParser>
 185 prefix_ typename senf::detail::Parse_VectorN_Sizer<SizeParser>::iterator
 186 senf::detail::Parse_VectorN_Sizer<SizeParser>::begin(iterator i, state_type s)
 187     const
 188 {
 189     return boost::next(i,SizeParser::fixed_bytes);
 190 }
 191
 192 template <class SizeParser>
 193 prefix_ typename senf::detail::Parse_VectorN_Sizer<SizeParser>::size_type
 194 senf::detail::Parse_VectorN_Sizer<SizeParser>::bytes(iterator i, state_type s)
 195     const
 196 {
 197     return SizeParser::fixed_bytes;
 198 }
 199
 200 template <class SizeParser>
 201 prefix_ void senf::detail::Parse_VectorN_Sizer<SizeParser>::init(iterator i, state_type s)
 202     const
 203 {}
 204
 205 ///////////////////////////////////////////////////////////////////////////
 206 // senf::Parse_Vector_wrapper<Parser,SizeParser,Container>
 207
 208 // structors and default members
 209
 210 // hm ... be careful here ! the data() member is called in an incompletely intitialized
 211 // instance. However, data() only depends on state_ which is initialized before the call. YOU MUST
 212 // NOT CHANGE THE ORDERING OF THE DATA MEMBERS
 213 template <class ElementParser, class Sizer>
 214 prefix_ senf::Parse_Vector_Container<ElementParser,Sizer>::
 215 Parse_Vector_Container(parser_type const & vector)
 216     : sizer_ (vector.sizer_), state_ (vector.state()),
 217       i_ (std::distance(data().begin(),vector.i()))
 218 {}
 219
 220 // accessors
 221
 222 template <class ElementParser, class Sizer>
 223 prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::size_type
 224 senf::Parse_Vector_Container<ElementParser,Sizer>::size()
 225     const
 226 {
 227     return sizer_.size(i(),state());
 228 }
 229
 230 template <class ElementParser, class Sizer>
 231 prefix_ bool senf::Parse_Vector_Container<ElementParser,Sizer>::empty()
 232     const
 233 {
 234     return size() == 0;
 235 }
 236
 237 template <class ElementParser, class Sizer>
 238 prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::iterator
 239 senf::Parse_Vector_Container<ElementParser,Sizer>::begin()
 240     const
 241 {
 242     return iterator(sizer_.begin(i(),state()),state());
 243 }
 244
 245 template <class ElementParser, class Sizer>
 246 prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::iterator
 247 senf::Parse_Vector_Container<ElementParser,Sizer>::end()
 248     const
 249 {
 250     return boost::next(begin(),size());
 251 }
 252
 253 template <class ElementParser, class Sizer>
 254 prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::value_type
 255 senf::Parse_Vector_Container<ElementParser,Sizer>::operator[](difference_type i)
 256     const
 257 {
 258     return begin()[i];
 259 }
 260
 261 template <class ElementParser, class Sizer>
 262 prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::value_type
 263 senf::Parse_Vector_Container<ElementParser,Sizer>::front()
 264     const
 265 {
 266     return begin()[0];
 267 }
 268
 269 template <class ElementParser, class Sizer>
 270 prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::value_type
 271 senf::Parse_Vector_Container<ElementParser,Sizer>::back()
 272     const
 273 {
 274     return begin()[size()-1];
 275 }
 276
 277 // Mutators
 278
 279 template <class ElementParser, class Sizer>
 280 template <class Value>
 281 prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::insert(iterator pos,
 282                                                                        Value const & t)
 283 {
 284     *shift(pos) << t;
 285 }
 286
 287 template <class ElementParser, class Sizer>
 288 prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::erase(iterator pos, size_type n)
 289 {
 290     data().erase(pos.raw(),boost::next(pos.raw(),n*ElementParser::fixed_bytes));
 291     setSize(size()-n);
 292 }
 293
 294 template <class ElementParser, class Sizer>
 295 prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::erase(iterator f, iterator l)
 296 {
 297     erase(f,std::distance(f,l));
 298 }
 299
 300 template <class ElementParser, class Sizer>
 301 prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::clear()
 302 {
 303     erase(begin(),end());
 304 }
 305
 306 template <class ElementParser, class Sizer>
 307 template <class Value>
 308 prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::push_back(Value value,
 309                                                                           size_type n)
 310 {
 311     insert(end(),n,value);
 312 }
 313
 314 template <class ElementParser, class Sizer>
 315 prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::push_back_space(size_type n)
 316 {
 317     shift(end(),n);
 318 }
 319
 320 template <class ElementParser, class Sizer>
 321 template <class Value>
 322 prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::push_front(Value value,
 323                                                                            size_type n)
 324 {
 325     insert(begin(),n,value);
 326 }
 327
 328 template <class ElementParser, class Sizer>
 329 prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::push_front_space(size_type n)
 330 {
 331     shift(begin(),n);
 332 }
 333
 334 // Parser interface
 335
 336 template <class ElementParser, class Sizer>
 337 prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::parser_type
 338 senf::Parse_Vector_Container<ElementParser,Sizer>::parser()
 339     const
 340 {
 341     return parser_type(i(),state());
 342 }
 343
 344 template <class ElementParser, class Sizer>
 345 prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::data_iterator
 346 senf::Parse_Vector_Container<ElementParser,Sizer>::i()
 347     const
 348 {
 349     return boost::next(data().begin(),i_);
 350 }
 351
 352 template <class ElementParser, class Sizer>
 353 prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::state_type
 354 senf::Parse_Vector_Container<ElementParser,Sizer>::state()
 355     const
 356 {
 357     return state_;
 358 }
 359
 360 template <class ElementParser, class Sizer>
 361 prefix_ senf::PacketData &
 362 senf::Parse_Vector_Container<ElementParser,Sizer>::data()
 363     const
 364 {
 365     return *state_;
 366 }
 367
 368 template <class ElementParser, class Sizer>
 369 prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::size_type
 370 senf::Parse_Vector_Container<ElementParser,Sizer>::bytes()
 371     const
 372 {
 373     return size()*ElementParser::fixed_bytes + sizer_.bytes(i(),state());
 374 }
 375
 376 // private members
 377
 378 template <class ElementParser, class Sizer>
 379 prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::setSize(size_type value)
 380 {
 381     sizer_.size(i(),state(),value);
 382 }
 383
 384 /////////////////////////////cti.e///////////////////////////////////////
 385 #undef prefix_
 386
 387 \f
 388 // Local Variables:
 389 // mode: c++
 390 // fill-column: 100
 391 // c-file-style: "senf"
 392 // indent-tabs-mode: nil
 393 // ispell-local-dictionary: "american"
 394 // compile-command: "scons -u test"
 395 // comment-column: 40
 396 // End: