enum.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#ifndef PXR_BASE_TF_ENUM_H
#define PXR_BASE_TF_ENUM_H


#include "pxr/pxr.h"
#include "pxr/base/arch/defines.h"
#include "pxr/base/arch/demangle.h"
#include "pxr/base/tf/hash.h"
#include "pxr/base/tf/preprocessorUtils.h"
#include "pxr/base/tf/preprocessorUtilsLite.h"
#include "pxr/base/tf/safeTypeCompare.h"
#include "pxr/base/tf/api.h"

#include <boost/operators.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp>

#include <iosfwd>
#include <string>
#include <typeinfo>
#include <type_traits>
#include <vector>

PXR_NAMESPACE_OPEN_SCOPE

class TfEnum : boost::totally_ordered<TfEnum>
{
public:
    TfEnum()
        : _typeInfo(&typeid(int)), _value(0)
    {
    }

    template <class T>
    TfEnum(T value,
           std::enable_if_t<std::is_enum<T>::value> * = 0)
        : _typeInfo(&typeid(T)), _value(int(value))
    {
    }

    TfEnum(const std::type_info& ti, int value)
        : _typeInfo(&ti), _value(value)
    {
    }

    bool operator==(const TfEnum& t) const {
        return t._value == _value &&
            TfSafeTypeCompare(*t._typeInfo, *_typeInfo);
    }

    bool operator<(const TfEnum& t) const {
        return _typeInfo->before(*t._typeInfo) ||
            (!t._typeInfo->before(*_typeInfo) && _value < t._value);
    }

    template <class T>
    std::enable_if_t<std::is_enum<T>::value, bool>
    operator==(T value) const {
        return int(value) == _value && IsA<T>();
    }

    template <class T>
    std::enable_if_t<std::is_enum<T>::value, bool>
    operator!=(T value) const {
        return int(value) != _value || !IsA<T>();
    }

    template <class T>
    friend std::enable_if_t<std::is_enum<T>::value, bool>
    operator==(T val, TfEnum const &e) {
        return e == val;
    }

    template <class T>
    friend std::enable_if_t<std::is_enum<T>::value, bool>
    operator!=(T val, TfEnum const &e) {
        return e != val;
    }

    template <class T>
    bool IsA() const {
        return TfSafeTypeCompare(*_typeInfo, typeid(T));
    }
    
    bool IsA(const std::type_info& t) const {
        return TfSafeTypeCompare(*_typeInfo, t);
    }

    const std::type_info& GetType() const {
        return *_typeInfo;
    }

    const int& GetValueAsInt() const {
        return _value;
    }

    template <typename T>
    T GetValue() const {
        if (!IsA<T>())
            _FatalGetValueError(typeid(T));

        return T(_value);
    }

    template <typename T,
             typename = typename std::enable_if<
                 std::is_integral<T>::value ||
                 std::is_enum<T>::value>::type
             >
    operator T() const
    {
        return T(_value);
    }


    TF_API static std::string  GetName(TfEnum val);

    TF_API static std::string  GetFullName(TfEnum val);

    TF_API static std::string  GetDisplayName(TfEnum val);

    static std::vector<std::string> GetAllNames(TfEnum val) {
        return GetAllNames(val.GetType());
    }
    
    TF_API static std::vector<std::string> GetAllNames(const std::type_info &ti);

    template <class T>
    static std::vector<std::string> GetAllNames() {
        return GetAllNames(typeid(T));
    }

    TF_API
    static const std::type_info *GetTypeFromName(const std::string& typeName);

    template <class T>
    static T GetValueFromName(const std::string &name, bool *foundIt = NULL) {
        TfEnum e = GetValueFromName(typeid(T), name, foundIt);
        return T(e.GetValueAsInt());
    }

    TF_API
    static TfEnum GetValueFromName(const std::type_info& ti,
                                   const std::string &name,
                                   bool *foundIt = NULL);

    TF_API
    static TfEnum GetValueFromFullName(const std::string &fullname,
                                       bool *foundIt = NULL);

    TF_API
    static bool IsKnownEnumType(const std::string& typeName);


    TF_API
    static void _AddName(TfEnum val, const std::string &valName,
                         const std::string &displayName="");

    static void AddName(TfEnum val, const std::string &valName,
                        const std::string &displayName="")
    {
        _AddName(val, valName, displayName);
    }
     
    template <typename T>
    static TfEnum IntegralEnum(T value) {
        TfEnum e;
        e._typeInfo = &typeid(T);
        e._value = int(value);
        return e;
    }

private:
    // Internal constructor for int values.
    explicit TfEnum(int value)
        : _typeInfo(&typeid(int)), _value(value)
    {
    }

    // Internal constructor for size_t values.
    explicit TfEnum(size_t value)
        : _typeInfo(&typeid(size_t)), _value(static_cast<int>(value))
    {
    }

    TF_API
    void _FatalGetValueError(std::type_info const& typeInfo) const;

    const std::type_info* _typeInfo;
    int _value;
};

// TfHash support.  Make the enum parameter be a deduced template type but
// enable the overload only for TfEnum.  This disables implicit conversion from
// ordinary enum types to TfEnum.
template <class HashState, class Enum>
std::enable_if_t<std::is_same<Enum, TfEnum>::value>
TfHashAppend(HashState &h, Enum const &e)
{
    h.Append(TfHashAsCStr(e.GetType().name()));
    h.Append(e.GetValueAsInt());
}

TF_API std::ostream& operator<<(std::ostream& out, const TfEnum & e);

#define TF_ADD_ENUM_NAME(VAL, ...)                               \
    TfEnum::_AddName(VAL,                                        \
                     TF_PP_STRINGIZE(VAL)                        \
                     BOOST_PP_COMMA_IF(TF_NUM_ARGS(__VA_ARGS__)) \
                     __VA_ARGS__)

PXR_NAMESPACE_CLOSE_SCOPE

#endif // PXR_BASE_TF_ENUM_H