validationError.h

//
// Copyright 2024 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
 
#ifndef PXR_USD_USD_VALIDATION_ERROR_H
#define PXR_USD_USD_VALIDATION_ERROR_H
 
#include "pxr/pxr.h"
#include "pxr/usd/sdf/path.h"
#include "pxr/usd/usd/stage.h"
#include "pxr/usd/usd/property.h"
 
#include <string>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class UsdPrim;
class UsdValidator;
 
enum class UsdValidationErrorType {
    None = 0,
    Error,
    Warn,
    Info
};
 
struct UsdValidationErrorSite
{
public:
    UsdValidationErrorSite() = default;
 
    USD_API
    UsdValidationErrorSite(const SdfLayerHandle &layer,
                                    const SdfPath &objectPath);
 
    USD_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:
    USD_API
    UsdValidationError();
 
    USD_API
    UsdValidationError(const UsdValidationErrorType &errorType, 
                       const UsdValidationErrorSites &errorSites, 
                       const std::string &errorMsg);
 
    bool operator==(const UsdValidationError& other) const {
        return (_errorType == other._errorType) &&
               (_errorSites == other._errorSites) &&
               (_errorMsg == other._errorMsg) &&
               (_validator == other._validator);
    }
 
    bool operator!=(const UsdValidationError& other) const {
        return !(*this == other);
    }
 
    UsdValidationErrorType GetType() const
    {
        return _errorType;
    }
 
    const UsdValidationErrorSites& GetSites() const
    {
        return _errorSites;
    }
 
    const UsdValidator* GetValidator() const
    {
        return _validator;
    }
 
    const std::string& GetMessage() const
    {
        return _errorMsg;
    }
 
    USD_API
    std::string GetErrorAsString() const;
 
    bool HasNoError() const {
      return _errorType == UsdValidationErrorType::None;
    }
 
private:
    // UsdValidatorError holds a pointer to the UsdValidator that generated it, so
    // we need to provide friend access to allow the necessary mutation.
    friend class UsdValidator;
 
    // Used by UsdValidator::Validate methods to embed itself to the reported
    // errors.
    void _SetValidator(const UsdValidator *validator);
 
    // _validator is set when ValidationError is generated via a 
    // UsdValidator::Validate() call.
    const UsdValidator *_validator;
 
    // These data members should not be modified other than during
    // initialization by the validate task functions.
    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_USD_VALIDATION_ERROR_H