AccountEntryExtensionV2.java

// Automatically generated by xdrgen
// DO NOT EDIT or your changes may be overwritten

package org.stellar.sdk.xdr;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.LinkedHashMap;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.stellar.sdk.Base64Factory;

/**
 * AccountEntryExtensionV2's original definition in the XDR file is:
 *
 * <pre>
 * struct AccountEntryExtensionV2
 * {
 *     uint32 numSponsored;
 *     uint32 numSponsoring;
 *     SponsorshipDescriptor signerSponsoringIDs&lt;MAX_SIGNERS&gt;;
 *
 *     union switch (int v)
 *     {
 *     case 0:
 *         void;
 *     case 3:
 *         AccountEntryExtensionV3 v3;
 *     }
 *     ext;
 * };
 * </pre>
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder(toBuilder = true)
public class AccountEntryExtensionV2 implements XdrElement {
  private Uint32 numSponsored;
  private Uint32 numSponsoring;
  private SponsorshipDescriptor[] signerSponsoringIDs;
  private AccountEntryExtensionV2Ext ext;

  public void encode(XdrDataOutputStream stream) throws IOException {
    numSponsored.encode(stream);
    numSponsoring.encode(stream);
    int signerSponsoringIDsSize = getSignerSponsoringIDs().length;
    if (signerSponsoringIDsSize > 20) {
      throw new IOException(
          "signerSponsoringIDs size " + signerSponsoringIDsSize + " exceeds max size 20");
    }
    stream.writeInt(signerSponsoringIDsSize);
    for (int i = 0; i < signerSponsoringIDsSize; i++) {
      signerSponsoringIDs[i].encode(stream);
    }
    ext.encode(stream);
  }

  public static AccountEntryExtensionV2 decode(XdrDataInputStream stream, int maxDepth)
      throws IOException {
    if (maxDepth <= 0) {
      throw new IOException("Maximum decoding depth reached");
    }
    maxDepth -= 1;
    AccountEntryExtensionV2 decodedAccountEntryExtensionV2 = new AccountEntryExtensionV2();
    decodedAccountEntryExtensionV2.numSponsored = Uint32.decode(stream, maxDepth);
    decodedAccountEntryExtensionV2.numSponsoring = Uint32.decode(stream, maxDepth);
    int signerSponsoringIDsSize = stream.readInt();
    if (signerSponsoringIDsSize < 0) {
      throw new IOException("signerSponsoringIDs size " + signerSponsoringIDsSize + " is negative");
    }
    if (signerSponsoringIDsSize > 20) {
      throw new IOException(
          "signerSponsoringIDs size " + signerSponsoringIDsSize + " exceeds max size 20");
    }
    int signerSponsoringIDsRemainingInputLen = stream.getRemainingInputLen();
    if (signerSponsoringIDsRemainingInputLen >= 0
        && signerSponsoringIDsRemainingInputLen < signerSponsoringIDsSize) {
      throw new IOException(
          "signerSponsoringIDs size "
              + signerSponsoringIDsSize
              + " exceeds remaining input length "
              + signerSponsoringIDsRemainingInputLen);
    }
    decodedAccountEntryExtensionV2.signerSponsoringIDs =
        new SponsorshipDescriptor[signerSponsoringIDsSize];
    for (int i = 0; i < signerSponsoringIDsSize; i++) {
      decodedAccountEntryExtensionV2.signerSponsoringIDs[i] =
          SponsorshipDescriptor.decode(stream, maxDepth);
    }
    decodedAccountEntryExtensionV2.ext = AccountEntryExtensionV2Ext.decode(stream, maxDepth);
    return decodedAccountEntryExtensionV2;
  }

  public static AccountEntryExtensionV2 decode(XdrDataInputStream stream) throws IOException {
    return decode(stream, XdrDataInputStream.DEFAULT_MAX_DEPTH);
  }

  public static AccountEntryExtensionV2 fromXdrBase64(String xdr) throws IOException {
    byte[] bytes = Base64Factory.getInstance().decode(xdr);
    return fromXdrByteArray(bytes);
  }

  public static AccountEntryExtensionV2 fromXdrByteArray(byte[] xdr) throws IOException {
    ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(xdr);
    XdrDataInputStream xdrDataInputStream = new XdrDataInputStream(byteArrayInputStream);
    xdrDataInputStream.setMaxInputLen(xdr.length);
    return decode(xdrDataInputStream);
  }

  @Override
  public String toJson() {
    return XdrElement.gson.toJson(toJsonObject());
  }

  public static AccountEntryExtensionV2 fromJson(String json) {
    return fromJsonObject(XdrElement.gson.fromJson(json, Object.class));
  }

  Object toJsonObject() {
    LinkedHashMap<String, Object> jsonMap = new LinkedHashMap<>();
    jsonMap.put("num_sponsored", numSponsored.toJsonObject());
    jsonMap.put("num_sponsoring", numSponsoring.toJsonObject());
    jsonMap.put(
        "signer_sponsoring_i_ds",
        XdrElement.arrayToJsonArray(
            signerSponsoringIDs, i -> signerSponsoringIDs[i].toJsonObject()));
    jsonMap.put("ext", ext.toJsonObject());
    return jsonMap;
  }

  @SuppressWarnings("unchecked")
  static AccountEntryExtensionV2 fromJsonObject(Object json) {
    java.util.Map<String, Object> jsonMap = (java.util.Map<String, Object>) json;
    AccountEntryExtensionV2 instance = new AccountEntryExtensionV2();
    instance.numSponsored = Uint32.fromJsonObject(jsonMap.get("num_sponsored"));
    instance.numSponsoring = Uint32.fromJsonObject(jsonMap.get("num_sponsoring"));
    instance.signerSponsoringIDs =
        XdrElement.jsonArrayToArray(
            (List<Object>) jsonMap.get("signer_sponsoring_i_ds"),
            SponsorshipDescriptor.class,
            item -> SponsorshipDescriptor.fromJsonObject(item));
    instance.ext = AccountEntryExtensionV2Ext.fromJsonObject(jsonMap.get("ext"));
    return instance;
  }

  /**
   * AccountEntryExtensionV2Ext's original definition in the XDR file is:
   *
   * <pre>
   * union switch (int v)
   *     {
   *     case 0:
   *         void;
   *     case 3:
   *         AccountEntryExtensionV3 v3;
   *     }
   * </pre>
   */
  @Data
  @NoArgsConstructor
  @AllArgsConstructor
  @Builder(toBuilder = true)
  public static class AccountEntryExtensionV2Ext implements XdrElement {
    private Integer discriminant;
    private AccountEntryExtensionV3 v3;

    public void encode(XdrDataOutputStream stream) throws IOException {
      stream.writeInt(discriminant);
      switch (discriminant) {
        case 0:
          break;
        case 3:
          v3.encode(stream);
          break;
      }
    }

    public static AccountEntryExtensionV2Ext decode(XdrDataInputStream stream, int maxDepth)
        throws IOException {
      if (maxDepth <= 0) {
        throw new IOException("Maximum decoding depth reached");
      }
      maxDepth -= 1;
      AccountEntryExtensionV2Ext decodedAccountEntryExtensionV2Ext =
          new AccountEntryExtensionV2Ext();
      Integer discriminant = stream.readInt();
      decodedAccountEntryExtensionV2Ext.setDiscriminant(discriminant);
      switch (decodedAccountEntryExtensionV2Ext.getDiscriminant()) {
        case 0:
          break;
        case 3:
          decodedAccountEntryExtensionV2Ext.v3 = AccountEntryExtensionV3.decode(stream, maxDepth);
          break;
        default:
          throw new IOException("Unknown discriminant value: " + discriminant);
      }
      return decodedAccountEntryExtensionV2Ext;
    }

    public static AccountEntryExtensionV2Ext decode(XdrDataInputStream stream) throws IOException {
      return decode(stream, XdrDataInputStream.DEFAULT_MAX_DEPTH);
    }

    public static AccountEntryExtensionV2Ext fromXdrBase64(String xdr) throws IOException {
      byte[] bytes = Base64Factory.getInstance().decode(xdr);
      return fromXdrByteArray(bytes);
    }

    public static AccountEntryExtensionV2Ext fromXdrByteArray(byte[] xdr) throws IOException {
      ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(xdr);
      XdrDataInputStream xdrDataInputStream = new XdrDataInputStream(byteArrayInputStream);
      xdrDataInputStream.setMaxInputLen(xdr.length);
      return decode(xdrDataInputStream);
    }

    @Override
    public String toJson() {
      return XdrElement.gson.toJson(toJsonObject());
    }

    public static AccountEntryExtensionV2Ext fromJson(String json) {
      return fromJsonObject(XdrElement.gson.fromJson(json, Object.class));
    }

    Object toJsonObject() {
      if (discriminant == 0) {
        return "v0";
      }
      if (discriminant == 3) {
        LinkedHashMap<String, Object> jsonMap = new LinkedHashMap<>();
        jsonMap.put("v3", v3.toJsonObject());
        return jsonMap;
      }
      throw new IllegalArgumentException("Unknown discriminant: " + discriminant);
    }

    @SuppressWarnings("unchecked")
    static AccountEntryExtensionV2Ext fromJsonObject(Object json) {
      if (json instanceof String) {
        String strVal = (String) json;
        if (!(strVal.equals("v0"))) {
          throw new IllegalArgumentException(
              "Unexpected string '" + strVal + "' for AccountEntryExtensionV2Ext");
        }
        AccountEntryExtensionV2Ext instance = new AccountEntryExtensionV2Ext();
        instance.discriminant = Integer.parseInt(strVal.substring(1));
        return instance;
      }
      java.util.Map<String, Object> jsonMap = (java.util.Map<String, Object>) json;
      if (jsonMap.containsKey("$schema")) {
        jsonMap = new LinkedHashMap<>(jsonMap);
        jsonMap.remove("$schema");
      }
      if (jsonMap.size() != 1) {
        throw new IllegalArgumentException(
            "Expected a single-key object for AccountEntryExtensionV2Ext, got: " + json);
      }
      String key = jsonMap.keySet().iterator().next();
      Integer discriminant = Integer.parseInt(key.substring(1));
      if (key.equals("v3")) {
        AccountEntryExtensionV2Ext instance = new AccountEntryExtensionV2Ext();
        instance.discriminant = discriminant;
        instance.v3 = AccountEntryExtensionV3.fromJsonObject(jsonMap.get("v3"));
        return instance;
      }
      throw new IllegalArgumentException(
          "Unknown key '" + key + "' for AccountEntryExtensionV2Ext");
    }
  }
}