LandmarkId.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 <cstdint>
#include <iostream>
#include <limits>
#include <sstream>
#include <stdexcept>
#include "spdlog/fmt/ostr.h"
#include "spdlog/spdlog.h"
namespace ad {
namespace map {
namespace landmark {
 
#define AD_MAP_LANDMARK_LANDMARKID_THROWS_EXCEPTION 1
 
#if SAFE_DATATYPES_EXPLICIT_CONVERSION
 
#define _AD_MAP_LANDMARK_LANDMARKID_EXPLICIT_CONVERSION_ explicit
#else
 
#define _AD_MAP_LANDMARK_LANDMARKID_EXPLICIT_CONVERSION_
#endif
 
class LandmarkId
{
public:
  static const uint64_t cMinValue;
 
  static const uint64_t cMaxValue;
 
  LandmarkId()
    : mLandmarkId(std::numeric_limits<uint64_t>::quiet_NaN())
  {
  }
 
  _AD_MAP_LANDMARK_LANDMARKID_EXPLICIT_CONVERSION_ LandmarkId(uint64_t const iLandmarkId)
    : mLandmarkId(iLandmarkId)
  {
  }
 
  LandmarkId(const LandmarkId &other) = default;
 
  LandmarkId(LandmarkId &&other) = default;
 
  LandmarkId &operator=(const LandmarkId &other) = default;
 
  LandmarkId &operator=(LandmarkId &&other) = default;
 
  bool operator==(const LandmarkId &other) const
  {
    ensureValid();
    other.ensureValid();
    return mLandmarkId == other.mLandmarkId;
  }
 
  bool operator!=(const LandmarkId &other) const
  {
    return !operator==(other);
  }
 
  bool operator>(const LandmarkId &other) const
  {
    ensureValid();
    other.ensureValid();
    return (mLandmarkId > other.mLandmarkId) && operator!=(other);
  }
 
  bool operator<(const LandmarkId &other) const
  {
    ensureValid();
    other.ensureValid();
    return (mLandmarkId < other.mLandmarkId) && operator!=(other);
  }
 
  bool operator>=(const LandmarkId &other) const
  {
    ensureValid();
    other.ensureValid();
    return ((mLandmarkId > other.mLandmarkId) || operator==(other));
  }
 
  bool operator<=(const LandmarkId &other) const
  {
    ensureValid();
    other.ensureValid();
    return ((mLandmarkId < other.mLandmarkId) || operator==(other));
  }
 
  LandmarkId operator+(const LandmarkId &other) const
  {
    ensureValid();
    other.ensureValid();
    LandmarkId const result(mLandmarkId + other.mLandmarkId);
    result.ensureValid();
    return result;
  }
 
  LandmarkId &operator+=(const LandmarkId &other)
  {
    ensureValid();
    other.ensureValid();
    mLandmarkId += other.mLandmarkId;
    ensureValid();
    return *this;
  }
 
  LandmarkId operator-(const LandmarkId &other) const
  {
    ensureValid();
    other.ensureValid();
    LandmarkId const result(mLandmarkId - other.mLandmarkId);
    result.ensureValid();
    return result;
  }
 
  LandmarkId operator-=(const LandmarkId &other)
  {
    ensureValid();
    other.ensureValid();
    mLandmarkId -= other.mLandmarkId;
    ensureValid();
    return *this;
  }
 
  _AD_MAP_LANDMARK_LANDMARKID_EXPLICIT_CONVERSION_ operator uint64_t() const
  {
    return mLandmarkId;
  }
 
  bool isValid() const
  {
    auto const valueClass = std::fpclassify(mLandmarkId);
    return ((valueClass == FP_NORMAL) || (valueClass == FP_ZERO)) && (cMinValue <= mLandmarkId)
      && (mLandmarkId <= cMaxValue);
  }
 
  void ensureValid() const
  {
    if (!isValid())
    {
      spdlog::info("ensureValid(::ad::map::landmark::LandmarkId)>> {} value out of range", *this); // LCOV_EXCL_BR_LINE
#if (AD_MAP_LANDMARK_LANDMARKID_THROWS_EXCEPTION == 1)
      throw std::out_of_range("LandmarkId value out of range"); // LCOV_EXCL_BR_LINE
#endif
    }
  }
 
  void ensureValidNonZero() const
  {
    ensureValid();
    if (operator==(LandmarkId(0))) // LCOV_EXCL_BR_LINE
    {
      spdlog::info("ensureValid(::ad::map::landmark::LandmarkId)>> {} value is zero", *this); // LCOV_EXCL_BR_LINE
#if (AD_MAP_LANDMARK_LANDMARKID_THROWS_EXCEPTION == 1)
      throw std::out_of_range("LandmarkId value is zero"); // LCOV_EXCL_BR_LINE
#endif
    }
  }
 
  static LandmarkId getMin()
  {
    return LandmarkId(cMinValue);
  }
 
  static LandmarkId getMax()
  {
    return LandmarkId(cMaxValue);
  }
 
private:
  uint64_t mLandmarkId;
};
 
} // namespace landmark
} // namespace map
} // namespace ad
namespace std {
 
template <> class numeric_limits<::ad::map::landmark::LandmarkId> : public numeric_limits<uint64_t>
{
public:
  static inline ::ad::map::landmark::LandmarkId lowest()
  {
    return ::ad::map::landmark::LandmarkId::getMin();
  }
  static inline ::ad::map::landmark::LandmarkId max()
  {
    return ::ad::map::landmark::LandmarkId::getMax();
  }
 
  static inline ::ad::map::landmark::LandmarkId epsilon()
  {
    return ::ad::map::landmark::LandmarkId(0);
  }
};
 
} // namespace std
 
#ifndef GEN_GUARD_AD_MAP_LANDMARK_LANDMARKID
#define GEN_GUARD_AD_MAP_LANDMARK_LANDMARKID
 
namespace ad {
namespace map {
namespace landmark {
 
inline std::ostream &operator<<(std::ostream &os, LandmarkId const &_value)
{
  return os << uint64_t(_value);
}
 
} // namespace landmark
} // namespace map
} // namespace ad
 
namespace std {
inline std::string to_string(::ad::map::landmark::LandmarkId const &value)
{
  return to_string(static_cast<uint64_t>(value));
}
} // namespace std
#endif // GEN_GUARD_AD_MAP_LANDMARK_LANDMARKID