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 "pxr/base/tf/enum.h"

#include <memory>
#include <string>
#include <vector>

PXR_NAMESPACE_OPEN_SCOPE

// Forward declaration:
class PcpCache;

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_OpinionAtRelocationSource,
    PcpErrorType_PrimPermissionDenied,
    PcpErrorType_PropertyPermissionDenied,
    PcpErrorType_SublayerCycle,
    PcpErrorType_TargetPermissionDenied,
    PcpErrorType_UnresolvedPrimPath
};

// 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 TfEnum errorType;

    PcpSiteStr rootSite;

    bool ShouldReportAtMostOnce() const {
        // Capacity errors are reported at most once. (If these limits are
        // reached, there is likely to be a very large number of whatever
        // caused it.)
        return errorType == PcpErrorType_IndexCapacityExceeded ||
            errorType == PcpErrorType_ArcCapacityExceeded ||
            errorType == PcpErrorType_ArcNamespaceDepthCapacityExceeded;
    }
   
protected:
    PcpErrorBase(TfEnum errorType);
};


// Forward declarations:
class PcpErrorArcCycle;
typedef std::shared_ptr<PcpErrorArcCycle> PcpErrorArcCyclePtr;

class PcpErrorArcCycle : public PcpErrorBase {
public:
    static PcpErrorArcCyclePtr New();
    PCP_API ~PcpErrorArcCycle();
    PCP_API virtual std::string ToString() const;
    
    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();
    PCP_API virtual std::string ToString() const;
    
    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();
    PCP_API virtual std::string ToString() const;
    
private:
    PcpErrorCapacityExceeded(PcpErrorType errorType);
};


class PcpErrorInconsistentPropertyBase : public PcpErrorBase {
public:
    PCP_API virtual ~PcpErrorInconsistentPropertyBase();
    
    std::string definingLayerIdentifier;
    SdfPath definingSpecPath;

    std::string conflictingLayerIdentifier;
    SdfPath conflictingSpecPath;
    
protected:
    PcpErrorInconsistentPropertyBase(TfEnum errorType);
};


// Forward declarations:
class PcpErrorInconsistentPropertyType;
typedef std::shared_ptr<PcpErrorInconsistentPropertyType> 
    PcpErrorInconsistentPropertyTypePtr;

class PcpErrorInconsistentPropertyType : 
    public PcpErrorInconsistentPropertyBase {
public:
    static PcpErrorInconsistentPropertyTypePtr New();
    PCP_API ~PcpErrorInconsistentPropertyType();
    PCP_API virtual std::string ToString() const;

    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();
    PCP_API virtual std::string ToString() const;

    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();
    PCP_API virtual std::string ToString() const;

    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();
    PCP_API virtual std::string ToString() const;

    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();
    
    PcpSite site;

    SdfPath targetPath;

    std::string assetPath;

    std::string resolvedAssetPath;

    SdfLayerHandle sourceLayer;

    PcpArcType arcType;

    std::string messages;

protected:
    PcpErrorInvalidAssetPathBase(TfEnum errorType);
};


// Forward declarations:
class PcpErrorInvalidAssetPath;
typedef std::shared_ptr<PcpErrorInvalidAssetPath>
    PcpErrorInvalidAssetPathPtr;

class PcpErrorInvalidAssetPath : public PcpErrorInvalidAssetPathBase {
public:
    static PcpErrorInvalidAssetPathPtr New();
    PCP_API ~PcpErrorInvalidAssetPath();
    PCP_API virtual std::string ToString() const;

private:
    PcpErrorInvalidAssetPath();
};


// Forward declarations:
class PcpErrorMutedAssetPath;
typedef std::shared_ptr<PcpErrorMutedAssetPath>
    PcpErrorMutedAssetPathPtr;

class PcpErrorMutedAssetPath : public PcpErrorInvalidAssetPathBase {
public:
    static PcpErrorMutedAssetPathPtr New();
    PCP_API ~PcpErrorMutedAssetPath();
    PCP_API virtual std::string ToString() const;

private:
    PcpErrorMutedAssetPath();
};


// Forward declarations:
class PcpErrorTargetPathBase;
typedef std::shared_ptr<PcpErrorTargetPathBase>
    PcpErrorTargetPathBasePtr;

class PcpErrorTargetPathBase : public PcpErrorBase {
public:
    PCP_API ~PcpErrorTargetPathBase();

    SdfPath targetPath;
    SdfPath owningPath;
    SdfSpecType ownerSpecType;
    SdfLayerHandle layer;

    SdfPath composedTargetPath;

protected:
    PcpErrorTargetPathBase(TfEnum errorType);
};


// Forward declarations:
class PcpErrorInvalidInstanceTargetPath;
typedef std::shared_ptr<PcpErrorInvalidInstanceTargetPath>
    PcpErrorInvalidInstanceTargetPathPtr;

class PcpErrorInvalidInstanceTargetPath : public PcpErrorTargetPathBase {
public:
    static PcpErrorInvalidInstanceTargetPathPtr New();
    PCP_API ~PcpErrorInvalidInstanceTargetPath();
    PCP_API virtual std::string ToString() const;

private:
    PcpErrorInvalidInstanceTargetPath();
};


// Forward declarations:
class PcpErrorInvalidExternalTargetPath;
typedef std::shared_ptr<PcpErrorInvalidExternalTargetPath>
    PcpErrorInvalidExternalTargetPathPtr;

class PcpErrorInvalidExternalTargetPath : public PcpErrorTargetPathBase {
public:
    static PcpErrorInvalidExternalTargetPathPtr New();
    PCP_API ~PcpErrorInvalidExternalTargetPath();
    PCP_API virtual std::string ToString() const;
    
    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();
    PCP_API virtual std::string ToString() const;

private:
    PcpErrorInvalidTargetPath();
};


// Forward declarations:
class PcpErrorInvalidSublayerOffset;
typedef std::shared_ptr<PcpErrorInvalidSublayerOffset>
    PcpErrorInvalidSublayerOffsetPtr;

class PcpErrorInvalidSublayerOffset : public PcpErrorBase {
public:
    static PcpErrorInvalidSublayerOffsetPtr New();
    PCP_API ~PcpErrorInvalidSublayerOffset();
    PCP_API virtual std::string ToString() const;
    
    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();
    PCP_API virtual std::string ToString() const;
    
    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();
    PCP_API virtual std::string ToString() const;

    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();
    PCP_API virtual std::string ToString() const;
    
    SdfLayerHandle layer;
    std::string sublayerPath;
    std::string messages;

private:
    PcpErrorInvalidSublayerPath();
};


// Forward declarations:
class PcpErrorOpinionAtRelocationSource;
typedef std::shared_ptr<PcpErrorOpinionAtRelocationSource>
    PcpErrorOpinionAtRelocationSourcePtr;

class PcpErrorOpinionAtRelocationSource : public PcpErrorBase {
public:
    static PcpErrorOpinionAtRelocationSourcePtr New();
    PCP_API ~PcpErrorOpinionAtRelocationSource();
    PCP_API virtual std::string ToString() const;
    
    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();
    PCP_API virtual std::string ToString() const;
    
    PcpSiteStr site;
    PcpSiteStr privateSite;

private:
    PcpErrorPrimPermissionDenied();
};


// Forward declarations:
class PcpErrorPropertyPermissionDenied;
typedef std::shared_ptr<PcpErrorPropertyPermissionDenied>
    PcpErrorPropertyPermissionDeniedPtr;

class PcpErrorPropertyPermissionDenied : public PcpErrorBase {
public:
    static PcpErrorPropertyPermissionDeniedPtr New();
    PCP_API ~PcpErrorPropertyPermissionDenied();
    PCP_API virtual std::string ToString() const;
    
    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();
    PCP_API virtual std::string ToString() const;
    
    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();
    PCP_API virtual std::string ToString() const;

private:
    PcpErrorTargetPermissionDenied();
};


// Forward declarations:
class PcpErrorUnresolvedPrimPath;
typedef std::shared_ptr<PcpErrorUnresolvedPrimPath>
    PcpErrorUnresolvedPrimPathPtr;

class PcpErrorUnresolvedPrimPath : public PcpErrorBase {
public:
    static PcpErrorUnresolvedPrimPathPtr New();
    PCP_API ~PcpErrorUnresolvedPrimPath();
    PCP_API virtual std::string ToString() const;
    
    PcpSiteStr site;

    SdfLayerHandle sourceLayer;
    
    SdfLayerHandle targetLayer;

    SdfPath unresolvedPath;

    PcpArcType arcType;

private:
    PcpErrorUnresolvedPrimPath();
};

PCP_API
void PcpRaiseErrors(const PcpErrorVector &errors);

PXR_NAMESPACE_CLOSE_SCOPE

#endif // PXR_USD_PCP_ERRORS_H