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;
class UsdValidationFixer;

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,
                       const VtValue &data = VtValue());

    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;
    }

    const VtValue &GetData() const
    {
        return _data;
    }

    USDVALIDATION_API
    TfToken GetIdentifier() const;

    USDVALIDATION_API
    std::string GetErrorAsString() const;

    bool HasNoError() const
    {
        return _errorType == UsdValidationErrorType::None;
    }

    USDVALIDATION_API
    const std::vector<const UsdValidationFixer *> GetFixers() const;

    USDVALIDATION_API
    const UsdValidationFixer *GetFixerByName(const TfToken &name) const;

    USDVALIDATION_API
    const std::vector<const UsdValidationFixer *> 
    GetFixersByErrorName() const;

    USDVALIDATION_API
    const UsdValidationFixer *GetFixerByNameAndErrorName(
        const TfToken &name) const;

    USDVALIDATION_API
    const std::vector<const UsdValidationFixer *> GetFixersByKeywords(
        const TfTokenVector &keywords) const;


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;
    VtValue _data;

}; // UsdValidationError

PXR_NAMESPACE_CLOSE_SCOPE

#endif // PXR_USD_VALIDATION_USD_VALIDATION_ERROR_H