InterfaceAPIBase.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_InterfaceAPIBase_
#define HH_SENF_Ext_NetEmu_InterfaceAPIBase_ 1

// Custom includes
#include "WirelessInterfaceAPI.hh"
#include "EmulatedInterface.hh"
#include "EmulatedWirelessInterface.hh"

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

namespace senf {
namespace emu {
namespace interface {

    // Transport
    struct Hardware {};
    struct Emulated {};

    // Medium
    struct Wired {};
    struct Wireless {};

    // Direction
    struct Bidirectional {};
    struct ReceiveOnly {};
    struct TransmitOnly {};

}

    template <class Medium, class Direction, class Transport=void, class Base=void>
    class InterfaceAPIBase
    {};

    //-/////////////////////////////////////////////////////////////////////////////////////////////
    // senf::emu::InterfaceAPIBase< Wired,Bidirectional,void >

    template <>
    class InterfaceAPIBase<interface::Wired, interface::Bidirectional>
        : public WiredInterface, public WiredReceiver, public WiredTransmitter
    {
    public:
        template <class Output, class Input>
        InterfaceAPIBase(Output & output, Input & input);

    protected:
        void init();
    };

    typedef InterfaceAPIBase<interface::Wired, interface::Bidirectional> BidirectionalWiredInterface;

    //-/////////////////////////////////////////////////////////////////////////////////////////////
    // senf::emu::InterfaceAPIBase< Wired,Bidirectional,Hardware >

    template <>
    class InterfaceAPIBase<interface::Wired, interface::Bidirectional, interface::Hardware>
        : public BidirectionalWiredInterface,
          public HardwareInterface
    {
    public:
        template <class Output, class Input>
        InterfaceAPIBase(Output & output, Input & input);

    protected:
        void init();
    };

    //-/////////////////////////////////////////////////////////////////////////////////////////////
    // senf::emu::InterfaceAPIBase< Wired,ReceiveOnly,Hardware >

    template <>
    class InterfaceAPIBase<interface::Wired, interface::ReceiveOnly, interface::Hardware>
        : public WiredInterface, public WiredReceiver,
          public HardwareInterface
    {
    public:
        template <class Output>
        explicit InterfaceAPIBase(Output & output);

    protected:
        void init();
    };

    //-/////////////////////////////////////////////////////////////////////////////////////////////
    // senf::emu::InterfaceAPIBase< Wired,TransmitOnly,Hardware >

    template <>
    class InterfaceAPIBase<interface::Wired, interface::TransmitOnly, interface::Hardware>
        : public WiredInterface, public WiredTransmitter,
          public HardwareInterface
    {
    public:
        template <class Input>
        explicit InterfaceAPIBase(Input & input);

    protected:
        void init();
    };

    //-/////////////////////////////////////////////////////////////////////////////////////////////
    // senf::emu::InterfaceAPIBase< Wireless,Bidirectional,void >

    template <>
    class InterfaceAPIBase<interface::Wireless, interface::Bidirectional>
        : public WirelessInterface, public WirelessReceiver, public WirelessTransmitter
    {
    public:
        template <class Output, class Input>
        InterfaceAPIBase(Output & output, Input & input);

    protected:
        void init();
    };

    typedef InterfaceAPIBase<interface::Wireless, interface::Bidirectional> BidirectionalWirelessInterface;

    //-/////////////////////////////////////////////////////////////////////////////////////////////
    // senf::emu::InterfaceAPIBase< Wireless,Bidirectional,Hardware >

    template <>
    class InterfaceAPIBase<interface::Wireless, interface::Bidirectional, interface::Hardware>
        : public BidirectionalWirelessInterface,
          public HardwareInterface
    {
    public:
        template <class Output, class Input>
        InterfaceAPIBase(Output & output, Input & input);

    protected:
        void init();
    };

    //-/////////////////////////////////////////////////////////////////////////////////////////////
    // senf::emu::InterfaceAPIBase< Wireless,ReceiveOnly,Hardware >

    template <>
    class InterfaceAPIBase<interface::Wireless, interface::ReceiveOnly, interface::Hardware>
        : public WirelessInterface, public WirelessReceiver,
          public HardwareInterface
    {
    public:
        template <class Output>
        explicit InterfaceAPIBase(Output & output);

    protected:
        void init();
    };

    //-/////////////////////////////////////////////////////////////////////////////////////////////
    // senf::emu::InterfaceAPIBase< Wireless,TransmitOnly,Hardware >

    template <>
    class InterfaceAPIBase<interface::Wireless, interface::TransmitOnly, interface::Hardware>
        : public WirelessInterface, public WirelessTransmitter,
          public HardwareInterface
    {
    public:
        template <class Input>
        explicit InterfaceAPIBase(Input & input);

    protected:
        void init();
    };

    //-/////////////////////////////////////////////////////////////////////////////////////////////
    // senf::emu::InterfaceAPIBase< Wired,Bidirectional,Emulated >

    template < class Base>
    class InterfaceAPIBase<interface::Wired, interface::Bidirectional, interface::Emulated, Base>
        : public Base,
          public EmulatedWiredInterface, public EmulatedWiredReceiver, public EmulatedWiredTransmitter
    {
    public:
        template <class Output, class Input>
        InterfaceAPIBase(Output & output, Input & input);

    protected:
        void init();

    private:
        void v_enable();
        void v_disable();
        bool v_enabled() const;
        void v_initEmulationInterface();
        void v_deinitEmulationInterface();
        bool v_promisc() const;
        void v_promisc(bool v);
        bool v_annotationMode() const;
        void v_annotationMode(bool a);
        void v_mcAdd(senf::MACAddress const & address);
        void v_mcDrop(senf::MACAddress const & address);
        unsigned v_mtu() const;
        void v_mtu(unsigned v);
    };

    template <>
    class InterfaceAPIBase<interface::Wired, interface::Bidirectional, interface::Emulated>
        : InterfaceAPIBase<interface::Wired, interface::Bidirectional, interface::Emulated, BidirectionalWiredInterface>
    { };

    //-/////////////////////////////////////////////////////////////////////////////////////////////
    // senf::emu::InterfaceAPIBase< Wired,ReceiveOnly,Emulated >

    template <>
    class InterfaceAPIBase<interface::Wired, interface::ReceiveOnly, interface::Emulated>
        : public WiredInterface, public WiredReceiver,
          public EmulatedWiredInterface, public EmulatedWiredReceiver
    {
    public:
        template <class Output>
        explicit InterfaceAPIBase(Output & output);

    protected:
        void init();

    private:
        void v_enable();
        void v_disable();
        bool v_enabled() const;
        void v_initEmulationInterface();
        void v_deinitEmulationInterface();
        bool v_promisc() const;
        void v_promisc(bool v);
        bool v_annotationMode() const;
        void v_annotationMode(bool a);
        void v_mcAdd(senf::MACAddress const & address);
        void v_mcDrop(senf::MACAddress const & address);
    };

    //-/////////////////////////////////////////////////////////////////////////////////////////////
    // senf::emu::InterfaceAPIBase< Wired,TransmitOnly,Emulated >

    template <>
    class InterfaceAPIBase<interface::Wired, interface::TransmitOnly, interface::Emulated>
        : public WiredInterface, public WiredTransmitter,
          public EmulatedWiredInterface, public EmulatedWiredTransmitter
    {
    public:
        template <class Input>
        explicit InterfaceAPIBase(Input & input);

    protected:
        void init();

    private:
        void v_enable();
        void v_disable();
        bool v_enabled() const;
        void v_initEmulationInterface();
        void v_deinitEmulationInterface();
        unsigned v_mtu() const;
        void v_mtu(unsigned v);
    };

    //-/////////////////////////////////////////////////////////////////////////////////////////////
    // senf::emu::InterfaceAPIBase< Wireless,Bidirectional,Emulated >

    template <class Base>
    class InterfaceAPIBase<interface::Wireless, interface::Bidirectional, interface::Emulated, Base>
        : public Base,
          public EmulatedWirelessInterface, public EmulatedWirelessReceiver, public EmulatedWirelessTransmitter
    {
    public:
        template <class Output, class Input>
        InterfaceAPIBase(Output & output, Input & input);

    protected:
        void init();
        // why the heck ??
        using EmulatedWirelessReceiver::receiverJack;
        using EmulatedWirelessTransmitter::transmitterJack;

    private:
        void v_enable();
        void v_disable();
        bool v_enabled() const;
        void v_initEmulationInterface();
        void v_deinitEmulationInterface();
        bool v_promisc() const;
        void v_promisc(bool v);
        bool v_annotationMode() const;
        void v_annotationMode(bool a);
        void v_mcAdd(senf::MACAddress const & address);
        void v_mcDrop(senf::MACAddress const & address);
        unsigned v_mtu() const;
        void v_mtu(unsigned v);
        unsigned v_frequency() const;
        unsigned v_bandwidth() const;
        void v_frequency(unsigned frequency, unsigned bandwidth);
        void v_coverageRange(unsigned distance);
    };

    template <>
    class InterfaceAPIBase<interface::Wireless, interface::Bidirectional, interface::Emulated>
        : InterfaceAPIBase<interface::Wireless, interface::Bidirectional, interface::Emulated, BidirectionalWirelessInterface>
    { };

    //-/////////////////////////////////////////////////////////////////////////////////////////////
    // senf::emu::InterfaceAPIBase< Wireless,ReceiveOnly,Emulated >

    template <class Base>
    class InterfaceAPIBase<interface::Wireless, interface::ReceiveOnly, interface::Emulated, Base>
        : public Base, public WirelessReceiver,
          public EmulatedWirelessInterface, public EmulatedWirelessReceiver
    {
    public:
        template <class Output>
        explicit InterfaceAPIBase(Output & output);

    protected:
        void init();
        // why the heck ??
        using EmulatedWirelessReceiver::receiverJack;

    private:
        void v_enable();
        void v_disable();
        bool v_enabled() const;
        void v_initEmulationInterface();
        void v_deinitEmulationInterface();
        bool v_promisc() const;
        void v_promisc(bool v);
        bool v_annotationMode() const;
        void v_annotationMode(bool a);
        void v_mcAdd(senf::MACAddress const & address);
        void v_mcDrop(senf::MACAddress const & address);
        unsigned v_frequency() const;
        unsigned v_bandwidth() const;
        void v_frequency(unsigned frequency, unsigned bandwidth);
        void v_coverageRange(unsigned distance);
    };

    template <>
    class InterfaceAPIBase<interface::Wireless, interface::ReceiveOnly, interface::Emulated>
        : InterfaceAPIBase<interface::Wireless, interface::ReceiveOnly, interface::Emulated, WirelessInterface>
    { };

    //-/////////////////////////////////////////////////////////////////////////////////////////////
    // senf::emu::InterfaceAPIBase< Wireless,TransmitOnly,Emulated >

    template <class Base>
    class InterfaceAPIBase<interface::Wireless, interface::TransmitOnly, interface::Emulated, Base>
        : public Base, public WirelessTransmitter,
          public EmulatedWirelessInterface, public EmulatedWirelessTransmitter
    {
    public:
        template <class Input>
        explicit InterfaceAPIBase(Input & input);

    protected:
        void init();
        // why the heck ??
        using EmulatedWirelessTransmitter::transmitterJack;

    private:
        void v_enable();
        void v_disable();
        bool v_enabled() const;
        void v_initEmulationInterface();
        void v_deinitEmulationInterface();
        unsigned v_mtu() const;
        void v_mtu(unsigned v);
        unsigned v_frequency() const;
        unsigned v_bandwidth() const;
        void v_frequency(unsigned frequency, unsigned bandwidth);
        void v_coverageRange(unsigned distance);
    };

    template <>
    class InterfaceAPIBase<interface::Wireless, interface::TransmitOnly, interface::Emulated>
        : InterfaceAPIBase<interface::Wireless, interface::TransmitOnly, interface::Emulated, WirelessInterface>
    { };

}}

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