validationRegistry.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_USD_VALIDATION_REGISTRY_H
#define PXR_USD_USD_VALIDATION_REGISTRY_H
 
#include "pxr/pxr.h"
#include "pxr/usd/usd/api.h"
#include "pxr/usd/usd/validator.h"
#include "pxr/base/tf/singleton.h"
 
#include <shared_mutex>
#include <memory>
#include <unordered_map>
 
 
PXR_NAMESPACE_OPEN_SCOPE
 
class UsdValidationRegistry
{
    UsdValidationRegistry(const UsdValidationRegistry&) = delete;
    UsdValidationRegistry& operator=(const UsdValidationRegistry&) = delete;
public:
    USD_API
    static UsdValidationRegistry& GetInstance() {
        return TfSingleton<UsdValidationRegistry>::GetInstance();
    }
 
    USD_API
    void RegisterPluginValidator(const TfToken &validatorName,
                           const UsdValidateLayerTaskFn &layerTaskFn);
 
    USD_API
    void RegisterPluginValidator(const TfToken &validatorName,
                           const UsdValidateStageTaskFn &stageTaskFn);
 
    USD_API
    void RegisterPluginValidator(const TfToken &validatorName,
                           const UsdValidatePrimTaskFn &primTaskFn);
 
    USD_API
    void RegisterValidator(const UsdValidatorMetadata &metadata,
                           const UsdValidateLayerTaskFn &layerTaskFn);
 
    USD_API
    void RegisterValidator(const UsdValidatorMetadata &metadata,
                           const UsdValidateStageTaskFn &stageTaskFn);
 
    USD_API
    void RegisterValidator(const UsdValidatorMetadata &metadata,
                           const UsdValidatePrimTaskFn &primTaskFn);
 
    USD_API
    void RegisterPluginValidatorSuite(const TfToken &validatorSuiteName, 
                                      const std::vector<const UsdValidator*>& 
                                          containedValidators);
 
    USD_API
    void RegisterValidatorSuite(const UsdValidatorMetadata &metadata,
                                const std::vector<const UsdValidator*>&
                                    containedValidators);
 
    bool HasValidator(const TfToken &validatorName) const;
 
    bool HasValidatorSuite(const TfToken &suiteName) const;
 
    USD_API
    std::vector<const UsdValidator*> GetOrLoadAllValidators();
 
    USD_API
    const UsdValidator* GetOrLoadValidatorByName(const TfToken &validatorName);
 
    USD_API
    std::vector<const UsdValidator*> 
    GetOrLoadValidatorsByName(const TfTokenVector &validatorNames);
 
    USD_API
    std::vector<const UsdValidatorSuite*> GetOrLoadAllValidatorSuites();
 
    USD_API
    const UsdValidatorSuite* GetOrLoadValidatorSuiteByName(
        const TfToken &suiteName);
 
    USD_API
    std::vector<const UsdValidatorSuite*> 
    GetOrLoadValidatorSuitesByName(const TfTokenVector &suiteNames);
 
    USD_API
    bool GetValidatorMetadata(const TfToken &name, 
                              UsdValidatorMetadata *metadata) const;
 
    USD_API
    UsdValidatorMetadataVector GetAllValidatorMetadata() const;
 
    USD_API
    UsdValidatorMetadataVector GetValidatorMetadataForPlugin(
        const TfToken &pluginName) const;
 
    USD_API
    UsdValidatorMetadataVector GetValidatorMetadataForKeyword(
        const TfToken &keyword) const;
 
    USD_API
    UsdValidatorMetadataVector GetValidatorMetadataForSchemaType(
        const TfToken &schemaType) const;
 
    USD_API
    UsdValidatorMetadataVector GetValidatorMetadataForPlugins(
        const TfTokenVector &pluginNames) const;
 
    USD_API
    UsdValidatorMetadataVector GetValidatorMetadataForKeywords(
        const TfTokenVector &keywords) const;
 
    USD_API
    UsdValidatorMetadataVector 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);
 
    // Overloaded templated _RegisterValidator, where metadata is explicitly
    // provided. 
    template<typename ValidateTaskFn>
    void _RegisterValidator(const UsdValidatorMetadata &metadata, 
        const ValidateTaskFn &taskFn, bool addMetadata = true);
 
    void _RegisterValidatorSuite(const UsdValidatorMetadata &metadata,
        const std::vector<const UsdValidator*>& 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 UsdValidatorSuite) or not (for UsdValidator).
    static
    bool _CheckMetadata(const UsdValidatorMetadata &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 UsdValidatorMetadata &metadata);
    
    using _ValidatorNameToValidatorMap = 
        std::unordered_map<TfToken, std::unique_ptr<UsdValidator>, 
            TfToken::HashFunctor>;
    using _ValidatorSuiteNameToValidatorSuiteMap = 
        std::unordered_map<TfToken, std::unique_ptr<UsdValidatorSuite>,
            TfToken::HashFunctor>;
    using _ValidatorNameToMetadataMap =
        std::unordered_map<TfToken, UsdValidatorMetadata, TfToken::HashFunctor>;
    using _TokenToValidatorNamesMap =
        std::unordered_map<TfToken, TfTokenVector, TfToken::HashFunctor>;
 
    // Helper to query 
    UsdValidatorMetadataVector _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<UsdValidator>
    _ValidatorNameToValidatorMap _validators;
    // Main datastructure which holds suiteName to 
    // std::unique_ptr<UsdValidatorSuite>
    _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;
};
 
USD_API_TEMPLATE_CLASS(TfSingleton<UsdValidationRegistry>);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_USD_VALIDATION_REGISTRY_H