PacketImpl.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_PacketImpl_
#define HH_SENF_Packets_PacketImpl_ 1

// Custom includes
#include <boost/noncopyable.hpp>
#include <boost/static_assert.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <boost/type_traits/aligned_storage.hpp>
#include <senf/Utils/pool_alloc_mixin.hh>

//#include "PacketImpl.mpp"
#include "PacketImpl.ih"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

// Here we only need the size of PacketInterpreter, no implementation is needed
#ifndef HH_SENF_Packets_Packets__decls_
#define HH_SENF_Packets_Packets__decls_
#include "PacketInterpreter.hh"
#include "PacketType.hh"
#undef HH_SENF_Packets_Packets__decls_
#else
#include "PacketInterpreter.hh"
#include "PacketType.hh"
#endif

namespace senf {

    struct ComplexAnnotation {};

    void dumpPacketAnnotationRegistry(std::ostream & os);

    template <class PacketType> class PacketInterpreter;

namespace detail {

    class PacketImpl
        : boost::noncopyable,
          public pool_alloc_mixin<PacketImpl>
    {
    public:
        typedef senf::detail::packet::byte byte;
        typedef senf::detail::packet::raw_container raw_container;
        typedef senf::detail::packet::size_type size_type;
        typedef senf::detail::packet::difference_type difference_type;
        typedef senf::detail::packet::interpreter_list interpreter_list;
        typedef senf::detail::packet::iterator iterator;
        typedef senf::detail::packet::const_iterator const_iterator;
        typedef senf::detail::packet::refcount_t refcount_t;

        // structors

        PacketImpl();
        PacketImpl(size_type size, byte initValue);
        template <class InputIterator>
        PacketImpl(InputIterator b, InputIterator e);
        PacketImpl(byte * data, size_type size, size_type chunkSize = 0u,
                   size_type offset = 0u);
        ~PacketImpl();

        // reference/memory management

        void add_ref();
        bool release();
        refcount_t refcount() const;

        // Interpreter chain

        PacketInterpreterBase * first();
        PacketInterpreterBase * last();

        PacketInterpreterBase * next(PacketInterpreterBase * p);
        PacketInterpreterBase * prev(PacketInterpreterBase * p);

        void * allocateInterpreter();
        void deallocateInterpreter(void * address);

        bool usingExternalMemory() const;
        void releaseExternalMemory();

        void memDebug(std::ostream & os);

        void appendInterpreter    (PacketInterpreterBase * p);
        void prependInterpreter   (PacketInterpreterBase * p);
        void prependInterpreter   (PacketInterpreterBase * p, PacketInterpreterBase * before);
        void truncateInterpreters (PacketInterpreterBase * p);
        void truncateInterpretersBackwards (PacketInterpreterBase * p);

        // This one is DANGEROUS:
        // a) if called without a Guard in place, this will destroy the PacketImpl
        // b) this will invalidate ALL (!!) packet's referencing this data
        void clearInterpreters();

        // Data container

        iterator begin();
        iterator end();
        size_type size();

        void insert(PacketData * self, iterator pos, byte v);
        void insert(PacketData * self, iterator pos, size_type n, byte v);
        template <class ForwardIterator>
        void insert(PacketData * self, iterator pos, ForwardIterator f, ForwardIterator l);

        void erase(PacketData * self, iterator pos);
        void erase(PacketData * self, iterator first, iterator last);
        void truncateDataBackwards(PacketData * self, iterator pos);
        iterator truncateRawDataBackwards(iterator pos);
        void truncateRawDataForward(iterator pos);
        void clear(PacketData * self);

        // Annotations
        template <class Annotation>
        Annotation & annotation();

        void clearAnnotations();
        void assignAnnotations(PacketImpl const & other);
        void dumpAnnotations(std::ostream & os);

        struct Guard {
            Guard(PacketImpl * impl);
            ~Guard();
            PacketImpl * p;
        };

        static size_type maxPreallocHigh();
        static size_type maxPreallocHeapcount();

    private:
        void eraseInterpreters(interpreter_list::iterator b, interpreter_list::iterator e);
        void updateIterators(PacketData * self, difference_type pos, difference_type n);

        void * annotation(AnnotationRegistry::key_type key); // may return 0 !
#ifndef SENF_PACKET_NO_COMPLEX_ANNOTATIONS
        void * complexAnnotation(AnnotationRegistry::key_type key); // may return 0 !
        template <class Annotation>
        void * complexAnnotation();
#endif

#ifndef SENF_PACKET_NO_HEAP_INTERPRETERS
        void destroySelf();
#endif

        refcount_t refcount_;
        raw_container data_;
        interpreter_list interpreters_;

        // Annotations

        typedef boost::aligned_storage<SENF_PACKET_ANNOTATION_SLOTSIZE>::type SimpleAnnotationSlot;

#ifndef SENF_PACKET_NO_COMPLEX_ANNOTATIONS
        typedef boost::ptr_vector< boost::nullable<AnnotationRegistry::EntryBase> >
            ComplexAnnotations;
        ComplexAnnotations complexAnnotations_;
#endif

        SimpleAnnotationSlot simpleAnnotations_[SENF_PACKET_ANNOTATION_SLOTS];

        // Preallocated interpreters

        union PreallocSlot {
            boost::aligned_storage<
                sizeof(PacketInterpreter<PacketTypeBase>),
                boost::alignment_of< PacketInterpreter<PacketTypeBase> >::value
                >::type storage_;
#ifndef SENF_PACKET_ALTERNATIVE_PREALLOC
            int nextOffset_;
#else
            PreallocSlot * nextFree_;
#endif
        };

        PreallocSlot prealloc_[SENF_PACKET_PREALLOC_INTERPRETERS];
#ifdef SENF_PACKET_ALTERNATIVE_PREALLOC
        size_type preallocHigh_;
#endif
        PreallocSlot * preallocFree_;
#ifndef SENF_PACKET_NO_HEAP_INTERPRETERS
        size_type preallocHeapcount_;
#endif

#ifdef SENF_DEBUG
        static size_type maxPreallocHigh_;
#ifndef SENF_PACKET_NO_HEAP_INTERPRETERS
        static size_type maxPreallocHeapcount_;
#endif
#endif
    };

    void intrusive_ptr_add_ref(PacketImpl *);
    void intrusive_ptr_release(PacketImpl *);

}}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#endif
#if !defined(HH_SENF_Packets_Packets__decls_) && !defined(HH_SENF_Packets_PacketImpl_i_)
#define HH_SENF_Packets_PacketImpl_i_
#include "PacketImpl.cci"
#include "PacketImpl.ct"
#include "PacketImpl.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: