diff a/cr-examples/onnx/src/main/java/oracle/code/onnx/foreign/OrtEpApi.java b/cr-examples/onnx/src/main/java/oracle/code/onnx/foreign/OrtEpApi.java --- /dev/null +++ b/cr-examples/onnx/src/main/java/oracle/code/onnx/foreign/OrtEpApi.java @@ -0,0 +1,7619 @@ +// Generated by jextract + +package oracle.code.onnx.foreign; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +/** + * {@snippet lang=c : + * struct OrtEpApi { + * OrtStatusPtr (*CreateEpDevice)(OrtEpFactory *, const OrtHardwareDevice *, const OrtKeyValuePairs *, const OrtKeyValuePairs *, OrtEpDevice **); + * void (*ReleaseEpDevice)(OrtEpDevice *); + * OrtStatusPtr (*EpGraphSupportInfo_AddNodesToFuse)(OrtEpGraphSupportInfo *, const OrtNode *const *, size_t, const OrtNodeFusionOptions *); + * OrtStatusPtr (*EpGraphSupportInfo_AddSingleNode)(OrtEpGraphSupportInfo *, const OrtNode *); + * const char *(*NodeComputeContext_NodeName)(const OrtNodeComputeContext *); + * OrtStatusPtr (*EpDevice_AddAllocatorInfo)(OrtEpDevice *, const OrtMemoryInfo *); + * const OrtMemoryDevice *(*MemoryInfo_GetMemoryDevice)(const OrtMemoryInfo *); + * const OrtMemoryDevice *(*Value_GetMemoryDevice)(const OrtValue *); + * bool (*MemoryDevice_AreEqual)(const OrtMemoryDevice *, const OrtMemoryDevice *); + * OrtMemoryInfoDeviceType (*MemoryDevice_GetDeviceType)(const OrtMemoryDevice *); + * OrtDeviceMemoryType (*MemoryDevice_GetMemoryType)(const OrtMemoryDevice *); + * uint32_t (*MemoryDevice_GetVendorId)(const OrtMemoryDevice *); + * uint32_t (*MemoryDevice_GetDeviceId)(const OrtMemoryDevice *); + * const OrtSyncStreamImpl *(*SyncStream_GetImpl)(const OrtSyncStream *); + * uint64_t (*SyncStream_GetSyncId)(const OrtSyncStream *); + * uint64_t (*GetSyncIdForLastWaitOnSyncStream)(const OrtSyncStream *, const OrtSyncStream *); + * OrtStatusPtr (*CreateHardwareDevice)(OrtHardwareDeviceType, uint32_t, uint32_t, const char *, const OrtKeyValuePairs *, OrtHardwareDevice **); + * void (*ReleaseHardwareDevice)(OrtHardwareDevice *); + * OrtStatusPtr (*CreateKernelRegistry)(OrtKernelRegistry **); + * void (*ReleaseKernelRegistry)(OrtKernelRegistry *); + * OrtStatusPtr (*KernelRegistry_AddKernel)(OrtKernelRegistry *, const OrtKernelDef *, OrtKernelCreateFunc, void *); + * OrtStatusPtr (*CreateKernelDefBuilder)(OrtKernelDefBuilder **); + * void (*ReleaseKernelDefBuilder)(OrtKernelDefBuilder *); + * OrtStatusPtr (*KernelDefBuilder_SetOperatorType)(OrtKernelDefBuilder *, const char *); + * OrtStatusPtr (*KernelDefBuilder_SetDomain)(OrtKernelDefBuilder *, const char *); + * OrtStatusPtr (*KernelDefBuilder_SetSinceVersion)(OrtKernelDefBuilder *, int, int); + * OrtStatusPtr (*KernelDefBuilder_SetExecutionProvider)(OrtKernelDefBuilder *, const char *); + * OrtStatusPtr (*KernelDefBuilder_SetInputMemType)(OrtKernelDefBuilder *, size_t, OrtMemType); + * OrtStatusPtr (*KernelDefBuilder_SetOutputMemType)(OrtKernelDefBuilder *, size_t, OrtMemType); + * OrtStatusPtr (*KernelDefBuilder_AddTypeConstraint)(OrtKernelDefBuilder *, const char *, const OrtDataType *const *, size_t); + * OrtStatusPtr (*KernelDefBuilder_AddInputOutputAliases)(OrtKernelDefBuilder *, const int *, const int *, size_t); + * OrtStatusPtr (*KernelDefBuilder_AddInputOutputMutableAliases)(OrtKernelDefBuilder *, const int *, const int *, size_t); + * OrtStatusPtr (*KernelDefBuilder_Build)(OrtKernelDefBuilder *, OrtKernelDef **); + * void (*ReleaseKernelDef)(OrtKernelDef *); + * const char *(*KernelDef_GetOperatorType)(const OrtKernelDef *); + * const char *(*KernelDef_GetDomain)(const OrtKernelDef *); + * OrtStatusPtr (*KernelDef_GetSinceVersion)(const OrtKernelDef *, int *, int *); + * const char *(*KernelDef_GetExecutionProvider)(const OrtKernelDef *); + * OrtStatusPtr (*KernelDef_GetInputMemType)(const OrtKernelDef *, size_t, OrtMemType *); + * OrtStatusPtr (*KernelDef_GetOutputMemType)(const OrtKernelDef *, size_t, OrtMemType *); + * OrtStatusPtr (*GetTensorDataType)(ONNXTensorElementDataType, const OrtDataType **); + * OrtStatusPtr (*EpGraphSupportInfo_LookUpKernel)(OrtEpGraphSupportInfo *, const OrtNode *, const OrtKernelDef **); + * OrtStatusPtr (*SharedPrePackedWeightCache_StoreWeightData)(OrtSharedPrePackedWeightCache *, void **, size_t *, size_t); + * OrtStatusPtr (*KernelInfo_GetEp)(const OrtKernelInfo *, const OrtEp **); + * OrtStatusPtr (*DeviceEpIncompatibilityDetails_SetDetails)(OrtDeviceEpIncompatibilityDetails *, uint32_t, int32_t, const char *); + * OrtStatusPtr (*CreateIfKernel)(const OrtKernelInfo *, OrtKernelImpl **); + * OrtStatusPtr (*CreateLoopKernel)(const OrtKernelInfo *, OrtLoopKernelHelper *, OrtKernelImpl **); + * OrtStatusPtr (*CreateScanKernel)(const OrtKernelInfo *, OrtScanKernelHelper *, OrtKernelImpl **); + * void (*ReleaseKernelImpl)(OrtKernelImpl *); + * OrtStatusPtr (*GetEnvConfigEntries)(OrtKeyValuePairs **); + * OrtStatusPtr (*GetOpSchema)(const char *, int, const char *, OrtOpSchema **); + * void (*ReleaseOpSchema)(OrtOpSchema *); + * OrtStatusPtr (*OpSchema_GetSinceVersion)(const OrtOpSchema *, int *); + * OrtStatusPtr (*OpSchema_GetNumInputs)(const OrtOpSchema *, size_t *); + * OrtStatusPtr (*OpSchema_GetInputName)(const OrtOpSchema *, size_t, const char **); + * OrtStatusPtr (*OpSchema_GetInputTypeConstraint)(const OrtOpSchema *, size_t, const OrtOpSchemaTypeConstraint **); + * OrtStatusPtr (*OpSchema_GetNumOutputs)(const OrtOpSchema *, size_t *); + * OrtStatusPtr (*OpSchema_GetOutputName)(const OrtOpSchema *, size_t, const char **); + * OrtStatusPtr (*OpSchema_GetOutputTypeConstraint)(const OrtOpSchema *, size_t, const OrtOpSchemaTypeConstraint **); + * OrtStatusPtr (*OpSchema_GetTypeConstraintCount)(const OrtOpSchema *, size_t *); + * OrtStatusPtr (*OpSchema_GetTypeConstraint)(const OrtOpSchema *, size_t, const OrtOpSchemaTypeConstraint **); + * OrtStatusPtr (*OpSchemaTypeConstraint_GetTypeParamName)(const OrtOpSchemaTypeConstraint *, const char **); + * OrtStatusPtr (*OpSchemaTypeConstraint_GetAllowedTypes)(const OrtOpSchemaTypeConstraint *, const char *const **, size_t *); + * OrtStatusPtr (*OpSchemaTypeConstraint_GetInputIndices)(const OrtOpSchemaTypeConstraint *, const size_t **, size_t *); + * OrtStatusPtr (*OpSchemaTypeConstraint_GetOutputIndices)(const OrtOpSchemaTypeConstraint *, const size_t **, size_t *); + * OrtStatusPtr (*CreateProfilingEvent)(OrtProfilingEventCategory, int32_t, int32_t, const char *, int64_t, int64_t, const char *const *, const char *const *, size_t, OrtProfilingEvent **); + * void (*ReleaseProfilingEvent)(OrtProfilingEvent *); + * OrtStatusPtr (*ProfilingEvent_GetCategory)(const OrtProfilingEvent *, OrtProfilingEventCategory *); + * OrtStatusPtr (*ProfilingEvent_GetName)(const OrtProfilingEvent *, const char **); + * OrtStatusPtr (*ProfilingEvent_GetTimestampUs)(const OrtProfilingEvent *, int64_t *); + * OrtStatusPtr (*ProfilingEvent_GetDurationUs)(const OrtProfilingEvent *, int64_t *); + * OrtStatusPtr (*ProfilingEvent_GetArgValue)(const OrtProfilingEvent *, const char *, const char **); + * OrtStatusPtr (*ProfilingEventsContainer_AddEvents)(OrtProfilingEventsContainer *, const OrtProfilingEvent *const *, size_t); + * } + * } + */ +public class OrtEpApi { + + OrtEpApi() { + // Should not be called directly + } + + private static final GroupLayout $LAYOUT = MemoryLayout.structLayout( + onnxruntime_c_api_h.C_POINTER.withName("CreateEpDevice"), + onnxruntime_c_api_h.C_POINTER.withName("ReleaseEpDevice"), + onnxruntime_c_api_h.C_POINTER.withName("EpGraphSupportInfo_AddNodesToFuse"), + onnxruntime_c_api_h.C_POINTER.withName("EpGraphSupportInfo_AddSingleNode"), + onnxruntime_c_api_h.C_POINTER.withName("NodeComputeContext_NodeName"), + onnxruntime_c_api_h.C_POINTER.withName("EpDevice_AddAllocatorInfo"), + onnxruntime_c_api_h.C_POINTER.withName("MemoryInfo_GetMemoryDevice"), + onnxruntime_c_api_h.C_POINTER.withName("Value_GetMemoryDevice"), + onnxruntime_c_api_h.C_POINTER.withName("MemoryDevice_AreEqual"), + onnxruntime_c_api_h.C_POINTER.withName("MemoryDevice_GetDeviceType"), + onnxruntime_c_api_h.C_POINTER.withName("MemoryDevice_GetMemoryType"), + onnxruntime_c_api_h.C_POINTER.withName("MemoryDevice_GetVendorId"), + onnxruntime_c_api_h.C_POINTER.withName("MemoryDevice_GetDeviceId"), + onnxruntime_c_api_h.C_POINTER.withName("SyncStream_GetImpl"), + onnxruntime_c_api_h.C_POINTER.withName("SyncStream_GetSyncId"), + onnxruntime_c_api_h.C_POINTER.withName("GetSyncIdForLastWaitOnSyncStream"), + onnxruntime_c_api_h.C_POINTER.withName("CreateHardwareDevice"), + onnxruntime_c_api_h.C_POINTER.withName("ReleaseHardwareDevice"), + onnxruntime_c_api_h.C_POINTER.withName("CreateKernelRegistry"), + onnxruntime_c_api_h.C_POINTER.withName("ReleaseKernelRegistry"), + onnxruntime_c_api_h.C_POINTER.withName("KernelRegistry_AddKernel"), + onnxruntime_c_api_h.C_POINTER.withName("CreateKernelDefBuilder"), + onnxruntime_c_api_h.C_POINTER.withName("ReleaseKernelDefBuilder"), + onnxruntime_c_api_h.C_POINTER.withName("KernelDefBuilder_SetOperatorType"), + onnxruntime_c_api_h.C_POINTER.withName("KernelDefBuilder_SetDomain"), + onnxruntime_c_api_h.C_POINTER.withName("KernelDefBuilder_SetSinceVersion"), + onnxruntime_c_api_h.C_POINTER.withName("KernelDefBuilder_SetExecutionProvider"), + onnxruntime_c_api_h.C_POINTER.withName("KernelDefBuilder_SetInputMemType"), + onnxruntime_c_api_h.C_POINTER.withName("KernelDefBuilder_SetOutputMemType"), + onnxruntime_c_api_h.C_POINTER.withName("KernelDefBuilder_AddTypeConstraint"), + onnxruntime_c_api_h.C_POINTER.withName("KernelDefBuilder_AddInputOutputAliases"), + onnxruntime_c_api_h.C_POINTER.withName("KernelDefBuilder_AddInputOutputMutableAliases"), + onnxruntime_c_api_h.C_POINTER.withName("KernelDefBuilder_Build"), + onnxruntime_c_api_h.C_POINTER.withName("ReleaseKernelDef"), + onnxruntime_c_api_h.C_POINTER.withName("KernelDef_GetOperatorType"), + onnxruntime_c_api_h.C_POINTER.withName("KernelDef_GetDomain"), + onnxruntime_c_api_h.C_POINTER.withName("KernelDef_GetSinceVersion"), + onnxruntime_c_api_h.C_POINTER.withName("KernelDef_GetExecutionProvider"), + onnxruntime_c_api_h.C_POINTER.withName("KernelDef_GetInputMemType"), + onnxruntime_c_api_h.C_POINTER.withName("KernelDef_GetOutputMemType"), + onnxruntime_c_api_h.C_POINTER.withName("GetTensorDataType"), + onnxruntime_c_api_h.C_POINTER.withName("EpGraphSupportInfo_LookUpKernel"), + onnxruntime_c_api_h.C_POINTER.withName("SharedPrePackedWeightCache_StoreWeightData"), + onnxruntime_c_api_h.C_POINTER.withName("KernelInfo_GetEp"), + onnxruntime_c_api_h.C_POINTER.withName("DeviceEpIncompatibilityDetails_SetDetails"), + onnxruntime_c_api_h.C_POINTER.withName("CreateIfKernel"), + onnxruntime_c_api_h.C_POINTER.withName("CreateLoopKernel"), + onnxruntime_c_api_h.C_POINTER.withName("CreateScanKernel"), + onnxruntime_c_api_h.C_POINTER.withName("ReleaseKernelImpl"), + onnxruntime_c_api_h.C_POINTER.withName("GetEnvConfigEntries"), + onnxruntime_c_api_h.C_POINTER.withName("GetOpSchema"), + onnxruntime_c_api_h.C_POINTER.withName("ReleaseOpSchema"), + onnxruntime_c_api_h.C_POINTER.withName("OpSchema_GetSinceVersion"), + onnxruntime_c_api_h.C_POINTER.withName("OpSchema_GetNumInputs"), + onnxruntime_c_api_h.C_POINTER.withName("OpSchema_GetInputName"), + onnxruntime_c_api_h.C_POINTER.withName("OpSchema_GetInputTypeConstraint"), + onnxruntime_c_api_h.C_POINTER.withName("OpSchema_GetNumOutputs"), + onnxruntime_c_api_h.C_POINTER.withName("OpSchema_GetOutputName"), + onnxruntime_c_api_h.C_POINTER.withName("OpSchema_GetOutputTypeConstraint"), + onnxruntime_c_api_h.C_POINTER.withName("OpSchema_GetTypeConstraintCount"), + onnxruntime_c_api_h.C_POINTER.withName("OpSchema_GetTypeConstraint"), + onnxruntime_c_api_h.C_POINTER.withName("OpSchemaTypeConstraint_GetTypeParamName"), + onnxruntime_c_api_h.C_POINTER.withName("OpSchemaTypeConstraint_GetAllowedTypes"), + onnxruntime_c_api_h.C_POINTER.withName("OpSchemaTypeConstraint_GetInputIndices"), + onnxruntime_c_api_h.C_POINTER.withName("OpSchemaTypeConstraint_GetOutputIndices"), + onnxruntime_c_api_h.C_POINTER.withName("CreateProfilingEvent"), + onnxruntime_c_api_h.C_POINTER.withName("ReleaseProfilingEvent"), + onnxruntime_c_api_h.C_POINTER.withName("ProfilingEvent_GetCategory"), + onnxruntime_c_api_h.C_POINTER.withName("ProfilingEvent_GetName"), + onnxruntime_c_api_h.C_POINTER.withName("ProfilingEvent_GetTimestampUs"), + onnxruntime_c_api_h.C_POINTER.withName("ProfilingEvent_GetDurationUs"), + onnxruntime_c_api_h.C_POINTER.withName("ProfilingEvent_GetArgValue"), + onnxruntime_c_api_h.C_POINTER.withName("ProfilingEventsContainer_AddEvents") + ).withName("OrtEpApi"); + + /** + * The layout of this struct + */ + public static final GroupLayout layout() { + return $LAYOUT; + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*CreateEpDevice)(OrtEpFactory *, const OrtHardwareDevice *, const OrtKeyValuePairs *, const OrtKeyValuePairs *, OrtEpDevice **) + * } + */ + public final static class CreateEpDevice { + + private CreateEpDevice() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, MemorySegment _x3, MemorySegment _x4); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(CreateEpDevice.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(CreateEpDevice.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, MemorySegment _x3, MemorySegment _x4) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout CreateEpDevice$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("CreateEpDevice")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateEpDevice)(OrtEpFactory *, const OrtHardwareDevice *, const OrtKeyValuePairs *, const OrtKeyValuePairs *, OrtEpDevice **) + * } + */ + public static final AddressLayout CreateEpDevice$layout() { + return CreateEpDevice$LAYOUT; + } + + private static final long CreateEpDevice$OFFSET = $LAYOUT.byteOffset(groupElement("CreateEpDevice")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateEpDevice)(OrtEpFactory *, const OrtHardwareDevice *, const OrtKeyValuePairs *, const OrtKeyValuePairs *, OrtEpDevice **) + * } + */ + public static final long CreateEpDevice$offset() { + return CreateEpDevice$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateEpDevice)(OrtEpFactory *, const OrtHardwareDevice *, const OrtKeyValuePairs *, const OrtKeyValuePairs *, OrtEpDevice **) + * } + */ + public static MemorySegment CreateEpDevice(MemorySegment struct) { + return struct.get(CreateEpDevice$LAYOUT, CreateEpDevice$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateEpDevice)(OrtEpFactory *, const OrtHardwareDevice *, const OrtKeyValuePairs *, const OrtKeyValuePairs *, OrtEpDevice **) + * } + */ + public static void CreateEpDevice(MemorySegment struct, MemorySegment fieldValue) { + struct.set(CreateEpDevice$LAYOUT, CreateEpDevice$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * void (*ReleaseEpDevice)(OrtEpDevice *) + * } + */ + public final static class ReleaseEpDevice { + + private ReleaseEpDevice() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + void apply(MemorySegment _x0); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.ofVoid( + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(ReleaseEpDevice.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(ReleaseEpDevice.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static void invoke(MemorySegment funcPtr, MemorySegment _x0) { + try { + DOWN$MH.invokeExact(funcPtr, _x0); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout ReleaseEpDevice$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("ReleaseEpDevice")); + + /** + * Layout for field: + * {@snippet lang=c : + * void (*ReleaseEpDevice)(OrtEpDevice *) + * } + */ + public static final AddressLayout ReleaseEpDevice$layout() { + return ReleaseEpDevice$LAYOUT; + } + + private static final long ReleaseEpDevice$OFFSET = $LAYOUT.byteOffset(groupElement("ReleaseEpDevice")); + + /** + * Offset for field: + * {@snippet lang=c : + * void (*ReleaseEpDevice)(OrtEpDevice *) + * } + */ + public static final long ReleaseEpDevice$offset() { + return ReleaseEpDevice$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * void (*ReleaseEpDevice)(OrtEpDevice *) + * } + */ + public static MemorySegment ReleaseEpDevice(MemorySegment struct) { + return struct.get(ReleaseEpDevice$LAYOUT, ReleaseEpDevice$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * void (*ReleaseEpDevice)(OrtEpDevice *) + * } + */ + public static void ReleaseEpDevice(MemorySegment struct, MemorySegment fieldValue) { + struct.set(ReleaseEpDevice$LAYOUT, ReleaseEpDevice$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*EpGraphSupportInfo_AddNodesToFuse)(OrtEpGraphSupportInfo *, const OrtNode *const *, size_t, const OrtNodeFusionOptions *) + * } + */ + public final static class EpGraphSupportInfo_AddNodesToFuse { + + private EpGraphSupportInfo_AddNodesToFuse() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1, long _x2, MemorySegment _x3); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_LONG, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(EpGraphSupportInfo_AddNodesToFuse.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(EpGraphSupportInfo_AddNodesToFuse.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1, long _x2, MemorySegment _x3) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout EpGraphSupportInfo_AddNodesToFuse$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("EpGraphSupportInfo_AddNodesToFuse")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*EpGraphSupportInfo_AddNodesToFuse)(OrtEpGraphSupportInfo *, const OrtNode *const *, size_t, const OrtNodeFusionOptions *) + * } + */ + public static final AddressLayout EpGraphSupportInfo_AddNodesToFuse$layout() { + return EpGraphSupportInfo_AddNodesToFuse$LAYOUT; + } + + private static final long EpGraphSupportInfo_AddNodesToFuse$OFFSET = $LAYOUT.byteOffset(groupElement("EpGraphSupportInfo_AddNodesToFuse")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*EpGraphSupportInfo_AddNodesToFuse)(OrtEpGraphSupportInfo *, const OrtNode *const *, size_t, const OrtNodeFusionOptions *) + * } + */ + public static final long EpGraphSupportInfo_AddNodesToFuse$offset() { + return EpGraphSupportInfo_AddNodesToFuse$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*EpGraphSupportInfo_AddNodesToFuse)(OrtEpGraphSupportInfo *, const OrtNode *const *, size_t, const OrtNodeFusionOptions *) + * } + */ + public static MemorySegment EpGraphSupportInfo_AddNodesToFuse(MemorySegment struct) { + return struct.get(EpGraphSupportInfo_AddNodesToFuse$LAYOUT, EpGraphSupportInfo_AddNodesToFuse$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*EpGraphSupportInfo_AddNodesToFuse)(OrtEpGraphSupportInfo *, const OrtNode *const *, size_t, const OrtNodeFusionOptions *) + * } + */ + public static void EpGraphSupportInfo_AddNodesToFuse(MemorySegment struct, MemorySegment fieldValue) { + struct.set(EpGraphSupportInfo_AddNodesToFuse$LAYOUT, EpGraphSupportInfo_AddNodesToFuse$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*EpGraphSupportInfo_AddSingleNode)(OrtEpGraphSupportInfo *, const OrtNode *) + * } + */ + public final static class EpGraphSupportInfo_AddSingleNode { + + private EpGraphSupportInfo_AddSingleNode() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(EpGraphSupportInfo_AddSingleNode.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(EpGraphSupportInfo_AddSingleNode.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout EpGraphSupportInfo_AddSingleNode$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("EpGraphSupportInfo_AddSingleNode")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*EpGraphSupportInfo_AddSingleNode)(OrtEpGraphSupportInfo *, const OrtNode *) + * } + */ + public static final AddressLayout EpGraphSupportInfo_AddSingleNode$layout() { + return EpGraphSupportInfo_AddSingleNode$LAYOUT; + } + + private static final long EpGraphSupportInfo_AddSingleNode$OFFSET = $LAYOUT.byteOffset(groupElement("EpGraphSupportInfo_AddSingleNode")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*EpGraphSupportInfo_AddSingleNode)(OrtEpGraphSupportInfo *, const OrtNode *) + * } + */ + public static final long EpGraphSupportInfo_AddSingleNode$offset() { + return EpGraphSupportInfo_AddSingleNode$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*EpGraphSupportInfo_AddSingleNode)(OrtEpGraphSupportInfo *, const OrtNode *) + * } + */ + public static MemorySegment EpGraphSupportInfo_AddSingleNode(MemorySegment struct) { + return struct.get(EpGraphSupportInfo_AddSingleNode$LAYOUT, EpGraphSupportInfo_AddSingleNode$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*EpGraphSupportInfo_AddSingleNode)(OrtEpGraphSupportInfo *, const OrtNode *) + * } + */ + public static void EpGraphSupportInfo_AddSingleNode(MemorySegment struct, MemorySegment fieldValue) { + struct.set(EpGraphSupportInfo_AddSingleNode$LAYOUT, EpGraphSupportInfo_AddSingleNode$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * const char *(*NodeComputeContext_NodeName)(const OrtNodeComputeContext *) + * } + */ + public final static class NodeComputeContext_NodeName { + + private NodeComputeContext_NodeName() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(NodeComputeContext_NodeName.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(NodeComputeContext_NodeName.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout NodeComputeContext_NodeName$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("NodeComputeContext_NodeName")); + + /** + * Layout for field: + * {@snippet lang=c : + * const char *(*NodeComputeContext_NodeName)(const OrtNodeComputeContext *) + * } + */ + public static final AddressLayout NodeComputeContext_NodeName$layout() { + return NodeComputeContext_NodeName$LAYOUT; + } + + private static final long NodeComputeContext_NodeName$OFFSET = $LAYOUT.byteOffset(groupElement("NodeComputeContext_NodeName")); + + /** + * Offset for field: + * {@snippet lang=c : + * const char *(*NodeComputeContext_NodeName)(const OrtNodeComputeContext *) + * } + */ + public static final long NodeComputeContext_NodeName$offset() { + return NodeComputeContext_NodeName$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * const char *(*NodeComputeContext_NodeName)(const OrtNodeComputeContext *) + * } + */ + public static MemorySegment NodeComputeContext_NodeName(MemorySegment struct) { + return struct.get(NodeComputeContext_NodeName$LAYOUT, NodeComputeContext_NodeName$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * const char *(*NodeComputeContext_NodeName)(const OrtNodeComputeContext *) + * } + */ + public static void NodeComputeContext_NodeName(MemorySegment struct, MemorySegment fieldValue) { + struct.set(NodeComputeContext_NodeName$LAYOUT, NodeComputeContext_NodeName$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*EpDevice_AddAllocatorInfo)(OrtEpDevice *, const OrtMemoryInfo *) + * } + */ + public final static class EpDevice_AddAllocatorInfo { + + private EpDevice_AddAllocatorInfo() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(EpDevice_AddAllocatorInfo.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(EpDevice_AddAllocatorInfo.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout EpDevice_AddAllocatorInfo$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("EpDevice_AddAllocatorInfo")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*EpDevice_AddAllocatorInfo)(OrtEpDevice *, const OrtMemoryInfo *) + * } + */ + public static final AddressLayout EpDevice_AddAllocatorInfo$layout() { + return EpDevice_AddAllocatorInfo$LAYOUT; + } + + private static final long EpDevice_AddAllocatorInfo$OFFSET = $LAYOUT.byteOffset(groupElement("EpDevice_AddAllocatorInfo")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*EpDevice_AddAllocatorInfo)(OrtEpDevice *, const OrtMemoryInfo *) + * } + */ + public static final long EpDevice_AddAllocatorInfo$offset() { + return EpDevice_AddAllocatorInfo$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*EpDevice_AddAllocatorInfo)(OrtEpDevice *, const OrtMemoryInfo *) + * } + */ + public static MemorySegment EpDevice_AddAllocatorInfo(MemorySegment struct) { + return struct.get(EpDevice_AddAllocatorInfo$LAYOUT, EpDevice_AddAllocatorInfo$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*EpDevice_AddAllocatorInfo)(OrtEpDevice *, const OrtMemoryInfo *) + * } + */ + public static void EpDevice_AddAllocatorInfo(MemorySegment struct, MemorySegment fieldValue) { + struct.set(EpDevice_AddAllocatorInfo$LAYOUT, EpDevice_AddAllocatorInfo$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * const OrtMemoryDevice *(*MemoryInfo_GetMemoryDevice)(const OrtMemoryInfo *) + * } + */ + public final static class MemoryInfo_GetMemoryDevice { + + private MemoryInfo_GetMemoryDevice() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(MemoryInfo_GetMemoryDevice.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(MemoryInfo_GetMemoryDevice.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout MemoryInfo_GetMemoryDevice$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("MemoryInfo_GetMemoryDevice")); + + /** + * Layout for field: + * {@snippet lang=c : + * const OrtMemoryDevice *(*MemoryInfo_GetMemoryDevice)(const OrtMemoryInfo *) + * } + */ + public static final AddressLayout MemoryInfo_GetMemoryDevice$layout() { + return MemoryInfo_GetMemoryDevice$LAYOUT; + } + + private static final long MemoryInfo_GetMemoryDevice$OFFSET = $LAYOUT.byteOffset(groupElement("MemoryInfo_GetMemoryDevice")); + + /** + * Offset for field: + * {@snippet lang=c : + * const OrtMemoryDevice *(*MemoryInfo_GetMemoryDevice)(const OrtMemoryInfo *) + * } + */ + public static final long MemoryInfo_GetMemoryDevice$offset() { + return MemoryInfo_GetMemoryDevice$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * const OrtMemoryDevice *(*MemoryInfo_GetMemoryDevice)(const OrtMemoryInfo *) + * } + */ + public static MemorySegment MemoryInfo_GetMemoryDevice(MemorySegment struct) { + return struct.get(MemoryInfo_GetMemoryDevice$LAYOUT, MemoryInfo_GetMemoryDevice$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * const OrtMemoryDevice *(*MemoryInfo_GetMemoryDevice)(const OrtMemoryInfo *) + * } + */ + public static void MemoryInfo_GetMemoryDevice(MemorySegment struct, MemorySegment fieldValue) { + struct.set(MemoryInfo_GetMemoryDevice$LAYOUT, MemoryInfo_GetMemoryDevice$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * const OrtMemoryDevice *(*Value_GetMemoryDevice)(const OrtValue *) + * } + */ + public final static class Value_GetMemoryDevice { + + private Value_GetMemoryDevice() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(Value_GetMemoryDevice.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(Value_GetMemoryDevice.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout Value_GetMemoryDevice$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("Value_GetMemoryDevice")); + + /** + * Layout for field: + * {@snippet lang=c : + * const OrtMemoryDevice *(*Value_GetMemoryDevice)(const OrtValue *) + * } + */ + public static final AddressLayout Value_GetMemoryDevice$layout() { + return Value_GetMemoryDevice$LAYOUT; + } + + private static final long Value_GetMemoryDevice$OFFSET = $LAYOUT.byteOffset(groupElement("Value_GetMemoryDevice")); + + /** + * Offset for field: + * {@snippet lang=c : + * const OrtMemoryDevice *(*Value_GetMemoryDevice)(const OrtValue *) + * } + */ + public static final long Value_GetMemoryDevice$offset() { + return Value_GetMemoryDevice$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * const OrtMemoryDevice *(*Value_GetMemoryDevice)(const OrtValue *) + * } + */ + public static MemorySegment Value_GetMemoryDevice(MemorySegment struct) { + return struct.get(Value_GetMemoryDevice$LAYOUT, Value_GetMemoryDevice$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * const OrtMemoryDevice *(*Value_GetMemoryDevice)(const OrtValue *) + * } + */ + public static void Value_GetMemoryDevice(MemorySegment struct, MemorySegment fieldValue) { + struct.set(Value_GetMemoryDevice$LAYOUT, Value_GetMemoryDevice$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * bool (*MemoryDevice_AreEqual)(const OrtMemoryDevice *, const OrtMemoryDevice *) + * } + */ + public final static class MemoryDevice_AreEqual { + + private MemoryDevice_AreEqual() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + boolean apply(MemorySegment _x0, MemorySegment _x1); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_BOOL, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(MemoryDevice_AreEqual.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(MemoryDevice_AreEqual.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static boolean invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1) { + try { + return (boolean) DOWN$MH.invokeExact(funcPtr, _x0, _x1); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout MemoryDevice_AreEqual$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("MemoryDevice_AreEqual")); + + /** + * Layout for field: + * {@snippet lang=c : + * bool (*MemoryDevice_AreEqual)(const OrtMemoryDevice *, const OrtMemoryDevice *) + * } + */ + public static final AddressLayout MemoryDevice_AreEqual$layout() { + return MemoryDevice_AreEqual$LAYOUT; + } + + private static final long MemoryDevice_AreEqual$OFFSET = $LAYOUT.byteOffset(groupElement("MemoryDevice_AreEqual")); + + /** + * Offset for field: + * {@snippet lang=c : + * bool (*MemoryDevice_AreEqual)(const OrtMemoryDevice *, const OrtMemoryDevice *) + * } + */ + public static final long MemoryDevice_AreEqual$offset() { + return MemoryDevice_AreEqual$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * bool (*MemoryDevice_AreEqual)(const OrtMemoryDevice *, const OrtMemoryDevice *) + * } + */ + public static MemorySegment MemoryDevice_AreEqual(MemorySegment struct) { + return struct.get(MemoryDevice_AreEqual$LAYOUT, MemoryDevice_AreEqual$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * bool (*MemoryDevice_AreEqual)(const OrtMemoryDevice *, const OrtMemoryDevice *) + * } + */ + public static void MemoryDevice_AreEqual(MemorySegment struct, MemorySegment fieldValue) { + struct.set(MemoryDevice_AreEqual$LAYOUT, MemoryDevice_AreEqual$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtMemoryInfoDeviceType (*MemoryDevice_GetDeviceType)(const OrtMemoryDevice *) + * } + */ + public final static class MemoryDevice_GetDeviceType { + + private MemoryDevice_GetDeviceType() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + int apply(MemorySegment _x0); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_INT, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(MemoryDevice_GetDeviceType.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(MemoryDevice_GetDeviceType.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static int invoke(MemorySegment funcPtr, MemorySegment _x0) { + try { + return (int) DOWN$MH.invokeExact(funcPtr, _x0); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout MemoryDevice_GetDeviceType$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("MemoryDevice_GetDeviceType")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtMemoryInfoDeviceType (*MemoryDevice_GetDeviceType)(const OrtMemoryDevice *) + * } + */ + public static final AddressLayout MemoryDevice_GetDeviceType$layout() { + return MemoryDevice_GetDeviceType$LAYOUT; + } + + private static final long MemoryDevice_GetDeviceType$OFFSET = $LAYOUT.byteOffset(groupElement("MemoryDevice_GetDeviceType")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtMemoryInfoDeviceType (*MemoryDevice_GetDeviceType)(const OrtMemoryDevice *) + * } + */ + public static final long MemoryDevice_GetDeviceType$offset() { + return MemoryDevice_GetDeviceType$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtMemoryInfoDeviceType (*MemoryDevice_GetDeviceType)(const OrtMemoryDevice *) + * } + */ + public static MemorySegment MemoryDevice_GetDeviceType(MemorySegment struct) { + return struct.get(MemoryDevice_GetDeviceType$LAYOUT, MemoryDevice_GetDeviceType$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtMemoryInfoDeviceType (*MemoryDevice_GetDeviceType)(const OrtMemoryDevice *) + * } + */ + public static void MemoryDevice_GetDeviceType(MemorySegment struct, MemorySegment fieldValue) { + struct.set(MemoryDevice_GetDeviceType$LAYOUT, MemoryDevice_GetDeviceType$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtDeviceMemoryType (*MemoryDevice_GetMemoryType)(const OrtMemoryDevice *) + * } + */ + public final static class MemoryDevice_GetMemoryType { + + private MemoryDevice_GetMemoryType() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + int apply(MemorySegment _x0); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_INT, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(MemoryDevice_GetMemoryType.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(MemoryDevice_GetMemoryType.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static int invoke(MemorySegment funcPtr, MemorySegment _x0) { + try { + return (int) DOWN$MH.invokeExact(funcPtr, _x0); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout MemoryDevice_GetMemoryType$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("MemoryDevice_GetMemoryType")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtDeviceMemoryType (*MemoryDevice_GetMemoryType)(const OrtMemoryDevice *) + * } + */ + public static final AddressLayout MemoryDevice_GetMemoryType$layout() { + return MemoryDevice_GetMemoryType$LAYOUT; + } + + private static final long MemoryDevice_GetMemoryType$OFFSET = $LAYOUT.byteOffset(groupElement("MemoryDevice_GetMemoryType")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtDeviceMemoryType (*MemoryDevice_GetMemoryType)(const OrtMemoryDevice *) + * } + */ + public static final long MemoryDevice_GetMemoryType$offset() { + return MemoryDevice_GetMemoryType$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtDeviceMemoryType (*MemoryDevice_GetMemoryType)(const OrtMemoryDevice *) + * } + */ + public static MemorySegment MemoryDevice_GetMemoryType(MemorySegment struct) { + return struct.get(MemoryDevice_GetMemoryType$LAYOUT, MemoryDevice_GetMemoryType$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtDeviceMemoryType (*MemoryDevice_GetMemoryType)(const OrtMemoryDevice *) + * } + */ + public static void MemoryDevice_GetMemoryType(MemorySegment struct, MemorySegment fieldValue) { + struct.set(MemoryDevice_GetMemoryType$LAYOUT, MemoryDevice_GetMemoryType$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * uint32_t (*MemoryDevice_GetVendorId)(const OrtMemoryDevice *) + * } + */ + public final static class MemoryDevice_GetVendorId { + + private MemoryDevice_GetVendorId() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + int apply(MemorySegment _x0); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_INT, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(MemoryDevice_GetVendorId.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(MemoryDevice_GetVendorId.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static int invoke(MemorySegment funcPtr, MemorySegment _x0) { + try { + return (int) DOWN$MH.invokeExact(funcPtr, _x0); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout MemoryDevice_GetVendorId$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("MemoryDevice_GetVendorId")); + + /** + * Layout for field: + * {@snippet lang=c : + * uint32_t (*MemoryDevice_GetVendorId)(const OrtMemoryDevice *) + * } + */ + public static final AddressLayout MemoryDevice_GetVendorId$layout() { + return MemoryDevice_GetVendorId$LAYOUT; + } + + private static final long MemoryDevice_GetVendorId$OFFSET = $LAYOUT.byteOffset(groupElement("MemoryDevice_GetVendorId")); + + /** + * Offset for field: + * {@snippet lang=c : + * uint32_t (*MemoryDevice_GetVendorId)(const OrtMemoryDevice *) + * } + */ + public static final long MemoryDevice_GetVendorId$offset() { + return MemoryDevice_GetVendorId$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * uint32_t (*MemoryDevice_GetVendorId)(const OrtMemoryDevice *) + * } + */ + public static MemorySegment MemoryDevice_GetVendorId(MemorySegment struct) { + return struct.get(MemoryDevice_GetVendorId$LAYOUT, MemoryDevice_GetVendorId$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * uint32_t (*MemoryDevice_GetVendorId)(const OrtMemoryDevice *) + * } + */ + public static void MemoryDevice_GetVendorId(MemorySegment struct, MemorySegment fieldValue) { + struct.set(MemoryDevice_GetVendorId$LAYOUT, MemoryDevice_GetVendorId$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * uint32_t (*MemoryDevice_GetDeviceId)(const OrtMemoryDevice *) + * } + */ + public final static class MemoryDevice_GetDeviceId { + + private MemoryDevice_GetDeviceId() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + int apply(MemorySegment _x0); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_INT, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(MemoryDevice_GetDeviceId.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(MemoryDevice_GetDeviceId.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static int invoke(MemorySegment funcPtr, MemorySegment _x0) { + try { + return (int) DOWN$MH.invokeExact(funcPtr, _x0); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout MemoryDevice_GetDeviceId$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("MemoryDevice_GetDeviceId")); + + /** + * Layout for field: + * {@snippet lang=c : + * uint32_t (*MemoryDevice_GetDeviceId)(const OrtMemoryDevice *) + * } + */ + public static final AddressLayout MemoryDevice_GetDeviceId$layout() { + return MemoryDevice_GetDeviceId$LAYOUT; + } + + private static final long MemoryDevice_GetDeviceId$OFFSET = $LAYOUT.byteOffset(groupElement("MemoryDevice_GetDeviceId")); + + /** + * Offset for field: + * {@snippet lang=c : + * uint32_t (*MemoryDevice_GetDeviceId)(const OrtMemoryDevice *) + * } + */ + public static final long MemoryDevice_GetDeviceId$offset() { + return MemoryDevice_GetDeviceId$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * uint32_t (*MemoryDevice_GetDeviceId)(const OrtMemoryDevice *) + * } + */ + public static MemorySegment MemoryDevice_GetDeviceId(MemorySegment struct) { + return struct.get(MemoryDevice_GetDeviceId$LAYOUT, MemoryDevice_GetDeviceId$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * uint32_t (*MemoryDevice_GetDeviceId)(const OrtMemoryDevice *) + * } + */ + public static void MemoryDevice_GetDeviceId(MemorySegment struct, MemorySegment fieldValue) { + struct.set(MemoryDevice_GetDeviceId$LAYOUT, MemoryDevice_GetDeviceId$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * const OrtSyncStreamImpl *(*SyncStream_GetImpl)(const OrtSyncStream *) + * } + */ + public final static class SyncStream_GetImpl { + + private SyncStream_GetImpl() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(SyncStream_GetImpl.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(SyncStream_GetImpl.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout SyncStream_GetImpl$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("SyncStream_GetImpl")); + + /** + * Layout for field: + * {@snippet lang=c : + * const OrtSyncStreamImpl *(*SyncStream_GetImpl)(const OrtSyncStream *) + * } + */ + public static final AddressLayout SyncStream_GetImpl$layout() { + return SyncStream_GetImpl$LAYOUT; + } + + private static final long SyncStream_GetImpl$OFFSET = $LAYOUT.byteOffset(groupElement("SyncStream_GetImpl")); + + /** + * Offset for field: + * {@snippet lang=c : + * const OrtSyncStreamImpl *(*SyncStream_GetImpl)(const OrtSyncStream *) + * } + */ + public static final long SyncStream_GetImpl$offset() { + return SyncStream_GetImpl$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * const OrtSyncStreamImpl *(*SyncStream_GetImpl)(const OrtSyncStream *) + * } + */ + public static MemorySegment SyncStream_GetImpl(MemorySegment struct) { + return struct.get(SyncStream_GetImpl$LAYOUT, SyncStream_GetImpl$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * const OrtSyncStreamImpl *(*SyncStream_GetImpl)(const OrtSyncStream *) + * } + */ + public static void SyncStream_GetImpl(MemorySegment struct, MemorySegment fieldValue) { + struct.set(SyncStream_GetImpl$LAYOUT, SyncStream_GetImpl$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * uint64_t (*SyncStream_GetSyncId)(const OrtSyncStream *) + * } + */ + public final static class SyncStream_GetSyncId { + + private SyncStream_GetSyncId() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + long apply(MemorySegment _x0); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_LONG_LONG, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(SyncStream_GetSyncId.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(SyncStream_GetSyncId.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static long invoke(MemorySegment funcPtr, MemorySegment _x0) { + try { + return (long) DOWN$MH.invokeExact(funcPtr, _x0); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout SyncStream_GetSyncId$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("SyncStream_GetSyncId")); + + /** + * Layout for field: + * {@snippet lang=c : + * uint64_t (*SyncStream_GetSyncId)(const OrtSyncStream *) + * } + */ + public static final AddressLayout SyncStream_GetSyncId$layout() { + return SyncStream_GetSyncId$LAYOUT; + } + + private static final long SyncStream_GetSyncId$OFFSET = $LAYOUT.byteOffset(groupElement("SyncStream_GetSyncId")); + + /** + * Offset for field: + * {@snippet lang=c : + * uint64_t (*SyncStream_GetSyncId)(const OrtSyncStream *) + * } + */ + public static final long SyncStream_GetSyncId$offset() { + return SyncStream_GetSyncId$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * uint64_t (*SyncStream_GetSyncId)(const OrtSyncStream *) + * } + */ + public static MemorySegment SyncStream_GetSyncId(MemorySegment struct) { + return struct.get(SyncStream_GetSyncId$LAYOUT, SyncStream_GetSyncId$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * uint64_t (*SyncStream_GetSyncId)(const OrtSyncStream *) + * } + */ + public static void SyncStream_GetSyncId(MemorySegment struct, MemorySegment fieldValue) { + struct.set(SyncStream_GetSyncId$LAYOUT, SyncStream_GetSyncId$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * uint64_t (*GetSyncIdForLastWaitOnSyncStream)(const OrtSyncStream *, const OrtSyncStream *) + * } + */ + public final static class GetSyncIdForLastWaitOnSyncStream { + + private GetSyncIdForLastWaitOnSyncStream() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + long apply(MemorySegment _x0, MemorySegment _x1); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_LONG_LONG, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(GetSyncIdForLastWaitOnSyncStream.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(GetSyncIdForLastWaitOnSyncStream.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static long invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1) { + try { + return (long) DOWN$MH.invokeExact(funcPtr, _x0, _x1); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout GetSyncIdForLastWaitOnSyncStream$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("GetSyncIdForLastWaitOnSyncStream")); + + /** + * Layout for field: + * {@snippet lang=c : + * uint64_t (*GetSyncIdForLastWaitOnSyncStream)(const OrtSyncStream *, const OrtSyncStream *) + * } + */ + public static final AddressLayout GetSyncIdForLastWaitOnSyncStream$layout() { + return GetSyncIdForLastWaitOnSyncStream$LAYOUT; + } + + private static final long GetSyncIdForLastWaitOnSyncStream$OFFSET = $LAYOUT.byteOffset(groupElement("GetSyncIdForLastWaitOnSyncStream")); + + /** + * Offset for field: + * {@snippet lang=c : + * uint64_t (*GetSyncIdForLastWaitOnSyncStream)(const OrtSyncStream *, const OrtSyncStream *) + * } + */ + public static final long GetSyncIdForLastWaitOnSyncStream$offset() { + return GetSyncIdForLastWaitOnSyncStream$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * uint64_t (*GetSyncIdForLastWaitOnSyncStream)(const OrtSyncStream *, const OrtSyncStream *) + * } + */ + public static MemorySegment GetSyncIdForLastWaitOnSyncStream(MemorySegment struct) { + return struct.get(GetSyncIdForLastWaitOnSyncStream$LAYOUT, GetSyncIdForLastWaitOnSyncStream$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * uint64_t (*GetSyncIdForLastWaitOnSyncStream)(const OrtSyncStream *, const OrtSyncStream *) + * } + */ + public static void GetSyncIdForLastWaitOnSyncStream(MemorySegment struct, MemorySegment fieldValue) { + struct.set(GetSyncIdForLastWaitOnSyncStream$LAYOUT, GetSyncIdForLastWaitOnSyncStream$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*CreateHardwareDevice)(OrtHardwareDeviceType, uint32_t, uint32_t, const char *, const OrtKeyValuePairs *, OrtHardwareDevice **) + * } + */ + public final static class CreateHardwareDevice { + + private CreateHardwareDevice() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(int _x0, int _x1, int _x2, MemorySegment _x3, MemorySegment _x4, MemorySegment _x5); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_INT, + onnxruntime_c_api_h.C_INT, + onnxruntime_c_api_h.C_INT, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(CreateHardwareDevice.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(CreateHardwareDevice.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, int _x0, int _x1, int _x2, MemorySegment _x3, MemorySegment _x4, MemorySegment _x5) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4, _x5); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout CreateHardwareDevice$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("CreateHardwareDevice")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateHardwareDevice)(OrtHardwareDeviceType, uint32_t, uint32_t, const char *, const OrtKeyValuePairs *, OrtHardwareDevice **) + * } + */ + public static final AddressLayout CreateHardwareDevice$layout() { + return CreateHardwareDevice$LAYOUT; + } + + private static final long CreateHardwareDevice$OFFSET = $LAYOUT.byteOffset(groupElement("CreateHardwareDevice")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateHardwareDevice)(OrtHardwareDeviceType, uint32_t, uint32_t, const char *, const OrtKeyValuePairs *, OrtHardwareDevice **) + * } + */ + public static final long CreateHardwareDevice$offset() { + return CreateHardwareDevice$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateHardwareDevice)(OrtHardwareDeviceType, uint32_t, uint32_t, const char *, const OrtKeyValuePairs *, OrtHardwareDevice **) + * } + */ + public static MemorySegment CreateHardwareDevice(MemorySegment struct) { + return struct.get(CreateHardwareDevice$LAYOUT, CreateHardwareDevice$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateHardwareDevice)(OrtHardwareDeviceType, uint32_t, uint32_t, const char *, const OrtKeyValuePairs *, OrtHardwareDevice **) + * } + */ + public static void CreateHardwareDevice(MemorySegment struct, MemorySegment fieldValue) { + struct.set(CreateHardwareDevice$LAYOUT, CreateHardwareDevice$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * void (*ReleaseHardwareDevice)(OrtHardwareDevice *) + * } + */ + public final static class ReleaseHardwareDevice { + + private ReleaseHardwareDevice() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + void apply(MemorySegment _x0); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.ofVoid( + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(ReleaseHardwareDevice.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(ReleaseHardwareDevice.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static void invoke(MemorySegment funcPtr, MemorySegment _x0) { + try { + DOWN$MH.invokeExact(funcPtr, _x0); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout ReleaseHardwareDevice$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("ReleaseHardwareDevice")); + + /** + * Layout for field: + * {@snippet lang=c : + * void (*ReleaseHardwareDevice)(OrtHardwareDevice *) + * } + */ + public static final AddressLayout ReleaseHardwareDevice$layout() { + return ReleaseHardwareDevice$LAYOUT; + } + + private static final long ReleaseHardwareDevice$OFFSET = $LAYOUT.byteOffset(groupElement("ReleaseHardwareDevice")); + + /** + * Offset for field: + * {@snippet lang=c : + * void (*ReleaseHardwareDevice)(OrtHardwareDevice *) + * } + */ + public static final long ReleaseHardwareDevice$offset() { + return ReleaseHardwareDevice$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * void (*ReleaseHardwareDevice)(OrtHardwareDevice *) + * } + */ + public static MemorySegment ReleaseHardwareDevice(MemorySegment struct) { + return struct.get(ReleaseHardwareDevice$LAYOUT, ReleaseHardwareDevice$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * void (*ReleaseHardwareDevice)(OrtHardwareDevice *) + * } + */ + public static void ReleaseHardwareDevice(MemorySegment struct, MemorySegment fieldValue) { + struct.set(ReleaseHardwareDevice$LAYOUT, ReleaseHardwareDevice$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*CreateKernelRegistry)(OrtKernelRegistry **) + * } + */ + public final static class CreateKernelRegistry { + + private CreateKernelRegistry() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(CreateKernelRegistry.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(CreateKernelRegistry.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout CreateKernelRegistry$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("CreateKernelRegistry")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateKernelRegistry)(OrtKernelRegistry **) + * } + */ + public static final AddressLayout CreateKernelRegistry$layout() { + return CreateKernelRegistry$LAYOUT; + } + + private static final long CreateKernelRegistry$OFFSET = $LAYOUT.byteOffset(groupElement("CreateKernelRegistry")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateKernelRegistry)(OrtKernelRegistry **) + * } + */ + public static final long CreateKernelRegistry$offset() { + return CreateKernelRegistry$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateKernelRegistry)(OrtKernelRegistry **) + * } + */ + public static MemorySegment CreateKernelRegistry(MemorySegment struct) { + return struct.get(CreateKernelRegistry$LAYOUT, CreateKernelRegistry$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateKernelRegistry)(OrtKernelRegistry **) + * } + */ + public static void CreateKernelRegistry(MemorySegment struct, MemorySegment fieldValue) { + struct.set(CreateKernelRegistry$LAYOUT, CreateKernelRegistry$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * void (*ReleaseKernelRegistry)(OrtKernelRegistry *) + * } + */ + public final static class ReleaseKernelRegistry { + + private ReleaseKernelRegistry() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + void apply(MemorySegment _x0); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.ofVoid( + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(ReleaseKernelRegistry.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(ReleaseKernelRegistry.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static void invoke(MemorySegment funcPtr, MemorySegment _x0) { + try { + DOWN$MH.invokeExact(funcPtr, _x0); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout ReleaseKernelRegistry$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("ReleaseKernelRegistry")); + + /** + * Layout for field: + * {@snippet lang=c : + * void (*ReleaseKernelRegistry)(OrtKernelRegistry *) + * } + */ + public static final AddressLayout ReleaseKernelRegistry$layout() { + return ReleaseKernelRegistry$LAYOUT; + } + + private static final long ReleaseKernelRegistry$OFFSET = $LAYOUT.byteOffset(groupElement("ReleaseKernelRegistry")); + + /** + * Offset for field: + * {@snippet lang=c : + * void (*ReleaseKernelRegistry)(OrtKernelRegistry *) + * } + */ + public static final long ReleaseKernelRegistry$offset() { + return ReleaseKernelRegistry$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * void (*ReleaseKernelRegistry)(OrtKernelRegistry *) + * } + */ + public static MemorySegment ReleaseKernelRegistry(MemorySegment struct) { + return struct.get(ReleaseKernelRegistry$LAYOUT, ReleaseKernelRegistry$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * void (*ReleaseKernelRegistry)(OrtKernelRegistry *) + * } + */ + public static void ReleaseKernelRegistry(MemorySegment struct, MemorySegment fieldValue) { + struct.set(ReleaseKernelRegistry$LAYOUT, ReleaseKernelRegistry$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*KernelRegistry_AddKernel)(OrtKernelRegistry *, const OrtKernelDef *, OrtKernelCreateFunc, void *) + * } + */ + public final static class KernelRegistry_AddKernel { + + private KernelRegistry_AddKernel() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, MemorySegment _x3); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(KernelRegistry_AddKernel.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(KernelRegistry_AddKernel.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, MemorySegment _x3) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout KernelRegistry_AddKernel$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("KernelRegistry_AddKernel")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelRegistry_AddKernel)(OrtKernelRegistry *, const OrtKernelDef *, OrtKernelCreateFunc, void *) + * } + */ + public static final AddressLayout KernelRegistry_AddKernel$layout() { + return KernelRegistry_AddKernel$LAYOUT; + } + + private static final long KernelRegistry_AddKernel$OFFSET = $LAYOUT.byteOffset(groupElement("KernelRegistry_AddKernel")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelRegistry_AddKernel)(OrtKernelRegistry *, const OrtKernelDef *, OrtKernelCreateFunc, void *) + * } + */ + public static final long KernelRegistry_AddKernel$offset() { + return KernelRegistry_AddKernel$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelRegistry_AddKernel)(OrtKernelRegistry *, const OrtKernelDef *, OrtKernelCreateFunc, void *) + * } + */ + public static MemorySegment KernelRegistry_AddKernel(MemorySegment struct) { + return struct.get(KernelRegistry_AddKernel$LAYOUT, KernelRegistry_AddKernel$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelRegistry_AddKernel)(OrtKernelRegistry *, const OrtKernelDef *, OrtKernelCreateFunc, void *) + * } + */ + public static void KernelRegistry_AddKernel(MemorySegment struct, MemorySegment fieldValue) { + struct.set(KernelRegistry_AddKernel$LAYOUT, KernelRegistry_AddKernel$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*CreateKernelDefBuilder)(OrtKernelDefBuilder **) + * } + */ + public final static class CreateKernelDefBuilder { + + private CreateKernelDefBuilder() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(CreateKernelDefBuilder.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(CreateKernelDefBuilder.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout CreateKernelDefBuilder$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("CreateKernelDefBuilder")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateKernelDefBuilder)(OrtKernelDefBuilder **) + * } + */ + public static final AddressLayout CreateKernelDefBuilder$layout() { + return CreateKernelDefBuilder$LAYOUT; + } + + private static final long CreateKernelDefBuilder$OFFSET = $LAYOUT.byteOffset(groupElement("CreateKernelDefBuilder")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateKernelDefBuilder)(OrtKernelDefBuilder **) + * } + */ + public static final long CreateKernelDefBuilder$offset() { + return CreateKernelDefBuilder$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateKernelDefBuilder)(OrtKernelDefBuilder **) + * } + */ + public static MemorySegment CreateKernelDefBuilder(MemorySegment struct) { + return struct.get(CreateKernelDefBuilder$LAYOUT, CreateKernelDefBuilder$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateKernelDefBuilder)(OrtKernelDefBuilder **) + * } + */ + public static void CreateKernelDefBuilder(MemorySegment struct, MemorySegment fieldValue) { + struct.set(CreateKernelDefBuilder$LAYOUT, CreateKernelDefBuilder$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * void (*ReleaseKernelDefBuilder)(OrtKernelDefBuilder *) + * } + */ + public final static class ReleaseKernelDefBuilder { + + private ReleaseKernelDefBuilder() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + void apply(MemorySegment _x0); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.ofVoid( + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(ReleaseKernelDefBuilder.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(ReleaseKernelDefBuilder.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static void invoke(MemorySegment funcPtr, MemorySegment _x0) { + try { + DOWN$MH.invokeExact(funcPtr, _x0); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout ReleaseKernelDefBuilder$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("ReleaseKernelDefBuilder")); + + /** + * Layout for field: + * {@snippet lang=c : + * void (*ReleaseKernelDefBuilder)(OrtKernelDefBuilder *) + * } + */ + public static final AddressLayout ReleaseKernelDefBuilder$layout() { + return ReleaseKernelDefBuilder$LAYOUT; + } + + private static final long ReleaseKernelDefBuilder$OFFSET = $LAYOUT.byteOffset(groupElement("ReleaseKernelDefBuilder")); + + /** + * Offset for field: + * {@snippet lang=c : + * void (*ReleaseKernelDefBuilder)(OrtKernelDefBuilder *) + * } + */ + public static final long ReleaseKernelDefBuilder$offset() { + return ReleaseKernelDefBuilder$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * void (*ReleaseKernelDefBuilder)(OrtKernelDefBuilder *) + * } + */ + public static MemorySegment ReleaseKernelDefBuilder(MemorySegment struct) { + return struct.get(ReleaseKernelDefBuilder$LAYOUT, ReleaseKernelDefBuilder$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * void (*ReleaseKernelDefBuilder)(OrtKernelDefBuilder *) + * } + */ + public static void ReleaseKernelDefBuilder(MemorySegment struct, MemorySegment fieldValue) { + struct.set(ReleaseKernelDefBuilder$LAYOUT, ReleaseKernelDefBuilder$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetOperatorType)(OrtKernelDefBuilder *, const char *) + * } + */ + public final static class KernelDefBuilder_SetOperatorType { + + private KernelDefBuilder_SetOperatorType() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(KernelDefBuilder_SetOperatorType.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(KernelDefBuilder_SetOperatorType.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout KernelDefBuilder_SetOperatorType$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("KernelDefBuilder_SetOperatorType")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetOperatorType)(OrtKernelDefBuilder *, const char *) + * } + */ + public static final AddressLayout KernelDefBuilder_SetOperatorType$layout() { + return KernelDefBuilder_SetOperatorType$LAYOUT; + } + + private static final long KernelDefBuilder_SetOperatorType$OFFSET = $LAYOUT.byteOffset(groupElement("KernelDefBuilder_SetOperatorType")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetOperatorType)(OrtKernelDefBuilder *, const char *) + * } + */ + public static final long KernelDefBuilder_SetOperatorType$offset() { + return KernelDefBuilder_SetOperatorType$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetOperatorType)(OrtKernelDefBuilder *, const char *) + * } + */ + public static MemorySegment KernelDefBuilder_SetOperatorType(MemorySegment struct) { + return struct.get(KernelDefBuilder_SetOperatorType$LAYOUT, KernelDefBuilder_SetOperatorType$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetOperatorType)(OrtKernelDefBuilder *, const char *) + * } + */ + public static void KernelDefBuilder_SetOperatorType(MemorySegment struct, MemorySegment fieldValue) { + struct.set(KernelDefBuilder_SetOperatorType$LAYOUT, KernelDefBuilder_SetOperatorType$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetDomain)(OrtKernelDefBuilder *, const char *) + * } + */ + public final static class KernelDefBuilder_SetDomain { + + private KernelDefBuilder_SetDomain() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(KernelDefBuilder_SetDomain.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(KernelDefBuilder_SetDomain.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout KernelDefBuilder_SetDomain$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("KernelDefBuilder_SetDomain")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetDomain)(OrtKernelDefBuilder *, const char *) + * } + */ + public static final AddressLayout KernelDefBuilder_SetDomain$layout() { + return KernelDefBuilder_SetDomain$LAYOUT; + } + + private static final long KernelDefBuilder_SetDomain$OFFSET = $LAYOUT.byteOffset(groupElement("KernelDefBuilder_SetDomain")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetDomain)(OrtKernelDefBuilder *, const char *) + * } + */ + public static final long KernelDefBuilder_SetDomain$offset() { + return KernelDefBuilder_SetDomain$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetDomain)(OrtKernelDefBuilder *, const char *) + * } + */ + public static MemorySegment KernelDefBuilder_SetDomain(MemorySegment struct) { + return struct.get(KernelDefBuilder_SetDomain$LAYOUT, KernelDefBuilder_SetDomain$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetDomain)(OrtKernelDefBuilder *, const char *) + * } + */ + public static void KernelDefBuilder_SetDomain(MemorySegment struct, MemorySegment fieldValue) { + struct.set(KernelDefBuilder_SetDomain$LAYOUT, KernelDefBuilder_SetDomain$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetSinceVersion)(OrtKernelDefBuilder *, int, int) + * } + */ + public final static class KernelDefBuilder_SetSinceVersion { + + private KernelDefBuilder_SetSinceVersion() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, int _x1, int _x2); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_INT, + onnxruntime_c_api_h.C_INT + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(KernelDefBuilder_SetSinceVersion.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(KernelDefBuilder_SetSinceVersion.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, int _x1, int _x2) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout KernelDefBuilder_SetSinceVersion$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("KernelDefBuilder_SetSinceVersion")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetSinceVersion)(OrtKernelDefBuilder *, int, int) + * } + */ + public static final AddressLayout KernelDefBuilder_SetSinceVersion$layout() { + return KernelDefBuilder_SetSinceVersion$LAYOUT; + } + + private static final long KernelDefBuilder_SetSinceVersion$OFFSET = $LAYOUT.byteOffset(groupElement("KernelDefBuilder_SetSinceVersion")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetSinceVersion)(OrtKernelDefBuilder *, int, int) + * } + */ + public static final long KernelDefBuilder_SetSinceVersion$offset() { + return KernelDefBuilder_SetSinceVersion$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetSinceVersion)(OrtKernelDefBuilder *, int, int) + * } + */ + public static MemorySegment KernelDefBuilder_SetSinceVersion(MemorySegment struct) { + return struct.get(KernelDefBuilder_SetSinceVersion$LAYOUT, KernelDefBuilder_SetSinceVersion$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetSinceVersion)(OrtKernelDefBuilder *, int, int) + * } + */ + public static void KernelDefBuilder_SetSinceVersion(MemorySegment struct, MemorySegment fieldValue) { + struct.set(KernelDefBuilder_SetSinceVersion$LAYOUT, KernelDefBuilder_SetSinceVersion$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetExecutionProvider)(OrtKernelDefBuilder *, const char *) + * } + */ + public final static class KernelDefBuilder_SetExecutionProvider { + + private KernelDefBuilder_SetExecutionProvider() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(KernelDefBuilder_SetExecutionProvider.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(KernelDefBuilder_SetExecutionProvider.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout KernelDefBuilder_SetExecutionProvider$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("KernelDefBuilder_SetExecutionProvider")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetExecutionProvider)(OrtKernelDefBuilder *, const char *) + * } + */ + public static final AddressLayout KernelDefBuilder_SetExecutionProvider$layout() { + return KernelDefBuilder_SetExecutionProvider$LAYOUT; + } + + private static final long KernelDefBuilder_SetExecutionProvider$OFFSET = $LAYOUT.byteOffset(groupElement("KernelDefBuilder_SetExecutionProvider")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetExecutionProvider)(OrtKernelDefBuilder *, const char *) + * } + */ + public static final long KernelDefBuilder_SetExecutionProvider$offset() { + return KernelDefBuilder_SetExecutionProvider$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetExecutionProvider)(OrtKernelDefBuilder *, const char *) + * } + */ + public static MemorySegment KernelDefBuilder_SetExecutionProvider(MemorySegment struct) { + return struct.get(KernelDefBuilder_SetExecutionProvider$LAYOUT, KernelDefBuilder_SetExecutionProvider$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetExecutionProvider)(OrtKernelDefBuilder *, const char *) + * } + */ + public static void KernelDefBuilder_SetExecutionProvider(MemorySegment struct, MemorySegment fieldValue) { + struct.set(KernelDefBuilder_SetExecutionProvider$LAYOUT, KernelDefBuilder_SetExecutionProvider$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetInputMemType)(OrtKernelDefBuilder *, size_t, OrtMemType) + * } + */ + public final static class KernelDefBuilder_SetInputMemType { + + private KernelDefBuilder_SetInputMemType() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, long _x1, int _x2); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_LONG, + onnxruntime_c_api_h.C_INT + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(KernelDefBuilder_SetInputMemType.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(KernelDefBuilder_SetInputMemType.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, long _x1, int _x2) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout KernelDefBuilder_SetInputMemType$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("KernelDefBuilder_SetInputMemType")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetInputMemType)(OrtKernelDefBuilder *, size_t, OrtMemType) + * } + */ + public static final AddressLayout KernelDefBuilder_SetInputMemType$layout() { + return KernelDefBuilder_SetInputMemType$LAYOUT; + } + + private static final long KernelDefBuilder_SetInputMemType$OFFSET = $LAYOUT.byteOffset(groupElement("KernelDefBuilder_SetInputMemType")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetInputMemType)(OrtKernelDefBuilder *, size_t, OrtMemType) + * } + */ + public static final long KernelDefBuilder_SetInputMemType$offset() { + return KernelDefBuilder_SetInputMemType$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetInputMemType)(OrtKernelDefBuilder *, size_t, OrtMemType) + * } + */ + public static MemorySegment KernelDefBuilder_SetInputMemType(MemorySegment struct) { + return struct.get(KernelDefBuilder_SetInputMemType$LAYOUT, KernelDefBuilder_SetInputMemType$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetInputMemType)(OrtKernelDefBuilder *, size_t, OrtMemType) + * } + */ + public static void KernelDefBuilder_SetInputMemType(MemorySegment struct, MemorySegment fieldValue) { + struct.set(KernelDefBuilder_SetInputMemType$LAYOUT, KernelDefBuilder_SetInputMemType$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetOutputMemType)(OrtKernelDefBuilder *, size_t, OrtMemType) + * } + */ + public final static class KernelDefBuilder_SetOutputMemType { + + private KernelDefBuilder_SetOutputMemType() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, long _x1, int _x2); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_LONG, + onnxruntime_c_api_h.C_INT + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(KernelDefBuilder_SetOutputMemType.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(KernelDefBuilder_SetOutputMemType.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, long _x1, int _x2) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout KernelDefBuilder_SetOutputMemType$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("KernelDefBuilder_SetOutputMemType")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetOutputMemType)(OrtKernelDefBuilder *, size_t, OrtMemType) + * } + */ + public static final AddressLayout KernelDefBuilder_SetOutputMemType$layout() { + return KernelDefBuilder_SetOutputMemType$LAYOUT; + } + + private static final long KernelDefBuilder_SetOutputMemType$OFFSET = $LAYOUT.byteOffset(groupElement("KernelDefBuilder_SetOutputMemType")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetOutputMemType)(OrtKernelDefBuilder *, size_t, OrtMemType) + * } + */ + public static final long KernelDefBuilder_SetOutputMemType$offset() { + return KernelDefBuilder_SetOutputMemType$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetOutputMemType)(OrtKernelDefBuilder *, size_t, OrtMemType) + * } + */ + public static MemorySegment KernelDefBuilder_SetOutputMemType(MemorySegment struct) { + return struct.get(KernelDefBuilder_SetOutputMemType$LAYOUT, KernelDefBuilder_SetOutputMemType$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_SetOutputMemType)(OrtKernelDefBuilder *, size_t, OrtMemType) + * } + */ + public static void KernelDefBuilder_SetOutputMemType(MemorySegment struct, MemorySegment fieldValue) { + struct.set(KernelDefBuilder_SetOutputMemType$LAYOUT, KernelDefBuilder_SetOutputMemType$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_AddTypeConstraint)(OrtKernelDefBuilder *, const char *, const OrtDataType *const *, size_t) + * } + */ + public final static class KernelDefBuilder_AddTypeConstraint { + + private KernelDefBuilder_AddTypeConstraint() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_LONG + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(KernelDefBuilder_AddTypeConstraint.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(KernelDefBuilder_AddTypeConstraint.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout KernelDefBuilder_AddTypeConstraint$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("KernelDefBuilder_AddTypeConstraint")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_AddTypeConstraint)(OrtKernelDefBuilder *, const char *, const OrtDataType *const *, size_t) + * } + */ + public static final AddressLayout KernelDefBuilder_AddTypeConstraint$layout() { + return KernelDefBuilder_AddTypeConstraint$LAYOUT; + } + + private static final long KernelDefBuilder_AddTypeConstraint$OFFSET = $LAYOUT.byteOffset(groupElement("KernelDefBuilder_AddTypeConstraint")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_AddTypeConstraint)(OrtKernelDefBuilder *, const char *, const OrtDataType *const *, size_t) + * } + */ + public static final long KernelDefBuilder_AddTypeConstraint$offset() { + return KernelDefBuilder_AddTypeConstraint$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_AddTypeConstraint)(OrtKernelDefBuilder *, const char *, const OrtDataType *const *, size_t) + * } + */ + public static MemorySegment KernelDefBuilder_AddTypeConstraint(MemorySegment struct) { + return struct.get(KernelDefBuilder_AddTypeConstraint$LAYOUT, KernelDefBuilder_AddTypeConstraint$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_AddTypeConstraint)(OrtKernelDefBuilder *, const char *, const OrtDataType *const *, size_t) + * } + */ + public static void KernelDefBuilder_AddTypeConstraint(MemorySegment struct, MemorySegment fieldValue) { + struct.set(KernelDefBuilder_AddTypeConstraint$LAYOUT, KernelDefBuilder_AddTypeConstraint$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_AddInputOutputAliases)(OrtKernelDefBuilder *, const int *, const int *, size_t) + * } + */ + public final static class KernelDefBuilder_AddInputOutputAliases { + + private KernelDefBuilder_AddInputOutputAliases() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_LONG + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(KernelDefBuilder_AddInputOutputAliases.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(KernelDefBuilder_AddInputOutputAliases.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout KernelDefBuilder_AddInputOutputAliases$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("KernelDefBuilder_AddInputOutputAliases")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_AddInputOutputAliases)(OrtKernelDefBuilder *, const int *, const int *, size_t) + * } + */ + public static final AddressLayout KernelDefBuilder_AddInputOutputAliases$layout() { + return KernelDefBuilder_AddInputOutputAliases$LAYOUT; + } + + private static final long KernelDefBuilder_AddInputOutputAliases$OFFSET = $LAYOUT.byteOffset(groupElement("KernelDefBuilder_AddInputOutputAliases")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_AddInputOutputAliases)(OrtKernelDefBuilder *, const int *, const int *, size_t) + * } + */ + public static final long KernelDefBuilder_AddInputOutputAliases$offset() { + return KernelDefBuilder_AddInputOutputAliases$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_AddInputOutputAliases)(OrtKernelDefBuilder *, const int *, const int *, size_t) + * } + */ + public static MemorySegment KernelDefBuilder_AddInputOutputAliases(MemorySegment struct) { + return struct.get(KernelDefBuilder_AddInputOutputAliases$LAYOUT, KernelDefBuilder_AddInputOutputAliases$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_AddInputOutputAliases)(OrtKernelDefBuilder *, const int *, const int *, size_t) + * } + */ + public static void KernelDefBuilder_AddInputOutputAliases(MemorySegment struct, MemorySegment fieldValue) { + struct.set(KernelDefBuilder_AddInputOutputAliases$LAYOUT, KernelDefBuilder_AddInputOutputAliases$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_AddInputOutputMutableAliases)(OrtKernelDefBuilder *, const int *, const int *, size_t) + * } + */ + public final static class KernelDefBuilder_AddInputOutputMutableAliases { + + private KernelDefBuilder_AddInputOutputMutableAliases() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_LONG + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(KernelDefBuilder_AddInputOutputMutableAliases.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(KernelDefBuilder_AddInputOutputMutableAliases.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout KernelDefBuilder_AddInputOutputMutableAliases$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("KernelDefBuilder_AddInputOutputMutableAliases")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_AddInputOutputMutableAliases)(OrtKernelDefBuilder *, const int *, const int *, size_t) + * } + */ + public static final AddressLayout KernelDefBuilder_AddInputOutputMutableAliases$layout() { + return KernelDefBuilder_AddInputOutputMutableAliases$LAYOUT; + } + + private static final long KernelDefBuilder_AddInputOutputMutableAliases$OFFSET = $LAYOUT.byteOffset(groupElement("KernelDefBuilder_AddInputOutputMutableAliases")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_AddInputOutputMutableAliases)(OrtKernelDefBuilder *, const int *, const int *, size_t) + * } + */ + public static final long KernelDefBuilder_AddInputOutputMutableAliases$offset() { + return KernelDefBuilder_AddInputOutputMutableAliases$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_AddInputOutputMutableAliases)(OrtKernelDefBuilder *, const int *, const int *, size_t) + * } + */ + public static MemorySegment KernelDefBuilder_AddInputOutputMutableAliases(MemorySegment struct) { + return struct.get(KernelDefBuilder_AddInputOutputMutableAliases$LAYOUT, KernelDefBuilder_AddInputOutputMutableAliases$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_AddInputOutputMutableAliases)(OrtKernelDefBuilder *, const int *, const int *, size_t) + * } + */ + public static void KernelDefBuilder_AddInputOutputMutableAliases(MemorySegment struct, MemorySegment fieldValue) { + struct.set(KernelDefBuilder_AddInputOutputMutableAliases$LAYOUT, KernelDefBuilder_AddInputOutputMutableAliases$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_Build)(OrtKernelDefBuilder *, OrtKernelDef **) + * } + */ + public final static class KernelDefBuilder_Build { + + private KernelDefBuilder_Build() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(KernelDefBuilder_Build.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(KernelDefBuilder_Build.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout KernelDefBuilder_Build$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("KernelDefBuilder_Build")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_Build)(OrtKernelDefBuilder *, OrtKernelDef **) + * } + */ + public static final AddressLayout KernelDefBuilder_Build$layout() { + return KernelDefBuilder_Build$LAYOUT; + } + + private static final long KernelDefBuilder_Build$OFFSET = $LAYOUT.byteOffset(groupElement("KernelDefBuilder_Build")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_Build)(OrtKernelDefBuilder *, OrtKernelDef **) + * } + */ + public static final long KernelDefBuilder_Build$offset() { + return KernelDefBuilder_Build$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_Build)(OrtKernelDefBuilder *, OrtKernelDef **) + * } + */ + public static MemorySegment KernelDefBuilder_Build(MemorySegment struct) { + return struct.get(KernelDefBuilder_Build$LAYOUT, KernelDefBuilder_Build$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDefBuilder_Build)(OrtKernelDefBuilder *, OrtKernelDef **) + * } + */ + public static void KernelDefBuilder_Build(MemorySegment struct, MemorySegment fieldValue) { + struct.set(KernelDefBuilder_Build$LAYOUT, KernelDefBuilder_Build$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * void (*ReleaseKernelDef)(OrtKernelDef *) + * } + */ + public final static class ReleaseKernelDef { + + private ReleaseKernelDef() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + void apply(MemorySegment _x0); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.ofVoid( + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(ReleaseKernelDef.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(ReleaseKernelDef.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static void invoke(MemorySegment funcPtr, MemorySegment _x0) { + try { + DOWN$MH.invokeExact(funcPtr, _x0); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout ReleaseKernelDef$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("ReleaseKernelDef")); + + /** + * Layout for field: + * {@snippet lang=c : + * void (*ReleaseKernelDef)(OrtKernelDef *) + * } + */ + public static final AddressLayout ReleaseKernelDef$layout() { + return ReleaseKernelDef$LAYOUT; + } + + private static final long ReleaseKernelDef$OFFSET = $LAYOUT.byteOffset(groupElement("ReleaseKernelDef")); + + /** + * Offset for field: + * {@snippet lang=c : + * void (*ReleaseKernelDef)(OrtKernelDef *) + * } + */ + public static final long ReleaseKernelDef$offset() { + return ReleaseKernelDef$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * void (*ReleaseKernelDef)(OrtKernelDef *) + * } + */ + public static MemorySegment ReleaseKernelDef(MemorySegment struct) { + return struct.get(ReleaseKernelDef$LAYOUT, ReleaseKernelDef$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * void (*ReleaseKernelDef)(OrtKernelDef *) + * } + */ + public static void ReleaseKernelDef(MemorySegment struct, MemorySegment fieldValue) { + struct.set(ReleaseKernelDef$LAYOUT, ReleaseKernelDef$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * const char *(*KernelDef_GetOperatorType)(const OrtKernelDef *) + * } + */ + public final static class KernelDef_GetOperatorType { + + private KernelDef_GetOperatorType() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(KernelDef_GetOperatorType.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(KernelDef_GetOperatorType.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout KernelDef_GetOperatorType$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("KernelDef_GetOperatorType")); + + /** + * Layout for field: + * {@snippet lang=c : + * const char *(*KernelDef_GetOperatorType)(const OrtKernelDef *) + * } + */ + public static final AddressLayout KernelDef_GetOperatorType$layout() { + return KernelDef_GetOperatorType$LAYOUT; + } + + private static final long KernelDef_GetOperatorType$OFFSET = $LAYOUT.byteOffset(groupElement("KernelDef_GetOperatorType")); + + /** + * Offset for field: + * {@snippet lang=c : + * const char *(*KernelDef_GetOperatorType)(const OrtKernelDef *) + * } + */ + public static final long KernelDef_GetOperatorType$offset() { + return KernelDef_GetOperatorType$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * const char *(*KernelDef_GetOperatorType)(const OrtKernelDef *) + * } + */ + public static MemorySegment KernelDef_GetOperatorType(MemorySegment struct) { + return struct.get(KernelDef_GetOperatorType$LAYOUT, KernelDef_GetOperatorType$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * const char *(*KernelDef_GetOperatorType)(const OrtKernelDef *) + * } + */ + public static void KernelDef_GetOperatorType(MemorySegment struct, MemorySegment fieldValue) { + struct.set(KernelDef_GetOperatorType$LAYOUT, KernelDef_GetOperatorType$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * const char *(*KernelDef_GetDomain)(const OrtKernelDef *) + * } + */ + public final static class KernelDef_GetDomain { + + private KernelDef_GetDomain() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(KernelDef_GetDomain.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(KernelDef_GetDomain.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout KernelDef_GetDomain$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("KernelDef_GetDomain")); + + /** + * Layout for field: + * {@snippet lang=c : + * const char *(*KernelDef_GetDomain)(const OrtKernelDef *) + * } + */ + public static final AddressLayout KernelDef_GetDomain$layout() { + return KernelDef_GetDomain$LAYOUT; + } + + private static final long KernelDef_GetDomain$OFFSET = $LAYOUT.byteOffset(groupElement("KernelDef_GetDomain")); + + /** + * Offset for field: + * {@snippet lang=c : + * const char *(*KernelDef_GetDomain)(const OrtKernelDef *) + * } + */ + public static final long KernelDef_GetDomain$offset() { + return KernelDef_GetDomain$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * const char *(*KernelDef_GetDomain)(const OrtKernelDef *) + * } + */ + public static MemorySegment KernelDef_GetDomain(MemorySegment struct) { + return struct.get(KernelDef_GetDomain$LAYOUT, KernelDef_GetDomain$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * const char *(*KernelDef_GetDomain)(const OrtKernelDef *) + * } + */ + public static void KernelDef_GetDomain(MemorySegment struct, MemorySegment fieldValue) { + struct.set(KernelDef_GetDomain$LAYOUT, KernelDef_GetDomain$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*KernelDef_GetSinceVersion)(const OrtKernelDef *, int *, int *) + * } + */ + public final static class KernelDef_GetSinceVersion { + + private KernelDef_GetSinceVersion() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(KernelDef_GetSinceVersion.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(KernelDef_GetSinceVersion.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1, MemorySegment _x2) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout KernelDef_GetSinceVersion$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("KernelDef_GetSinceVersion")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDef_GetSinceVersion)(const OrtKernelDef *, int *, int *) + * } + */ + public static final AddressLayout KernelDef_GetSinceVersion$layout() { + return KernelDef_GetSinceVersion$LAYOUT; + } + + private static final long KernelDef_GetSinceVersion$OFFSET = $LAYOUT.byteOffset(groupElement("KernelDef_GetSinceVersion")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDef_GetSinceVersion)(const OrtKernelDef *, int *, int *) + * } + */ + public static final long KernelDef_GetSinceVersion$offset() { + return KernelDef_GetSinceVersion$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDef_GetSinceVersion)(const OrtKernelDef *, int *, int *) + * } + */ + public static MemorySegment KernelDef_GetSinceVersion(MemorySegment struct) { + return struct.get(KernelDef_GetSinceVersion$LAYOUT, KernelDef_GetSinceVersion$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDef_GetSinceVersion)(const OrtKernelDef *, int *, int *) + * } + */ + public static void KernelDef_GetSinceVersion(MemorySegment struct, MemorySegment fieldValue) { + struct.set(KernelDef_GetSinceVersion$LAYOUT, KernelDef_GetSinceVersion$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * const char *(*KernelDef_GetExecutionProvider)(const OrtKernelDef *) + * } + */ + public final static class KernelDef_GetExecutionProvider { + + private KernelDef_GetExecutionProvider() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(KernelDef_GetExecutionProvider.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(KernelDef_GetExecutionProvider.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout KernelDef_GetExecutionProvider$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("KernelDef_GetExecutionProvider")); + + /** + * Layout for field: + * {@snippet lang=c : + * const char *(*KernelDef_GetExecutionProvider)(const OrtKernelDef *) + * } + */ + public static final AddressLayout KernelDef_GetExecutionProvider$layout() { + return KernelDef_GetExecutionProvider$LAYOUT; + } + + private static final long KernelDef_GetExecutionProvider$OFFSET = $LAYOUT.byteOffset(groupElement("KernelDef_GetExecutionProvider")); + + /** + * Offset for field: + * {@snippet lang=c : + * const char *(*KernelDef_GetExecutionProvider)(const OrtKernelDef *) + * } + */ + public static final long KernelDef_GetExecutionProvider$offset() { + return KernelDef_GetExecutionProvider$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * const char *(*KernelDef_GetExecutionProvider)(const OrtKernelDef *) + * } + */ + public static MemorySegment KernelDef_GetExecutionProvider(MemorySegment struct) { + return struct.get(KernelDef_GetExecutionProvider$LAYOUT, KernelDef_GetExecutionProvider$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * const char *(*KernelDef_GetExecutionProvider)(const OrtKernelDef *) + * } + */ + public static void KernelDef_GetExecutionProvider(MemorySegment struct, MemorySegment fieldValue) { + struct.set(KernelDef_GetExecutionProvider$LAYOUT, KernelDef_GetExecutionProvider$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*KernelDef_GetInputMemType)(const OrtKernelDef *, size_t, OrtMemType *) + * } + */ + public final static class KernelDef_GetInputMemType { + + private KernelDef_GetInputMemType() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, long _x1, MemorySegment _x2); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_LONG, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(KernelDef_GetInputMemType.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(KernelDef_GetInputMemType.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, long _x1, MemorySegment _x2) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout KernelDef_GetInputMemType$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("KernelDef_GetInputMemType")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDef_GetInputMemType)(const OrtKernelDef *, size_t, OrtMemType *) + * } + */ + public static final AddressLayout KernelDef_GetInputMemType$layout() { + return KernelDef_GetInputMemType$LAYOUT; + } + + private static final long KernelDef_GetInputMemType$OFFSET = $LAYOUT.byteOffset(groupElement("KernelDef_GetInputMemType")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDef_GetInputMemType)(const OrtKernelDef *, size_t, OrtMemType *) + * } + */ + public static final long KernelDef_GetInputMemType$offset() { + return KernelDef_GetInputMemType$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDef_GetInputMemType)(const OrtKernelDef *, size_t, OrtMemType *) + * } + */ + public static MemorySegment KernelDef_GetInputMemType(MemorySegment struct) { + return struct.get(KernelDef_GetInputMemType$LAYOUT, KernelDef_GetInputMemType$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDef_GetInputMemType)(const OrtKernelDef *, size_t, OrtMemType *) + * } + */ + public static void KernelDef_GetInputMemType(MemorySegment struct, MemorySegment fieldValue) { + struct.set(KernelDef_GetInputMemType$LAYOUT, KernelDef_GetInputMemType$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*KernelDef_GetOutputMemType)(const OrtKernelDef *, size_t, OrtMemType *) + * } + */ + public final static class KernelDef_GetOutputMemType { + + private KernelDef_GetOutputMemType() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, long _x1, MemorySegment _x2); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_LONG, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(KernelDef_GetOutputMemType.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(KernelDef_GetOutputMemType.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, long _x1, MemorySegment _x2) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout KernelDef_GetOutputMemType$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("KernelDef_GetOutputMemType")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDef_GetOutputMemType)(const OrtKernelDef *, size_t, OrtMemType *) + * } + */ + public static final AddressLayout KernelDef_GetOutputMemType$layout() { + return KernelDef_GetOutputMemType$LAYOUT; + } + + private static final long KernelDef_GetOutputMemType$OFFSET = $LAYOUT.byteOffset(groupElement("KernelDef_GetOutputMemType")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDef_GetOutputMemType)(const OrtKernelDef *, size_t, OrtMemType *) + * } + */ + public static final long KernelDef_GetOutputMemType$offset() { + return KernelDef_GetOutputMemType$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDef_GetOutputMemType)(const OrtKernelDef *, size_t, OrtMemType *) + * } + */ + public static MemorySegment KernelDef_GetOutputMemType(MemorySegment struct) { + return struct.get(KernelDef_GetOutputMemType$LAYOUT, KernelDef_GetOutputMemType$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelDef_GetOutputMemType)(const OrtKernelDef *, size_t, OrtMemType *) + * } + */ + public static void KernelDef_GetOutputMemType(MemorySegment struct, MemorySegment fieldValue) { + struct.set(KernelDef_GetOutputMemType$LAYOUT, KernelDef_GetOutputMemType$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*GetTensorDataType)(ONNXTensorElementDataType, const OrtDataType **) + * } + */ + public final static class GetTensorDataType { + + private GetTensorDataType() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(int _x0, MemorySegment _x1); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_INT, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(GetTensorDataType.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(GetTensorDataType.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, int _x0, MemorySegment _x1) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout GetTensorDataType$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("GetTensorDataType")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*GetTensorDataType)(ONNXTensorElementDataType, const OrtDataType **) + * } + */ + public static final AddressLayout GetTensorDataType$layout() { + return GetTensorDataType$LAYOUT; + } + + private static final long GetTensorDataType$OFFSET = $LAYOUT.byteOffset(groupElement("GetTensorDataType")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*GetTensorDataType)(ONNXTensorElementDataType, const OrtDataType **) + * } + */ + public static final long GetTensorDataType$offset() { + return GetTensorDataType$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*GetTensorDataType)(ONNXTensorElementDataType, const OrtDataType **) + * } + */ + public static MemorySegment GetTensorDataType(MemorySegment struct) { + return struct.get(GetTensorDataType$LAYOUT, GetTensorDataType$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*GetTensorDataType)(ONNXTensorElementDataType, const OrtDataType **) + * } + */ + public static void GetTensorDataType(MemorySegment struct, MemorySegment fieldValue) { + struct.set(GetTensorDataType$LAYOUT, GetTensorDataType$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*EpGraphSupportInfo_LookUpKernel)(OrtEpGraphSupportInfo *, const OrtNode *, const OrtKernelDef **) + * } + */ + public final static class EpGraphSupportInfo_LookUpKernel { + + private EpGraphSupportInfo_LookUpKernel() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(EpGraphSupportInfo_LookUpKernel.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(EpGraphSupportInfo_LookUpKernel.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1, MemorySegment _x2) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout EpGraphSupportInfo_LookUpKernel$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("EpGraphSupportInfo_LookUpKernel")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*EpGraphSupportInfo_LookUpKernel)(OrtEpGraphSupportInfo *, const OrtNode *, const OrtKernelDef **) + * } + */ + public static final AddressLayout EpGraphSupportInfo_LookUpKernel$layout() { + return EpGraphSupportInfo_LookUpKernel$LAYOUT; + } + + private static final long EpGraphSupportInfo_LookUpKernel$OFFSET = $LAYOUT.byteOffset(groupElement("EpGraphSupportInfo_LookUpKernel")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*EpGraphSupportInfo_LookUpKernel)(OrtEpGraphSupportInfo *, const OrtNode *, const OrtKernelDef **) + * } + */ + public static final long EpGraphSupportInfo_LookUpKernel$offset() { + return EpGraphSupportInfo_LookUpKernel$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*EpGraphSupportInfo_LookUpKernel)(OrtEpGraphSupportInfo *, const OrtNode *, const OrtKernelDef **) + * } + */ + public static MemorySegment EpGraphSupportInfo_LookUpKernel(MemorySegment struct) { + return struct.get(EpGraphSupportInfo_LookUpKernel$LAYOUT, EpGraphSupportInfo_LookUpKernel$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*EpGraphSupportInfo_LookUpKernel)(OrtEpGraphSupportInfo *, const OrtNode *, const OrtKernelDef **) + * } + */ + public static void EpGraphSupportInfo_LookUpKernel(MemorySegment struct, MemorySegment fieldValue) { + struct.set(EpGraphSupportInfo_LookUpKernel$LAYOUT, EpGraphSupportInfo_LookUpKernel$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*SharedPrePackedWeightCache_StoreWeightData)(OrtSharedPrePackedWeightCache *, void **, size_t *, size_t) + * } + */ + public final static class SharedPrePackedWeightCache_StoreWeightData { + + private SharedPrePackedWeightCache_StoreWeightData() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_LONG + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(SharedPrePackedWeightCache_StoreWeightData.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(SharedPrePackedWeightCache_StoreWeightData.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1, MemorySegment _x2, long _x3) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout SharedPrePackedWeightCache_StoreWeightData$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("SharedPrePackedWeightCache_StoreWeightData")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*SharedPrePackedWeightCache_StoreWeightData)(OrtSharedPrePackedWeightCache *, void **, size_t *, size_t) + * } + */ + public static final AddressLayout SharedPrePackedWeightCache_StoreWeightData$layout() { + return SharedPrePackedWeightCache_StoreWeightData$LAYOUT; + } + + private static final long SharedPrePackedWeightCache_StoreWeightData$OFFSET = $LAYOUT.byteOffset(groupElement("SharedPrePackedWeightCache_StoreWeightData")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*SharedPrePackedWeightCache_StoreWeightData)(OrtSharedPrePackedWeightCache *, void **, size_t *, size_t) + * } + */ + public static final long SharedPrePackedWeightCache_StoreWeightData$offset() { + return SharedPrePackedWeightCache_StoreWeightData$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*SharedPrePackedWeightCache_StoreWeightData)(OrtSharedPrePackedWeightCache *, void **, size_t *, size_t) + * } + */ + public static MemorySegment SharedPrePackedWeightCache_StoreWeightData(MemorySegment struct) { + return struct.get(SharedPrePackedWeightCache_StoreWeightData$LAYOUT, SharedPrePackedWeightCache_StoreWeightData$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*SharedPrePackedWeightCache_StoreWeightData)(OrtSharedPrePackedWeightCache *, void **, size_t *, size_t) + * } + */ + public static void SharedPrePackedWeightCache_StoreWeightData(MemorySegment struct, MemorySegment fieldValue) { + struct.set(SharedPrePackedWeightCache_StoreWeightData$LAYOUT, SharedPrePackedWeightCache_StoreWeightData$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*KernelInfo_GetEp)(const OrtKernelInfo *, const OrtEp **) + * } + */ + public final static class KernelInfo_GetEp { + + private KernelInfo_GetEp() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(KernelInfo_GetEp.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(KernelInfo_GetEp.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout KernelInfo_GetEp$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("KernelInfo_GetEp")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelInfo_GetEp)(const OrtKernelInfo *, const OrtEp **) + * } + */ + public static final AddressLayout KernelInfo_GetEp$layout() { + return KernelInfo_GetEp$LAYOUT; + } + + private static final long KernelInfo_GetEp$OFFSET = $LAYOUT.byteOffset(groupElement("KernelInfo_GetEp")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelInfo_GetEp)(const OrtKernelInfo *, const OrtEp **) + * } + */ + public static final long KernelInfo_GetEp$offset() { + return KernelInfo_GetEp$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelInfo_GetEp)(const OrtKernelInfo *, const OrtEp **) + * } + */ + public static MemorySegment KernelInfo_GetEp(MemorySegment struct) { + return struct.get(KernelInfo_GetEp$LAYOUT, KernelInfo_GetEp$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*KernelInfo_GetEp)(const OrtKernelInfo *, const OrtEp **) + * } + */ + public static void KernelInfo_GetEp(MemorySegment struct, MemorySegment fieldValue) { + struct.set(KernelInfo_GetEp$LAYOUT, KernelInfo_GetEp$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*DeviceEpIncompatibilityDetails_SetDetails)(OrtDeviceEpIncompatibilityDetails *, uint32_t, int32_t, const char *) + * } + */ + public final static class DeviceEpIncompatibilityDetails_SetDetails { + + private DeviceEpIncompatibilityDetails_SetDetails() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, int _x1, int _x2, MemorySegment _x3); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_INT, + onnxruntime_c_api_h.C_INT, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(DeviceEpIncompatibilityDetails_SetDetails.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(DeviceEpIncompatibilityDetails_SetDetails.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, int _x1, int _x2, MemorySegment _x3) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout DeviceEpIncompatibilityDetails_SetDetails$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("DeviceEpIncompatibilityDetails_SetDetails")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*DeviceEpIncompatibilityDetails_SetDetails)(OrtDeviceEpIncompatibilityDetails *, uint32_t, int32_t, const char *) + * } + */ + public static final AddressLayout DeviceEpIncompatibilityDetails_SetDetails$layout() { + return DeviceEpIncompatibilityDetails_SetDetails$LAYOUT; + } + + private static final long DeviceEpIncompatibilityDetails_SetDetails$OFFSET = $LAYOUT.byteOffset(groupElement("DeviceEpIncompatibilityDetails_SetDetails")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*DeviceEpIncompatibilityDetails_SetDetails)(OrtDeviceEpIncompatibilityDetails *, uint32_t, int32_t, const char *) + * } + */ + public static final long DeviceEpIncompatibilityDetails_SetDetails$offset() { + return DeviceEpIncompatibilityDetails_SetDetails$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*DeviceEpIncompatibilityDetails_SetDetails)(OrtDeviceEpIncompatibilityDetails *, uint32_t, int32_t, const char *) + * } + */ + public static MemorySegment DeviceEpIncompatibilityDetails_SetDetails(MemorySegment struct) { + return struct.get(DeviceEpIncompatibilityDetails_SetDetails$LAYOUT, DeviceEpIncompatibilityDetails_SetDetails$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*DeviceEpIncompatibilityDetails_SetDetails)(OrtDeviceEpIncompatibilityDetails *, uint32_t, int32_t, const char *) + * } + */ + public static void DeviceEpIncompatibilityDetails_SetDetails(MemorySegment struct, MemorySegment fieldValue) { + struct.set(DeviceEpIncompatibilityDetails_SetDetails$LAYOUT, DeviceEpIncompatibilityDetails_SetDetails$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*CreateIfKernel)(const OrtKernelInfo *, OrtKernelImpl **) + * } + */ + public final static class CreateIfKernel { + + private CreateIfKernel() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(CreateIfKernel.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(CreateIfKernel.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout CreateIfKernel$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("CreateIfKernel")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateIfKernel)(const OrtKernelInfo *, OrtKernelImpl **) + * } + */ + public static final AddressLayout CreateIfKernel$layout() { + return CreateIfKernel$LAYOUT; + } + + private static final long CreateIfKernel$OFFSET = $LAYOUT.byteOffset(groupElement("CreateIfKernel")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateIfKernel)(const OrtKernelInfo *, OrtKernelImpl **) + * } + */ + public static final long CreateIfKernel$offset() { + return CreateIfKernel$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateIfKernel)(const OrtKernelInfo *, OrtKernelImpl **) + * } + */ + public static MemorySegment CreateIfKernel(MemorySegment struct) { + return struct.get(CreateIfKernel$LAYOUT, CreateIfKernel$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateIfKernel)(const OrtKernelInfo *, OrtKernelImpl **) + * } + */ + public static void CreateIfKernel(MemorySegment struct, MemorySegment fieldValue) { + struct.set(CreateIfKernel$LAYOUT, CreateIfKernel$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*CreateLoopKernel)(const OrtKernelInfo *, OrtLoopKernelHelper *, OrtKernelImpl **) + * } + */ + public final static class CreateLoopKernel { + + private CreateLoopKernel() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(CreateLoopKernel.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(CreateLoopKernel.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1, MemorySegment _x2) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout CreateLoopKernel$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("CreateLoopKernel")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateLoopKernel)(const OrtKernelInfo *, OrtLoopKernelHelper *, OrtKernelImpl **) + * } + */ + public static final AddressLayout CreateLoopKernel$layout() { + return CreateLoopKernel$LAYOUT; + } + + private static final long CreateLoopKernel$OFFSET = $LAYOUT.byteOffset(groupElement("CreateLoopKernel")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateLoopKernel)(const OrtKernelInfo *, OrtLoopKernelHelper *, OrtKernelImpl **) + * } + */ + public static final long CreateLoopKernel$offset() { + return CreateLoopKernel$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateLoopKernel)(const OrtKernelInfo *, OrtLoopKernelHelper *, OrtKernelImpl **) + * } + */ + public static MemorySegment CreateLoopKernel(MemorySegment struct) { + return struct.get(CreateLoopKernel$LAYOUT, CreateLoopKernel$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateLoopKernel)(const OrtKernelInfo *, OrtLoopKernelHelper *, OrtKernelImpl **) + * } + */ + public static void CreateLoopKernel(MemorySegment struct, MemorySegment fieldValue) { + struct.set(CreateLoopKernel$LAYOUT, CreateLoopKernel$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*CreateScanKernel)(const OrtKernelInfo *, OrtScanKernelHelper *, OrtKernelImpl **) + * } + */ + public final static class CreateScanKernel { + + private CreateScanKernel() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(CreateScanKernel.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(CreateScanKernel.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1, MemorySegment _x2) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout CreateScanKernel$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("CreateScanKernel")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateScanKernel)(const OrtKernelInfo *, OrtScanKernelHelper *, OrtKernelImpl **) + * } + */ + public static final AddressLayout CreateScanKernel$layout() { + return CreateScanKernel$LAYOUT; + } + + private static final long CreateScanKernel$OFFSET = $LAYOUT.byteOffset(groupElement("CreateScanKernel")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateScanKernel)(const OrtKernelInfo *, OrtScanKernelHelper *, OrtKernelImpl **) + * } + */ + public static final long CreateScanKernel$offset() { + return CreateScanKernel$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateScanKernel)(const OrtKernelInfo *, OrtScanKernelHelper *, OrtKernelImpl **) + * } + */ + public static MemorySegment CreateScanKernel(MemorySegment struct) { + return struct.get(CreateScanKernel$LAYOUT, CreateScanKernel$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateScanKernel)(const OrtKernelInfo *, OrtScanKernelHelper *, OrtKernelImpl **) + * } + */ + public static void CreateScanKernel(MemorySegment struct, MemorySegment fieldValue) { + struct.set(CreateScanKernel$LAYOUT, CreateScanKernel$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * void (*ReleaseKernelImpl)(OrtKernelImpl *) + * } + */ + public final static class ReleaseKernelImpl { + + private ReleaseKernelImpl() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + void apply(MemorySegment _x0); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.ofVoid( + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(ReleaseKernelImpl.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(ReleaseKernelImpl.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static void invoke(MemorySegment funcPtr, MemorySegment _x0) { + try { + DOWN$MH.invokeExact(funcPtr, _x0); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout ReleaseKernelImpl$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("ReleaseKernelImpl")); + + /** + * Layout for field: + * {@snippet lang=c : + * void (*ReleaseKernelImpl)(OrtKernelImpl *) + * } + */ + public static final AddressLayout ReleaseKernelImpl$layout() { + return ReleaseKernelImpl$LAYOUT; + } + + private static final long ReleaseKernelImpl$OFFSET = $LAYOUT.byteOffset(groupElement("ReleaseKernelImpl")); + + /** + * Offset for field: + * {@snippet lang=c : + * void (*ReleaseKernelImpl)(OrtKernelImpl *) + * } + */ + public static final long ReleaseKernelImpl$offset() { + return ReleaseKernelImpl$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * void (*ReleaseKernelImpl)(OrtKernelImpl *) + * } + */ + public static MemorySegment ReleaseKernelImpl(MemorySegment struct) { + return struct.get(ReleaseKernelImpl$LAYOUT, ReleaseKernelImpl$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * void (*ReleaseKernelImpl)(OrtKernelImpl *) + * } + */ + public static void ReleaseKernelImpl(MemorySegment struct, MemorySegment fieldValue) { + struct.set(ReleaseKernelImpl$LAYOUT, ReleaseKernelImpl$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*GetEnvConfigEntries)(OrtKeyValuePairs **) + * } + */ + public final static class GetEnvConfigEntries { + + private GetEnvConfigEntries() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(GetEnvConfigEntries.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(GetEnvConfigEntries.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout GetEnvConfigEntries$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("GetEnvConfigEntries")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*GetEnvConfigEntries)(OrtKeyValuePairs **) + * } + */ + public static final AddressLayout GetEnvConfigEntries$layout() { + return GetEnvConfigEntries$LAYOUT; + } + + private static final long GetEnvConfigEntries$OFFSET = $LAYOUT.byteOffset(groupElement("GetEnvConfigEntries")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*GetEnvConfigEntries)(OrtKeyValuePairs **) + * } + */ + public static final long GetEnvConfigEntries$offset() { + return GetEnvConfigEntries$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*GetEnvConfigEntries)(OrtKeyValuePairs **) + * } + */ + public static MemorySegment GetEnvConfigEntries(MemorySegment struct) { + return struct.get(GetEnvConfigEntries$LAYOUT, GetEnvConfigEntries$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*GetEnvConfigEntries)(OrtKeyValuePairs **) + * } + */ + public static void GetEnvConfigEntries(MemorySegment struct, MemorySegment fieldValue) { + struct.set(GetEnvConfigEntries$LAYOUT, GetEnvConfigEntries$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*GetOpSchema)(const char *, int, const char *, OrtOpSchema **) + * } + */ + public final static class GetOpSchema { + + private GetOpSchema() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, int _x1, MemorySegment _x2, MemorySegment _x3); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_INT, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(GetOpSchema.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(GetOpSchema.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, int _x1, MemorySegment _x2, MemorySegment _x3) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout GetOpSchema$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("GetOpSchema")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*GetOpSchema)(const char *, int, const char *, OrtOpSchema **) + * } + */ + public static final AddressLayout GetOpSchema$layout() { + return GetOpSchema$LAYOUT; + } + + private static final long GetOpSchema$OFFSET = $LAYOUT.byteOffset(groupElement("GetOpSchema")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*GetOpSchema)(const char *, int, const char *, OrtOpSchema **) + * } + */ + public static final long GetOpSchema$offset() { + return GetOpSchema$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*GetOpSchema)(const char *, int, const char *, OrtOpSchema **) + * } + */ + public static MemorySegment GetOpSchema(MemorySegment struct) { + return struct.get(GetOpSchema$LAYOUT, GetOpSchema$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*GetOpSchema)(const char *, int, const char *, OrtOpSchema **) + * } + */ + public static void GetOpSchema(MemorySegment struct, MemorySegment fieldValue) { + struct.set(GetOpSchema$LAYOUT, GetOpSchema$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * void (*ReleaseOpSchema)(OrtOpSchema *) + * } + */ + public final static class ReleaseOpSchema { + + private ReleaseOpSchema() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + void apply(MemorySegment _x0); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.ofVoid( + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(ReleaseOpSchema.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(ReleaseOpSchema.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static void invoke(MemorySegment funcPtr, MemorySegment _x0) { + try { + DOWN$MH.invokeExact(funcPtr, _x0); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout ReleaseOpSchema$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("ReleaseOpSchema")); + + /** + * Layout for field: + * {@snippet lang=c : + * void (*ReleaseOpSchema)(OrtOpSchema *) + * } + */ + public static final AddressLayout ReleaseOpSchema$layout() { + return ReleaseOpSchema$LAYOUT; + } + + private static final long ReleaseOpSchema$OFFSET = $LAYOUT.byteOffset(groupElement("ReleaseOpSchema")); + + /** + * Offset for field: + * {@snippet lang=c : + * void (*ReleaseOpSchema)(OrtOpSchema *) + * } + */ + public static final long ReleaseOpSchema$offset() { + return ReleaseOpSchema$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * void (*ReleaseOpSchema)(OrtOpSchema *) + * } + */ + public static MemorySegment ReleaseOpSchema(MemorySegment struct) { + return struct.get(ReleaseOpSchema$LAYOUT, ReleaseOpSchema$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * void (*ReleaseOpSchema)(OrtOpSchema *) + * } + */ + public static void ReleaseOpSchema(MemorySegment struct, MemorySegment fieldValue) { + struct.set(ReleaseOpSchema$LAYOUT, ReleaseOpSchema$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetSinceVersion)(const OrtOpSchema *, int *) + * } + */ + public final static class OpSchema_GetSinceVersion { + + private OpSchema_GetSinceVersion() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(OpSchema_GetSinceVersion.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(OpSchema_GetSinceVersion.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout OpSchema_GetSinceVersion$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("OpSchema_GetSinceVersion")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetSinceVersion)(const OrtOpSchema *, int *) + * } + */ + public static final AddressLayout OpSchema_GetSinceVersion$layout() { + return OpSchema_GetSinceVersion$LAYOUT; + } + + private static final long OpSchema_GetSinceVersion$OFFSET = $LAYOUT.byteOffset(groupElement("OpSchema_GetSinceVersion")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetSinceVersion)(const OrtOpSchema *, int *) + * } + */ + public static final long OpSchema_GetSinceVersion$offset() { + return OpSchema_GetSinceVersion$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetSinceVersion)(const OrtOpSchema *, int *) + * } + */ + public static MemorySegment OpSchema_GetSinceVersion(MemorySegment struct) { + return struct.get(OpSchema_GetSinceVersion$LAYOUT, OpSchema_GetSinceVersion$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetSinceVersion)(const OrtOpSchema *, int *) + * } + */ + public static void OpSchema_GetSinceVersion(MemorySegment struct, MemorySegment fieldValue) { + struct.set(OpSchema_GetSinceVersion$LAYOUT, OpSchema_GetSinceVersion$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetNumInputs)(const OrtOpSchema *, size_t *) + * } + */ + public final static class OpSchema_GetNumInputs { + + private OpSchema_GetNumInputs() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(OpSchema_GetNumInputs.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(OpSchema_GetNumInputs.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout OpSchema_GetNumInputs$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("OpSchema_GetNumInputs")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetNumInputs)(const OrtOpSchema *, size_t *) + * } + */ + public static final AddressLayout OpSchema_GetNumInputs$layout() { + return OpSchema_GetNumInputs$LAYOUT; + } + + private static final long OpSchema_GetNumInputs$OFFSET = $LAYOUT.byteOffset(groupElement("OpSchema_GetNumInputs")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetNumInputs)(const OrtOpSchema *, size_t *) + * } + */ + public static final long OpSchema_GetNumInputs$offset() { + return OpSchema_GetNumInputs$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetNumInputs)(const OrtOpSchema *, size_t *) + * } + */ + public static MemorySegment OpSchema_GetNumInputs(MemorySegment struct) { + return struct.get(OpSchema_GetNumInputs$LAYOUT, OpSchema_GetNumInputs$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetNumInputs)(const OrtOpSchema *, size_t *) + * } + */ + public static void OpSchema_GetNumInputs(MemorySegment struct, MemorySegment fieldValue) { + struct.set(OpSchema_GetNumInputs$LAYOUT, OpSchema_GetNumInputs$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetInputName)(const OrtOpSchema *, size_t, const char **) + * } + */ + public final static class OpSchema_GetInputName { + + private OpSchema_GetInputName() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, long _x1, MemorySegment _x2); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_LONG, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(OpSchema_GetInputName.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(OpSchema_GetInputName.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, long _x1, MemorySegment _x2) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout OpSchema_GetInputName$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("OpSchema_GetInputName")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetInputName)(const OrtOpSchema *, size_t, const char **) + * } + */ + public static final AddressLayout OpSchema_GetInputName$layout() { + return OpSchema_GetInputName$LAYOUT; + } + + private static final long OpSchema_GetInputName$OFFSET = $LAYOUT.byteOffset(groupElement("OpSchema_GetInputName")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetInputName)(const OrtOpSchema *, size_t, const char **) + * } + */ + public static final long OpSchema_GetInputName$offset() { + return OpSchema_GetInputName$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetInputName)(const OrtOpSchema *, size_t, const char **) + * } + */ + public static MemorySegment OpSchema_GetInputName(MemorySegment struct) { + return struct.get(OpSchema_GetInputName$LAYOUT, OpSchema_GetInputName$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetInputName)(const OrtOpSchema *, size_t, const char **) + * } + */ + public static void OpSchema_GetInputName(MemorySegment struct, MemorySegment fieldValue) { + struct.set(OpSchema_GetInputName$LAYOUT, OpSchema_GetInputName$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetInputTypeConstraint)(const OrtOpSchema *, size_t, const OrtOpSchemaTypeConstraint **) + * } + */ + public final static class OpSchema_GetInputTypeConstraint { + + private OpSchema_GetInputTypeConstraint() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, long _x1, MemorySegment _x2); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_LONG, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(OpSchema_GetInputTypeConstraint.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(OpSchema_GetInputTypeConstraint.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, long _x1, MemorySegment _x2) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout OpSchema_GetInputTypeConstraint$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("OpSchema_GetInputTypeConstraint")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetInputTypeConstraint)(const OrtOpSchema *, size_t, const OrtOpSchemaTypeConstraint **) + * } + */ + public static final AddressLayout OpSchema_GetInputTypeConstraint$layout() { + return OpSchema_GetInputTypeConstraint$LAYOUT; + } + + private static final long OpSchema_GetInputTypeConstraint$OFFSET = $LAYOUT.byteOffset(groupElement("OpSchema_GetInputTypeConstraint")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetInputTypeConstraint)(const OrtOpSchema *, size_t, const OrtOpSchemaTypeConstraint **) + * } + */ + public static final long OpSchema_GetInputTypeConstraint$offset() { + return OpSchema_GetInputTypeConstraint$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetInputTypeConstraint)(const OrtOpSchema *, size_t, const OrtOpSchemaTypeConstraint **) + * } + */ + public static MemorySegment OpSchema_GetInputTypeConstraint(MemorySegment struct) { + return struct.get(OpSchema_GetInputTypeConstraint$LAYOUT, OpSchema_GetInputTypeConstraint$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetInputTypeConstraint)(const OrtOpSchema *, size_t, const OrtOpSchemaTypeConstraint **) + * } + */ + public static void OpSchema_GetInputTypeConstraint(MemorySegment struct, MemorySegment fieldValue) { + struct.set(OpSchema_GetInputTypeConstraint$LAYOUT, OpSchema_GetInputTypeConstraint$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetNumOutputs)(const OrtOpSchema *, size_t *) + * } + */ + public final static class OpSchema_GetNumOutputs { + + private OpSchema_GetNumOutputs() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(OpSchema_GetNumOutputs.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(OpSchema_GetNumOutputs.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout OpSchema_GetNumOutputs$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("OpSchema_GetNumOutputs")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetNumOutputs)(const OrtOpSchema *, size_t *) + * } + */ + public static final AddressLayout OpSchema_GetNumOutputs$layout() { + return OpSchema_GetNumOutputs$LAYOUT; + } + + private static final long OpSchema_GetNumOutputs$OFFSET = $LAYOUT.byteOffset(groupElement("OpSchema_GetNumOutputs")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetNumOutputs)(const OrtOpSchema *, size_t *) + * } + */ + public static final long OpSchema_GetNumOutputs$offset() { + return OpSchema_GetNumOutputs$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetNumOutputs)(const OrtOpSchema *, size_t *) + * } + */ + public static MemorySegment OpSchema_GetNumOutputs(MemorySegment struct) { + return struct.get(OpSchema_GetNumOutputs$LAYOUT, OpSchema_GetNumOutputs$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetNumOutputs)(const OrtOpSchema *, size_t *) + * } + */ + public static void OpSchema_GetNumOutputs(MemorySegment struct, MemorySegment fieldValue) { + struct.set(OpSchema_GetNumOutputs$LAYOUT, OpSchema_GetNumOutputs$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetOutputName)(const OrtOpSchema *, size_t, const char **) + * } + */ + public final static class OpSchema_GetOutputName { + + private OpSchema_GetOutputName() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, long _x1, MemorySegment _x2); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_LONG, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(OpSchema_GetOutputName.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(OpSchema_GetOutputName.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, long _x1, MemorySegment _x2) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout OpSchema_GetOutputName$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("OpSchema_GetOutputName")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetOutputName)(const OrtOpSchema *, size_t, const char **) + * } + */ + public static final AddressLayout OpSchema_GetOutputName$layout() { + return OpSchema_GetOutputName$LAYOUT; + } + + private static final long OpSchema_GetOutputName$OFFSET = $LAYOUT.byteOffset(groupElement("OpSchema_GetOutputName")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetOutputName)(const OrtOpSchema *, size_t, const char **) + * } + */ + public static final long OpSchema_GetOutputName$offset() { + return OpSchema_GetOutputName$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetOutputName)(const OrtOpSchema *, size_t, const char **) + * } + */ + public static MemorySegment OpSchema_GetOutputName(MemorySegment struct) { + return struct.get(OpSchema_GetOutputName$LAYOUT, OpSchema_GetOutputName$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetOutputName)(const OrtOpSchema *, size_t, const char **) + * } + */ + public static void OpSchema_GetOutputName(MemorySegment struct, MemorySegment fieldValue) { + struct.set(OpSchema_GetOutputName$LAYOUT, OpSchema_GetOutputName$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetOutputTypeConstraint)(const OrtOpSchema *, size_t, const OrtOpSchemaTypeConstraint **) + * } + */ + public final static class OpSchema_GetOutputTypeConstraint { + + private OpSchema_GetOutputTypeConstraint() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, long _x1, MemorySegment _x2); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_LONG, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(OpSchema_GetOutputTypeConstraint.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(OpSchema_GetOutputTypeConstraint.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, long _x1, MemorySegment _x2) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout OpSchema_GetOutputTypeConstraint$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("OpSchema_GetOutputTypeConstraint")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetOutputTypeConstraint)(const OrtOpSchema *, size_t, const OrtOpSchemaTypeConstraint **) + * } + */ + public static final AddressLayout OpSchema_GetOutputTypeConstraint$layout() { + return OpSchema_GetOutputTypeConstraint$LAYOUT; + } + + private static final long OpSchema_GetOutputTypeConstraint$OFFSET = $LAYOUT.byteOffset(groupElement("OpSchema_GetOutputTypeConstraint")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetOutputTypeConstraint)(const OrtOpSchema *, size_t, const OrtOpSchemaTypeConstraint **) + * } + */ + public static final long OpSchema_GetOutputTypeConstraint$offset() { + return OpSchema_GetOutputTypeConstraint$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetOutputTypeConstraint)(const OrtOpSchema *, size_t, const OrtOpSchemaTypeConstraint **) + * } + */ + public static MemorySegment OpSchema_GetOutputTypeConstraint(MemorySegment struct) { + return struct.get(OpSchema_GetOutputTypeConstraint$LAYOUT, OpSchema_GetOutputTypeConstraint$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetOutputTypeConstraint)(const OrtOpSchema *, size_t, const OrtOpSchemaTypeConstraint **) + * } + */ + public static void OpSchema_GetOutputTypeConstraint(MemorySegment struct, MemorySegment fieldValue) { + struct.set(OpSchema_GetOutputTypeConstraint$LAYOUT, OpSchema_GetOutputTypeConstraint$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetTypeConstraintCount)(const OrtOpSchema *, size_t *) + * } + */ + public final static class OpSchema_GetTypeConstraintCount { + + private OpSchema_GetTypeConstraintCount() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(OpSchema_GetTypeConstraintCount.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(OpSchema_GetTypeConstraintCount.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout OpSchema_GetTypeConstraintCount$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("OpSchema_GetTypeConstraintCount")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetTypeConstraintCount)(const OrtOpSchema *, size_t *) + * } + */ + public static final AddressLayout OpSchema_GetTypeConstraintCount$layout() { + return OpSchema_GetTypeConstraintCount$LAYOUT; + } + + private static final long OpSchema_GetTypeConstraintCount$OFFSET = $LAYOUT.byteOffset(groupElement("OpSchema_GetTypeConstraintCount")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetTypeConstraintCount)(const OrtOpSchema *, size_t *) + * } + */ + public static final long OpSchema_GetTypeConstraintCount$offset() { + return OpSchema_GetTypeConstraintCount$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetTypeConstraintCount)(const OrtOpSchema *, size_t *) + * } + */ + public static MemorySegment OpSchema_GetTypeConstraintCount(MemorySegment struct) { + return struct.get(OpSchema_GetTypeConstraintCount$LAYOUT, OpSchema_GetTypeConstraintCount$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetTypeConstraintCount)(const OrtOpSchema *, size_t *) + * } + */ + public static void OpSchema_GetTypeConstraintCount(MemorySegment struct, MemorySegment fieldValue) { + struct.set(OpSchema_GetTypeConstraintCount$LAYOUT, OpSchema_GetTypeConstraintCount$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetTypeConstraint)(const OrtOpSchema *, size_t, const OrtOpSchemaTypeConstraint **) + * } + */ + public final static class OpSchema_GetTypeConstraint { + + private OpSchema_GetTypeConstraint() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, long _x1, MemorySegment _x2); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_LONG, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(OpSchema_GetTypeConstraint.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(OpSchema_GetTypeConstraint.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, long _x1, MemorySegment _x2) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout OpSchema_GetTypeConstraint$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("OpSchema_GetTypeConstraint")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetTypeConstraint)(const OrtOpSchema *, size_t, const OrtOpSchemaTypeConstraint **) + * } + */ + public static final AddressLayout OpSchema_GetTypeConstraint$layout() { + return OpSchema_GetTypeConstraint$LAYOUT; + } + + private static final long OpSchema_GetTypeConstraint$OFFSET = $LAYOUT.byteOffset(groupElement("OpSchema_GetTypeConstraint")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetTypeConstraint)(const OrtOpSchema *, size_t, const OrtOpSchemaTypeConstraint **) + * } + */ + public static final long OpSchema_GetTypeConstraint$offset() { + return OpSchema_GetTypeConstraint$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetTypeConstraint)(const OrtOpSchema *, size_t, const OrtOpSchemaTypeConstraint **) + * } + */ + public static MemorySegment OpSchema_GetTypeConstraint(MemorySegment struct) { + return struct.get(OpSchema_GetTypeConstraint$LAYOUT, OpSchema_GetTypeConstraint$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchema_GetTypeConstraint)(const OrtOpSchema *, size_t, const OrtOpSchemaTypeConstraint **) + * } + */ + public static void OpSchema_GetTypeConstraint(MemorySegment struct, MemorySegment fieldValue) { + struct.set(OpSchema_GetTypeConstraint$LAYOUT, OpSchema_GetTypeConstraint$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*OpSchemaTypeConstraint_GetTypeParamName)(const OrtOpSchemaTypeConstraint *, const char **) + * } + */ + public final static class OpSchemaTypeConstraint_GetTypeParamName { + + private OpSchemaTypeConstraint_GetTypeParamName() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(OpSchemaTypeConstraint_GetTypeParamName.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(OpSchemaTypeConstraint_GetTypeParamName.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout OpSchemaTypeConstraint_GetTypeParamName$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("OpSchemaTypeConstraint_GetTypeParamName")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchemaTypeConstraint_GetTypeParamName)(const OrtOpSchemaTypeConstraint *, const char **) + * } + */ + public static final AddressLayout OpSchemaTypeConstraint_GetTypeParamName$layout() { + return OpSchemaTypeConstraint_GetTypeParamName$LAYOUT; + } + + private static final long OpSchemaTypeConstraint_GetTypeParamName$OFFSET = $LAYOUT.byteOffset(groupElement("OpSchemaTypeConstraint_GetTypeParamName")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchemaTypeConstraint_GetTypeParamName)(const OrtOpSchemaTypeConstraint *, const char **) + * } + */ + public static final long OpSchemaTypeConstraint_GetTypeParamName$offset() { + return OpSchemaTypeConstraint_GetTypeParamName$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchemaTypeConstraint_GetTypeParamName)(const OrtOpSchemaTypeConstraint *, const char **) + * } + */ + public static MemorySegment OpSchemaTypeConstraint_GetTypeParamName(MemorySegment struct) { + return struct.get(OpSchemaTypeConstraint_GetTypeParamName$LAYOUT, OpSchemaTypeConstraint_GetTypeParamName$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchemaTypeConstraint_GetTypeParamName)(const OrtOpSchemaTypeConstraint *, const char **) + * } + */ + public static void OpSchemaTypeConstraint_GetTypeParamName(MemorySegment struct, MemorySegment fieldValue) { + struct.set(OpSchemaTypeConstraint_GetTypeParamName$LAYOUT, OpSchemaTypeConstraint_GetTypeParamName$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*OpSchemaTypeConstraint_GetAllowedTypes)(const OrtOpSchemaTypeConstraint *, const char *const **, size_t *) + * } + */ + public final static class OpSchemaTypeConstraint_GetAllowedTypes { + + private OpSchemaTypeConstraint_GetAllowedTypes() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(OpSchemaTypeConstraint_GetAllowedTypes.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(OpSchemaTypeConstraint_GetAllowedTypes.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1, MemorySegment _x2) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout OpSchemaTypeConstraint_GetAllowedTypes$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("OpSchemaTypeConstraint_GetAllowedTypes")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchemaTypeConstraint_GetAllowedTypes)(const OrtOpSchemaTypeConstraint *, const char *const **, size_t *) + * } + */ + public static final AddressLayout OpSchemaTypeConstraint_GetAllowedTypes$layout() { + return OpSchemaTypeConstraint_GetAllowedTypes$LAYOUT; + } + + private static final long OpSchemaTypeConstraint_GetAllowedTypes$OFFSET = $LAYOUT.byteOffset(groupElement("OpSchemaTypeConstraint_GetAllowedTypes")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchemaTypeConstraint_GetAllowedTypes)(const OrtOpSchemaTypeConstraint *, const char *const **, size_t *) + * } + */ + public static final long OpSchemaTypeConstraint_GetAllowedTypes$offset() { + return OpSchemaTypeConstraint_GetAllowedTypes$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchemaTypeConstraint_GetAllowedTypes)(const OrtOpSchemaTypeConstraint *, const char *const **, size_t *) + * } + */ + public static MemorySegment OpSchemaTypeConstraint_GetAllowedTypes(MemorySegment struct) { + return struct.get(OpSchemaTypeConstraint_GetAllowedTypes$LAYOUT, OpSchemaTypeConstraint_GetAllowedTypes$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchemaTypeConstraint_GetAllowedTypes)(const OrtOpSchemaTypeConstraint *, const char *const **, size_t *) + * } + */ + public static void OpSchemaTypeConstraint_GetAllowedTypes(MemorySegment struct, MemorySegment fieldValue) { + struct.set(OpSchemaTypeConstraint_GetAllowedTypes$LAYOUT, OpSchemaTypeConstraint_GetAllowedTypes$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*OpSchemaTypeConstraint_GetInputIndices)(const OrtOpSchemaTypeConstraint *, const size_t **, size_t *) + * } + */ + public final static class OpSchemaTypeConstraint_GetInputIndices { + + private OpSchemaTypeConstraint_GetInputIndices() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(OpSchemaTypeConstraint_GetInputIndices.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(OpSchemaTypeConstraint_GetInputIndices.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1, MemorySegment _x2) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout OpSchemaTypeConstraint_GetInputIndices$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("OpSchemaTypeConstraint_GetInputIndices")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchemaTypeConstraint_GetInputIndices)(const OrtOpSchemaTypeConstraint *, const size_t **, size_t *) + * } + */ + public static final AddressLayout OpSchemaTypeConstraint_GetInputIndices$layout() { + return OpSchemaTypeConstraint_GetInputIndices$LAYOUT; + } + + private static final long OpSchemaTypeConstraint_GetInputIndices$OFFSET = $LAYOUT.byteOffset(groupElement("OpSchemaTypeConstraint_GetInputIndices")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchemaTypeConstraint_GetInputIndices)(const OrtOpSchemaTypeConstraint *, const size_t **, size_t *) + * } + */ + public static final long OpSchemaTypeConstraint_GetInputIndices$offset() { + return OpSchemaTypeConstraint_GetInputIndices$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchemaTypeConstraint_GetInputIndices)(const OrtOpSchemaTypeConstraint *, const size_t **, size_t *) + * } + */ + public static MemorySegment OpSchemaTypeConstraint_GetInputIndices(MemorySegment struct) { + return struct.get(OpSchemaTypeConstraint_GetInputIndices$LAYOUT, OpSchemaTypeConstraint_GetInputIndices$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchemaTypeConstraint_GetInputIndices)(const OrtOpSchemaTypeConstraint *, const size_t **, size_t *) + * } + */ + public static void OpSchemaTypeConstraint_GetInputIndices(MemorySegment struct, MemorySegment fieldValue) { + struct.set(OpSchemaTypeConstraint_GetInputIndices$LAYOUT, OpSchemaTypeConstraint_GetInputIndices$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*OpSchemaTypeConstraint_GetOutputIndices)(const OrtOpSchemaTypeConstraint *, const size_t **, size_t *) + * } + */ + public final static class OpSchemaTypeConstraint_GetOutputIndices { + + private OpSchemaTypeConstraint_GetOutputIndices() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(OpSchemaTypeConstraint_GetOutputIndices.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(OpSchemaTypeConstraint_GetOutputIndices.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1, MemorySegment _x2) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout OpSchemaTypeConstraint_GetOutputIndices$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("OpSchemaTypeConstraint_GetOutputIndices")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchemaTypeConstraint_GetOutputIndices)(const OrtOpSchemaTypeConstraint *, const size_t **, size_t *) + * } + */ + public static final AddressLayout OpSchemaTypeConstraint_GetOutputIndices$layout() { + return OpSchemaTypeConstraint_GetOutputIndices$LAYOUT; + } + + private static final long OpSchemaTypeConstraint_GetOutputIndices$OFFSET = $LAYOUT.byteOffset(groupElement("OpSchemaTypeConstraint_GetOutputIndices")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchemaTypeConstraint_GetOutputIndices)(const OrtOpSchemaTypeConstraint *, const size_t **, size_t *) + * } + */ + public static final long OpSchemaTypeConstraint_GetOutputIndices$offset() { + return OpSchemaTypeConstraint_GetOutputIndices$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchemaTypeConstraint_GetOutputIndices)(const OrtOpSchemaTypeConstraint *, const size_t **, size_t *) + * } + */ + public static MemorySegment OpSchemaTypeConstraint_GetOutputIndices(MemorySegment struct) { + return struct.get(OpSchemaTypeConstraint_GetOutputIndices$LAYOUT, OpSchemaTypeConstraint_GetOutputIndices$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*OpSchemaTypeConstraint_GetOutputIndices)(const OrtOpSchemaTypeConstraint *, const size_t **, size_t *) + * } + */ + public static void OpSchemaTypeConstraint_GetOutputIndices(MemorySegment struct, MemorySegment fieldValue) { + struct.set(OpSchemaTypeConstraint_GetOutputIndices$LAYOUT, OpSchemaTypeConstraint_GetOutputIndices$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*CreateProfilingEvent)(OrtProfilingEventCategory, int32_t, int32_t, const char *, int64_t, int64_t, const char *const *, const char *const *, size_t, OrtProfilingEvent **) + * } + */ + public final static class CreateProfilingEvent { + + private CreateProfilingEvent() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(int _x0, int _x1, int _x2, MemorySegment _x3, long _x4, long _x5, MemorySegment _x6, MemorySegment _x7, long _x8, MemorySegment _x9); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_INT, + onnxruntime_c_api_h.C_INT, + onnxruntime_c_api_h.C_INT, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_LONG_LONG, + onnxruntime_c_api_h.C_LONG_LONG, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_LONG, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(CreateProfilingEvent.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(CreateProfilingEvent.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, int _x0, int _x1, int _x2, MemorySegment _x3, long _x4, long _x5, MemorySegment _x6, MemorySegment _x7, long _x8, MemorySegment _x9) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2, _x3, _x4, _x5, _x6, _x7, _x8, _x9); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout CreateProfilingEvent$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("CreateProfilingEvent")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateProfilingEvent)(OrtProfilingEventCategory, int32_t, int32_t, const char *, int64_t, int64_t, const char *const *, const char *const *, size_t, OrtProfilingEvent **) + * } + */ + public static final AddressLayout CreateProfilingEvent$layout() { + return CreateProfilingEvent$LAYOUT; + } + + private static final long CreateProfilingEvent$OFFSET = $LAYOUT.byteOffset(groupElement("CreateProfilingEvent")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateProfilingEvent)(OrtProfilingEventCategory, int32_t, int32_t, const char *, int64_t, int64_t, const char *const *, const char *const *, size_t, OrtProfilingEvent **) + * } + */ + public static final long CreateProfilingEvent$offset() { + return CreateProfilingEvent$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateProfilingEvent)(OrtProfilingEventCategory, int32_t, int32_t, const char *, int64_t, int64_t, const char *const *, const char *const *, size_t, OrtProfilingEvent **) + * } + */ + public static MemorySegment CreateProfilingEvent(MemorySegment struct) { + return struct.get(CreateProfilingEvent$LAYOUT, CreateProfilingEvent$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*CreateProfilingEvent)(OrtProfilingEventCategory, int32_t, int32_t, const char *, int64_t, int64_t, const char *const *, const char *const *, size_t, OrtProfilingEvent **) + * } + */ + public static void CreateProfilingEvent(MemorySegment struct, MemorySegment fieldValue) { + struct.set(CreateProfilingEvent$LAYOUT, CreateProfilingEvent$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * void (*ReleaseProfilingEvent)(OrtProfilingEvent *) + * } + */ + public final static class ReleaseProfilingEvent { + + private ReleaseProfilingEvent() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + void apply(MemorySegment _x0); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.ofVoid( + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(ReleaseProfilingEvent.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(ReleaseProfilingEvent.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static void invoke(MemorySegment funcPtr, MemorySegment _x0) { + try { + DOWN$MH.invokeExact(funcPtr, _x0); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout ReleaseProfilingEvent$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("ReleaseProfilingEvent")); + + /** + * Layout for field: + * {@snippet lang=c : + * void (*ReleaseProfilingEvent)(OrtProfilingEvent *) + * } + */ + public static final AddressLayout ReleaseProfilingEvent$layout() { + return ReleaseProfilingEvent$LAYOUT; + } + + private static final long ReleaseProfilingEvent$OFFSET = $LAYOUT.byteOffset(groupElement("ReleaseProfilingEvent")); + + /** + * Offset for field: + * {@snippet lang=c : + * void (*ReleaseProfilingEvent)(OrtProfilingEvent *) + * } + */ + public static final long ReleaseProfilingEvent$offset() { + return ReleaseProfilingEvent$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * void (*ReleaseProfilingEvent)(OrtProfilingEvent *) + * } + */ + public static MemorySegment ReleaseProfilingEvent(MemorySegment struct) { + return struct.get(ReleaseProfilingEvent$LAYOUT, ReleaseProfilingEvent$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * void (*ReleaseProfilingEvent)(OrtProfilingEvent *) + * } + */ + public static void ReleaseProfilingEvent(MemorySegment struct, MemorySegment fieldValue) { + struct.set(ReleaseProfilingEvent$LAYOUT, ReleaseProfilingEvent$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetCategory)(const OrtProfilingEvent *, OrtProfilingEventCategory *) + * } + */ + public final static class ProfilingEvent_GetCategory { + + private ProfilingEvent_GetCategory() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(ProfilingEvent_GetCategory.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(ProfilingEvent_GetCategory.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout ProfilingEvent_GetCategory$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("ProfilingEvent_GetCategory")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetCategory)(const OrtProfilingEvent *, OrtProfilingEventCategory *) + * } + */ + public static final AddressLayout ProfilingEvent_GetCategory$layout() { + return ProfilingEvent_GetCategory$LAYOUT; + } + + private static final long ProfilingEvent_GetCategory$OFFSET = $LAYOUT.byteOffset(groupElement("ProfilingEvent_GetCategory")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetCategory)(const OrtProfilingEvent *, OrtProfilingEventCategory *) + * } + */ + public static final long ProfilingEvent_GetCategory$offset() { + return ProfilingEvent_GetCategory$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetCategory)(const OrtProfilingEvent *, OrtProfilingEventCategory *) + * } + */ + public static MemorySegment ProfilingEvent_GetCategory(MemorySegment struct) { + return struct.get(ProfilingEvent_GetCategory$LAYOUT, ProfilingEvent_GetCategory$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetCategory)(const OrtProfilingEvent *, OrtProfilingEventCategory *) + * } + */ + public static void ProfilingEvent_GetCategory(MemorySegment struct, MemorySegment fieldValue) { + struct.set(ProfilingEvent_GetCategory$LAYOUT, ProfilingEvent_GetCategory$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetName)(const OrtProfilingEvent *, const char **) + * } + */ + public final static class ProfilingEvent_GetName { + + private ProfilingEvent_GetName() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(ProfilingEvent_GetName.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(ProfilingEvent_GetName.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout ProfilingEvent_GetName$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("ProfilingEvent_GetName")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetName)(const OrtProfilingEvent *, const char **) + * } + */ + public static final AddressLayout ProfilingEvent_GetName$layout() { + return ProfilingEvent_GetName$LAYOUT; + } + + private static final long ProfilingEvent_GetName$OFFSET = $LAYOUT.byteOffset(groupElement("ProfilingEvent_GetName")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetName)(const OrtProfilingEvent *, const char **) + * } + */ + public static final long ProfilingEvent_GetName$offset() { + return ProfilingEvent_GetName$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetName)(const OrtProfilingEvent *, const char **) + * } + */ + public static MemorySegment ProfilingEvent_GetName(MemorySegment struct) { + return struct.get(ProfilingEvent_GetName$LAYOUT, ProfilingEvent_GetName$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetName)(const OrtProfilingEvent *, const char **) + * } + */ + public static void ProfilingEvent_GetName(MemorySegment struct, MemorySegment fieldValue) { + struct.set(ProfilingEvent_GetName$LAYOUT, ProfilingEvent_GetName$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetTimestampUs)(const OrtProfilingEvent *, int64_t *) + * } + */ + public final static class ProfilingEvent_GetTimestampUs { + + private ProfilingEvent_GetTimestampUs() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(ProfilingEvent_GetTimestampUs.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(ProfilingEvent_GetTimestampUs.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout ProfilingEvent_GetTimestampUs$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("ProfilingEvent_GetTimestampUs")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetTimestampUs)(const OrtProfilingEvent *, int64_t *) + * } + */ + public static final AddressLayout ProfilingEvent_GetTimestampUs$layout() { + return ProfilingEvent_GetTimestampUs$LAYOUT; + } + + private static final long ProfilingEvent_GetTimestampUs$OFFSET = $LAYOUT.byteOffset(groupElement("ProfilingEvent_GetTimestampUs")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetTimestampUs)(const OrtProfilingEvent *, int64_t *) + * } + */ + public static final long ProfilingEvent_GetTimestampUs$offset() { + return ProfilingEvent_GetTimestampUs$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetTimestampUs)(const OrtProfilingEvent *, int64_t *) + * } + */ + public static MemorySegment ProfilingEvent_GetTimestampUs(MemorySegment struct) { + return struct.get(ProfilingEvent_GetTimestampUs$LAYOUT, ProfilingEvent_GetTimestampUs$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetTimestampUs)(const OrtProfilingEvent *, int64_t *) + * } + */ + public static void ProfilingEvent_GetTimestampUs(MemorySegment struct, MemorySegment fieldValue) { + struct.set(ProfilingEvent_GetTimestampUs$LAYOUT, ProfilingEvent_GetTimestampUs$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetDurationUs)(const OrtProfilingEvent *, int64_t *) + * } + */ + public final static class ProfilingEvent_GetDurationUs { + + private ProfilingEvent_GetDurationUs() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(ProfilingEvent_GetDurationUs.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(ProfilingEvent_GetDurationUs.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout ProfilingEvent_GetDurationUs$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("ProfilingEvent_GetDurationUs")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetDurationUs)(const OrtProfilingEvent *, int64_t *) + * } + */ + public static final AddressLayout ProfilingEvent_GetDurationUs$layout() { + return ProfilingEvent_GetDurationUs$LAYOUT; + } + + private static final long ProfilingEvent_GetDurationUs$OFFSET = $LAYOUT.byteOffset(groupElement("ProfilingEvent_GetDurationUs")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetDurationUs)(const OrtProfilingEvent *, int64_t *) + * } + */ + public static final long ProfilingEvent_GetDurationUs$offset() { + return ProfilingEvent_GetDurationUs$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetDurationUs)(const OrtProfilingEvent *, int64_t *) + * } + */ + public static MemorySegment ProfilingEvent_GetDurationUs(MemorySegment struct) { + return struct.get(ProfilingEvent_GetDurationUs$LAYOUT, ProfilingEvent_GetDurationUs$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetDurationUs)(const OrtProfilingEvent *, int64_t *) + * } + */ + public static void ProfilingEvent_GetDurationUs(MemorySegment struct, MemorySegment fieldValue) { + struct.set(ProfilingEvent_GetDurationUs$LAYOUT, ProfilingEvent_GetDurationUs$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetArgValue)(const OrtProfilingEvent *, const char *, const char **) + * } + */ + public final static class ProfilingEvent_GetArgValue { + + private ProfilingEvent_GetArgValue() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1, MemorySegment _x2); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(ProfilingEvent_GetArgValue.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(ProfilingEvent_GetArgValue.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1, MemorySegment _x2) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout ProfilingEvent_GetArgValue$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("ProfilingEvent_GetArgValue")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetArgValue)(const OrtProfilingEvent *, const char *, const char **) + * } + */ + public static final AddressLayout ProfilingEvent_GetArgValue$layout() { + return ProfilingEvent_GetArgValue$LAYOUT; + } + + private static final long ProfilingEvent_GetArgValue$OFFSET = $LAYOUT.byteOffset(groupElement("ProfilingEvent_GetArgValue")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetArgValue)(const OrtProfilingEvent *, const char *, const char **) + * } + */ + public static final long ProfilingEvent_GetArgValue$offset() { + return ProfilingEvent_GetArgValue$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetArgValue)(const OrtProfilingEvent *, const char *, const char **) + * } + */ + public static MemorySegment ProfilingEvent_GetArgValue(MemorySegment struct) { + return struct.get(ProfilingEvent_GetArgValue$LAYOUT, ProfilingEvent_GetArgValue$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEvent_GetArgValue)(const OrtProfilingEvent *, const char *, const char **) + * } + */ + public static void ProfilingEvent_GetArgValue(MemorySegment struct, MemorySegment fieldValue) { + struct.set(ProfilingEvent_GetArgValue$LAYOUT, ProfilingEvent_GetArgValue$OFFSET, fieldValue); + } + + /** + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEventsContainer_AddEvents)(OrtProfilingEventsContainer *, const OrtProfilingEvent *const *, size_t) + * } + */ + public final static class ProfilingEventsContainer_AddEvents { + + private ProfilingEventsContainer_AddEvents() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + MemorySegment apply(MemorySegment _x0, MemorySegment _x1, long _x2); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.of( + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_POINTER, + onnxruntime_c_api_h.C_LONG + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = onnxruntime_c_api_h.upcallHandle(ProfilingEventsContainer_AddEvents.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(ProfilingEventsContainer_AddEvents.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static MemorySegment invoke(MemorySegment funcPtr, MemorySegment _x0, MemorySegment _x1, long _x2) { + try { + return (MemorySegment) DOWN$MH.invokeExact(funcPtr, _x0, _x1, _x2); + } catch (Error | RuntimeException ex) { + throw ex; + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static final AddressLayout ProfilingEventsContainer_AddEvents$LAYOUT = (AddressLayout)$LAYOUT.select(groupElement("ProfilingEventsContainer_AddEvents")); + + /** + * Layout for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEventsContainer_AddEvents)(OrtProfilingEventsContainer *, const OrtProfilingEvent *const *, size_t) + * } + */ + public static final AddressLayout ProfilingEventsContainer_AddEvents$layout() { + return ProfilingEventsContainer_AddEvents$LAYOUT; + } + + private static final long ProfilingEventsContainer_AddEvents$OFFSET = $LAYOUT.byteOffset(groupElement("ProfilingEventsContainer_AddEvents")); + + /** + * Offset for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEventsContainer_AddEvents)(OrtProfilingEventsContainer *, const OrtProfilingEvent *const *, size_t) + * } + */ + public static final long ProfilingEventsContainer_AddEvents$offset() { + return ProfilingEventsContainer_AddEvents$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEventsContainer_AddEvents)(OrtProfilingEventsContainer *, const OrtProfilingEvent *const *, size_t) + * } + */ + public static MemorySegment ProfilingEventsContainer_AddEvents(MemorySegment struct) { + return struct.get(ProfilingEventsContainer_AddEvents$LAYOUT, ProfilingEventsContainer_AddEvents$OFFSET); + } + + /** + * Setter for field: + * {@snippet lang=c : + * OrtStatusPtr (*ProfilingEventsContainer_AddEvents)(OrtProfilingEventsContainer *, const OrtProfilingEvent *const *, size_t) + * } + */ + public static void ProfilingEventsContainer_AddEvents(MemorySegment struct, MemorySegment fieldValue) { + struct.set(ProfilingEventsContainer_AddEvents$LAYOUT, ProfilingEventsContainer_AddEvents$OFFSET, fieldValue); + } + + /** + * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}. + * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()} + */ + public static MemorySegment asSlice(MemorySegment array, long index) { + return array.asSlice(layout().byteSize() * index); + } + + /** + * The size (in bytes) of this struct + */ + public static long sizeof() { return layout().byteSize(); } + + /** + * Allocate a segment of size {@code layout().byteSize()} using {@code allocator} + */ + public static MemorySegment allocate(SegmentAllocator allocator) { + return allocator.allocate(layout()); + } + + /** + * Allocate an array of size {@code elementCount} using {@code allocator}. + * The returned segment has size {@code elementCount * layout().byteSize()}. + */ + public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) { + return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout())); + } + + /** + * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction} (if any). + * The returned segment has size {@code layout().byteSize()} + */ + public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer cleanup) { + return reinterpret(addr, 1, arena, cleanup); + } + + /** + * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction} (if any). + * The returned segment has size {@code elementCount * layout().byteSize()} + */ + public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer cleanup) { + return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup); + } +} +