senf/Packets/VectorParser.cti

   1 // $Id$
   2 //
   3 // Copyright (C) 2006
   4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
   5 //
   6 // The contents of this file are subject to the Fraunhofer FOKUS Public License
   7 // Version 1.0 (the "License"); you may not use this file except in compliance
   8 // with the License. You may obtain a copy of the License at
   9 // http://senf.berlios.de/license.html
  10 //
  11 // The Fraunhofer FOKUS Public License Version 1.0 is based on,
  12 // but modifies the Mozilla Public License Version 1.1.
  13 // See the full license text for the amendments.
  14 //
  15 // Software distributed under the License is distributed on an "AS IS" basis,
  16 // WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  17 // for the specific language governing rights and limitations under the License.
  18 //
  19 // The Original Code is Fraunhofer FOKUS code.
  20 //
  21 // The Initial Developer of the Original Code is Fraunhofer-Gesellschaft e.V.
  22 // (registered association), Hansastraße 27 c, 80686 Munich, Germany.
  23 // All Rights Reserved.
  24 //
  25 // Contributor(s):
  26 //   Stefan Bund <g0dil@berlios.de>
  27
  28 /** \file
  29     \brief VectorParser inline template implementation */
  30
  31 #include "VectorParser.ih"
  32
  33 // Custom includes
  34
  35 #define prefix_ inline
  36 //-/////////////////////////////////////////////////////////////////////////////////////////////////
  37
  38 //-/////////////////////////////////////////////////////////////////////////////////////////////////
  39 // senf::VectorParser<ElementParser,Sizer>
  40
  41 template <class ElementParser, class AuxPolicy>
  42 prefix_ senf::VectorParser<ElementParser,AuxPolicy>::VectorParser(data_iterator i, state_type s)
  43     : PacketParserBase(i,s), AuxPolicy()
  44 {}
  45
  46 template <class ElementParser, class AuxPolicy>
  47 prefix_ senf::VectorParser<ElementParser,AuxPolicy>::VectorParser(AuxPolicy policy,
  48                                                                   data_iterator i, state_type s)
  49     : PacketParserBase(i,s), AuxPolicy(policy)
  50 {}
  51
  52 template <class ElementParser, class AuxPolicy>
  53 prefix_ typename senf::VectorParser<ElementParser,AuxPolicy>::size_type
  54 senf::VectorParser<ElementParser,AuxPolicy>::bytes()
  55     const
  56 {
  57     return size()*ElementParser::fixed_bytes + AuxPolicy::aux_bytes;
  58 }
  59
  60 // Container interface
  61
  62 template <class ElementParser, class AuxPolicy>
  63 prefix_ typename senf::VectorParser<ElementParser,AuxPolicy>::size_type
  64 senf::VectorParser<ElementParser,AuxPolicy>::size()
  65     const
  66 {
  67     return aux(i(),state());
  68 }
  69
  70 template <class ElementParser, class AuxPolicy>
  71 prefix_ bool senf::VectorParser<ElementParser,AuxPolicy>::empty()
  72     const
  73 {
  74     return size()==0;
  75 }
  76
  77 template <class ElementParser, class AuxPolicy>
  78 prefix_ typename senf::VectorParser<ElementParser,AuxPolicy>::iterator
  79 senf::VectorParser<ElementParser,AuxPolicy>::begin()
  80     const
  81 {
  82     return iterator(adjust(i(),state()),state());
  83 }
  84
  85 template <class ElementParser, class AuxPolicy>
  86 prefix_ typename senf::VectorParser<ElementParser,AuxPolicy>::iterator
  87 senf::VectorParser<ElementParser,AuxPolicy>::end()
  88     const
  89 {
  90     return boost::next(begin(),size());
  91 }
  92
  93 template <class ElementParser, class AuxPolicy>
  94 prefix_ typename senf::VectorParser<ElementParser,AuxPolicy>::value_type
  95 senf::VectorParser<ElementParser,AuxPolicy>::operator[](difference_type i)
  96     const
  97 {
  98     return begin()[i];
  99 }
 100
 101 template <class ElementParser, class AuxPolicy>
 102 prefix_ typename senf::VectorParser<ElementParser,AuxPolicy>::value_type
 103 senf::VectorParser<ElementParser,AuxPolicy>::front()
 104     const
 105 {
 106     return begin()[0];
 107 }
 108
 109 template <class ElementParser, class AuxPolicy>
 110 prefix_ typename senf::VectorParser<ElementParser,AuxPolicy>::value_type
 111 senf::VectorParser<ElementParser,AuxPolicy>::back()
 112     const
 113 {
 114     return begin()[size()-1];
 115 }
 116
 117 // Mutators
 118
 119 template <class ElementParser, class AuxPolicy>
 120 template <class Value>
 121 prefix_ void senf::VectorParser<ElementParser,AuxPolicy>::push_back(Value const & value, size_type n)
 122     const
 123 {
 124     container c (*this);
 125     c.push_back(value,n);
 126 }
 127
 128 template <class ElementParser, class AuxPolicy>
 129 prefix_ typename senf::VectorParser<ElementParser,AuxPolicy>::value_type
 130 senf::VectorParser<ElementParser,AuxPolicy>::push_back_space(size_type n)
 131     const
 132 {
 133     container c (*this);
 134     return c.push_back_space(n);
 135 }
 136
 137 template <class ElementParser, class AuxPolicy>
 138 template <class Value>
 139 prefix_ void senf::VectorParser<ElementParser,AuxPolicy>::push_front(Value const & value, size_type n)
 140     const
 141 {
 142     container c (*this);
 143     c.push_front(value,n);
 144 }
 145
 146 template <class ElementParser, class AuxPolicy>
 147 prefix_ typename senf::VectorParser<ElementParser,AuxPolicy>::value_type
 148 senf::VectorParser<ElementParser,AuxPolicy>::push_front_space(size_type n)
 149     const
 150 {
 151     container c (*this);
 152     return c.push_front_space(n);
 153 }
 154
 155 template <class ElementParser, class AuxPolicy>
 156 prefix_ void senf::VectorParser<ElementParser,AuxPolicy>::resize(size_type n)
 157     const
 158 {
 159     container c (*this);
 160     c.resize(n);
 161 }
 162
 163 template <class ElementParser, class AuxPolicy>
 164 template <class Value>
 165 prefix_ void senf::VectorParser<ElementParser,AuxPolicy>::resize(size_type n, Value value)
 166     const
 167 {
 168     container c (*this);
 169     c.resize(n,value);
 170 }
 171
 172 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 173 // senf::VectorParser_wrapper<Parser,SizeParser,Container>
 174
 175 // structors and default members
 176
 177 // hm ... be careful here ! the data() member is called in an incompletely intitialized
 178 // instance. However, data() only depends on state_ which is initialized before the call. YOU MUST
 179 // NOT CHANGE THE ORDERING OF THE DATA MEMBERS
 180 template <class ElementParser, class AuxPolicy>
 181 prefix_ senf::VectorParser_Container<ElementParser,AuxPolicy>::
 182 VectorParser_Container(parser_type const & vector)
 183     : AuxPolicy::WrapperPolicy(static_cast<AuxPolicy const &>(vector)), state_ (vector.state()),
 184       i_ (std::distance(data().begin(),vector.i()))
 185 {}
 186
 187 // accessors
 188
 189 template <class ElementParser, class AuxPolicy>
 190 prefix_ typename senf::VectorParser_Container<ElementParser,AuxPolicy>::size_type
 191 senf::VectorParser_Container<ElementParser,AuxPolicy>::size()
 192     const
 193 {
 194     return aux(i(),state());
 195 }
 196
 197 template <class ElementParser, class AuxPolicy>
 198 prefix_ bool senf::VectorParser_Container<ElementParser,AuxPolicy>::empty()
 199     const
 200 {
 201     return size() == 0;
 202 }
 203
 204 template <class ElementParser, class AuxPolicy>
 205 prefix_ typename senf::VectorParser_Container<ElementParser,AuxPolicy>::iterator
 206 senf::VectorParser_Container<ElementParser,AuxPolicy>::begin()
 207     const
 208 {
 209     return iterator(adjust(i(),state()),state());
 210 }
 211
 212 template <class ElementParser, class AuxPolicy>
 213 prefix_ typename senf::VectorParser_Container<ElementParser,AuxPolicy>::iterator
 214 senf::VectorParser_Container<ElementParser,AuxPolicy>::end()
 215     const
 216 {
 217     return boost::next(begin(),size());
 218 }
 219
 220 template <class ElementParser, class AuxPolicy>
 221 prefix_ typename senf::VectorParser_Container<ElementParser,AuxPolicy>::value_type
 222 senf::VectorParser_Container<ElementParser,AuxPolicy>::operator[](difference_type i)
 223     const
 224 {
 225     return begin()[i];
 226 }
 227
 228 template <class ElementParser, class AuxPolicy>
 229 prefix_ typename senf::VectorParser_Container<ElementParser,AuxPolicy>::value_type
 230 senf::VectorParser_Container<ElementParser,AuxPolicy>::front()
 231     const
 232 {
 233     return begin()[0];
 234 }
 235
 236 template <class ElementParser, class AuxPolicy>
 237 prefix_ typename senf::VectorParser_Container<ElementParser,AuxPolicy>::value_type
 238 senf::VectorParser_Container<ElementParser,AuxPolicy>::back()
 239     const
 240 {
 241     return begin()[size()-1];
 242 }
 243
 244 // Mutators
 245
 246 template <class ElementParser, class AuxPolicy>
 247 template <class Value>
 248 prefix_ void senf::VectorParser_Container<ElementParser,AuxPolicy>::insert(iterator pos,
 249                                                                        Value const & t)
 250 {
 251     *shift(pos) << t;
 252 }
 253
 254 template <class ElementParser, class AuxPolicy>
 255 prefix_ void senf::VectorParser_Container<ElementParser,AuxPolicy>::erase(iterator pos, size_type n)
 256 {
 257     setSize(size()-n);
 258     data().erase(pos.raw(),boost::next(pos.raw(),n*ElementParser::fixed_bytes));
 259 }
 260
 261 template <class ElementParser, class AuxPolicy>
 262 prefix_ void senf::VectorParser_Container<ElementParser,AuxPolicy>::erase(iterator f, iterator l)
 263 {
 264     erase(f,std::distance(f,l));
 265 }
 266
 267 template <class ElementParser, class AuxPolicy>
 268 prefix_ void senf::VectorParser_Container<ElementParser,AuxPolicy>::clear()
 269 {
 270     erase(begin(),end());
 271 }
 272
 273 template <class ElementParser, class AuxPolicy>
 274 template <class Value>
 275 prefix_ void senf::VectorParser_Container<ElementParser,AuxPolicy>::push_back(Value const & value,
 276                                                                               size_type n)
 277 {
 278     insert(end(),n,value);
 279 }
 280
 281 template <class ElementParser, class AuxPolicy>
 282 prefix_ typename senf::VectorParser_Container<ElementParser,AuxPolicy>::value_type
 283 senf::VectorParser_Container<ElementParser,AuxPolicy>::push_back_space(size_type n)
 284 {
 285     return *shift(end(),n);
 286 }
 287
 288 template <class ElementParser, class AuxPolicy>
 289 template <class Value>
 290 prefix_ void senf::VectorParser_Container<ElementParser,AuxPolicy>::push_front(Value const & value,
 291                                                                                size_type n)
 292 {
 293     insert(begin(),n,value);
 294 }
 295
 296 template <class ElementParser, class AuxPolicy>
 297 prefix_ typename senf::VectorParser_Container<ElementParser,AuxPolicy>::value_type
 298 senf::VectorParser_Container<ElementParser,AuxPolicy>::push_front_space(size_type n)
 299 {
 300     return *shift(begin(),n);
 301 }
 302
 303 // Parser interface
 304
 305 template <class ElementParser, class AuxPolicy>
 306 prefix_ typename senf::VectorParser_Container<ElementParser,AuxPolicy>::parser_type
 307 senf::VectorParser_Container<ElementParser,AuxPolicy>::parser()
 308     const
 309 {
 310     return parser_type(i(),state());
 311 }
 312
 313 template <class ElementParser, class AuxPolicy>
 314 prefix_ typename senf::VectorParser_Container<ElementParser,AuxPolicy>::data_iterator
 315 senf::VectorParser_Container<ElementParser,AuxPolicy>::i()
 316     const
 317 {
 318     return boost::next(data().begin(),i_);
 319 }
 320
 321 template <class ElementParser, class AuxPolicy>
 322 prefix_ typename senf::VectorParser_Container<ElementParser,AuxPolicy>::state_type
 323 senf::VectorParser_Container<ElementParser,AuxPolicy>::state()
 324     const
 325 {
 326     return state_;
 327 }
 328
 329 template <class ElementParser, class AuxPolicy>
 330 prefix_ senf::PacketData &
 331 senf::VectorParser_Container<ElementParser,AuxPolicy>::data()
 332     const
 333 {
 334     return *state_;
 335 }
 336
 337 template <class ElementParser, class AuxPolicy>
 338 prefix_ typename senf::VectorParser_Container<ElementParser,AuxPolicy>::size_type
 339 senf::VectorParser_Container<ElementParser,AuxPolicy>::bytes()
 340     const
 341 {
 342     return size()*ElementParser::fixed_bytes + AuxPolicy::aux_bytes;
 343 }
 344
 345 // private members
 346
 347 template <class ElementParser, class AuxPolicy>
 348 prefix_ void senf::VectorParser_Container<ElementParser,AuxPolicy>::setSize(size_type value)
 349 {
 350     aux(value, i(),state());
 351 }
 352
 353 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 354 #undef prefix_
 355
 356 \f
 357 // Local Variables:
 358 // mode: c++
 359 // fill-column: 100
 360 // c-file-style: "senf"
 361 // indent-tabs-mode: nil
 362 // ispell-local-dictionary: "american"
 363 // compile-command: "scons -u test"
 364 // comment-column: 40
 365 // End: