WebSVN – SmartDukaan – Diff – /trunk/ThriftConfig/src/main/java/in/shop2020/model/v1/order/TransactionService.java

     public PaginatedLoanHistory getLimitedLoanHistoryRecords(long paymentId, long userId, long creditorId, long limit, long offset) throws org.apache.thrift.TException;
     public PaginatedUserSanction getUserSanctionsDetailsAsPerLimit(long userId, long creditorId, long limit, long offset, String sort) throws org.apache.thrift.TException;
+    public List<OutstandingPayments> getOutstandingPayments(String fetchType, long userId, long limit) throws org.apache.thrift.TException;
     public ReturnOrderInfo getReturnOrderInfo(long id) throws TransactionServiceException, org.apache.thrift.TException;
     public Map<Long,List<ReturnOrderInfo>> getReturnOrderInfoList(List<Long> order_ids) throws org.apache.thrift.TException;
     public Map<Long,List<ReturnOrderInfo>> getReturnOrderInfoListAsByStatus(List<Long> order_ids, List<String> statuses) throws org.apache.thrift.TException;
     public void getLimitedLoanHistoryRecords(long paymentId, long userId, long creditorId, long limit, long offset, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getLimitedLoanHistoryRecords_call> resultHandler) throws org.apache.thrift.TException;
     public void getUserSanctionsDetailsAsPerLimit(long userId, long creditorId, long limit, long offset, String sort, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getUserSanctionsDetailsAsPerLimit_call> resultHandler) throws org.apache.thrift.TException;
+    public void getOutstandingPayments(String fetchType, long userId, long limit, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getOutstandingPayments_call> resultHandler) throws org.apache.thrift.TException;
     public void getReturnOrderInfo(long id, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getReturnOrderInfo_call> resultHandler) throws org.apache.thrift.TException;
     public void getReturnOrderInfoList(List<Long> order_ids, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getReturnOrderInfoList_call> resultHandler) throws org.apache.thrift.TException;
     public void getReturnOrderInfoListAsByStatus(List<Long> order_ids, List<String> statuses, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getReturnOrderInfoListAsByStatus_call> resultHandler) throws org.apache.thrift.TException;
         return result.success;
+      }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getUserSanctionsDetailsAsPerLimit failed: unknown result");
+    }
+    public List<OutstandingPayments> getOutstandingPayments(String fetchType, long userId, long limit) throws org.apache.thrift.TException
+    {
+      send_getOutstandingPayments(fetchType, userId, limit);
+      return recv_getOutstandingPayments();
+    }
+    public void send_getOutstandingPayments(String fetchType, long userId, long limit) throws org.apache.thrift.TException
+    {
+      getOutstandingPayments_args args = new getOutstandingPayments_args();
+      args.setFetchType(fetchType);
+      args.setUserId(userId);
+      args.setLimit(limit);
+      sendBase("getOutstandingPayments", args);
+    }
+    public List<OutstandingPayments> recv_getOutstandingPayments() throws org.apache.thrift.TException
+    {
+      getOutstandingPayments_result result = new getOutstandingPayments_result();
+      receiveBase(result, "getOutstandingPayments");
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getOutstandingPayments failed: unknown result");
+    }
     public ReturnOrderInfo getReturnOrderInfo(long id) throws TransactionServiceException, org.apache.thrift.TException
+    {
       send_getReturnOrderInfo(id);
       return recv_getReturnOrderInfo();
+    }
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         return (new Client(prot)).recv_getUserSanctionsDetailsAsPerLimit();
+      }
+    }
+    public void getOutstandingPayments(String fetchType, long userId, long limit, org.apache.thrift.async.AsyncMethodCallback<getOutstandingPayments_call> resultHandler) throws org.apache.thrift.TException {
+      checkReady();
+      getOutstandingPayments_call method_call = new getOutstandingPayments_call(fetchType, userId, limit, resultHandler, this, ___protocolFactory, ___transport);
+      this.___currentMethod = method_call;
+      ___manager.call(method_call);
+    }
+    public static class getOutstandingPayments_call extends org.apache.thrift.async.TAsyncMethodCall {
+      private String fetchType;
+      private long userId;
+      private long limit;
+      public getOutstandingPayments_call(String fetchType, long userId, long limit, org.apache.thrift.async.AsyncMethodCallback<getOutstandingPayments_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+        super(client, protocolFactory, transport, resultHandler, false);
+        this.fetchType = fetchType;
+        this.userId = userId;
+        this.limit = limit;
+      }
+      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getOutstandingPayments", org.apache.thrift.protocol.TMessageType.CALL, 0));
+        getOutstandingPayments_args args = new getOutstandingPayments_args();
+        args.setFetchType(fetchType);
+        args.setUserId(userId);
+        args.setLimit(limit);
+        args.write(prot);
+        prot.writeMessageEnd();
+      }
+      public List<OutstandingPayments> getResult() throws org.apache.thrift.TException {
+        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+          throw new IllegalStateException("Method call not finished!");
+        }
+        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+        return (new Client(prot)).recv_getOutstandingPayments();
+      }
+    }
     public void getReturnOrderInfo(long id, org.apache.thrift.async.AsyncMethodCallback<getReturnOrderInfo_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       getReturnOrderInfo_call method_call = new getReturnOrderInfo_call(id, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
       processMap.put("getLoanHistoryRecordsForUserAndCreditor", new getLoanHistoryRecordsForUserAndCreditor());
       processMap.put("processLoanTransaction", new processLoanTransaction());
       processMap.put("getLimitedCreditHistoryRecords", new getLimitedCreditHistoryRecords());
       processMap.put("getLimitedLoanHistoryRecords", new getLimitedLoanHistoryRecords());
       processMap.put("getUserSanctionsDetailsAsPerLimit", new getUserSanctionsDetailsAsPerLimit());
+      processMap.put("getOutstandingPayments", new getOutstandingPayments());
       processMap.put("getReturnOrderInfo", new getReturnOrderInfo());
       processMap.put("getReturnOrderInfoList", new getReturnOrderInfoList());
       processMap.put("getReturnOrderInfoListAsByStatus", new getReturnOrderInfoListAsByStatus());
       processMap.put("updateReturnOrderInfo", new updateReturnOrderInfo());
       processMap.put("bulkUpdateReturnOrderInfo", new bulkUpdateReturnOrderInfo());
         result.success = iface.getUserSanctionsDetailsAsPerLimit(args.userId, args.creditorId, args.limit, args.offset, args.sort);
         return result;
+      }
+    }
+    private static class getOutstandingPayments<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getOutstandingPayments_args> {
+      public getOutstandingPayments() {
+        super("getOutstandingPayments");
+      }
+      protected getOutstandingPayments_args getEmptyArgsInstance() {
+        return new getOutstandingPayments_args();
+      }
+      protected getOutstandingPayments_result getResult(I iface, getOutstandingPayments_args args) throws org.apache.thrift.TException {
+        getOutstandingPayments_result result = new getOutstandingPayments_result();
+        result.success = iface.getOutstandingPayments(args.fetchType, args.userId, args.limit);
+        return result;
+      }
+    }
     private static class getReturnOrderInfo<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getReturnOrderInfo_args> {
       public getReturnOrderInfo() {
         super("getReturnOrderInfo");
+      }
+      }
+    }
+  }
+  public static class getOutstandingPayments_args implements org.apache.thrift.TBase<getOutstandingPayments_args, getOutstandingPayments_args._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getOutstandingPayments_args");
+    private static final org.apache.thrift.protocol.TField FETCH_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("fetchType", org.apache.thrift.protocol.TType.STRING, (short)1);
+    private static final org.apache.thrift.protocol.TField USER_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("userId", org.apache.thrift.protocol.TType.I64, (short)2);
+    private static final org.apache.thrift.protocol.TField LIMIT_FIELD_DESC = new org.apache.thrift.protocol.TField("limit", org.apache.thrift.protocol.TType.I64, (short)3);
+    private String fetchType; // required
+    private long userId; // required
+    private long limit; // required
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+      FETCH_TYPE((short)1, "fetchType"),
+      USER_ID((short)2, "userId"),
+      LIMIT((short)3, "limit");
+      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+      static {
+        for (_Fields field : EnumSet.allOf(_Fields.class)) {
+          byName.put(field.getFieldName(), field);
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, or null if its not found.
+       */
+      public static _Fields findByThriftId(int fieldId) {
+        switch(fieldId) {
+          case 1: // FETCH_TYPE
+            return FETCH_TYPE;
+          case 2: // USER_ID
+            return USER_ID;
+          case 3: // LIMIT
+            return LIMIT;
+          default:
+            return null;
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, throwing an exception
+       * if it is not found.
+       */
+      public static _Fields findByThriftIdOrThrow(int fieldId) {
+        _Fields fields = findByThriftId(fieldId);
+        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+        return fields;
+      }
+      /**
+       * Find the _Fields constant that matches name, or null if its not found.
+       */
+      public static _Fields findByName(String name) {
+        return byName.get(name);
+      }
+      private final short _thriftId;
+      private final String _fieldName;
+      _Fields(short thriftId, String fieldName) {
+        _thriftId = thriftId;
+        _fieldName = fieldName;
+      }
+      public short getThriftFieldId() {
+        return _thriftId;
+      }
+      public String getFieldName() {
+        return _fieldName;
+      }
+    }
+    // isset id assignments
+    private static final int __USERID_ISSET_ID = 0;
+    private static final int __LIMIT_ISSET_ID = 1;
+    private BitSet __isset_bit_vector = new BitSet(2);
+    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+    static {
+      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+      tmpMap.put(_Fields.FETCH_TYPE, new org.apache.thrift.meta_data.FieldMetaData("fetchType", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+      tmpMap.put(_Fields.USER_ID, new org.apache.thrift.meta_data.FieldMetaData("userId", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      tmpMap.put(_Fields.LIMIT, new org.apache.thrift.meta_data.FieldMetaData("limit", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getOutstandingPayments_args.class, metaDataMap);
+    }
+    public getOutstandingPayments_args() {
+    }
+    public getOutstandingPayments_args(
+      String fetchType,
+      long userId,
+      long limit)
+    {
+      this();
+      this.fetchType = fetchType;
+      this.userId = userId;
+      setUserIdIsSet(true);
+      this.limit = limit;
+      setLimitIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getOutstandingPayments_args(getOutstandingPayments_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      if (other.isSetFetchType()) {
+        this.fetchType = other.fetchType;
+      }
+      this.userId = other.userId;
+      this.limit = other.limit;
+    }
+    public getOutstandingPayments_args deepCopy() {
+      return new getOutstandingPayments_args(this);
+    }
+    @Override
+    public void clear() {
+      this.fetchType = null;
+      setUserIdIsSet(false);
+      this.userId = 0;
+      setLimitIsSet(false);
+      this.limit = 0;
+    }
+    public String getFetchType() {
+      return this.fetchType;
+    }
+    public void setFetchType(String fetchType) {
+      this.fetchType = fetchType;
+    }
+    public void unsetFetchType() {
+      this.fetchType = null;
+    }
+    /** Returns true if field fetchType is set (has been assigned a value) and false otherwise */
+    public boolean isSetFetchType() {
+      return this.fetchType != null;
+    }
+    public void setFetchTypeIsSet(boolean value) {
+      if (!value) {
+        this.fetchType = null;
+      }
+    }
+    public long getUserId() {
+      return this.userId;
+    }
+    public void setUserId(long userId) {
+      this.userId = userId;
+      setUserIdIsSet(true);
+    }
+    public void unsetUserId() {
+      __isset_bit_vector.clear(__USERID_ISSET_ID);
+    }
+    /** Returns true if field userId is set (has been assigned a value) and false otherwise */
+    public boolean isSetUserId() {
+      return __isset_bit_vector.get(__USERID_ISSET_ID);
+    }
+    public void setUserIdIsSet(boolean value) {
+      __isset_bit_vector.set(__USERID_ISSET_ID, value);
+    }
+    public long getLimit() {
+      return this.limit;
+    }
+    public void setLimit(long limit) {
+      this.limit = limit;
+      setLimitIsSet(true);
+    }
+    public void unsetLimit() {
+      __isset_bit_vector.clear(__LIMIT_ISSET_ID);
+    }
+    /** Returns true if field limit is set (has been assigned a value) and false otherwise */
+    public boolean isSetLimit() {
+      return __isset_bit_vector.get(__LIMIT_ISSET_ID);
+    }
+    public void setLimitIsSet(boolean value) {
+      __isset_bit_vector.set(__LIMIT_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case FETCH_TYPE:
+        if (value == null) {
+          unsetFetchType();
+        } else {
+          setFetchType((String)value);
+        }
+        break;
+      case USER_ID:
+        if (value == null) {
+          unsetUserId();
+        } else {
+          setUserId((Long)value);
+        }
+        break;
+      case LIMIT:
+        if (value == null) {
+          unsetLimit();
+        } else {
+          setLimit((Long)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case FETCH_TYPE:
+        return getFetchType();
+      case USER_ID:
+        return Long.valueOf(getUserId());
+      case LIMIT:
+        return Long.valueOf(getLimit());
+      }
+      throw new IllegalStateException();
+    }
+    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+    public boolean isSet(_Fields field) {
+      if (field == null) {
+        throw new IllegalArgumentException();
+      }
+      switch (field) {
+      case FETCH_TYPE:
+        return isSetFetchType();
+      case USER_ID:
+        return isSetUserId();
+      case LIMIT:
+        return isSetLimit();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof getOutstandingPayments_args)
+        return this.equals((getOutstandingPayments_args)that);
+      return false;
+    }
+    public boolean equals(getOutstandingPayments_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_fetchType = true && this.isSetFetchType();
+      boolean that_present_fetchType = true && that.isSetFetchType();
+      if (this_present_fetchType || that_present_fetchType) {
+        if (!(this_present_fetchType && that_present_fetchType))
+          return false;
+        if (!this.fetchType.equals(that.fetchType))
+          return false;
+      }
+      boolean this_present_userId = true;
+      boolean that_present_userId = true;
+      if (this_present_userId || that_present_userId) {
+        if (!(this_present_userId && that_present_userId))
+          return false;
+        if (this.userId != that.userId)
+          return false;
+      }
+      boolean this_present_limit = true;
+      boolean that_present_limit = true;
+      if (this_present_limit || that_present_limit) {
+        if (!(this_present_limit && that_present_limit))
+          return false;
+        if (this.limit != that.limit)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getOutstandingPayments_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getOutstandingPayments_args typedOther = (getOutstandingPayments_args)other;
+      lastComparison = Boolean.valueOf(isSetFetchType()).compareTo(typedOther.isSetFetchType());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetFetchType()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fetchType, typedOther.fetchType);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetUserId()).compareTo(typedOther.isSetUserId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetUserId()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userId, typedOther.userId);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetLimit()).compareTo(typedOther.isSetLimit());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetLimit()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.limit, typedOther.limit);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      return 0;
+    }
+    public _Fields fieldForId(int fieldId) {
+      return _Fields.findByThriftId(fieldId);
+    }
+    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField field;
+      iprot.readStructBegin();
+      while (true)
+      {
+        field = iprot.readFieldBegin();
+        if (field.type == org.apache.thrift.protocol.TType.STOP) {
+          break;
+        }
+        switch (field.id) {
+          case 1: // FETCH_TYPE
+            if (field.type == org.apache.thrift.protocol.TType.STRING) {
+              this.fetchType = iprot.readString();
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 2: // USER_ID
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.userId = iprot.readI64();
+              setUserIdIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 3: // LIMIT
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.limit = iprot.readI64();
+              setLimitIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+      validate();
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.fetchType != null) {
+        oprot.writeFieldBegin(FETCH_TYPE_FIELD_DESC);
+        oprot.writeString(this.fetchType);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldBegin(USER_ID_FIELD_DESC);
+      oprot.writeI64(this.userId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(LIMIT_FIELD_DESC);
+      oprot.writeI64(this.limit);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getOutstandingPayments_args(");
+      boolean first = true;
+      sb.append("fetchType:");
+      if (this.fetchType == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.fetchType);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("userId:");
+      sb.append(this.userId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("limit:");
+      sb.append(this.limit);
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws org.apache.thrift.TException {
+      // check for required fields
+    }
+    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+      try {
+        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+      try {
+        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+        __isset_bit_vector = new BitSet(1);
+        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+  }
+  public static class getOutstandingPayments_result implements org.apache.thrift.TBase<getOutstandingPayments_result, getOutstandingPayments_result._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getOutstandingPayments_result");
+    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0);
+    private List<OutstandingPayments> success; // required
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+      SUCCESS((short)0, "success");
+      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+      static {
+        for (_Fields field : EnumSet.allOf(_Fields.class)) {
+          byName.put(field.getFieldName(), field);
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, or null if its not found.
+       */
+      public static _Fields findByThriftId(int fieldId) {
+        switch(fieldId) {
+          case 0: // SUCCESS
+            return SUCCESS;
+          default:
+            return null;
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, throwing an exception
+       * if it is not found.
+       */
+      public static _Fields findByThriftIdOrThrow(int fieldId) {
+        _Fields fields = findByThriftId(fieldId);
+        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+        return fields;
+      }
+      /**
+       * Find the _Fields constant that matches name, or null if its not found.
+       */
+      public static _Fields findByName(String name) {
+        return byName.get(name);
+      }
+      private final short _thriftId;
+      private final String _fieldName;
+      _Fields(short thriftId, String fieldName) {
+        _thriftId = thriftId;
+        _fieldName = fieldName;
+      }
+      public short getThriftFieldId() {
+        return _thriftId;
+      }
+      public String getFieldName() {
+        return _fieldName;
+      }
+    }
+    // isset id assignments
+    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+    static {
+      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+              new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, OutstandingPayments.class))));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getOutstandingPayments_result.class, metaDataMap);
+    }
+    public getOutstandingPayments_result() {
+    }
+    public getOutstandingPayments_result(
+      List<OutstandingPayments> success)
+    {
+      this();
+      this.success = success;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getOutstandingPayments_result(getOutstandingPayments_result other) {
+      if (other.isSetSuccess()) {
+        List<OutstandingPayments> __this__success = new ArrayList<OutstandingPayments>();
+        for (OutstandingPayments other_element : other.success) {
+          __this__success.add(new OutstandingPayments(other_element));
+        }
+        this.success = __this__success;
+      }
+    }
+    public getOutstandingPayments_result deepCopy() {
+      return new getOutstandingPayments_result(this);
+    }
+    @Override
+    public void clear() {
+      this.success = null;
+    }
+    public int getSuccessSize() {
+      return (this.success == null) ? 0 : this.success.size();
+    }
+    public java.util.Iterator<OutstandingPayments> getSuccessIterator() {
+      return (this.success == null) ? null : this.success.iterator();
+    }
+    public void addToSuccess(OutstandingPayments elem) {
+      if (this.success == null) {
+        this.success = new ArrayList<OutstandingPayments>();
+      }
+      this.success.add(elem);
+    }
+    public List<OutstandingPayments> getSuccess() {
+      return this.success;
+    }
+    public void setSuccess(List<OutstandingPayments> success) {
+      this.success = success;
+    }
+    public void unsetSuccess() {
+      this.success = null;
+    }
+    /** Returns true if field success is set (has been assigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return this.success != null;
+    }
+    public void setSuccessIsSet(boolean value) {
+      if (!value) {
+        this.success = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((List<OutstandingPayments>)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case SUCCESS:
+        return getSuccess();
+      }
+      throw new IllegalStateException();
+    }
+    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+    public boolean isSet(_Fields field) {
+      if (field == null) {
+        throw new IllegalArgumentException();
+      }
+      switch (field) {
+      case SUCCESS:
+        return isSetSuccess();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof getOutstandingPayments_result)
+        return this.equals((getOutstandingPayments_result)that);
+      return false;
+    }
+    public boolean equals(getOutstandingPayments_result that) {
+      if (that == null)
+        return false;
+      boolean this_present_success = true && this.isSetSuccess();
+      boolean that_present_success = true && that.isSetSuccess();
+      if (this_present_success || that_present_success) {
+        if (!(this_present_success && that_present_success))
+          return false;
+        if (!this.success.equals(that.success))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getOutstandingPayments_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getOutstandingPayments_result typedOther = (getOutstandingPayments_result)other;
+      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetSuccess()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      return 0;
+    }
+    public _Fields fieldForId(int fieldId) {
+      return _Fields.findByThriftId(fieldId);
+    }
+    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField field;
+      iprot.readStructBegin();
+      while (true)
+      {
+        field = iprot.readFieldBegin();
+        if (field.type == org.apache.thrift.protocol.TType.STOP) {
+          break;
+        }
+        switch (field.id) {
+          case 0: // SUCCESS
+            if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
+                org.apache.thrift.protocol.TList _list692 = iprot.readListBegin();
+                this.success = new ArrayList<OutstandingPayments>(_list692.size);
+                for (int _i693 = 0; _i693 < _list692.size; ++_i693)
+                {
+                  OutstandingPayments _elem694; // required
+                  _elem694 = new OutstandingPayments();
+                  _elem694.read(iprot);
+                  this.success.add(_elem694);
+                }
+                iprot.readListEnd();
+              }
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
+          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
+          for (OutstandingPayments _iter695 : this.success)
+          {
+            _iter695.write(oprot);
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getOutstandingPayments_result(");
+      boolean first = true;
+      sb.append("success:");
+      if (this.success == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.success);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws org.apache.thrift.TException {
+      // check for required fields
+    }
+    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+      try {
+        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+      try {
+        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+  }
   public static class getReturnOrderInfo_args implements org.apache.thrift.TBase<getReturnOrderInfo_args, getReturnOrderInfo_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getReturnOrderInfo_args");
     private static final org.apache.thrift.protocol.TField ID_FIELD_DESC = new org.apache.thrift.protocol.TField("id", org.apache.thrift.protocol.TType.I64, (short)1);
+        }
         switch (field.id) {
           case 1: // ORDER_IDS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list692 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list696 = iprot.readListBegin();
-                this.order_ids = new ArrayList<Long>(_list692.size);
+                this.order_ids = new ArrayList<Long>(_list696.size);
-                for (int _i693 = 0; _i693 < _list692.size; ++_i693)
+                for (int _i697 = 0; _i697 < _list696.size; ++_i697)
                 {
-                  long _elem694; // required
+                  long _elem698; // required
-                  _elem694 = iprot.readI64();
+                  _elem698 = iprot.readI64();
-                  this.order_ids.add(_elem694);
+                  this.order_ids.add(_elem698);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.order_ids != null) {
         oprot.writeFieldBegin(ORDER_IDS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.order_ids.size()));
-          for (long _iter695 : this.order_ids)
+          for (long _iter699 : this.order_ids)
+          {
-            oprot.writeI64(_iter695);
+            oprot.writeI64(_iter699);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map696 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map700 = iprot.readMapBegin();
-                this.success = new HashMap<Long,List<ReturnOrderInfo>>(2*_map696.size);
+                this.success = new HashMap<Long,List<ReturnOrderInfo>>(2*_map700.size);
-                for (int _i697 = 0; _i697 < _map696.size; ++_i697)
+                for (int _i701 = 0; _i701 < _map700.size; ++_i701)
                 {
-                  long _key698; // required
+                  long _key702; // required
-                  List<ReturnOrderInfo> _val699; // required
+                  List<ReturnOrderInfo> _val703; // required
-                  _key698 = iprot.readI64();
+                  _key702 = iprot.readI64();
+                  {
-                    org.apache.thrift.protocol.TList _list700 = iprot.readListBegin();
+                    org.apache.thrift.protocol.TList _list704 = iprot.readListBegin();
-                    _val699 = new ArrayList<ReturnOrderInfo>(_list700.size);
+                    _val703 = new ArrayList<ReturnOrderInfo>(_list704.size);
-                    for (int _i701 = 0; _i701 < _list700.size; ++_i701)
+                    for (int _i705 = 0; _i705 < _list704.size; ++_i705)
+                    {
-                      ReturnOrderInfo _elem702; // required
+                      ReturnOrderInfo _elem706; // required
-                      _elem702 = new ReturnOrderInfo();
+                      _elem706 = new ReturnOrderInfo();
-                      _elem702.read(iprot);
+                      _elem706.read(iprot);
-                      _val699.add(_elem702);
+                      _val703.add(_elem706);
+                    }
                     iprot.readListEnd();
+                  }
-                  this.success.put(_key698, _val699);
+                  this.success.put(_key702, _val703);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.LIST, this.success.size()));
-          for (Map.Entry<Long, List<ReturnOrderInfo>> _iter703 : this.success.entrySet())
+          for (Map.Entry<Long, List<ReturnOrderInfo>> _iter707 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter703.getKey());
+            oprot.writeI64(_iter707.getKey());
+            {
-              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter703.getValue().size()));
+              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter707.getValue().size()));
-              for (ReturnOrderInfo _iter704 : _iter703.getValue())
+              for (ReturnOrderInfo _iter708 : _iter707.getValue())
+              {
-                _iter704.write(oprot);
+                _iter708.write(oprot);
+              }
               oprot.writeListEnd();
+            }
+          }
           oprot.writeMapEnd();
+        }
         switch (field.id) {
           case 1: // ORDER_IDS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list705 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list709 = iprot.readListBegin();
-                this.order_ids = new ArrayList<Long>(_list705.size);
+                this.order_ids = new ArrayList<Long>(_list709.size);
-                for (int _i706 = 0; _i706 < _list705.size; ++_i706)
+                for (int _i710 = 0; _i710 < _list709.size; ++_i710)
                 {
-                  long _elem707; // required
+                  long _elem711; // required
-                  _elem707 = iprot.readI64();
+                  _elem711 = iprot.readI64();
-                  this.order_ids.add(_elem707);
+                  this.order_ids.add(_elem711);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
             break;
           case 2: // STATUSES
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list708 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list712 = iprot.readListBegin();
-                this.statuses = new ArrayList<String>(_list708.size);
+                this.statuses = new ArrayList<String>(_list712.size);
-                for (int _i709 = 0; _i709 < _list708.size; ++_i709)
+                for (int _i713 = 0; _i713 < _list712.size; ++_i713)
                 {
-                  String _elem710; // required
+                  String _elem714; // required
-                  _elem710 = iprot.readString();
+                  _elem714 = iprot.readString();
-                  this.statuses.add(_elem710);
+                  this.statuses.add(_elem714);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.order_ids != null) {
         oprot.writeFieldBegin(ORDER_IDS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.order_ids.size()));
-          for (long _iter711 : this.order_ids)
+          for (long _iter715 : this.order_ids)
+          {
-            oprot.writeI64(_iter711);
+            oprot.writeI64(_iter715);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
       if (this.statuses != null) {
         oprot.writeFieldBegin(STATUSES_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.statuses.size()));
-          for (String _iter712 : this.statuses)
+          for (String _iter716 : this.statuses)
+          {
-            oprot.writeString(_iter712);
+            oprot.writeString(_iter716);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map713 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map717 = iprot.readMapBegin();
-                this.success = new HashMap<Long,List<ReturnOrderInfo>>(2*_map713.size);
+                this.success = new HashMap<Long,List<ReturnOrderInfo>>(2*_map717.size);
-                for (int _i714 = 0; _i714 < _map713.size; ++_i714)
+                for (int _i718 = 0; _i718 < _map717.size; ++_i718)
                 {
-                  long _key715; // required
+                  long _key719; // required
-                  List<ReturnOrderInfo> _val716; // required
+                  List<ReturnOrderInfo> _val720; // required
-                  _key715 = iprot.readI64();
+                  _key719 = iprot.readI64();
+                  {
-                    org.apache.thrift.protocol.TList _list717 = iprot.readListBegin();
+                    org.apache.thrift.protocol.TList _list721 = iprot.readListBegin();
-                    _val716 = new ArrayList<ReturnOrderInfo>(_list717.size);
+                    _val720 = new ArrayList<ReturnOrderInfo>(_list721.size);
-                    for (int _i718 = 0; _i718 < _list717.size; ++_i718)
+                    for (int _i722 = 0; _i722 < _list721.size; ++_i722)
+                    {
-                      ReturnOrderInfo _elem719; // required
+                      ReturnOrderInfo _elem723; // required
-                      _elem719 = new ReturnOrderInfo();
+                      _elem723 = new ReturnOrderInfo();
-                      _elem719.read(iprot);
+                      _elem723.read(iprot);
-                      _val716.add(_elem719);
+                      _val720.add(_elem723);
+                    }
                     iprot.readListEnd();
+                  }
-                  this.success.put(_key715, _val716);
+                  this.success.put(_key719, _val720);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.LIST, this.success.size()));
-          for (Map.Entry<Long, List<ReturnOrderInfo>> _iter720 : this.success.entrySet())
+          for (Map.Entry<Long, List<ReturnOrderInfo>> _iter724 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter720.getKey());
+            oprot.writeI64(_iter724.getKey());
+            {
-              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter720.getValue().size()));
+              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter724.getValue().size()));
-              for (ReturnOrderInfo _iter721 : _iter720.getValue())
+              for (ReturnOrderInfo _iter725 : _iter724.getValue())
+              {
-                _iter721.write(oprot);
+                _iter725.write(oprot);
+              }
               oprot.writeListEnd();
+            }
+          }
           oprot.writeMapEnd();
+        }
         switch (field.id) {
           case 1: // ORDER_RETURN_INFOS_MAP
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map722 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map726 = iprot.readMapBegin();
-                this.orderReturnInfosMap = new HashMap<Long,List<ReturnOrderInfo>>(2*_map722.size);
+                this.orderReturnInfosMap = new HashMap<Long,List<ReturnOrderInfo>>(2*_map726.size);
-                for (int _i723 = 0; _i723 < _map722.size; ++_i723)
+                for (int _i727 = 0; _i727 < _map726.size; ++_i727)
                 {
-                  long _key724; // required
+                  long _key728; // required
-                  List<ReturnOrderInfo> _val725; // required
+                  List<ReturnOrderInfo> _val729; // required
-                  _key724 = iprot.readI64();
+                  _key728 = iprot.readI64();
+                  {
-                    org.apache.thrift.protocol.TList _list726 = iprot.readListBegin();
+                    org.apache.thrift.protocol.TList _list730 = iprot.readListBegin();
-                    _val725 = new ArrayList<ReturnOrderInfo>(_list726.size);
+                    _val729 = new ArrayList<ReturnOrderInfo>(_list730.size);
-                    for (int _i727 = 0; _i727 < _list726.size; ++_i727)
+                    for (int _i731 = 0; _i731 < _list730.size; ++_i731)
+                    {
-                      ReturnOrderInfo _elem728; // required
+                      ReturnOrderInfo _elem732; // required
-                      _elem728 = new ReturnOrderInfo();
+                      _elem732 = new ReturnOrderInfo();
-                      _elem728.read(iprot);
+                      _elem732.read(iprot);
-                      _val725.add(_elem728);
+                      _val729.add(_elem732);
+                    }
                     iprot.readListEnd();
+                  }
-                  this.orderReturnInfosMap.put(_key724, _val725);
+                  this.orderReturnInfosMap.put(_key728, _val729);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.orderReturnInfosMap != null) {
         oprot.writeFieldBegin(ORDER_RETURN_INFOS_MAP_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.LIST, this.orderReturnInfosMap.size()));
-          for (Map.Entry<Long, List<ReturnOrderInfo>> _iter729 : this.orderReturnInfosMap.entrySet())
+          for (Map.Entry<Long, List<ReturnOrderInfo>> _iter733 : this.orderReturnInfosMap.entrySet())
+          {
-            oprot.writeI64(_iter729.getKey());
+            oprot.writeI64(_iter733.getKey());
+            {
-              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter729.getValue().size()));
+              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter733.getValue().size()));
-              for (ReturnOrderInfo _iter730 : _iter729.getValue())
+              for (ReturnOrderInfo _iter734 : _iter733.getValue())
+              {
-                _iter730.write(oprot);
+                _iter734.write(oprot);
+              }
               oprot.writeListEnd();
+            }
+          }
           oprot.writeMapEnd();
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map731 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map735 = iprot.readMapBegin();
-                this.success = new HashMap<Long,Boolean>(2*_map731.size);
+                this.success = new HashMap<Long,Boolean>(2*_map735.size);
-                for (int _i732 = 0; _i732 < _map731.size; ++_i732)
+                for (int _i736 = 0; _i736 < _map735.size; ++_i736)
                 {
-                  long _key733; // required
+                  long _key737; // required
-                  boolean _val734; // required
+                  boolean _val738; // required
-                  _key733 = iprot.readI64();
+                  _key737 = iprot.readI64();
-                  _val734 = iprot.readBool();
+                  _val738 = iprot.readBool();
-                  this.success.put(_key733, _val734);
+                  this.success.put(_key737, _val738);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.BOOL, this.success.size()));
-          for (Map.Entry<Long, Boolean> _iter735 : this.success.entrySet())
+          for (Map.Entry<Long, Boolean> _iter739 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter735.getKey());
+            oprot.writeI64(_iter739.getKey());
-            oprot.writeBool(_iter735.getValue());
+            oprot.writeBool(_iter739.getValue());
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list736 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list740 = iprot.readListBegin();
-                this.success = new ArrayList<ReturnOrderInfo>(_list736.size);
+                this.success = new ArrayList<ReturnOrderInfo>(_list740.size);
-                for (int _i737 = 0; _i737 < _list736.size; ++_i737)
+                for (int _i741 = 0; _i741 < _list740.size; ++_i741)
                 {
-                  ReturnOrderInfo _elem738; // required
+                  ReturnOrderInfo _elem742; // required
-                  _elem738 = new ReturnOrderInfo();
+                  _elem742 = new ReturnOrderInfo();
-                  _elem738.read(iprot);
+                  _elem742.read(iprot);
-                  this.success.add(_elem738);
+                  this.success.add(_elem742);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (ReturnOrderInfo _iter739 : this.success)
+          for (ReturnOrderInfo _iter743 : this.success)
+          {
-            _iter739.write(oprot);
+            _iter743.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list740 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list744 = iprot.readListBegin();
-                this.success = new ArrayList<ReturnOrderInfo>(_list740.size);
+                this.success = new ArrayList<ReturnOrderInfo>(_list744.size);
-                for (int _i741 = 0; _i741 < _list740.size; ++_i741)
+                for (int _i745 = 0; _i745 < _list744.size; ++_i745)
+                {
-                  ReturnOrderInfo _elem742; // required
+                  ReturnOrderInfo _elem746; // required
-                  _elem742 = new ReturnOrderInfo();
+                  _elem746 = new ReturnOrderInfo();
-                  _elem742.read(iprot);
+                  _elem746.read(iprot);
-                  this.success.add(_elem742);
+                  this.success.add(_elem746);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (ReturnOrderInfo _iter743 : this.success)
+          for (ReturnOrderInfo _iter747 : this.success)
+          {
-            _iter743.write(oprot);
+            _iter747.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+            }
             break;
           case 3: // RETURN_ORDER_IDS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list744 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list748 = iprot.readListBegin();
-                this.returnOrderIds = new ArrayList<Long>(_list744.size);
+                this.returnOrderIds = new ArrayList<Long>(_list748.size);
-                for (int _i745 = 0; _i745 < _list744.size; ++_i745)
+                for (int _i749 = 0; _i749 < _list748.size; ++_i749)
+                {
-                  long _elem746; // required
+                  long _elem750; // required
-                  _elem746 = iprot.readI64();
+                  _elem750 = iprot.readI64();
-                  this.returnOrderIds.add(_elem746);
+                  this.returnOrderIds.add(_elem750);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+      }
       if (this.returnOrderIds != null) {
         oprot.writeFieldBegin(RETURN_ORDER_IDS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.returnOrderIds.size()));
-          for (long _iter747 : this.returnOrderIds)
+          for (long _iter751 : this.returnOrderIds)
+          {
-            oprot.writeI64(_iter747);
+            oprot.writeI64(_iter751);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // RETURN_ORDER_IDS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list748 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list752 = iprot.readListBegin();
-                this.returnOrderIds = new ArrayList<Long>(_list748.size);
+                this.returnOrderIds = new ArrayList<Long>(_list752.size);
-                for (int _i749 = 0; _i749 < _list748.size; ++_i749)
+                for (int _i753 = 0; _i753 < _list752.size; ++_i753)
+                {
-                  long _elem750; // required
+                  long _elem754; // required
-                  _elem750 = iprot.readI64();
+                  _elem754 = iprot.readI64();
-                  this.returnOrderIds.add(_elem750);
+                  this.returnOrderIds.add(_elem754);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.returnOrderIds != null) {
         oprot.writeFieldBegin(RETURN_ORDER_IDS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.returnOrderIds.size()));
-          for (long _iter751 : this.returnOrderIds)
+          for (long _iter755 : this.returnOrderIds)
+          {
-            oprot.writeI64(_iter751);
+            oprot.writeI64(_iter755);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list752 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list756 = iprot.readListBegin();
-                this.success = new ArrayList<ReturnOrderInfo>(_list752.size);
+                this.success = new ArrayList<ReturnOrderInfo>(_list756.size);
-                for (int _i753 = 0; _i753 < _list752.size; ++_i753)
+                for (int _i757 = 0; _i757 < _list756.size; ++_i757)
                 {
-                  ReturnOrderInfo _elem754; // required
+                  ReturnOrderInfo _elem758; // required
-                  _elem754 = new ReturnOrderInfo();
+                  _elem758 = new ReturnOrderInfo();
-                  _elem754.read(iprot);
+                  _elem758.read(iprot);
-                  this.success.add(_elem754);
+                  this.success.add(_elem758);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (ReturnOrderInfo _iter755 : this.success)
+          for (ReturnOrderInfo _iter759 : this.success)
+          {
-            _iter755.write(oprot);
+            _iter759.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+        }
         switch (field.id) {
           case 1: // RETURN_ORDERS_MAP
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map756 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map760 = iprot.readMapBegin();
-                this.returnOrdersMap = new HashMap<Long,Map<String,String>>(2*_map756.size);
+                this.returnOrdersMap = new HashMap<Long,Map<String,String>>(2*_map760.size);
-                for (int _i757 = 0; _i757 < _map756.size; ++_i757)
+                for (int _i761 = 0; _i761 < _map760.size; ++_i761)
                 {
-                  long _key758; // required
+                  long _key762; // required
-                  Map<String,String> _val759; // required
+                  Map<String,String> _val763; // required
-                  _key758 = iprot.readI64();
+                  _key762 = iprot.readI64();
+                  {
-                    org.apache.thrift.protocol.TMap _map760 = iprot.readMapBegin();
+                    org.apache.thrift.protocol.TMap _map764 = iprot.readMapBegin();
-                    _val759 = new HashMap<String,String>(2*_map760.size);
+                    _val763 = new HashMap<String,String>(2*_map764.size);
-                    for (int _i761 = 0; _i761 < _map760.size; ++_i761)
+                    for (int _i765 = 0; _i765 < _map764.size; ++_i765)
+                    {
-                      String _key762; // required
+                      String _key766; // required
-                      String _val763; // required
+                      String _val767; // required
-                      _key762 = iprot.readString();
+                      _key766 = iprot.readString();
-                      _val763 = iprot.readString();
+                      _val767 = iprot.readString();
-                      _val759.put(_key762, _val763);
+                      _val763.put(_key766, _val767);
+                    }
                     iprot.readMapEnd();
+                  }
-                  this.returnOrdersMap.put(_key758, _val759);
+                  this.returnOrdersMap.put(_key762, _val763);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.returnOrdersMap != null) {
         oprot.writeFieldBegin(RETURN_ORDERS_MAP_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.MAP, this.returnOrdersMap.size()));
-          for (Map.Entry<Long, Map<String,String>> _iter764 : this.returnOrdersMap.entrySet())
+          for (Map.Entry<Long, Map<String,String>> _iter768 : this.returnOrdersMap.entrySet())
+          {
-            oprot.writeI64(_iter764.getKey());
+            oprot.writeI64(_iter768.getKey());
+            {
-              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter764.getValue().size()));
+              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter768.getValue().size()));
-              for (Map.Entry<String, String> _iter765 : _iter764.getValue().entrySet())
+              for (Map.Entry<String, String> _iter769 : _iter768.getValue().entrySet())
+              {
-                oprot.writeString(_iter765.getKey());
+                oprot.writeString(_iter769.getKey());
-                oprot.writeString(_iter765.getValue());
+                oprot.writeString(_iter769.getValue());
+              }
               oprot.writeMapEnd();
+            }
+          }
           oprot.writeMapEnd();
+            }
             break;
           case 2: // RETURN_ORDERS_MAP
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map766 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map770 = iprot.readMapBegin();
-                this.returnOrdersMap = new HashMap<Long,Boolean>(2*_map766.size);
+                this.returnOrdersMap = new HashMap<Long,Boolean>(2*_map770.size);
-                for (int _i767 = 0; _i767 < _map766.size; ++_i767)
+                for (int _i771 = 0; _i771 < _map770.size; ++_i771)
                 {
-                  long _key768; // required
+                  long _key772; // required
-                  boolean _val769; // required
+                  boolean _val773; // required
-                  _key768 = iprot.readI64();
+                  _key772 = iprot.readI64();
-                  _val769 = iprot.readBool();
+                  _val773 = iprot.readBool();
-                  this.returnOrdersMap.put(_key768, _val769);
+                  this.returnOrdersMap.put(_key772, _val773);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeFieldEnd();
       if (this.returnOrdersMap != null) {
         oprot.writeFieldBegin(RETURN_ORDERS_MAP_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.BOOL, this.returnOrdersMap.size()));
-          for (Map.Entry<Long, Boolean> _iter770 : this.returnOrdersMap.entrySet())
+          for (Map.Entry<Long, Boolean> _iter774 : this.returnOrdersMap.entrySet())
+          {
-            oprot.writeI64(_iter770.getKey());
+            oprot.writeI64(_iter774.getKey());
-            oprot.writeBool(_iter770.getValue());
+            oprot.writeBool(_iter774.getValue());
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }
+            }
             break;
           case 2: // RETURN_ORDERS_MAP
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map771 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map775 = iprot.readMapBegin();
-                this.returnOrdersMap = new HashMap<Long,Map<String,String>>(2*_map771.size);
+                this.returnOrdersMap = new HashMap<Long,Map<String,String>>(2*_map775.size);
-                for (int _i772 = 0; _i772 < _map771.size; ++_i772)
+                for (int _i776 = 0; _i776 < _map775.size; ++_i776)
                 {
-                  long _key773; // required
+                  long _key777; // required
-                  Map<String,String> _val774; // required
+                  Map<String,String> _val778; // required
-                  _key773 = iprot.readI64();
+                  _key777 = iprot.readI64();
+                  {
-                    org.apache.thrift.protocol.TMap _map775 = iprot.readMapBegin();
+                    org.apache.thrift.protocol.TMap _map779 = iprot.readMapBegin();
-                    _val774 = new HashMap<String,String>(2*_map775.size);
+                    _val778 = new HashMap<String,String>(2*_map779.size);
-                    for (int _i776 = 0; _i776 < _map775.size; ++_i776)
+                    for (int _i780 = 0; _i780 < _map779.size; ++_i780)
+                    {
-                      String _key777; // required
+                      String _key781; // required
-                      String _val778; // required
+                      String _val782; // required
-                      _key777 = iprot.readString();
+                      _key781 = iprot.readString();
-                      _val778 = iprot.readString();
+                      _val782 = iprot.readString();
-                      _val774.put(_key777, _val778);
+                      _val778.put(_key781, _val782);
+                    }
                     iprot.readMapEnd();
+                  }
-                  this.returnOrdersMap.put(_key773, _val774);
+                  this.returnOrdersMap.put(_key777, _val778);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeFieldEnd();
       if (this.returnOrdersMap != null) {
         oprot.writeFieldBegin(RETURN_ORDERS_MAP_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.MAP, this.returnOrdersMap.size()));
-          for (Map.Entry<Long, Map<String,String>> _iter779 : this.returnOrdersMap.entrySet())
+          for (Map.Entry<Long, Map<String,String>> _iter783 : this.returnOrdersMap.entrySet())
+          {
-            oprot.writeI64(_iter779.getKey());
+            oprot.writeI64(_iter783.getKey());
+            {
-              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter779.getValue().size()));
+              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter783.getValue().size()));
-              for (Map.Entry<String, String> _iter780 : _iter779.getValue().entrySet())
+              for (Map.Entry<String, String> _iter784 : _iter783.getValue().entrySet())
+              {
-                oprot.writeString(_iter780.getKey());
+                oprot.writeString(_iter784.getKey());
-                oprot.writeString(_iter780.getValue());
+                oprot.writeString(_iter784.getValue());
+              }
               oprot.writeMapEnd();
+            }
+          }
           oprot.writeMapEnd();
+        }
         switch (field.id) {
           case 1: // REFUND_ORDERS_MAP
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map781 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map785 = iprot.readMapBegin();
-                this.refundOrdersMap = new HashMap<Long,Map<String,String>>(2*_map781.size);
+                this.refundOrdersMap = new HashMap<Long,Map<String,String>>(2*_map785.size);
-                for (int _i782 = 0; _i782 < _map781.size; ++_i782)
+                for (int _i786 = 0; _i786 < _map785.size; ++_i786)
                 {
-                  long _key783; // required
+                  long _key787; // required
-                  Map<String,String> _val784; // required
+                  Map<String,String> _val788; // required
-                  _key783 = iprot.readI64();
+                  _key787 = iprot.readI64();
+                  {
-                    org.apache.thrift.protocol.TMap _map785 = iprot.readMapBegin();
+                    org.apache.thrift.protocol.TMap _map789 = iprot.readMapBegin();
-                    _val784 = new HashMap<String,String>(2*_map785.size);
+                    _val788 = new HashMap<String,String>(2*_map789.size);
-                    for (int _i786 = 0; _i786 < _map785.size; ++_i786)
+                    for (int _i790 = 0; _i790 < _map789.size; ++_i790)
+                    {
-                      String _key787; // required
+                      String _key791; // required
-                      String _val788; // required
+                      String _val792; // required
-                      _key787 = iprot.readString();
+                      _key791 = iprot.readString();
-                      _val788 = iprot.readString();
+                      _val792 = iprot.readString();
-                      _val784.put(_key787, _val788);
+                      _val788.put(_key791, _val792);
+                    }
                     iprot.readMapEnd();
+                  }
-                  this.refundOrdersMap.put(_key783, _val784);
+                  this.refundOrdersMap.put(_key787, _val788);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.refundOrdersMap != null) {
         oprot.writeFieldBegin(REFUND_ORDERS_MAP_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.MAP, this.refundOrdersMap.size()));
-          for (Map.Entry<Long, Map<String,String>> _iter789 : this.refundOrdersMap.entrySet())
+          for (Map.Entry<Long, Map<String,String>> _iter793 : this.refundOrdersMap.entrySet())
+          {
-            oprot.writeI64(_iter789.getKey());
+            oprot.writeI64(_iter793.getKey());
+            {
-              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter789.getValue().size()));
+              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter793.getValue().size()));
-              for (Map.Entry<String, String> _iter790 : _iter789.getValue().entrySet())
+              for (Map.Entry<String, String> _iter794 : _iter793.getValue().entrySet())
+              {
-                oprot.writeString(_iter790.getKey());
+                oprot.writeString(_iter794.getKey());
-                oprot.writeString(_iter790.getValue());
+                oprot.writeString(_iter794.getValue());
+              }
               oprot.writeMapEnd();
+            }
+          }
           oprot.writeMapEnd();
+        }
         switch (field.id) {
           case 1: // STATUS_LIST
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list791 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list795 = iprot.readListBegin();
-                this.statusList = new ArrayList<ReturnTransactionStatus>(_list791.size);
+                this.statusList = new ArrayList<ReturnTransactionStatus>(_list795.size);
-                for (int _i792 = 0; _i792 < _list791.size; ++_i792)
+                for (int _i796 = 0; _i796 < _list795.size; ++_i796)
                 {
-                  ReturnTransactionStatus _elem793; // required
+                  ReturnTransactionStatus _elem797; // required
-                  _elem793 = ReturnTransactionStatus.findByValue(iprot.readI32());
+                  _elem797 = ReturnTransactionStatus.findByValue(iprot.readI32());
-                  this.statusList.add(_elem793);
+                  this.statusList.add(_elem797);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.statusList != null) {
         oprot.writeFieldBegin(STATUS_LIST_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statusList.size()));
-          for (ReturnTransactionStatus _iter794 : this.statusList)
+          for (ReturnTransactionStatus _iter798 : this.statusList)
+          {
-            oprot.writeI32(_iter794.getValue());
+            oprot.writeI32(_iter798.getValue());
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list795 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list799 = iprot.readListBegin();
-                this.success = new ArrayList<ReturnTransaction>(_list795.size);
+                this.success = new ArrayList<ReturnTransaction>(_list799.size);
-                for (int _i796 = 0; _i796 < _list795.size; ++_i796)
+                for (int _i800 = 0; _i800 < _list799.size; ++_i800)
+                {
-                  ReturnTransaction _elem797; // required
+                  ReturnTransaction _elem801; // required
-                  _elem797 = new ReturnTransaction();
+                  _elem801 = new ReturnTransaction();
-                  _elem797.read(iprot);
+                  _elem801.read(iprot);
-                  this.success.add(_elem797);
+                  this.success.add(_elem801);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (ReturnTransaction _iter798 : this.success)
+          for (ReturnTransaction _iter802 : this.success)
+          {
-            _iter798.write(oprot);
+            _iter802.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+        }
         switch (field.id) {
           case 1: // STATUSES
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list799 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list803 = iprot.readListBegin();
-                this.statuses = new ArrayList<OrderStatus>(_list799.size);
+                this.statuses = new ArrayList<OrderStatus>(_list803.size);
-                for (int _i800 = 0; _i800 < _list799.size; ++_i800)
+                for (int _i804 = 0; _i804 < _list803.size; ++_i804)
+                {
-                  OrderStatus _elem801; // required
+                  OrderStatus _elem805; // required
-                  _elem801 = OrderStatus.findByValue(iprot.readI32());
+                  _elem805 = OrderStatus.findByValue(iprot.readI32());
-                  this.statuses.add(_elem801);
+                  this.statuses.add(_elem805);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.statuses != null) {
         oprot.writeFieldBegin(STATUSES_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
-          for (OrderStatus _iter802 : this.statuses)
+          for (OrderStatus _iter806 : this.statuses)
+          {
-            oprot.writeI32(_iter802.getValue());
+            oprot.writeI32(_iter806.getValue());
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list803 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list807 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list803.size);
+                this.success = new ArrayList<Order>(_list807.size);
-                for (int _i804 = 0; _i804 < _list803.size; ++_i804)
+                for (int _i808 = 0; _i808 < _list807.size; ++_i808)
+                {
-                  Order _elem805; // required
+                  Order _elem809; // required
-                  _elem805 = new Order();
+                  _elem809 = new Order();
-                  _elem805.read(iprot);
+                  _elem809.read(iprot);
-                  this.success.add(_elem805);
+                  this.success.add(_elem809);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Order _iter806 : this.success)
+          for (Order _iter810 : this.success)
+          {
-            _iter806.write(oprot);
+            _iter810.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+            }
             break;
           case 2: // ATTRIBUTES
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list807 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list811 = iprot.readListBegin();
-                this.attributes = new ArrayList<Attribute>(_list807.size);
+                this.attributes = new ArrayList<Attribute>(_list811.size);
-                for (int _i808 = 0; _i808 < _list807.size; ++_i808)
+                for (int _i812 = 0; _i812 < _list811.size; ++_i812)
+                {
-                  Attribute _elem809; // required
+                  Attribute _elem813; // required
-                  _elem809 = new Attribute();
+                  _elem813 = new Attribute();
-                  _elem809.read(iprot);
+                  _elem813.read(iprot);
-                  this.attributes.add(_elem809);
+                  this.attributes.add(_elem813);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+      }
       if (this.attributes != null) {
         oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.attributes.size()));
-          for (Attribute _iter810 : this.attributes)
+          for (Attribute _iter814 : this.attributes)
+          {
-            _iter810.write(oprot);
+            _iter814.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // SHIPMENT_LOGISTICS_COST_DETAILS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list811 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list815 = iprot.readListBegin();
-                this.shipmentLogisticsCostDetails = new ArrayList<ShipmentLogisticsCostDetail>(_list811.size);
+                this.shipmentLogisticsCostDetails = new ArrayList<ShipmentLogisticsCostDetail>(_list815.size);
-                for (int _i812 = 0; _i812 < _list811.size; ++_i812)
+                for (int _i816 = 0; _i816 < _list815.size; ++_i816)
+                {
-                  ShipmentLogisticsCostDetail _elem813; // required
+                  ShipmentLogisticsCostDetail _elem817; // required
-                  _elem813 = new ShipmentLogisticsCostDetail();
+                  _elem817 = new ShipmentLogisticsCostDetail();
-                  _elem813.read(iprot);
+                  _elem817.read(iprot);
-                  this.shipmentLogisticsCostDetails.add(_elem813);
+                  this.shipmentLogisticsCostDetails.add(_elem817);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.shipmentLogisticsCostDetails != null) {
         oprot.writeFieldBegin(SHIPMENT_LOGISTICS_COST_DETAILS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.shipmentLogisticsCostDetails.size()));
-          for (ShipmentLogisticsCostDetail _iter814 : this.shipmentLogisticsCostDetails)
+          for (ShipmentLogisticsCostDetail _iter818 : this.shipmentLogisticsCostDetails)
+          {
-            _iter814.write(oprot);
+            _iter818.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list815 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list819 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list815.size);
+                this.success = new ArrayList<Order>(_list819.size);
-                for (int _i816 = 0; _i816 < _list815.size; ++_i816)
+                for (int _i820 = 0; _i820 < _list819.size; ++_i820)
+                {
-                  Order _elem817; // required
+                  Order _elem821; // required
-                  _elem817 = new Order();
+                  _elem821 = new Order();
-                  _elem817.read(iprot);
+                  _elem821.read(iprot);
-                  this.success.add(_elem817);
+                  this.success.add(_elem821);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Order _iter818 : this.success)
+          for (Order _iter822 : this.success)
+          {
-            _iter818.write(oprot);
+            _iter822.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list819 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list823 = iprot.readListBegin();
-                this.success = new ArrayList<ReturnOrderInfo>(_list819.size);
+                this.success = new ArrayList<ReturnOrderInfo>(_list823.size);
-                for (int _i820 = 0; _i820 < _list819.size; ++_i820)
+                for (int _i824 = 0; _i824 < _list823.size; ++_i824)
                 {
-                  ReturnOrderInfo _elem821; // required
+                  ReturnOrderInfo _elem825; // required
-                  _elem821 = new ReturnOrderInfo();
+                  _elem825 = new ReturnOrderInfo();
-                  _elem821.read(iprot);
+                  _elem825.read(iprot);
-                  this.success.add(_elem821);
+                  this.success.add(_elem825);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (ReturnOrderInfo _iter822 : this.success)
+          for (ReturnOrderInfo _iter826 : this.success)
+          {
-            _iter822.write(oprot);
+            _iter826.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+            }
             break;
           case 2: // RETURN_ORDERS_MAP
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map823 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map827 = iprot.readMapBegin();
-                this.returnOrdersMap = new HashMap<Long,Long>(2*_map823.size);
+                this.returnOrdersMap = new HashMap<Long,Long>(2*_map827.size);
-                for (int _i824 = 0; _i824 < _map823.size; ++_i824)
+                for (int _i828 = 0; _i828 < _map827.size; ++_i828)
                 {
-                  long _key825; // required
+                  long _key829; // required
-                  long _val826; // required
+                  long _val830; // required
-                  _key825 = iprot.readI64();
+                  _key829 = iprot.readI64();
-                  _val826 = iprot.readI64();
+                  _val830 = iprot.readI64();
-                  this.returnOrdersMap.put(_key825, _val826);
+                  this.returnOrdersMap.put(_key829, _val830);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeFieldEnd();
       if (this.returnOrdersMap != null) {
         oprot.writeFieldBegin(RETURN_ORDERS_MAP_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.I64, this.returnOrdersMap.size()));
-          for (Map.Entry<Long, Long> _iter827 : this.returnOrdersMap.entrySet())
+          for (Map.Entry<Long, Long> _iter831 : this.returnOrdersMap.entrySet())
+          {
-            oprot.writeI64(_iter827.getKey());
+            oprot.writeI64(_iter831.getKey());
-            oprot.writeI64(_iter827.getValue());
+            oprot.writeI64(_iter831.getValue());
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list828 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list832 = iprot.readListBegin();
-                this.success = new ArrayList<PendingStoreOrder>(_list828.size);
+                this.success = new ArrayList<PendingStoreOrder>(_list832.size);
-                for (int _i829 = 0; _i829 < _list828.size; ++_i829)
+                for (int _i833 = 0; _i833 < _list832.size; ++_i833)
                 {
-                  PendingStoreOrder _elem830; // required
+                  PendingStoreOrder _elem834; // required
-                  _elem830 = new PendingStoreOrder();
+                  _elem834 = new PendingStoreOrder();
-                  _elem830.read(iprot);
+                  _elem834.read(iprot);
-                  this.success.add(_elem830);
+                  this.success.add(_elem834);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (PendingStoreOrder _iter831 : this.success)
+          for (PendingStoreOrder _iter835 : this.success)
+          {
-            _iter831.write(oprot);
+            _iter835.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }

Subversion Repositories SmartDukaan

(root)/trunk/ThriftConfig/src/main/java/in/shop2020/model/v1/order/TransactionService.java – Rev 19869 → 19888