profileRegistry.h

Go to the documentation of this file.

//
// Copyright 2026 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_USD_PROFILE_REGISTRY_H
#define PXR_USD_PROFILE_REGISTRY_H
 
 
#include "pxr/usd/usdProfiles/api.h"
#include "pxr/base/tf/type.h"
#include "pxr/base/tf/weakBase.h"
#include "pxr/base/tf/singleton.h"
#include "pxr/base/tf/staticTokens.h"
#include "pxr/base/tf/token.h"
#include "pxr/base/vt/dictionary.h"
#include "pxr/base/js/types.h"
 
#include <memory>
#include <set>
#include <string>
#include <utility>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class UsdProfileRegistry : public TfSingleton<UsdProfileRegistry>
{
    UsdProfileRegistry(const UsdProfileRegistry&) = delete;
    UsdProfileRegistry& operator=(const UsdProfileRegistry&) = delete;
    public:
    enum class QueryStatus {
        NoPath,
        ValidPath,
        Deprecated,
        DeprecationConflict,
        Excepted,
        CycleFound,
    };
 
    USDPROFILES_API static bool HasCapability(const TfToken& capability);
 
    USDPROFILES_API static bool IsProfile(const TfToken& capability);
 
    USDPROFILES_API
    static VtDictionary GetCapabilityMetadata(const TfToken& capability);
 
    struct CapabilityResult {
        TfToken capability;
        QueryStatus status;
 
        bool operator<(const CapabilityResult& rhs) const {
            return capability < rhs.capability;
        }
    };
 
    USDPROFILES_API static
    std::set<CapabilityResult> GetPredecessors(const TfToken& capability);
 
    USDPROFILES_API static
    std::set<CapabilityResult> GetTransitivePredecessors(const TfToken& capability);
 
    USDPROFILES_API static 
    std::pair<TfToken, int> ParseCapabilityVersion(const TfToken& capability);
 
    USDPROFILES_API static TfToken ResolveCapability(const TfToken& capability);
 
    USDPROFILES_API static QueryStatus HasPredecessor(const TfToken& capabilityA,
                                                      const TfToken& capabilityB);
 
    USDPROFILES_API static QueryStatus CoversCapabilities(
                                    const TfToken& perspective,
                                    const std::set<TfToken>& required,
                                    const std::set<TfToken>& excepted = {},
                                    std::set<CapabilityResult>* results = nullptr);
 
    USDPROFILES_API
    static std::set<TfToken>
    GetSchemaImpliedCapabilities(const TfType& schemaType);
 
    USDPROFILES_API
    static std::set<TfToken>
    GetFileFormatImpliedCapabilities(const TfType& formatType);
 
    USDPROFILES_API static std::set<TfToken> GetAllCapabilities();
 
    USDPROFILES_API static std::set<TfToken> GetAllProfiles();
 
    static std::set<TfToken>
    CapabilityResultsToTokens(const std::set<CapabilityResult>& results) {
        std::set<TfToken> tokens;
        for (const auto& r : results) {
            tokens.insert(r.capability);
        }
        return tokens;
    }
 
    // Style, Subgraph, DocString, and DisplayName are all meant for 
    // visualization purposes. Styles can be used to give a capability a distinct
    // appearance, subgraph can be used to group capabilities into a box.
 
    USDPROFILES_API static TfToken GetStyleForCapability(const TfToken& capability);
 
    USDPROFILES_API static TfToken GetSubgraphForCapability(const TfToken& capability);
 
    USDPROFILES_API static std::string GetDocString(const TfToken& capability);
 
    USDPROFILES_API static std::string GetDisplayName(const TfToken& capability);
 
    USDPROFILES_API static std::map<TfToken, std::string> GetCapabilityStyles();
 
private:
    friend class Usd_ProfilesRegistryTestAccess;
    friend class TfSingleton<UsdProfileRegistry>;
 
    UsdProfileRegistry();
    ~UsdProfileRegistry();
    
    static UsdProfileRegistry& GetInstance();
 
    void _RegisterFromPlugins();
 
    bool _LoadCapabilitiesFromProfileData(const JsObject& profileData);
    
    class _CapabilityGraph;
    std::unique_ptr<_CapabilityGraph> _capabilityGraph;
 
    // Store styles and groups defined in plugins
    std::map<TfToken, std::string> _capabilityStyles;
};
 
USDPROFILES_API_TEMPLATE_CLASS(TfSingleton<UsdProfileRegistry>);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_PROFILE_REGISTRY_H