Adding GetAll method to the codegenTemplates for multiple-apply schemas

pxr/usd/usd/apiSchemaBase.cpp

@@ -102,6 +102,30 @@ PXR_NAMESPACE_CLOSE_SCOPE
 
 PXR_NAMESPACE_OPEN_SCOPE
 
+/* static */
+TfTokenVector
+UsdAPISchemaBase::_GetMultipleApplyInstanceNames(const UsdPrim &prim,
+                                                 const TfType &schemaType)
+{
+    TfTokenVector instanceNames;
+
+    auto appliedSchemas = prim.GetAppliedSchemas();
+    if (appliedSchemas.empty()) {
+        return instanceNames;
+    }
+
+    TfToken schemaTypeName = UsdSchemaRegistry::GetAPISchemaTypeName(schemaType);
+
+    for (const auto &appliedSchema : appliedSchemas) {
+        std::pair<TfToken, TfToken> typeNameAndInstance =
+                UsdSchemaRegistry::GetTypeNameAndInstance(appliedSchema);
+        if (typeNameAndInstance.first == schemaTypeName) {
+            instanceNames.emplace_back(typeNameAndInstance.second);
+        }
+    }
+
+    return instanceNames;
+}
 
 /* virtual */
 bool 

pxr/usd/usd/apiSchemaBase.h

@@ -209,6 +209,11 @@ class UsdAPISchemaBase : public UsdSchemaBase
         return _instanceName;
     }
 
+    /// Returns a vector of names of API schema objects belonging to a
+    /// multiple-apply API schema applied to a given prim.
+    static TfTokenVector _GetMultipleApplyInstanceNames(const UsdPrim &prim,
+                                                        const TfType &schemaType);
+
 protected:        
     /// Check whether this APISchema object is valid for the currently held  
     /// prim. 

pxr/usd/usd/codegenTemplates/schemaClass.cpp

@@ -94,6 +94,20 @@ TF_DEFINE_PRIVATE_TOKENS(
     return {{ cls.cppClassName }}(prim, name);
 }
 
+/* static */
+std::vector<{{ cls.cppClassName }}>
+{{ cls.cppClassName }}::GetAll(const UsdPrim &prim)
+{
+    std::vector<{{ cls.cppClassName }}> schemas;
+
+    for (const auto &schemaName :
+         UsdAPISchemaBase::_GetMultipleApplyInstanceNames(prim, _GetStaticTfType())) {
+        schemas.emplace_back(prim, schemaName);
+    }
+
+    return schemas;
+}
+
 {% endif %}
 {% endif %}
 {% if cls.isConcrete %}

pxr/usd/usd/codegenTemplates/schemaClass.h

@@ -194,6 +194,13 @@ class {{ cls.cppClassName }} : public {{ cls.parentCppClassName }}
     {% endif -%}
     static {{ cls.cppClassName }}
     Get(const UsdPrim &prim, const TfToken &name);
+
+    /// Return a vector of {{ cls.cppClassName }} holding the prim \p prim.
+    {% if useExportAPI -%}
+    {{ Upper(libraryName) }}_API
+    {% endif -%}
+    static std::vector<{{ cls.cppClassName }}>
+    GetAll(const UsdPrim &prim);
 {% endif %}
 {% endif %}
 

pxr/usd/usd/codegenTemplates/wrapSchemaClass.cpp

@@ -169,6 +169,15 @@ void wrap{{ cls.cppClassName }}()
 {% endif %}
         .staticmethod("Get")
 {% endif %}
+{% if cls.isMultipleApply %}
+
+        .def("GetAll",
+            (std::vector<{{ cls.cppClassName }}>(*)(const UsdPrim &prim))
+                &This::GetAll,
+            arg("prim"),
+            return_value_policy<TfPySequenceToList>())
+        .staticmethod("GetAll")
+{% endif %}
 {% if cls.isConcrete %}
 
         .def("Define", &This::Define, (arg("stage"), arg("path")))

pxr/usd/usd/collectionAPI.cpp

@@ -72,6 +72,20 @@ UsdCollectionAPI::Get(const UsdPrim &prim, const TfToken &name)
     return UsdCollectionAPI(prim, name);
 }
 
+/* static */
+std::vector<UsdCollectionAPI>
+UsdCollectionAPI::GetAll(const UsdPrim &prim)
+{
+    std::vector<UsdCollectionAPI> schemas;
+
+    for (const auto &schemaName :
+         UsdAPISchemaBase::_GetMultipleApplyInstanceNames(prim, _GetStaticTfType())) {
+        schemas.emplace_back(prim, schemaName);
+    }
+
+    return schemas;
+}
+
 
 /* static */
 bool 

pxr/usd/usd/collectionAPI.h

@@ -229,6 +229,11 @@ class UsdCollectionAPI : public UsdAPISchemaBase
     static UsdCollectionAPI
     Get(const UsdPrim &prim, const TfToken &name);
 
+    /// Return a vector of UsdCollectionAPI holding the prim \p prim.
+    USD_API
+    static std::vector<UsdCollectionAPI>
+    GetAll(const UsdPrim &prim);
+
     /// Checks if the given name \p baseName is the base name of a property
     /// of CollectionAPI.
     USD_API
@@ -424,7 +429,8 @@ class UsdCollectionAPI : public UsdAPISchemaBase
     static UsdCollectionAPI GetCollection(const UsdPrim &prim, 
                                           const TfToken &name);
 
-    /// Returns all the named collections on the given USD prim. 
+    /// Returns all the named collections on the given USD prim.
+    /// \deprecated Use GetAll(prim) instead.
     USD_API
     static std::vector<UsdCollectionAPI> GetAllCollections(const UsdPrim &prim);
 

pxr/usd/usd/testenv/testUsdCollectionAPI.py

@@ -582,7 +582,7 @@ def test_CollectionEquivalence(self):
         # ends up equivalent.
 
         # Get all collections on the root test prim
-        collections = Usd.CollectionAPI.GetAllCollections(testPrim)
+        collections = Usd.CollectionAPI.GetAll(testPrim)
         self.assertTrue(len(collections) > 1)
 
         # Each of their membership queries should be equal to itself,

pxr/usd/usd/wrapCollectionAPI.cpp

@@ -124,6 +124,13 @@ void wrapUsdCollectionAPI()
             (arg("prim"), arg("name")))
         .staticmethod("Get")
 
+        .def("GetAll",
+            (std::vector<UsdCollectionAPI>(*)(const UsdPrim &prim))
+                &This::GetAll,
+            arg("prim"),
+            return_value_policy<TfPySequenceToList>())
+        .staticmethod("GetAll")
+
         .def("CanApply", &_WrapCanApply, (arg("prim"), arg("name")))
         .staticmethod("CanApply")
 

pxr/usd/usdPhysics/driveAPI.cpp

@@ -72,6 +72,20 @@ UsdPhysicsDriveAPI::Get(const UsdPrim &prim, const TfToken &name)
     return UsdPhysicsDriveAPI(prim, name);
 }
 
+/* static */
+std::vector<UsdPhysicsDriveAPI>
+UsdPhysicsDriveAPI::GetAll(const UsdPrim &prim)
+{
+    std::vector<UsdPhysicsDriveAPI> schemas;
+
+    for (const auto &schemaName :
+         UsdAPISchemaBase::_GetMultipleApplyInstanceNames(prim, _GetStaticTfType())) {
+        schemas.emplace_back(prim, schemaName);
+    }
+
+    return schemas;
+}
+
 
 /* static */
 bool 

pxr/usd/usdPhysics/driveAPI.h

@@ -147,6 +147,11 @@ class UsdPhysicsDriveAPI : public UsdAPISchemaBase
     static UsdPhysicsDriveAPI
     Get(const UsdPrim &prim, const TfToken &name);
 
+    /// Return a vector of UsdPhysicsDriveAPI holding the prim \p prim.
+    USDPHYSICS_API
+    static std::vector<UsdPhysicsDriveAPI>
+    GetAll(const UsdPrim &prim);
+
     /// Checks if the given name \p baseName is the base name of a property
     /// of PhysicsDriveAPI.
     USDPHYSICS_API

pxr/usd/usdPhysics/limitAPI.cpp

@@ -72,6 +72,20 @@ UsdPhysicsLimitAPI::Get(const UsdPrim &prim, const TfToken &name)
     return UsdPhysicsLimitAPI(prim, name);
 }
 
+/* static */
+std::vector<UsdPhysicsLimitAPI>
+UsdPhysicsLimitAPI::GetAll(const UsdPrim &prim)
+{
+    std::vector<UsdPhysicsLimitAPI> schemas;
+
+    for (const auto &schemaName :
+         UsdAPISchemaBase::_GetMultipleApplyInstanceNames(prim, _GetStaticTfType())) {
+        schemas.emplace_back(prim, schemaName);
+    }
+
+    return schemas;
+}
+
 
 /* static */
 bool 

pxr/usd/usdPhysics/limitAPI.h

@@ -140,6 +140,11 @@ class UsdPhysicsLimitAPI : public UsdAPISchemaBase
     static UsdPhysicsLimitAPI
     Get(const UsdPrim &prim, const TfToken &name);
 
+    /// Return a vector of UsdPhysicsLimitAPI holding the prim \p prim.
+    USDPHYSICS_API
+    static std::vector<UsdPhysicsLimitAPI>
+    GetAll(const UsdPrim &prim);
+
     /// Checks if the given name \p baseName is the base name of a property
     /// of PhysicsLimitAPI.
     USDPHYSICS_API

pxr/usd/usdPhysics/wrapDriveAPI.cpp

@@ -152,6 +152,13 @@ void wrapUsdPhysicsDriveAPI()
             (arg("prim"), arg("name")))
         .staticmethod("Get")
 
+        .def("GetAll",
+            (std::vector<UsdPhysicsDriveAPI>(*)(const UsdPrim &prim))
+                &This::GetAll,
+            arg("prim"),
+            return_value_policy<TfPySequenceToList>())
+        .staticmethod("GetAll")
+
         .def("CanApply", &_WrapCanApply, (arg("prim"), arg("name")))
         .staticmethod("CanApply")
 

pxr/usd/usdPhysics/wrapLimitAPI.cpp

@@ -124,6 +124,13 @@ void wrapUsdPhysicsLimitAPI()
             (arg("prim"), arg("name")))
         .staticmethod("Get")
 
+        .def("GetAll",
+            (std::vector<UsdPhysicsLimitAPI>(*)(const UsdPrim &prim))
+                &This::GetAll,
+            arg("prim"),
+            return_value_policy<TfPySequenceToList>())
+        .staticmethod("GetAll")
+
         .def("CanApply", &_WrapCanApply, (arg("prim"), arg("name")))
         .staticmethod("CanApply")