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