identifiers.h

Go to the documentation of this file.

#ifndef META_NUMERIC_IDENTIFIER_H_
#define META_NUMERIC_IDENTIFIER_H_

#include <functional> // for std::hash
#include "util/comparable.h"

namespace meta
{
namespace util
{

struct numeric
{
};

template <template <class> class Wrapped>
struct hash_wrapper : public Wrapped<hash_wrapper<Wrapped>>
{
    using Wrapped<hash_wrapper>::Wrapped;
    using Wrapped<hash_wrapper>::operator=;

    hash_wrapper() = default;
    hash_wrapper(const hash_wrapper&) = default;
    hash_wrapper(hash_wrapper&&) = default;
    hash_wrapper& operator=(const hash_wrapper&) = default;
    hash_wrapper& operator=(hash_wrapper&&) = default;
};

template <class Derived, class T>
struct identifier : public comparable<identifier<Derived, T>>
{
    T id_;

    explicit identifier(const T& t) : id_{t}
    {
    }

    identifier() = default;

    identifier(const identifier&) = default;

    identifier(identifier&&) = default;

    identifier& operator=(const identifier&) = default;

    identifier& operator=(identifier&&) = default;

    identifier& operator=(const T& t)
    {
        id_ = t;
        return *this;
    }

    operator const T&() const
    {
        return id_;
    }

    operator T&()
    {
        return id_;
    }

    inline friend bool operator<(const identifier& lhs, const identifier& rhs)
    {
        return static_cast<T>(lhs) < static_cast<T>(rhs);
    }

    inline friend std::ostream& operator<<(std::ostream& stream,
                                           const identifier& ident)
    {
        return stream << static_cast<T>(ident);
    }

    inline friend std::istream& operator>>(std::istream& stream,
                                           identifier& ident)
    {
        return stream >> ident.id_;
    }
};

template <class Derived, class T>
struct numerical_identifier : public identifier<Derived, T>, numeric
{
    using identifier<Derived, T>::identifier;
    using identifier<Derived, T>::id_;
    using identifier<Derived, T>::operator=;

    Derived& operator++()
    {
        ++id_;
        return *derived();
    }

    Derived operator++(int)
    {
        Derived t = *derived();
        ++(*this);
        return t;
    }

    Derived& operator--()
    {
        --id_;
        return *derived();
    }

    Derived operator--(int)
    {
        Derived t = *derived();
        --(*this);
        return t;
    }

    Derived& operator+=(const T& step)
    {
        id_ += step;
        return *derived();
    }

    Derived& operator-=(const T& step)
    {
        id_ -= step;
        return *derived();
    }

    friend inline Derived operator+(Derived lhs, const Derived& rhs)
    {
        lhs += static_cast<T>(rhs);
        return lhs;
    }

    friend inline Derived operator-(Derived lhs, const Derived& rhs)
    {
        lhs -= static_cast<T>(rhs);
        return lhs;
    }

  private:
    Derived* derived()
    {
        return static_cast<Derived*>(this);
    }
};
}
}

namespace std
{

template <template <class> class Wrapped>
struct hash<meta::util::hash_wrapper<Wrapped>>
{
    template <class T>
    size_t operator()(
        const meta::util::identifier<meta::util::hash_wrapper<Wrapped>,
                                     T>& to_hash) const
    {
        return hash<T>{}(static_cast<T>(to_hash));
    }
};
}

#define MAKE_USER_DEFINED_LITERAL(ident_name, base_type, suffix)               \
    inline ident_name operator"" suffix(const char* str, std::size_t len)      \
    {                                                                          \
        return ident_name{base_type{str, len}};                                \
    }

#define MAKE_USER_DEFINED_NUMERIC_LITERAL(ident_name, base_type, suffix)       \
    inline ident_name operator"" suffix(unsigned long long int val)            \
    {                                                                          \
        return ident_name{base_type(val)};                                     \
    }

#define MAKE_OPAQUE_IDENTIFIER(ident_name, base_type)                          \
    template <class Wrapper>                                                   \
    struct ident_name##_dummy                                                  \
        : public meta::util::identifier<Wrapper, base_type>                    \
    {                                                                          \
        using meta::util::identifier<Wrapper, base_type>::identifier;          \
        using meta::util::identifier<Wrapper, base_type>::operator=;           \
    };                                                                         \
    using ident_name = meta::util::hash_wrapper<ident_name##_dummy>;

#define MAKE_OPAQUE_NUMERIC_IDENTIFIER(ident_name, base_type)                  \
    template <class Wrapper>                                                   \
    struct ident_name##_dummy                                                  \
        : public meta::util::numerical_identifier<Wrapper, base_type>          \
    {                                                                          \
        using meta::util::numerical_identifier<Wrapper, base_type>::           \
            numerical_identifier;                                              \
        using meta::util::numerical_identifier<Wrapper, base_type>::operator=; \
    };                                                                         \
    using ident_name = meta::util::hash_wrapper<ident_name##_dummy>;

#if !defined NDEBUG && !defined NUSE_OPAQUE_IDENTIFIERS
#define MAKE_IDENTIFIER(ident_name, base_type)                                 \
    MAKE_OPAQUE_IDENTIFIER(ident_name, base_type)
#else
#define MAKE_IDENTIFIER(ident_name, base_type) using ident_name = base_type;
#endif

#if !defined NDEBUG && !defined NUSE_OPAQUE_IDENTIFIERS
#define MAKE_NUMERIC_IDENTIFIER(ident_name, base_type)                         \
    MAKE_OPAQUE_NUMERIC_IDENTIFIER(ident_name, base_type)
#else
#define MAKE_NUMERIC_IDENTIFIER(ident_name, base_type)                         \
    using ident_name = base_type;
#endif

#if !defined NDEBUG && !defined NUSE_OPAQUE_IDENTIFIERS
#define MAKE_IDENTIFIER_UDL(ident_name, base_type, suffix)                     \
    MAKE_OPAQUE_IDENTIFIER(ident_name, base_type)                              \
    MAKE_USER_DEFINED_LITERAL(ident_name, base_type, suffix)
#else
#define MAKE_IDENTIFIER_UDL(ident_name, base_type, suffix)                     \
    using ident_name = base_type;                                              \
    MAKE_USER_DEFINED_LITERAL(ident_name, base_type, suffix)
#endif

#if !defined NDEBUG && !defined NUSE_OPAQUE_IDENTIFIERS
#define MAKE_NUMERIC_IDENTIFIER_UDL(ident_name, base_type, suffix)             \
    MAKE_OPAQUE_NUMERIC_IDENTIFIER(ident_name, base_type)                      \
    MAKE_USER_DEFINED_NUMERIC_LITERAL(ident_name, base_type, suffix)
#else
#define MAKE_NUMERIC_IDENTIFIER_UDL(ident_name, base_type, suffix)             \
    using ident_name = base_type;                                              \
    MAKE_USER_DEFINED_NUMERIC_LITERAL(ident_name, base_type, suffix)
#endif

#endif