WirelessInterfaceAPI.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_WirelessInterfaceAPI_
#define HH_SENF_Ext_NetEmu_WirelessInterfaceAPI_ 1

// Custom includes
#include <boost/ptr_container/ptr_unordered_map.hpp>
#include "InterfaceAPI.hh"

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

namespace senf {
namespace emu {

    class WirelessReceiver;
    class WirelessTransmitter;
    class EmulatedWirelessInterface;
    class EmulatedWirelessReceiver;
    class EmulatedWirelessTransmitter;
    class ModulationParameterRegistry;


    struct ModulationParameter
        : public boost::equality_comparable<ModulationParameter>,
          public boost::less_than_comparable<ModulationParameter>
    {
        typedef boost::uint32_t id_t;
        id_t id;  
        std::string coding;
        short minRssi;       
        unsigned rate;       
        unsigned bandwidth;  
        boost::uint8_t linkTypeId;
        std::string info;    

        ModulationParameter(std::string const & _coding, short _minRssi, unsigned _rate, unsigned _bandwidth, boost::uint8_t _linkTypeId, std::string const & _info = "");
        virtual ~ModulationParameter() {}

        void dump(std::ostream & os) const;
        void dumpTableHeader(std::ostream & os) const;
        void dumpTableRow(std::ostream & os, bool is_current_modulation) const;

        struct Error : public senf::Exception {
            Error();
        };

        bool operator<(ModulationParameter const & other) const {
            return id < other.id;
        };

        bool operator==(ModulationParameter const & other) const {
            return id == other.id;
        };
        
    private:
        friend class ModulationParameterRegistry;
        virtual boost::uint16_t v_modulationId() const = 0;
        virtual ModulationParameter * v_clone() const = 0;
        virtual void v_dump(std::ostream & os) const = 0;
        virtual void v_dumpTableHeader(std::ostream & os) const = 0;
        virtual void v_dumpTableRow(std::ostream & os) const = 0;
    };

    class ModulationParameterRegistry
        : private boost::noncopyable
    {
    public:
        static ModulationParameterRegistry & instance() {
            static ModulationParameterRegistry _instance;
            return _instance;
        }

        unsigned registerModulation(ModulationParameter & parameter);
        ModulationParameter const & findModulationById(ModulationParameter::id_t id) const;

    private:
        typedef boost::ptr_unordered_map<ModulationParameter::id_t, ModulationParameter> Modulations;
        Modulations modulations_;
    };


    class WirelessInterface
        : public Interface,
          public detail::CommfaceAccess<WirelessReceiver, WirelessTransmitter>
    {
    public:
        //-////////////////////////////////////////////////////////////////////////
        // Types

        typedef TypedInterfaceDecorator<WirelessInterface, Interface::Decorator> Decorator;

        struct Frequency {
            unsigned frequencyLower;     
            unsigned frequencyUpper;     
            unsigned bandwidthLower;     
            unsigned bandwidthUpper;     

            Frequency(unsigned frequencyLower_, unsigned frequencyUpper_, unsigned bandwidthLower_, unsigned bandwidthUpper_);
            Frequency(unsigned frequency_, unsigned bandwidth_);
        };

    private:
        struct ByLower {};
        struct ByUpper {};

        // This greatly shortens the type name and thus error messages ...
        struct FrequenciesIndexes
            : public boost::multi_index::indexed_by<
                  boost::multi_index::ordered_non_unique<
                      boost::multi_index::tag<ByLower>,
                      boost::multi_index::composite_key<
                          Frequency,
                          boost::multi_index::member<Frequency, unsigned, &Frequency::bandwidthLower>,
                          boost::multi_index::member<Frequency, unsigned, &Frequency::frequencyLower> > >,
                  boost::multi_index::ordered_non_unique<
                      boost::multi_index::tag<ByUpper>,
                      boost::multi_index::composite_key<
                          Frequency,
                          boost::multi_index::member<Frequency, unsigned, &Frequency::bandwidthUpper>,
                          boost::multi_index::member<Frequency, unsigned, &Frequency::frequencyUpper> > > >
        {};

        typedef boost::multi_index_container<Frequency, FrequenciesIndexes> Frequencies;

        typedef std::pair<unsigned, unsigned> FrequencyInterval; // Frequency interval lower & upper bound
        typedef std::set<FrequencyInterval> FrequencyIntervals;

        struct frequency_is_whitelisted
        {
            FrequencyIntervals const & whitelistedFrequencies_;
            frequency_is_whitelisted(FrequencyIntervals const & whitelistedFrequencies);
            bool operator()(unsigned frequencyLower, unsigned frequencyUpper);
            bool operator()(Frequency const & frequency);
        };

        typedef std::set<ModulationParameter::id_t> ModulationParameterIds;

    public:
        typedef boost::filter_iterator<frequency_is_whitelisted, Frequencies::const_iterator> FrequencyIterator;
        typedef boost::iterator_range<FrequencyIterator> FrequenciesRange;

        //-////////////////////////////////////////////////////////////////////////
        // Methods

        using detail::CommfaceAccess<WirelessReceiver,WirelessTransmitter>::receiver;
        using detail::CommfaceAccess<WirelessReceiver,WirelessTransmitter>::transmitter;

        //\{
        ModulationParameterIds const & modulationParameterIds() const; 
        unsigned maxNSS() const; 
        //\}

        //\{
        unsigned frequency() const;     
        unsigned bandwidth() const;     
        void frequency(unsigned freq);  
        void frequency(unsigned freq, unsigned bw); 

        FrequenciesRange frequencies() const; 

        void whitelistedFrequencyRange(unsigned frequencyLower, unsigned frequencyUpper);
        void whitelistedChannel(unsigned frequency, unsigned bandwidth);
        void clearWhitelistedFrequencies();

        void coverageRange(unsigned distance); 
        //\}

    protected:
        WirelessInterface();

        void init();

        void clearRegisteredFrequencies(); 
        void clearRegisteredModulations(); 

        void registerFrequency(unsigned frequency, unsigned bandwidth);
        void registerFrequency(unsigned frequencyLower, unsigned frequencyUpper,
                               unsigned bandwidthLower, unsigned bandwidthUpper);
        void registerModulation(ModulationParameter::id_t id);

#ifndef DOXYGEN
    private:
#else
    protected:
#endif
        virtual void v_coverageRange(unsigned distance) = 0;
        // channel frequency
        virtual unsigned v_frequency() const = 0; 
        virtual unsigned v_bandwidth() const = 0; 
        virtual void v_frequency(unsigned freq, unsigned bw) = 0;

    private:
        void listModulations(std::ostream & os) const;
        void listFrequencies(std::ostream & os) const;

        void lookupFrequency(unsigned freq, unsigned bw) const;

        ModulationParameterIds modulationIds_;
        Frequencies frequencies_;
        FrequencyIntervals whitelistedFrequencies_;

        friend class WirelessTransmitter;
        friend class EmulatedWirelessInterface;
    };


    class WirelessReceiver
        : public Receiver,
          public detail::InterfaceAccess<WirelessInterface>
    {
    protected:
        WirelessReceiver(ppi::connector::ActiveOutput<> & output);
        WirelessReceiver(ppi::connector::ActiveOutput<EthernetPacket> & output);
        WirelessReceiver(ppi::connector::ActiveOutputJack<> & output);
        WirelessReceiver(ppi::connector::ActiveOutputJack<EthernetPacket> & output);

        void init();

    private:
        using detail::InterfaceAccess<WirelessInterface>::interface;
    };


    class WirelessTransmitter
        : public Transmitter,
          public detail::InterfaceAccess<WirelessInterface>
    {
    public:
        //-////////////////////////////////////////////////////////////////////////
        // Types

        struct TxPower {
            const int lower;  
            const int upper;  

            TxPower(int _lower, int _upper);
        };

    private:
        struct TxPowersIndices
            : public boost::multi_index::indexed_by<
                  boost::multi_index::ordered_unique<
                      boost::multi_index::member<TxPower, const int, &TxPower::upper> > >
        {};

        typedef boost::multi_index_container<TxPower, TxPowersIndices> TxPowers;

    public:
        typedef boost::iterator_range<TxPowers::const_iterator> TxPowersRange;

        //-////////////////////////////////////////////////////////////////////////
        // Methods

        //\{
        ModulationParameter::id_t modulation() const;
        void modulation(ModulationParameter::id_t id); 
        //\}

        //\{
        int txPower() const;            
        void txPower(int power);        
        TxPowersRange txPowers() const; 
        //\}

    protected:
        WirelessTransmitter(ppi::connector::PassiveInput<> & input);
        WirelessTransmitter(ppi::connector::PassiveInput<EthernetPacket> & input);
        WirelessTransmitter(ppi::connector::PassiveInputJack<> & input);
        WirelessTransmitter(ppi::connector::PassiveInputJack<EthernetPacket> & input);

        void init();

        void registerTxPower(int power);
        void registerTxPower(int powerLower, int powerUpper);

#ifndef DOXYGEN
    private:
#else
    protected:
#endif
        virtual ModulationParameter::id_t v_modulationId() const = 0;
        virtual void v_modulationId(ModulationParameter::id_t id) = 0;
        virtual int v_txPower() const = 0;
        virtual void v_txPower(int power) = 0;

    private:
        using detail::InterfaceAccess<WirelessInterface>::interface;

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

        TxPowers txPowers_;

        friend class EmulatedWirelessTransmitter;
    };

}}

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