resolverContext.h

Go to the documentation of this file.

//
// Copyright 2020 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_USD_AR_RESOLVER_CONTEXT_H
#define PXR_USD_AR_RESOLVER_CONTEXT_H


#include "pxr/pxr.h"
#include "pxr/usd/ar/api.h"
#include "pxr/usd/ar/ar.h"

#include "pxr/base/tf/hash.h"
#include "pxr/base/tf/safeTypeCompare.h"

#ifdef PXR_PYTHON_SUPPORT_ENABLED
// XXX: This include is a hack to avoid build errors due to
// incompatible macro definitions in pyport.h on macOS.
#include <locale>
#include "pxr/base/tf/pyLock.h"
#endif

#include "pxr/base/tf/pyObjWrapper.h"

#include <algorithm>
#include <memory>
#include <string>
#include <type_traits>
#include <typeinfo>
#include <vector>

PXR_NAMESPACE_OPEN_SCOPE

template <class T>
struct ArIsContextObject
{
    static const bool value = false;
};

template <class Context> 
std::string ArGetDebugString(const Context& context); 

// Metafunctions for determining if a variadic list of objects
// are valid for use with the ArResolverContext c'tor.
class ArResolverContext;

template <class ...Objects> struct Ar_AllValidForContext;

template <class Object, class ...Other>
struct Ar_AllValidForContext<Object, Other...>
{
    static const bool value = 
        (std::is_same<Object, ArResolverContext>::value ||
         ArIsContextObject<Object>::value) &&
        Ar_AllValidForContext<Other...>::value;
};

template <>
struct Ar_AllValidForContext<>
{
    static const bool value = true;
};

class ArResolverContext
{
public:
    ArResolverContext()
    {
    }

    template <
        class ...Objects,
        typename std::enable_if<Ar_AllValidForContext<Objects...>::value>::type*
            = nullptr>
    ArResolverContext(const Objects&... objs)
    {
        _AddObjects(objs...);
    }

    AR_API
    explicit ArResolverContext(const std::vector<ArResolverContext>& ctxs);

    bool IsEmpty() const
    {
        return _contexts.empty();
    }

    template <class ContextObj>
    const ContextObj* Get() const
    {
        for (const auto& context : _contexts) {
            if (context->IsHolding(typeid(ContextObj))) {
                return &_GetTyped<ContextObj>(*context)._context;
            }
        }
        return nullptr;
    }

    AR_API
    std::string GetDebugString() const;

    AR_API
    bool operator==(const ArResolverContext& rhs) const;

    bool operator!=(const ArResolverContext& rhs) const
    {
        return !(*this == rhs);
    }

    AR_API
    bool operator<(const ArResolverContext& rhs) const;


    friend size_t hash_value(const ArResolverContext& context)
    {
        return TfHash()(context._contexts);
    }

private:
    // Type-erased storage for context objects.
    struct _Untyped;
    template <class Context> struct _Typed;

    void _AddObjects()
    {
        // Empty base case for unpacking parameter pack
    }

    template <class Object, class ...Other>
    void _AddObjects(const Object& obj, const Other&... other)
    {
        _Add(obj);
        _AddObjects(other...);
    }

    AR_API
    void _Add(const ArResolverContext& ctx);

    template <class Object>
    void _Add(const Object& obj)
    {
        _Add(std::shared_ptr<_Untyped>(new _Typed<Object>(obj)));
    }

    AR_API
    void _Add(std::shared_ptr<_Untyped>&& context);

    template <class Context> 
    static const _Typed<Context>& _GetTyped(const _Untyped& untyped)
    {
        return static_cast<const _Typed<Context>&>(untyped);
    }

    struct _Untyped 
    {
        AR_API
        virtual ~_Untyped();

        bool IsHolding(const std::type_info& ti) const
        {
            return TfSafeTypeCompare(ti, GetTypeid());
        }

        virtual _Untyped* Clone() const = 0;
        virtual const std::type_info& GetTypeid() const = 0;
        virtual bool LessThan(const _Untyped& rhs) const = 0;
        virtual bool Equals(const _Untyped& rhs) const = 0;
        virtual size_t Hash() const = 0;
        virtual std::string GetDebugString() const = 0;
        virtual TfPyObjWrapper GetPythonObj() const = 0;
    };

    template <class Context>
    struct _Typed : public _Untyped
    {
        virtual ~_Typed() { }

        _Typed(const Context& context) : _context(context)
        { 
        }

        virtual _Untyped* Clone() const
        {
            return new _Typed<Context>(_context);
        }

        virtual const std::type_info& GetTypeid() const
        {
            return typeid(Context);
        }

        virtual bool LessThan(const _Untyped& rhs) const
        {
            return _context < _GetTyped<Context>(rhs)._context;
        }

        virtual bool Equals(const _Untyped& rhs) const
        {
            return _context == _GetTyped<Context>(rhs)._context;
        }

        virtual size_t Hash() const
        {
            return hash_value(_context);
        }

        virtual std::string GetDebugString() const 
        {
            return ArGetDebugString(_context);            
        }

        virtual TfPyObjWrapper GetPythonObj() const
        {
 #ifdef PXR_PYTHON_SUPPORT_ENABLED
            TfPyLock lock;
            return boost::python::object(_context);
#else
            return {};
#endif
        }

        Context _context;
    };

    template <class HashState>
    friend void TfHashAppend(
        HashState& h, const std::shared_ptr<_Untyped>& context)
    {
        h.Append(context->Hash());
    }

#ifdef PXR_PYTHON_SUPPORT_ENABLED
    friend class Ar_ResolverContextPythonAccess;
#endif

    std::vector<std::shared_ptr<_Untyped>> _contexts;
};


// Default implementation for streaming out held contexts.
AR_API
std::string Ar_GetDebugString(const std::type_info&, void const*);

template <class Context>
std::string ArGetDebugString(const Context& context) 
{
    return Ar_GetDebugString(typeid(Context),
                             static_cast<void const*>(&context));
}

PXR_NAMESPACE_CLOSE_SCOPE

#endif