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