registry.h

Go to the documentation of this file.

//
// 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_REGISTRY_H
#define PXR_USD_VALIDATION_USD_VALIDATION_REGISTRY_H

#include "pxr/pxr.h"
#include "pxr/base/tf/singleton.h"
#include "pxr/usdValidation/usdValidation/api.h"
#include "pxr/usdValidation/usdValidation/validator.h"
#include "pxr/usdValidation/usdValidation/fixer.h"

#include <memory>
#include <shared_mutex>
#include <unordered_map>


PXR_NAMESPACE_OPEN_SCOPE

class UsdValidationRegistry
{
    UsdValidationRegistry(const UsdValidationRegistry &) = delete;
    UsdValidationRegistry &operator=(const UsdValidationRegistry &) = delete;

public:
    USDVALIDATION_API
    static UsdValidationRegistry &GetInstance()
    {
        return TfSingleton<UsdValidationRegistry>::GetInstance();
    }

    USDVALIDATION_API
    void RegisterPluginValidator(const TfToken &validatorName,
                                 const UsdValidateLayerTaskFn &layerTaskFn,
                                 std::vector<UsdValidationFixer> fixers = {});

    USDVALIDATION_API
    void RegisterPluginValidator(const TfToken &validatorName,
                                 const UsdValidateStageTaskFn &stageTaskFn,
                                 std::vector<UsdValidationFixer> fixers = {});

    USDVALIDATION_API
    void RegisterPluginValidator(const TfToken &validatorName,
                                 const UsdValidatePrimTaskFn &primTaskFn,
                                 std::vector<UsdValidationFixer> fixers = {});

    USDVALIDATION_API
    void RegisterValidator(const UsdValidationValidatorMetadata &metadata,
                           const UsdValidateLayerTaskFn &layerTaskFn,
                           std::vector<UsdValidationFixer> fixers = {});

    USDVALIDATION_API
    void RegisterValidator(const UsdValidationValidatorMetadata &metadata,
                           const UsdValidateStageTaskFn &stageTaskFn,
                           std::vector<UsdValidationFixer> fixers = {});

    USDVALIDATION_API
    void RegisterValidator(const UsdValidationValidatorMetadata &metadata,
                           const UsdValidatePrimTaskFn &primTaskFn,
                           std::vector<UsdValidationFixer> fixers = {});

    USDVALIDATION_API
    void RegisterPluginValidatorSuite(
        const TfToken &validatorSuiteName,
        const std::vector<const UsdValidationValidator *> &containedValidators);

    USDVALIDATION_API
    void RegisterValidatorSuite(
        const UsdValidationValidatorMetadata &metadata,
        const std::vector<const UsdValidationValidator *> &containedValidators);

    USDVALIDATION_API
    bool HasValidator(const TfToken &validatorName) const;

    USDVALIDATION_API
    bool HasValidatorSuite(const TfToken &suiteName) const;

    USDVALIDATION_API
    std::vector<const UsdValidationValidator *> GetOrLoadAllValidators();

    USDVALIDATION_API
    const UsdValidationValidator *
    GetOrLoadValidatorByName(const TfToken &validatorName);

    USDVALIDATION_API
    std::vector<const UsdValidationValidator *>
    GetOrLoadValidatorsByName(const TfTokenVector &validatorNames);

    USDVALIDATION_API
    std::vector<const UsdValidationValidatorSuite *>
    GetOrLoadAllValidatorSuites();

    USDVALIDATION_API
    const UsdValidationValidatorSuite *
    GetOrLoadValidatorSuiteByName(const TfToken &suiteName);

    USDVALIDATION_API
    std::vector<const UsdValidationValidatorSuite *>
    GetOrLoadValidatorSuitesByName(const TfTokenVector &suiteNames);

    USDVALIDATION_API
    bool GetValidatorMetadata(const TfToken &name,
                              UsdValidationValidatorMetadata *metadata) const;

    USDVALIDATION_API
    UsdValidationValidatorMetadataVector GetAllValidatorMetadata() const;

    USDVALIDATION_API
    UsdValidationValidatorMetadataVector
    GetValidatorMetadataForPlugin(const TfToken &pluginName) const;

    USDVALIDATION_API
    UsdValidationValidatorMetadataVector
    GetValidatorMetadataForKeyword(const TfToken &keyword) const;

    USDVALIDATION_API
    UsdValidationValidatorMetadataVector
    GetValidatorMetadataForSchemaType(const TfToken &schemaType) const;

    USDVALIDATION_API
    UsdValidationValidatorMetadataVector
    GetValidatorMetadataForPlugins(const TfTokenVector &pluginNames) const;

    USDVALIDATION_API
    UsdValidationValidatorMetadataVector
    GetValidatorMetadataForKeywords(const TfTokenVector &keywords) const;

    USDVALIDATION_API
    UsdValidationValidatorMetadataVector
    GetValidatorMetadataForSchemaTypes(const TfTokenVector &schemaTypes) const;

private:
    friend class TfSingleton<UsdValidationRegistry>;

    UsdValidationRegistry();

    // Initialize _validatorNameToMetadata, _keywordToValidatorNames and
    // _schemaTypeToValidatorNames by parsing all plugInfo.json, find all
    // Validators.
    void _PopulateMetadataFromPlugInfo();

    // Templated method to register validator, called by appropriate
    // RegisterValidator methods, providing UsdValidateLayerTaskFn,
    // UsdValidateStageTaskFn or UsdValidatePrimTaskFn.
    template <typename ValidateTaskFn>
    void _RegisterPluginValidator(const TfToken &validatorName,
                                  const ValidateTaskFn &taskFn,
                                  std::vector<UsdValidationFixer> fixers);

    // Overloaded templated _RegisterValidator, where metadata is explicitly
    // provided.
    template <typename ValidateTaskFn>
    void _RegisterValidator(const UsdValidationValidatorMetadata &metadata,
                            const ValidateTaskFn &taskFn,
                            std::vector<UsdValidationFixer> fixers,
                            bool addMetadata = true);

    void _RegisterValidatorSuite(
        const UsdValidationValidatorMetadata &metadata,
        const std::vector<const UsdValidationValidator *> &containedValidators,
        bool addMetadata = true);

    // makes sure metadata provided is legal
    // checkForPrimTask parameter is used to determine if schemaTypes metadata
    // is provided and if the task being registered for the validator is
    // UsdValidatePrimTaskFn.
    // expectSuite parameter is used to determine if the isSuite metadata is
    // appropriately set (for UsdValidationValidatorSuite) or not (for
    // UsdValidationValidator).
    static bool _CheckMetadata(const UsdValidationValidatorMetadata &metadata,
                               bool checkForPrimTask, bool expectSuite = false);

    // Add validator metadata to _validatorNameToMetadata, also updates
    // _schemaTypeToValidatorNames and _keywordToValidatorNames, for easy access
    // to what validators are linked to specific schemaTypes or keywords.
    // _mutex must be acquired before calling this method.
    bool _AddValidatorMetadata(const UsdValidationValidatorMetadata &metadata);

    using _ValidatorNameToValidatorMap
        = std::unordered_map<TfToken, std::unique_ptr<UsdValidationValidator>,
                             TfToken::HashFunctor>;
    using _ValidatorSuiteNameToValidatorSuiteMap
        = std::unordered_map<TfToken,
                             std::unique_ptr<UsdValidationValidatorSuite>,
                             TfToken::HashFunctor>;
    using _ValidatorNameToMetadataMap
        = std::unordered_map<TfToken, UsdValidationValidatorMetadata,
                             TfToken::HashFunctor>;
    using _TokenToValidatorNamesMap
        = std::unordered_map<TfToken, TfTokenVector, TfToken::HashFunctor>;

    // Helper to query
    UsdValidationValidatorMetadataVector _GetValidatorMetadataForToken(
        const _TokenToValidatorNamesMap &tokenToValidatorNames,
        const TfTokenVector &tokens) const;

    // Helper to populate _keywordToValidatorNames and
    // _schemaTypeToValidatorNames
    // _mutex must be acquired before calling this method.
    static void
    _UpdateValidatorNamesMappings(_TokenToValidatorNamesMap &tokenMap,
                                  const TfToken &validatorName,
                                  const TfTokenVector &tokens);

    // Main datastructure which holds validatorName to
    // std::unique_ptr<UsdValidationValidator>
    _ValidatorNameToValidatorMap _validators;
    // Main datastructure which holds suiteName to
    // std::unique_ptr<UsdValidationValidatorSuite>
    _ValidatorSuiteNameToValidatorSuiteMap _validatorSuites;

    // ValidatorName to ValidatorMetadata map
    _ValidatorNameToMetadataMap _validatorNameToMetadata;

    // Following 3 are helper data structures to easy lookup for Validators,
    // when queried for keywords, schemaType or pluginName.

    // This map stores the mapping from keyword to validator names. It may get
    // updated as validators can be registered dynamically outside of the plugin
    // infrastructure.
    _TokenToValidatorNamesMap _keywordToValidatorNames;

    // This map stores the mapping from schemaTypes to validator names. It may
    // get updated as validators can be registered dynamically outside of the
    // plugin infrastructure.
    _TokenToValidatorNamesMap _schemaTypeToValidatorNames;

    // This map stores the mapping from plugin names to validator names.
    // It is populated during the initialization of UsdValidationRegistry
    // and remains constant thereafter.
    _TokenToValidatorNamesMap _pluginNameToValidatorNames;

    // Mutex to protect access to all data members.
    mutable std::shared_mutex _mutex;
};

// Specialize and delete the DeleteInstance function to prevent destruction.
// This will prevent the singleton instance for UsdValidationRegistry from
// being destroyed and hence making it immortal.
template <> void TfSingleton<UsdValidationRegistry>::DeleteInstance() = delete;

USDVALIDATION_API_TEMPLATE_CLASS(TfSingleton<UsdValidationRegistry>);

PXR_NAMESPACE_CLOSE_SCOPE

#endif // PXR_USD_VALIDATION_USD_VALIDATION_REGISTRY_H