_ Git - ldk-java/blob - c_sharp/src/org/ldk/structs/Bech32Error.cs

   1 using org.ldk.impl;
   2 using org.ldk.enums;
   3 using org.ldk.util;
   4 using System;
   5
   6 namespace org { namespace ldk { namespace structs {
   7
   8 /**
   9  * Represents an error returned from the bech32 library during validation of some bech32 data
  10  */
  11 public class Bech32Error : CommonBase {
  12         protected Bech32Error(object _dummy, long ptr) : base(ptr) { }
  13         ~Bech32Error() {
  14                 if (ptr != 0) { bindings.Bech32Error_free(ptr); }
  15         }
  16
  17         internal static Bech32Error constr_from_ptr(long ptr) {
  18                 long raw_ty = bindings.LDKBech32Error_ty_from_ptr(ptr);
  19                 switch (raw_ty) {
  20                         case 0: return new Bech32Error_MissingSeparator(ptr);
  21                         case 1: return new Bech32Error_InvalidChecksum(ptr);
  22                         case 2: return new Bech32Error_InvalidLength(ptr);
  23                         case 3: return new Bech32Error_InvalidChar(ptr);
  24                         case 4: return new Bech32Error_InvalidData(ptr);
  25                         case 5: return new Bech32Error_InvalidPadding(ptr);
  26                         case 6: return new Bech32Error_MixedCase(ptr);
  27                         default:
  28                                 throw new ArgumentException("Impossible enum variant");
  29                 }
  30         }
  31
  32         /** A Bech32Error of type MissingSeparator */
  33         public class Bech32Error_MissingSeparator : Bech32Error {
  34                 internal Bech32Error_MissingSeparator(long ptr) : base(null, ptr) {
  35                 }
  36         }
  37         /** A Bech32Error of type InvalidChecksum */
  38         public class Bech32Error_InvalidChecksum : Bech32Error {
  39                 internal Bech32Error_InvalidChecksum(long ptr) : base(null, ptr) {
  40                 }
  41         }
  42         /** A Bech32Error of type InvalidLength */
  43         public class Bech32Error_InvalidLength : Bech32Error {
  44                 internal Bech32Error_InvalidLength(long ptr) : base(null, ptr) {
  45                 }
  46         }
  47         /** A Bech32Error of type InvalidChar */
  48         public class Bech32Error_InvalidChar : Bech32Error {
  49                 public int invalid_char;
  50                 internal Bech32Error_InvalidChar(long ptr) : base(null, ptr) {
  51                         this.invalid_char = bindings.LDKBech32Error_InvalidChar_get_invalid_char(ptr);
  52                 }
  53         }
  54         /** A Bech32Error of type InvalidData */
  55         public class Bech32Error_InvalidData : Bech32Error {
  56                 public byte invalid_data;
  57                 internal Bech32Error_InvalidData(long ptr) : base(null, ptr) {
  58                         this.invalid_data = bindings.LDKBech32Error_InvalidData_get_invalid_data(ptr);
  59                 }
  60         }
  61         /** A Bech32Error of type InvalidPadding */
  62         public class Bech32Error_InvalidPadding : Bech32Error {
  63                 internal Bech32Error_InvalidPadding(long ptr) : base(null, ptr) {
  64                 }
  65         }
  66         /** A Bech32Error of type MixedCase */
  67         public class Bech32Error_MixedCase : Bech32Error {
  68                 internal Bech32Error_MixedCase(long ptr) : base(null, ptr) {
  69                 }
  70         }
  71         internal long clone_ptr() {
  72                 long ret = bindings.Bech32Error_clone_ptr(this.ptr);
  73                 GC.KeepAlive(this);
  74                 return ret;
  75         }
  76
  77         /**
  78          * Creates a new Bech32Error which has the same data as `orig`
  79          */
  80         public Bech32Error clone() {
  81                 long ret = bindings.Bech32Error_clone(this.ptr);
  82                 GC.KeepAlive(this);
  83                 if (ret >= 0 && ret <= 4096) { return null; }
  84                 org.ldk.structs.Bech32Error ret_hu_conv = org.ldk.structs.Bech32Error.constr_from_ptr(ret);
  85                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(this); };
  86                 return ret_hu_conv;
  87         }
  88
  89 }
  90 } } }