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

//#include "Annotations.ih"

// Custom includes

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

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

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

prefix_ senf::emu::annotations::Interface::Interface(MACAddress const & v)
    : value (v)
{}

prefix_ bool senf::emu::annotations::Interface::operator<(Interface const & other)
    const
{
    return value < other.value;
}

prefix_ bool senf::emu::annotations::Interface::operator==(Interface const & other)
    const
{
    return value == other.value;
}

prefix_ std::ostream & senf::emu::annotations::operator<<(std::ostream & os, Interface const & annotation)
{
    os << annotation.value;
    return os;
}

prefix_ std::size_t senf::emu::annotations::hash_value(Interface const & annotation) noexcept
{
    return senf::hash_value(annotation.value);
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::annotations::Quality

prefix_ senf::emu::annotations::Quality::Quality()
{
    memset(this, 0, sizeof(*this));
}
/*
prefix_ bool senf::emu::annotations::Quality::operator<(Quality const & other)
    const
{
    return (snr < other.snr || (snr == other.snr && (rssi < other.rssi)));
}
*/
prefix_ void senf::emu::annotations::Quality::setLoss(unsigned loss)
{
    flags.framePredecessorLost = std::min(255u, loss); 
}

prefix_ std::ostream & senf::emu::annotations::operator<<(std::ostream & os,
                                                          Quality const & annotation)
{
    os << "(snr:" << annotation.snr
       << " rssi:" << annotation.rssi
       << " noise:" << annotation.noise
       << " airTime:" << annotation.airTime
       << " flags:" << annotation.flags.frameCorrupt << "," << annotation.flags.frameRetransmitted 
       << "," << annotation.flags.frameDuplicate << "," << annotation.flags.frameReordered
       << "," << annotation.flags.frameAggregated
       << "," << annotation.flags.framePredecessorLost << "," << annotation.flags.frameLength
       << ")";
    return os;
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::annotations::Timestamp

prefix_ senf::emu::annotations::Timestamp::Timestamp()
{
}

prefix_ bool senf::emu::annotations::Timestamp::operator<(Timestamp const & other)
    const
{
    return as_clock_type() < other.as_clock_type();
}

prefix_ std::ostream & senf::emu::annotations::operator<<(std::ostream & os,
                                                          Timestamp const & annotation)
{
    os << ClockService::abstime(annotation.as_clock_type());
    return os;
}

prefix_ senf::emu::annotations::Timestamp & senf::emu::annotations::Timestamp::operator=(Timestamp const & other)
{
    ::memcpy(timestamp, other.timestamp, sizeof(timestamp));
    return *this;
}

prefix_ void senf::emu::annotations::Timestamp::fromScheduler()
    const
{
    timestamp[0]= ClockService::in_seconds(scheduler::now());
    timestamp[1]= ClockService::in_nanoseconds(scheduler::now()) % 1000000000ull;
}

prefix_ void senf::emu::annotations::Timestamp::fromSocketProtocol(senf::DatagramSocketProtocol const & protocol)
    const
{
    struct timespec spec;
    protocol.timestamp(&spec);
    timestamp[0]= spec.tv_sec;
    timestamp[1]= spec.tv_nsec;
}

prefix_ void senf::emu::annotations::Timestamp::fromQueueBuffer(senf::SocketQueueBuffer const & buffer)
    const
{
    ::memcpy(timestamp, buffer.timestampPtr(), sizeof(timestamp));
}

prefix_ void senf::emu::annotations::Timestamp::fromWallClock()
    const
{
    struct timespec spec;
    clock_gettime(CLOCK_REALTIME_COARSE, &spec);
    timestamp[0]= spec.tv_sec;
    timestamp[1]= spec.tv_nsec;
}

prefix_ senf::ClockService::clock_type senf::emu::annotations::Timestamp::as_clock_type() 
    const
{
    return ClockService::from_time_t(timestamp[0]) + ClockService::nanoseconds(timestamp[1]);
}

prefix_ std::uint32_t senf::emu::annotations::Timestamp::as_milli_seconds(std::uint32_t modulo) 
    const
{
    return ((timestamp[0] * 1000) + (timestamp[1] / 1000000)) % modulo;
}


//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::emu::annotations::WirelessModulation

prefix_ senf::emu::annotations::WirelessModulation::WirelessModulation()
    : id(0)
{}

prefix_ bool senf::emu::annotations::WirelessModulation::operator<(WirelessModulation const & other)
    const
{
    return id < other.id;
}

prefix_ std::ostream & senf::emu::annotations::operator<<(std::ostream & os, WirelessModulation const & annotation)
{
    os << annotation.id;
    return os;
}

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