senf/Packets/ListParser.cti

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