error.h

//
// Copyright 2024 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
 
#ifndef PXR_USD_VALIDATION_USD_VALIDATION_ERROR_H
#define PXR_USD_VALIDATION_USD_VALIDATION_ERROR_H
 
#include "pxr/pxr.h"
#include "pxr/usd/sdf/path.h"
#include "pxr/usd/usd/property.h"
#include "pxr/usd/usd/stage.h"
#include "pxr/usdValidation/usdValidation/api.h"
 
#include <string>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class UsdPrim;
class UsdValidationValidator;
 
enum class UsdValidationErrorType
{
    None = 0,
    Error,
    Warn,
    Info
};
 
struct UsdValidationErrorSite
{
public:
    UsdValidationErrorSite() = default;
 
    USDVALIDATION_API
    UsdValidationErrorSite(const SdfLayerHandle &layer,
                           const SdfPath &objectPath);
 
    USDVALIDATION_API
    UsdValidationErrorSite(const UsdStagePtr &usdStage,
                           const SdfPath &objectPath,
                           const SdfLayerHandle &layer = SdfLayerHandle());
 
    bool IsValid() const
    {
        return IsValidSpecInLayer() || IsPrim() || IsProperty();
    }
 
    bool IsValidSpecInLayer() const
    {
        if (!_layer || _objectPath.IsEmpty()) {
            return false;
        }
        return _layer->HasSpec(_objectPath);
    }
 
    bool IsPrim() const
    {
        return GetPrim().IsValid();
    }
 
    bool IsProperty() const
    {
        return GetProperty().IsValid();
    }
 
    const SdfPropertySpecHandle GetPropertySpec() const
    {
        if (!_layer) {
            return SdfPropertySpecHandle();
        }
        return _layer->GetPropertyAtPath(_objectPath);
    }
 
    const SdfPrimSpecHandle GetPrimSpec() const
    {
        if (!_layer) {
            return SdfPrimSpecHandle();
        }
        return _layer->GetPrimAtPath(_objectPath);
    }
 
    const SdfLayerHandle &GetLayer() const
    {
        return _layer;
    }
 
    const UsdStagePtr &GetStage() const
    {
        return _usdStage;
    }
 
    UsdPrim GetPrim() const
    {
        if (_usdStage) {
            return _usdStage->GetPrimAtPath(_objectPath);
        }
        return UsdPrim();
    }
 
    UsdProperty GetProperty() const
    {
        if (_usdStage) {
            return _usdStage->GetPropertyAtPath(_objectPath);
        }
        return UsdProperty();
    }
 
    bool operator==(const UsdValidationErrorSite &other) const
    {
        return (_layer == other._layer) && (_usdStage == other._usdStage)
            && (_objectPath == other._objectPath);
    }
 
    bool operator!=(const UsdValidationErrorSite &other) const
    {
        return !(*this == other);
    }
 
private:
    UsdStagePtr _usdStage;
    SdfLayerHandle _layer;
    SdfPath _objectPath;
 
}; // UsdValidationErrorSite
 
using UsdValidationErrorSites = std::vector<UsdValidationErrorSite>;
 
class UsdValidationError
{
public:
    USDVALIDATION_API
    UsdValidationError();
 
    USDVALIDATION_API
    UsdValidationError(const TfToken &name,
                       const UsdValidationErrorType &errorType,
                       const UsdValidationErrorSites &errorSites,
                       const std::string &errorMsg);
 
    bool operator==(const UsdValidationError &other) const
    {
        return (_name == other._name) && (_errorType == other._errorType)
            && (_errorSites == other._errorSites)
            && (_errorMsg == other._errorMsg)
            && (_validator == other._validator);
    }
 
    bool operator!=(const UsdValidationError &other) const
    {
        return !(*this == other);
    }
 
    const TfToken &GetName() const &
    {
        return _name;
    }
 
    TfToken GetName() &&
    {
        return std::move(_name);
    }
 
    UsdValidationErrorType GetType() const
    {
        return _errorType;
    }
 
    const UsdValidationErrorSites &GetSites() const &
    {
        return _errorSites;
    }
 
    UsdValidationErrorSites GetSites() &&
    {
        return std::move(_errorSites);
    }
 
    const UsdValidationValidator *GetValidator() const
    {
        return _validator;
    }
 
    const std::string &GetMessage() const
    {
        return _errorMsg;
    }
 
    USDVALIDATION_API
    TfToken GetIdentifier() const;
 
    USDVALIDATION_API
    std::string GetErrorAsString() const;
 
    bool HasNoError() const
    {
        return _errorType == UsdValidationErrorType::None;
    }
 
private:
    // UsdValidationValidatorError holds a pointer to the UsdValidationValidator
    // that generated it, so we need to provide friend access to allow the
    // necessary mutation.
    friend class UsdValidationValidator;
 
    // Used by UsdValidationValidator::Validate methods to embed itself to the
    // reported errors.
    void _SetValidator(const UsdValidationValidator *validator);
 
    // _validator is set when ValidationError is generated via a
    // UsdValidationValidator::Validate() call.
    const UsdValidationValidator *_validator;
 
    // These data members should not be modified other than during
    // initialization by the validate task functions.
    TfToken _name;
    UsdValidationErrorType _errorType;
    UsdValidationErrorSites _errorSites;
    std::string _errorMsg;
 
    // TODO:(Subsequent iterations)
    // - VtValue of a random value the error wants to propagate down to the
    // fixer
 
}; // UsdValidationError
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_VALIDATION_USD_VALIDATION_ERROR_H