InterfaceDecorator.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_Ext_NetEmu_InterfaceDecorator_
#define HH_SENF_Ext_NetEmu_InterfaceDecorator_ 1

// Custom includes
#include <boost/mpl/if.hpp>
#include <boost/type_traits/is_base_of.hpp>
#include <boost/utility/base_from_member.hpp>
#include <senf/PPI/Jack.hh>
#include <senf/Packets/DefaultBundle/EthernetPacket.hh>
#include <senf/Utils/mpl.hh>

//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {
namespace emu {

    class Interface;
    class Receiver;
    class Transmitter;

    class ReceiverDecorator
    {
    public:
        virtual ~ReceiverDecorator();

        ppi::connector::ActiveOutputJack<EthernetPacket> output;

    protected:
        template <class Connector>
        ReceiverDecorator(Connector & connector);
    };

    class TransmitterDecorator
    {
    public:
        virtual ~TransmitterDecorator();

        ppi::connector::PassiveInputJack<EthernetPacket> input;

    protected:
        template <class Connector>
        TransmitterDecorator(Connector & connector);
    };

    class InterfaceDecorator
        : private boost::noncopyable
    {
    public:
        virtual ~InterfaceDecorator();

        Interface & interface();
        Interface const & interface() const;

        Interface * operator->();
        Interface const * operator->() const;

        ReceiverDecorator & receiverDecorator();
        ReceiverDecorator const & receiverDecorator() const;
        TransmitterDecorator & transmitterDecorator();
        TransmitterDecorator const & transmitterDecorator() const;

        bool canReceive() const;
        bool canTransmit() const;
        MACAddress id() const;

    protected:
        InterfaceDecorator(Interface & interface);

    private:
        Interface & interface_;
    };

#ifndef DOXYGEN

    template <class InterfaceType, class Base=InterfaceDecorator>
    class TypedInterfaceDecorator
        : public Base
    {
    public:
        InterfaceType & interface();
        InterfaceType const & interface() const;

    protected:
        TypedInterfaceDecorator(InterfaceType & interface);
   };

#else

    template <class InterfaceType, class Base>
    class TypedInterfaceDecorator
        : public InterfaceDecorator
    {
    public:
        InterfaceType & interface();
        InterfaceType const & interface() const;

    protected:
        TypedInterfaceDecorator(InterfaceType & interface);
   };

#endif

    template <class ReceiveModule>
    class ReceiverDecoratorImplementation
        : private boost::base_from_member<ReceiveModule>,
          public ReceiverDecorator
    {
        typedef boost::base_from_member<ReceiveModule> ModuleMember;
    public:
        ReceiveModule & receiveModule();
        ReceiveModule const & receiveModule() const;

    protected:
        template <class Interface>
        ReceiverDecoratorImplementation(Interface & interface);
    };

#ifndef DOXYGEN

    template <>
    class ReceiverDecoratorImplementation<senf::mpl::nil>
        : public ReceiverDecorator
    {
    protected:
        template <class Interface>
        ReceiverDecoratorImplementation(Interface & interface);
    };

#endif

    template <class TransmitModule>
    class TransmitterDecoratorImplementation
        : private boost::base_from_member<TransmitModule>,
          public TransmitterDecorator
    {
        typedef boost::base_from_member<TransmitModule> ModuleMember;
    public:
        TransmitModule & transmitModule();
        TransmitModule const & transmitModule() const;

    protected:
        template <class Interface>
        TransmitterDecoratorImplementation(Interface & interface);
    };

#ifndef DOXYGEN

    template <>
    class TransmitterDecoratorImplementation<senf::mpl::nil>
        : public TransmitterDecorator
    {
    protected:
        template <class Interface>
        TransmitterDecoratorImplementation(Interface & interface);
    };

#endif

namespace detail {

#ifndef DOXYGEN

    struct NoDecorator
    {
        template <class Interface>
        NoDecorator(Interface & interface);
    };

    template <class InterfaceType, class CheckBase, class Implementation>
    struct CheckDecoratorBase
        : public boost::mpl::if_<
            boost::is_base_of<CheckBase, InterfaceType>,
            Implementation,
            NoDecorator >
    {};

#endif

}

#ifndef DOXYGEN

    template <class InterfaceType, class ReceiveModule, class TransmitModule>
    class InterfaceDecoratorImplementation
        : private boost::base_from_member<InterfaceType>,
          public InterfaceType::Decorator,
          public detail::CheckDecoratorBase<
              InterfaceType,
              Receiver,
              ReceiverDecoratorImplementation<ReceiveModule>
              >::type,
          public detail::CheckDecoratorBase<
              InterfaceType,
              Transmitter,
              TransmitterDecoratorImplementation<TransmitModule>
              >::type
    {
        typedef boost::base_from_member<InterfaceType> InterfaceBase;
        typedef typename detail::CheckDecoratorBase<
            InterfaceType,
            Receiver,
            ReceiverDecoratorImplementation<ReceiveModule> >::type ReceiverDecoratorBase;
        typedef typename detail::CheckDecoratorBase<
            InterfaceType,
            Transmitter,
            TransmitterDecoratorImplementation<TransmitModule> >::type TransmitterDecoratorBase;

    public:
        InterfaceDecoratorImplementation();
        template <class A1> explicit InterfaceDecoratorImplementation(A1 const & a1);
        template <class A1, class A2> explicit InterfaceDecoratorImplementation(A1 const & a1, A2 const & a2);
    };

#else

    template <class InterfaceType, class ReceiveModule, class TransmitModule>
    class InterfaceDecoratorImplementation
        : public TypedInterfaceDecorator<InterfaceType>,
          public ReceiverDecoratorImplementation<ReceiveModule>,
          public TransmitterDecoratorImplementation<TransmitModule>
    {};

#endif

    template <class ReceiveModule=senf::mpl::nil, class TransmitModule=senf::mpl::nil>
    struct ApplyInterfaceDecorator
    {
#ifndef DOXYGEN
        template <class InterfaceType>
        struct apply
        {
            typedef InterfaceDecoratorImplementation<
                InterfaceType, ReceiveModule, TransmitModule> type;

        };
#endif

        static ReceiveModule & receiveModule(InterfaceDecorator & interface);
        static ReceiveModule const & receiveModule(InterfaceDecorator const & interface);

        static TransmitModule & transmitModule(InterfaceDecorator & interface);
        static TransmitModule const & transmitModule(InterfaceDecorator const & interface);
    };

}}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#include "InterfaceDecorator.cci"
//#include "InterfaceDecorator.ct"
#include "InterfaceDecorator.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: