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(senf::NoInit_t)
 158 {
 159     return ConcretePacket(interpreter::create(senf::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, senf::NoInit_t)
 172 {
 173     return ConcretePacket(interpreter::create(size,senf::noinit));
 174 }
 175
 176 template <class PacketType>
 177 template <class ForwardReadableRange>
 178 prefix_ senf::ConcretePacket<PacketType> senf::ConcretePacket<PacketType>::
 179 create(ForwardReadableRange const & range,
 180        typename boost::disable_if< boost::is_integral<ForwardReadableRange> >::type *)
 181 {
 182     return ConcretePacket(interpreter::create(range));
 183 }
 184
 185 // Create packet as new packet after a given packet
 186
 187 template <class PacketType>
 188 prefix_ senf::ConcretePacket<PacketType>
 189 senf::ConcretePacket<PacketType>::createAfter(Packet packet)
 190 {
 191     return ConcretePacket(interpreter::createAfter(packet.ptr()));
 192 }
 193
 194 template <class PacketType>
 195 prefix_ senf::ConcretePacket<PacketType>
 196 senf::ConcretePacket<PacketType>::createAfter(Packet packet, senf::NoInit_t)
 197 {
 198     return ConcretePacket(interpreter::createAfter(packet.ptr(),senf::noinit));
 199 }
 200
 201 template <class PacketType>
 202 prefix_ senf::ConcretePacket<PacketType>
 203 senf::ConcretePacket<PacketType>::createAfter(Packet packet, size_type size)
 204 {
 205     return ConcretePacket(interpreter::createAfter(packet.ptr(), size));
 206 }
 207
 208 template <class PacketType>
 209 prefix_ senf::ConcretePacket<PacketType>
 210 senf::ConcretePacket<PacketType>::createAfter(Packet packet, size_type size, senf::NoInit_t)
 211 {
 212     return ConcretePacket(interpreter::createAfter(packet.ptr(), size, senf::noinit));
 213 }
 214
 215 template <class PacketType>
 216 template <class ForwardReadableRange>
 217 prefix_ senf::ConcretePacket<PacketType> senf::ConcretePacket<PacketType>::
 218 createAfter(Packet packet, ForwardReadableRange const & range,
 219             typename boost::disable_if< boost::is_integral<ForwardReadableRange> >::type *)
 220 {
 221     return ConcretePacket(interpreter::createAfter(packet.ptr(), range));
 222 }
 223
 224 // Create packet as new packet (header) before a given packet
 225
 226 template <class PacketType>
 227 prefix_ senf::ConcretePacket<PacketType>
 228 senf::ConcretePacket<PacketType>::createBefore(Packet packet)
 229 {
 230     return ConcretePacket(interpreter::createBefore(packet.ptr()));
 231 }
 232
 233 template <class PacketType>
 234 prefix_ senf::ConcretePacket<PacketType>
 235 senf::ConcretePacket<PacketType>::createBefore(Packet packet, senf::NoInit_t)
 236 {
 237     return ConcretePacket(interpreter::createBefore(packet.ptr(), senf::noinit));
 238 }
 239
 240 // Create a clone of the current packet
 241
 242 template <class PacketType>
 243 prefix_ senf::ConcretePacket<PacketType>
 244 senf::ConcretePacket<PacketType>::clone()
 245     const
 246 {
 247     return ConcretePacket(ptr()->clone());
 248 }
 249
 250 // Field access
 251
 252 template <class PacketType>
 253 prefix_ typename senf::ConcretePacket<PacketType>::Parser *
 254 senf::ConcretePacket<PacketType>::operator->()
 255     const
 256 {
 257     return ptr()->fields_p();
 258 }
 259
 260 template <class PacketType>
 261 prefix_ typename senf::ConcretePacket<PacketType>::Parser
 262 senf::ConcretePacket<PacketType>::parser()
 263     const
 264 {
 265     return ptr()->fields();
 266 }
 267
 268 // private members
 269
 270 template <class PacketType>
 271 prefix_ senf::ConcretePacket<PacketType>::ConcretePacket(typename interpreter::ptr packet_)
 272     : Packet(packet_)
 273 {}
 274
 275 template <class PacketType>
 276 prefix_ typename senf::ConcretePacket<PacketType>::interpreter::ptr
 277 senf::ConcretePacket<PacketType>::ptr()
 278     const
 279 {
 280     return boost::static_pointer_cast< PacketInterpreter<PacketType> >(Packet::ptr());
 281 }
 282
 283 ///////////////////////////////cti.e///////////////////////////////////////
 284 #undef prefix_
 285
 286 \f
 287 // Local Variables:
 288 // mode: c++
 289 // fill-column: 100
 290 // c-file-style: "senf"
 291 // indent-tabs-mode: nil
 292 // ispell-local-dictionary: "american"
 293 // compile-command: "scons -u test"
 294 // comment-column: 40
 295 // End: