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

#ifndef PXR_USD_AR_RESOLVER_V1_H
#define PXR_USD_AR_RESOLVER_V1_H


#include "pxr/pxr.h"
#include "pxr/usd/ar/api.h"
#include <memory>
#include <string>
#include <vector>

PXR_NAMESPACE_OPEN_SCOPE

class ArAsset;
class ArAssetInfo;
class ArResolverContext;
class TfType;
class VtValue;

class ArResolver 
{
public:
    AR_API
    virtual ~ArResolver();

    // Disallow copies
    ArResolver(const ArResolver&) = delete;
    ArResolver& operator=(const ArResolver&) = delete;

    // --------------------------------------------------------------------- //
    // --------------------------------------------------------------------- //

    AR_API
    virtual void ConfigureResolverForAsset(const std::string& path) = 0;

    AR_API
    virtual std::string AnchorRelativePath(
        const std::string& anchorPath, 
        const std::string& path) = 0; 

    AR_API
    virtual bool IsRelativePath(const std::string& path) = 0;

    AR_API
    virtual bool IsRepositoryPath(const std::string& path) = 0;

    AR_API
    virtual bool IsSearchPath(const std::string& path) = 0;

    AR_API
    virtual std::string GetExtension(const std::string& path) = 0;

    AR_API
    virtual std::string ComputeNormalizedPath(const std::string& path) = 0;

    AR_API
    virtual std::string ComputeRepositoryPath(const std::string& path) = 0;

    AR_API
    virtual std::string ComputeLocalPath(const std::string& path) = 0;

    AR_API
    virtual std::string Resolve(const std::string& path) = 0;


    // --------------------------------------------------------------------- //
    // --------------------------------------------------------------------- //

    AR_API
    virtual void BindContext(
        const ArResolverContext& context,
        VtValue* bindingData) = 0;

    AR_API
    virtual void UnbindContext(
        const ArResolverContext& context,
        VtValue* bindingData) = 0;

    AR_API
    virtual ArResolverContext CreateDefaultContext() = 0;

    AR_API
    virtual ArResolverContext CreateDefaultContextForAsset(
        const std::string& filePath) = 0;

    AR_API
    virtual void RefreshContext(const ArResolverContext& context) = 0;

    AR_API
    virtual ArResolverContext GetCurrentContext() = 0;


    // --------------------------------------------------------------------- //
    // --------------------------------------------------------------------- //

    AR_API
    virtual std::string ResolveWithAssetInfo(
        const std::string& path, 
        ArAssetInfo* assetInfo) = 0;

    AR_API
    virtual void UpdateAssetInfo(
        const std::string& identifier,
        const std::string& filePath,
        const std::string& fileVersion,
        ArAssetInfo* assetInfo) = 0;

    AR_API
    virtual VtValue GetModificationTimestamp(
        const std::string& path,
        const std::string& resolvedPath) = 0;

    AR_API
    virtual bool FetchToLocalResolvedPath(
        const std::string& path,
        const std::string& resolvedPath) = 0;

    AR_API
    virtual std::shared_ptr<ArAsset> OpenAsset(
        const std::string& resolvedPath) = 0;

    AR_API
    virtual bool CreatePathForLayer(
        const std::string& path) = 0;

    AR_API
    virtual bool CanWriteLayerToPath(
        const std::string& path,
        std::string* whyNot) = 0;

    AR_API
    virtual bool CanCreateNewLayerWithIdentifier(
        const std::string& identifier, 
        std::string* whyNot) = 0;


    // --------------------------------------------------------------------- //
    // --------------------------------------------------------------------- //

    AR_API
    virtual void BeginCacheScope(
        VtValue* cacheScopeData) = 0;

    AR_API
    virtual void EndCacheScope(
        VtValue* cacheScopeData) = 0;


protected:
    AR_API
    ArResolver();
};

AR_API
ArResolver& ArGetResolver();

AR_API
void ArSetPreferredResolver(const std::string& resolverTypeName);


AR_API
ArResolver& ArGetUnderlyingResolver();

AR_API
std::vector<TfType> ArGetAvailableResolvers();

AR_API
std::unique_ptr<ArResolver> ArCreateResolver(const TfType& resolverType);


PXR_NAMESPACE_CLOSE_SCOPE

#endif