ECEFCoordinate.hpp

Go to the documentation of this file.

/*
 * ----------------- BEGIN LICENSE BLOCK ---------------------------------
 *
 * Copyright (C) 2018-2020 Intel Corporation
 *
 * SPDX-License-Identifier: MIT
 *
 * ----------------- END LICENSE BLOCK -----------------------------------
 */
 
#pragma once
 
#include <cmath>
#include <iostream>
#include <limits>
#include <sstream>
#include <stdexcept>
#include "spdlog/fmt/ostr.h"
#include "spdlog/spdlog.h"
namespace ad {
namespace map {
namespace point {
 
#define AD_MAP_POINT_ECEFCOORDINATE_THROWS_EXCEPTION 1
 
#if SAFE_DATATYPES_EXPLICIT_CONVERSION
 
#define _AD_MAP_POINT_ECEFCOORDINATE_EXPLICIT_CONVERSION_ explicit
#else
 
#define _AD_MAP_POINT_ECEFCOORDINATE_EXPLICIT_CONVERSION_
#endif
 
class ECEFCoordinate
{
public:
  static const double cMinValue;
 
  static const double cMaxValue;
 
  static const double cPrecisionValue;
 
  ECEFCoordinate()
    : mECEFCoordinate(std::numeric_limits<double>::quiet_NaN())
  {
  }
 
  _AD_MAP_POINT_ECEFCOORDINATE_EXPLICIT_CONVERSION_ ECEFCoordinate(double const iECEFCoordinate)
    : mECEFCoordinate(iECEFCoordinate)
  {
  }
 
  ECEFCoordinate(const ECEFCoordinate &other) = default;
 
  ECEFCoordinate(ECEFCoordinate &&other) = default;
 
  ECEFCoordinate &operator=(const ECEFCoordinate &other) = default;
 
  ECEFCoordinate &operator=(ECEFCoordinate &&other) = default;
 
  bool operator==(const ECEFCoordinate &other) const
  {
    ensureValid();
    other.ensureValid();
    return std::fabs(mECEFCoordinate - other.mECEFCoordinate) < cPrecisionValue;
  }
 
  bool operator!=(const ECEFCoordinate &other) const
  {
    return !operator==(other);
  }
 
  bool operator>(const ECEFCoordinate &other) const
  {
    ensureValid();
    other.ensureValid();
    return (mECEFCoordinate > other.mECEFCoordinate) && operator!=(other);
  }
 
  bool operator<(const ECEFCoordinate &other) const
  {
    ensureValid();
    other.ensureValid();
    return (mECEFCoordinate < other.mECEFCoordinate) && operator!=(other);
  }
 
  bool operator>=(const ECEFCoordinate &other) const
  {
    ensureValid();
    other.ensureValid();
    return ((mECEFCoordinate > other.mECEFCoordinate) || operator==(other));
  }
 
  bool operator<=(const ECEFCoordinate &other) const
  {
    ensureValid();
    other.ensureValid();
    return ((mECEFCoordinate < other.mECEFCoordinate) || operator==(other));
  }
 
  ECEFCoordinate operator+(const ECEFCoordinate &other) const
  {
    ensureValid();
    other.ensureValid();
    ECEFCoordinate const result(mECEFCoordinate + other.mECEFCoordinate);
    result.ensureValid();
    return result;
  }
 
  ECEFCoordinate &operator+=(const ECEFCoordinate &other)
  {
    ensureValid();
    other.ensureValid();
    mECEFCoordinate += other.mECEFCoordinate;
    ensureValid();
    return *this;
  }
 
  ECEFCoordinate operator-(const ECEFCoordinate &other) const
  {
    ensureValid();
    other.ensureValid();
    ECEFCoordinate const result(mECEFCoordinate - other.mECEFCoordinate);
    result.ensureValid();
    return result;
  }
 
  ECEFCoordinate operator-=(const ECEFCoordinate &other)
  {
    ensureValid();
    other.ensureValid();
    mECEFCoordinate -= other.mECEFCoordinate;
    ensureValid();
    return *this;
  }
 
  ECEFCoordinate operator*(const double &scalar) const
  {
    ensureValid();
    ECEFCoordinate const result(mECEFCoordinate * scalar);
    result.ensureValid();
    return result;
  }
 
  ECEFCoordinate operator/(const double &scalar) const
  {
    ECEFCoordinate const scalarECEFCoordinate(scalar);
    ECEFCoordinate const result(operator/(scalarECEFCoordinate));
    result.ensureValid();
    return result;
  }
 
  double operator/(const ECEFCoordinate &other) const
  {
    ensureValid();
    other.ensureValidNonZero();
    double const result = mECEFCoordinate / other.mECEFCoordinate;
    return result;
  }
 
  ECEFCoordinate operator-() const
  {
    ensureValid();
    ECEFCoordinate const result(-mECEFCoordinate);
    result.ensureValid(); // LCOV_EXCL_BR_LINE Some types do not throw an exception
    return result;
  }
 
  _AD_MAP_POINT_ECEFCOORDINATE_EXPLICIT_CONVERSION_ operator double() const
  {
    return mECEFCoordinate;
  }
 
  bool isValid() const
  {
    auto const valueClass = std::fpclassify(mECEFCoordinate);
    return ((valueClass == FP_NORMAL) || (valueClass == FP_ZERO)) && (cMinValue <= mECEFCoordinate)
      && (mECEFCoordinate <= cMaxValue);
  }
 
  void ensureValid() const
  {
    if (!isValid())
    {
      spdlog::info("ensureValid(::ad::map::point::ECEFCoordinate)>> {} value out of range", *this); // LCOV_EXCL_BR_LINE
#if (AD_MAP_POINT_ECEFCOORDINATE_THROWS_EXCEPTION == 1)
      throw std::out_of_range("ECEFCoordinate value out of range"); // LCOV_EXCL_BR_LINE
#endif
    }
  }
 
  void ensureValidNonZero() const
  {
    ensureValid();
    if (operator==(ECEFCoordinate(0.))) // LCOV_EXCL_BR_LINE
    {
      spdlog::info("ensureValid(::ad::map::point::ECEFCoordinate)>> {} value is zero", *this); // LCOV_EXCL_BR_LINE
#if (AD_MAP_POINT_ECEFCOORDINATE_THROWS_EXCEPTION == 1)
      throw std::out_of_range("ECEFCoordinate value is zero"); // LCOV_EXCL_BR_LINE
#endif
    }
  }
 
  static ECEFCoordinate getMin()
  {
    return ECEFCoordinate(cMinValue);
  }
 
  static ECEFCoordinate getMax()
  {
    return ECEFCoordinate(cMaxValue);
  }
 
  static ECEFCoordinate getPrecision()
  {
    return ECEFCoordinate(cPrecisionValue);
  }
 
private:
  double mECEFCoordinate;
};
 
} // namespace point
} // namespace map
} // namespace ad
inline ::ad::map::point::ECEFCoordinate operator*(const double &other, ::ad::map::point::ECEFCoordinate const &value)
{
  return value.operator*(other);
}
 
namespace std {
 
inline ::ad::map::point::ECEFCoordinate fabs(const ::ad::map::point::ECEFCoordinate other)
{
  ::ad::map::point::ECEFCoordinate const result(std::fabs(static_cast<double>(other)));
  return result;
}
 
template <> class numeric_limits<::ad::map::point::ECEFCoordinate> : public numeric_limits<double>
{
public:
  static inline ::ad::map::point::ECEFCoordinate lowest()
  {
    return ::ad::map::point::ECEFCoordinate::getMin();
  }
  static inline ::ad::map::point::ECEFCoordinate max()
  {
    return ::ad::map::point::ECEFCoordinate::getMax();
  }
 
  static inline ::ad::map::point::ECEFCoordinate epsilon()
  {
    return ::ad::map::point::ECEFCoordinate::getPrecision();
  }
};
 
} // namespace std
 
#ifndef GEN_GUARD_AD_MAP_POINT_ECEFCOORDINATE
#define GEN_GUARD_AD_MAP_POINT_ECEFCOORDINATE
 
namespace ad {
namespace map {
namespace point {
 
inline std::ostream &operator<<(std::ostream &os, ECEFCoordinate const &_value)
{
  return os << double(_value);
}
 
} // namespace point
} // namespace map
} // namespace ad
 
namespace std {
inline std::string to_string(::ad::map::point::ECEFCoordinate const &value)
{
  return to_string(static_cast<double>(value));
}
} // namespace std
#endif // GEN_GUARD_AD_MAP_POINT_ECEFCOORDINATE