senf/Packets/PacketInterpreter.ct

   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 PacketInterpreter non-inline template implementation  */
  25
  26 //#include "PacketInterpreter.ih"
  27
  28 // Custom includes
  29 #include "Packet.hh"
  30
  31 #define prefix_
  32 //-/////////////////////////////////////////////////////////////////////////////////////////////////
  33
  34 //-/////////////////////////////////////////////////////////////////////////////////////////////////
  35 // senf::PacketInterpreterBase
  36
  37 // Interpreter chain access
  38
  39 template <class Type>
  40 prefix_ typename senf::PacketInterpreter<Type>::ptr
  41 senf::PacketInterpreterBase::parseNextAs()
  42 {
  43     optional_range r (nextPacketRange());
  44     if (!r)
  45         throw InvalidPacketChainException();
  46
  47     if (next())
  48         impl().truncateInterpreters(next().get());
  49
  50     typename PacketInterpreter<Type>::ptr pi
  51         (PacketInterpreter<Type>::create(&impl(),r->begin(),r->end(),Append));
  52     return pi;
  53 }
  54
  55 //-/////////////////////////////////////////////////////////////////////////////////////////////////
  56 // senf::PacketInterpreter<PacketType>
  57
  58 // Create completely new packet
  59
  60 template <class PacketType>
  61 prefix_ typename senf::PacketInterpreter<PacketType>::ptr
  62 senf::PacketInterpreter<PacketType>::create(size_type size)
  63 {
  64     if (size < initSize())
  65         throw TruncatedPacketException();
  66     ptr pi (create(size,senf::noinit));
  67     pi->init();
  68     return pi;
  69 }
  70
  71 template <class PacketType>
  72 prefix_ typename senf::PacketInterpreter<PacketType>::ptr
  73 senf::PacketInterpreter<PacketType>::create(size_type size, senf::NoInit_t)
  74 {
  75     detail::PacketImpl::Guard p (new detail::PacketImpl(size,0));
  76     ptr pi (create(p.p,p.p->begin(),p.p->end(),Append));
  77     return pi;
  78 }
  79
  80 // Create packet as new packet after a given packet
  81
  82 template <class PacketType>
  83 prefix_ typename senf::PacketInterpreter<PacketType>::ptr
  84 senf::PacketInterpreter<PacketType>::createAfter(PacketInterpreterBase::ptr packet,
  85                                                  size_type size)
  86 {
  87     if (size < initSize())
  88         throw TruncatedPacketException();
  89     ptr pi (createAfter(packet,size,senf::noinit));
  90     std::fill(pi->data().begin(), pi->data().end(),0);
  91     pi->init();
  92     return pi;
  93 }
  94
  95 template <class PacketType>
  96 prefix_ typename senf::PacketInterpreter<PacketType>::ptr
  97 senf::PacketInterpreter<PacketType>::createAfter(PacketInterpreterBase::ptr packet,
  98                                                  size_type size, senf::NoInit_t)
  99 {
 100     optional_range r (packet->nextPacketRange());
 101     if (!r)
 102         throw InvalidPacketChainException();
 103
 104     if (packet->next())
 105         packet->impl().truncateInterpreters(packet->next().get());
 106
 107     ptr pi (create(&packet->impl(),r->begin(),r->end(),Append));
 108     pi->data().resize(size);
 109     return pi;
 110 }
 111
 112 template <class PacketType>
 113 template <class ForwardReadableRange>
 114 prefix_ typename senf::PacketInterpreter<PacketType>::ptr
 115 senf::PacketInterpreter<PacketType>::createAfter(PacketInterpreterBase::ptr packet,
 116                                                  ForwardReadableRange const & range)
 117 {
 118     optional_range r (packet->nextPacketRange());
 119     if (!r)
 120         throw InvalidPacketChainException();
 121
 122     if (packet->next())
 123         packet->impl().truncateInterpreters(packet->next().get());
 124
 125     ptr pi (create(&packet->impl(),r->begin(),r->end(),Append));
 126     pi->data().resize(boost::size(range));
 127     std::copy(boost::begin(range), boost::end(range), pi->data().begin());
 128     return pi;
 129 }
 130
 131 // Create packet as new packet (header) before a given packet
 132
 133 template <class PacketType>
 134 prefix_ typename senf::PacketInterpreter<PacketType>::ptr
 135 senf::PacketInterpreter<PacketType>::createBefore(PacketInterpreterBase::ptr packet)
 136 {
 137     ptr pi (createBefore(packet, senf::noinit));
 138     pi->data().insert(pi->data().begin(),initHeadSize(),byte(0x00u));
 139     pi->data().insert(pi->data().end(),initSize()-initHeadSize(),byte(0x00u));
 140     pi->init();
 141     return pi;
 142 }
 143
 144 template <class PacketType>
 145 prefix_ typename senf::PacketInterpreter<PacketType>::ptr
 146 senf::PacketInterpreter<PacketType>::createBefore(PacketInterpreterBase::ptr packet, senf::NoInit_t)
 147 {
 148     if (packet->prev())
 149         packet->impl().truncateInterpretersBackwards(packet->prev().get());
 150
 151     return create(&packet->impl(),packet->data().begin(),packet->data().end(),Prepend);
 152 }
 153
 154 template <class PacketType>
 155 prefix_ typename senf::PacketInterpreter<PacketType>::ptr
 156 senf::PacketInterpreter<PacketType>::createInsertBefore(PacketInterpreterBase::ptr packet)
 157 {
 158     ptr pi (createInsertBefore(packet, senf::noinit));
 159     pi->data().insert(pi->data().begin(),initHeadSize(),byte(0x00u));
 160     pi->data().insert(pi->data().end(),initSize()-initHeadSize(),byte(0x00u));
 161     pi->init();
 162     return pi;
 163 }
 164
 165 template <class PacketType>
 166 prefix_ typename senf::PacketInterpreter<PacketType>::ptr
 167 senf::PacketInterpreter<PacketType>::createInsertBefore(PacketInterpreterBase::ptr packet,
 168                                                         senf::NoInit_t)
 169 {
 170     return create(&packet->impl(),packet->data().begin(),packet->data().end(),packet);
 171 }
 172
 173 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 174 // private members
 175
 176 // virtual interface
 177
 178 template <class PacketType>
 179 prefix_ typename senf::PacketInterpreter<PacketType>::optional_range
 180 senf::PacketInterpreter<PacketType>::v_nextPacketRange()
 181 {
 182     return type::nextPacketRange(ConcretePacket<PacketType>(ptr(this)));
 183 }
 184
 185 template <class PacketType>
 186 prefix_ senf::PacketInterpreterBase::ptr
 187 senf::PacketInterpreter<PacketType>::v_appendClone(detail::PacketImpl * impl, iterator base,
 188                                                    iterator new_base)
 189 {
 190     return create(impl,
 191                   boost::next(new_base,std::distance(base,begin())),
 192                   boost::next(new_base,std::distance(base,end())),
 193                   Append);
 194 }
 195
 196 template <class PacketType>
 197 prefix_ senf::PacketInterpreterBase::ptr
 198 senf::PacketInterpreter<PacketType>::v_appendClone(detail::PacketImpl * impl, range r)
 199 {
 200     return create(impl, r.begin(), r.end(), Append);
 201 }
 202
 203 template <class PacketType>
 204 prefix_ void senf::PacketInterpreter<PacketType>::v_finalize()
 205 {
 206     type::finalize(ConcretePacket<PacketType>(ptr(this)));
 207 }
 208
 209 template <class PacketType>
 210 prefix_ void senf::PacketInterpreter<PacketType>::v_dump(std::ostream & os)
 211 {
 212     type::dump(ConcretePacket<PacketType>(ptr(this)),os);
 213 }
 214
 215 template <class PacketType>
 216 prefix_ senf::TypeIdValue senf::PacketInterpreter<PacketType>::v_type()
 217 {
 218     return typeIdValue< ConcretePacket<PacketType> >();
 219 }
 220
 221 template <class PacketType>
 222 prefix_ typename senf::PacketInterpreter<PacketType>::factory_t
 223 senf::PacketInterpreter<PacketType>::v_factory()
 224 {
 225     return factory();
 226 }
 227
 228 template <class PacketType>
 229 prefix_ typename senf::PacketInterpreter<PacketType>::factory_t
 230 senf::PacketInterpreter<PacketType>::v_nextPacketType()
 231 {
 232     return type::nextPacketType(ConcretePacket<PacketType>(ptr(this)));
 233 }
 234
 235
 236 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 237 // senf::PacketInterpreterBase::Factory
 238
 239 template <class ForwardReadableRange>
 240 prefix_ senf::PacketInterpreterBase::ptr
 241 senf::PacketInterpreterBase::Factory::create(ForwardReadableRange const & range)
 242     const
 243 {
 244     ptr pi (create(boost::size(range),senf::noinit));
 245     std::copy(boost::begin(range), boost::end(range), pi->data().begin());
 246     return pi;
 247 }
 248
 249 template <class ForwardReadableRange>
 250 prefix_ senf::PacketInterpreterBase::ptr
 251 senf::PacketInterpreterBase::Factory::createAfter(PacketInterpreterBase::ptr packet,
 252                                                   ForwardReadableRange const & range)
 253     const
 254 {
 255     ptr pi (createAfter(packet,boost::size(range),senf::noinit));
 256     std::copy(boost::begin(range), boost::end(range), pi->data().begin());
 257     return pi;
 258 }
 259
 260 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 261 // senf::PacketInterpreter<PacketType>::FactoryImpl
 262
 263 // Create completely new packet
 264
 265 template <class PacketType>
 266 prefix_ typename senf::PacketInterpreterBase::ptr
 267 senf::PacketInterpreter<PacketType>::FactoryImpl::create()
 268     const
 269 {
 270     return senf::PacketInterpreter<PacketType>::create();
 271 }
 272
 273 template <class PacketType>
 274 prefix_ typename senf::PacketInterpreterBase::ptr
 275 senf::PacketInterpreter<PacketType>::FactoryImpl::create(senf::NoInit_t)
 276     const
 277 {
 278     return senf::PacketInterpreter<PacketType>::create(senf::noinit);
 279 }
 280
 281 template <class PacketType>
 282 prefix_ typename senf::PacketInterpreterBase::ptr
 283 senf::PacketInterpreter<PacketType>::FactoryImpl::create(size_type size)
 284     const
 285 {
 286     return senf::PacketInterpreter<PacketType>::create(size);
 287 }
 288
 289 template <class PacketType>
 290 prefix_ typename senf::PacketInterpreterBase::ptr
 291 senf::PacketInterpreter<PacketType>::FactoryImpl::create(size_type size, senf::NoInit_t)
 292     const
 293 {
 294     return senf::PacketInterpreter<PacketType>::create(size, senf::noinit);
 295 }
 296
 297 // Create packet as new packet after a given packet
 298
 299 template <class PacketType>
 300 prefix_ typename senf::PacketInterpreterBase::ptr
 301 senf::PacketInterpreter<PacketType>::FactoryImpl::createAfter(PacketInterpreterBase::ptr packet)
 302     const
 303 {
 304     return senf::PacketInterpreter<PacketType>::createAfter(packet);
 305 }
 306
 307 template <class PacketType>
 308 prefix_ typename senf::PacketInterpreterBase::ptr
 309 senf::PacketInterpreter<PacketType>::FactoryImpl::createAfter(PacketInterpreterBase::ptr packet,
 310                                                               senf::NoInit_t)
 311     const
 312 {
 313     return senf::PacketInterpreter<PacketType>::createAfter(packet,senf::noinit);
 314 }
 315
 316 template <class PacketType>
 317 prefix_ typename senf::PacketInterpreterBase::ptr
 318 senf::PacketInterpreter<PacketType>::FactoryImpl::createAfter(PacketInterpreterBase::ptr packet,
 319                                                               size_type size)
 320     const
 321 {
 322     return senf::PacketInterpreter<PacketType>::createAfter(packet,size);
 323 }
 324
 325 template <class PacketType>
 326 prefix_ typename senf::PacketInterpreterBase::ptr
 327 senf::PacketInterpreter<PacketType>::FactoryImpl::createAfter(PacketInterpreterBase::ptr packet,
 328                                                               size_type size, senf::NoInit_t)
 329     const
 330 {
 331     return senf::PacketInterpreter<PacketType>::createAfter(packet,size,senf::noinit);
 332 }
 333
 334 // Create packet as new packet (header) before a given packet
 335
 336 template <class PacketType>
 337 prefix_ typename senf::PacketInterpreterBase::ptr
 338 senf::PacketInterpreter<PacketType>::FactoryImpl::
 339 createBefore(PacketInterpreterBase::ptr packet)
 340     const
 341 {
 342     return senf::PacketInterpreter<PacketType>::createBefore(packet);
 343 }
 344
 345 template <class PacketType>
 346 prefix_ senf::PacketInterpreterBase::ptr
 347 senf::PacketInterpreter<PacketType>::FactoryImpl::
 348 createBefore(PacketInterpreterBase::ptr packet, senf::NoInit_t)
 349     const
 350 {
 351     return senf::PacketInterpreter<PacketType>::createBefore(packet,senf::noinit);
 352 }
 353
 354 template <class PacketType>
 355 prefix_ senf::PacketInterpreterBase::ptr
 356 senf::PacketInterpreter<PacketType>::FactoryImpl::
 357 createInsertBefore(PacketInterpreterBase::ptr packet)
 358     const
 359 {
 360     return senf::PacketInterpreter<PacketType>::createInsertBefore(packet);
 361 }
 362
 363 template <class PacketType>
 364 prefix_ senf::PacketInterpreterBase::ptr
 365 senf::PacketInterpreter<PacketType>::FactoryImpl::
 366 createInsertBefore(PacketInterpreterBase::ptr packet, senf::NoInit_t)
 367     const
 368 {
 369     return senf::PacketInterpreter<PacketType>::createInsertBefore(packet,senf::noinit);
 370 }
 371
 372 // Parse next packet in chain
 373
 374 template <class PacketType>
 375 prefix_ typename senf::PacketInterpreterBase::ptr
 376 senf::PacketInterpreter<PacketType>::FactoryImpl::parseNext(PacketInterpreterBase::ptr packet)
 377     const
 378 {
 379     optional_range r (packet->nextPacketRange());
 380     if (!r)
 381         throw InvalidPacketChainException();
 382
 383     if (packet->next())
 384         packet->impl().truncateInterpreters(packet->next().get());
 385
 386     return senf::PacketInterpreter<PacketType>::create(&packet->impl(),r->begin(),r->end(),Append);
 387 }
 388
 389 template <class PacketType>
 390 const typename senf::PacketInterpreter<PacketType>::FactoryImpl
 391     senf::PacketInterpreter<PacketType>::factory_;
 392
 393 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 394 #undef prefix_
 395
 396 \f
 397 // Local Variables:
 398 // mode: c++
 399 // fill-column: 100
 400 // c-file-style: "senf"
 401 // indent-tabs-mode: nil
 402 // ispell-local-dictionary: "american"
 403 // compile-command: "scons -u test"
 404 // comment-column: 40
 405 // End: