Program Listing for omni/graph/core/bundle/IBundle2.h

↰ Return to documentation for omni/graph/core/bundle/IBundle2.h

// Copyright (c) 2022-2023, NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//

#pragma once

#include "IConstBundle2.h"

namespace omni
{
namespace graph
{
namespace core
{

OMNI_DECLARE_INTERFACE(IBundle2);

class IBundle2_abi : public omni::core::Inherits<IConstBundle2, OMNI_TYPE_ID("omni.graph.core.IBundle2")>
{
protected:
    OMNI_ATTR("no_py")
    virtual BundleHandle getHandle_abi() noexcept = 0;

    OMNI_ATTR("no_py")
    virtual BundleHandle getParentBundle_abi() noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result getAttributes_abi(
        AttributeDataHandle* const attributes OMNI_ATTR("out, not_null, count=*attributeCount"),
        size_t* const attributeCount OMNI_ATTR("in, out, not_null")) noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result getAttributesByName_abi(
        NameToken const* const names OMNI_ATTR("in, not_null, count=nameCount"),
        size_t nameCount,
        AttributeDataHandle* const attributes OMNI_ATTR("out, not_null, count=nameCount")) noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result getChildBundles_abi(BundleHandle* const bundles OMNI_ATTR("out, not_null, count=bundleCount"),
                                                   size_t* const bundleCount OMNI_ATTR("in, out, not_null")) noexcept = 0;

    OMNI_ATTR("no_py, no_api")
    virtual omni::core::Result getChildBundle_abi(size_t bundleIndex,
                                                  BundleHandle* const bundle OMNI_ATTR("out, not_null")) noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result getChildBundlesByName_abi(
        NameToken const* const names OMNI_ATTR("in, not_null, count=nameCount"),
        size_t nameCount,
        BundleHandle* const foundBundles OMNI_ATTR("out, not_null, count=nameCount")) noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result copyAttributes_abi(
        NameToken const* const newNames OMNI_ATTR("in, count=attributeCount"),
        ConstAttributeDataHandle const* const sourceAttributes OMNI_ATTR("in, not_null, count=attributeCount"),
        size_t attributeCount,
        bool overwrite,
        AttributeDataHandle* const copiedAttributes OMNI_ATTR("out, count=attributeCount"),
        size_t* const copiedCount OMNI_ATTR("out, not_null")) noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result createAttributes_abi(
        NameToken const* const names OMNI_ATTR("in, not_null, count=attributeCount"),
        Type const* const types OMNI_ATTR("in, not_null, count=attributeCount"),
        size_t const* const elementCount OMNI_ATTR("in, not_null, count=attributeCount"),
        size_t attributeCount,
        AttributeDataHandle* const createdAttributes OMNI_ATTR("out, count=attributeCount"),
        size_t* const createdCount OMNI_ATTR("out, not_null")) noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result createAttributesLike_abi(
        ConstAttributeDataHandle const* const patternAttributes OMNI_ATTR("in, not_null, count=patternCount"),
        size_t patternCount,
        AttributeDataHandle* const createdAttributes OMNI_ATTR("out, count=patternCount"),
        size_t* const createdCount OMNI_ATTR("out, not_null")) noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result createChildBundles_abi(
        NameToken const* const names OMNI_ATTR("in, not_null, count=nameCount"),
        size_t nameCount,
        BundleHandle* const createdBundles OMNI_ATTR("out, count=nameCount"),
        size_t* const createdCount OMNI_ATTR("out, not_null")) noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result linkAttributes_abi(
        NameToken const* const linkNames OMNI_ATTR("in, count=attributeCount"),
        ConstAttributeDataHandle const* const targetAttributes OMNI_ATTR("in, not_null, count=attributeCount"),
        size_t attributeCount,
        AttributeDataHandle* const linkedAttributes OMNI_ATTR("out, count=attributeCount"),
        size_t* const linkedCount OMNI_ATTR("out, not_null")) noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result copyBundle_abi(ConstBundleHandle sourceBundle, bool overwrite) noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result copyChildBundles_abi(
        NameToken const* const newNames OMNI_ATTR("in, count=bundleCount"),
        ConstBundleHandle const* const sourceBundles OMNI_ATTR("in, not_null, count=bundleCount"),
        size_t bundleCount,
        bool overwrite,
        BundleHandle* const copiedBundles OMNI_ATTR("out, count=bundleCount"),
        size_t* const copiedCount OMNI_ATTR("out, not_null")) noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result linkBundle_abi(
        ConstBundleHandle const* const sourceBundle OMNI_ATTR("in, not_null")) noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result linkChildBundles_abi(
        NameToken const* const linkNames OMNI_ATTR("in, count=bundleCount"),
        ConstBundleHandle const* const targetBundles OMNI_ATTR("in, not_null, count=bundleCount"),
        size_t bundleCount,
        BundleHandle* const linkedBundles OMNI_ATTR("out, count=bundleCount"),
        size_t* const linkedCount OMNI_ATTR("out, not_null")) noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result removeAttributes_abi(ConstAttributeDataHandle const* const attributes
                                                        OMNI_ATTR("in, not_null, count=attributeCount"),
                                                    size_t attributeCount,
                                                    size_t* const removedCount OMNI_ATTR("out, not_null")) noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result removeAttributesByName_abi(
        NameToken const* const names OMNI_ATTR("in, not_null, count=nameCount"),
        size_t nameCount,
        size_t* const removedCount OMNI_ATTR("out, not_null")) noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result removeChildBundles_abi(
        ConstBundleHandle const* const childHandles OMNI_ATTR("in, not_null, count=bundleCount"),
        size_t childCount,
        size_t* const removedCount OMNI_ATTR("out, not_null")) noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result removeChildBundlesByName_abi(
        NameToken const* const names OMNI_ATTR("in, not_null, count=nameCount"),
        size_t nameCount,
        size_t* const removedCount OMNI_ATTR("out, not_null")) noexcept = 0;

    OMNI_ATTR("no_py")
    virtual BundleHandle getMetadataStorage_abi() noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result getBundleMetadataByName_abi(
        NameToken const* const fieldNames OMNI_ATTR("in, count=fieldCount"),
        size_t fieldCount,
        AttributeDataHandle* const bundleMetadata OMNI_ATTR("out, count=fieldCount")) noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result createBundleMetadata_abi(
        NameToken const* const fieldNames OMNI_ATTR("in, count=fieldCount"),
        Type const* const fieldTypes OMNI_ATTR("in, count=fieldCount"),
        size_t const* const elementCount OMNI_ATTR("in, count=fieldCount"),
        size_t fieldCount,
        AttributeDataHandle* const bundleMetadata OMNI_ATTR("out, count=fieldCount"),
        size_t* const createdCount OMNI_ATTR("out, not_null")) noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result removeBundleMetadata_abi(
        NameToken const* const fieldNames OMNI_ATTR("in, not_null, count=fieldCount"),
        size_t fieldCount,
        size_t* const removedCount OMNI_ATTR("out, not_null")) noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result getAttributeMetadataByName_abi(
        NameToken attribute,
        NameToken const* const fieldNames OMNI_ATTR("in, count=fieldCount"),
        size_t fieldCount,
        AttributeDataHandle* const attributeMetadata OMNI_ATTR("out, count=fieldCount")) noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result createAttributeMetadata_abi(
        NameToken attribute,
        NameToken const* const fieldNames OMNI_ATTR("in, count=fieldCount"),
        Type const* const fieldTypes OMNI_ATTR("in, count=fieldCount"),
        size_t const* const elementCount OMNI_ATTR("in, count=fieldCount"),
        size_t fieldCount,
        AttributeDataHandle* const attributeMetadata OMNI_ATTR("out, count=fieldCount"),
        size_t* const createdCount OMNI_ATTR("out, not_null")) noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result removeAttributeMetadata_abi(
        NameToken attribute,
        NameToken const* const fieldNames OMNI_ATTR("in, count=fieldCount"),
        size_t fieldCount,
        size_t* const removedCount OMNI_ATTR("out, not_null")) noexcept = 0;

    OMNI_ATTR("no_py")
    virtual omni::core::Result clearContents_abi(bool bundleMetadata, bool attributes, bool childBundles) noexcept = 0;
};

} // namespace core
} // namespace graph
} // namespace omni

#include "IBundle2.gen.h"

OMNI_DEFINE_INTERFACE_API(omni::graph::core::IBundle2)
{
public:
    omni::core::Result getAttributes(
        omni::graph::core::AttributeDataHandle* const attributes, size_t attributeCount) noexcept
    {
        return getAttributes_abi(attributes, &attributeCount);
    }

    omni::graph::core::AttributeDataHandle getAttributeByName(omni::graph::core::NameToken name) noexcept
    {
        using namespace omni::graph::core;
        AttributeDataHandle out{ AttributeDataHandle::invalidValue() };
        auto result = getAttributesByName_abi(&name, 1, &out);
        return OMNI_SUCCEEDED(result) ? out : AttributeDataHandle{ AttributeDataHandle::invalidValue() };
    }

    omni::core::Result getChildBundles(omni::graph::core::BundleHandle* const bundles, size_t bundleCount) noexcept
    {
        return getChildBundles_abi(bundles, &bundleCount);
    }

    omni::graph::core::BundleHandle getChildBundle(size_t bundleIndex) noexcept
    {
        using namespace omni::graph::core;
        BundleHandle out{ BundleHandle::invalidValue() };
        auto result = getChildBundle_abi(bundleIndex, &out);
        return OMNI_SUCCEEDED(result) ? out : BundleHandle{ BundleHandle::invalidValue() };
    }

    template <typename HANDLE>
    omni::core::Result copyAttributes(HANDLE const* const sourceAttributes, size_t attributeCount, bool overwrite = true,
                                      omni::graph::core::NameToken const* const newNames = nullptr,
                                      omni::graph::core::AttributeDataHandle* const copiedAttributes = nullptr,
                                      size_t* const copiedCount = nullptr) noexcept
    {
        using namespace omni::graph::core;
        static_assert(
            std::is_same<HANDLE, AttributeDataHandle>::value || std::is_same<HANDLE, ConstAttributeDataHandle>::value,
            "Only AttributeDataHandle and ConstAttributeDataHandle can be copied");

        return copyAttributes_abi(newNames, reinterpret_cast<ConstAttributeDataHandle const* const>(sourceAttributes),
                                  attributeCount, overwrite, copiedAttributes, copiedCount);
    }

    omni::graph::core::AttributeDataHandle copyAttribute(
        omni::graph::core::ConstAttributeDataHandle const& sourceAttribute, bool overwrite = true,
        omni::graph::core::NameToken newName = omni::fabric::kUninitializedToken) noexcept
    {
        using namespace omni::graph::core;
        AttributeDataHandle out{ AttributeDataHandle::invalidValue() };
        NameToken* newNamePtr = newName == omni::fabric::kUninitializedToken ? nullptr : &newName;
        auto result = copyAttributes_abi(newNamePtr, &sourceAttribute, 1, overwrite, &out, nullptr);
        return OMNI_SUCCEEDED(result) ? out : AttributeDataHandle{ AttributeDataHandle::invalidValue() };
    }

    omni::core::Result createAttributes(omni::graph::core::NameToken const* const names,
                                        omni::graph::core::Type const* const types, size_t attributeCount,
                                        size_t const* const elementCount = nullptr,
                                        omni::graph::core::AttributeDataHandle* const createdAttributes = nullptr,
                                        size_t* const createdCount = nullptr) noexcept
    {
        return createAttributes_abi(names, types, elementCount, attributeCount, createdAttributes, createdCount);
    }

    omni::graph::core::AttributeDataHandle createAttribute(
        omni::graph::core::NameToken name, omni::graph::core::Type const& type, size_t elementCount = 0) noexcept
    {
        using namespace omni::graph::core;
        omni::core::Result result = kResultFail;
        AttributeDataHandle out{ AttributeDataHandle::invalidValue() };
        size_t* elementCountPtr = type.arrayDepth == 0 ? nullptr : &elementCount;
        result = createAttributes_abi(&name, &type, elementCountPtr, 1, &out, nullptr);
        return OMNI_SUCCEEDED(result) ? out : AttributeDataHandle{ AttributeDataHandle::invalidValue() };
    }

    omni::core::Result createAttributesLike(omni::graph::core::ConstAttributeDataHandle const* const patternAttributes,
                                            size_t patternCount,
                                            omni::graph::core::AttributeDataHandle* const createdAttributes = nullptr,
                                            size_t* const createdCount = nullptr) noexcept
    {
        return createAttributesLike_abi(patternAttributes, patternCount, createdAttributes, createdCount);
    }

    omni::graph::core::AttributeDataHandle createAttributeLike(
        omni::graph::core::ConstAttributeDataHandle const& patternAttribute) noexcept
    {
        using namespace omni::graph::core;
        AttributeDataHandle out{ AttributeDataHandle::invalidValue() };
        auto result = createAttributesLike_abi(&patternAttribute, 1, &out, nullptr);
        return OMNI_SUCCEEDED(result) ? out : AttributeDataHandle{ AttributeDataHandle::invalidValue() };
    }

    omni::core::Result createChildBundles(omni::graph::core::NameToken const* const names, size_t nameCount,
                                          omni::graph::core::BundleHandle* const createdBundles = nullptr,
                                          size_t* const createdCount = nullptr) noexcept
    {
        return createChildBundles_abi(names, nameCount, createdBundles, createdCount);
    }

    omni::graph::core::BundleHandle createChildBundle(omni::graph::core::NameToken name) noexcept
    {
        using namespace omni::graph::core;
        BundleHandle out{ BundleHandle::invalidValue() };
        auto result = createChildBundles_abi(&name, 1, &out, nullptr);
        return OMNI_SUCCEEDED(result) ? out : BundleHandle{ BundleHandle::invalidValue() };
    }

    template <typename HANDLE>
    omni::core::Result linkAttributes(HANDLE const* const targetAttributes, size_t attributeCount,
                                      omni::graph::core::NameToken const* const linkNames = nullptr,
                                      omni::graph::core::AttributeDataHandle* const linkedAttributes = nullptr,
                                      size_t* const linkedCount = nullptr) noexcept
    {
        using namespace omni::graph::core;
        static_assert(
            std::is_same<HANDLE, AttributeDataHandle>::value || std::is_same<HANDLE, ConstAttributeDataHandle>::value,
            "Only AttributeDataHandle and ConstAttributeDataHandle can be copied");

        auto linkedAttributesPtr = reinterpret_cast<ConstAttributeDataHandle const* const>(targetAttributes);
        return linkAttributes_abi(linkNames, linkedAttributesPtr, attributeCount, linkedAttributes, linkedCount);
    }

    omni::graph::core::AttributeDataHandle linkAttribute(
        omni::graph::core::ConstAttributeDataHandle const& targetAttribute,
        omni::graph::core::NameToken linkName = omni::fabric::kUninitializedToken) noexcept
    {
        using namespace omni::graph::core;
        AttributeDataHandle out{ AttributeDataHandle::invalidValue() };
        auto result = linkAttributes_abi(&linkName, &targetAttribute, 1, &out, nullptr);
        return OMNI_SUCCEEDED(result) ? out : AttributeDataHandle{ AttributeDataHandle::invalidValue() };
    }

    omni::core::Result copyBundle(omni::graph::core::ConstBundleHandle sourceBundle, bool overwrite = true) noexcept
    {
        return copyBundle_abi(sourceBundle, overwrite);
    }

    template <typename HANDLE>
    omni::core::Result copyChildBundles(HANDLE const* const sourceBundles, size_t bundleCount, bool overwrite = true,
                                        omni::graph::core::NameToken const* const newNames = nullptr,
                                        omni::graph::core::BundleHandle* const copiedBundles = nullptr,
                                        size_t* const copiedCount = nullptr) noexcept
    {
        using namespace omni::graph::core;
        static_assert(std::is_same<HANDLE, BundleHandle>::value || std::is_same<HANDLE, ConstBundleHandle>::value,
                      "Only BundleHandle and ConstBundleHandle can be copied");

        auto sourceBundlesPtr = reinterpret_cast<ConstBundleHandle const* const>(sourceBundles);
        return copyChildBundles_abi(newNames, sourceBundlesPtr, bundleCount, overwrite, copiedBundles, copiedCount);
    }

    omni::graph::core::BundleHandle copyChildBundle(
        omni::graph::core::ConstBundleHandle const& sourceBundle, bool overwrite = true,
        omni::graph::core::NameToken newName = omni::fabric::kUninitializedToken) noexcept
    {
        using namespace omni::graph::core;
        BundleHandle out{ BundleHandle::invalidValue() };
        NameToken* newNamePtr = newName == omni::fabric::kUninitializedToken ? nullptr : &newName;
        auto result = copyChildBundles_abi(newNamePtr, &sourceBundle, 1, overwrite, &out, nullptr);
        return OMNI_SUCCEEDED(result) ? out : BundleHandle{ BundleHandle::invalidValue() };
    }

    template <typename HANDLE>
    omni::core::Result removeAttributes(
        HANDLE const* const attributes, size_t attributeCount, size_t* const removedCount = nullptr) noexcept
    {
        using namespace omni::graph::core;
        static_assert(
            std::is_same<HANDLE, AttributeDataHandle>::value || std::is_same<HANDLE, ConstAttributeDataHandle>::value,
            "Only AttributeDataHandle and ConstAttributeDataHandle can be copied");

        auto attributesPtr = reinterpret_cast<ConstAttributeDataHandle const* const>(attributes);
        return removeAttributes_abi(attributesPtr, attributeCount, removedCount);
    }

    omni::core::Result removeAttribute(omni::graph::core::ConstAttributeDataHandle const& attribute) noexcept
    {
        return removeAttributes_abi(&attribute, 1, nullptr);
    }

    omni::core::Result removeAttributesByName(omni::graph::core::NameToken const* const names, size_t nameCount,
                                              size_t* const removedCount = nullptr) noexcept
    {
        return removeAttributesByName_abi(names, nameCount, removedCount);
    }

    omni::core::Result removeAttributeByName(omni::graph::core::NameToken name) noexcept
    {
        return removeAttributesByName_abi(&name, 1, nullptr);
    }

    template <typename HANDLE>
    omni::core::Result removeChildBundles(
        HANDLE const* const bundles, size_t bundleCount, size_t* const removedCount = nullptr) noexcept
    {
        using namespace omni::graph::core;
        static_assert(std::is_same<HANDLE, BundleHandle>::value || std::is_same<HANDLE, ConstBundleHandle>::value,
                      "Only BundleHandle and ConstBundleHandle can be copied");

        auto bundlesPtr = reinterpret_cast<ConstBundleHandle const* const>(bundles);
        return removeChildBundles_abi(bundlesPtr, bundleCount, removedCount);
    }

    omni::core::Result removeChildBundle(omni::graph::core::ConstBundleHandle const& bundle) noexcept
    {
        return removeChildBundles_abi(&bundle, 1, nullptr);
    }

    omni::core::Result removeChildBundlesByName(omni::graph::core::NameToken const* const names, size_t nameCount,
                                                size_t* const removedCount = nullptr) noexcept
    {
        return removeChildBundlesByName_abi(names, nameCount, removedCount);
    }

    omni::core::Result removeChildBundleByName(omni::graph::core::NameToken name) noexcept
    {
        return removeChildBundlesByName_abi(&name, 1, nullptr);
    }

    omni::graph::core::BundleHandle getChildBundleByName(omni::graph::core::NameToken name) noexcept
    {
        using namespace omni::graph::core;
        BundleHandle out{ BundleHandle::invalidValue() };
        auto result = getChildBundlesByName_abi(&name, 1, &out);
        return OMNI_SUCCEEDED(result) ? out : BundleHandle{ BundleHandle::invalidValue() };
    }

    using omni::core::Generated<omni::graph::core::IBundle2_abi>::getBundleMetadataByName;

    omni::graph::core::AttributeDataHandle getBundleMetadataByName(omni::graph::core::NameToken fieldName) noexcept
    {
        using namespace omni::graph::core;
        AttributeDataHandle out{ AttributeDataHandle::invalidValue() };
        auto result = getBundleMetadataByName_abi(&fieldName, 1, &out);
        return OMNI_SUCCEEDED(result) ? out : AttributeDataHandle{ AttributeDataHandle::invalidValue() };
    }

    omni::core::Result createBundleMetadata(omni::graph::core::NameToken const* const fieldNames,
                                            omni::graph::core::Type const* const fieldTypes, size_t fieldCount,
                                            size_t const* const elementCount = nullptr,
                                            omni::graph::core::AttributeDataHandle* const bundleMetadata = nullptr,
                                            size_t* const createdCount = nullptr) noexcept
    {
        return createBundleMetadata_abi(fieldNames, fieldTypes, elementCount, fieldCount, bundleMetadata, createdCount);
    }

    omni::graph::core::AttributeDataHandle createBundleMetadata(
        omni::graph::core::NameToken fieldName, omni::graph::core::Type const& fieldType, size_t elementCount = 0) noexcept
    {
        using namespace omni::graph::core;
        AttributeDataHandle out{ AttributeDataHandle::invalidValue() };
        auto result = createBundleMetadata_abi(&fieldName, &fieldType, &elementCount, 1, &out, nullptr);
        return OMNI_SUCCEEDED(result) ? out : AttributeDataHandle{ AttributeDataHandle::invalidValue() };
    }

    omni::core::Result removeBundleMetadata(omni::graph::core::NameToken const* const fieldNames, size_t fieldCount,
                                            size_t* const removedCount = nullptr) noexcept
    {
        return removeBundleMetadata_abi(fieldNames, fieldCount, removedCount);
    }

    omni::core::Result removeBundleMetadata(omni::graph::core::NameToken fieldName) noexcept
    {
        return removeBundleMetadata_abi(&fieldName, 1, nullptr);
    }

    using omni::core::Generated<omni::graph::core::IBundle2_abi>::getAttributeMetadataByName;

    omni::graph::core::AttributeDataHandle getAttributeMetadataByName(
        omni::graph::core::NameToken attribute, omni::graph::core::NameToken fieldName) noexcept
    {
        using namespace omni::graph::core;
        AttributeDataHandle out{ AttributeDataHandle::invalidValue() };
        auto result = getAttributeMetadataByName_abi(attribute, &fieldName, 1, &out);
        return OMNI_SUCCEEDED(result) ? out : AttributeDataHandle{ AttributeDataHandle::invalidValue() };
    }

    omni::core::Result createAttributeMetadata(
        omni::graph::core::NameToken attribute, omni::graph::core::NameToken const* const fieldNames,
        omni::graph::core::Type const* const fieldTypes, size_t fieldCount, size_t const* const elementCount = nullptr,
        omni::graph::core::AttributeDataHandle* const attributeMetadata = nullptr,
        size_t* const createdCount = nullptr) noexcept
    {
        return createAttributeMetadata_abi(
            attribute, fieldNames, fieldTypes, elementCount, fieldCount, attributeMetadata, createdCount);
    }

    omni::graph::core::AttributeDataHandle createAttributeMetadata(
        omni::graph::core::NameToken attribute, omni::graph::core::NameToken fieldName,
        omni::graph::core::Type const& fieldType, size_t elementCount = 0) noexcept
    {
        using namespace omni::graph::core;
        AttributeDataHandle out{ AttributeDataHandle::invalidValue() };
        size_t* elementCountPtr = fieldType.arrayDepth == 0 ? nullptr : &elementCount;
        auto result = createAttributeMetadata_abi(attribute, &fieldName, &fieldType, elementCountPtr, 1, &out, nullptr);
        return OMNI_SUCCEEDED(result) ? out : AttributeDataHandle{ AttributeDataHandle::invalidValue() };
    }

    omni::core::Result removeAttributeMetadata(omni::graph::core::NameToken attribute,
                                               omni::graph::core::NameToken const* const fieldNames, size_t fieldCount,
                                               size_t* const removedCount = nullptr) noexcept
    {
        return removeAttributeMetadata_abi(attribute, fieldNames, fieldCount, removedCount);
    }

    using omni::core::Generated<omni::graph::core::IBundle2_abi>::removeAttributeMetadata;

    omni::core::Result removeAttributeMetadata(
        omni::graph::core::NameToken attribute, omni::graph::core::NameToken fieldName) noexcept
    {
        return removeAttributeMetadata_abi(attribute, &fieldName, 1, nullptr);
    }

    omni::core::Result clearContents(bool bundleMetadata = true, bool attributes = true, bool childBundles = true) noexcept
    {
        return clearContents_abi(bundleMetadata, attributes, childBundles);
    }

    CARB_DEPRECATED("Accessing child bundles by index is deprecated, look up children by name")
    omni::core::Result getChildBundle(size_t bundleIndex, omni::graph::core::BundleHandle* const bundle) noexcept
    {
        return getChildBundle_abi(bundleIndex, bundle);
    }
}; // IBundle2