StronglyTypedValue.h

Go to the documentation of this file.

//  -------------------------------------------------------------------------
//  Copyright (C) 2017 BMW Car IT GmbH
//  -------------------------------------------------------------------------
//  This Source Code Form is subject to the terms of the Mozilla Public
//  License, v. 2.0. If a copy of the MPL was not distributed with this
//  file, You can obtain one at https://mozilla.org/MPL/2.0/.
//  -------------------------------------------------------------------------
 
#ifndef RAMSES_STRONGLYTYPEDVALUE_H
#define RAMSES_STRONGLYTYPEDVALUE_H
 
#include "ramses-framework-api/APIExport.h"
#include <functional>
#include <type_traits>
 
namespace ramses
{
    template <typename _baseType, _baseType _invalid, typename _uniqueId>
    class StronglyTypedValue
    {
    public:
        using BaseType = _baseType;
 
        static constexpr StronglyTypedValue Invalid()
        {
            return StronglyTypedValue(_invalid);
        }
 
        explicit constexpr StronglyTypedValue(BaseType value)
            : m_value(value)
        {
        }
 
        constexpr StronglyTypedValue()
            : m_value(_invalid)
        {
        }
 
        constexpr StronglyTypedValue(const StronglyTypedValue& other) = default;
 
        StronglyTypedValue& operator=(const StronglyTypedValue& other) = default;
 
        constexpr BaseType getValue() const
        {
            return m_value;
        }
 
        BaseType& getReference()
        {
            return m_value;
        }
 
        constexpr bool isValid() const
        {
            return m_value != _invalid;
        }
 
        constexpr bool operator==(const StronglyTypedValue& other) const
        {
            return m_value == other.m_value;
        }
 
        constexpr bool operator!=(const StronglyTypedValue& other) const
        {
            return m_value != other.m_value;
        }
 
        static_assert(std::is_arithmetic<BaseType>::value || std::is_pointer<BaseType>::value, "expected arithmetic or pointer basetype");
 
    private:
        BaseType m_value;
    };
}
 
namespace std
{
    template <typename _baseType, _baseType _invalid, typename _uniqueId>
    struct hash<ramses::StronglyTypedValue<_baseType, _invalid, _uniqueId>>
    {
    public:
        size_t operator()(const ramses::StronglyTypedValue<_baseType, _invalid, _uniqueId>& v) const
        {
            return static_cast<size_t>(hash<_baseType>()(v.getValue()));
        }
    };
}
 
#endif