senf/Packets/PacketInterpreter.ct

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