Packets/Packet.cti

   1 // Copyright (C) 2007
   2 // Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
   3 // Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
   4 //     Stefan Bund <g0dil@berlios.de>
   5 //
   6 // This program is free software; you can redistribute it and/or modify
   7 // it under the terms of the GNU General Public License as published by
   8 // the Free Software Foundation; either version 2 of the License, or
   9 // (at your option) any later version.
  10 //
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the
  18 // Free Software Foundation, Inc.,
  19 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20
  21 /** \file
  22     \brief Packet inline template implementation */
  23
  24 //#include "Packet.ih"
  25
  26 // Custom includes
  27
  28 #define prefix_ inline
  29 ///////////////////////////////cti.p///////////////////////////////////////
  30
  31 ///////////////////////////////////////////////////////////////////////////
  32 // senf::Packet
  33
  34 // conversion constructors
  35
  36 template <class PacketType>
  37 prefix_ senf::Packet::Packet(ConcretePacket<PacketType> packet)
  38     : packet_(packet.ptr())
  39 {}
  40
  41 // interpreter chain access
  42
  43 template <class OtherPacket>
  44 prefix_ OtherPacket senf::Packet::parseNextAs()
  45     const
  46 {
  47     return OtherPacket(ptr()->parseNextAs<typename OtherPacket::type>());
  48 }
  49
  50 template <class OtherPacket>
  51 prefix_ bool senf::Packet::is()
  52     const
  53 {
  54     return ptr()->is<typename OtherPacket::type>();
  55 }
  56
  57 template <class OtherPacket>
  58 prefix_ OtherPacket senf::Packet::as()
  59     const
  60 {
  61     return OtherPacket(ptr()->as<typename OtherPacket::type>());
  62 }
  63
  64 template <class OtherPacket>
  65 prefix_ OtherPacket senf::Packet::next()
  66     const
  67 {
  68     OtherPacket p (next<OtherPacket>(nothrow));
  69     if (!p) throw InvalidPacketChainException();
  70     return p;
  71 }
  72
  73
  74 template <class OtherPacket>
  75 prefix_ OtherPacket senf::Packet::next(NoThrow_t)
  76     const
  77 {
  78     Packet p (next());
  79     return p ? p.findNext<OtherPacket>(nothrow) : OtherPacket();
  80 }
  81
  82 template <class OtherPacket>
  83 prefix_ OtherPacket senf::Packet::prev()
  84     const
  85 {
  86     OtherPacket p (prev<OtherPacket>(nothrow));
  87     if (!p) throw InvalidPacketChainException();
  88     return p;
  89 }
  90
  91 template <class OtherPacket>
  92 prefix_ OtherPacket senf::Packet::prev(NoThrow_t)
  93     const
  94 {
  95     Packet p (prev());
  96     return p ? p.findPrev<OtherPacket>(nothrow) : OtherPacket();
  97 }
  98
  99 template <class OtherPacket>
 100 prefix_ OtherPacket senf::Packet::findNext()
 101     const
 102 {
 103     OtherPacket p (findNext<OtherPacket>(nothrow));
 104     if (!p) throw InvalidPacketChainException();
 105     return p;
 106 }
 107
 108 template <class OtherPacket>
 109 prefix_ OtherPacket senf::Packet::findPrev()
 110     const
 111 {
 112     OtherPacket p (findPrev<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().findPrev<OtherPacket>();
 122 }
 123
 124 template <class OtherPacket>
 125 prefix_ OtherPacket senf::Packet::last(NoThrow_t)
 126     const
 127 {
 128     return last().findPrev<OtherPacket>(nothrow);
 129 }
 130
 131 template <class OtherPacket>
 132 prefix_ OtherPacket senf::Packet::first()
 133     const
 134 {
 135     return first().findNext<OtherPacket>();
 136 }
 137
 138 template <class OtherPacket>
 139 prefix_ OtherPacket senf::Packet::first(NoThrow_t)
 140     const
 141 {
 142     return first().findNext<OtherPacket>(nothrow);
 143 }
 144
 145 ///////////////////////////////////////////////////////////////////////////
 146 // senf::ConcretePacket<PacketType>
 147
 148 // structors and default members
 149
 150 template <class PacketType>
 151 prefix_ senf::ConcretePacket<PacketType>::ConcretePacket()
 152 {}
 153
 154 template <class PacketType>
 155 prefix_ typename senf::ConcretePacket<PacketType>::factory_t
 156 senf::ConcretePacket<PacketType>::factory()
 157 {
 158     return interpreter::factory();
 159 }
 160
 161 // Create completely new packet
 162
 163 template <class PacketType>
 164 prefix_ senf::ConcretePacket<PacketType>
 165 senf::ConcretePacket<PacketType>::create()
 166 {
 167     return ConcretePacket(interpreter::create());
 168 }
 169
 170 template <class PacketType>
 171 prefix_ senf::ConcretePacket<PacketType>
 172 senf::ConcretePacket<PacketType>::create(NoInit_t)
 173 {
 174     return ConcretePacket(interpreter::create(interpreter::noinit));
 175 }
 176
 177 template <class PacketType>
 178 prefix_ senf::ConcretePacket<PacketType>
 179 senf::ConcretePacket<PacketType>::create(size_type size)
 180 {
 181     return ConcretePacket(interpreter::create(size));
 182 }
 183
 184 template <class PacketType>
 185 prefix_ senf::ConcretePacket<PacketType>
 186 senf::ConcretePacket<PacketType>::create(size_type size, NoInit_t)
 187 {
 188     return ConcretePacket(interpreter::create(size,interpreter::noinit));
 189 }
 190
 191 template <class PacketType>
 192 template <class ForwardReadableRange>
 193 prefix_ senf::ConcretePacket<PacketType>
 194 senf::ConcretePacket<PacketType>::create(ForwardReadableRange const & range)
 195 {
 196     return ConcretePacket(interpreter::create(range));
 197 }
 198
 199 // Create packet as new packet after a given packet
 200
 201 template <class PacketType>
 202 prefix_ senf::ConcretePacket<PacketType>
 203 senf::ConcretePacket<PacketType>::createAfter(Packet packet)
 204 {
 205     return ConcretePacket(interpreter::createAfter(packet.ptr()));
 206 }
 207
 208 template <class PacketType>
 209 prefix_ senf::ConcretePacket<PacketType>
 210 senf::ConcretePacket<PacketType>::createAfter(Packet packet, NoInit_t)
 211 {
 212     return ConcretePacket(interpreter::createAfter(packet.ptr(),interpreter::noinit));
 213 }
 214
 215 template <class PacketType>
 216 prefix_ senf::ConcretePacket<PacketType>
 217 senf::ConcretePacket<PacketType>::createAfter(Packet packet, size_type size)
 218 {
 219     return ConcretePacket(interpreter::createAfter(packet.ptr(), size));
 220 }
 221
 222 template <class PacketType>
 223 prefix_ senf::ConcretePacket<PacketType>
 224 senf::ConcretePacket<PacketType>::createAfter(Packet packet, size_type size, NoInit_t)
 225 {
 226     return ConcretePacket(interpreter::createAfter(packet.ptr(), size, interpreter::noinit));
 227 }
 228
 229 template <class PacketType>
 230 template <class ForwardReadableRange>
 231 prefix_ senf::ConcretePacket<PacketType>
 232 senf::ConcretePacket<PacketType>::createAfter(Packet packet, ForwardReadableRange const & range)
 233 {
 234     return ConcretePacket(interpreter::createAfter(packet.ptr(), range));
 235 }
 236
 237 // Create packet as new packet (header) before a given packet
 238
 239 template <class PacketType>
 240 prefix_ senf::ConcretePacket<PacketType>
 241 senf::ConcretePacket<PacketType>::createBefore(Packet packet)
 242 {
 243     return ConcretePacket(interpreter::createBefore(packet.ptr()));
 244 }
 245
 246 template <class PacketType>
 247 prefix_ senf::ConcretePacket<PacketType>
 248 senf::ConcretePacket<PacketType>::createBefore(Packet packet, NoInit_t)
 249 {
 250     return ConcretePacket(interpreter::createBefore(packet.ptr(), interpreter::noinit));
 251 }
 252
 253 // Create a clone of the current packet
 254
 255 template <class PacketType>
 256 prefix_ senf::ConcretePacket<PacketType>
 257 senf::ConcretePacket<PacketType>::clone()
 258     const
 259 {
 260     return ConcretePacket(ptr()->clone());
 261 }
 262
 263 // Field access
 264
 265 template <class PacketType>
 266 prefix_ typename senf::ConcretePacket<PacketType>::interpreter::parser *
 267 senf::ConcretePacket<PacketType>::operator->()
 268     const
 269 {
 270     return ptr()->fields_p();
 271 }
 272
 273 // private members
 274
 275 template <class PacketType>
 276 prefix_ senf::ConcretePacket<PacketType>::ConcretePacket(typename interpreter::ptr packet_)
 277     : Packet(packet_)
 278 {}
 279
 280 template <class PacketType>
 281 prefix_ typename senf::ConcretePacket<PacketType>::interpreter::ptr
 282 senf::ConcretePacket<PacketType>::ptr()
 283     const
 284 {
 285     return boost::static_pointer_cast< PacketInterpreter<PacketType> >(Packet::ptr());
 286 }
 287
 288 ///////////////////////////////cti.e///////////////////////////////////////
 289 #undef prefix_
 290
 291 \f
 292 // Local Variables:
 293 // mode: c++
 294 // fill-column: 100
 295 // c-file-style: "senf"
 296 // indent-tabs-mode: nil
 297 // ispell-local-dictionary: "american"
 298 // compile-command: "scons -u test"
 299 // End: