IdType.hpp

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
 
#pragma once
 
#include <functional>
#include "Arp/System/Core/Enum.hxx"
#include <limits>
#include <vector>
 
 
namespace Arp { namespace System { namespace Nm { namespace Internal
{
template<typename T>
class IdGenerator;
} // namespace Internal
 
 
template<typename T, typename TypeTag>
class IdType
{
    static_assert(std::is_unsigned<T>::value, "T must be an unsigned integer type");
    static_assert(std::is_same<T, bool>::value == 0, "Cannot be used with bool");
 
public:
    using type = T;
    using self_type = IdType<T, TypeTag>;
 
 
    constexpr IdType() noexcept = default;
 
    constexpr explicit IdType(T value) noexcept : Value(value)
    {
    }
 
    constexpr IdType(const self_type&) noexcept = default;
 
    IdType(IdType&& other) noexcept : Value(other.Value)
    {
        other.Value = self_type().Value;
    }
 
    ~IdType() noexcept = default;
 
 
    self_type& operator=(const self_type&) noexcept = default;
 
    self_type& operator=(IdType&& other) noexcept
    {
        this->Value = other.Value;
        other.Value = self_type().Value;
        return *this;
    }
 
 
    constexpr bool operator<(const self_type& rhs) const noexcept
    {
        return this->Value < rhs.Value;
    }
 
 
    constexpr bool operator==(const self_type& rhs) const noexcept
    {
        return this->Value == rhs.Value;
    }
 
 
    constexpr bool operator!=(const self_type& rhs) const noexcept
    {
        return this->Value != rhs.Value;
    }
 
 
    constexpr bool IsValid() const noexcept
    {
        return this->Value != self_type().Value;
    }
 
 
    constexpr T GetValue() const noexcept
    {
        return this->Value;
    }
 
 
private:
    constexpr static const self_type GetIncrementedId(const self_type& id) noexcept
    {
        return self_type(static_cast<T>(id.Value + 1));
    }
 
 
    constexpr static const self_type CreateInitalId() noexcept
    {
        return GetIncrementedId(self_type());
    }
 
 
    constexpr const self_type CreateNextIdUnique() const noexcept
    {
        return GetIncrementedId(*this);
    }
 
 
    constexpr const self_type CreateNextId() const noexcept
    {
        return this->IsValid() ? this->CreateNextIdUnique() : self_type();
    }
 
 
private:
    T Value = std::numeric_limits<T>::min();
 
    friend Internal::IdGenerator<self_type>;
};
 
 
template<typename T, typename TypeTag>
std::ostream& operator<<(std::ostream& os, const Arp::System::Nm::IdType<T, TypeTag>& id)
{
    os << id.GetValue();
    return os;
}
 
 
template<typename IdType>
std::vector<typename IdType::type> ConvertIdTypesToRawIds(const std::vector<IdType>& ids)
{
    std::vector<typename IdType::type> result;
    result.reserve(ids.size());
    for (const IdType& each : ids)
    {
        result.emplace_back(each.GetValue());
    }
    return result;
}
 
 
template<typename IdType>
std::vector<IdType> ConvertRawIdsToIdTypes(const std::vector<typename IdType::type>& ids)
{
    std::vector<IdType> result;
    result.reserve(ids.size());
    for (const typename IdType::type& each : ids)
    {
        result.emplace_back(IdType(each));
    }
    return result;
}
 
 
}}} // end of namespace Arp::System::Nm
 
 
namespace std
{
template<typename T, typename TypeTag>
struct hash<Arp::System::Nm::IdType<T, TypeTag>>
{
    using arguement_type = Arp::System::Nm::IdType<T, TypeTag>;
    using result_type = std::size_t;
    result_type operator()(const arguement_type& id) const noexcept
    {
        return std::hash<T>()(id.GetValue());
    }
};
} // namespace std