length.h

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * 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>
 */

#ifndef NS3_LENGTH_H_
#define NS3_LENGTH_H_

#include "attribute.h"
#include "attribute-helper.h"

#ifdef HAVE_BOOST
#include <boost/units/quantity.hpp>
#include <boost/units/systems/si.hpp>
#endif

#include <istream>
#include <limits>
#include <ostream>
#include <string>
#include <tuple>

namespace ns3 {

class Length
{
public:
  enum Unit : uint16_t
  {
    //Metric Units
    Nanometer = 1,  
    Micrometer,     
    Millimeter,     
    Centimeter,     
    Meter,          
    Kilometer,      
    NauticalMile,   

    //US Customary Units
    Inch,           
    Foot,           
    Yard,           
    Mile            
  };

  class Quantity
  {
public:
    Quantity (double value, Length::Unit unit)
      : m_value (value),
        m_unit (unit)
    { }

    Quantity (const Quantity&) = default;

    Quantity (Quantity&&) = default;

    ~Quantity () = default;

    Quantity& operator= (const Quantity&) = default;

    Quantity& operator= (Quantity&&) = default;

    double Value () const
    {
      return m_value;
    }

    Length::Unit Unit () const
    {
      return m_unit;
    }

private:
    double m_value;         
    Length::Unit m_unit;    
  };

  static constexpr double DEFAULT_TOLERANCE = std::numeric_limits<double>::epsilon ();

  static std::tuple<bool, Length> TryParse (double value, const std::string& unit);

  Length ();

  Length (const std::string& text);

  Length (double value, const std::string& unit);

  Length (double value, Length::Unit unit);

  Length (Quantity quantity);

#ifdef HAVE_BOOST_UNITS

  template <class U, class T>
  explicit Length (boost::units::quantity<U, T> quantity);
#endif

  Length (const Length& other) = default;

  Length (Length&& other) = default;

  ~Length () = default;

  Length& operator= (const Length& other) = default;

  Length& operator= (Length&& other) = default;

  Length& operator= (const Length::Quantity& q);

  bool IsEqual (const Length& other, double tolerance = DEFAULT_TOLERANCE) const;

  bool IsNotEqual (const Length& other, double tolerance = DEFAULT_TOLERANCE) const;

  bool IsLess (const Length& other, double tolerance = DEFAULT_TOLERANCE) const;

  bool IsLessOrEqual (const Length& other, double tolerance = DEFAULT_TOLERANCE) const;

  bool IsGreater (const Length& other, double tolerance = DEFAULT_TOLERANCE) const;

  bool IsGreaterOrEqual (const Length& other, double tolerance = DEFAULT_TOLERANCE) const;

  void swap (Length& other);

  double GetDouble () const;

  Quantity As (Unit unit) const;

private:
  double m_value;      
};  // class Length

ATTRIBUTE_HELPER_HEADER (Length);

std::string ToSymbol (Length::Unit unit);

std::string ToName (Length::Unit unit, bool plural = false);

std::tuple<bool, Length::Unit> FromString (std::string unitString);

std::ostream& operator<< (std::ostream& stream, const Length& l);

std::ostream& operator<< (std::ostream& stream, const Length::Quantity& q);

std::ostream& operator<< (std::ostream& stream, Length::Unit unit);

std::istream& operator>> (std::istream& stream, Length& l);

bool operator== (const Length& left, const Length& right);

bool operator!= (const Length& l, const Length& r);

bool operator< (const Length& l, const Length& r);

bool operator<= (const Length& l, const Length& r);

bool operator> (const Length& l, const Length& r);

bool operator>= (const Length& l, const Length& r);

Length operator+ (const Length& first, const Length& second);

Length operator- (const Length& first, const Length& second);

Length operator* (double scalar, const Length& right);

Length operator* (const Length& left, double scalar);

Length operator/ (const Length& left, double scalar);

double operator/ (const Length& numerator, const Length& denominator);

int64_t Div (const Length& numerator, const Length& denominator, Length* remainder = nullptr);

Length Mod (const Length& numerator, const Length& denominator);

Length NanoMeters (double value);

Length MicroMeters (double value);

Length MilliMeters (double value);

Length CentiMeters (double value);

Length Meters (double value);

Length KiloMeters (double value);

Length NauticalMiles (double value);

Length Inches (double value);

Length Feet (double value);

Length Yards (double value);

Length Miles (double value);
#ifdef HAVE_BOOST_UNITS
template <class U, class T>
Length::Length (boost::units::quantity<U, T> quantity)
  :   m_value (0)
{
  namespace bu = boost::units;
  using BoostMeters = bu::quantity<bu::si::length, double>;

  //convert value to meters
  m_value = static_cast<BoostMeters> (quantity).value ();
}
#endif

}  // namespace ns3

#endif  /* NS3_LENGTH_H_ */