GenericTLV.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_GenericTLV_
#define HH_SENF_Packets_GenericTLV_ 1

// Custom includes
#include <boost/ptr_container/ptr_map.hpp>
#include <senf/Utils/type_traits.hh>
#include <senf/Utils/singleton.hh>
#include "Packets.hh"

#include "GenericTLV.ih"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {

    template <class Base>
    class GenericTLVParserBase
        : private detail::GenericTLVParserBaseTag,
          public Base
    {
    public:
        GenericTLVParserBase(PacketParserBase::data_iterator i, PacketParserBase::state_type s)
            : Base(i,s) {}

        static PacketParserBase::size_type const init_bytes = senf::init_bytes<Base>::value;

        PacketParserBase::size_type bytes() const;
        void init() const;

        template <class Parser>
        Parser init();

        template <class Parser>
        Parser as() const;

        template <class Parser>
        bool is() const;

        PacketInterpreterBase::range value() const;

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

#ifndef DOXYGEN
        template<class ForwardReadableRange>
        void value(ForwardReadableRange const & val,
                typename boost::disable_if<senf::is_pair<ForwardReadableRange> >::type * = 0);

        template<class First, class Second>
        void value(std::pair<First, Second> const & val,
                typename boost::disable_if<boost::is_convertible<First, typename Base::type_t::value_type> >::type * = 0);

        template <class Type, class ForwardReadableRange>
        void value(std::pair<Type, ForwardReadableRange> const & val,
                typename boost::enable_if<boost::is_convertible<Type, typename Base::type_t::value_type> >::type * = 0);
#else
        template<class ForwardReadableRange>
        void value(ForwardReadableRange const & val);

        template <class ForwardReadableRange>
        void value(std::pair<typename Base::type_t::value_type, ForwardReadableRange> const & val);
#endif

    private:
        template<class ForwardReadableRange>
        void value_(ForwardReadableRange const &range);

        Base & self();
        Base const & self() const;
    };


    template <class BaseParser, class Keytype = typename BaseParser::type_t::value_type>
    class GenericTLVParserRegistry
        : public singleton<GenericTLVParserRegistry<BaseParser,Keytype> >
    {
        GenericTLVParserRegistry() {};

        typedef boost::ptr_map<Keytype,
            detail::GenericTLVParserRegistry_EntryBase<BaseParser> > Map;
        Map map_;

    public:
        using singleton<GenericTLVParserRegistry<BaseParser,Keytype> >::instance;
        friend class singleton<GenericTLVParserRegistry<BaseParser,Keytype> >;

        template <class PacketParser>
        struct RegistrationProxy {
            RegistrationProxy();
        };

        template <typename Parser>
        void registerParser();

        typedef GenericTLVParserBase<BaseParser> GenericTLVParser;

        bool isRegistered(GenericTLVParserBase<BaseParser> const & parser) const;
        bool isRegistered(Keytype const & key) const;

        void dump(GenericTLVParser const & parser, std::ostream & os) const;
        void dump(GenericTLVParser const & parser, Keytype const & key, std::ostream & os) const;

        PacketParserBase::size_type bytes(GenericTLVParser const & parser) const;
        PacketParserBase::size_type bytes(GenericTLVParser const & parser, Keytype const & key) const;

        typedef typename Map::const_iterator const_iterator;
        const_iterator begin() const;
        const_iterator end() const;
    };

    struct TLVParserNotRegisteredException : public senf::Exception
    {
        TLVParserNotRegisteredException() : senf::Exception("tlv parser not registered") {}
    };


    template <class ListPolicy>
    class TLVListParser
        : public ListParser<ListPolicy>
    {
    public:
        TLVListParser(PacketParserBase::data_iterator i, PacketParserBase::state_type s);
        TLVListParser(ListPolicy policy, PacketParserBase::data_iterator i, PacketParserBase::state_type s);

        template <typename TLVParser>
        bool contains() const;
        bool contains(typename ListPolicy::element_type::type_t::value_type typeId) const;

        template <typename TLVParser>
        TLVParser find() const;
    };


#   define SENF_PACKET_TLV_REGISTRY_REGISTER( ConreteTLVParser )                \
        namespace {                                                             \
            ConreteTLVParser::Registry::RegistrationProxy<ConreteTLVParser>     \
                    BOOST_PP_CAT(tlvparserRegistration_, __LINE__);             \
        }

#   define SENF_PARSER_TLV_LIST SENF_PARSER_LIST
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
//#include "GenericTLV.cci"
#include "GenericTLV.ct"
#include "GenericTLV.cti"
#endif

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