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 // Definition of inline template functions
  24
  25 #include "ParseVec.ih"
  26
  27 // Custom includes
  28
  29 #define prefix_ inline
  30 ///////////////////////////////cti.p///////////////////////////////////////
  31
  32 ///////////////////////////////////////////////////////////////////////////
  33 // senf::Parse_Vector<ElementParser,Sizer>
  34
  35 template <class ElementParser, class Sizer>
  36 prefix_ senf::Parse_Vector<ElementParser,Sizer>::Parse_Vector(data_iterator i, state_type s)
  37     : PacketParserBase(i,s), sizer_()
  38 {}
  39
  40 template <class ElementParser, class Sizer>
  41 prefix_ senf::Parse_Vector<ElementParser,Sizer>::Parse_Vector(Sizer sizer, data_iterator i,
  42                                                               state_type s)
  43     : PacketParserBase(i,s), sizer_(sizer)
  44 {}
  45
  46 template <class ElementParser, class Sizer>
  47 prefix_ typename senf::Parse_Vector<ElementParser,Sizer>::size_type
  48 senf::Parse_Vector<ElementParser,Sizer>::bytes()
  49     const
  50 {
  51     return size()*ElementParser::fixed_bytes + sizer_.bytes(i(),state());
  52 }
  53
  54 // Container interface
  55
  56 template <class ElementParser, class Sizer>
  57 prefix_ typename senf::Parse_Vector<ElementParser,Sizer>::size_type
  58 senf::Parse_Vector<ElementParser,Sizer>::size()
  59     const
  60 {
  61     return sizer_.size(i(),state());
  62 }
  63
  64 template <class ElementParser, class Sizer>
  65 prefix_ bool senf::Parse_Vector<ElementParser,Sizer>::empty()
  66     const
  67 {
  68     return size()==0;
  69 }
  70
  71 template <class ElementParser, class Sizer>
  72 prefix_ typename senf::Parse_Vector<ElementParser,Sizer>::iterator
  73 senf::Parse_Vector<ElementParser,Sizer>::begin()
  74     const
  75 {
  76     return iterator(sizer_.begin(i(),state()),state());
  77 }
  78
  79 template <class ElementParser, class Sizer>
  80 prefix_ typename senf::Parse_Vector<ElementParser,Sizer>::iterator
  81 senf::Parse_Vector<ElementParser,Sizer>::end()
  82     const
  83 {
  84     return boost::next(begin(),size());
  85 }
  86
  87 template <class ElementParser, class Sizer>
  88 prefix_ typename senf::Parse_Vector<ElementParser,Sizer>::value_type
  89 senf::Parse_Vector<ElementParser,Sizer>::operator[](difference_type i)
  90     const
  91 {
  92     return begin()[i];
  93 }
  94
  95 template <class ElementParser, class Sizer>
  96 prefix_ typename senf::Parse_Vector<ElementParser,Sizer>::value_type
  97 senf::Parse_Vector<ElementParser,Sizer>::front()
  98     const
  99 {
 100     return begin()[0];
 101 }
 102
 103 template <class ElementParser, class Sizer>
 104 prefix_ typename senf::Parse_Vector<ElementParser,Sizer>::value_type
 105 senf::Parse_Vector<ElementParser,Sizer>::back()
 106     const
 107 {
 108     return begin()[size()-1];
 109 }
 110
 111 // Mutators
 112
 113 template <class ElementParser, class Sizer>
 114 template <class Value>
 115 prefix_ void senf::Parse_Vector<ElementParser,Sizer>::push_back(Value value, size_type n)
 116     const
 117 {
 118     container c (*this);
 119     c.push_back(value,n);
 120 }
 121
 122 template <class ElementParser, class Sizer>
 123 prefix_ void senf::Parse_Vector<ElementParser,Sizer>::push_back_space(size_type n)
 124     const
 125 {
 126     container c (*this);
 127     c.push_back_space(n);
 128 }
 129
 130 template <class ElementParser, class Sizer>
 131 template <class Value>
 132 prefix_ void senf::Parse_Vector<ElementParser,Sizer>::push_front(Value value, size_type n)
 133     const
 134 {
 135     container c (*this);
 136     c.push_front(value,n);
 137 }
 138
 139 template <class ElementParser, class Sizer>
 140 prefix_ void senf::Parse_Vector<ElementParser,Sizer>::push_front_space(size_type n)
 141     const
 142 {
 143     container c (*this);
 144     c.push_front_space(n);
 145 }
 146
 147 template <class ElementParser, class Sizer>
 148 prefix_ void senf::Parse_Vector<ElementParser,Sizer>::resize(size_type n)
 149     const
 150 {
 151     container c (*this);
 152     c.resize(n);
 153 }
 154
 155 template <class ElementParser, class Sizer>
 156 template <class Value>
 157 prefix_ void senf::Parse_Vector<ElementParser,Sizer>::resize(size_type n, Value value)
 158     const
 159 {
 160     container c (*this);
 161     c.resize(n,value);
 162 }
 163
 164 ///////////////////////////////////////////////////////////////////////////
 165 // senf::SimpleSizeParser<SizeParser,offset>
 166
 167 template <class SizeParser>
 168 prefix_ typename senf::detail::Parse_VectorN_Sizer<SizeParser>::size_type
 169 senf::detail::Parse_VectorN_Sizer<SizeParser>::size(iterator i, state_type s)
 170     const
 171 {
 172     return SizeParser(i,s).value();
 173 }
 174
 175 template <class SizeParser>
 176 prefix_ void senf::detail::Parse_VectorN_Sizer<SizeParser>::size(iterator i, state_type s,
 177                                                               size_type v)
 178     const
 179 {
 180     SizeParser(i,s).value(v);
 181 }
 182
 183 template <class SizeParser>
 184 prefix_ typename senf::detail::Parse_VectorN_Sizer<SizeParser>::iterator
 185 senf::detail::Parse_VectorN_Sizer<SizeParser>::begin(iterator i, state_type s)
 186     const
 187 {
 188     return boost::next(i,SizeParser::fixed_bytes);
 189 }
 190
 191 template <class SizeParser>
 192 prefix_ typename senf::detail::Parse_VectorN_Sizer<SizeParser>::size_type
 193 senf::detail::Parse_VectorN_Sizer<SizeParser>::bytes(iterator i, state_type s)
 194     const
 195 {
 196     return SizeParser::fixed_bytes;
 197 }
 198
 199 template <class SizeParser>
 200 prefix_ void senf::detail::Parse_VectorN_Sizer<SizeParser>::init(iterator i, state_type s)
 201     const
 202 {}
 203
 204 ///////////////////////////////////////////////////////////////////////////
 205 // senf::Parse_Vector_wrapper<Parser,SizeParser,Container>
 206
 207 // structors and default members
 208
 209 // hm ... be careful here ! the data() member is called in an incompletely intitialized
 210 // instance. However, data() only depends on state_ which is initialized before the call. YOU MUST
 211 // NOT CHANGE THE ORDERING OF THE DATA MEMBERS
 212 template <class ElementParser, class Sizer>
 213 prefix_ senf::Parse_Vector_Container<ElementParser,Sizer>::
 214 Parse_Vector_Container(parser_type const & vector)
 215     : sizer_ (vector.sizer_), state_ (vector.state()),
 216       i_ (std::distance(data().begin(),vector.i()))
 217 {}
 218
 219 // accessors
 220
 221 template <class ElementParser, class Sizer>
 222 prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::size_type
 223 senf::Parse_Vector_Container<ElementParser,Sizer>::size()
 224     const
 225 {
 226     return sizer_.size(i(),state());
 227 }
 228
 229 template <class ElementParser, class Sizer>
 230 prefix_ bool senf::Parse_Vector_Container<ElementParser,Sizer>::empty()
 231     const
 232 {
 233     return size() == 0;
 234 }
 235
 236 template <class ElementParser, class Sizer>
 237 prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::iterator
 238 senf::Parse_Vector_Container<ElementParser,Sizer>::begin()
 239     const
 240 {
 241     return iterator(sizer_.begin(i(),state()),state());
 242 }
 243
 244 template <class ElementParser, class Sizer>
 245 prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::iterator
 246 senf::Parse_Vector_Container<ElementParser,Sizer>::end()
 247     const
 248 {
 249     return boost::next(begin(),size());
 250 }
 251
 252 template <class ElementParser, class Sizer>
 253 prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::value_type
 254 senf::Parse_Vector_Container<ElementParser,Sizer>::operator[](difference_type i)
 255     const
 256 {
 257     return begin()[i];
 258 }
 259
 260 template <class ElementParser, class Sizer>
 261 prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::value_type
 262 senf::Parse_Vector_Container<ElementParser,Sizer>::front()
 263     const
 264 {
 265     return begin()[0];
 266 }
 267
 268 template <class ElementParser, class Sizer>
 269 prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::value_type
 270 senf::Parse_Vector_Container<ElementParser,Sizer>::back()
 271     const
 272 {
 273     return begin()[size()-1];
 274 }
 275
 276 // Mutators
 277
 278 template <class ElementParser, class Sizer>
 279 template <class Value>
 280 prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::insert(iterator pos,
 281                                                                        Value const & t)
 282 {
 283     *shift(pos) << t;
 284 }
 285
 286 template <class ElementParser, class Sizer>
 287 prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::erase(iterator pos, size_type n)
 288 {
 289     data().erase(pos.raw(),boost::next(pos.raw(),n*ElementParser::fixed_bytes));
 290     setSize(size()-n);
 291 }
 292
 293 template <class ElementParser, class Sizer>
 294 prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::erase(iterator f, iterator l)
 295 {
 296     erase(f,std::distance(f,l));
 297 }
 298
 299 template <class ElementParser, class Sizer>
 300 prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::clear()
 301 {
 302     erase(begin(),end());
 303 }
 304
 305 template <class ElementParser, class Sizer>
 306 template <class Value>
 307 prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::push_back(Value value,
 308                                                                           size_type n)
 309 {
 310     insert(end(),n,value);
 311 }
 312
 313 template <class ElementParser, class Sizer>
 314 prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::push_back_space(size_type n)
 315 {
 316     shift(end(),n);
 317 }
 318
 319 template <class ElementParser, class Sizer>
 320 template <class Value>
 321 prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::push_front(Value value,
 322                                                                            size_type n)
 323 {
 324     insert(begin(),n,value);
 325 }
 326
 327 template <class ElementParser, class Sizer>
 328 prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::push_front_space(size_type n)
 329 {
 330     shift(begin(),n);
 331 }
 332
 333 // Parser interface
 334
 335 template <class ElementParser, class Sizer>
 336 prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::parser_type
 337 senf::Parse_Vector_Container<ElementParser,Sizer>::parser()
 338     const
 339 {
 340     return parser_type(i(),state());
 341 }
 342
 343 template <class ElementParser, class Sizer>
 344 prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::data_iterator
 345 senf::Parse_Vector_Container<ElementParser,Sizer>::i()
 346     const
 347 {
 348     return boost::next(data().begin(),i_);
 349 }
 350
 351 template <class ElementParser, class Sizer>
 352 prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::state_type
 353 senf::Parse_Vector_Container<ElementParser,Sizer>::state()
 354     const
 355 {
 356     return state_;
 357 }
 358
 359 template <class ElementParser, class Sizer>
 360 prefix_ senf::PacketData &
 361 senf::Parse_Vector_Container<ElementParser,Sizer>::data()
 362     const
 363 {
 364     return *state_;
 365 }
 366
 367 template <class ElementParser, class Sizer>
 368 prefix_ typename senf::Parse_Vector_Container<ElementParser,Sizer>::size_type
 369 senf::Parse_Vector_Container<ElementParser,Sizer>::bytes()
 370     const
 371 {
 372     return size()*ElementParser::fixed_bytes + sizer_.bytes(i(),state());
 373 }
 374
 375 // private members
 376
 377 template <class ElementParser, class Sizer>
 378 prefix_ void senf::Parse_Vector_Container<ElementParser,Sizer>::setSize(size_type value)
 379 {
 380     sizer_.size(i(),state(),value);
 381 }
 382
 383 /////////////////////////////cti.e///////////////////////////////////////
 384 #undef prefix_
 385
 386 \f
 387 // Local Variables:
 388 // mode: c++
 389 // fill-column: 100
 390 // c-file-style: "senf"
 391 // indent-tabs-mode: nil
 392 // ispell-local-dictionary: "american"
 393 // compile-command: "scons -u test"
 394 // End: