From 9ae6db40303ad09261c7c0bb31fcf1a8c08115e4 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Tue, 12 Nov 2024 02:15:49 +0100 Subject: [PATCH] Update generated classes after commit 55eda73 (#749) Co-authored-by: masesdevelopers <94312179+masesdevelopers@users.noreply.github.com> --- .../kafka/metadata/FeatureLevelListener.java | 79 ++ .../Org/Apache/Kafka/Admin/AdminUtils.cs | 142 +++ .../Org/Apache/Kafka/Admin/BrokerMetadata.cs | 124 ++ .../Org/Apache/Kafka/Common/DirectoryId.cs | 176 +++ .../Apache/Kafka/Deferred/DeferredEvent.cs | 131 +++ .../Kafka/Deferred/DeferredEventQueue.cs | 144 +++ .../Kafka/Metadata/AssignmentsHelper.cs | 103 ++ .../Kafka/Metadata/FeatureLevelListener.cs | 216 ++++ .../Org/Apache/Kafka/Queue/EventQueue.cs | 1019 +++++++++++++++++ .../Org/Apache/Kafka/Queue/KafkaEventQueue.cs | 196 ++++ .../Kafka/Security/CipherParamsEncoder.cs | 142 +++ .../Security/EncryptingPasswordEncoder.cs | 135 +++ .../Apache/Kafka/Security/GcmParamsEncoder.cs | 122 ++ .../Apache/Kafka/Security/IvParamsEncoder.cs | 122 ++ .../Apache/Kafka/Security/PasswordEncoder.cs | 228 ++++ .../Kafka/Security/PasswordEncoderConfigs.cs | 199 ++++ .../Apache/Kafka/Timeline/SnapshotRegistry.cs | 198 ++++ .../Apache/Kafka/Timeline/TimelineHashMap.cs | 537 +++++++++ .../Apache/Kafka/Timeline/TimelineHashSet.cs | 500 ++++++++ .../Apache/Kafka/Timeline/TimelineInteger.cs | 163 +++ .../Org/Apache/Kafka/Timeline/TimelineLong.cs | 163 +++ .../Apache/Kafka/Timeline/TimelineObject.cs | 266 +++++ 22 files changed, 5105 insertions(+) create mode 100644 src/jvm/knet/src/main/java/org/mases/knet/generated/org/apache/kafka/metadata/FeatureLevelListener.java create mode 100644 src/net/KNet/Generated/Org/Apache/Kafka/Admin/AdminUtils.cs create mode 100644 src/net/KNet/Generated/Org/Apache/Kafka/Admin/BrokerMetadata.cs create mode 100644 src/net/KNet/Generated/Org/Apache/Kafka/Common/DirectoryId.cs create mode 100644 src/net/KNet/Generated/Org/Apache/Kafka/Deferred/DeferredEvent.cs create mode 100644 src/net/KNet/Generated/Org/Apache/Kafka/Deferred/DeferredEventQueue.cs create mode 100644 src/net/KNet/Generated/Org/Apache/Kafka/Metadata/AssignmentsHelper.cs create mode 100644 src/net/KNet/Generated/Org/Apache/Kafka/Metadata/FeatureLevelListener.cs create mode 100644 src/net/KNet/Generated/Org/Apache/Kafka/Queue/EventQueue.cs create mode 100644 src/net/KNet/Generated/Org/Apache/Kafka/Queue/KafkaEventQueue.cs create mode 100644 src/net/KNet/Generated/Org/Apache/Kafka/Security/CipherParamsEncoder.cs create mode 100644 src/net/KNet/Generated/Org/Apache/Kafka/Security/EncryptingPasswordEncoder.cs create mode 100644 src/net/KNet/Generated/Org/Apache/Kafka/Security/GcmParamsEncoder.cs create mode 100644 src/net/KNet/Generated/Org/Apache/Kafka/Security/IvParamsEncoder.cs create mode 100644 src/net/KNet/Generated/Org/Apache/Kafka/Security/PasswordEncoder.cs create mode 100644 src/net/KNet/Generated/Org/Apache/Kafka/Security/PasswordEncoderConfigs.cs create mode 100644 src/net/KNet/Generated/Org/Apache/Kafka/Timeline/SnapshotRegistry.cs create mode 100644 src/net/KNet/Generated/Org/Apache/Kafka/Timeline/TimelineHashMap.cs create mode 100644 src/net/KNet/Generated/Org/Apache/Kafka/Timeline/TimelineHashSet.cs create mode 100644 src/net/KNet/Generated/Org/Apache/Kafka/Timeline/TimelineInteger.cs create mode 100644 src/net/KNet/Generated/Org/Apache/Kafka/Timeline/TimelineLong.cs create mode 100644 src/net/KNet/Generated/Org/Apache/Kafka/Timeline/TimelineObject.cs diff --git a/src/jvm/knet/src/main/java/org/mases/knet/generated/org/apache/kafka/metadata/FeatureLevelListener.java b/src/jvm/knet/src/main/java/org/mases/knet/generated/org/apache/kafka/metadata/FeatureLevelListener.java new file mode 100644 index 000000000..971f1c3ee --- /dev/null +++ b/src/jvm/knet/src/main/java/org/mases/knet/generated/org/apache/kafka/metadata/FeatureLevelListener.java @@ -0,0 +1,79 @@ +/* +* Copyright 2024 MASES s.r.l. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* +* Refer to LICENSE for more information. +*/ + +/* +* This file is generated by MASES.JNetReflector (ver. 2.5.10.0) +*/ + +package org.mases.knet.generated.org.apache.kafka.metadata; + +public final class FeatureLevelListener implements org.mases.jcobridge.IJCListener, org.apache.kafka.metadata.FeatureLevelListener { + final org.mases.jcobridge.JCListener _internalListener; + + public FeatureLevelListener(String key) throws org.mases.jcobridge.JCNativeException { + super(); + _internalListener = new org.mases.jcobridge.JCListener(key); + } + + public synchronized void release() { + _internalListener.release(); + } + + public synchronized void raiseEvent(String eventName) { + _internalListener.raiseEvent(eventName); + } + + public synchronized void raiseEvent(String eventName, Object e) { + _internalListener.raiseEvent(eventName, e); + } + + public synchronized void raiseEvent(String eventName, Object e, Object... objects) { + _internalListener.raiseEvent(eventName, e, objects); + } + + public Object getEventData() { + return _internalListener.getEventData(); + } + + public boolean hasExtraData() { + return _internalListener.hasExtraData(); + } + + public int extraDataLength() { + return _internalListener.extraDataLength(); + } + + public Object[] extraData() { + return _internalListener.extraData(); + } + + public Object getReturnData() { + return _internalListener.getReturnData(); + } + + public void setReturnData(Object retData) { + _internalListener.setReturnData(retData); + } + + //@Override + public void handle(java.lang.String arg0, short arg1) { + org.mases.jnet.developed.JNetEventResult eventDataExchange = new org.mases.jnet.developed.JNetEventResult(); + raiseEvent("handle", eventDataExchange, arg0, arg1); if (!eventDataExchange.getHasOverride()) throw new UnsupportedOperationException("The method shall be implemented in .NET side since does not have a default implementation within the JVM"); + } + +} \ No newline at end of file diff --git a/src/net/KNet/Generated/Org/Apache/Kafka/Admin/AdminUtils.cs b/src/net/KNet/Generated/Org/Apache/Kafka/Admin/AdminUtils.cs new file mode 100644 index 000000000..7b3473dbc --- /dev/null +++ b/src/net/KNet/Generated/Org/Apache/Kafka/Admin/AdminUtils.cs @@ -0,0 +1,142 @@ +/* +* Copyright 2024 MASES s.r.l. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* +* Refer to LICENSE for more information. +*/ + +/* +* This file is generated by MASES.JNetReflector (ver. 2.5.10.0) +* using kafka-server-common-3.9.0.jar as reference +*/ + +using MASES.JCOBridge.C2JBridge; + +namespace Org.Apache.Kafka.Admin +{ + #region AdminUtils declaration + /// + /// + /// + public partial class AdminUtils : MASES.JCOBridge.C2JBridge.JVMBridgeBase + { + const string _bridgeClassName = "org.apache.kafka.admin.AdminUtils"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public AdminUtils() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public AdminUtils(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => false; + + // TODO: complete the class + + } + #endregion + + #region AdminUtils implementation + public partial class AdminUtils + { + #region Constructors + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + /// + /// + /// + public static Java.Lang.String ADMIN_CLIENT_ID { get { if (!_ADMIN_CLIENT_IDReady) { _ADMIN_CLIENT_IDContent = SGetField(LocalBridgeClazz, "ADMIN_CLIENT_ID"); _ADMIN_CLIENT_IDReady = true; } return _ADMIN_CLIENT_IDContent; } } + private static Java.Lang.String _ADMIN_CLIENT_IDContent = default; + private static bool _ADMIN_CLIENT_IDReady = false; // this is used because in case of generics + + #endregion + + #region Static methods + /// + /// + /// + /// + /// + public static Java.Util.List GetRackAlternatedBrokerList(Java.Util.Map arg0) + { + return SExecuteWithSignature>(LocalBridgeClazz, "getRackAlternatedBrokerList", "(Ljava/util/Map;)Ljava/util/List;", arg0); + } + /// + /// + /// + /// + /// + /// + /// + /// + /// + public static Java.Util.Map> AssignReplicasToBrokers(Java.Util.Collection arg0, int arg1, int arg2, int arg3, int arg4) + { + return SExecuteWithSignature>>(LocalBridgeClazz, "assignReplicasToBrokers", "(Ljava/util/Collection;IIII)Ljava/util/Map;", arg0, arg1, arg2, arg3, arg4); + } + /// + /// + /// + /// + /// + /// + /// + public static Java.Util.Map> AssignReplicasToBrokers(Java.Util.Collection arg0, int arg1, int arg2) + { + return SExecuteWithSignature>>(LocalBridgeClazz, "assignReplicasToBrokers", "(Ljava/util/Collection;II)Ljava/util/Map;", arg0, arg1, arg2); + } + + #endregion + + #region Instance methods + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion +} \ No newline at end of file diff --git a/src/net/KNet/Generated/Org/Apache/Kafka/Admin/BrokerMetadata.cs b/src/net/KNet/Generated/Org/Apache/Kafka/Admin/BrokerMetadata.cs new file mode 100644 index 000000000..8b5d1a508 --- /dev/null +++ b/src/net/KNet/Generated/Org/Apache/Kafka/Admin/BrokerMetadata.cs @@ -0,0 +1,124 @@ +/* +* Copyright 2024 MASES s.r.l. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* +* Refer to LICENSE for more information. +*/ + +/* +* This file is generated by MASES.JNetReflector (ver. 2.5.10.0) +* using kafka-server-common-3.9.0.jar as reference +*/ + +using MASES.JCOBridge.C2JBridge; + +namespace Org.Apache.Kafka.Admin +{ + #region BrokerMetadata declaration + /// + /// + /// + public partial class BrokerMetadata : MASES.JCOBridge.C2JBridge.JVMBridgeBase + { + const string _bridgeClassName = "org.apache.kafka.admin.BrokerMetadata"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public BrokerMetadata() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public BrokerMetadata(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => false; + + // TODO: complete the class + + } + #endregion + + #region BrokerMetadata implementation + public partial class BrokerMetadata + { + #region Constructors + /// + /// + /// + /// + /// + public BrokerMetadata(int arg0, Java.Util.Optional arg1) + : base(arg0, arg1) + { + } + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + /// + /// + /// + public int id { get { if (!_idReady) { _idContent = IGetField("id"); _idReady = true; } return _idContent; } } + private int _idContent = default; + private bool _idReady = false; // this is used because in case of generics + /// + /// + /// + public Java.Util.Optional rack { get { if (!_rackReady) { _rackContent = IGetField("rack"); _rackReady = true; } return _rackContent; } } + private Java.Util.Optional _rackContent = default; + private bool _rackReady = false; // this is used because in case of generics + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion +} \ No newline at end of file diff --git a/src/net/KNet/Generated/Org/Apache/Kafka/Common/DirectoryId.cs b/src/net/KNet/Generated/Org/Apache/Kafka/Common/DirectoryId.cs new file mode 100644 index 000000000..685239d5a --- /dev/null +++ b/src/net/KNet/Generated/Org/Apache/Kafka/Common/DirectoryId.cs @@ -0,0 +1,176 @@ +/* +* Copyright 2024 MASES s.r.l. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* +* Refer to LICENSE for more information. +*/ + +/* +* This file is generated by MASES.JNetReflector (ver. 2.5.10.0) +* using kafka-server-common-3.9.0.jar as reference +*/ + +using MASES.JCOBridge.C2JBridge; + +namespace Org.Apache.Kafka.Common +{ + #region DirectoryId declaration + /// + /// + /// + public partial class DirectoryId : MASES.JCOBridge.C2JBridge.JVMBridgeBase + { + const string _bridgeClassName = "org.apache.kafka.common.DirectoryId"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public DirectoryId() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public DirectoryId(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => false; + + // TODO: complete the class + + } + #endregion + + #region DirectoryId implementation + public partial class DirectoryId + { + #region Constructors + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + /// + /// + /// + public static Org.Apache.Kafka.Common.Uuid LOST { get { if (!_LOSTReady) { _LOSTContent = SGetField(LocalBridgeClazz, "LOST"); _LOSTReady = true; } return _LOSTContent; } } + private static Org.Apache.Kafka.Common.Uuid _LOSTContent = default; + private static bool _LOSTReady = false; // this is used because in case of generics + /// + /// + /// + public static Org.Apache.Kafka.Common.Uuid MIGRATING { get { if (!_MIGRATINGReady) { _MIGRATINGContent = SGetField(LocalBridgeClazz, "MIGRATING"); _MIGRATINGReady = true; } return _MIGRATINGContent; } } + private static Org.Apache.Kafka.Common.Uuid _MIGRATINGContent = default; + private static bool _MIGRATINGReady = false; // this is used because in case of generics + /// + /// + /// + public static Org.Apache.Kafka.Common.Uuid UNASSIGNED { get { if (!_UNASSIGNEDReady) { _UNASSIGNEDContent = SGetField(LocalBridgeClazz, "UNASSIGNED"); _UNASSIGNEDReady = true; } return _UNASSIGNEDContent; } } + private static Org.Apache.Kafka.Common.Uuid _UNASSIGNEDContent = default; + private static bool _UNASSIGNEDReady = false; // this is used because in case of generics + + #endregion + + #region Static methods + /// + /// + /// + /// + /// + /// + public static bool IsOnline(Org.Apache.Kafka.Common.Uuid arg0, Java.Util.List arg1) + { + return SExecuteWithSignature(LocalBridgeClazz, "isOnline", "(Lorg/apache/kafka/common/Uuid;Ljava/util/List;)Z", arg0, arg1); + } + /// + /// + /// + /// + /// + public static bool Reserved(Org.Apache.Kafka.Common.Uuid arg0) + { + return SExecuteWithSignature(LocalBridgeClazz, "reserved", "(Lorg/apache/kafka/common/Uuid;)Z", arg0); + } + /// + /// + /// + /// + /// + /// + public static Java.Util.Map CreateAssignmentMap(int[] arg0, Org.Apache.Kafka.Common.Uuid[] arg1) + { + return SExecuteWithSignature>(LocalBridgeClazz, "createAssignmentMap", "([I[Lorg/apache/kafka/common/Uuid;)Ljava/util/Map;", arg0, arg1); + } + /// + /// + /// + /// + public static Org.Apache.Kafka.Common.Uuid Random() + { + return SExecuteWithSignature(LocalBridgeClazz, "random", "()Lorg/apache/kafka/common/Uuid;"); + } + /// + /// + /// + /// + /// + public static Org.Apache.Kafka.Common.Uuid[] MigratingArray(int arg0) + { + return SExecuteWithSignatureArray(LocalBridgeClazz, "migratingArray", "(I)[Lorg/apache/kafka/common/Uuid;", arg0); + } + /// + /// + /// + /// + /// + public static Org.Apache.Kafka.Common.Uuid[] UnassignedArray(int arg0) + { + return SExecuteWithSignatureArray(LocalBridgeClazz, "unassignedArray", "(I)[Lorg/apache/kafka/common/Uuid;", arg0); + } + + #endregion + + #region Instance methods + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion +} \ No newline at end of file diff --git a/src/net/KNet/Generated/Org/Apache/Kafka/Deferred/DeferredEvent.cs b/src/net/KNet/Generated/Org/Apache/Kafka/Deferred/DeferredEvent.cs new file mode 100644 index 000000000..c210a3a54 --- /dev/null +++ b/src/net/KNet/Generated/Org/Apache/Kafka/Deferred/DeferredEvent.cs @@ -0,0 +1,131 @@ +/* +* Copyright 2024 MASES s.r.l. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* +* Refer to LICENSE for more information. +*/ + +/* +* This file is generated by MASES.JNetReflector (ver. 2.5.10.0) +* using kafka-server-common-3.9.0.jar as reference +*/ + +using MASES.JCOBridge.C2JBridge; + +namespace Org.Apache.Kafka.Deferred +{ + #region DeferredEvent declaration + /// + /// + /// + public partial class DeferredEvent : MASES.JCOBridge.C2JBridge.JVMBridgeBase + { + const string _bridgeClassName = "org.apache.kafka.deferred.DeferredEvent"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + [global::System.Obsolete("DeferredEvent class represents, in .NET, an instance of a JVM interface or abstract class. This public initializer is needed for JCOBridge internal use, other uses can produce unidentible behaviors.")] + public DeferredEvent() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + [global::System.Obsolete("DeferredEvent class represents, in .NET, an instance of a JVM interface or abstract class. This public initializer is needed for JCOBridge internal use, other uses can produce unidentible behaviors.")] + public DeferredEvent(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => true; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => true; + /// + /// + /// + public override bool IsBridgeStatic => false; + + // TODO: complete the class + + } + #endregion + + #region IDeferredEvent + /// + /// .NET interface for TO BE DEFINED FROM USER + /// + public partial interface IDeferredEvent + { + #region Instance methods + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion + + #region DeferredEvent implementation + public partial class DeferredEvent : Org.Apache.Kafka.Deferred.IDeferredEvent + { + #region Constructors + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + public void Complete(MASES.JCOBridge.C2JBridge.JVMBridgeException arg0) + { + IExecuteWithSignature("complete", "(Ljava/lang/Throwable;)V", arg0); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion +} \ No newline at end of file diff --git a/src/net/KNet/Generated/Org/Apache/Kafka/Deferred/DeferredEventQueue.cs b/src/net/KNet/Generated/Org/Apache/Kafka/Deferred/DeferredEventQueue.cs new file mode 100644 index 000000000..7417ad980 --- /dev/null +++ b/src/net/KNet/Generated/Org/Apache/Kafka/Deferred/DeferredEventQueue.cs @@ -0,0 +1,144 @@ +/* +* Copyright 2024 MASES s.r.l. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* +* Refer to LICENSE for more information. +*/ + +/* +* This file is generated by MASES.JNetReflector (ver. 2.5.10.0) +* using kafka-server-common-3.9.0.jar as reference +*/ + +using MASES.JCOBridge.C2JBridge; + +namespace Org.Apache.Kafka.Deferred +{ + #region DeferredEventQueue declaration + /// + /// + /// + public partial class DeferredEventQueue : MASES.JCOBridge.C2JBridge.JVMBridgeBase + { + const string _bridgeClassName = "org.apache.kafka.deferred.DeferredEventQueue"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public DeferredEventQueue() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public DeferredEventQueue(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => false; + + // TODO: complete the class + + } + #endregion + + #region DeferredEventQueue implementation + public partial class DeferredEventQueue + { + #region Constructors + /// + /// + /// + /// + public DeferredEventQueue(Org.Apache.Kafka.Common.Utils.LogContext arg0) + : base(arg0) + { + } + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + public Java.Util.OptionalLong HighestPendingOffset() + { + return IExecuteWithSignature("highestPendingOffset", "()Ljava/util/OptionalLong;"); + } + /// + /// + /// + /// + /// + public void Add(long arg0, Org.Apache.Kafka.Deferred.DeferredEvent arg1) + { + IExecuteWithSignature("add", "(JLorg/apache/kafka/deferred/DeferredEvent;)V", arg0, arg1); + } + /// + /// + /// + /// + public void CompleteUpTo(long arg0) + { + IExecuteWithSignature("completeUpTo", "(J)V", arg0); + } + /// + /// + /// + /// + public void FailAll(MASES.JCOBridge.C2JBridge.JVMBridgeException arg0) + { + IExecuteWithSignature("failAll", "(Ljava/lang/Exception;)V", arg0); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion +} \ No newline at end of file diff --git a/src/net/KNet/Generated/Org/Apache/Kafka/Metadata/AssignmentsHelper.cs b/src/net/KNet/Generated/Org/Apache/Kafka/Metadata/AssignmentsHelper.cs new file mode 100644 index 000000000..47fc8c873 --- /dev/null +++ b/src/net/KNet/Generated/Org/Apache/Kafka/Metadata/AssignmentsHelper.cs @@ -0,0 +1,103 @@ +/* +* Copyright 2024 MASES s.r.l. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* +* Refer to LICENSE for more information. +*/ + +/* +* This file is generated by MASES.JNetReflector (ver. 2.5.10.0) +* using kafka-server-common-3.9.0.jar as reference +*/ + +using MASES.JCOBridge.C2JBridge; + +namespace Org.Apache.Kafka.Metadata +{ + #region AssignmentsHelper declaration + /// + /// + /// + public partial class AssignmentsHelper : MASES.JCOBridge.C2JBridge.JVMBridgeBase + { + const string _bridgeClassName = "org.apache.kafka.metadata.AssignmentsHelper"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public AssignmentsHelper() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public AssignmentsHelper(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => false; + + // TODO: complete the class + + } + #endregion + + #region AssignmentsHelper implementation + public partial class AssignmentsHelper + { + #region Constructors + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion +} \ No newline at end of file diff --git a/src/net/KNet/Generated/Org/Apache/Kafka/Metadata/FeatureLevelListener.cs b/src/net/KNet/Generated/Org/Apache/Kafka/Metadata/FeatureLevelListener.cs new file mode 100644 index 000000000..884a3d5cf --- /dev/null +++ b/src/net/KNet/Generated/Org/Apache/Kafka/Metadata/FeatureLevelListener.cs @@ -0,0 +1,216 @@ +/* +* Copyright 2024 MASES s.r.l. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* +* Refer to LICENSE for more information. +*/ + +/* +* This file is generated by MASES.JNetReflector (ver. 2.5.10.0) +* using kafka-server-common-3.9.0.jar as reference +*/ + +using MASES.JCOBridge.C2JBridge; + +namespace Org.Apache.Kafka.Metadata +{ + #region FeatureLevelListener declaration + /// + /// + /// + public partial class FeatureLevelListener : MASES.JCOBridge.C2JBridge.JVMBridgeListener + { + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public FeatureLevelListener() { InitializeHandlers(); } + + const string _bridgeClassName = "org.mases.knet.generated.org.apache.kafka.metadata.FeatureLevelListener"; + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + + + // TODO: complete the class + + } + #endregion + + #region FeatureLevelListenerDirect declaration + /// + /// Direct override of or its generic type if there is one + /// + public partial class FeatureLevelListenerDirect : FeatureLevelListener + { + /// + /// + /// + public override bool AutoInit => false; + + /// + protected override void InitializeHandlers() { } + + const string _bridgeClassName = "org.apache.kafka.metadata.FeatureLevelListener"; + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => true; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => true; + /// + /// + /// + public override bool IsBridgeStatic => false; + } + #endregion + + #region IFeatureLevelListener + /// + /// .NET interface for org.mases.knet.generated.org.apache.kafka.metadata.FeatureLevelListener implementing + /// + public partial interface IFeatureLevelListener + { + #region Instance methods + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion + + #region FeatureLevelListener implementation + public partial class FeatureLevelListener : Org.Apache.Kafka.Metadata.IFeatureLevelListener + { + #region Constructors + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// Handlers initializer for + /// + protected virtual void InitializeHandlers() + { + AddEventHandler("handle", new global::System.EventHandler>>(HandleEventHandler)); + + } + + /// + /// Handler for + /// + /// If has a value it takes precedence over corresponding class method + public global::System.Action OnHandle { get; set; } = null; + + bool hasOverrideHandle = true; + void HandleEventHandler(object sender, CLRListenerEventArgs> data) + { + hasOverrideHandle = true; + var methodToExecute = (OnHandle != null) ? OnHandle : Handle; + methodToExecute.Invoke(data.EventData.GetAt(0), data.EventData.GetAt(1)); + data.EventData.TypedEventData.HasOverride = hasOverrideHandle; + } + + /// + /// + /// + /// + /// + public virtual void Handle(Java.Lang.String arg0, short arg1) + { + hasOverrideHandle = false; + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion + + #region FeatureLevelListenerDirect implementation + public partial class FeatureLevelListenerDirect : Org.Apache.Kafka.Metadata.IFeatureLevelListener + { + #region Constructors + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + /// + public override void Handle(Java.Lang.String arg0, short arg1) + { + IExecuteWithSignature("handle", "(Ljava/lang/String;S)V", arg0, arg1); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion +} \ No newline at end of file diff --git a/src/net/KNet/Generated/Org/Apache/Kafka/Queue/EventQueue.cs b/src/net/KNet/Generated/Org/Apache/Kafka/Queue/EventQueue.cs new file mode 100644 index 000000000..7f6dbc885 --- /dev/null +++ b/src/net/KNet/Generated/Org/Apache/Kafka/Queue/EventQueue.cs @@ -0,0 +1,1019 @@ +/* +* Copyright 2024 MASES s.r.l. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* +* Refer to LICENSE for more information. +*/ + +/* +* This file is generated by MASES.JNetReflector (ver. 2.5.10.0) +* using kafka-server-common-3.9.0.jar as reference +*/ + +using MASES.JCOBridge.C2JBridge; + +namespace Org.Apache.Kafka.Queue +{ + #region EventQueue declaration + /// + /// + /// + public partial class EventQueue : Java.Lang.AutoCloseable + { + const string _bridgeClassName = "org.apache.kafka.queue.EventQueue"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + [global::System.Obsolete("EventQueue class represents, in .NET, an instance of a JVM interface or abstract class. This public initializer is needed for JCOBridge internal use, other uses can produce unidentible behaviors.")] + public EventQueue() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + [global::System.Obsolete("EventQueue class represents, in .NET, an instance of a JVM interface or abstract class. This public initializer is needed for JCOBridge internal use, other uses can produce unidentible behaviors.")] + public EventQueue(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => true; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => true; + /// + /// + /// + public override bool IsBridgeStatic => false; + + // TODO: complete the class + #region DeadlineFunction declaration + /// + /// + /// + public partial class DeadlineFunction : MASES.JCOBridge.C2JBridge.JVMBridgeBase + { + const string _bridgeClassName = "org.apache.kafka.queue.EventQueue$DeadlineFunction"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public DeadlineFunction() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public DeadlineFunction(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => true; + + // TODO: complete the class + + } + #endregion + + #region EarliestDeadlineFunction declaration + /// + /// + /// + public partial class EarliestDeadlineFunction : MASES.JCOBridge.C2JBridge.JVMBridgeBase + { + const string _bridgeClassName = "org.apache.kafka.queue.EventQueue$EarliestDeadlineFunction"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public EarliestDeadlineFunction() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public EarliestDeadlineFunction(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => true; + + // TODO: complete the class + + } + #endregion + + #region Event declaration + /// + /// + /// + public partial class Event : MASES.JCOBridge.C2JBridge.JVMBridgeBase + { + const string _bridgeClassName = "org.apache.kafka.queue.EventQueue$Event"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + [global::System.Obsolete("Event class represents, in .NET, an instance of a JVM interface or abstract class. This public initializer is needed for JCOBridge internal use, other uses can produce unidentible behaviors.")] + public Event() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + [global::System.Obsolete("Event class represents, in .NET, an instance of a JVM interface or abstract class. This public initializer is needed for JCOBridge internal use, other uses can produce unidentible behaviors.")] + public Event(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => true; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => true; + /// + /// + /// + public override bool IsBridgeStatic => true; + + // TODO: complete the class + + } + #endregion + + #region EventInsertionType declaration + /// + /// + /// + public partial class EventInsertionType : Java.Lang.Enum + { + const string _bridgeClassName = "org.apache.kafka.queue.EventQueue$EventInsertionType"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public EventInsertionType() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public EventInsertionType(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => true; + + // TODO: complete the class + + } + #endregion + + #region FailureLoggingEvent declaration + /// + /// + /// + public partial class FailureLoggingEvent : Org.Apache.Kafka.Queue.EventQueue.Event + { + const string _bridgeClassName = "org.apache.kafka.queue.EventQueue$FailureLoggingEvent"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + [global::System.Obsolete("FailureLoggingEvent class represents, in .NET, an instance of a JVM interface or abstract class. This public initializer is needed for JCOBridge internal use, other uses can produce unidentible behaviors.")] + public FailureLoggingEvent() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + [global::System.Obsolete("FailureLoggingEvent class represents, in .NET, an instance of a JVM interface or abstract class. This public initializer is needed for JCOBridge internal use, other uses can produce unidentible behaviors.")] + public FailureLoggingEvent(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => true; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => true; + + // TODO: complete the class + + } + #endregion + + #region LatestDeadlineFunction declaration + /// + /// + /// + public partial class LatestDeadlineFunction : MASES.JCOBridge.C2JBridge.JVMBridgeBase + { + const string _bridgeClassName = "org.apache.kafka.queue.EventQueue$LatestDeadlineFunction"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public LatestDeadlineFunction() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public LatestDeadlineFunction(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => true; + + // TODO: complete the class + + } + #endregion + + #region NoDeadlineFunction declaration + /// + /// + /// + public partial class NoDeadlineFunction : MASES.JCOBridge.C2JBridge.JVMBridgeBase + { + const string _bridgeClassName = "org.apache.kafka.queue.EventQueue$NoDeadlineFunction"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public NoDeadlineFunction() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public NoDeadlineFunction(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => true; + + // TODO: complete the class + + } + #endregion + + #region VoidEvent declaration + /// + /// + /// + public partial class VoidEvent : Org.Apache.Kafka.Queue.EventQueue.Event + { + const string _bridgeClassName = "org.apache.kafka.queue.EventQueue$VoidEvent"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public VoidEvent() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public VoidEvent(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => true; + + // TODO: complete the class + + } + #endregion + + + } + #endregion + + #region IEventQueue + /// + /// .NET interface for TO BE DEFINED FROM USER + /// + public partial interface IEventQueue : Java.Lang.IAutoCloseable + { + #region Instance methods + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion + + #region EventQueue implementation + public partial class EventQueue : Org.Apache.Kafka.Queue.IEventQueue + { + #region Constructors + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + public int Size() + { + return IExecuteWithSignature("size", "()I"); + } + /// + /// + /// + /// + public void BeginShutdown(Java.Lang.String arg0) + { + IExecuteWithSignature("beginShutdown", "(Ljava/lang/String;)V", arg0); + } + /// + /// + /// + /// + public void CancelDeferred(Java.Lang.String arg0) + { + IExecuteWithSignature("cancelDeferred", "(Ljava/lang/String;)V", arg0); + } + /// + /// + /// + /// + public void Close() + { + IExecuteWithSignature("close", "()V"); + } + /// + /// + /// + /// + /// + /// + /// + public void Enqueue(Org.Apache.Kafka.Queue.EventQueue.EventInsertionType arg0, Java.Lang.String arg1, Java.Util.Function.Function arg2, Org.Apache.Kafka.Queue.EventQueue.Event arg3) + { + IExecuteWithSignature("enqueue", "(Lorg/apache/kafka/queue/EventQueue$EventInsertionType;Ljava/lang/String;Ljava/util/function/Function;Lorg/apache/kafka/queue/EventQueue$Event;)V", arg0, arg1, arg2, arg3); + } + /// + /// + /// + /// + public bool IsEmpty() + { + return IExecuteWithSignature("isEmpty", "()Z"); + } + /// + /// + /// + /// + public void Append(Org.Apache.Kafka.Queue.EventQueue.Event arg0) + { + IExecuteWithSignature("append", "(Lorg/apache/kafka/queue/EventQueue$Event;)V", arg0); + } + /// + /// + /// + /// + /// + public void AppendWithDeadline(long arg0, Org.Apache.Kafka.Queue.EventQueue.Event arg1) + { + IExecuteWithSignature("appendWithDeadline", "(JLorg/apache/kafka/queue/EventQueue$Event;)V", arg0, arg1); + } + /// + /// + /// + /// + public void Prepend(Org.Apache.Kafka.Queue.EventQueue.Event arg0) + { + IExecuteWithSignature("prepend", "(Lorg/apache/kafka/queue/EventQueue$Event;)V", arg0); + } + /// + /// + /// + /// + /// + /// + public void ScheduleDeferred(Java.Lang.String arg0, Java.Util.Function.Function arg1, Org.Apache.Kafka.Queue.EventQueue.Event arg2) + { + IExecuteWithSignature("scheduleDeferred", "(Ljava/lang/String;Ljava/util/function/Function;Lorg/apache/kafka/queue/EventQueue$Event;)V", arg0, arg1, arg2); + } + /// + /// + /// + public void Wakeup() + { + IExecuteWithSignature("wakeup", "()V"); + } + + #endregion + + #region Nested classes + #region DeadlineFunction implementation + public partial class DeadlineFunction + { + #region Constructors + /// + /// + /// + /// + public DeadlineFunction(long arg0) + : base(arg0) + { + } + + #endregion + + #region Class/Interface conversion operators + /// + /// Converter from to + /// + public static implicit operator Java.Util.Function.Function(Org.Apache.Kafka.Queue.EventQueue.DeadlineFunction t) => t.Cast(); + + #endregion + + #region Fields + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + /// + public object Apply(object arg0) + { + return IExecuteWithSignature("apply", "(Ljava/lang/Object;)Ljava/lang/Object;", arg0); + } + /// + /// + /// + /// + /// + public Java.Util.OptionalLong Apply(Java.Util.OptionalLong arg0) + { + return IExecuteWithSignature("apply", "(Ljava/util/OptionalLong;)Ljava/util/OptionalLong;", arg0); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion + + #region EarliestDeadlineFunction implementation + public partial class EarliestDeadlineFunction + { + #region Constructors + /// + /// + /// + /// + public EarliestDeadlineFunction(long arg0) + : base(arg0) + { + } + + #endregion + + #region Class/Interface conversion operators + /// + /// Converter from to + /// + public static implicit operator Java.Util.Function.Function(Org.Apache.Kafka.Queue.EventQueue.EarliestDeadlineFunction t) => t.Cast(); + + #endregion + + #region Fields + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + /// + public object Apply(object arg0) + { + return IExecuteWithSignature("apply", "(Ljava/lang/Object;)Ljava/lang/Object;", arg0); + } + /// + /// + /// + /// + /// + public Java.Util.OptionalLong Apply(Java.Util.OptionalLong arg0) + { + return IExecuteWithSignature("apply", "(Ljava/util/OptionalLong;)Ljava/util/OptionalLong;", arg0); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion + + #region Event implementation + public partial class Event + { + #region Constructors + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + public void Run() + { + IExecuteWithSignature("run", "()V"); + } + /// + /// + /// + /// + public void HandleException(MASES.JCOBridge.C2JBridge.JVMBridgeException arg0) + { + IExecuteWithSignature("handleException", "(Ljava/lang/Throwable;)V", arg0); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion + + #region EventInsertionType implementation + public partial class EventInsertionType + { + #region Constructors + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + /// + /// + /// + public static Org.Apache.Kafka.Queue.EventQueue.EventInsertionType APPEND { get { if (!_APPENDReady) { _APPENDContent = SGetField(LocalBridgeClazz, "APPEND"); _APPENDReady = true; } return _APPENDContent; } } + private static Org.Apache.Kafka.Queue.EventQueue.EventInsertionType _APPENDContent = default; + private static bool _APPENDReady = false; // this is used because in case of generics + /// + /// + /// + public static Org.Apache.Kafka.Queue.EventQueue.EventInsertionType DEFERRED { get { if (!_DEFERREDReady) { _DEFERREDContent = SGetField(LocalBridgeClazz, "DEFERRED"); _DEFERREDReady = true; } return _DEFERREDContent; } } + private static Org.Apache.Kafka.Queue.EventQueue.EventInsertionType _DEFERREDContent = default; + private static bool _DEFERREDReady = false; // this is used because in case of generics + /// + /// + /// + public static Org.Apache.Kafka.Queue.EventQueue.EventInsertionType PREPEND { get { if (!_PREPENDReady) { _PREPENDContent = SGetField(LocalBridgeClazz, "PREPEND"); _PREPENDReady = true; } return _PREPENDContent; } } + private static Org.Apache.Kafka.Queue.EventQueue.EventInsertionType _PREPENDContent = default; + private static bool _PREPENDReady = false; // this is used because in case of generics + + #endregion + + #region Static methods + /// + /// + /// + /// + /// + public static Org.Apache.Kafka.Queue.EventQueue.EventInsertionType ValueOf(Java.Lang.String arg0) + { + return SExecuteWithSignature(LocalBridgeClazz, "valueOf", "(Ljava/lang/String;)Lorg/apache/kafka/queue/EventQueue$EventInsertionType;", arg0); + } + /// + /// + /// + /// + public static Org.Apache.Kafka.Queue.EventQueue.EventInsertionType[] Values() + { + return SExecuteWithSignatureArray(LocalBridgeClazz, "values", "()[Lorg/apache/kafka/queue/EventQueue$EventInsertionType;"); + } + + #endregion + + #region Instance methods + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion + + #region FailureLoggingEvent implementation + public partial class FailureLoggingEvent + { + #region Constructors + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + public void HandleException(MASES.JCOBridge.C2JBridge.JVMBridgeException arg0) + { + IExecuteWithSignature("handleException", "(Ljava/lang/Throwable;)V", arg0); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion + + #region LatestDeadlineFunction implementation + public partial class LatestDeadlineFunction + { + #region Constructors + /// + /// + /// + /// + public LatestDeadlineFunction(long arg0) + : base(arg0) + { + } + + #endregion + + #region Class/Interface conversion operators + /// + /// Converter from to + /// + public static implicit operator Java.Util.Function.Function(Org.Apache.Kafka.Queue.EventQueue.LatestDeadlineFunction t) => t.Cast(); + + #endregion + + #region Fields + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + /// + public object Apply(object arg0) + { + return IExecuteWithSignature("apply", "(Ljava/lang/Object;)Ljava/lang/Object;", arg0); + } + /// + /// + /// + /// + /// + public Java.Util.OptionalLong Apply(Java.Util.OptionalLong arg0) + { + return IExecuteWithSignature("apply", "(Ljava/util/OptionalLong;)Ljava/util/OptionalLong;", arg0); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion + + #region NoDeadlineFunction implementation + public partial class NoDeadlineFunction + { + #region Constructors + + #endregion + + #region Class/Interface conversion operators + /// + /// Converter from to + /// + public static implicit operator Java.Util.Function.Function(Org.Apache.Kafka.Queue.EventQueue.NoDeadlineFunction t) => t.Cast(); + + #endregion + + #region Fields + /// + /// + /// + public static Org.Apache.Kafka.Queue.EventQueue.NoDeadlineFunction INSTANCE { get { if (!_INSTANCEReady) { _INSTANCEContent = SGetField(LocalBridgeClazz, "INSTANCE"); _INSTANCEReady = true; } return _INSTANCEContent; } } + private static Org.Apache.Kafka.Queue.EventQueue.NoDeadlineFunction _INSTANCEContent = default; + private static bool _INSTANCEReady = false; // this is used because in case of generics + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + /// + public object Apply(object arg0) + { + return IExecuteWithSignature("apply", "(Ljava/lang/Object;)Ljava/lang/Object;", arg0); + } + /// + /// + /// + /// + /// + public Java.Util.OptionalLong Apply(Java.Util.OptionalLong arg0) + { + return IExecuteWithSignature("apply", "(Ljava/util/OptionalLong;)Ljava/util/OptionalLong;", arg0); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion + + #region VoidEvent implementation + public partial class VoidEvent + { + #region Constructors + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + /// + /// + /// + public static Org.Apache.Kafka.Queue.EventQueue.VoidEvent INSTANCE { get { if (!_INSTANCEReady) { _INSTANCEContent = SGetField(LocalBridgeClazz, "INSTANCE"); _INSTANCEReady = true; } return _INSTANCEContent; } } + private static Org.Apache.Kafka.Queue.EventQueue.VoidEvent _INSTANCEContent = default; + private static bool _INSTANCEReady = false; // this is used because in case of generics + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + public void Run() + { + IExecuteWithSignature("run", "()V"); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion + + + #endregion + + // TODO: complete the class + } + #endregion +} \ No newline at end of file diff --git a/src/net/KNet/Generated/Org/Apache/Kafka/Queue/KafkaEventQueue.cs b/src/net/KNet/Generated/Org/Apache/Kafka/Queue/KafkaEventQueue.cs new file mode 100644 index 000000000..46e0e3d75 --- /dev/null +++ b/src/net/KNet/Generated/Org/Apache/Kafka/Queue/KafkaEventQueue.cs @@ -0,0 +1,196 @@ +/* +* Copyright 2024 MASES s.r.l. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* +* Refer to LICENSE for more information. +*/ + +/* +* This file is generated by MASES.JNetReflector (ver. 2.5.10.0) +* using kafka-server-common-3.9.0.jar as reference +*/ + +using MASES.JCOBridge.C2JBridge; + +namespace Org.Apache.Kafka.Queue +{ + #region KafkaEventQueue declaration + /// + /// + /// + public partial class KafkaEventQueue : Org.Apache.Kafka.Queue.EventQueue + { + const string _bridgeClassName = "org.apache.kafka.queue.KafkaEventQueue"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public KafkaEventQueue() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public KafkaEventQueue(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => false; + + // TODO: complete the class + + } + #endregion + + #region KafkaEventQueue implementation + public partial class KafkaEventQueue + { + #region Constructors + /// + /// + /// + /// + /// + /// + /// + public KafkaEventQueue(Org.Apache.Kafka.Common.Utils.Time arg0, Org.Apache.Kafka.Common.Utils.LogContext arg1, Java.Lang.String arg2, Org.Apache.Kafka.Queue.EventQueue.Event arg3) + : base(arg0, arg1, arg2, arg3) + { + } + /// + /// + /// + /// + /// + /// + public KafkaEventQueue(Org.Apache.Kafka.Common.Utils.Time arg0, Org.Apache.Kafka.Common.Utils.LogContext arg1, Java.Lang.String arg2) + : base(arg0, arg1, arg2) + { + } + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + /// + /// + /// + public static Java.Lang.String EVENT_HANDLER_THREAD_SUFFIX { get { if (!_EVENT_HANDLER_THREAD_SUFFIXReady) { _EVENT_HANDLER_THREAD_SUFFIXContent = SGetField(LocalBridgeClazz, "EVENT_HANDLER_THREAD_SUFFIX"); _EVENT_HANDLER_THREAD_SUFFIXReady = true; } return _EVENT_HANDLER_THREAD_SUFFIXContent; } } + private static Java.Lang.String _EVENT_HANDLER_THREAD_SUFFIXContent = default; + private static bool _EVENT_HANDLER_THREAD_SUFFIXReady = false; // this is used because in case of generics + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + public int Size() + { + return IExecuteWithSignature("size", "()I"); + } + /// + /// + /// + /// + public Java.Util.Optional FirstDeferredIfIdling() + { + return IExecuteWithSignature>("firstDeferredIfIdling", "()Ljava/util/Optional;"); + } + /// + /// + /// + /// + public Org.Apache.Kafka.Common.Utils.Time Time() + { + return IExecuteWithSignature("time", "()Lorg/apache/kafka/common/utils/Time;"); + } + /// + /// + /// + /// + public void BeginShutdown(Java.Lang.String arg0) + { + IExecuteWithSignature("beginShutdown", "(Ljava/lang/String;)V", arg0); + } + /// + /// + /// + /// + public void CancelDeferred(Java.Lang.String arg0) + { + IExecuteWithSignature("cancelDeferred", "(Ljava/lang/String;)V", arg0); + } + /// + /// + /// + /// + public void Close() + { + IExecuteWithSignature("close", "()V"); + } + /// + /// + /// + /// + /// + /// + /// + public void Enqueue(Org.Apache.Kafka.Queue.EventQueue.EventInsertionType arg0, Java.Lang.String arg1, Java.Util.Function.Function arg2, Org.Apache.Kafka.Queue.EventQueue.Event arg3) + { + IExecuteWithSignature("enqueue", "(Lorg/apache/kafka/queue/EventQueue$EventInsertionType;Ljava/lang/String;Ljava/util/function/Function;Lorg/apache/kafka/queue/EventQueue$Event;)V", arg0, arg1, arg2, arg3); + } + /// + /// + /// + public void Wakeup() + { + IExecuteWithSignature("wakeup", "()V"); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion +} \ No newline at end of file diff --git a/src/net/KNet/Generated/Org/Apache/Kafka/Security/CipherParamsEncoder.cs b/src/net/KNet/Generated/Org/Apache/Kafka/Security/CipherParamsEncoder.cs new file mode 100644 index 000000000..691d63410 --- /dev/null +++ b/src/net/KNet/Generated/Org/Apache/Kafka/Security/CipherParamsEncoder.cs @@ -0,0 +1,142 @@ +/* +* Copyright 2024 MASES s.r.l. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* +* Refer to LICENSE for more information. +*/ + +/* +* This file is generated by MASES.JNetReflector (ver. 2.5.10.0) +* using kafka-server-common-3.9.0.jar as reference +*/ + +using MASES.JCOBridge.C2JBridge; + +namespace Org.Apache.Kafka.Security +{ + #region CipherParamsEncoder declaration + /// + /// + /// + public partial class CipherParamsEncoder : MASES.JCOBridge.C2JBridge.JVMBridgeBase + { + const string _bridgeClassName = "org.apache.kafka.security.CipherParamsEncoder"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + [global::System.Obsolete("CipherParamsEncoder class represents, in .NET, an instance of a JVM interface or abstract class. This public initializer is needed for JCOBridge internal use, other uses can produce unidentible behaviors.")] + public CipherParamsEncoder() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + [global::System.Obsolete("CipherParamsEncoder class represents, in .NET, an instance of a JVM interface or abstract class. This public initializer is needed for JCOBridge internal use, other uses can produce unidentible behaviors.")] + public CipherParamsEncoder(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => true; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => true; + /// + /// + /// + public override bool IsBridgeStatic => false; + + // TODO: complete the class + + } + #endregion + + #region ICipherParamsEncoder + /// + /// .NET interface for TO BE DEFINED FROM USER + /// + public partial interface ICipherParamsEncoder + { + #region Instance methods + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion + + #region CipherParamsEncoder implementation + public partial class CipherParamsEncoder : Org.Apache.Kafka.Security.ICipherParamsEncoder + { + #region Constructors + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + /// + public Java.Security.Spec.AlgorithmParameterSpec ToParameterSpec(Java.Util.Map arg0) + { + return IExecuteWithSignature("toParameterSpec", "(Ljava/util/Map;)Ljava/security/spec/AlgorithmParameterSpec;", arg0); + } + /// + /// + /// + /// + /// + /// + public Java.Util.Map ToMap(Java.Security.AlgorithmParameters arg0) + { + return IExecuteWithSignature>("toMap", "(Ljava/security/AlgorithmParameters;)Ljava/util/Map;", arg0); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion +} \ No newline at end of file diff --git a/src/net/KNet/Generated/Org/Apache/Kafka/Security/EncryptingPasswordEncoder.cs b/src/net/KNet/Generated/Org/Apache/Kafka/Security/EncryptingPasswordEncoder.cs new file mode 100644 index 000000000..09553e913 --- /dev/null +++ b/src/net/KNet/Generated/Org/Apache/Kafka/Security/EncryptingPasswordEncoder.cs @@ -0,0 +1,135 @@ +/* +* Copyright 2024 MASES s.r.l. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* +* Refer to LICENSE for more information. +*/ + +/* +* This file is generated by MASES.JNetReflector (ver. 2.5.10.0) +* using kafka-server-common-3.9.0.jar as reference +*/ + +using MASES.JCOBridge.C2JBridge; + +namespace Org.Apache.Kafka.Security +{ + #region EncryptingPasswordEncoder declaration + /// + /// + /// + public partial class EncryptingPasswordEncoder : Org.Apache.Kafka.Security.PasswordEncoder + { + const string _bridgeClassName = "org.apache.kafka.security.EncryptingPasswordEncoder"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public EncryptingPasswordEncoder() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public EncryptingPasswordEncoder(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => false; + + // TODO: complete the class + + } + #endregion + + #region EncryptingPasswordEncoder implementation + public partial class EncryptingPasswordEncoder + { + #region Constructors + /// + /// + /// + /// + /// + /// + /// + /// + public EncryptingPasswordEncoder(Org.Apache.Kafka.Common.Config.Types.Password arg0, Java.Lang.String arg1, Java.Lang.String arg2, int arg3, int arg4) + : base(arg0, arg1, arg2, arg3, arg4) + { + } + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + /// + /// + public Java.Lang.String Encode(Org.Apache.Kafka.Common.Config.Types.Password arg0) + { + return IExecuteWithSignature("encode", "(Lorg/apache/kafka/common/config/types/Password;)Ljava/lang/String;", arg0); + } + /// + /// + /// + /// + /// + /// + public Org.Apache.Kafka.Common.Config.Types.Password Decode(Java.Lang.String arg0) + { + return IExecuteWithSignature("decode", "(Ljava/lang/String;)Lorg/apache/kafka/common/config/types/Password;", arg0); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion +} \ No newline at end of file diff --git a/src/net/KNet/Generated/Org/Apache/Kafka/Security/GcmParamsEncoder.cs b/src/net/KNet/Generated/Org/Apache/Kafka/Security/GcmParamsEncoder.cs new file mode 100644 index 000000000..a81b8d0ac --- /dev/null +++ b/src/net/KNet/Generated/Org/Apache/Kafka/Security/GcmParamsEncoder.cs @@ -0,0 +1,122 @@ +/* +* Copyright 2024 MASES s.r.l. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* +* Refer to LICENSE for more information. +*/ + +/* +* This file is generated by MASES.JNetReflector (ver. 2.5.10.0) +* using kafka-server-common-3.9.0.jar as reference +*/ + +using MASES.JCOBridge.C2JBridge; + +namespace Org.Apache.Kafka.Security +{ + #region GcmParamsEncoder declaration + /// + /// + /// + public partial class GcmParamsEncoder : Org.Apache.Kafka.Security.CipherParamsEncoder + { + const string _bridgeClassName = "org.apache.kafka.security.GcmParamsEncoder"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public GcmParamsEncoder() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public GcmParamsEncoder(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => false; + + // TODO: complete the class + + } + #endregion + + #region GcmParamsEncoder implementation + public partial class GcmParamsEncoder + { + #region Constructors + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + /// + public Java.Security.Spec.AlgorithmParameterSpec ToParameterSpec(Java.Util.Map arg0) + { + return IExecuteWithSignature("toParameterSpec", "(Ljava/util/Map;)Ljava/security/spec/AlgorithmParameterSpec;", arg0); + } + /// + /// + /// + /// + /// + /// + public Java.Util.Map ToMap(Java.Security.AlgorithmParameters arg0) + { + return IExecuteWithSignature>("toMap", "(Ljava/security/AlgorithmParameters;)Ljava/util/Map;", arg0); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion +} \ No newline at end of file diff --git a/src/net/KNet/Generated/Org/Apache/Kafka/Security/IvParamsEncoder.cs b/src/net/KNet/Generated/Org/Apache/Kafka/Security/IvParamsEncoder.cs new file mode 100644 index 000000000..8f8312b66 --- /dev/null +++ b/src/net/KNet/Generated/Org/Apache/Kafka/Security/IvParamsEncoder.cs @@ -0,0 +1,122 @@ +/* +* Copyright 2024 MASES s.r.l. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* +* Refer to LICENSE for more information. +*/ + +/* +* This file is generated by MASES.JNetReflector (ver. 2.5.10.0) +* using kafka-server-common-3.9.0.jar as reference +*/ + +using MASES.JCOBridge.C2JBridge; + +namespace Org.Apache.Kafka.Security +{ + #region IvParamsEncoder declaration + /// + /// + /// + public partial class IvParamsEncoder : Org.Apache.Kafka.Security.CipherParamsEncoder + { + const string _bridgeClassName = "org.apache.kafka.security.IvParamsEncoder"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public IvParamsEncoder() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public IvParamsEncoder(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => false; + + // TODO: complete the class + + } + #endregion + + #region IvParamsEncoder implementation + public partial class IvParamsEncoder + { + #region Constructors + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + /// + public Java.Security.Spec.AlgorithmParameterSpec ToParameterSpec(Java.Util.Map arg0) + { + return IExecuteWithSignature("toParameterSpec", "(Ljava/util/Map;)Ljava/security/spec/AlgorithmParameterSpec;", arg0); + } + /// + /// + /// + /// + /// + /// + public Java.Util.Map ToMap(Java.Security.AlgorithmParameters arg0) + { + return IExecuteWithSignature>("toMap", "(Ljava/security/AlgorithmParameters;)Ljava/util/Map;", arg0); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion +} \ No newline at end of file diff --git a/src/net/KNet/Generated/Org/Apache/Kafka/Security/PasswordEncoder.cs b/src/net/KNet/Generated/Org/Apache/Kafka/Security/PasswordEncoder.cs new file mode 100644 index 000000000..3c2391274 --- /dev/null +++ b/src/net/KNet/Generated/Org/Apache/Kafka/Security/PasswordEncoder.cs @@ -0,0 +1,228 @@ +/* +* Copyright 2024 MASES s.r.l. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* +* Refer to LICENSE for more information. +*/ + +/* +* This file is generated by MASES.JNetReflector (ver. 2.5.10.0) +* using kafka-server-common-3.9.0.jar as reference +*/ + +using MASES.JCOBridge.C2JBridge; + +namespace Org.Apache.Kafka.Security +{ + #region PasswordEncoder declaration + /// + /// + /// + public partial class PasswordEncoder : MASES.JCOBridge.C2JBridge.JVMBridgeBase + { + const string _bridgeClassName = "org.apache.kafka.security.PasswordEncoder"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + [global::System.Obsolete("PasswordEncoder class represents, in .NET, an instance of a JVM interface or abstract class. This public initializer is needed for JCOBridge internal use, other uses can produce unidentible behaviors.")] + public PasswordEncoder() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + [global::System.Obsolete("PasswordEncoder class represents, in .NET, an instance of a JVM interface or abstract class. This public initializer is needed for JCOBridge internal use, other uses can produce unidentible behaviors.")] + public PasswordEncoder(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => true; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => true; + /// + /// + /// + public override bool IsBridgeStatic => false; + + // TODO: complete the class + + } + #endregion + + #region IPasswordEncoder + /// + /// .NET interface for TO BE DEFINED FROM USER + /// + public partial interface IPasswordEncoder + { + #region Instance methods + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion + + #region PasswordEncoder implementation + public partial class PasswordEncoder : Org.Apache.Kafka.Security.IPasswordEncoder + { + #region Constructors + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + /// + /// + /// + public static Java.Lang.String CIPHER_ALGORITHM { get { if (!_CIPHER_ALGORITHMReady) { _CIPHER_ALGORITHMContent = SGetField(LocalBridgeClazz, "CIPHER_ALGORITHM"); _CIPHER_ALGORITHMReady = true; } return _CIPHER_ALGORITHMContent; } } + private static Java.Lang.String _CIPHER_ALGORITHMContent = default; + private static bool _CIPHER_ALGORITHMReady = false; // this is used because in case of generics + /// + /// + /// + public static Java.Lang.String ENCRYPTED_PASSWORD { get { if (!_ENCRYPTED_PASSWORDReady) { _ENCRYPTED_PASSWORDContent = SGetField(LocalBridgeClazz, "ENCRYPTED_PASSWORD"); _ENCRYPTED_PASSWORDReady = true; } return _ENCRYPTED_PASSWORDContent; } } + private static Java.Lang.String _ENCRYPTED_PASSWORDContent = default; + private static bool _ENCRYPTED_PASSWORDReady = false; // this is used because in case of generics + /// + /// + /// + public static Java.Lang.String INITIALIZATION_VECTOR { get { if (!_INITIALIZATION_VECTORReady) { _INITIALIZATION_VECTORContent = SGetField(LocalBridgeClazz, "INITIALIZATION_VECTOR"); _INITIALIZATION_VECTORReady = true; } return _INITIALIZATION_VECTORContent; } } + private static Java.Lang.String _INITIALIZATION_VECTORContent = default; + private static bool _INITIALIZATION_VECTORReady = false; // this is used because in case of generics + /// + /// + /// + public static Java.Lang.String ITERATIONS { get { if (!_ITERATIONSReady) { _ITERATIONSContent = SGetField(LocalBridgeClazz, "ITERATIONS"); _ITERATIONSReady = true; } return _ITERATIONSContent; } } + private static Java.Lang.String _ITERATIONSContent = default; + private static bool _ITERATIONSReady = false; // this is used because in case of generics + /// + /// + /// + public static Java.Lang.String KEY_FACTORY_ALGORITHM { get { if (!_KEY_FACTORY_ALGORITHMReady) { _KEY_FACTORY_ALGORITHMContent = SGetField(LocalBridgeClazz, "KEY_FACTORY_ALGORITHM"); _KEY_FACTORY_ALGORITHMReady = true; } return _KEY_FACTORY_ALGORITHMContent; } } + private static Java.Lang.String _KEY_FACTORY_ALGORITHMContent = default; + private static bool _KEY_FACTORY_ALGORITHMReady = false; // this is used because in case of generics + /// + /// + /// + public static Java.Lang.String KEY_LENGTH { get { if (!_KEY_LENGTHReady) { _KEY_LENGTHContent = SGetField(LocalBridgeClazz, "KEY_LENGTH"); _KEY_LENGTHReady = true; } return _KEY_LENGTHContent; } } + private static Java.Lang.String _KEY_LENGTHContent = default; + private static bool _KEY_LENGTHReady = false; // this is used because in case of generics + /// + /// + /// + public static Java.Lang.String PASSWORD_LENGTH { get { if (!_PASSWORD_LENGTHReady) { _PASSWORD_LENGTHContent = SGetField(LocalBridgeClazz, "PASSWORD_LENGTH"); _PASSWORD_LENGTHReady = true; } return _PASSWORD_LENGTHContent; } } + private static Java.Lang.String _PASSWORD_LENGTHContent = default; + private static bool _PASSWORD_LENGTHReady = false; // this is used because in case of generics + /// + /// + /// + public static Java.Lang.String SALT { get { if (!_SALTReady) { _SALTContent = SGetField(LocalBridgeClazz, "SALT"); _SALTReady = true; } return _SALTContent; } } + private static Java.Lang.String _SALTContent = default; + private static bool _SALTReady = false; // this is used because in case of generics + /// + /// + /// + public static Org.Apache.Kafka.Security.PasswordEncoder NOOP { get { if (!_NOOPReady) { _NOOPContent = SGetField(LocalBridgeClazz, "NOOP"); _NOOPReady = true; } return _NOOPContent; } } + private static Org.Apache.Kafka.Security.PasswordEncoder _NOOPContent = default; + private static bool _NOOPReady = false; // this is used because in case of generics + + #endregion + + #region Static methods + /// + /// + /// + /// + /// + public static byte[] Base64Decode(Java.Lang.String arg0) + { + return SExecuteWithSignatureArray(LocalBridgeClazz, "base64Decode", "(Ljava/lang/String;)[B", arg0); + } + /// + /// + /// + /// + /// + public static Java.Lang.String Base64Encode(byte[] arg0) + { + return SExecuteWithSignature(LocalBridgeClazz, "base64Encode", "([B)Ljava/lang/String;", new object[] { arg0 }); + } + /// + /// + /// + /// + /// + /// + /// + /// + /// + public static Org.Apache.Kafka.Security.EncryptingPasswordEncoder Encrypting(Org.Apache.Kafka.Common.Config.Types.Password arg0, Java.Lang.String arg1, Java.Lang.String arg2, int arg3, int arg4) + { + return SExecuteWithSignature(LocalBridgeClazz, "encrypting", "(Lorg/apache/kafka/common/config/types/Password;Ljava/lang/String;Ljava/lang/String;II)Lorg/apache/kafka/security/EncryptingPasswordEncoder;", arg0, arg1, arg2, arg3, arg4); + } + + #endregion + + #region Instance methods + /// + /// + /// + /// + /// + /// + public Java.Lang.String Encode(Org.Apache.Kafka.Common.Config.Types.Password arg0) + { + return IExecuteWithSignature("encode", "(Lorg/apache/kafka/common/config/types/Password;)Ljava/lang/String;", arg0); + } + /// + /// + /// + /// + /// + /// + public Org.Apache.Kafka.Common.Config.Types.Password Decode(Java.Lang.String arg0) + { + return IExecuteWithSignature("decode", "(Ljava/lang/String;)Lorg/apache/kafka/common/config/types/Password;", arg0); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion +} \ No newline at end of file diff --git a/src/net/KNet/Generated/Org/Apache/Kafka/Security/PasswordEncoderConfigs.cs b/src/net/KNet/Generated/Org/Apache/Kafka/Security/PasswordEncoderConfigs.cs new file mode 100644 index 000000000..042e27c71 --- /dev/null +++ b/src/net/KNet/Generated/Org/Apache/Kafka/Security/PasswordEncoderConfigs.cs @@ -0,0 +1,199 @@ +/* +* Copyright 2024 MASES s.r.l. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* +* Refer to LICENSE for more information. +*/ + +/* +* This file is generated by MASES.JNetReflector (ver. 2.5.10.0) +* using kafka-server-common-3.9.0.jar as reference +*/ + +using MASES.JCOBridge.C2JBridge; + +namespace Org.Apache.Kafka.Security +{ + #region PasswordEncoderConfigs declaration + /// + /// + /// + public partial class PasswordEncoderConfigs : MASES.JCOBridge.C2JBridge.JVMBridgeBase + { + const string _bridgeClassName = "org.apache.kafka.security.PasswordEncoderConfigs"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public PasswordEncoderConfigs() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public PasswordEncoderConfigs(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => false; + + // TODO: complete the class + + } + #endregion + + #region PasswordEncoderConfigs implementation + public partial class PasswordEncoderConfigs + { + #region Constructors + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + /// + /// + /// + public static int PASSWORD_ENCODER_ITERATIONS_DEFAULT { get { if (!_PASSWORD_ENCODER_ITERATIONS_DEFAULTReady) { _PASSWORD_ENCODER_ITERATIONS_DEFAULTContent = SGetField(LocalBridgeClazz, "PASSWORD_ENCODER_ITERATIONS_DEFAULT"); _PASSWORD_ENCODER_ITERATIONS_DEFAULTReady = true; } return _PASSWORD_ENCODER_ITERATIONS_DEFAULTContent; } } + private static int _PASSWORD_ENCODER_ITERATIONS_DEFAULTContent = default; + private static bool _PASSWORD_ENCODER_ITERATIONS_DEFAULTReady = false; // this is used because in case of generics + /// + /// + /// + public static int PASSWORD_ENCODER_KEY_LENGTH_DEFAULT { get { if (!_PASSWORD_ENCODER_KEY_LENGTH_DEFAULTReady) { _PASSWORD_ENCODER_KEY_LENGTH_DEFAULTContent = SGetField(LocalBridgeClazz, "PASSWORD_ENCODER_KEY_LENGTH_DEFAULT"); _PASSWORD_ENCODER_KEY_LENGTH_DEFAULTReady = true; } return _PASSWORD_ENCODER_KEY_LENGTH_DEFAULTContent; } } + private static int _PASSWORD_ENCODER_KEY_LENGTH_DEFAULTContent = default; + private static bool _PASSWORD_ENCODER_KEY_LENGTH_DEFAULTReady = false; // this is used because in case of generics + /// + /// + /// + public static Java.Lang.String PASSWORD_ENCODER_CIPHER_ALGORITHM_CONFIG { get { if (!_PASSWORD_ENCODER_CIPHER_ALGORITHM_CONFIGReady) { _PASSWORD_ENCODER_CIPHER_ALGORITHM_CONFIGContent = SGetField(LocalBridgeClazz, "PASSWORD_ENCODER_CIPHER_ALGORITHM_CONFIG"); _PASSWORD_ENCODER_CIPHER_ALGORITHM_CONFIGReady = true; } return _PASSWORD_ENCODER_CIPHER_ALGORITHM_CONFIGContent; } } + private static Java.Lang.String _PASSWORD_ENCODER_CIPHER_ALGORITHM_CONFIGContent = default; + private static bool _PASSWORD_ENCODER_CIPHER_ALGORITHM_CONFIGReady = false; // this is used because in case of generics + /// + /// + /// + public static Java.Lang.String PASSWORD_ENCODER_CIPHER_ALGORITHM_DEFAULT { get { if (!_PASSWORD_ENCODER_CIPHER_ALGORITHM_DEFAULTReady) { _PASSWORD_ENCODER_CIPHER_ALGORITHM_DEFAULTContent = SGetField(LocalBridgeClazz, "PASSWORD_ENCODER_CIPHER_ALGORITHM_DEFAULT"); _PASSWORD_ENCODER_CIPHER_ALGORITHM_DEFAULTReady = true; } return _PASSWORD_ENCODER_CIPHER_ALGORITHM_DEFAULTContent; } } + private static Java.Lang.String _PASSWORD_ENCODER_CIPHER_ALGORITHM_DEFAULTContent = default; + private static bool _PASSWORD_ENCODER_CIPHER_ALGORITHM_DEFAULTReady = false; // this is used because in case of generics + /// + /// + /// + public static Java.Lang.String PASSWORD_ENCODER_CIPHER_ALGORITHM_DOC { get { if (!_PASSWORD_ENCODER_CIPHER_ALGORITHM_DOCReady) { _PASSWORD_ENCODER_CIPHER_ALGORITHM_DOCContent = SGetField(LocalBridgeClazz, "PASSWORD_ENCODER_CIPHER_ALGORITHM_DOC"); _PASSWORD_ENCODER_CIPHER_ALGORITHM_DOCReady = true; } return _PASSWORD_ENCODER_CIPHER_ALGORITHM_DOCContent; } } + private static Java.Lang.String _PASSWORD_ENCODER_CIPHER_ALGORITHM_DOCContent = default; + private static bool _PASSWORD_ENCODER_CIPHER_ALGORITHM_DOCReady = false; // this is used because in case of generics + /// + /// + /// + public static Java.Lang.String PASSWORD_ENCODER_ITERATIONS_CONFIG { get { if (!_PASSWORD_ENCODER_ITERATIONS_CONFIGReady) { _PASSWORD_ENCODER_ITERATIONS_CONFIGContent = SGetField(LocalBridgeClazz, "PASSWORD_ENCODER_ITERATIONS_CONFIG"); _PASSWORD_ENCODER_ITERATIONS_CONFIGReady = true; } return _PASSWORD_ENCODER_ITERATIONS_CONFIGContent; } } + private static Java.Lang.String _PASSWORD_ENCODER_ITERATIONS_CONFIGContent = default; + private static bool _PASSWORD_ENCODER_ITERATIONS_CONFIGReady = false; // this is used because in case of generics + /// + /// + /// + public static Java.Lang.String PASSWORD_ENCODER_ITERATIONS_DOC { get { if (!_PASSWORD_ENCODER_ITERATIONS_DOCReady) { _PASSWORD_ENCODER_ITERATIONS_DOCContent = SGetField(LocalBridgeClazz, "PASSWORD_ENCODER_ITERATIONS_DOC"); _PASSWORD_ENCODER_ITERATIONS_DOCReady = true; } return _PASSWORD_ENCODER_ITERATIONS_DOCContent; } } + private static Java.Lang.String _PASSWORD_ENCODER_ITERATIONS_DOCContent = default; + private static bool _PASSWORD_ENCODER_ITERATIONS_DOCReady = false; // this is used because in case of generics + /// + /// + /// + public static Java.Lang.String PASSWORD_ENCODER_KEY_LENGTH_CONFIG { get { if (!_PASSWORD_ENCODER_KEY_LENGTH_CONFIGReady) { _PASSWORD_ENCODER_KEY_LENGTH_CONFIGContent = SGetField(LocalBridgeClazz, "PASSWORD_ENCODER_KEY_LENGTH_CONFIG"); _PASSWORD_ENCODER_KEY_LENGTH_CONFIGReady = true; } return _PASSWORD_ENCODER_KEY_LENGTH_CONFIGContent; } } + private static Java.Lang.String _PASSWORD_ENCODER_KEY_LENGTH_CONFIGContent = default; + private static bool _PASSWORD_ENCODER_KEY_LENGTH_CONFIGReady = false; // this is used because in case of generics + /// + /// + /// + public static Java.Lang.String PASSWORD_ENCODER_KEY_LENGTH_DOC { get { if (!_PASSWORD_ENCODER_KEY_LENGTH_DOCReady) { _PASSWORD_ENCODER_KEY_LENGTH_DOCContent = SGetField(LocalBridgeClazz, "PASSWORD_ENCODER_KEY_LENGTH_DOC"); _PASSWORD_ENCODER_KEY_LENGTH_DOCReady = true; } return _PASSWORD_ENCODER_KEY_LENGTH_DOCContent; } } + private static Java.Lang.String _PASSWORD_ENCODER_KEY_LENGTH_DOCContent = default; + private static bool _PASSWORD_ENCODER_KEY_LENGTH_DOCReady = false; // this is used because in case of generics + /// + /// + /// + public static Java.Lang.String PASSWORD_ENCODER_KEYFACTORY_ALGORITHM_CONFIG { get { if (!_PASSWORD_ENCODER_KEYFACTORY_ALGORITHM_CONFIGReady) { _PASSWORD_ENCODER_KEYFACTORY_ALGORITHM_CONFIGContent = SGetField(LocalBridgeClazz, "PASSWORD_ENCODER_KEYFACTORY_ALGORITHM_CONFIG"); _PASSWORD_ENCODER_KEYFACTORY_ALGORITHM_CONFIGReady = true; } return _PASSWORD_ENCODER_KEYFACTORY_ALGORITHM_CONFIGContent; } } + private static Java.Lang.String _PASSWORD_ENCODER_KEYFACTORY_ALGORITHM_CONFIGContent = default; + private static bool _PASSWORD_ENCODER_KEYFACTORY_ALGORITHM_CONFIGReady = false; // this is used because in case of generics + /// + /// + /// + public static Java.Lang.String PASSWORD_ENCODER_KEYFACTORY_ALGORITHM_DOC { get { if (!_PASSWORD_ENCODER_KEYFACTORY_ALGORITHM_DOCReady) { _PASSWORD_ENCODER_KEYFACTORY_ALGORITHM_DOCContent = SGetField(LocalBridgeClazz, "PASSWORD_ENCODER_KEYFACTORY_ALGORITHM_DOC"); _PASSWORD_ENCODER_KEYFACTORY_ALGORITHM_DOCReady = true; } return _PASSWORD_ENCODER_KEYFACTORY_ALGORITHM_DOCContent; } } + private static Java.Lang.String _PASSWORD_ENCODER_KEYFACTORY_ALGORITHM_DOCContent = default; + private static bool _PASSWORD_ENCODER_KEYFACTORY_ALGORITHM_DOCReady = false; // this is used because in case of generics + /// + /// + /// + public static Java.Lang.String PASSWORD_ENCODER_OLD_SECRET_CONFIG { get { if (!_PASSWORD_ENCODER_OLD_SECRET_CONFIGReady) { _PASSWORD_ENCODER_OLD_SECRET_CONFIGContent = SGetField(LocalBridgeClazz, "PASSWORD_ENCODER_OLD_SECRET_CONFIG"); _PASSWORD_ENCODER_OLD_SECRET_CONFIGReady = true; } return _PASSWORD_ENCODER_OLD_SECRET_CONFIGContent; } } + private static Java.Lang.String _PASSWORD_ENCODER_OLD_SECRET_CONFIGContent = default; + private static bool _PASSWORD_ENCODER_OLD_SECRET_CONFIGReady = false; // this is used because in case of generics + /// + /// + /// + public static Java.Lang.String PASSWORD_ENCODER_OLD_SECRET_DOC { get { if (!_PASSWORD_ENCODER_OLD_SECRET_DOCReady) { _PASSWORD_ENCODER_OLD_SECRET_DOCContent = SGetField(LocalBridgeClazz, "PASSWORD_ENCODER_OLD_SECRET_DOC"); _PASSWORD_ENCODER_OLD_SECRET_DOCReady = true; } return _PASSWORD_ENCODER_OLD_SECRET_DOCContent; } } + private static Java.Lang.String _PASSWORD_ENCODER_OLD_SECRET_DOCContent = default; + private static bool _PASSWORD_ENCODER_OLD_SECRET_DOCReady = false; // this is used because in case of generics + /// + /// + /// + public static Java.Lang.String PASSWORD_ENCODER_SECRET_CONFIG { get { if (!_PASSWORD_ENCODER_SECRET_CONFIGReady) { _PASSWORD_ENCODER_SECRET_CONFIGContent = SGetField(LocalBridgeClazz, "PASSWORD_ENCODER_SECRET_CONFIG"); _PASSWORD_ENCODER_SECRET_CONFIGReady = true; } return _PASSWORD_ENCODER_SECRET_CONFIGContent; } } + private static Java.Lang.String _PASSWORD_ENCODER_SECRET_CONFIGContent = default; + private static bool _PASSWORD_ENCODER_SECRET_CONFIGReady = false; // this is used because in case of generics + /// + /// + /// + public static Java.Lang.String PASSWORD_ENCODER_SECRET_DOC { get { if (!_PASSWORD_ENCODER_SECRET_DOCReady) { _PASSWORD_ENCODER_SECRET_DOCContent = SGetField(LocalBridgeClazz, "PASSWORD_ENCODER_SECRET_DOC"); _PASSWORD_ENCODER_SECRET_DOCReady = true; } return _PASSWORD_ENCODER_SECRET_DOCContent; } } + private static Java.Lang.String _PASSWORD_ENCODER_SECRET_DOCContent = default; + private static bool _PASSWORD_ENCODER_SECRET_DOCReady = false; // this is used because in case of generics + /// + /// + /// + public static Org.Apache.Kafka.Common.Config.ConfigDef CONFIG_DEF { get { if (!_CONFIG_DEFReady) { _CONFIG_DEFContent = SGetField(LocalBridgeClazz, "CONFIG_DEF"); _CONFIG_DEFReady = true; } return _CONFIG_DEFContent; } } + private static Org.Apache.Kafka.Common.Config.ConfigDef _CONFIG_DEFContent = default; + private static bool _CONFIG_DEFReady = false; // this is used because in case of generics + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion +} \ No newline at end of file diff --git a/src/net/KNet/Generated/Org/Apache/Kafka/Timeline/SnapshotRegistry.cs b/src/net/KNet/Generated/Org/Apache/Kafka/Timeline/SnapshotRegistry.cs new file mode 100644 index 000000000..a425cafff --- /dev/null +++ b/src/net/KNet/Generated/Org/Apache/Kafka/Timeline/SnapshotRegistry.cs @@ -0,0 +1,198 @@ +/* +* Copyright 2024 MASES s.r.l. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* +* Refer to LICENSE for more information. +*/ + +/* +* This file is generated by MASES.JNetReflector (ver. 2.5.10.0) +* using kafka-server-common-3.9.0.jar as reference +*/ + +using MASES.JCOBridge.C2JBridge; + +namespace Org.Apache.Kafka.Timeline +{ + #region SnapshotRegistry declaration + /// + /// + /// + public partial class SnapshotRegistry : MASES.JCOBridge.C2JBridge.JVMBridgeBase + { + const string _bridgeClassName = "org.apache.kafka.timeline.SnapshotRegistry"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public SnapshotRegistry() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public SnapshotRegistry(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => false; + + // TODO: complete the class + + } + #endregion + + #region SnapshotRegistry implementation + public partial class SnapshotRegistry + { + #region Constructors + /// + /// + /// + /// + public SnapshotRegistry(Org.Apache.Kafka.Common.Utils.LogContext arg0) + : base(arg0) + { + } + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + /// + /// + /// + public static long LATEST_EPOCH { get { if (!_LATEST_EPOCHReady) { _LATEST_EPOCHContent = SGetField(LocalBridgeClazz, "LATEST_EPOCH"); _LATEST_EPOCHReady = true; } return _LATEST_EPOCHContent; } } + private static long _LATEST_EPOCHContent = default; + private static bool _LATEST_EPOCHReady = false; // this is used because in case of generics + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + /// + public bool HasSnapshot(long arg0) + { + return IExecuteWithSignature("hasSnapshot", "(J)Z", arg0); + } + /// + /// + /// + /// + public Java.Util.Iterator Iterator() + { + return IExecuteWithSignature>("iterator", "()Ljava/util/Iterator;"); + } + /// + /// + /// + /// + /// + public Java.Util.Iterator Iterator(long arg0) + { + return IExecuteWithSignature>("iterator", "(J)Ljava/util/Iterator;", arg0); + } + /// + /// + /// + /// + public Java.Util.Iterator ReverseIterator() + { + return IExecuteWithSignature>("reverseIterator", "()Ljava/util/Iterator;"); + } + /// + /// + /// + /// + public Java.Util.List EpochsList() + { + return IExecuteWithSignature>("epochsList", "()Ljava/util/List;"); + } + /// + /// + /// + /// + public long LatestEpoch() + { + return IExecuteWithSignature("latestEpoch", "()J"); + } + /// + /// + /// + /// + public void DeleteSnapshot(long arg0) + { + IExecuteWithSignature("deleteSnapshot", "(J)V", arg0); + } + /// + /// + /// + /// + public void DeleteSnapshotsUpTo(long arg0) + { + IExecuteWithSignature("deleteSnapshotsUpTo", "(J)V", arg0); + } + /// + /// + /// + public void Reset() + { + IExecuteWithSignature("reset", "()V"); + } + /// + /// + /// + /// + public void RevertToSnapshot(long arg0) + { + IExecuteWithSignature("revertToSnapshot", "(J)V", arg0); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion +} \ No newline at end of file diff --git a/src/net/KNet/Generated/Org/Apache/Kafka/Timeline/TimelineHashMap.cs b/src/net/KNet/Generated/Org/Apache/Kafka/Timeline/TimelineHashMap.cs new file mode 100644 index 000000000..937d3a608 --- /dev/null +++ b/src/net/KNet/Generated/Org/Apache/Kafka/Timeline/TimelineHashMap.cs @@ -0,0 +1,537 @@ +/* +* Copyright 2024 MASES s.r.l. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* +* Refer to LICENSE for more information. +*/ + +/* +* This file is generated by MASES.JNetReflector (ver. 2.5.10.0) +* using kafka-server-common-3.9.0.jar as reference +*/ + +using MASES.JCOBridge.C2JBridge; + +namespace Org.Apache.Kafka.Timeline +{ + #region TimelineHashMap declaration + /// + /// + /// + public partial class TimelineHashMap : Java.Util.Map + { + const string _bridgeClassName = "org.apache.kafka.timeline.TimelineHashMap"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public TimelineHashMap() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public TimelineHashMap(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => false; + + // TODO: complete the class + + } + #endregion + + #region TimelineHashMap declaration + /// + /// + /// + /// + /// + public partial class TimelineHashMap : Java.Util.Map + { + const string _bridgeClassName = "org.apache.kafka.timeline.TimelineHashMap"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public TimelineHashMap() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public TimelineHashMap(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => false; + + // TODO: complete the class + + } + #endregion + + #region TimelineHashMap implementation + public partial class TimelineHashMap + { + #region Constructors + /// + /// + /// + /// + /// + public TimelineHashMap(Org.Apache.Kafka.Timeline.SnapshotRegistry arg0, int arg1) + : base(arg0, arg1) + { + } + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + /// + /// + public bool ContainsKey(object arg0, long arg1) + { + return IExecuteWithSignature("containsKey", "(Ljava/lang/Object;J)Z", arg0, arg1); + } + /// + /// + /// + /// + /// + public bool ContainsKey(object arg0) + { + return IExecuteWithSignature("containsKey", "(Ljava/lang/Object;)Z", arg0); + } + /// + /// + /// + /// + /// + public bool ContainsValue(object arg0) + { + return IExecuteWithSignature("containsValue", "(Ljava/lang/Object;)Z", arg0); + } + /// + /// + /// + /// + public bool IsEmpty() + { + return IExecuteWithSignature("isEmpty", "()Z"); + } + /// + /// + /// + /// + /// + public bool IsEmpty(long arg0) + { + return IExecuteWithSignature("isEmpty", "(J)Z", arg0); + } + /// + /// + /// + /// + public int Size() + { + return IExecuteWithSignature("size", "()I"); + } + /// + /// + /// + /// + /// + public int Size(long arg0) + { + return IExecuteWithSignature("size", "(J)I", arg0); + } + /// + /// + /// + /// + public Java.Util.Collection ValuesMethod() + { + return IExecuteWithSignature("values", "()Ljava/util/Collection;"); + } + /// + /// + /// + /// + /// + public Java.Util.Collection ValuesMethod(long arg0) + { + return IExecuteWithSignature("values", "(J)Ljava/util/Collection;", arg0); + } + /// + /// + /// + /// + public Java.Util.Set EntrySetMethod() + { + return IExecuteWithSignature("entrySet", "()Ljava/util/Set;"); + } + /// + /// + /// + /// + /// + public Java.Util.Set EntrySetMethod(long arg0) + { + return IExecuteWithSignature("entrySet", "(J)Ljava/util/Set;", arg0); + } + /// + /// + /// + /// + public Java.Util.Set KeySetMethod() + { + return IExecuteWithSignature("keySet", "()Ljava/util/Set;"); + } + /// + /// + /// + /// + /// + public Java.Util.Set KeySetMethod(long arg0) + { + return IExecuteWithSignature("keySet", "(J)Ljava/util/Set;", arg0); + } + /// + /// + /// + /// + /// + /// + public object Get(object arg0, long arg1) + { + return IExecuteWithSignature("get", "(Ljava/lang/Object;J)Ljava/lang/Object;", arg0, arg1); + } + /// + /// + /// + /// + /// + public object Get(object arg0) + { + return IExecuteWithSignature("get", "(Ljava/lang/Object;)Ljava/lang/Object;", arg0); + } + /// + /// + /// + /// + /// + /// + public object Put(object arg0, object arg1) + { + return IExecuteWithSignature("put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", arg0, arg1); + } + /// + /// + /// + /// + /// + public object Remove(object arg0) + { + return IExecuteWithSignature("remove", "(Ljava/lang/Object;)Ljava/lang/Object;", arg0); + } + /// + /// + /// + public void Clear() + { + IExecuteWithSignature("clear", "()V"); + } + /// + /// + /// + /// + public void PutAll(Java.Util.Map arg0) + { + IExecuteWithSignature("putAll", "(Ljava/util/Map;)V", arg0); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion + + #region TimelineHashMap implementation + public partial class TimelineHashMap + { + #region Constructors + /// + /// + /// + /// + /// + public TimelineHashMap(Org.Apache.Kafka.Timeline.SnapshotRegistry arg0, int arg1) + : base(arg0, arg1) + { + } + + #endregion + + #region Class/Interface conversion operators + /// + /// Converter from to + /// + public static implicit operator Org.Apache.Kafka.Timeline.TimelineHashMap(Org.Apache.Kafka.Timeline.TimelineHashMap t) => t.Cast(); + + #endregion + + #region Fields + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + /// + /// + public bool ContainsKey(object arg0, long arg1) + { + return IExecuteWithSignature("containsKey", "(Ljava/lang/Object;J)Z", arg0, arg1); + } + /// + /// + /// + /// + /// + public bool ContainsKey(object arg0) + { + return IExecuteWithSignature("containsKey", "(Ljava/lang/Object;)Z", arg0); + } + /// + /// + /// + /// + /// + public bool ContainsValue(object arg0) + { + return IExecuteWithSignature("containsValue", "(Ljava/lang/Object;)Z", arg0); + } + /// + /// + /// + /// + public bool IsEmpty() + { + return IExecuteWithSignature("isEmpty", "()Z"); + } + /// + /// + /// + /// + /// + public bool IsEmpty(long arg0) + { + return IExecuteWithSignature("isEmpty", "(J)Z", arg0); + } + /// + /// + /// + /// + public int Size() + { + return IExecuteWithSignature("size", "()I"); + } + /// + /// + /// + /// + /// + public int Size(long arg0) + { + return IExecuteWithSignature("size", "(J)I", arg0); + } + /// + /// + /// + /// + public Java.Util.Collection ValuesMethod() + { + return IExecuteWithSignature>("values", "()Ljava/util/Collection;"); + } + /// + /// + /// + /// + /// + public Java.Util.Collection ValuesMethod(long arg0) + { + return IExecuteWithSignature>("values", "(J)Ljava/util/Collection;", arg0); + } + /// + /// + /// + /// + public Java.Util.Set> EntrySetMethod() + { + return IExecuteWithSignature>>("entrySet", "()Ljava/util/Set;"); + } + /// + /// + /// + /// + /// + public Java.Util.Set> EntrySetMethod(long arg0) + { + return IExecuteWithSignature>>("entrySet", "(J)Ljava/util/Set;", arg0); + } + /// + /// + /// + /// + public Java.Util.Set KeySetMethod() + { + return IExecuteWithSignature>("keySet", "()Ljava/util/Set;"); + } + /// + /// + /// + /// + /// + public Java.Util.Set KeySetMethod(long arg0) + { + return IExecuteWithSignature>("keySet", "(J)Ljava/util/Set;", arg0); + } + /// + /// + /// + /// + /// + /// + public V Get(object arg0, long arg1) + { + return IExecuteWithSignature("get", "(Ljava/lang/Object;J)Ljava/lang/Object;", arg0, arg1); + } + /// + /// + /// + /// + /// + public V Get(object arg0) + { + return IExecuteWithSignature("get", "(Ljava/lang/Object;)Ljava/lang/Object;", arg0); + } + /// + /// + /// + /// + /// + /// + public V Put(K arg0, V arg1) + { + return IExecuteWithSignature("put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", arg0, arg1); + } + /// + /// + /// + /// + /// + public V Remove(object arg0) + { + return IExecuteWithSignature("remove", "(Ljava/lang/Object;)Ljava/lang/Object;", arg0); + } + /// + /// + /// + public void Clear() + { + IExecuteWithSignature("clear", "()V"); + } + /// + /// + /// + /// + /// + /// + public void PutAll(Java.Util.Map arg0) where Arg0ExtendsK : K where Arg0ExtendsV : V + { + IExecuteWithSignature("putAll", "(Ljava/util/Map;)V", arg0); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion +} \ No newline at end of file diff --git a/src/net/KNet/Generated/Org/Apache/Kafka/Timeline/TimelineHashSet.cs b/src/net/KNet/Generated/Org/Apache/Kafka/Timeline/TimelineHashSet.cs new file mode 100644 index 000000000..b836ae070 --- /dev/null +++ b/src/net/KNet/Generated/Org/Apache/Kafka/Timeline/TimelineHashSet.cs @@ -0,0 +1,500 @@ +/* +* Copyright 2024 MASES s.r.l. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* +* Refer to LICENSE for more information. +*/ + +/* +* This file is generated by MASES.JNetReflector (ver. 2.5.10.0) +* using kafka-server-common-3.9.0.jar as reference +*/ + +using MASES.JCOBridge.C2JBridge; + +namespace Org.Apache.Kafka.Timeline +{ + #region TimelineHashSet declaration + /// + /// + /// + public partial class TimelineHashSet : Java.Util.Set + { + const string _bridgeClassName = "org.apache.kafka.timeline.TimelineHashSet"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public TimelineHashSet() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public TimelineHashSet(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => false; + + // TODO: complete the class + + } + #endregion + + #region TimelineHashSet declaration + /// + /// + /// + /// + public partial class TimelineHashSet : Java.Util.Set + { + const string _bridgeClassName = "org.apache.kafka.timeline.TimelineHashSet"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public TimelineHashSet() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public TimelineHashSet(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => false; + + // TODO: complete the class + + } + #endregion + + #region TimelineHashSet implementation + public partial class TimelineHashSet + { + #region Constructors + /// + /// + /// + /// + /// + public TimelineHashSet(Org.Apache.Kafka.Timeline.SnapshotRegistry arg0, int arg1) + : base(arg0, arg1) + { + } + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + /// + public object[] ToArray(object[] arg0) + { + return IExecuteWithSignatureArray("toArray", "([Ljava/lang/Object;)[Ljava/lang/Object;", new object[] { arg0 }); + } + /// + /// + /// + /// + /// + public bool Add(object arg0) + { + return IExecuteWithSignature("add", "(Ljava/lang/Object;)Z", arg0); + } + /// + /// + /// + /// + /// + public bool AddAll(Java.Util.Collection arg0) + { + return IExecuteWithSignature("addAll", "(Ljava/util/Collection;)Z", arg0); + } + /// + /// + /// + /// + /// + /// + public bool Contains(object arg0, long arg1) + { + return IExecuteWithSignature("contains", "(Ljava/lang/Object;J)Z", arg0, arg1); + } + /// + /// + /// + /// + /// + public bool Contains(object arg0) + { + return IExecuteWithSignature("contains", "(Ljava/lang/Object;)Z", arg0); + } + /// + /// + /// + /// + /// + public bool ContainsAll(Java.Util.Collection arg0) + { + return IExecuteWithSignature("containsAll", "(Ljava/util/Collection;)Z", arg0); + } + /// + /// + /// + /// + public bool IsEmpty() + { + return IExecuteWithSignature("isEmpty", "()Z"); + } + /// + /// + /// + /// + /// + public bool IsEmpty(long arg0) + { + return IExecuteWithSignature("isEmpty", "(J)Z", arg0); + } + /// + /// + /// + /// + /// + public bool Remove(object arg0) + { + return IExecuteWithSignature("remove", "(Ljava/lang/Object;)Z", arg0); + } + /// + /// + /// + /// + /// + public bool RemoveAll(Java.Util.Collection arg0) + { + return IExecuteWithSignature("removeAll", "(Ljava/util/Collection;)Z", arg0); + } + /// + /// + /// + /// + /// + public bool RetainAll(Java.Util.Collection arg0) + { + return IExecuteWithSignature("retainAll", "(Ljava/util/Collection;)Z", arg0); + } + /// + /// + /// + /// + public int Size() + { + return IExecuteWithSignature("size", "()I"); + } + /// + /// + /// + /// + /// + public int Size(long arg0) + { + return IExecuteWithSignature("size", "(J)I", arg0); + } + /// + /// + /// + /// + public object[] ToArray() + { + return IExecuteWithSignatureArray("toArray", "()[Ljava/lang/Object;"); + } + /// + /// + /// + /// + public Java.Util.Iterator Iterator() + { + return IExecuteWithSignature("iterator", "()Ljava/util/Iterator;"); + } + /// + /// + /// + /// + /// + public Java.Util.Iterator Iterator(long arg0) + { + return IExecuteWithSignature("iterator", "(J)Ljava/util/Iterator;", arg0); + } + /// + /// + /// + public void Clear() + { + IExecuteWithSignature("clear", "()V"); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion + + #region TimelineHashSet implementation + public partial class TimelineHashSet + { + #region Constructors + /// + /// + /// + /// + /// + public TimelineHashSet(Org.Apache.Kafka.Timeline.SnapshotRegistry arg0, int arg1) + : base(arg0, arg1) + { + } + + #endregion + + #region Class/Interface conversion operators + /// + /// Converter from to + /// + public static implicit operator Org.Apache.Kafka.Timeline.TimelineHashSet(Org.Apache.Kafka.Timeline.TimelineHashSet t) => t.Cast(); + + #endregion + + #region Fields + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + /// + /// + public R[] ToArray(R[] arg0) + { + return IExecuteWithSignatureArray("toArray", "([Ljava/lang/Object;)[Ljava/lang/Object;", new object[] { arg0 }); + } + /// + /// + /// + /// + /// + public bool Add(T arg0) + { + return IExecuteWithSignature("add", "(Ljava/lang/Object;)Z", arg0); + } + /// + /// + /// + /// + /// + /// + public bool AddAll(Java.Util.Collection arg0) where Arg0ExtendsT : T + { + return IExecuteWithSignature("addAll", "(Ljava/util/Collection;)Z", arg0); + } + /// + /// + /// + /// + /// + /// + public bool Contains(object arg0, long arg1) + { + return IExecuteWithSignature("contains", "(Ljava/lang/Object;J)Z", arg0, arg1); + } + /// + /// + /// + /// + /// + public bool Contains(object arg0) + { + return IExecuteWithSignature("contains", "(Ljava/lang/Object;)Z", arg0); + } + /// + /// + /// + /// + /// + public bool ContainsAll(Java.Util.Collection arg0) + { + return IExecuteWithSignature("containsAll", "(Ljava/util/Collection;)Z", arg0); + } + /// + /// + /// + /// + public bool IsEmpty() + { + return IExecuteWithSignature("isEmpty", "()Z"); + } + /// + /// + /// + /// + /// + public bool IsEmpty(long arg0) + { + return IExecuteWithSignature("isEmpty", "(J)Z", arg0); + } + /// + /// + /// + /// + /// + public bool Remove(object arg0) + { + return IExecuteWithSignature("remove", "(Ljava/lang/Object;)Z", arg0); + } + /// + /// + /// + /// + /// + public bool RemoveAll(Java.Util.Collection arg0) + { + return IExecuteWithSignature("removeAll", "(Ljava/util/Collection;)Z", arg0); + } + /// + /// + /// + /// + /// + public bool RetainAll(Java.Util.Collection arg0) + { + return IExecuteWithSignature("retainAll", "(Ljava/util/Collection;)Z", arg0); + } + /// + /// + /// + /// + public int Size() + { + return IExecuteWithSignature("size", "()I"); + } + /// + /// + /// + /// + /// + public int Size(long arg0) + { + return IExecuteWithSignature("size", "(J)I", arg0); + } + /// + /// + /// + /// + public object[] ToArray() + { + return IExecuteWithSignatureArray("toArray", "()[Ljava/lang/Object;"); + } + /// + /// + /// + /// + public Java.Util.Iterator Iterator() + { + return IExecuteWithSignature>("iterator", "()Ljava/util/Iterator;"); + } + /// + /// + /// + /// + /// + public Java.Util.Iterator Iterator(long arg0) + { + return IExecuteWithSignature>("iterator", "(J)Ljava/util/Iterator;", arg0); + } + /// + /// + /// + public void Clear() + { + IExecuteWithSignature("clear", "()V"); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion +} \ No newline at end of file diff --git a/src/net/KNet/Generated/Org/Apache/Kafka/Timeline/TimelineInteger.cs b/src/net/KNet/Generated/Org/Apache/Kafka/Timeline/TimelineInteger.cs new file mode 100644 index 000000000..86313bc1b --- /dev/null +++ b/src/net/KNet/Generated/Org/Apache/Kafka/Timeline/TimelineInteger.cs @@ -0,0 +1,163 @@ +/* +* Copyright 2024 MASES s.r.l. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* +* Refer to LICENSE for more information. +*/ + +/* +* This file is generated by MASES.JNetReflector (ver. 2.5.10.0) +* using kafka-server-common-3.9.0.jar as reference +*/ + +using MASES.JCOBridge.C2JBridge; + +namespace Org.Apache.Kafka.Timeline +{ + #region TimelineInteger declaration + /// + /// + /// + public partial class TimelineInteger : MASES.JCOBridge.C2JBridge.JVMBridgeBase + { + const string _bridgeClassName = "org.apache.kafka.timeline.TimelineInteger"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public TimelineInteger() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public TimelineInteger(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => false; + + // TODO: complete the class + + } + #endregion + + #region TimelineInteger implementation + public partial class TimelineInteger + { + #region Constructors + /// + /// + /// + /// + public TimelineInteger(Org.Apache.Kafka.Timeline.SnapshotRegistry arg0) + : base(arg0) + { + } + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + /// + /// + /// + public static int INIT { get { if (!_INITReady) { _INITContent = SGetField(LocalBridgeClazz, "INIT"); _INITReady = true; } return _INITContent; } } + private static int _INITContent = default; + private static bool _INITReady = false; // this is used because in case of generics + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + public int Get() + { + return IExecuteWithSignature("get", "()I"); + } + /// + /// + /// + /// + /// + public int Get(long arg0) + { + return IExecuteWithSignature("get", "(J)I", arg0); + } + /// + /// + /// + public void Decrement() + { + IExecuteWithSignature("decrement", "()V"); + } + /// + /// + /// + public void Increment() + { + IExecuteWithSignature("increment", "()V"); + } + /// + /// + /// + public void Reset() + { + IExecuteWithSignature("reset", "()V"); + } + /// + /// + /// + /// + public void Set(int arg0) + { + IExecuteWithSignature("set", "(I)V", arg0); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion +} \ No newline at end of file diff --git a/src/net/KNet/Generated/Org/Apache/Kafka/Timeline/TimelineLong.cs b/src/net/KNet/Generated/Org/Apache/Kafka/Timeline/TimelineLong.cs new file mode 100644 index 000000000..84c8a2882 --- /dev/null +++ b/src/net/KNet/Generated/Org/Apache/Kafka/Timeline/TimelineLong.cs @@ -0,0 +1,163 @@ +/* +* Copyright 2024 MASES s.r.l. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* +* Refer to LICENSE for more information. +*/ + +/* +* This file is generated by MASES.JNetReflector (ver. 2.5.10.0) +* using kafka-server-common-3.9.0.jar as reference +*/ + +using MASES.JCOBridge.C2JBridge; + +namespace Org.Apache.Kafka.Timeline +{ + #region TimelineLong declaration + /// + /// + /// + public partial class TimelineLong : MASES.JCOBridge.C2JBridge.JVMBridgeBase + { + const string _bridgeClassName = "org.apache.kafka.timeline.TimelineLong"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public TimelineLong() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public TimelineLong(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => false; + + // TODO: complete the class + + } + #endregion + + #region TimelineLong implementation + public partial class TimelineLong + { + #region Constructors + /// + /// + /// + /// + public TimelineLong(Org.Apache.Kafka.Timeline.SnapshotRegistry arg0) + : base(arg0) + { + } + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + /// + /// + /// + public static long INIT { get { if (!_INITReady) { _INITContent = SGetField(LocalBridgeClazz, "INIT"); _INITReady = true; } return _INITContent; } } + private static long _INITContent = default; + private static bool _INITReady = false; // this is used because in case of generics + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + public long Get() + { + return IExecuteWithSignature("get", "()J"); + } + /// + /// + /// + /// + /// + public long Get(long arg0) + { + return IExecuteWithSignature("get", "(J)J", arg0); + } + /// + /// + /// + public void Decrement() + { + IExecuteWithSignature("decrement", "()V"); + } + /// + /// + /// + public void Increment() + { + IExecuteWithSignature("increment", "()V"); + } + /// + /// + /// + public void Reset() + { + IExecuteWithSignature("reset", "()V"); + } + /// + /// + /// + /// + public void Set(long arg0) + { + IExecuteWithSignature("set", "(J)V", arg0); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion +} \ No newline at end of file diff --git a/src/net/KNet/Generated/Org/Apache/Kafka/Timeline/TimelineObject.cs b/src/net/KNet/Generated/Org/Apache/Kafka/Timeline/TimelineObject.cs new file mode 100644 index 000000000..1bd7a437c --- /dev/null +++ b/src/net/KNet/Generated/Org/Apache/Kafka/Timeline/TimelineObject.cs @@ -0,0 +1,266 @@ +/* +* Copyright 2024 MASES s.r.l. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +* +* Refer to LICENSE for more information. +*/ + +/* +* This file is generated by MASES.JNetReflector (ver. 2.5.10.0) +* using kafka-server-common-3.9.0.jar as reference +*/ + +using MASES.JCOBridge.C2JBridge; + +namespace Org.Apache.Kafka.Timeline +{ + #region TimelineObject declaration + /// + /// + /// + public partial class TimelineObject : MASES.JCOBridge.C2JBridge.JVMBridgeBase + { + const string _bridgeClassName = "org.apache.kafka.timeline.TimelineObject"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public TimelineObject() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public TimelineObject(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => false; + + // TODO: complete the class + + } + #endregion + + #region TimelineObject declaration + /// + /// + /// + /// + public partial class TimelineObject : MASES.JCOBridge.C2JBridge.JVMBridgeBase> + { + const string _bridgeClassName = "org.apache.kafka.timeline.TimelineObject"; + /// + /// Default constructor: even if the corresponding Java class does not have one, it is mandatory for JCOBridge + /// + public TimelineObject() { } + /// + /// Generic constructor: it is useful for JCOBridge when there is a derived class which needs to pass arguments to the highest JVMBridgeBase class + /// + public TimelineObject(params object[] args) : base(args) { } + + private static readonly MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType _LocalBridgeClazz = JVMBridgeBase.ClazzOf(_bridgeClassName); + private static MASES.JCOBridge.C2JBridge.JVMInterop.IJavaType LocalBridgeClazz => _LocalBridgeClazz ?? throw new global::System.InvalidOperationException($"Class {_bridgeClassName} was not found."); + + /// + /// + /// + public override string BridgeClassName => _bridgeClassName; + /// + /// + /// + public override bool IsBridgeAbstract => false; + /// + /// + /// + public override bool IsBridgeCloseable => false; + /// + /// + /// + public override bool IsBridgeInterface => false; + /// + /// + /// + public override bool IsBridgeStatic => false; + + // TODO: complete the class + + } + #endregion + + #region TimelineObject implementation + public partial class TimelineObject + { + #region Constructors + /// + /// + /// + /// + /// + public TimelineObject(Org.Apache.Kafka.Timeline.SnapshotRegistry arg0, object arg1) + : base(arg0, arg1) + { + } + + #endregion + + #region Class/Interface conversion operators + + #endregion + + #region Fields + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + public object Get() + { + return IExecuteWithSignature("get", "()Ljava/lang/Object;"); + } + /// + /// + /// + /// + /// + public object Get(long arg0) + { + return IExecuteWithSignature("get", "(J)Ljava/lang/Object;", arg0); + } + /// + /// + /// + public void Reset() + { + IExecuteWithSignature("reset", "()V"); + } + /// + /// + /// + /// + public void Set(object arg0) + { + IExecuteWithSignature("set", "(Ljava/lang/Object;)V", arg0); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion + + #region TimelineObject implementation + public partial class TimelineObject + { + #region Constructors + /// + /// + /// + /// + /// + public TimelineObject(Org.Apache.Kafka.Timeline.SnapshotRegistry arg0, T arg1) + : base(arg0, arg1) + { + } + + #endregion + + #region Class/Interface conversion operators + /// + /// Converter from to + /// + public static implicit operator Org.Apache.Kafka.Timeline.TimelineObject(Org.Apache.Kafka.Timeline.TimelineObject t) => t.Cast(); + + #endregion + + #region Fields + + #endregion + + #region Static methods + + #endregion + + #region Instance methods + /// + /// + /// + /// + public T Get() + { + return IExecuteWithSignature("get", "()Ljava/lang/Object;"); + } + /// + /// + /// + /// + /// + public T Get(long arg0) + { + return IExecuteWithSignature("get", "(J)Ljava/lang/Object;", arg0); + } + /// + /// + /// + public void Reset() + { + IExecuteWithSignature("reset", "()V"); + } + /// + /// + /// + /// + public void Set(T arg0) + { + IExecuteWithSignature("set", "(Ljava/lang/Object;)V", arg0); + } + + #endregion + + #region Nested classes + + #endregion + + // TODO: complete the class + } + #endregion +} \ No newline at end of file