type.h

//
// 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_TYPE_H
#define PXR_BASE_TF_TYPE_H
 
#include "pxr/pxr.h"
 
#include "pxr/base/tf/api.h"
#include "pxr/base/tf/registryManager.h"
#include "pxr/base/tf/typeFunctions.h"
 
#include <iosfwd>
#include <memory>
#include <set>
#include <string>
#include <type_traits>
#include <typeinfo>
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
#ifdef PXR_PYTHON_SUPPORT_ENABLED
class TfPyObjWrapper;
#endif // PXR_PYTHON_SUPPORT_ENABLED
 
class TfType
{
    struct _TypeInfo;
 
public:
    using DefinitionCallback = void (*)(TfType);
 
    class FactoryBase {
    public:
        TF_API virtual ~FactoryBase();
    };
 
public:
    
    enum LegacyFlags {
        ABSTRACT =       0x01,   
        CONCRETE =       0x02,   
        MANUFACTURABLE = 0x08,   
    };
 
#ifdef PXR_PYTHON_SUPPORT_ENABLED
    // This is a non-templated base class for the templated
    // polymorphic-to-Python infrastructure.
    struct PyPolymorphicBase
    {
    protected:
        TF_API virtual ~PyPolymorphicBase();
    };
#endif // PXR_PYTHON_SUPPORT_ENABLED
 
public:
    template <class ... Args>
    struct Bases {};
 
public:
    TF_API
    TfType();
 
    TF_API
    static TfType const& GetUnknownType();
 
    inline bool operator ==(const TfType& t) const { return _info == t._info; }
    inline bool operator !=(const TfType& t) const { return _info != t._info; }
 
    inline bool operator <(const TfType& t) const { return _info < t._info; }
    inline bool operator >(const TfType& t) const { return _info > t._info; }
    inline bool operator <=(const TfType& t) const { return _info <= t._info; }
    inline bool operator >=(const TfType& t) const { return _info >= t._info; }
 
    
 
    template <typename T>
    static TfType const& Find() {
        return Find(typeid(T));
    }
 
    template <typename T>
    static TfType const& Find(const T &obj) {
        // If T is polymorphic to python, we may have to bridge into python.  We
        // could also optimize for Ts that are not polymorphic at all and avoid
        // doing rtti typeid lookups, but we trust the compiler to do this for
        // us.
        if (auto const *rawPtr = TfTypeFunctions<T>::GetRawPtr(obj))
            return _FindImpl(rawPtr);
        return GetUnknownType();
    }
 
    static TfType const& Find(const std::type_info &t) {
        return _FindByTypeid(t);
    }
    
    static TfType const& FindByTypeid(const std::type_info &t) {
        return _FindByTypeid(t);
    }
 
    TF_API
    static TfType const& FindByName(const std::string &name);
 
    TF_API
    TfType const& FindDerivedByName(const std::string &name) const;
 
    template <typename BASE>
    static TfType const& FindDerivedByName(const std::string &name)
    {
        return TfType::Find<BASE>().FindDerivedByName(name);
    }
 
#ifdef PXR_PYTHON_SUPPORT_ENABLED
    TF_API
    static TfType const& FindByPythonClass(const TfPyObjWrapper & classObj);
#endif // PXR_PYTHON_SUPPORT_ENABLED
 
 
 
 
    TF_API
    static TfType const& GetRoot();
 
    TF_API
    const std::string &GetTypeName() const;
 
    TF_API
    const std::type_info &GetTypeid() const;
 
    TF_API
    static std::string GetCanonicalTypeName(const std::type_info &);
 
    TF_API
    std::vector<std::string> GetAliases(TfType derivedType) const;
 
#ifdef PXR_PYTHON_SUPPORT_ENABLED
    TF_API
    TfPyObjWrapper GetPythonClass() const;
#endif // PXR_PYTHON_SUPPORT_ENABLED
 
    TF_API
    std::vector<TfType> GetBaseTypes() const;
    
    TF_API
    size_t GetNBaseTypes(TfType *out, size_t maxBases) const;
 
    TF_API
    std::vector<TfType> GetDirectlyDerivedTypes() const;
 
    TF_API
    TfType const& GetCanonicalType() const;
    
    TF_API
    void GetAllDerivedTypes( std::set<TfType> *result ) const;
 
    TF_API
    void GetAllAncestorTypes(std::vector<TfType> *result) const;
 
    TF_API
    bool IsA(TfType queryType) const;
 
    template <typename T>
    bool IsA() const { return IsA(Find<T>()); }
 
    bool IsUnknown() const { return *this == TfType(); }
 
    typedef TfType::_TypeInfo * (TfType::*UnspecifiedBoolType);
 
    operator UnspecifiedBoolType() const {
        return IsUnknown() ? NULL : &TfType::_info;
    }
 
    bool operator !() const { return !bool(*this); }
 
    bool IsRoot() const { return *this == GetRoot(); }
 
    TF_API
    bool IsEnumType() const;
 
    TF_API
    bool IsPlainOldDataType() const;
 
    TF_API
    size_t GetSizeof() const;
 
 
 
 
    TF_API
    static TfType const&
    Declare( const std::string & typeName );
 
    TF_API
    static TfType const&
    Declare( const std::string & typeName,
             const std::vector<TfType> & bases,
             DefinitionCallback definitionCallback=nullptr );
 
    template <typename T, typename BaseTypes = TfType::Bases<>>
    static TfType const& Declare();
 
    template <typename T, typename B>
    static TfType const& Define();
 
    template <typename T>
    static TfType const& Define();
 
#ifdef PXR_PYTHON_SUPPORT_ENABLED
    TF_API
    void DefinePythonClass(const TfPyObjWrapper &classObj) const;
#endif // PXR_PYTHON_SUPPORT_ENABLED
 
    template <typename Base, typename Derived>
    static void AddAlias(const std::string &name) {
        TfType b = Declare(GetCanonicalTypeName(typeid(Base)));
        TfType d = Declare(GetCanonicalTypeName(typeid(Derived)));
        d.AddAlias(b, name);
    }
 
    TF_API
    void AddAlias(TfType base, const std::string &name) const;
 
    const TfType &Alias(TfType base, const std::string &name) const {
        AddAlias(base, name);
        return *this;
    }
 
 
 
 
    TF_API
    void* CastToAncestor(TfType ancestor, void* addr) const;
 
    const void* CastToAncestor(TfType ancestor,
                               const void* addr) const {
        return CastToAncestor(ancestor, const_cast<void*>(addr));
    }
    
    TF_API
    void* CastFromAncestor(TfType ancestor, void* addr) const;
 
    const void* CastFromAncestor(TfType ancestor,
                                 const void* addr) const {
        return CastFromAncestor(ancestor, const_cast<void*>(addr));
    }
 
 
 
    TF_API
    void SetFactory(std::unique_ptr<FactoryBase> factory) const;
 
    template <class T>
    void SetFactory(std::unique_ptr<T>& factory) const {
        SetFactory(std::unique_ptr<FactoryBase>(std::move(factory)));
    }
 
    template <class T>
    void SetFactory() const { SetFactory(std::unique_ptr<FactoryBase>(new T)); }
 
    const TfType& Factory(std::unique_ptr<FactoryBase> factory) const {
        SetFactory(std::move(factory));
        return *this;
    }
 
    template <class T>
    const TfType& Factory(std::unique_ptr<T>& factory) const
    {
        SetFactory(std::unique_ptr<FactoryBase>(std::move(factory)));
        return *this;
    }
 
    template <class T>
    const TfType& Factory() const {
        SetFactory(std::unique_ptr<FactoryBase>(new T));
        return *this;
    }
 
    template <class T>
    T *GetFactory() const { return dynamic_cast<T*>(_GetFactory()); }
 
 
private:
    TF_API
    FactoryBase* _GetFactory() const;
 
#ifdef PXR_PYTHON_SUPPORT_ENABLED
    TF_API
    static TfType const &_FindImplPyPolymorphic(PyPolymorphicBase const *ptr);
    
    // PyPolymorphic case.
    template <class T>
    static typename std::enable_if<
        std::is_base_of<PyPolymorphicBase, T>::value, TfType const &>::type
    _FindImpl(T const *rawPtr) {
        return _FindImplPyPolymorphic(
            static_cast<PyPolymorphicBase const *>(rawPtr));
    }
 
    // Polymorphic.
    template <class T>
    static typename std::enable_if<
        std::is_polymorphic<T>::value &&
        !std::is_base_of<PyPolymorphicBase, T>::value, TfType const &>::type
    _FindImpl(T const *rawPtr) {
        if (auto ptr = dynamic_cast<PyPolymorphicBase const *>(rawPtr))
            return _FindImplPyPolymorphic(ptr);
        return Find(typeid(*rawPtr));
    }
 
    template <class T>
    static typename std::enable_if<
        !std::is_polymorphic<T>::value, TfType const &>::type
    _FindImpl(T const *rawPtr) {
        return Find(typeid(T));
    }
 
#else
    template <class T>
    static typename std::enable_if<
        std::is_polymorphic<T>::value, TfType const &>::type
    _FindImpl(T const *rawPtr) {
        return Find(typeid(*rawPtr));
    }
 
    template <class T>
    static typename std::enable_if<
        !std::is_polymorphic<T>::value, TfType const &>::type
    _FindImpl(T const *rawPtr) {
        return Find(typeid(T));
    }
 
#endif // PXR_PYTHON_SUPPORT_ENABLED
 
    // Callers must hold at least a read lock on the type registry's mutex.
    bool _IsAImplNoLock(TfType queryType) const;
 
    typedef void *(*_CastFunction)(void *, bool derivedToBase);
 
    template <typename TypeVector>
    friend struct Tf_AddBases;
    friend struct _TypeInfo;
    friend class Tf_TypeRegistry;
 
    // TfHash support.
    template <class HashState>
    friend void
    TfHashAppend(HashState &h, TfType const &type) {
        h.Append(type._info);
    }
 
    // Construct a TfType with the given _TypeInfo.
    explicit TfType(_TypeInfo *info) : _info(info) {}
 
    // Add base type(s), and link as a derived type of the bases.  Callers
    // must hold a registry write lock.
    void _AddBasesNoLock(
        const std::vector<TfType> &bases,
        std::vector<std::string> *errorToEmit) const;
 
    // Add the given function for casting to/from the given baseType.
    TF_API
    void _AddCppCastFunc(
        const std::type_info &baseTypeInfo, _CastFunction) const;
 
    // Define this TfType to have the given type_info.
    TF_API
    void _DefineCppType(const std::type_info &,
                        size_t sizeofType,
                        bool isPodType,
                        bool isEnumType) const;
 
    // Execute the definition callback if one exists.
    void _ExecuteDefinitionCallback() const;
 
    // Retrieve the \c TfType corresponding to an obj with the
    // given \c type_info.
    TF_API
    static TfType const& _FindByTypeid(const std::type_info &);
 
    // Pointer to internal type representation.
    // Our only data member.
    _TypeInfo *_info;
};
 
TF_API std::ostream& operator<<(std::ostream& out, const TfType &t);
 
template <typename T>
struct TfSizeofType {
    static const size_t value = sizeof(T);
};
template <>
struct TfSizeofType<void> {
    static const size_t value = 0;
};
template <>
struct TfSizeofType<const void> {
    static const size_t value = 0;
};
template <>
struct TfSizeofType<volatile void> {
    static const size_t value = 0;
};
template <>
struct TfSizeofType<const volatile void> {
    static const size_t value = 0;
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
// Implementation details are put in this header.
#include "pxr/base/tf/type_Impl.h"
 
#endif // PXR_BASE_TF_TYPE_H