senf/Packets/ListParser.cti

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