senf/Packets/DefaultBundle/ListOptionTypeParser.cti

   1 // $Id$
   2 //
   3 // Copyright (C) 2009
   4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
   5 // Competence Center NETwork research (NET), St. Augustin, GERMANY
   6 //     Philipp.Batroff@fokus.fraunhofer.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 ListOptionTypeParser inline template implementation */
  25
  26 #include "ListOptionTypeParser.ih"
  27
  28 // Custom includes
  29
  30 #define prefix_ inline
  31 //-/////////////////////////////////////////////////////////////////////////////////////////////////
  32
  33 //-/////////////////////////////////////////////////////////////////////////////////////////////////
  34 // senf::detail::ListOptionTypeParser_Policy<ElementParser,AuxPolicy>
  35
  36 template <class ElementParser, class AuxPolicy>
  37 prefix_
  38 senf::detail::ListOptionTypeParser_Policy<ElementParser,AuxPolicy>::
  39 ListOptionTypeParser_Policy()
  40 {}
  41
  42 template <class ElementParser, class AuxPolicy>
  43 template <class Arg>
  44 prefix_
  45 senf::detail::ListOptionTypeParser_Policy<ElementParser,AuxPolicy>::
  46 ListOptionTypeParser_Policy(Arg const & arg)
  47     : AuxPolicy(arg)
  48 {}
  49
  50 template <class ElementParser, class AuxPolicy>
  51 prefix_ typename senf::detail::ListOptionTypeParser_Policy<ElementParser, AuxPolicy>::size_type
  52 senf::detail::ListOptionTypeParser_Policy<ElementParser,AuxPolicy>::bytes(data_iterator i,
  53                                                                           state_type s)
  54     const
  55 {
  56     return ((AuxPolicy::aux(i, s) * 8 + 6)  + AuxPolicy::aux_bytes);
  57 }
  58
  59 template <class ElementParser, class AuxPolicy>
  60 prefix_ typename senf::detail::ListOptionTypeParser_Policy<ElementParser,AuxPolicy>::size_type
  61 senf::detail::ListOptionTypeParser_Policy<ElementParser,AuxPolicy>::size(data_iterator i,
  62                                                                          state_type s)
  63     const
  64 {
  65     parser_type p(*this, i, s);
  66     container_type c(p);
  67     return std::distance(c.begin(), c.end());
  68 }
  69
  70 template <class ElementParser, class AuxPolicy>
  71 prefix_ void
  72 senf::detail::ListOptionTypeParser_Policy<ElementParser,AuxPolicy>::init(data_iterator i,
  73                                                                          state_type s)
  74     const
  75 {
  76     i[0] = 1u;
  77     i[1] = 4u;
  78     for (unsigned int n = 2;n < 6; ++n)
  79         i[n] = 0u;
  80     AuxPolicy::aux(0, i, s);
  81 }
  82
  83 //-/////////////////////////////////////////////////////////////////////////////////////////////////
  84 // senf::detail::ListOptionTypeParser_Policy<ElementParser,BytesParser>
  85
  86 //constructor
  87 template <class ElementParser, class AuxPolicy>
  88 prefix_
  89 senf::detail::ListOptionTypeParser_Policy<ElementParser,AuxPolicy>::container_policy::
  90 container_policy(parser_policy const & p)
  91     : AuxPolicy(p)
  92 {}
  93
  94 //destructor
  95 template <class ElementParser, class AuxPolicy>
  96 prefix_
  97 senf::detail::ListOptionTypeParser_Policy<ElementParser,AuxPolicy>::container_policy::
  98 ~container_policy()
  99 {}
 100
 101 //construct method
 102 template <class ElementParser, class AuxPolicy>
 103 prefix_ void
 104 senf::detail::ListOptionTypeParser_Policy<ElementParser,AuxPolicy>::container_policy::
 105 construct(container_type & c)
 106 {
 107     safe_data_iterator i (c.data(), c.i()) ;
 108     realAux_ = (AuxPolicy::aux(i, c.state()) * 8) + 6;
 109     safe_data_iterator e = i + realAux_;
 110     for (n_ = 0; i != e;) {
 111         size_type elByte;
 112         if (i[0] == 0u)
 113             elByte = 1;
 114         else
 115             elByte = senf::bytes(ElementParser(i, c.state()));
 116         if (((i + elByte) == e) && (i[0] == 0u || i[0] == 1u)) { //check weather last element is padding or not
 117             realAux_ -= std::distance(i, e);
 118             c.data().erase(i, e); //delete padding
 119             e = i; //set end iterator
 120         } else{
 121             ++n_;
 122             std::advance(i, elByte);
 123         }
 124     }
 125     container_size_ = c.data().size(); //set actual size without padding
 126 }
 127
 128 //destruct method
 129 template <class ElementParser, class AuxPolicy>
 130 prefix_ void
 131 senf::detail::ListOptionTypeParser_Policy<ElementParser,AuxPolicy>::container_policy::
 132 destruct(container_type & c)
 133 {
 134     //data_iterator i (AuxPolicy::adjust(parser_type::get(p).i(), parser_type::get(p).state()));
 135     safe_data_iterator i (c.data(), c.i()) ;
 136     safe_data_iterator e = i + realAux_;
 137     unsigned int padBytes = 0;
 138     if (realAux_ == 0)      //if list is empty, 6 padding bytes required!
 139       padBytes = 6;
 140     else{
 141       padBytes = ( (realAux_+2) % 8);
 142       if (padBytes != 0)
 143           padBytes = 8 - padBytes;
 144     }
 145     if (padBytes > 0) {
 146         c.data().insert(e, padBytes, 0u);
 147         if (padBytes > 1) {
 148             e[0] = 1u;
 149             e[1] = padBytes - 2;
 150         } else
 151             e[0] = 0;
 152         container_size_ += padBytes;
 153         realAux_ += padBytes;
 154         ++n_;
 155     }
 156     AuxPolicy::aux(( (realAux_ + 2)/ 8 - 1), i, c.state());
 157 }
 158
 159 //bytes()
 160 template <class ElementParser, class AuxPolicy>
 161 prefix_ typename senf::detail::ListOptionTypeParser_Policy<
 162     ElementParser,AuxPolicy>::container_policy::size_type
 163 senf::detail::ListOptionTypeParser_Policy<ElementParser,AuxPolicy>::container_policy::
 164 bytes(data_iterator i, state_type s)
 165     const
 166 {
 167     return (realAux_ );
 168 }
 169
 170 //size()
 171 template <class ElementParser, class AuxPolicy>
 172 prefix_ typename senf::detail::ListOptionTypeParser_Policy<
 173     ElementParser,AuxPolicy>::container_policy::size_type
 174 senf::detail::ListOptionTypeParser_Policy<ElementParser,AuxPolicy>::container_policy::
 175 size(data_iterator i, state_type s)
 176     const
 177 {
 178     return n_;
 179 }
 180
 181 //init()
 182 template <class ElementParser, class AuxPolicy>
 183 prefix_ void
 184 senf::detail::ListOptionTypeParser_Policy<ElementParser,AuxPolicy>::container_policy::
 185 init(data_iterator i, state_type s)
 186 {
 187     realAux_ = 0;
 188     n_ = 0;
 189     container_size_ = s->size();
 190     AuxPolicy::aux(0, i, s);
 191 }
 192
 193 //erase()
 194 template <class ElementParser, class AuxPolicy>
 195 prefix_ void
 196 senf::detail::ListOptionTypeParser_Policy<ElementParser,AuxPolicy>::container_policy::
 197 erase(container_type & c, data_iterator p)
 198 {
 199     size_type b(senf::bytes(ElementParser(p, c.state())));
 200     realAux_ -= b;
 201     --n_;
 202     container_size_ = c.data().size() - b;
 203 }
 204
 205 //insert()
 206 template <class ElementParser, class AuxPolicy>
 207 prefix_ void
 208 senf::detail::ListOptionTypeParser_Policy<ElementParser,AuxPolicy>::container_policy::
 209 insert(container_type & c, data_iterator p)
 210 {
 211     size_type b(senf::bytes(ElementParser(p, c.state())));
 212     realAux_ += b;
 213     ++n_;
 214     container_size_ = c.data().size();
 215 }
 216
 217 //update()
 218 template <class ElementParser, class AuxPolicy>
 219 prefix_ void
 220 senf::detail::ListOptionTypeParser_Policy<ElementParser,AuxPolicy>::container_policy::
 221 update(container_type const & c)
 222     const
 223 {
 224     if (container_size_ == c.data().size())
 225         return;
 226     data_iterator i(AuxPolicy::adjust(c.i(), c.state()));
 227     data_iterator j(i);
 228     for (size_type n(n_); n; --n, std::advance(j, senf::bytes(ElementParser(j,c.state())))) { ; }
 229     realAux_ = std::distance(i, j);
 230     container_size_ = c.data().size();
 231 }
 232
 233 //setbegin()
 234 template <class ElementParser, class AuxPolicy>
 235 prefix_ typename senf::detail::ListOptionTypeParser_Policy<
 236     ElementParser,AuxPolicy>::container_policy::data_iterator
 237 senf::detail::ListOptionTypeParser_Policy<ElementParser,AuxPolicy>::container_policy::
 238 setBegin(container_type const & c, iterator_data & d)
 239     const
 240 {
 241     return c.i();
 242 }
 243
 244 //setEnd()
 245 template <class ElementParser, class AuxPolicy>
 246 prefix_ typename senf::detail::ListOptionTypeParser_Policy<
 247     ElementParser,AuxPolicy>::container_policy::data_iterator
 248 senf::detail::ListOptionTypeParser_Policy<ElementParser,AuxPolicy>::container_policy::
 249 setEnd(container_type const & c, iterator_data & d)
 250     const
 251 {
 252     return boost::next(c.i(),realAux_);
 253 }
 254
 255 //setFromPosition()
 256 template <class ElementParser, class AuxPolicy>
 257 prefix_ void
 258 senf::detail::ListOptionTypeParser_Policy<ElementParser,AuxPolicy>::container_policy::
 259 setFromPosition(container_type const & c, iterator_data & d, data_iterator p)
 260     const
 261 {}
 262
 263 //next()
 264 template <class ElementParser, class AuxPolicy>
 265 prefix_ typename senf::detail::ListOptionTypeParser_Policy<
 266     ElementParser,AuxPolicy>::container_policy::data_iterator
 267 senf::detail::ListOptionTypeParser_Policy<ElementParser,AuxPolicy>::container_policy::
 268 next(container_type const & c, iterator_data & d)
 269     const
 270 {
 271     return boost::next(container_type::iterator::get(d).i(), senf::bytes(ElementParser(container_type::iterator::get(d).i(), c.state())));
 272 }
 273
 274 //raw()
 275 template <class ElementParser, class AuxPolicy>
 276 prefix_ typename senf::detail::ListOptionTypeParser_Policy<
 277     ElementParser,AuxPolicy>::container_policy::data_iterator
 278 senf::detail::ListOptionTypeParser_Policy<ElementParser,AuxPolicy>::container_policy::
 279 raw(container_type const & c, iterator_data const & d)
 280     const
 281 {
 282     return container_type::iterator::get(d).i();
 283 }
 284
 285 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 286 #undef prefix_
 287
 288 \f
 289 // Local Variables:
 290 // mode: c++
 291 // fill-column: 100
 292 // comment-column: 40
 293 // c-file-style: "senf"
 294 // indent-tabs-mode: nil
 295 // ispell-local-dictionary: "american"
 296 // compile-command: "scons -u test"
 297 // End: