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