PacketRegistry.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_PacketRegistry_
#define HH_SENF_Packets_PacketRegistry_ 1

// Custom includes
#include <boost/optional.hpp>
#include <boost/preprocessor/cat.hpp>
#include <senf/Utils/Exception.hh>
#include <senf/Utils/singleton.hh>
#include "Packet.hh"

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

namespace senf {

    template <class Tag>
    class PacketRegistry
        : private senf::singleton< PacketRegistry<Tag> >
    {
    public:
        typedef typename detail::PacketRegistryImpl<typename Tag::key_t>::iterator iterator;
        typedef typename detail::PacketRegistryImpl<typename Tag::key_t>::Entry Entry;

        template <class PacketType>
        struct ScopedRegistrationProxy
        {
            ScopedRegistrationProxy(typename Tag::key_t key, int priority=0);
            ~ScopedRegistrationProxy();
        };

        template <class PacketType>
        static void registerPacket(typename Tag::key_t key, int priority=0);

        template <class PacketType>
        static void unregisterPacket();

        static void unregisterPacket(typename Tag::key_t key, int priority=0);

        template <class PacketType>
        static typename Tag::key_t key();

        template <class PacketType>
        static typename boost::optional<typename Tag::key_t> key(NoThrow_t);

        static typename Tag::key_t key(Packet const & packet);

        static typename boost::optional<typename Tag::key_t> key(Packet const & packet, NoThrow_t);

        static Entry const & lookup(typename Tag::key_t key);

        static Entry const * lookup(typename Tag::key_t key, NoThrow_t);

        static iterator begin();

        static iterator end();

    private:
        using singleton<PacketRegistry>::instance;
        using singleton<PacketRegistry>::alive;

        PacketRegistry();

        typedef detail::PacketRegistryImpl<typename Tag::key_t> Registry;
        static Registry & registry();
        Registry registry_;

        friend class senf::singleton< PacketRegistry >;
    };

#   define SENF_PACKET_REGISTRY_REGISTER( registry, value, type )       \
        namespace {                                                     \
            senf::PacketRegistry< registry >::ScopedRegistrationProxy< type > \
            BOOST_PP_CAT(packetRegistration_, __LINE__) ( value );      \
        }

#   define SENF_PACKET_REGISTRY_REGISTER_PRIORITY( registry, value, priority, type ) \
        namespace {                                                     \
            senf::PacketRegistry< registry >::ScopedRegistrationProxy< type > \
            BOOST_PP_CAT(packetRegistration_, __LINE__) ( value, priority ); \
        }

    void dumpPacketRegistries(std::ostream & os);

    struct PacketTypeNotRegisteredException : public senf::Exception
    { PacketTypeNotRegisteredException() : senf::Exception("packet type not registered") {} };

}

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