resolverContext_v1.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 INCLUDE_AR_RESOLVER_CONTEXT
#error This file should not be included directly. Include resolverContext.h instead
#endif

#ifndef PXR_USD_AR_RESOLVER_CONTEXT_V1_H
#define PXR_USD_AR_RESOLVER_CONTEXT_V1_H


#include "pxr/pxr.h"
#include "pxr/usd/ar/api.h"
#include "pxr/base/tf/safeTypeCompare.h"

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

PXR_NAMESPACE_OPEN_SCOPE

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

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

class ArResolverContext
{
public:
    ArResolverContext()
    {
    }

    template <class Context,
              typename std::enable_if<ArIsContextObject<Context>::value>
                  ::type* = nullptr>
    ArResolverContext(const Context& context)
        : _context(new _Typed<Context>(context))
    {
    }

    bool IsEmpty() const
    {
        return !_context;
    }

    template <class Context>
    const Context* Get() const
    {
        return _context && _context->IsHolding(typeid(Context)) ? 
            &_GetTyped<Context>(*_context)._context : NULL;
    }

    std::string GetDebugString() const
    {
        return _context ? _context->GetDebugString() : std::string();
    }

    bool operator==(const ArResolverContext& rhs) const
    {
        if (_context && rhs._context) {
            return (_context->IsHolding(rhs._context->GetTypeid())
                    && _context->Equals(*rhs._context));
        }
        return (!_context && !rhs._context);
    }

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

    bool operator<(const ArResolverContext& rhs) const
    {
        if (_context && rhs._context) {
            if (_context->IsHolding(rhs._context->GetTypeid())) {
                return _context->LessThan(*rhs._context);
            }
            return (std::string(_context->GetTypeid().name()) <
                    std::string(rhs._context->GetTypeid().name()));
        }
        else if (_context && !rhs._context) {
            return false;
        }
        else if (!_context && rhs._context) {
            return true;
        }
        return false;
    }


    friend size_t hash_value(const ArResolverContext& context)
    {
        return context._context ? context._context->Hash() : 0;
    }

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

    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 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;
    };

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

        _Typed(const Context& context) : _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);            
        }

        Context _context;
    };

    std::shared_ptr<_Untyped> _context;
};


// 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