errors.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_USD_PCP_ERRORS_H
#define PXR_USD_PCP_ERRORS_H
 
#include "pxr/pxr.h"
#include "pxr/usd/pcp/api.h"
#include "pxr/usd/pcp/site.h"
#include "pxr/usd/pcp/types.h"
#include "pxr/usd/sdf/layer.h"
#include "pxr/usd/sdf/layerOffset.h"
#include "pxr/usd/sdf/path.h"
 
#include <memory>
#include <string>
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
enum PcpErrorType {
    PcpErrorType_ArcCycle,
    PcpErrorType_ArcPermissionDenied,
    PcpErrorType_IndexCapacityExceeded,
    PcpErrorType_ArcCapacityExceeded,
    PcpErrorType_ArcNamespaceDepthCapacityExceeded,
    PcpErrorType_InconsistentPropertyType,
    PcpErrorType_InconsistentAttributeType,
    PcpErrorType_InconsistentAttributeVariability,
    PcpErrorType_InternalAssetPath,
    PcpErrorType_InvalidPrimPath,
    PcpErrorType_InvalidAssetPath,
    PcpErrorType_InvalidInstanceTargetPath,
    PcpErrorType_InvalidExternalTargetPath,
    PcpErrorType_InvalidTargetPath,
    PcpErrorType_InvalidReferenceOffset,
    PcpErrorType_InvalidSublayerOffset,
    PcpErrorType_InvalidSublayerOwnership,
    PcpErrorType_InvalidSublayerPath,
    PcpErrorType_InvalidVariantSelection,
    PcpErrorType_MutedAssetPath,
    PcpErrorType_InvalidAuthoredRelocation,
    PcpErrorType_InvalidConflictingRelocation,
    PcpErrorType_InvalidSameTargetRelocations,
    PcpErrorType_OpinionAtRelocationSource,
    PcpErrorType_PrimPermissionDenied,
    PcpErrorType_PropertyPermissionDenied,
    PcpErrorType_SublayerCycle,
    PcpErrorType_TargetPermissionDenied,
    PcpErrorType_UnresolvedPrimPath,
    PcpErrorType_VariableExpressionError
};
 
// Forward declarations:
class PcpErrorBase;
typedef std::shared_ptr<PcpErrorBase> PcpErrorBasePtr;
typedef std::vector<PcpErrorBasePtr> PcpErrorVector;
 
class PcpErrorBase {
public:
    PCP_API virtual ~PcpErrorBase();
    virtual std::string ToString() const = 0;
 
    const PcpErrorType errorType;
 
    PcpSite rootSite;
 
protected:
    explicit PcpErrorBase(PcpErrorType errorType);
};
 
 
// Forward declarations:
class PcpErrorArcCycle;
typedef std::shared_ptr<PcpErrorArcCycle> PcpErrorArcCyclePtr;
 
class PcpErrorArcCycle : public PcpErrorBase {
public:
    static PcpErrorArcCyclePtr New();
    PCP_API ~PcpErrorArcCycle() override;
    PCP_API std::string ToString() const override;
    
    PcpSiteTracker cycle;
    
private:
    PcpErrorArcCycle();
};
 
 
// Forward declarations:
class PcpErrorArcPermissionDenied;
typedef std::shared_ptr<PcpErrorArcPermissionDenied> 
    PcpErrorArcPermissionDeniedPtr;
 
class PcpErrorArcPermissionDenied : public PcpErrorBase {
public:
    static PcpErrorArcPermissionDeniedPtr New();
    PCP_API ~PcpErrorArcPermissionDenied() override;
    PCP_API std::string ToString() const override;
    
    PcpSite site;
    PcpSite privateSite;
    PcpArcType arcType;
    
private:
    PcpErrorArcPermissionDenied();
};
 
 
// Forward declarations:
class PcpErrorCapacityExceeded;
typedef std::shared_ptr<PcpErrorCapacityExceeded> PcpErrorCapacityExceededPtr;
 
class PcpErrorCapacityExceeded : public PcpErrorBase {
public:
    static PcpErrorCapacityExceededPtr New(PcpErrorType errorType);
    PCP_API ~PcpErrorCapacityExceeded() override;
    PCP_API std::string ToString() const override;
    
private:
    PcpErrorCapacityExceeded(PcpErrorType errorType);
};
 
 
class PcpErrorInconsistentPropertyBase : public PcpErrorBase {
public:
    PCP_API ~PcpErrorInconsistentPropertyBase() override;
    
    std::string definingLayerIdentifier;
    SdfPath definingSpecPath;
 
    std::string conflictingLayerIdentifier;
    SdfPath conflictingSpecPath;
    
protected:
    PcpErrorInconsistentPropertyBase(PcpErrorType errorType);
};
 
 
// Forward declarations:
class PcpErrorInconsistentPropertyType;
typedef std::shared_ptr<PcpErrorInconsistentPropertyType> 
    PcpErrorInconsistentPropertyTypePtr;
 
class PcpErrorInconsistentPropertyType : 
    public PcpErrorInconsistentPropertyBase {
public:
    static PcpErrorInconsistentPropertyTypePtr New();
    PCP_API ~PcpErrorInconsistentPropertyType() override;
    PCP_API std::string ToString() const override;
 
    SdfSpecType definingSpecType;
    SdfSpecType conflictingSpecType;
    
private:
    PcpErrorInconsistentPropertyType();
};
 
 
// Forward declarations:
class PcpErrorInconsistentAttributeType;
typedef std::shared_ptr<PcpErrorInconsistentAttributeType> 
    PcpErrorInconsistentAttributeTypePtr;
 
class PcpErrorInconsistentAttributeType : 
    public PcpErrorInconsistentPropertyBase {
public:
    static PcpErrorInconsistentAttributeTypePtr New();
    PCP_API ~PcpErrorInconsistentAttributeType() override;
    PCP_API std::string ToString() const override;
 
    TfToken definingValueType;
    TfToken conflictingValueType;
 
private:
    PcpErrorInconsistentAttributeType();
};
 
 
// Forward declarations:
class PcpErrorInconsistentAttributeVariability;
typedef std::shared_ptr<PcpErrorInconsistentAttributeVariability> 
    PcpErrorInconsistentAttributeVariabilityPtr;
 
class PcpErrorInconsistentAttributeVariability : 
    public PcpErrorInconsistentPropertyBase {
public:
    static PcpErrorInconsistentAttributeVariabilityPtr New();
    PCP_API ~PcpErrorInconsistentAttributeVariability() override;
    PCP_API std::string ToString() const override;
 
    SdfVariability definingVariability;
    SdfVariability conflictingVariability;
 
private:
    PcpErrorInconsistentAttributeVariability();
};
 
 
// Forward declarations:
class PcpErrorInvalidPrimPath;
typedef std::shared_ptr<PcpErrorInvalidPrimPath>
    PcpErrorInvalidPrimPathPtr;
 
class PcpErrorInvalidPrimPath : public PcpErrorBase {
public:        
    static PcpErrorInvalidPrimPathPtr New();
    PCP_API ~PcpErrorInvalidPrimPath() override;
    PCP_API std::string ToString() const override;
 
    PcpSite site;
 
    SdfPath primPath;
 
    SdfLayerHandle sourceLayer;
 
    PcpArcType arcType;
 
private:
    PcpErrorInvalidPrimPath();
};
 
 
// Forward declarations:
class PcpErrorInvalidAssetPathBase;
typedef std::shared_ptr<PcpErrorInvalidAssetPathBase>
    PcpErrorInvalidAssetPathBasePtr;
 
class PcpErrorInvalidAssetPathBase : public PcpErrorBase {
public:
    PCP_API ~PcpErrorInvalidAssetPathBase() override;
    
    PcpSite site;
 
    SdfPath targetPath;
 
    std::string assetPath;
 
    std::string resolvedAssetPath;
 
    SdfLayerHandle sourceLayer;
 
    PcpArcType arcType;
 
    std::string messages;
 
protected:
    PcpErrorInvalidAssetPathBase(PcpErrorType errorType);
};
 
 
// Forward declarations:
class PcpErrorInvalidAssetPath;
typedef std::shared_ptr<PcpErrorInvalidAssetPath>
    PcpErrorInvalidAssetPathPtr;
 
class PcpErrorInvalidAssetPath : public PcpErrorInvalidAssetPathBase {
public:
    static PcpErrorInvalidAssetPathPtr New();
    PCP_API ~PcpErrorInvalidAssetPath() override;
    PCP_API std::string ToString() const override;
 
private:
    PcpErrorInvalidAssetPath();
};
 
 
// Forward declarations:
class PcpErrorMutedAssetPath;
typedef std::shared_ptr<PcpErrorMutedAssetPath>
    PcpErrorMutedAssetPathPtr;
 
class PcpErrorMutedAssetPath : public PcpErrorInvalidAssetPathBase {
public:
    static PcpErrorMutedAssetPathPtr New();
    PCP_API ~PcpErrorMutedAssetPath() override;
    PCP_API std::string ToString() const override;
 
private:
    PcpErrorMutedAssetPath();
};
 
 
// Forward declarations:
class PcpErrorTargetPathBase;
typedef std::shared_ptr<PcpErrorTargetPathBase>
    PcpErrorTargetPathBasePtr;
 
class PcpErrorTargetPathBase : public PcpErrorBase {
public:
    PCP_API ~PcpErrorTargetPathBase() override;
 
    SdfPath targetPath;
    SdfPath owningPath;
    SdfSpecType ownerSpecType;
    SdfLayerHandle layer;
 
    SdfPath composedTargetPath;
 
protected:
    PcpErrorTargetPathBase(PcpErrorType errorType);
};
 
 
// Forward declarations:
class PcpErrorInvalidInstanceTargetPath;
typedef std::shared_ptr<PcpErrorInvalidInstanceTargetPath>
    PcpErrorInvalidInstanceTargetPathPtr;
 
class PcpErrorInvalidInstanceTargetPath : public PcpErrorTargetPathBase {
public:
    static PcpErrorInvalidInstanceTargetPathPtr New();
    PCP_API ~PcpErrorInvalidInstanceTargetPath() override;
    PCP_API std::string ToString() const override;
 
private:
    PcpErrorInvalidInstanceTargetPath();
};
 
 
// Forward declarations:
class PcpErrorInvalidExternalTargetPath;
typedef std::shared_ptr<PcpErrorInvalidExternalTargetPath>
    PcpErrorInvalidExternalTargetPathPtr;
 
class PcpErrorInvalidExternalTargetPath : public PcpErrorTargetPathBase {
public:
    static PcpErrorInvalidExternalTargetPathPtr New();
    PCP_API ~PcpErrorInvalidExternalTargetPath() override;
    PCP_API std::string ToString() const override;
    
    PcpArcType ownerArcType;
    SdfPath ownerIntroPath;
 
private:
    PcpErrorInvalidExternalTargetPath();
};
 
 
// Forward declarations:
class PcpErrorInvalidTargetPath;
typedef std::shared_ptr<PcpErrorInvalidTargetPath>
    PcpErrorInvalidTargetPathPtr;
 
class PcpErrorInvalidTargetPath : public PcpErrorTargetPathBase {
public:
    static PcpErrorInvalidTargetPathPtr New();
    PCP_API ~PcpErrorInvalidTargetPath() override;
    PCP_API std::string ToString() const override;
 
private:
    PcpErrorInvalidTargetPath();
};
 
 
// Forward declarations:
class PcpErrorInvalidSublayerOffset;
typedef std::shared_ptr<PcpErrorInvalidSublayerOffset>
    PcpErrorInvalidSublayerOffsetPtr;
 
class PcpErrorInvalidSublayerOffset : public PcpErrorBase {
public:
    static PcpErrorInvalidSublayerOffsetPtr New();
    PCP_API ~PcpErrorInvalidSublayerOffset() override;
    PCP_API std::string ToString() const override;
    
    SdfLayerHandle layer;
    SdfLayerHandle sublayer;
    SdfLayerOffset offset;
 
private:
    PcpErrorInvalidSublayerOffset();
};
 
 
// Forward declarations:
class PcpErrorInvalidReferenceOffset;
typedef std::shared_ptr<PcpErrorInvalidReferenceOffset>
    PcpErrorInvalidReferenceOffsetPtr;
 
class PcpErrorInvalidReferenceOffset : public PcpErrorBase {
public:
    static PcpErrorInvalidReferenceOffsetPtr New();
    PCP_API ~PcpErrorInvalidReferenceOffset() override;
    PCP_API std::string ToString() const override;
    
    SdfLayerHandle sourceLayer;
 
    SdfPath sourcePath;
 
    std::string assetPath;
 
    SdfPath targetPath;
 
    SdfLayerOffset offset;
 
    PcpArcType arcType;
 
private:
    PcpErrorInvalidReferenceOffset();
};
 
 
// Forward declarations:
class PcpErrorInvalidSublayerOwnership;
typedef std::shared_ptr<PcpErrorInvalidSublayerOwnership>
    PcpErrorInvalidSublayerOwnershipPtr;
 
class PcpErrorInvalidSublayerOwnership : public PcpErrorBase {
public:
    static PcpErrorInvalidSublayerOwnershipPtr New();
    PCP_API ~PcpErrorInvalidSublayerOwnership() override;
    PCP_API std::string ToString() const override;
 
    std::string owner;
    SdfLayerHandle layer;
    SdfLayerHandleVector sublayers;
 
private:
    PcpErrorInvalidSublayerOwnership();
};
 
 
// Forward declarations:
class PcpErrorInvalidSublayerPath;
typedef std::shared_ptr<PcpErrorInvalidSublayerPath>
    PcpErrorInvalidSublayerPathPtr;
 
class PcpErrorInvalidSublayerPath : public PcpErrorBase {
public:
    static PcpErrorInvalidSublayerPathPtr New();
    PCP_API ~PcpErrorInvalidSublayerPath() override;
    PCP_API std::string ToString() const override;
    
    SdfLayerHandle layer;
    std::string sublayerPath;
    std::string messages;
 
private:
    PcpErrorInvalidSublayerPath();
};
 
 
// Forward declarations:
class PcpErrorRelocationBase;
typedef std::shared_ptr<PcpErrorRelocationBase>
    PcpErrorRelocationBasePtr;
 
class PcpErrorRelocationBase : public PcpErrorBase {
public:
    PCP_API ~PcpErrorRelocationBase() override;
 
protected:
    PcpErrorRelocationBase(PcpErrorType errorType);
};
 
 
// Forward declarations:
class PcpErrorInvalidAuthoredRelocation;
typedef std::shared_ptr<PcpErrorInvalidAuthoredRelocation>
    PcpErrorInvalidAuthoredRelocationPtr;
 
class PcpErrorInvalidAuthoredRelocation : public PcpErrorRelocationBase {
public:
    static PcpErrorInvalidAuthoredRelocationPtr New();
    PCP_API ~PcpErrorInvalidAuthoredRelocation() override;
    PCP_API std::string ToString() const override;
    
    SdfPath sourcePath;
    SdfPath targetPath;
    SdfLayerHandle layer;
    SdfPath owningPath;
 
    std::string messages;
 
private:
    PcpErrorInvalidAuthoredRelocation();
};
 
 
// Forward declarations:
class PcpErrorInvalidConflictingRelocation;
typedef std::shared_ptr<PcpErrorInvalidConflictingRelocation>
    PcpErrorInvalidConflictingRelocationPtr;
 
class PcpErrorInvalidConflictingRelocation : public PcpErrorRelocationBase {
public:
    static PcpErrorInvalidConflictingRelocationPtr New();
    PCP_API ~PcpErrorInvalidConflictingRelocation() override;
    PCP_API std::string ToString() const override;
 
    SdfPath sourcePath;
    SdfPath targetPath;
    SdfLayerHandle layer;
    SdfPath owningPath;
 
    SdfPath conflictSourcePath;
    SdfPath conflictTargetPath;
    SdfLayerHandle conflictLayer;
    SdfPath conflictOwningPath;
 
    enum class ConflictReason {
        TargetIsConflictSource,
        SourceIsConflictTarget,
        TargetIsConflictSourceDescendant,
        SourceIsConflictSourceDescendant
    };
 
    ConflictReason conflictReason;
 
private:
    PcpErrorInvalidConflictingRelocation();
};
 
 
// Forward declarations:
class PcpErrorInvalidSameTargetRelocations;
typedef std::shared_ptr<PcpErrorInvalidSameTargetRelocations>
    PcpErrorInvalidSameTargetRelocationsPtr;
 
class PcpErrorInvalidSameTargetRelocations : public PcpErrorRelocationBase {
public:
    static PcpErrorInvalidSameTargetRelocationsPtr New();
    PCP_API ~PcpErrorInvalidSameTargetRelocations() override;
    PCP_API std::string ToString() const override;
 
    SdfPath targetPath;
 
    struct RelocationSource {
        SdfPath sourcePath;
        SdfLayerHandle layer;
        SdfPath owningPath;
    };
 
    std::vector<RelocationSource> sources;
 
private:
    PcpErrorInvalidSameTargetRelocations();
};
 
 
// Forward declarations:
class PcpErrorOpinionAtRelocationSource;
typedef std::shared_ptr<PcpErrorOpinionAtRelocationSource>
    PcpErrorOpinionAtRelocationSourcePtr;
 
class PcpErrorOpinionAtRelocationSource : public PcpErrorBase {
public:
    static PcpErrorOpinionAtRelocationSourcePtr New();
    PCP_API ~PcpErrorOpinionAtRelocationSource() override;
    PCP_API std::string ToString() const override;
    
    SdfLayerHandle layer;
    SdfPath path;
 
private:
    PcpErrorOpinionAtRelocationSource();
};
 
 
// Forward declarations:
class PcpErrorPrimPermissionDenied;
typedef std::shared_ptr<PcpErrorPrimPermissionDenied>
    PcpErrorPrimPermissionDeniedPtr;
 
class PcpErrorPrimPermissionDenied : public PcpErrorBase {
public:
    static PcpErrorPrimPermissionDeniedPtr New();
    PCP_API ~PcpErrorPrimPermissionDenied() override;
    PCP_API std::string ToString() const override;
    
    PcpSite site;
    PcpSite privateSite;
 
private:
    PcpErrorPrimPermissionDenied();
};
 
 
// Forward declarations:
class PcpErrorPropertyPermissionDenied;
typedef std::shared_ptr<PcpErrorPropertyPermissionDenied>
    PcpErrorPropertyPermissionDeniedPtr;
 
class PcpErrorPropertyPermissionDenied : public PcpErrorBase {
public:
    static PcpErrorPropertyPermissionDeniedPtr New();
    PCP_API ~PcpErrorPropertyPermissionDenied() override;
    PCP_API std::string ToString() const override;
    
    SdfPath propPath;
    SdfSpecType propType;
    std::string layerPath;
 
private:
    PcpErrorPropertyPermissionDenied();
};
 
 
// Forward declarations:
class PcpErrorSublayerCycle;
typedef std::shared_ptr<PcpErrorSublayerCycle> PcpErrorSublayerCyclePtr;
 
class PcpErrorSublayerCycle : public PcpErrorBase {
public:
    static PcpErrorSublayerCyclePtr New();
    PCP_API ~PcpErrorSublayerCycle() override;
    PCP_API std::string ToString() const override;
    
    SdfLayerHandle layer;
    SdfLayerHandle sublayer;
 
private:
    PcpErrorSublayerCycle();
};
 
 
// Forward declarations:
class PcpErrorTargetPermissionDenied;
typedef std::shared_ptr<PcpErrorTargetPermissionDenied>
    PcpErrorTargetPermissionDeniedPtr;
 
class PcpErrorTargetPermissionDenied : public PcpErrorTargetPathBase {
public:
    static PcpErrorTargetPermissionDeniedPtr New();
    PCP_API ~PcpErrorTargetPermissionDenied() override;
    PCP_API std::string ToString() const override;
 
private:
    PcpErrorTargetPermissionDenied();
};
 
 
// Forward declarations:
class PcpErrorUnresolvedPrimPath;
typedef std::shared_ptr<PcpErrorUnresolvedPrimPath>
    PcpErrorUnresolvedPrimPathPtr;
 
class PcpErrorUnresolvedPrimPath : public PcpErrorBase {
public:
    static PcpErrorUnresolvedPrimPathPtr New();
    PCP_API ~PcpErrorUnresolvedPrimPath() override;
    PCP_API std::string ToString() const override;
    
    PcpSite site;
 
    SdfLayerHandle sourceLayer;
    
    SdfLayerHandle targetLayer;
 
    SdfPath unresolvedPath;
 
    PcpArcType arcType;
 
private:
    PcpErrorUnresolvedPrimPath();
};
 
 
// Forward declarations:
class PcpErrorVariableExpressionError;
typedef std::shared_ptr<PcpErrorVariableExpressionError>
    PcpErrorVariableExpressionErrorPtr;
 
class PcpErrorVariableExpressionError : public PcpErrorBase {
public:
    static PcpErrorVariableExpressionErrorPtr New();
 
    PCP_API ~PcpErrorVariableExpressionError() override;
 
    PCP_API std::string ToString() const override;
 
    std::string expression;
 
    std::string expressionError;
 
    std::string context;
 
    SdfLayerHandle sourceLayer;
 
    SdfPath sourcePath;
 
private:
    PcpErrorVariableExpressionError();
};
 
 
PCP_API
void PcpRaiseErrors(const PcpErrorVector &errors);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_PCP_ERRORS_H