length.cc

Go to the documentation of this file.

/*
 * Copyright (c) 2019 Lawrence Livermore National Laboratory
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Mathew Bielejeski <bielejeski1@llnl.gov>
 */
 
#include "ns3/length.h"
 
#include "ns3/log.h"
 
#include <algorithm>
#include <array>
#include <cctype>
#include <cmath>
#include <functional>
#include <limits>
#include <map>
#include <ratio>
#include <sstream>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <vector>
 
namespace
{
template <class R>
double
ScaleValue(double value)
{
    return (value * R::num) / static_cast<double>(R::den);
}
 
double
FootToMeter(double value)
{
    return value * 0.3048;
}
 
double
MeterToFoot(double value)
{
    return value * 3.28084;
}
 
template <class R>
double
USToMeter(double value)
{
    return FootToMeter(ScaleValue<R>(value));
}
 
template <class R>
double
MeterToUS(double value)
{
    return ScaleValue<R>(MeterToFoot(value));
}
 
double
Convert(double value, ns3::Length::Unit fromUnit, ns3::Length::Unit toUnit)
{
    using Unit = ns3::Length::Unit;
    using Key = std::pair<Unit, Unit>;
    using Conversion = std::function<double(double)>;
 
    struct KeyHash
    {
        std::size_t operator()(const Key& key) const noexcept
        {
            static_assert(sizeof(Unit) < sizeof(std::size_t),
                          "sizeof(Length::Unit) changed, it must be less than "
                          "sizeof(std::size_t)");
 
            int shift = sizeof(Unit) * 8;
            return static_cast<std::size_t>(key.first) << shift |
                   static_cast<std::size_t>(key.second);
        }
    };
 
    using ConversionTable = std::unordered_map<Key, Conversion, KeyHash>;
 
    static ConversionTable CONVERSIONS{
        {{Unit::Nanometer, Unit::Meter}, ScaleValue<std::nano>},
        {{Unit::Meter, Unit::Nanometer}, ScaleValue<std::giga>},
        {{Unit::Micrometer, Unit::Meter}, ScaleValue<std::micro>},
        {{Unit::Meter, Unit::Micrometer}, ScaleValue<std::mega>},
        {{Unit::Millimeter, Unit::Meter}, ScaleValue<std::milli>},
        {{Unit::Meter, Unit::Millimeter}, ScaleValue<std::kilo>},
        {{Unit::Centimeter, Unit::Meter}, ScaleValue<std::centi>},
        {{Unit::Meter, Unit::Centimeter}, ScaleValue<std::hecto>},
        {{Unit::Meter, Unit::Meter}, ScaleValue<std::ratio<1, 1>>},
        {{Unit::Kilometer, Unit::Meter}, ScaleValue<std::kilo>},
        {{Unit::Meter, Unit::Kilometer}, ScaleValue<std::milli>},
        {{Unit::NauticalMile, Unit::Meter}, ScaleValue<std::ratio<1852, 1>>},
        {{Unit::Meter, Unit::NauticalMile}, ScaleValue<std::ratio<1, 1852>>},
        {{Unit::Inch, Unit::Meter}, USToMeter<std::ratio<1, 12>>},
        {{Unit::Meter, Unit::Inch}, MeterToUS<std::ratio<12, 1>>},
        {{Unit::Foot, Unit::Meter}, FootToMeter},
        {{Unit::Meter, Unit::Foot}, MeterToFoot},
        {{Unit::Yard, Unit::Meter}, USToMeter<std::ratio<3, 1>>},
        {{Unit::Meter, Unit::Yard}, MeterToUS<std::ratio<1, 3>>},
        {{Unit::Mile, Unit::Meter}, USToMeter<std::ratio<5280, 1>>},
        {{Unit::Meter, Unit::Mile}, MeterToUS<std::ratio<1, 5280>>}};
 
    auto iter = CONVERSIONS.find(Key{fromUnit, toUnit});
 
    if (iter == CONVERSIONS.end())
    {
        NS_FATAL_ERROR("No conversion defined for " << fromUnit << " -> " << toUnit);
    }
 
    return iter->second(value);
}
 
double
Convert(const ns3::Length::Quantity& from, ns3::Length::Unit toUnit)
{
    return Convert(from.Value(), from.Unit(), toUnit);
}
 
class EnumHash
{
  public:
    std::size_t operator()(ns3::Length::Unit u) const noexcept
    {
        return static_cast<std::size_t>(u);
    }
};
 
} // unnamed namespace
 
namespace ns3
{
 
NS_LOG_COMPONENT_DEFINE("Length");
 
// Implement the attribute helper
ATTRIBUTE_HELPER_CPP(Length);
 
std::optional<Length>
Length::TryParse(double value, const std::string& unitString)
{
    NS_LOG_FUNCTION(value << unitString);
 
    auto unit = FromString(unitString);
 
    if (unit.has_value())
    {
        return Length(value, *unit);
    }
 
    return std::nullopt;
}
 
Length::Length()
    : m_value(0)
{
    NS_LOG_FUNCTION(this);
}
 
Length::Length(const std::string& input)
    : m_value(0)
{
    NS_LOG_FUNCTION(this << input);
 
    std::istringstream stream(input);
 
    stream >> *this;
}
 
Length::Length(double value, const std::string& unitString)
    : m_value(0)
{
    NS_LOG_FUNCTION(this << value << unitString);
 
    auto unit = FromString(unitString);
 
    if (!unit.has_value())
    {
        NS_FATAL_ERROR("A Length object could not be constructed from the unit "
                       "string '"
                       << unitString
                       << "', because the string is not associated "
                          "with a Length::Unit entry");
    }
 
    m_value = Convert(value, *unit, Length::Unit::Meter);
}
 
Length::Length(double value, Length::Unit unit)
    : m_value(0)
{
    NS_LOG_FUNCTION(this << value << unit);
 
    m_value = Convert(value, unit, Length::Unit::Meter);
}
 
Length::Length(Quantity quantity)
    : Length(quantity.Value(), quantity.Unit())
{
    NS_LOG_FUNCTION(this << quantity);
}
 
Length&
Length::operator=(const Length::Quantity& q)
{
    NS_LOG_FUNCTION(this << q);
 
    m_value = Convert(q, Length::Unit::Meter);
 
    return *this;
}
 
bool
Length::IsEqual(const Length& other, double tolerance /*=DEFAULT_TOLERANCE*/) const
{
    NS_LOG_FUNCTION(this << m_value << other.m_value << tolerance);
 
    if (m_value == other.m_value)
    {
        return true;
    }
 
    auto diff = std::abs(m_value - other.m_value);
 
    return diff <= tolerance;
}
 
bool
Length::IsNotEqual(const Length& other, double tolerance /*=DEFAULT_TOLERANCE*/) const
{
    NS_LOG_FUNCTION(this << m_value << other.m_value << tolerance);
 
    return !IsEqual(other, tolerance);
}
 
bool
Length::IsLess(const Length& other, double tolerance /*=DEFAULT_TOLERANCE*/) const
{
    NS_LOG_FUNCTION(this << m_value << other.m_value << tolerance);
 
    return m_value < other.m_value && IsNotEqual(other, tolerance);
}
 
bool
Length::IsLessOrEqual(const Length& other, double tolerance /*=DEFAULT_TOLERANCE*/) const
{
    NS_LOG_FUNCTION(this << m_value << other.m_value << tolerance);
 
    return m_value < other.m_value || IsEqual(other, tolerance);
}
 
bool
Length::IsGreater(const Length& other, double tolerance /*=DEFAULT_TOLERANCE*/) const
{
    NS_LOG_FUNCTION(this << m_value << other.m_value << tolerance);
 
    return !IsLessOrEqual(other, tolerance);
}
 
bool
Length::IsGreaterOrEqual(const Length& other, double tolerance /*=DEFAULT_TOLERANCE*/) const
{
    NS_LOG_FUNCTION(this << m_value << other.m_value << tolerance);
 
    return !IsLess(other, tolerance);
}
 
void
Length::swap(Length& other)
{
    using std::swap;
 
    swap(m_value, other.m_value);
}
 
double
Length::GetDouble() const
{
    return m_value;
}
 
Length::Quantity
Length::As(Length::Unit unit) const
{
    NS_LOG_FUNCTION(this << unit);
 
    double value = Convert(m_value, Length::Unit::Meter, unit);
 
    return Quantity(value, unit);
}
 
bool
operator==(const Length& left, const Length& right)
{
    return left.GetDouble() == right.GetDouble();
}
 
bool
operator!=(const Length& left, const Length& right)
{
    return left.GetDouble() != right.GetDouble();
}
 
bool
operator<(const Length& left, const Length& right)
{
    return left.GetDouble() < right.GetDouble();
}
 
bool
operator<=(const Length& left, const Length& right)
{
    return left.GetDouble() <= right.GetDouble();
}
 
bool
operator>(const Length& left, const Length& right)
{
    return left.GetDouble() > right.GetDouble();
}
 
bool
operator>=(const Length& left, const Length& right)
{
    return left.GetDouble() >= right.GetDouble();
}
 
Length
operator+(const Length& left, const Length& right)
{
    double value = left.GetDouble() + right.GetDouble();
    return Length(value, Length::Unit::Meter);
}
 
Length
operator-(const Length& left, const Length& right)
{
    double value = left.GetDouble() - right.GetDouble();
    return Length(value, Length::Unit::Meter);
}
 
Length
operator*(const Length& left, double scalar)
{
    double value = left.GetDouble() * scalar;
    return Length(value, Length::Unit::Meter);
}
 
Length
operator*(double scalar, const Length& right)
{
    return right * scalar;
}
 
Length
operator/(const Length& left, double scalar)
{
    if (scalar == 0)
    {
        NS_FATAL_ERROR("Attempted to divide Length by 0");
    }
 
    return left * (1.0 / scalar);
}
 
double
operator/(const Length& numerator, const Length& denominator)
{
    if (denominator.GetDouble() == 0)
    {
        return std::numeric_limits<double>::quiet_NaN();
    }
 
    return numerator.GetDouble() / denominator.GetDouble();
}
 
int64_t
Div(const Length& numerator, const Length& denominator, Length* remainder)
{
    double value = numerator / denominator;
 
    if (std::isnan(value))
    {
        NS_FATAL_ERROR("numerator / denominator return NaN");
    }
 
    if (remainder)
    {
        double rem = std::fmod(numerator.GetDouble(), denominator.GetDouble());
        *remainder = Length(rem, Length::Unit::Meter);
    }
 
    return static_cast<int64_t>(std::trunc(value));
}
 
Length
Mod(const Length& numerator, const Length& denominator)
{
    double rem = std::fmod(numerator.GetDouble(), denominator.GetDouble());
 
    if (std::isnan(rem))
    {
        NS_FATAL_ERROR("numerator / denominator return NaN");
    }
 
    return Length(rem, Length::Unit::Meter);
}
 
std::string
ToSymbol(Length::Unit unit)
{
    using StringTable = std::unordered_map<Length::Unit, std::string, EnumHash>;
 
    static const StringTable STRINGS{{Length::Unit::Nanometer, "nm"},
                                     {Length::Unit::Micrometer, "um"},
                                     {Length::Unit::Millimeter, "mm"},
                                     {Length::Unit::Centimeter, "cm"},
                                     {Length::Unit::Meter, "m"},
                                     {Length::Unit::Kilometer, "km"},
                                     {Length::Unit::NauticalMile, "nmi"},
                                     {Length::Unit::Inch, "in"},
                                     {Length::Unit::Foot, "ft"},
                                     {Length::Unit::Yard, "yd"},
                                     {Length::Unit::Mile, "mi"}};
 
    auto iter = STRINGS.find(unit);
 
    if (iter == STRINGS.end())
    {
        NS_FATAL_ERROR("A symbol could not be found for Length::Unit with value "
                       << EnumHash()(unit));
    }
 
    return iter->second;
}
 
std::string
ToName(Length::Unit unit, bool plural /*=false*/)
{
    using Entry = std::tuple<std::string, std::string>;
    using StringTable = std::unordered_map<Length::Unit, Entry, EnumHash>;
 
    static const StringTable STRINGS{
        {Length::Unit::Nanometer, Entry{"nanometer", "nanometers"}},
        {Length::Unit::Micrometer, Entry{"micrometer", "micrometer"}},
        {Length::Unit::Millimeter, Entry{"millimeter", "millimeters"}},
        {Length::Unit::Centimeter, Entry{"centimeter", "centimeters"}},
        {Length::Unit::Meter, Entry{"meter", "meters"}},
        {Length::Unit::Kilometer, Entry{"kilometer", "kilometers"}},
        {Length::Unit::NauticalMile, Entry{"nautical mile", "nautical miles"}},
        {Length::Unit::Inch, Entry{"inch", "inches"}},
        {Length::Unit::Foot, Entry{"foot", "feet"}},
        {Length::Unit::Yard, Entry{"yard", "yards"}},
        {Length::Unit::Mile, Entry{"mile", "miles"}}};
 
    auto iter = STRINGS.find(unit);
 
    if (iter == STRINGS.end())
    {
        NS_FATAL_ERROR("A symbol could not be found for Length::Unit with value "
                       << EnumHash()(unit));
    }
 
    if (plural)
    {
        return std::get<1>(iter->second);
    }
 
    return std::get<0>(iter->second);
}
 
std::optional<Length::Unit>
FromString(std::string unitString)
{
    using UnitTable = std::unordered_map<std::string, Length::Unit>;
 
    static const UnitTable UNITS{{"nm", Length::Unit::Nanometer},
                                 {"nanometer", Length::Unit::Nanometer},
                                 {"nanometers", Length::Unit::Nanometer},
                                 {"nanometre", Length::Unit::Nanometer},
                                 {"nanometres", Length::Unit::Nanometer},
                                 {"um", Length::Unit::Micrometer},
                                 {"micrometer", Length::Unit::Micrometer},
                                 {"micrometers", Length::Unit::Micrometer},
                                 {"micrometre", Length::Unit::Micrometer},
                                 {"micrometres", Length::Unit::Micrometer},
                                 {"mm", Length::Unit::Millimeter},
                                 {"millimeter", Length::Unit::Millimeter},
                                 {"millimeters", Length::Unit::Millimeter},
                                 {"millimetre", Length::Unit::Millimeter},
                                 {"millimetres", Length::Unit::Millimeter},
                                 {"cm", Length::Unit::Centimeter},
                                 {"centimeter", Length::Unit::Centimeter},
                                 {"centimeters", Length::Unit::Centimeter},
                                 {"centimetre", Length::Unit::Centimeter},
                                 {"centimetres", Length::Unit::Centimeter},
                                 {"m", Length::Unit::Meter},
                                 {"meter", Length::Unit::Meter},
                                 {"metre", Length::Unit::Meter},
                                 {"meters", Length::Unit::Meter},
                                 {"metres", Length::Unit::Meter},
                                 {"km", Length::Unit::Kilometer},
                                 {"kilometer", Length::Unit::Kilometer},
                                 {"kilometers", Length::Unit::Kilometer},
                                 {"kilometre", Length::Unit::Kilometer},
                                 {"kilometres", Length::Unit::Kilometer},
                                 {"nmi", Length::Unit::NauticalMile},
                                 {"nauticalmile", Length::Unit::NauticalMile},
                                 {"nauticalmiles", Length::Unit::NauticalMile},
                                 {"in", Length::Unit::Inch},
                                 {"inch", Length::Unit::Inch},
                                 {"inches", Length::Unit::Inch},
                                 {"ft", Length::Unit::Foot},
                                 {"foot", Length::Unit::Foot},
                                 {"feet", Length::Unit::Foot},
                                 {"yd", Length::Unit::Yard},
                                 {"yard", Length::Unit::Yard},
                                 {"yards", Length::Unit::Yard},
                                 {"mi", Length::Unit::Mile},
                                 {"mile", Length::Unit::Mile},
                                 {"miles", Length::Unit::Mile}};
 
    // function to trim whitespace and convert to lowercase in one pass
    static auto Normalize = [](const std::string& str) {
        std::string output;
        output.reserve(str.size());
 
        for (unsigned char c : str)
        {
            // this strips all spaces not just beg/end but is fine for our purposes
            if (std::isspace(c))
            {
                continue;
            }
 
            output.push_back(std::tolower(c));
        }
 
        return output;
    };
 
    unitString = Normalize(unitString);
 
    auto iter = UNITS.find(unitString);
 
    if (iter != UNITS.end())
    {
        return iter->second;
    }
 
    return std::nullopt;
}
 
std::ostream&
operator<<(std::ostream& stream, const Length& l)
{
    stream << l.As(Length::Unit::Meter);
 
    return stream;
}
 
std::ostream&
operator<<(std::ostream& stream, const Length::Quantity& q)
{
    stream << q.Value() << ' ' << ToSymbol(q.Unit());
 
    return stream;
}
 
std::ostream&
operator<<(std::ostream& stream, Length::Unit unit)
{
    stream << ToName(unit);
 
    return stream;
}
 
std::tuple<bool, double, std::string>
ParseLengthString(const std::string& input)
{
    NS_LOG_FUNCTION(input);
 
    double value = 0;
    std::size_t pos = 0;
    std::string symbol;
 
    try
    {
        value = std::stod(input, &pos);
    }
    catch (const std::exception& e)
    {
        NS_LOG_ERROR("Caught exception while parsing double: " << e.what());
 
        return std::make_tuple(false, 0, "");
    }
 
    // skip any whitespace between value and symbol
    while (pos < input.size() && std::isspace(input[pos]))
    {
        ++pos;
    }
 
    if (pos < input.size())
    {
        NS_LOG_LOGIC("String has value and symbol, extracting symbol");
 
        // input has a double followed by a string
        symbol = input.substr(pos);
    }
 
    return std::make_tuple(true, value, symbol);
}
 
std::istream&
operator>>(std::istream& stream, Length& l)
{
    bool success = false;
    double value = 0;
    std::string symbol;
    std::string temp;
 
    // configure stream to skip whitespace in case it was disabled
    auto origFlags = stream.flags();
    std::skipws(stream);
 
    // Read the contents into a temporary string and parse it manually
    stream >> temp;
 
    std::tie(success, value, symbol) = ParseLengthString(temp);
 
    if (success && symbol.empty())
    {
        NS_LOG_LOGIC("Temp string only contained value, extracting unit symbol from stream");
 
        // temp only contained the double
        // still need to read the symbol from the stream
        stream >> symbol;
    }
 
    // special handling for nautical mile which is two words
    if (symbol == "nautical")
    {
        stream >> temp;
 
        if (!temp.empty())
        {
            symbol.push_back(' ');
            symbol.append(temp);
        }
    }
 
    Length(value, symbol).swap(l);
 
    // restore original flags
    stream.flags(origFlags);
 
    return stream;
}
 
Length
NanoMeters(double value)
{
    return Length(value, Length::Unit::Nanometer);
}
 
Length
MicroMeters(double value)
{
    return Length(value, Length::Unit::Micrometer);
}
 
Length
MilliMeters(double value)
{
    return Length(value, Length::Unit::Millimeter);
}
 
Length
CentiMeters(double value)
{
    return Length(value, Length::Unit::Centimeter);
}
 
Length
Meters(double value)
{
    return Length(value, Length::Unit::Meter);
}
 
Length
KiloMeters(double value)
{
    return Length(value, Length::Unit::Kilometer);
}
 
Length
NauticalMiles(double value)
{
    return Length(value, Length::Unit::NauticalMile);
}
 
Length
Inches(double value)
{
    return Length(value, Length::Unit::Inch);
}
 
Length
Feet(double value)
{
    return Length(value, Length::Unit::Foot);
}
 
Length
Yards(double value)
{
    return Length(value, Length::Unit::Yard);
}
 
Length
Miles(double value)
{
    return Length(value, Length::Unit::Mile);
}
 
} // namespace ns3