Packet.hh

Go to the documentation of this file.

//
// Copyright (c) 2020 Fraunhofer Institute for Applied Information Technology (FIT)
//                    Network Research Group (NET)
//                    Schloss Birlinghoven, 53754 Sankt Augustin, GERMANY
//                    Contact: support@wiback.org
//
// This file is part of the SENF code tree.
// It is licensed under the 3-clause BSD License (aka New BSD License).
// See LICENSE.txt in the top level directory for details or visit
// https://opensource.org/licenses/BSD-3-Clause
//


#ifndef HH_SENF_Packets_Packet_
#define HH_SENF_Packets_Packet_ 1

// Custom includes
#include <boost/operators.hpp>
#include <boost/utility/enable_if.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::byte byte;
        typedef senf::detail::packet::size_type size_type;
        typedef senf::detail::packet::difference_type difference_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);

        // the below is needed to implement an 'active' Packet Handle Counter
        Packet & operator=(Packet const &);
        Packet(Packet const & other);
        Packet(Packet && other) noexcept;
        ~Packet();

        
        static std::int32_t const & pktCount();

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

        //\{

        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 const & as() const;

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

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

        Packet append(Packet const & packet) const; 

        void reparse() const;           

        template <class OtherPacket>
        OtherPacket replaceAs(difference_type offset=0, difference_type tailOffset=0);

        //\}

        //\{

        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;      

        void finalizeThis();            

        template <class Other>
        void finalizeTo();              

        void finalizeTo(Packet const & other);  

        void finalizeAll();             

        void dump(std::ostream & os, DumpPacketAnnotations_t dumpAnnotationsSwitch = dumpAnnotations) const;

        TypeIdValue typeId() const;     

        factory_t factory() const;      

        unsigned long id() const;       

        bool is_shared() const;         

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

        //\}

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

        PacketInterpreterBase::ptr const & ptr() const;

        PacketInterpreterBase::ptr parseNextAs(factory_t factory, PacketInterpreterBase::optional_range const & range) const;
        PacketInterpreterBase::ptr getNext(PacketInterpreterBase::optional_range const & range) const;
        Packet getLast() const;

    private:
        PacketInterpreterBase::ptr packet_;

#ifdef SENF_DEBUG
        static std::int32_t pktCount_;
#endif
        template <class PacketType>
        friend class ConcretePacket;
        friend class PacketParserBase;
    };

    std::ostream & operator<<(std::ostream & os, Packet const & packet);

    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

        static ConcretePacket create(byte * data, size_type size, size_type totalSize = 0u,
                                     size_type offset = 0u);

        // 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 createBeforeNoZero(Packet const & packet);

        static ConcretePacket createBefore(Packet const & packet, senf::NoInit_t, size_type space=0,
                                           size_type tailSpace=0);

        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;          

#ifndef DOXYGEN
        using Packet::next;

        Packet next(NoThrow_t) const;
        template <class OtherPacket>
        OtherPacket next(NoThrow_t) const;
#endif

    private:
        typedef PacketInterpreter<PacketType> interpreter;

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

        interpreter * ptr() const;

        friend class Packet;
        friend class PacketInterpreter<PacketType>;
        template<class PType> friend class ConcretePacket;
    };

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

    //\}

#ifdef SENF_CXX11_ENABLED
#  define SENF_PACKET_PREVENT_TEMPLATE_INSTANTIATION(Packet)        \
        extern template class senf::ConcretePacket<Packet##Type>;   \
        extern template class senf::PacketInterpreter<Packet##Type>;
#  define SENF_PACKET_INSTANTIATE_TEMPLATE(Packet)                  \
        template class senf::ConcretePacket<Packet##Type>;          \
        template class senf::PacketInterpreter<Packet##Type>;
#else
#  define SENF_PACKET_PREVENT_TEMPLATE_INSTANTIATION(Packet)
#  define SENF_PACKET_INSTANTIATE_TEMPLATE(Packet)
#endif

}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#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: