Packets/ParseList.cti

   1 // Copyright (C) 2007
   2 // Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
   3 // Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
   4 //     Stefan Bund <g0dil@berlios.de>
   5 //
   6 // This program is free software; you can redistribute it and/or modify
   7 // it under the terms of the GNU General Public License as published by
   8 // the Free Software Foundation; either version 2 of the License, or
   9 // (at your option) any later version.
  10 //
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the
  18 // Free Software Foundation, Inc.,
  19 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20
  21 /** \file
  22     \brief ParseList inline template implementation */
  23
  24 #include "ParseList.ih"
  25
  26 // Custom includes
  27
  28 #define prefix_ inline
  29 ///////////////////////////////cti.p///////////////////////////////////////
  30
  31 ///////////////////////////////////////////////////////////////////////////
  32 // senf::Parse_List<ListPolicy>
  33
  34 template <class ListPolicy>
  35 prefix_ senf::Parse_List<ListPolicy>::Parse_List(data_iterator i, state_type s)
  36     : PacketParserBase(i,s), ListPolicy()
  37 {}
  38
  39 template <class ListPolicy>
  40 prefix_ senf::Parse_List<ListPolicy>::Parse_List(ListPolicy policy,
  41                                                                data_iterator i, state_type s)
  42     : PacketParserBase(i,s), ListPolicy(policy)
  43 {}
  44
  45 template <class ListPolicy>
  46 prefix_ senf::PacketParserBase::size_type
  47 senf::Parse_List<ListPolicy>::bytes()
  48     const
  49 {
  50     return ListPolicy::bytes(i(),state());
  51 }
  52
  53 ///////////////////////////////////////////////////////////////////////////
  54 // Container interface
  55
  56 template <class ListPolicy>
  57 prefix_ senf::PacketParserBase::size_type
  58 senf::Parse_List<ListPolicy>::size()
  59     const
  60 {
  61     return ListPolicy::size(i(),state());
  62 }
  63
  64 template <class ListPolicy>
  65 prefix_ bool senf::Parse_List<ListPolicy>::empty()
  66     const
  67 {
  68     return begin() == end();
  69 }
  70
  71 template <class ListPolicy>
  72 prefix_ typename senf::Parse_List<ListPolicy>::iterator
  73 senf::Parse_List<ListPolicy>::begin()
  74     const
  75 {
  76     return iterator(i(),state(),iterator::Begin);
  77 }
  78
  79 template <class ListPolicy>
  80 prefix_ typename senf::Parse_List<ListPolicy>::iterator
  81 senf::Parse_List<ListPolicy>::end()
  82     const
  83 {
  84     return iterator(i(),state(),iterator::End);
  85 }
  86
  87 template <class ListPolicy>
  88 prefix_ typename senf::Parse_List<ListPolicy>::value_type
  89 senf::Parse_List<ListPolicy>::front()
  90     const
  91 {
  92     BOOST_ASSERT( ! empty() );
  93     return *begin();
  94 }
  95
  96 template <class ListPolicy>
  97 template <class Value>
  98 prefix_ void senf::Parse_List<ListPolicy>::push_back(Value value, size_type n)
  99     const
 100 {
 101     container c(*this);
 102     c.push_back(value,n);
 103 }
 104
 105 template <class ListPolicy>
 106 prefix_ void senf::Parse_List<ListPolicy>::push_back_space(size_type n)
 107     const
 108 {
 109     container c(*this);
 110     c.push_back_space(n);
 111 }
 112
 113 template <class ListPolicy>
 114 template <class Value>
 115 prefix_ void senf::Parse_List<ListPolicy>::push_front(Value value, size_type n)
 116     const
 117 {
 118     container c(*this);
 119     c.push_front(value,n);
 120 }
 121
 122 template <class ListPolicy>
 123 prefix_ void senf::Parse_List<ListPolicy>::push_front_space(size_type n)
 124     const
 125 {
 126     container c(*this);
 127     c.push_front_space(n);
 128 }
 129
 130 template <class ListPolicy>
 131 prefix_ void senf::Parse_List<ListPolicy>::resize(size_type n)
 132     const
 133 {
 134     container c(*this);
 135     c.resize(n);
 136 }
 137
 138 template <class ListPolicy>
 139 template <class Value>
 140 prefix_ void senf::Parse_List<ListPolicy>::resize(size_type n, Value value)
 141     const
 142 {
 143     container c(*this);
 144     c.resize(n,value);
 145 }
 146
 147 ///////////////////////////////////////////////////////////////////////////
 148 // senf::detail::Parse_List_Iterator<ElementParser,IteratorPolicy>
 149
 150 template <class ElementParser, class IteratorPolicy>
 151 prefix_ senf::detail::Parse_List_Iterator<ElementParser,IteratorPolicy>::Parse_List_Iterator()
 152 {}
 153
 154 template <class ElementParser, class IteratorPolicy>
 155 prefix_ senf::detail::Parse_List_Iterator<ElementParser,IteratorPolicy>::
 156 Parse_List_Iterator(PacketParserBase::data_iterator i, PacketParserBase::state_type s, Begin_t)
 157     : IteratorPolicy(), i_(IteratorPolicy::setBegin(i,s)), s_(s)
 158 {}
 159
 160 template <class ElementParser, class IteratorPolicy>
 161 prefix_ senf::detail::Parse_List_Iterator<ElementParser,IteratorPolicy>::
 162 Parse_List_Iterator(PacketParserBase::data_iterator i, PacketParserBase::state_type s, End_t)
 163     : IteratorPolicy(), i_(IteratorPolicy::setEnd(i,s)), s_(s)
 164 {}
 165
 166 template <class ElementParser, class IteratorPolicy>
 167 prefix_ senf::detail::Parse_List_Iterator<ElementParser,IteratorPolicy>::
 168 Parse_List_Iterator(PacketParserBase::data_iterator i, PacketParserBase::state_type s,
 169                     PacketParserBase::data_iterator p)
 170     : IteratorPolicy(), i_(p), s_(s)
 171 {
 172     IteratorPolicy::setFromPosition(i,s,p);
 173 }
 174
 175 template <class ElementParser, class IteratorPolicy>
 176 prefix_ senf::PacketParserBase::data_iterator
 177 senf::detail::Parse_List_Iterator<ElementParser,IteratorPolicy>::raw()
 178     const
 179 {
 180     return IteratorPolicy::raw(i_,s_);
 181 }
 182
 183 template <class ElementParser, class IteratorPolicy>
 184 prefix_ ElementParser
 185 senf::detail::Parse_List_Iterator<ElementParser,IteratorPolicy>::dereference()
 186     const
 187 {
 188     return ElementParser(i_,s_);
 189 }
 190
 191 template <class ElementParser, class IteratorPolicy>
 192 prefix_ bool senf::detail::Parse_List_Iterator<ElementParser,IteratorPolicy>::
 193 equal(Parse_List_Iterator const & other)
 194     const
 195 {
 196     return i_ == other.i_;
 197 }
 198
 199 template <class ElementParser, class IteratorPolicy>
 200 prefix_ void senf::detail::Parse_List_Iterator<ElementParser,IteratorPolicy>::increment()
 201 {
 202     i_ = IteratorPolicy::next(i_,s_);
 203 }
 204
 205 ///////////////////////////////////////////////////////////////////////////
 206 // senf::Parse_List_Container<ListPolicy>
 207
 208 // Structors and default members
 209
 210 template <class ListPolicy>
 211 prefix_ senf::Parse_List_Container<ListPolicy>::
 212 Parse_List_Container(parser_type const & list)
 213     : ListPolicy(list), state_(list.state()), i_(std::distance(data().begin(),list.i()))
 214 {}
 215
 216 template <class ListPolicy>
 217 prefix_ senf::Parse_List_Container<ListPolicy>::~Parse_List_Container()
 218 {
 219     ListPolicy::update(i(),state());
 220 }
 221
 222 // Accessors
 223
 224 template <class ListPolicy>
 225 prefix_ typename senf::Parse_List_Container<ListPolicy>::size_type
 226 senf::Parse_List_Container<ListPolicy>::size()
 227     const
 228 {
 229     ListPolicy::update(i(),state());
 230     return ListPolicy::size(i(),state());
 231 }
 232
 233 template <class ListPolicy>
 234 prefix_ bool senf::Parse_List_Container<ListPolicy>::empty()
 235     const
 236 {
 237     ListPolicy::update(i(),state());
 238     return begin() == end();
 239 }
 240
 241 template <class ListPolicy>
 242 prefix_ typename senf::Parse_List_Container<ListPolicy>::iterator
 243 senf::Parse_List_Container<ListPolicy>::begin()
 244     const
 245 {
 246     ListPolicy::update(i(),state());
 247     return iterator(i(),state(),iterator::Begin);
 248 }
 249
 250 template <class ListPolicy>
 251 prefix_ typename senf::Parse_List_Container<ListPolicy>::iterator
 252 senf::Parse_List_Container<ListPolicy>::end()
 253     const
 254 {
 255     ListPolicy::update(i(),state());
 256     return iterator(i(),state(),iterator::End);
 257 }
 258
 259 template <class ListPolicy>
 260 prefix_ typename senf::Parse_List_Container<ListPolicy>::value_type
 261 senf::Parse_List_Container<ListPolicy>::front()
 262     const
 263 {
 264     BOOST_ASSERT( ! empty() );
 265     return *begin();
 266 }
 267
 268 // Mutators
 269
 270 template <class ListPolicy>
 271 template <class Value>
 272 prefix_ void senf::Parse_List_Container<ListPolicy>::insert(iterator pos,
 273                                                             Value const & t)
 274 {
 275     insert(pos,1,t);
 276 }
 277
 278 template <class ListPolicy>
 279 prefix_ void senf::Parse_List_Container<ListPolicy>::erase(iterator f, iterator l)
 280 {
 281     erase(f,std::distance(f,l));
 282 }
 283
 284 template <class ListPolicy>
 285 template <class Value>
 286 prefix_ void senf::Parse_List_Container<ListPolicy>::push_back(Value value,
 287                                                                size_type n)
 288 {
 289     insert(end(),n,value);
 290 }
 291
 292 template <class ListPolicy>
 293 prefix_ void senf::Parse_List_Container<ListPolicy>::push_back_space(size_type n)
 294 {
 295     shift(end(),n);
 296 }
 297
 298 template <class ListPolicy>
 299 template <class Value>
 300 prefix_ void senf::Parse_List_Container<ListPolicy>::push_front(Value value,
 301                                                                 size_type n)
 302 {
 303     insert(begin(),n,value);
 304 }
 305
 306 template <class ListPolicy>
 307 prefix_ void senf::Parse_List_Container<ListPolicy>::push_front_space(size_type n)
 308 {
 309     shift(begin(),n);
 310 }
 311
 312 // Parser interface
 313
 314 template <class ListPolicy>
 315 prefix_ typename senf::Parse_List_Container<ListPolicy>::parser_type
 316 senf::Parse_List_Container<ListPolicy>::parser()
 317     const
 318 {
 319     ListPolicy::update(i(),state());
 320     return parser_type(i(),state());
 321 }
 322
 323 template <class ListPolicy>
 324 prefix_ typename senf::Parse_List_Container<ListPolicy>::data_iterator
 325 senf::Parse_List_Container<ListPolicy>::i()
 326     const
 327 {
 328     return boost::next(data().begin(),i_);
 329 }
 330
 331 template <class ListPolicy>
 332 prefix_ typename senf::Parse_List_Container<ListPolicy>::state_type
 333 senf::Parse_List_Container<ListPolicy>::state()
 334     const
 335 {
 336     return state_;
 337 }
 338
 339 template <class ListPolicy>
 340 prefix_ senf::PacketData & senf::Parse_List_Container<ListPolicy>::data()
 341     const
 342 {
 343     return *state_;
 344 }
 345
 346 template <class ListPolicy>
 347 prefix_ typename senf::Parse_List_Container<ListPolicy>::size_type
 348 senf::Parse_List_Container<ListPolicy>::bytes()
 349     const
 350 {
 351     ListPolicy::update(i(),state());
 352     return ListPolicy::bytes(i(),state());
 353 }
 354
 355 template <class ListPolicy>
 356 prefix_ void senf::Parse_List_Container<ListPolicy>::init()
 357     const
 358 {
 359     parser().init();
 360 }
 361
 362 ///////////////////////////////cti.e///////////////////////////////////////
 363 #undef prefix_
 364
 365 \f
 366 // Local Variables:
 367 // mode: c++
 368 // fill-column: 100
 369 // comment-column: 40
 370 // c-file-style: "senf"
 371 // indent-tabs-mode: nil
 372 // ispell-local-dictionary: "american"
 373 // compile-command: "scons -u test"
 374 // End: