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