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& other) = default;
 
    Quantity& operator= (Quantity&& other) = 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& left, const Length& right);
 
bool operator< (const Length& left, const Length& right);
 
bool operator<= (const Length& left, const Length& right);
 
bool operator> (const Length& left, const Length& right);
 
bool operator>= (const Length& left, const Length& right);
 
Length operator+ (const Length& left, const Length& right);
 
Length operator- (const Length& left, const Length& right);
 
Length operator* (double scalar, const Length& l);
Length operator* (const Length& l, 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_ */