EmulatedWirelessInterface.cci

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
//


/** \file
    \brief EmulatedWirelessInterface inline non-template implementation */

// Custom includes

#define prefix_ inline
//-/////////////////////////////////////////////////////////////////////////////////////////////////

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::detail::EmulatedWirelessInterfaceTransmitFilter

prefix_
senf::emu::detail::EmulatedWirelessInterfaceTransmitFilter::
EmulatedWirelessInterfaceTransmitFilter(EmulatedWirelessTransmitter & iface)
    : iface_ (iface)
{
    route(input,output);
    input.onRequest(&EmulatedWirelessInterfaceTransmitFilter::request);
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::detail::EmulatedWirelessInterfaceReceiveFilter

prefix_
senf::emu::detail::EmulatedWirelessInterfaceReceiveFilter::
EmulatedWirelessInterfaceReceiveFilter(EmulatedWirelessReceiver & iface)
    : iface_ (iface)
{
    route(input,output);
    input.onRequest(&EmulatedWirelessInterfaceReceiveFilter::request);
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::EmulatedFrequencyRegistry::Entry

prefix_ senf::emu::EmulatedFrequencyRegistry::Entry::Entry()
    : frequency (), bandwidth (), address (), nUsers (), ownerNodeId ()
{}

prefix_ senf::emu::EmulatedFrequencyRegistry::Entry::Entry(unsigned frequency_,
                                                           unsigned bandwidth_)
    : frequency (frequency_), bandwidth (bandwidth_), address (), nUsers (), ownerNodeId ()
{}

prefix_ senf::emu::EmulatedFrequencyRegistry::Entry::Entry(unsigned frequency_,
                                                           unsigned bandwidth_,
                                                           UDPClientHandle::Address address_,
                                                           unsigned nUsers_,
                                                           unsigned ownerNodeId_)
    : frequency (frequency_), bandwidth (bandwidth_), address (address_), nUsers (nUsers_),
      ownerNodeId (ownerNodeId_)
{}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::EmulatedFrequencyRegistry::User

prefix_ senf::emu::EmulatedFrequencyRegistry::User::User()
    : entry(), interfaceId(), callback()
{}

prefix_ senf::emu::EmulatedFrequencyRegistry::User::
User(Entries::index_iterator<ByFrequency>::type entry_, unsigned interfaceId_, UserCallback callback_)
    : entry(entry_), interfaceId(interfaceId_), callback(callback_)
{}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::EmulatedFrequencyRegistry::AddrCompare

prefix_ bool senf::emu::EmulatedFrequencyRegistry::AddrCompare::
operator()(Entries::index_iterator<ByFrequency>::type a,
           Entries::index_iterator<ByFrequency>::type b)
    const
{
    return &*a < &*b;
}

prefix_ bool senf::emu::EmulatedFrequencyRegistry::AddrCompare::
operator()(Entries::index_iterator<ByFrequency>::type a, Entry const * b)
    const
{
    return &*a < b;
}

prefix_ bool senf::emu::EmulatedFrequencyRegistry::AddrCompare::
operator()(Entry const * a, Entries::index_iterator<ByFrequency>::type b)
    const
{
    return a < &*b;
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::EmulatedFrequencyRegistry

prefix_ senf::emu::UDPClientHandle::Address senf::emu::EmulatedFrequencyRegistry::consoleGroup()
    const
{
    return group_;
}

prefix_ void
senf::emu::EmulatedFrequencyRegistry::consoleGroup(UDPClientHandle::Address const & group)
{
    group_ = group;
    /// FIXME: How to change the group address after entering the scheduler ??
    /// (need to change the address of a running socket)
}

prefix_ std::pair<senf::INet4Network, unsigned> senf::emu::EmulatedFrequencyRegistry::addressRange()
    const
{
    return std::make_pair(channelGroupRange_, portbase_);
}

prefix_ void senf::emu::EmulatedFrequencyRegistry::addressRange(INet4Network const & range,
                                                                unsigned portbase)
{
    channelGroupRange_ = range;
    portbase_ = portbase;
}

prefix_ void senf::emu::EmulatedFrequencyRegistry::nextAddress(unsigned index)
{
    lastAddress_ = index-1;
}

prefix_ void senf::emu::EmulatedFrequencyRegistry::collisionCallback(CollisionCallback cb)
{
    cb_ = cb;
}

prefix_ senf::emu::EmulatedFrequencyRegistry::EntriesRange
senf::emu::EmulatedFrequencyRegistry::entries()
    const
{
    return boost::make_iterator_range(
        entries_.get<ByFrequency>().begin(), entries_.get<ByFrequency>().end());
}

prefix_ senf::emu::EmulatedFrequencyRegistry::UsersRange
senf::emu::EmulatedFrequencyRegistry::users(EntriesRange::iterator i)
    const
{
    return senf::make_transform_range(users_.get<ByEntry>().equal_range(i), GetInterfaceId());
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::EmulatedWirelessInterface

prefix_ void senf::emu::EmulatedWirelessInterface::registerFrequency(unsigned frequency,
                                                                     unsigned bandwidth)
{
    interface().registerFrequency(frequency, bandwidth);
}

prefix_ void senf::emu::EmulatedWirelessInterface::registerFrequency(unsigned frequencyLower,
                                                                     unsigned frequencyUpper,
                                                                     unsigned bandwidthLower,
                                                                     unsigned bandwidthUpper)
{
    interface().registerFrequency(frequencyLower, frequencyUpper, bandwidthLower, bandwidthUpper);
}

prefix_ senf::emu::EmulatedWirelessInterface::EmulatedWirelessInterface()
    : frequency_ (0u), bandwidth_ (0u), index_ (0u), distanceCallback_()
{}

prefix_ unsigned senf::emu::EmulatedWirelessInterface::emulatedFrequency()
    const
{
    return frequency_;
}

prefix_ unsigned senf::emu::EmulatedWirelessInterface::emulatedBandwidth()
    const
{
    return bandwidth_;
}

prefix_ void senf::emu::EmulatedWirelessInterface::distanceCallback(DistanceCallback cb)
{
    distanceCallback_ = cb;
}
//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::EmulatedWirelessReceiver

prefix_ senf::emu::EmulatedWirelessReceiver::EmulatedWirelessReceiver()
    : receiverJack(filter_.output), filter_ (*this),
      rssiRandomnessRange_(0), noiseRandomnessRange_(0)
{
    ppi::connect(EmulatedReceiver::receiverJack, filter_);
}
//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::EmulatedWirelessTransmitter

prefix_ void senf::emu::EmulatedWirelessTransmitter::registerTxPower(int power)
{
    basei::interface().transmitter().registerTxPower(power);
}

prefix_ void senf::emu::EmulatedWirelessTransmitter::registerTxPower(int powerLow,
                                                                     int powerHigh)
{
    basei::interface().transmitter().registerTxPower(powerLow, powerHigh);
}

prefix_ senf::emu::EmulatedWirelessTransmitter::EmulatedWirelessTransmitter()
    : transmitterJack(filter_.input), filter_ (*this)
{
    ppi::connect(filter_, EmulatedTransmitter::transmitterJack);
}

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

prefix_ senf::emu::EmulatedFrequencyRegistry & senf::emu::emulatedFrequencyRegistry()
{
    return EmulatedFrequencyRegistry::instance();
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#undef prefix_


// 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: