Search:

SENF Extensible Network Framework

• Home
• Download
• Wiki
• BerliOS
• ChangeLog
• Browse SVN
• Bug Tracker

Packet.hh

Go to the documentation of this file.

// $Id: Packet.hh 1756 2011-01-06 10:10:07Z tho $
//
// Copyright (C) 2007
// Fraunhofer (FOKUS)
// Competence Center NETwork research (NET), St. Augustin, GERMANY
//     Stefan Bund <g0dil@berlios.de>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

#ifndef HH_SENF_Packets_Packet_
#define HH_SENF_Packets_Packet_ 1

// Custom includes
#include <boost/operators.hpp>
#include <boost/utility.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <senf/Utils/Tags.hh>
#include <senf/Utils/safe_bool.hh>
#include "PacketInterpreter.hh"

//#include "Packet.mpp"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {

    template <class PackeType> class ConcretePacket;

    //\{

    class Packet
        : public safe_bool<Packet>,
          public boost::equality_comparable<Packet>
    {
    public:
        //-////////////////////////////////////////////////////////////////////////
        // Types

        typedef void type;              
        typedef senf::detail::packet::size_type size_type;
        typedef PacketInterpreterBase::factory_t factory_t; 

        //-////////////////////////////////////////////////////////////////////////
        //\{

        // default copy constructor
        // default copy assignment
        // default destructor

        Packet();                       

        Packet clone() const;           

        // conversion constructors

        template <class PacketType>
        Packet(ConcretePacket<PacketType> const & packet);

        //\}
        //-////////////////////////////////////////////////////////////////////////

        //\{

        Packet      next() const;       

        Packet      next(NoThrow_t) const; 

        template <class OtherPacket> OtherPacket next() const;

        template <class OtherPacket> OtherPacket next(NoThrow_t) const;

        template <class OtherPacket> OtherPacket find() const;

        template <class OtherPacket> OtherPacket find(NoThrow_t) const;

        Packet      prev() const;       

        Packet      prev(NoThrow_t) const; 

        template <class OtherPacket> OtherPacket prev() const;

        template <class OtherPacket> OtherPacket prev(NoThrow_t) const;

        template <class OtherPacket> OtherPacket rfind() const;

        template <class OtherPacket> OtherPacket rfind(NoThrow_t) const;

        Packet      first() const;      
        template <class OtherPacket> OtherPacket first() const;

        Packet      last() const;       
        template <class OtherPacket> OtherPacket last() const;

        template <class OtherPacket> OtherPacket parseNextAs() const;

        Packet      parseNextAs(factory_t factory) const;

        template <class OtherPacket> bool        is() const;
        template <class OtherPacket> OtherPacket as() const;

        template <class OtherPacket> OtherPacket as(NoThrow_t) const;

        Packet append(Packet const & packet) const; 

        void reparse() const;           

        //\}

        //\{

        PacketData & data() const;      
        size_type size() const;         

        //\}

        //\{

        template <class Annotation>
        Annotation & annotation();      

        template <class Annotation>
        Annotation const & annotation() const; 

        void clearAnnotations();        

        //\}

        //\{

        bool operator==(Packet const & other) const; 

        bool boolean_test() const;      

        bool valid() const;             

        void finalizeThis();            

        template <class Other>
        void finalizeTo();              

        void finalizeTo(Packet const & other);  

        void finalizeAll();             

        void dump(std::ostream & os) const; 

        TypeIdValue typeId() const;     

        factory_t factory() const;      

        unsigned long id() const;       

        bool is_shared() const;         

        //\}

    protected:
        explicit Packet(PacketInterpreterBase::ptr const & packet);

        PacketInterpreterBase::ptr const & ptr() const;

    private:
        Packet getNext() const;
        Packet getLast() const;

        PacketInterpreterBase::ptr packet_;

        template <class PacketType>
        friend class ConcretePacket;
        friend class PacketParserBase;
    };

    template <class PacketType>
    class ConcretePacket
        : public Packet
    {
    public:
        //-////////////////////////////////////////////////////////////////////////
        // Types

        typedef PacketType type;
        typedef typename PacketType::parser Parser;

        //-////////////////////////////////////////////////////////////////////////
        //\{

        // default copy constructor
        // default copy assignment
        // default destructor
        // no conversion constructors

        ConcretePacket();               

        static factory_t factory();     

        // Create completely new packet

        static ConcretePacket create(); 

        static ConcretePacket create(senf::NoInit_t); 

        static ConcretePacket create(size_type size); 

        static ConcretePacket create(size_type size, senf::NoInit_t);

#ifndef DOXYGEN
        template <class ForwardReadableRange>
        static ConcretePacket create(
            ForwardReadableRange const & range,
            typename boost::disable_if< boost::is_integral<ForwardReadableRange> >::type * = 0);
#else
        template <class ForwardReadableRange>
        static ConcretePacket create(ForwardReadableRange const & range);

#endif

        // Create packet as new packet after a given packet

        static ConcretePacket createAfter(Packet const & packet);

        static ConcretePacket createAfter(Packet const & packet, senf::NoInit_t);

        static ConcretePacket createAfter(Packet const & packet, size_type size);

        static ConcretePacket createAfter(Packet const & packet, size_type size, senf::NoInit_t);

#ifndef DOXYGEN
        template <class ForwardReadableRange>
        static ConcretePacket createAfter(
            Packet const & packet,
            ForwardReadableRange const & range,
            typename boost::disable_if< boost::is_integral<ForwardReadableRange> >::type * = 0);
#else
        template <class ForwardReadableRange>
        static ConcretePacket createAfter(Packet const & packet,
                                          ForwardReadableRange const & range);

#endif

        // Create packet as new packet (header) before a given packet

        static ConcretePacket createBefore(Packet const & packet);

        static ConcretePacket createBefore(Packet const & packet, senf::NoInit_t);

        static ConcretePacket createInsertBefore(Packet const & packet);

        static ConcretePacket createInsertBefore(Packet const & packet, senf::NoInit_t);

        // Create a clone of the current packet

        ConcretePacket clone() const;

        //\}
        //-////////////////////////////////////////////////////////////////////////

        // Field access

        struct ParserProxy
        {
            ParserProxy(Parser const & p) : p_ (p) {}
            Parser * operator->() { return &p_; }
            Parser p_;
        };

        ParserProxy operator->() const;    

        Parser parser() const;          

    protected:

    private:
        typedef PacketInterpreter<PacketType> interpreter;

        ConcretePacket(typename interpreter::ptr const & packet_);

        interpreter * ptr() const;

        friend class Packet;
        friend class PacketInterpreter<PacketType>;
    };

    template <class PacketType, class Parser>
    Parser operator<<(Parser target, ConcretePacket<PacketType> const & packet);

    //\}

}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#endif
#if !defined(HH_SENF_Packets_Packets__decls_) && !defined(HH_SENF_Packets_Packet_i_)
#define HH_SENF_Packets_Packet_i_
#include "Packet.cci"
#include "Packet.ct"
#include "Packet.cti"
#endif


// Local Variables:
// mode: c++
// fill-column: 100
// c-file-style: "senf"
// indent-tabs-mode: nil
// ispell-local-dictionary: "american"
// compile-command: "scons -u test"
// comment-column: 40
// End:

---

Contact: senf-dev@lists.berlios.de | © 2006-2010 Fraunhofer Institute for Open Communication Systems, Network Research