Packets/Packet.cti

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