+ if (ptr != 0) { bindings.DecodeError_free(ptr); }
+ }
+ static DecodeError constr_from_ptr(long ptr) {
+ bindings.LDKDecodeError raw_val = bindings.LDKDecodeError_ref_from_ptr(ptr);
+ if (raw_val.getClass() == bindings.LDKDecodeError.UnknownVersion.class) {
+ return new UnknownVersion(ptr, (bindings.LDKDecodeError.UnknownVersion)raw_val);
+ }
+ if (raw_val.getClass() == bindings.LDKDecodeError.UnknownRequiredFeature.class) {
+ return new UnknownRequiredFeature(ptr, (bindings.LDKDecodeError.UnknownRequiredFeature)raw_val);
+ }
+ if (raw_val.getClass() == bindings.LDKDecodeError.InvalidValue.class) {
+ return new InvalidValue(ptr, (bindings.LDKDecodeError.InvalidValue)raw_val);
+ }
+ if (raw_val.getClass() == bindings.LDKDecodeError.ShortRead.class) {
+ return new ShortRead(ptr, (bindings.LDKDecodeError.ShortRead)raw_val);
+ }
+ if (raw_val.getClass() == bindings.LDKDecodeError.BadLengthDescriptor.class) {
+ return new BadLengthDescriptor(ptr, (bindings.LDKDecodeError.BadLengthDescriptor)raw_val);
+ }
+ if (raw_val.getClass() == bindings.LDKDecodeError.Io.class) {
+ return new Io(ptr, (bindings.LDKDecodeError.Io)raw_val);
+ }
+ if (raw_val.getClass() == bindings.LDKDecodeError.UnsupportedCompression.class) {
+ return new UnsupportedCompression(ptr, (bindings.LDKDecodeError.UnsupportedCompression)raw_val);
+ }
+ assert false; return null; // Unreachable without extending the (internal) bindings interface
+ }
+
+ /**
+ * A version byte specified something we don't know how to handle.
+ * Includes unknown realm byte in an OnionHopData packet
+ */
+ public final static class UnknownVersion extends DecodeError {
+ private UnknownVersion(long ptr, bindings.LDKDecodeError.UnknownVersion obj) {
+ super(null, ptr);
+ }
+ }
+ /**
+ * Unknown feature mandating we fail to parse message (eg TLV with an even, unknown type)
+ */
+ public final static class UnknownRequiredFeature extends DecodeError {
+ private UnknownRequiredFeature(long ptr, bindings.LDKDecodeError.UnknownRequiredFeature obj) {
+ super(null, ptr);
+ }
+ }
+ /**
+ * Value was invalid, eg a byte which was supposed to be a bool was something other than a 0
+ * or 1, a public key/private key/signature was invalid, text wasn't UTF-8, TLV was
+ * syntactically incorrect, etc
+ */
+ public final static class InvalidValue extends DecodeError {
+ private InvalidValue(long ptr, bindings.LDKDecodeError.InvalidValue obj) {
+ super(null, ptr);
+ }
+ }
+ /**
+ * Buffer too short
+ */
+ public final static class ShortRead extends DecodeError {
+ private ShortRead(long ptr, bindings.LDKDecodeError.ShortRead obj) {
+ super(null, ptr);
+ }
+ }
+ /**
+ * A length descriptor in the packet didn't describe the later data correctly
+ */
+ public final static class BadLengthDescriptor extends DecodeError {
+ private BadLengthDescriptor(long ptr, bindings.LDKDecodeError.BadLengthDescriptor obj) {
+ super(null, ptr);
+ }
+ }
+ /**
+ * Error from std::io
+ */
+ public final static class Io extends DecodeError {
+ public final org.ldk.enums.IOError io;
+ private Io(long ptr, bindings.LDKDecodeError.Io obj) {
+ super(null, ptr);
+ this.io = obj.io;
+ }
+ }
+ /**
+ * The message included zlib-compressed values, which we don't support.
+ */
+ public final static class UnsupportedCompression extends DecodeError {
+ private UnsupportedCompression(long ptr, bindings.LDKDecodeError.UnsupportedCompression obj) {
+ super(null, ptr);
+ }
+ }
+ long clone_ptr() {
+ long ret = bindings.DecodeError_clone_ptr(this.ptr);
+ Reference.reachabilityFence(this);
+ return ret;
+ }
+
+ /**
+ * Creates a copy of the DecodeError
+ */
+ public DecodeError clone() {
+ long ret = bindings.DecodeError_clone(this.ptr);
+ Reference.reachabilityFence(this);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ org.ldk.structs.DecodeError ret_hu_conv = org.ldk.structs.DecodeError.constr_from_ptr(ret);
+ if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
+ return ret_hu_conv;
+ }
+
+ /**
+ * Utility method to constructs a new UnknownVersion-variant DecodeError
+ */
+ public static DecodeError unknown_version() {
+ long ret = bindings.DecodeError_unknown_version();
+ if (ret >= 0 && ret <= 4096) { return null; }
+ org.ldk.structs.DecodeError ret_hu_conv = org.ldk.structs.DecodeError.constr_from_ptr(ret);
+ if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
+ return ret_hu_conv;