Primitive.h

Go to the documentation of this file.

// this is for emacs file handling -*- mode: c++; c-basic-offset: 2;
// indent-tabs-mode: nil -*-
 
#pragma once
#include <limits>
#include <utility>
 
#include "lanelet2_core/Attribute.h"
#include "lanelet2_core/Exceptions.h"
#include "lanelet2_core/primitives/Traits.h"
 
namespace lanelet {
 
class PrimitiveData {
 public:
  PrimitiveData() noexcept = default;
  PrimitiveData(PrimitiveData&& rhs) noexcept = default;
  PrimitiveData& operator=(PrimitiveData&& rhs) noexcept = default;
  PrimitiveData(const PrimitiveData& rhs) = default;
  PrimitiveData& operator=(const PrimitiveData& rhs) = default;
 
  explicit PrimitiveData(Id id, AttributeMap attributes = AttributeMap()) : id{id}, attributes{std::move(attributes)} {}
 
  Id id{InvalId};           
  AttributeMap attributes;  
 protected:
  ~PrimitiveData() = default;
};  // class PrimitiveData
 
 
template <typename Data>
class ConstPrimitive {
 public:
  using DataType = Data;
  static constexpr bool IsConst = true;
  explicit ConstPrimitive(const std::shared_ptr<const Data>& data) : constData_{data} {
    if (!data) {
      throw lanelet::NullptrError("Nullptr passed to constructor!");
    }
  }
 
  // Comparison
  bool operator==(const ConstPrimitive& rhs) const { return this->constData_ == rhs.constData_; }
  bool operator!=(const ConstPrimitive& rhs) const { return !(*this == rhs); }
 
  const AttributeMap& attributes() const { return constData_->attributes; }
 
 
  Id id() const noexcept { return constData_->id; }
 
  bool hasAttribute(const std::string& name) const noexcept { return attributes().find(name) != attributes().end(); }
 
 
  bool hasAttribute(AttributeName name) const noexcept { return attributes().find(name) != attributes().end(); }
 
  const Attribute& attribute(const std::string& name) const {
    try {
      return attributes().at(name);
    } catch (std::out_of_range& err) {
      throw NoSuchAttributeError(err.what());
    }
  }
 
  const Attribute& attribute(AttributeName name) const {
    try {
      return attributes().at(name);
    } catch (std::out_of_range& err) {
      throw NoSuchAttributeError(err.what());
    }
  }
 
  template <typename T>
  T attributeOr(const std::string& name, T defaultVal) const noexcept {
    auto elem = attributes().find(name);
    if (elem == attributes().end()) {
      return defaultVal;
    }
    auto val = elem->second.template as<T>();
    if (!!val) {
      return *val;
    }
    return defaultVal;
  }
 
  template <typename T>
  T attributeOr(AttributeName name, T defaultVal) const {
    auto elem = attributes().find(name);
    if (elem == attributes().end()) {
      return defaultVal;
    }
    auto val = elem->second.template as<T>();
    if (!!val) {
      return *val;
    }
    return defaultVal;
  }
 
  const std::shared_ptr<const Data>& constData() const { return constData_; }
 
 protected:
  // This class is only an implementation class and should never be instanciated
  ConstPrimitive(ConstPrimitive&& rhs) noexcept = default;
  ConstPrimitive& operator=(ConstPrimitive&& rhs) noexcept = default;
  ConstPrimitive(const ConstPrimitive& rhs) = default;
  ConstPrimitive& operator=(const ConstPrimitive& rhs) = default;
  ~ConstPrimitive() noexcept = default;
 
 private:
  std::shared_ptr<const Data> constData_;  
 
};  // class ConstPrimitive
 
 
template <typename DerivedConstPrimitive>
class Primitive : public DerivedConstPrimitive {
 public:
  Primitive() = default;  // not inherited
  using DataType = typename DerivedConstPrimitive::DataType;
  using DerivedConstPrimitive::DerivedConstPrimitive;
  static constexpr bool IsConst = false;
 
  // needs a non-const shared_ptr to construct
  Primitive(const std::shared_ptr<const DataType>&) = delete;
 
  explicit Primitive(const std::shared_ptr<DataType>& data) : DerivedConstPrimitive(data) {
    if (!data) {
      throw lanelet::NullptrError("Nullptr passed to constructor!");
    }
  }
 
  template <typename OtherT>
  explicit Primitive(const Primitive<OtherT>& rhs) : DerivedConstPrimitive(rhs) {}
 
  void setId(Id id) noexcept { data()->id = id; }
 
  void setAttribute(const std::string& name, const Attribute& attribute) { attributes()[name] = attribute; }
 
  void setAttribute(AttributeName name, const Attribute& attribute) { attributes()[name] = attribute; }
 
  // need this for copy construction to work
  template <typename>
  friend class Primitive;
 
  using DerivedConstPrimitive::attributes;
  AttributeMap& attributes() noexcept { return data()->attributes; }
 
 protected:
  std::shared_ptr<DataType> data() const {
    // const_pointer_cast is ok. Non-const primitives cannot be created without
    // a non-const pointer.
    return std::const_pointer_cast<DataType>(this->constData());
  }
 
  // This class is only an implementation class and should never be instanciated
  Primitive(Primitive&& rhs) noexcept;
  Primitive& operator=(Primitive&& rhs) noexcept;
  Primitive(const Primitive& rhs) noexcept;
  Primitive& operator=(const Primitive& rhs) noexcept;
  ~Primitive() noexcept = default;  // NOLINT
};
 
namespace traits {
 
namespace internal {
template <typename PrimitiveT>
class IsPrimitiveHelper : public std::false_type {};
template <typename PrimitiveT>
class IsPrimitiveHelper<ConstPrimitive<PrimitiveT>> : public std::true_type {};
 
template <typename DataT>
bool isLaneletPrimitiveHelper(ConstPrimitive<DataT>* /*unused*/, int /*unused*/) {
  return true;
}
 
template <typename NotPrimitive>
bool isLaneletPrimitiveHelper(NotPrimitive* /*unused*/, long /*unused*/) {  // NOLINT
  return false;
}
}  // namespace internal
 
template <typename PrimitiveT>
constexpr bool isLaneletPrimitive() {
  PrimitiveT* v = nullptr;
  return IsLaneletPrimitiveHelper(v, 0);
}
}  // namespace traits
 
template <typename PrimitiveT>
struct HashBase {
  size_t operator()(const PrimitiveT& x) const noexcept { return std::hash<Id>()(x.id()); }
};
 
template <typename DerivedConstPrimitive>
Primitive<DerivedConstPrimitive>::Primitive(Primitive&& rhs) noexcept = default;
 
template <typename DerivedConstPrimitive>
Primitive<DerivedConstPrimitive>& Primitive<DerivedConstPrimitive>::operator=(Primitive&& rhs) noexcept = default;
 
template <typename DerivedConstPrimitive>
Primitive<DerivedConstPrimitive>::Primitive(const Primitive& rhs) noexcept = default;
 
template <typename DerivedConstPrimitive>
Primitive<DerivedConstPrimitive>& Primitive<DerivedConstPrimitive>::operator=(const Primitive& rhs) noexcept = default;
 
}  // namespace lanelet