TypeId.h

Go to the documentation of this file.

//-
// =============================================================================
// Copyright 2024 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// =============================================================================
//+
 
#ifndef AMINO_CORE_TYPE_ID_H
#define AMINO_CORE_TYPE_ID_H
 
 
#include "internal/TypeInfo.h"
 
//==============================================================================
// NAMESPACE Amino
//==============================================================================
 
namespace Amino {
 
//==============================================================================
// FORWARD DECLARATIONS
//==============================================================================
 
class TypeId;
 
template <typename T>
TypeId getTypeId() noexcept;
 
//==============================================================================
// CLASS TypeId
//==============================================================================
 
class TypeId {
public:
    /*----- member functions -----*/
 
    TypeId() = delete;
 
    size_t computeHash() const { return info().computeHash(); }
 
    bool operator==(TypeId o) const noexcept { return info() == o.info(); }
    bool operator!=(TypeId o) const noexcept { return info() != o.info(); }
 
    // clang-format off
    bool operator< (TypeId o) const noexcept { return info() <  o.info(); }
    bool operator<=(TypeId o) const noexcept { return info() <= o.info(); }
    bool operator> (TypeId o) const noexcept { return info() >  o.info(); }
    bool operator>=(TypeId o) const noexcept { return info() >= o.info(); }
    // clang-format on
 
private:
 
    /*----- friend declarations -----*/
 
    template <typename T>
    friend TypeId getTypeId() noexcept;
    friend ::Amino::Internal::TypeInfoDetails;
 
    /*----- static member functions -----*/
 
    template <typename T>
    static TypeId get() noexcept;
 
    /*----- member functions -----*/
 
    explicit constexpr TypeId(std::nullptr_t) : m_info(nullptr) {}
 
    explicit constexpr TypeId(Internal::TypeInfo const* info) : m_info(info) {
        assert(info);
    }
 
    Internal::TypeInfo const& info() const {
        assert(m_info);
        return *m_info;
    }
 
    /*----- data members -----*/
 
    Internal::TypeInfo const* m_info = nullptr;
 
};
 
//------------------------------------------------------------------------------
//
static_assert(
    sizeof(TypeId) == sizeof(void*), "TypeId must be the size of a pointer.");
static_assert(
    alignof(TypeId) == alignof(void*), "TypeId must be aligned like pointer.");
 
//------------------------------------------------------------------------------
//
template <typename T>
TypeId TypeId::get() noexcept {
#if AMINO_INTERNAL_OPTION_HAS_RTTI
    return TypeId(&Internal::TypeInfo::get<T>());
#else
    // If no RTTI, fail at compile time, not link time.
    // It's ok to use Amino::TypeId without RTTI, but not ok to create them.
    // This isRttiEnabled will always be false if this function is instantiated,
    // but the dummy expression must depend on the template type T, otherwise
    // the static_assert will fail even if the function isn't instantiated.
    constexpr bool isRttiEnabled = (alignof(T) == -42); // always false
    static_assert(isRttiEnabled, "Can't use getTypeId() without rtti enabled!");
    AMINO_INTERNAL_UNREACHABLE("Can't be instantiated");
#endif
}
template <>
inline TypeId TypeId::get<void>() noexcept {
    return TypeId(&Internal::TypeInfo::get<void>());
}
 
//==============================================================================
// FUNCTION getTypeId<T>()
//==============================================================================
 
//------------------------------------------------------------------------------
//
template <typename T>
TypeId getTypeId() noexcept {
    return TypeId::get<T>();
}
 
template <>
inline constexpr TypeId getTypeId<Internal::NullTypeInfo>() noexcept {
    return TypeId(nullptr);
}
 
} // namespace Amino
 
#endif