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::prev()
  77     const
  78 {
  79     return prev().as<OtherPacket>();
  80 }
  81
  82 template <class OtherPacket>
  83 prefix_ OtherPacket senf::Packet::last()
  84     const
  85 {
  86     return last().as<OtherPacket>();
  87 }
  88
  89 template <class OtherPacket>
  90 prefix_ OtherPacket senf::Packet::first()
  91     const
  92 {
  93     return first().as<OtherPacket>();
  94 }
  95
  96 ///////////////////////////////////////////////////////////////////////////
  97 // senf::ConcretePacket<PacketType>
  98
  99 // structors and default members
 100
 101 template <class PacketType>
 102 prefix_ senf::ConcretePacket<PacketType>::ConcretePacket()
 103 {}
 104
 105 template <class PacketType>
 106 prefix_ typename senf::ConcretePacket<PacketType>::factory_t
 107 senf::ConcretePacket<PacketType>::factory()
 108 {
 109     return interpreter::factory();
 110 }
 111
 112 // Create completely new packet
 113
 114 template <class PacketType>
 115 prefix_ senf::ConcretePacket<PacketType>
 116 senf::ConcretePacket<PacketType>::create()
 117 {
 118     return ConcretePacket(interpreter::create());
 119 }
 120
 121 template <class PacketType>
 122 prefix_ senf::ConcretePacket<PacketType>
 123 senf::ConcretePacket<PacketType>::create(NoInit_t)
 124 {
 125     return ConcretePacket(interpreter::create(interpreter::noinit));
 126 }
 127
 128 template <class PacketType>
 129 prefix_ senf::ConcretePacket<PacketType>
 130 senf::ConcretePacket<PacketType>::create(size_type size)
 131 {
 132     return ConcretePacket(interpreter::create(size));
 133 }
 134
 135 template <class PacketType>
 136 prefix_ senf::ConcretePacket<PacketType>
 137 senf::ConcretePacket<PacketType>::create(size_type size, NoInit_t)
 138 {
 139     return ConcretePacket(interpreter::create(size,interpreter::noinit));
 140 }
 141
 142 template <class PacketType>
 143 template <class ForwardReadableRange>
 144 prefix_ senf::ConcretePacket<PacketType>
 145 senf::ConcretePacket<PacketType>::create(ForwardReadableRange const & range)
 146 {
 147     return ConcretePacket(interpreter::create(range));
 148 }
 149
 150 // Create packet as new packet after a given packet
 151
 152 template <class PacketType>
 153 prefix_ senf::ConcretePacket<PacketType>
 154 senf::ConcretePacket<PacketType>::createAfter(Packet packet)
 155 {
 156     return ConcretePacket(interpreter::createAfter(packet.ptr()));
 157 }
 158
 159 template <class PacketType>
 160 prefix_ senf::ConcretePacket<PacketType>
 161 senf::ConcretePacket<PacketType>::createAfter(Packet packet, NoInit_t)
 162 {
 163     return ConcretePacket(interpreter::createAfter(packet.ptr(),interpreter::noinit));
 164 }
 165
 166 template <class PacketType>
 167 prefix_ senf::ConcretePacket<PacketType>
 168 senf::ConcretePacket<PacketType>::createAfter(Packet packet, size_type size)
 169 {
 170     return ConcretePacket(interpreter::createAfter(packet.ptr(), size));
 171 }
 172
 173 template <class PacketType>
 174 prefix_ senf::ConcretePacket<PacketType>
 175 senf::ConcretePacket<PacketType>::createAfter(Packet packet, size_type size, NoInit_t)
 176 {
 177     return ConcretePacket(interpreter::createAfter(packet.ptr(), size, interpreter::noinit));
 178 }
 179
 180 template <class PacketType>
 181 template <class ForwardReadableRange>
 182 prefix_ senf::ConcretePacket<PacketType>
 183 senf::ConcretePacket<PacketType>::createAfter(Packet packet, ForwardReadableRange const & range)
 184 {
 185     return ConcretePacket(interpreter::createAfter(packet.ptr(), range));
 186 }
 187
 188 // Create packet as new packet (header) before a given packet
 189
 190 template <class PacketType>
 191 prefix_ senf::ConcretePacket<PacketType>
 192 senf::ConcretePacket<PacketType>::createBefore(Packet packet)
 193 {
 194     return ConcretePacket(interpreter::createBefore(packet.ptr()));
 195 }
 196
 197 template <class PacketType>
 198 prefix_ senf::ConcretePacket<PacketType>
 199 senf::ConcretePacket<PacketType>::createBefore(Packet packet, NoInit_t)
 200 {
 201     return ConcretePacket(interpreter::createBefore(packet.ptr(), interpreter::noinit));
 202 }
 203
 204 // Create a clone of the current packet
 205
 206 template <class PacketType>
 207 prefix_ senf::ConcretePacket<PacketType>
 208 senf::ConcretePacket<PacketType>::clone()
 209     const
 210 {
 211     return ConcretePacket(ptr()->clone());
 212 }
 213
 214 // Field access
 215
 216 template <class PacketType>
 217 prefix_ typename senf::ConcretePacket<PacketType>::type::parser *
 218 senf::ConcretePacket<PacketType>::operator->()
 219     const
 220 {
 221     return ptr()->fields_p();
 222 }
 223
 224 // private members
 225
 226 template <class PacketType>
 227 prefix_ senf::ConcretePacket<PacketType>::ConcretePacket(typename interpreter::ptr packet_)
 228     : Packet(packet_)
 229 {}
 230
 231 template <class PacketType>
 232 prefix_ typename senf::ConcretePacket<PacketType>::interpreter::ptr
 233 senf::ConcretePacket<PacketType>::ptr()
 234     const
 235 {
 236     return boost::static_pointer_cast< PacketInterpreter<PacketType> >(Packet::ptr());
 237 }
 238
 239 ///////////////////////////////cti.e///////////////////////////////////////
 240 #undef prefix_
 241
 242 \f
 243 // Local Variables:
 244 // mode: c++
 245 // fill-column: 100
 246 // c-file-style: "senf"
 247 // indent-tabs-mode: nil
 248 // ispell-local-dictionary: "american"
 249 // compile-command: "scons -u test"
 250 // comment-column: 40
 251 // End: