senf/Packets/Packet.cti

   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 Packet inline template implementation */
  25
  26 //#include "Packet.ih"
  27
  28 // Custom includes
  29 #include <senf/Utils/Exception.hh>
  30
  31 #define prefix_ inline
  32 //-/////////////////////////////////////////////////////////////////////////////////////////////////
  33
  34 //-/////////////////////////////////////////////////////////////////////////////////////////////////
  35 // senf::Packet
  36
  37 // conversion constructors
  38
  39 template <class PacketType>
  40 prefix_ senf::Packet::Packet(ConcretePacket<PacketType> const & packet)
  41     : packet_(packet.ptr())
  42 {}
  43
  44 // interpreter chain access
  45
  46 template <class OtherPacket>
  47 prefix_ OtherPacket senf::Packet::parseNextAs()
  48     const
  49 {
  50     return OtherPacket(ptr()->parseNextAs<typename OtherPacket::type>());
  51 }
  52
  53 template <class OtherPacket>
  54 prefix_ bool senf::Packet::is()
  55     const
  56 {
  57     return valid() && ptr()->is<typename OtherPacket::type>();
  58 }
  59
  60 template <class OtherPacket>
  61 prefix_ OtherPacket senf::Packet::as()
  62     const
  63 {
  64     if (!is<OtherPacket>())
  65         throw WrapException<std::bad_cast>(std::bad_cast());
  66     return OtherPacket(ptr()->as<typename OtherPacket::type>());
  67 }
  68
  69 template <class OtherPacket>
  70 prefix_ OtherPacket senf::Packet::as(NoThrow_t)
  71     const
  72 {
  73     SENF_ASSERT( is<OtherPacket>(), "Bad cast, called packet::as(nothrow) with wrong PacketType");
  74     return OtherPacket(ptr()->as<typename OtherPacket::type>());
  75 }
  76
  77 template <class OtherPacket>
  78 prefix_ OtherPacket senf::Packet::next()
  79     const
  80 {
  81     return next().as<OtherPacket>();
  82 }
  83
  84 template <class OtherPacket>
  85 prefix_ OtherPacket senf::Packet::next(NoThrow_t)
  86     const
  87 {
  88     Packet p (next(nothrow));
  89     return p && p.is<OtherPacket>() ?
  90             OtherPacket(p.ptr()->as<typename OtherPacket::type>()) : OtherPacket();
  91 }
  92
  93 template <class OtherPacket>
  94 prefix_ OtherPacket senf::Packet::find()
  95     const
  96 {
  97     OtherPacket p (find<OtherPacket>(nothrow));
  98     if (!p) throw InvalidPacketChainException();
  99     return p;
 100 }
 101
 102 template <class OtherPacket>
 103 prefix_ OtherPacket senf::Packet::prev()
 104     const
 105 {
 106     return prev().as<OtherPacket>();
 107 }
 108
 109 template <class OtherPacket>
 110 prefix_ OtherPacket senf::Packet::prev(NoThrow_t)
 111     const
 112 {
 113     Packet p (prev(nothrow));
 114     return p && p.is<OtherPacket>() ?
 115             OtherPacket(p.ptr()->as<typename OtherPacket::type>()) : OtherPacket();
 116 }
 117
 118 template <class OtherPacket>
 119 prefix_ OtherPacket senf::Packet::rfind()
 120     const
 121 {
 122     OtherPacket p (rfind<OtherPacket>(nothrow));
 123     if (!p) throw InvalidPacketChainException();
 124     return p;
 125 }
 126
 127 template <class OtherPacket>
 128 prefix_ OtherPacket senf::Packet::last()
 129     const
 130 {
 131     return last().as<OtherPacket>();
 132 }
 133
 134 template <class OtherPacket>
 135 prefix_ OtherPacket senf::Packet::first()
 136     const
 137 {
 138     return first().as<OtherPacket>();
 139 }
 140
 141 template <class Other>
 142 prefix_ void senf::Packet::finalizeTo()
 143 {
 144     Packet p (find<Other>(nothrow));
 145     ptr()->finalizeTo(p ? p.ptr() : last().ptr());
 146 }
 147
 148 template <class Annotation>
 149 prefix_ Annotation & senf::Packet::annotation()
 150 {
 151     return ptr()->annotation<Annotation>();
 152 }
 153
 154 template <class Annotation>
 155 prefix_ Annotation const & senf::Packet::annotation()
 156     const
 157 {
 158     return ptr()->annotation<Annotation>();
 159 }
 160
 161 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 162 // senf::ConcretePacket<PacketType>
 163
 164 // structors and default members
 165
 166 template <class PacketType>
 167 prefix_ senf::ConcretePacket<PacketType>::ConcretePacket()
 168 {}
 169
 170 template <class PacketType>
 171 prefix_ typename senf::ConcretePacket<PacketType>::factory_t
 172 senf::ConcretePacket<PacketType>::factory()
 173 {
 174     return interpreter::factory();
 175 }
 176
 177 // Create completely new packet
 178
 179 template <class PacketType>
 180 prefix_ senf::ConcretePacket<PacketType>
 181 senf::ConcretePacket<PacketType>::create()
 182 {
 183     return ConcretePacket(interpreter::create());
 184 }
 185
 186 template <class PacketType>
 187 prefix_ senf::ConcretePacket<PacketType>
 188 senf::ConcretePacket<PacketType>::create(senf::NoInit_t)
 189 {
 190     return ConcretePacket(interpreter::create(senf::noinit));
 191 }
 192
 193 template <class PacketType>
 194 prefix_ senf::ConcretePacket<PacketType>
 195 senf::ConcretePacket<PacketType>::create(size_type size)
 196 {
 197     return ConcretePacket(interpreter::create(size));
 198 }
 199
 200 template <class PacketType>
 201 prefix_ senf::ConcretePacket<PacketType>
 202 senf::ConcretePacket<PacketType>::create(size_type size, senf::NoInit_t)
 203 {
 204     return ConcretePacket(interpreter::create(size,senf::noinit));
 205 }
 206
 207 #ifndef DOXYGEN
 208
 209 template <class PacketType>
 210 template <class ForwardReadableRange>
 211 prefix_ senf::ConcretePacket<PacketType> senf::ConcretePacket<PacketType>::
 212 create(ForwardReadableRange const & range,
 213        typename boost::disable_if< boost::is_integral<ForwardReadableRange> >::type *)
 214 {
 215     return ConcretePacket(interpreter::create(range));
 216 }
 217
 218 #endif
 219
 220 // Create packet as new packet after a given packet
 221
 222 template <class PacketType>
 223 prefix_ senf::ConcretePacket<PacketType>
 224 senf::ConcretePacket<PacketType>::createAfter(Packet const & packet)
 225 {
 226     return ConcretePacket(interpreter::createAfter(packet.ptr()));
 227 }
 228
 229 template <class PacketType>
 230 prefix_ senf::ConcretePacket<PacketType>
 231 senf::ConcretePacket<PacketType>::createAfter(Packet const & packet, senf::NoInit_t)
 232 {
 233     return ConcretePacket(interpreter::createAfter(packet.ptr(),senf::noinit));
 234 }
 235
 236 template <class PacketType>
 237 prefix_ senf::ConcretePacket<PacketType>
 238 senf::ConcretePacket<PacketType>::createAfter(Packet const & packet, size_type size)
 239 {
 240     return ConcretePacket(interpreter::createAfter(packet.ptr(), size));
 241 }
 242
 243 template <class PacketType>
 244 prefix_ senf::ConcretePacket<PacketType>
 245 senf::ConcretePacket<PacketType>::createAfter(Packet const & packet, size_type size,
 246                                               senf::NoInit_t)
 247 {
 248     return ConcretePacket(interpreter::createAfter(packet.ptr(), size, senf::noinit));
 249 }
 250
 251 #ifndef DOXYGEN
 252
 253 template <class PacketType>
 254 template <class ForwardReadableRange>
 255 prefix_ senf::ConcretePacket<PacketType> senf::ConcretePacket<PacketType>::
 256 createAfter(Packet const & packet, ForwardReadableRange const & range,
 257             typename boost::disable_if< boost::is_integral<ForwardReadableRange> >::type *)
 258 {
 259     return ConcretePacket(interpreter::createAfter(packet.ptr(), range));
 260 }
 261
 262 #endif
 263
 264 // Create packet as new packet (header) before a given packet
 265
 266 template <class PacketType>
 267 prefix_ senf::ConcretePacket<PacketType>
 268 senf::ConcretePacket<PacketType>::createBefore(Packet const & packet)
 269 {
 270     return ConcretePacket(interpreter::createBefore(packet.ptr()));
 271 }
 272
 273 template <class PacketType>
 274 prefix_ senf::ConcretePacket<PacketType>
 275 senf::ConcretePacket<PacketType>::createBefore(Packet const & packet, senf::NoInit_t)
 276 {
 277     return ConcretePacket(interpreter::createBefore(packet.ptr(), senf::noinit));
 278 }
 279
 280 template <class PacketType>
 281 prefix_ senf::ConcretePacket<PacketType>
 282 senf::ConcretePacket<PacketType>::createInsertBefore(Packet const & packet)
 283 {
 284     return ConcretePacket(interpreter::createInsertBefore(packet.ptr()));
 285 }
 286
 287 template <class PacketType>
 288 prefix_ senf::ConcretePacket<PacketType>
 289 senf::ConcretePacket<PacketType>::createInsertBefore(Packet const & packet, senf::NoInit_t)
 290 {
 291     return ConcretePacket(interpreter::createInsertBefore(packet.ptr(), senf::noinit));
 292 }
 293
 294 // Create a clone of the current packet
 295
 296 template <class PacketType>
 297 prefix_ senf::ConcretePacket<PacketType>
 298 senf::ConcretePacket<PacketType>::clone()
 299     const
 300 {
 301     return ConcretePacket(ptr()->clone());
 302 }
 303
 304 // Field access
 305
 306 template <class PacketType>
 307 prefix_ typename senf::ConcretePacket<PacketType>::Parser
 308 senf::ConcretePacket<PacketType>::parser()
 309     const
 310 {
 311     return ptr()->fields();
 312 }
 313
 314 template <class PacketType>
 315 prefix_ typename senf::ConcretePacket<PacketType>::ParserProxy
 316 senf::ConcretePacket<PacketType>::operator->()
 317     const
 318 {
 319     return ParserProxy(parser());
 320 }
 321
 322 // private members
 323
 324 template <class PacketType>
 325 prefix_ senf::ConcretePacket<PacketType>::ConcretePacket(typename interpreter::ptr const & packet_)
 326     : Packet(packet_)
 327 {}
 328
 329 template <class PacketType>
 330 prefix_ typename senf::ConcretePacket<PacketType>::interpreter * senf::ConcretePacket<PacketType>::ptr()
 331     const
 332 {
 333     return static_cast< PacketInterpreter<PacketType> *>( Packet::ptr().get());
 334 }
 335
 336 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 337 #undef prefix_
 338
 339 \f
 340 // Local Variables:
 341 // mode: c++
 342 // fill-column: 100
 343 // c-file-style: "senf"
 344 // indent-tabs-mode: nil
 345 // ispell-local-dictionary: "american"
 346 // compile-command: "scons -u test"
 347 // comment-column: 40
 348 // End: