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