Packets/PacketInterpreter.ct

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