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