TypeSafeId.h

Go to the documentation of this file.

// Copyright 2015 Sensics, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//        http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef INCLUDED_TypeSafeId_h_GUID_137CA336_382A_4796_7735_4521F02D5AC2
#define INCLUDED_TypeSafeId_h_GUID_137CA336_382A_4796_7735_4521F02D5AC2

// Internal Includes
#include <osvr/Util/StdInt.h>
#include <osvr/Util/BasicTypeTraits.h>

// Library/third-party includes
// - none

// Standard includes
#include <limits>

namespace osvr {
namespace util {

    template <class Tag> class TypeSafeId;
    template <class Tag> class TypeSafeIdBase;
    template <class Tag> class TypeSafeIdRefAccessorBase;
    namespace typesafeid_traits {
        template <typename Tag> struct WrappedType { typedef uint32_t type; };

        struct ShouldHaveReferenceAccessor {
            enum { value = true };
        };

        template <typename Tag> struct ProvideReferenceAccessor {
            enum { value = false };
        };

        template <typename Tag> struct ComputeBaseClass {
            typedef typename Conditional<ProvideReferenceAccessor<Tag>::value,
                                         TypeSafeIdRefAccessorBase<Tag>,
                                         TypeSafeIdBase<Tag> >::type type;
        };

        template <typename Tag> struct SentinelValue {
            typedef typename WrappedType<Tag>::type wrapped_type;
            static wrapped_type get() {
                return std::numeric_limits<wrapped_type>::max();
            }
        };

    } // namespace typesafeid_traits

    template <class Tag> class TypeSafeIdBase {
      public:
        typedef TypeSafeId<Tag> type;

        typedef typename typesafeid_traits::WrappedType<Tag>::type wrapped_type;

        static type invalid() { return type(); }

        TypeSafeIdBase() : m_val(sentinel()) {}

        explicit TypeSafeIdBase(wrapped_type val) : m_val(val) {}

        TypeSafeIdBase(TypeSafeIdBase const &other) : m_val(other.m_val) {}

        bool empty() const { return m_val == sentinel(); }

        wrapped_type value() const { return m_val; }

      protected:
        static wrapped_type sentinel() {
            return typesafeid_traits::SentinelValue<Tag>::get();
        }
        wrapped_type m_val;
    };

    template <class Tag>
    class TypeSafeIdRefAccessorBase : public TypeSafeIdBase<Tag> {
      public:
        typedef TypeSafeIdBase<Tag> Base;
        typedef typename typesafeid_traits::WrappedType<Tag>::type wrapped_type;
        TypeSafeIdRefAccessorBase() : Base() {}
        explicit TypeSafeIdRefAccessorBase(wrapped_type val) : Base(val) {}
        TypeSafeIdRefAccessorBase(TypeSafeIdRefAccessorBase const &other)
            : Base(other) {}

        wrapped_type &value() { return Base::m_val; }
    };

    template <class Tag>
    class TypeSafeId : public typesafeid_traits::ComputeBaseClass<Tag>::type {
      public:
        typedef TypeSafeId<Tag> type;
        typedef typename typesafeid_traits::ComputeBaseClass<Tag>::type Base;
        typedef typename typesafeid_traits::WrappedType<Tag>::type wrapped_type;
        TypeSafeId() : Base() {}
        explicit TypeSafeId(wrapped_type val) : Base(val) {}
        TypeSafeId(TypeSafeId const &other) : Base(other) {}
    };

    template <typename Tag>
    inline bool operator==(TypeSafeId<Tag> const a, TypeSafeId<Tag> const b) {
        return a.value() == b.value();
    }

    template <typename Tag>
    inline bool operator!=(TypeSafeId<Tag> const a, TypeSafeId<Tag> const b) {
        return a.value() != b.value();
    }

} // namespace util
} // namespace osvr

#endif // INCLUDED_TypeSafeId_h_GUID_137CA336_382A_4796_7735_4521F02D5AC2