senf/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 #include <senf/Utils/Exception.hh>
  30
  31 #define prefix_ inline
  32 ///////////////////////////////cti.p///////////////////////////////////////
  33
  34 ///////////////////////////////////////////////////////////////////////////
  35 // senf::Packet
  36
  37 // conversion constructors
  38
  39 template <class PacketType>
  40 prefix_ senf::Packet::Packet(ConcretePacket<PacketType> const & packet)
  41     : packet_(packet.ptr())
  42 {}
  43
  44 // interpreter chain access
  45
  46 template <class OtherPacket>
  47 prefix_ OtherPacket senf::Packet::parseNextAs()
  48     const
  49 {
  50     return OtherPacket(ptr()->parseNextAs<typename OtherPacket::type>());
  51 }
  52
  53 template <class OtherPacket>
  54 prefix_ bool senf::Packet::is()
  55     const
  56 {
  57     return valid() && ptr()->is<typename OtherPacket::type>();
  58 }
  59
  60 template <class OtherPacket>
  61 prefix_ OtherPacket senf::Packet::as()
  62     const
  63 {
  64     if (!is<OtherPacket>())
  65         throw WrapException<std::bad_cast>(std::bad_cast());
  66     return OtherPacket(ptr()->as<typename OtherPacket::type>());
  67 }
  68
  69 template <class OtherPacket>
  70 prefix_ OtherPacket senf::Packet::next()
  71     const
  72 {
  73     return next().as<OtherPacket>();
  74 }
  75
  76 template <class OtherPacket>
  77 prefix_ OtherPacket senf::Packet::next(NoThrow_t)
  78     const
  79 {
  80     Packet p (next(nothrow));
  81     return p && p.is<OtherPacket>() ?
  82             OtherPacket(p.ptr()->as<typename OtherPacket::type>()) : OtherPacket();
  83 }
  84
  85 template <class OtherPacket>
  86 prefix_ OtherPacket senf::Packet::find()
  87     const
  88 {
  89     OtherPacket p (find<OtherPacket>(nothrow));
  90     if (!p) throw InvalidPacketChainException();
  91     return p;
  92 }
  93
  94 template <class OtherPacket>
  95 prefix_ OtherPacket senf::Packet::prev()
  96     const
  97 {
  98     return prev().as<OtherPacket>();
  99 }
 100
 101 template <class OtherPacket>
 102 prefix_ OtherPacket senf::Packet::prev(NoThrow_t)
 103     const
 104 {
 105     Packet p (prev(nothrow));
 106     return p && p.is<OtherPacket>() ? p.as<OtherPacket>() : OtherPacket();
 107 }
 108
 109 template <class OtherPacket>
 110 prefix_ OtherPacket senf::Packet::rfind()
 111     const
 112 {
 113     OtherPacket p (rfind<OtherPacket>(nothrow));
 114     if (!p) throw InvalidPacketChainException();
 115     return p;
 116 }
 117
 118 template <class OtherPacket>
 119 prefix_ OtherPacket senf::Packet::last()
 120     const
 121 {
 122     return last().as<OtherPacket>();
 123 }
 124
 125 template <class OtherPacket>
 126 prefix_ OtherPacket senf::Packet::first()
 127     const
 128 {
 129     return first().as<OtherPacket>();
 130 }
 131
 132 template <class Other>
 133 prefix_ void senf::Packet::finalizeTo()
 134 {
 135     Packet p (find<Other>(nothrow));
 136     ptr()->finalizeTo(p ? p.ptr() : last().ptr());
 137 }
 138
 139 template <class Annotation>
 140 prefix_ Annotation & senf::Packet::annotation()
 141 {
 142     return ptr()->annotation<Annotation>();
 143 }
 144
 145 template <class Annotation>
 146 prefix_ Annotation const & senf::Packet::annotation()
 147     const
 148 {
 149     return ptr()->annotation<Annotation>();
 150 }
 151
 152 ///////////////////////////////////////////////////////////////////////////
 153 // senf::ConcretePacket<PacketType>
 154
 155 // structors and default members
 156
 157 template <class PacketType>
 158 prefix_ senf::ConcretePacket<PacketType>::ConcretePacket()
 159 {}
 160
 161 template <class PacketType>
 162 prefix_ typename senf::ConcretePacket<PacketType>::factory_t
 163 senf::ConcretePacket<PacketType>::factory()
 164 {
 165     return interpreter::factory();
 166 }
 167
 168 // Create completely new packet
 169
 170 template <class PacketType>
 171 prefix_ senf::ConcretePacket<PacketType>
 172 senf::ConcretePacket<PacketType>::create()
 173 {
 174     return ConcretePacket(interpreter::create());
 175 }
 176
 177 template <class PacketType>
 178 prefix_ senf::ConcretePacket<PacketType>
 179 senf::ConcretePacket<PacketType>::create(senf::NoInit_t)
 180 {
 181     return ConcretePacket(interpreter::create(senf::noinit));
 182 }
 183
 184 template <class PacketType>
 185 prefix_ senf::ConcretePacket<PacketType>
 186 senf::ConcretePacket<PacketType>::create(size_type size)
 187 {
 188     return ConcretePacket(interpreter::create(size));
 189 }
 190
 191 template <class PacketType>
 192 prefix_ senf::ConcretePacket<PacketType>
 193 senf::ConcretePacket<PacketType>::create(size_type size, senf::NoInit_t)
 194 {
 195     return ConcretePacket(interpreter::create(size,senf::noinit));
 196 }
 197
 198 #ifndef DOXYGEN
 199
 200 template <class PacketType>
 201 template <class ForwardReadableRange>
 202 prefix_ senf::ConcretePacket<PacketType> senf::ConcretePacket<PacketType>::
 203 create(ForwardReadableRange const & range,
 204        typename boost::disable_if< boost::is_integral<ForwardReadableRange> >::type *)
 205 {
 206     return ConcretePacket(interpreter::create(range));
 207 }
 208
 209 #endif
 210
 211 // Create packet as new packet after a given packet
 212
 213 template <class PacketType>
 214 prefix_ senf::ConcretePacket<PacketType>
 215 senf::ConcretePacket<PacketType>::createAfter(Packet const & packet)
 216 {
 217     return ConcretePacket(interpreter::createAfter(packet.ptr()));
 218 }
 219
 220 template <class PacketType>
 221 prefix_ senf::ConcretePacket<PacketType>
 222 senf::ConcretePacket<PacketType>::createAfter(Packet const & packet, senf::NoInit_t)
 223 {
 224     return ConcretePacket(interpreter::createAfter(packet.ptr(),senf::noinit));
 225 }
 226
 227 template <class PacketType>
 228 prefix_ senf::ConcretePacket<PacketType>
 229 senf::ConcretePacket<PacketType>::createAfter(Packet const & packet, size_type size)
 230 {
 231     return ConcretePacket(interpreter::createAfter(packet.ptr(), size));
 232 }
 233
 234 template <class PacketType>
 235 prefix_ senf::ConcretePacket<PacketType>
 236 senf::ConcretePacket<PacketType>::createAfter(Packet const & packet, size_type size,
 237                                               senf::NoInit_t)
 238 {
 239     return ConcretePacket(interpreter::createAfter(packet.ptr(), size, senf::noinit));
 240 }
 241
 242 #ifndef DOXYGEN
 243
 244 template <class PacketType>
 245 template <class ForwardReadableRange>
 246 prefix_ senf::ConcretePacket<PacketType> senf::ConcretePacket<PacketType>::
 247 createAfter(Packet const & packet, ForwardReadableRange const & range,
 248             typename boost::disable_if< boost::is_integral<ForwardReadableRange> >::type *)
 249 {
 250     return ConcretePacket(interpreter::createAfter(packet.ptr(), range));
 251 }
 252
 253 #endif
 254
 255 // Create packet as new packet (header) before a given packet
 256
 257 template <class PacketType>
 258 prefix_ senf::ConcretePacket<PacketType>
 259 senf::ConcretePacket<PacketType>::createBefore(Packet const & packet)
 260 {
 261     return ConcretePacket(interpreter::createBefore(packet.ptr()));
 262 }
 263
 264 template <class PacketType>
 265 prefix_ senf::ConcretePacket<PacketType>
 266 senf::ConcretePacket<PacketType>::createBefore(Packet const & packet, senf::NoInit_t)
 267 {
 268     return ConcretePacket(interpreter::createBefore(packet.ptr(), senf::noinit));
 269 }
 270
 271 template <class PacketType>
 272 prefix_ senf::ConcretePacket<PacketType>
 273 senf::ConcretePacket<PacketType>::createInsertBefore(Packet const & packet)
 274 {
 275     return ConcretePacket(interpreter::createInsertBefore(packet.ptr()));
 276 }
 277
 278 template <class PacketType>
 279 prefix_ senf::ConcretePacket<PacketType>
 280 senf::ConcretePacket<PacketType>::createInsertBefore(Packet const & packet, senf::NoInit_t)
 281 {
 282     return ConcretePacket(interpreter::createInsertBefore(packet.ptr(), senf::noinit));
 283 }
 284
 285 // Create a clone of the current packet
 286
 287 template <class PacketType>
 288 prefix_ senf::ConcretePacket<PacketType>
 289 senf::ConcretePacket<PacketType>::clone()
 290     const
 291 {
 292     return ConcretePacket(ptr()->clone());
 293 }
 294
 295 // Field access
 296
 297 template <class PacketType>
 298 prefix_ typename senf::ConcretePacket<PacketType>::Parser
 299 senf::ConcretePacket<PacketType>::parser()
 300     const
 301 {
 302     return ptr()->fields();
 303 }
 304
 305 template <class PacketType>
 306 prefix_ typename senf::ConcretePacket<PacketType>::ParserProxy
 307 senf::ConcretePacket<PacketType>::operator->()
 308     const
 309 {
 310     return ParserProxy(parser());
 311 }
 312
 313 // private members
 314
 315 template <class PacketType>
 316 prefix_ senf::ConcretePacket<PacketType>::ConcretePacket(typename interpreter::ptr const & packet_)
 317     : Packet(packet_)
 318 {}
 319
 320 template <class PacketType>
 321 prefix_ typename senf::ConcretePacket<PacketType>::interpreter::ptr
 322 senf::ConcretePacket<PacketType>::ptr()
 323     const
 324 {
 325     return boost::static_pointer_cast< PacketInterpreter<PacketType> >(Packet::ptr());
 326 }
 327
 328 ///////////////////////////////cti.e///////////////////////////////////////
 329 #undef prefix_
 330
 331 \f
 332 // Local Variables:
 333 // mode: c++
 334 // fill-column: 100
 335 // c-file-style: "senf"
 336 // indent-tabs-mode: nil
 337 // ispell-local-dictionary: "american"
 338 // compile-command: "scons -u test"
 339 // comment-column: 40
 340 // End: