InterfaceAPI.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 InterfaceAPI inline non-template implementation */

#include <senf/Utils/String.hh>
#include "InterfaceAPI.ih"

// Custom includes

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

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::Interface

prefix_ senf::emu::Interface::~Interface()
{
    try {
        // can't call id() anymore, as this would call v_id()
        console::provideDirectory(interfaceDir(),"by-id").remove(senf::str(id_));
    } catch (...) {};
}

prefix_ bool senf::emu::Interface::canTransmit()
    const
{
    try {
        return dynamic_cast<Transmitter const *>(this);
    }
    SENF_WRAP_EXC(std::bad_cast)
}

prefix_ bool senf::emu::Interface::canReceive()
    const
{
    try {
        return dynamic_cast<Receiver const *>(this);
    }
    SENF_WRAP_EXC(std::bad_cast)
}

prefix_ void senf::emu::Interface::enable()
{
    v_enable();
}

prefix_ void senf::emu::Interface::disable()
{
    v_disable();
}

prefix_ bool senf::emu::Interface::enabled()
    const
{
    return v_enabled();
}

prefix_ senf::MACAddress const & senf::emu::Interface::id()
    const
{
    return id_ = v_id();
}

prefix_ unsigned senf::emu::Interface::index()
    const
{
    return index_;
}

prefix_ unsigned senf::emu::Interface::nodeId()
{
    return nodeId_;
}

prefix_ void senf::emu::Interface::nodeId(unsigned id)
{
    nodeId_ = id;
}

prefix_ void senf::emu::Interface::deviceId(InterfaceDeviceId id)
{
    deviceId_ = id;
}

prefix_ senf::emu::InterfaceDeviceId senf::emu::Interface::deviceId()
    const
{
    return deviceId_;
}

prefix_ boost::uint8_t senf::emu::Interface::linkTypeId()
    const
{
    return v_linkTypeId();
}

prefix_ std::string const & senf::emu::Interface::device()
    const
{
    return v_device();
}

prefix_ senf::console::DirectoryNode & senf::emu::Interface::consoleDir()
    const
{
    return consoleDir_.node();
}

prefix_ senf::console::DirectoryNode & senf::emu::Interface::statisticsDir()
    const
{
    return consoleDir()["stats"];
}

prefix_ senf::emu::Interface::Interface()
{}

prefix_ std::string senf::emu::Interface::interfaceTypeName()
    const
{
    return senf::prettyName(typeid(*const_cast<Interface*>(this)));
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::Receiver

prefix_ senf::emu::Receiver::~Receiver()
{}

prefix_ bool senf::emu::Receiver::annotationMode()
    const
{
    return v_annotationMode();
}

prefix_ void senf::emu::Receiver::annotationMode(bool v)
{
    v_annotationMode(v);
}

prefix_ bool senf::emu::Receiver::promisc()
    const
{
    return v_promisc();
}

prefix_ void senf::emu::Receiver::promisc(bool v)
{
    v_promisc(v);
}

prefix_ void senf::emu::Receiver::flushRxQueues()
{
    v_flushRxQueues();
}

prefix_ void senf::emu::Receiver::mcAdd(MACAddress const & address)
{
    v_mcAdd(address);
}

prefix_ void senf::emu::Receiver::mcDrop(MACAddress const & address)
{
    v_mcDrop(address);
}

prefix_ senf::emu::Receiver::Receiver(ppi::connector::ActiveOutput<> & output)
    : output (output)
{}

prefix_ senf::emu::Receiver::
Receiver(ppi::connector::ActiveOutput<EthernetPacket> & output)
    : output (output)
{}

prefix_ senf::emu::Receiver::Receiver(ppi::connector::ActiveOutputJack<> & output)
    : output (output)
{}

prefix_ senf::emu::Receiver::
Receiver(ppi::connector::ActiveOutputJack<EthernetPacket> & output)
    : output (output)
{}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::Transmitter

prefix_ senf::emu::Transmitter::~Transmitter()
{}

prefix_ unsigned senf::emu::Transmitter::mtu()
    const
{
    return v_mtu();
}

prefix_ void senf::emu::Transmitter::mtu(unsigned v)
{
    v_mtu(v);
}

prefix_ void senf::emu::Transmitter::flushTxQueues()
{
    v_flushTxQueues();
}

prefix_ senf::emu::Transmitter::Transmitter(ppi::connector::PassiveInput<> & input)
    : input (input)
{}

prefix_ senf::emu::Transmitter::
Transmitter(ppi::connector::PassiveInput<EthernetPacket> & input)
    : input (input)
{}

prefix_ senf::emu::Transmitter::Transmitter(ppi::connector::PassiveInputJack<> & input)
    : input (input)
{}

prefix_ senf::emu::Transmitter::
Transmitter(ppi::connector::PassiveInputJack<EthernetPacket> & input)
    : input (input)
{}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::WiredReceiver

prefix_
senf::emu::WiredReceiver::WiredReceiver(ppi::connector::ActiveOutput<> & output)
    : Receiver (output)
{}

prefix_ senf::emu::WiredReceiver::
WiredReceiver(ppi::connector::ActiveOutput<EthernetPacket> & output)
    : Receiver (output)
{}

prefix_ senf::emu::WiredReceiver::
WiredReceiver(ppi::connector::ActiveOutputJack<> & output)
    : Receiver (output)
{}

prefix_ senf::emu::WiredReceiver::
WiredReceiver(ppi::connector::ActiveOutputJack<EthernetPacket> & output)
    : Receiver (output)
{}

prefix_ void senf::emu::WiredReceiver::init()
{
    Receiver::init();
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::WiredInterface

prefix_ void senf::emu::WiredInterface::init()
{
    Interface::init();
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::WiredTransmitter
prefix_ senf::emu::WiredTransmitter::
WiredTransmitter(ppi::connector::PassiveInput<> & input)
    : Transmitter (input)
{}

prefix_ senf::emu::WiredTransmitter::
WiredTransmitter(ppi::connector::PassiveInput<EthernetPacket> & input)
    : Transmitter (input)
{}

prefix_ senf::emu::WiredTransmitter::
WiredTransmitter(ppi::connector::PassiveInputJack<> & input)
    : Transmitter (input)
{}

prefix_ senf::emu::WiredTransmitter::
WiredTransmitter(ppi::connector::PassiveInputJack<EthernetPacket> & input)
    : Transmitter (input)
{}

prefix_ void senf::emu::WiredTransmitter::init()
{
    Transmitter::init();
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::HardwareInterface

prefix_ void senf::emu::HardwareInterface::init()
{}

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