MRId.h

Go to the documentation of this file.

#pragma once
 
#include "MRMeshFwd.h"
#include "MRMacros.h"
#include "MRPch/MRBindingMacros.h"
#include <cassert>
#include <cstddef>
#include <type_traits>
#include <utility>
 
namespace MR
{
 

template <typename T>
class Id
{
public:
    using ValueType = int; 
 
    constexpr Id() noexcept : id_( -1 ) { }
    explicit Id( NoInit ) noexcept { }

    template <typename U = int, std::enable_if_t<std::is_integral_v<U>, std::nullptr_t> = nullptr>
    MR_BIND_IGNORE explicit constexpr Id( U i ) noexcept : id_( ValueType( i ) ) { }
    #ifdef MR_PARSING_FOR_ANY_BINDINGS
    explicit constexpr Id( int i ) noexcept : id_( ValueType( i ) ) {}
    #endif
 
    constexpr operator ValueType() const { return id_; }
    constexpr bool valid() const { return id_ >= 0; }
    explicit constexpr operator bool() const { return id_ >= 0; }
    constexpr ValueType & get() noexcept { return id_; }
 
    constexpr bool operator == (Id b) const { return id_ == b.id_; }
    constexpr bool operator != (Id b) const { return id_ != b.id_; }
    constexpr bool operator <  (Id b) const { return id_ <  b.id_; }
 
    template <typename U>
    bool operator == (Id<U> b) const = delete;
    template <typename U>
    bool operator != (Id<U> b) const = delete;
    template <typename U>
    bool operator < (Id<U> b) const = delete;
 
    constexpr Id & operator --() { --id_; return * this; }
    constexpr Id & operator ++() { ++id_; return * this; }
 
    constexpr Id operator --( int ) { auto res = *this; --id_; return res; }
    constexpr Id operator ++( int ) { auto res = *this; ++id_; return res; }
 
    constexpr Id & operator -=( ValueType a ) { id_ -= a; return * this; }
    constexpr Id & operator +=( ValueType a ) { id_ += a; return * this; }

#if !MR_PARSING_FOR_C_BINDINGS && !MR_COMPILING_C_BINDINGS
private:
#endif
 
    ValueType id_;
};

template <typename T>
class NoInitId : public Id<T>
{
public:
    NoInitId() : Id<T>( noInit ) {}
    NoInitId( Id<T> id ) : Id<T>( id ) {}
};
 
template <>
class Id<EdgeTag>
{
public:
    using ValueType = int; 
 
    constexpr Id() noexcept : id_( -1 ) { }
    explicit Id( NoInit ) noexcept { }
    constexpr Id( UndirectedEdgeId u ) noexcept : id_( (ValueType)u << 1 ) { assert( u.valid() ); }
    explicit constexpr Id( ValueType i ) noexcept : id_( i ) { }
    explicit constexpr Id( unsigned int i ) noexcept : id_( i ) { }
    explicit constexpr Id( size_t i ) noexcept : id_( ValueType( i ) ) { }
    constexpr operator ValueType() const { return id_; }
    constexpr bool valid() const { return id_ >= 0; }
    explicit constexpr operator bool() const { return id_ >= 0; }
    constexpr ValueType & get() noexcept { return id_; }

    constexpr Id sym() const { assert( valid() ); return Id(id_ ^ 1); }
    constexpr bool even() const { assert( valid() ); return (id_ & 1) == 0; }
    constexpr bool odd() const { assert( valid() ); return (id_ & 1) == 1; }
    constexpr UndirectedEdgeId undirected() const { assert( valid() ); return UndirectedEdgeId( id_ >> 1 ); }
    constexpr operator UndirectedEdgeId() const { return undirected(); }
 
    constexpr bool operator == (Id b) const { return id_ == b.id_; }
    constexpr bool operator != (Id b) const { return id_ != b.id_; }
    constexpr bool operator <  (Id b) const { return id_ <  b.id_; }
 
    template <typename U>
    bool operator == (Id<U> b) const = delete;
    template <typename U>
    bool operator != (Id<U> b) const = delete;
    template <typename U>
    bool operator < (Id<U> b) const = delete;
 
    constexpr Id & operator --() { --id_; return * this; }
    constexpr Id & operator ++() { ++id_; return * this; }
 
    constexpr Id operator --( int ) { auto res = *this; --id_; return res; }
    constexpr Id operator ++( int ) { auto res = *this; ++id_; return res; }
 
    constexpr Id & operator -=( ValueType a ) { id_ -= a; return * this; }
    constexpr Id & operator +=( ValueType a ) { id_ += a; return * this; }

#if !MR_PARSING_FOR_C_BINDINGS && !MR_COMPILING_C_BINDINGS
private:
#endif
 
    ValueType id_;
};
 
template <>
class Id<VoxelTag>
{
public:
    using ValueType = size_t; 
 
    constexpr Id() noexcept : id_( ~ValueType( 0 ) ) { }
    explicit Id( NoInit ) noexcept { }
    explicit constexpr Id( ValueType i ) noexcept : id_( i ) { }
    explicit constexpr Id( int ) noexcept = delete;
    constexpr operator ValueType() const { return id_; }
    constexpr bool valid() const { return id_ != ~ValueType( 0 ); }
    explicit constexpr operator bool() const { return id_ != ~ValueType( 0 ); }
    constexpr ValueType& get() noexcept { return id_; }
 
    constexpr bool operator == (Id b) const { return id_ == b.id_; }
    constexpr bool operator != (Id b) const { return id_ != b.id_; }
    constexpr bool operator <  (Id b) const { return id_ <  b.id_; }
 
    template <typename U>
    bool operator == (Id<U> b) const = delete;
    template <typename U>
    bool operator != (Id<U> b) const = delete;
    template <typename U>
    bool operator < (Id<U> b) const = delete;
 
    constexpr Id & operator --() { --id_; return * this; }
    constexpr Id & operator ++() { ++id_; return * this; }
 
    constexpr Id operator --( int ) { auto res = *this; --id_; return res; }
    constexpr Id operator ++( int ) { auto res = *this; ++id_; return res; }
 
    constexpr Id & operator -=( ValueType a ) { id_ -= a; return * this; }
    constexpr Id & operator +=( ValueType a ) { id_ += a; return * this; }

#if !MR_PARSING_FOR_C_BINDINGS && !MR_COMPILING_C_BINDINGS
private:
#endif
 
    ValueType id_;
};
 
template <typename T>
inline constexpr Id<T> operator + ( Id<T> id, int a )          { return Id<T>{ id.get() + a }; }
template <typename T>
inline constexpr Id<T> operator + ( Id<T> id, unsigned int a ) { return Id<T>{ id.get() + a }; }
template <typename T>
inline constexpr Id<T> operator + ( Id<T> id, size_t a )       { return Id<T>{ id.get() + a }; }
 
template <typename T>
inline constexpr Id<T> operator - ( Id<T> id, int a )          { return Id<T>{ id.get() - a }; }
template <typename T>
inline constexpr Id<T> operator - ( Id<T> id, unsigned int a ) { return Id<T>{ id.get() - a }; }
template <typename T>
inline constexpr Id<T> operator - ( Id<T> id, size_t a )       { return Id<T>{ id.get() - a }; }
 
inline constexpr FaceId operator ""_f( unsigned long long i ) noexcept { return FaceId{ (int)i }; }
inline constexpr VertId operator ""_v( unsigned long long i ) noexcept { return VertId{ (int)i }; }
inline constexpr EdgeId operator ""_e( unsigned long long i ) noexcept { return EdgeId{ (int)i }; }
inline constexpr UndirectedEdgeId operator ""_ue( unsigned long long i ) noexcept { return UndirectedEdgeId{ (int)i }; }
inline constexpr VoxelId operator ""_vox( unsigned long long i ) noexcept { return VoxelId{ size_t( i ) }; }
 
}
 
template <typename T>
struct std::hash<MR::Id<T>>
{
    size_t operator() ( MR::Id<T> const& p ) const noexcept
    {
        return (int)p;
    }
};