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