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

     public List<LoanHistory> getLoanHistoryRecordsForUserAndCreditor(long userId, long creditorId, CreditTxnType creditTxnType) throws org.apache.thrift.TException;
     public boolean processLoanTransaction(long paymentId, long userId, long creditorId, List<LoanHistory> creditTxns) throws TransactionServiceException, org.apache.thrift.TException;
+    public List<CreditHistory> getLimitedCreditHistoryRecords(long paymentId, long userId, long creditorId, long limit, long offset) throws org.apache.thrift.TException;
+    public List<LoanHistory> getLimitedLoanHistoryRecords(long paymentId, long userId, long creditorId, long limit, long offset) 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 getLoanHistoryRecordsForUserAndCreditor(long userId, long creditorId, CreditTxnType creditTxnType, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getLoanHistoryRecordsForUserAndCreditor_call> resultHandler) throws org.apache.thrift.TException;
     public void processLoanTransaction(long paymentId, long userId, long creditorId, List<LoanHistory> creditTxns, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.processLoanTransaction_call> resultHandler) throws org.apache.thrift.TException;
+    public void getLimitedCreditHistoryRecords(long paymentId, long userId, long creditorId, long limit, long offset, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getLimitedCreditHistoryRecords_call> resultHandler) 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 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;
         throw result.pe;
+      }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "processLoanTransaction failed: unknown result");
+    }
+    public List<CreditHistory> getLimitedCreditHistoryRecords(long paymentId, long userId, long creditorId, long limit, long offset) throws org.apache.thrift.TException
+    {
+      send_getLimitedCreditHistoryRecords(paymentId, userId, creditorId, limit, offset);
+      return recv_getLimitedCreditHistoryRecords();
+    }
+    public void send_getLimitedCreditHistoryRecords(long paymentId, long userId, long creditorId, long limit, long offset) throws org.apache.thrift.TException
+    {
+      getLimitedCreditHistoryRecords_args args = new getLimitedCreditHistoryRecords_args();
+      args.setPaymentId(paymentId);
+      args.setUserId(userId);
+      args.setCreditorId(creditorId);
+      args.setLimit(limit);
+      args.setOffset(offset);
+      sendBase("getLimitedCreditHistoryRecords", args);
+    }
+    public List<CreditHistory> recv_getLimitedCreditHistoryRecords() throws org.apache.thrift.TException
+    {
+      getLimitedCreditHistoryRecords_result result = new getLimitedCreditHistoryRecords_result();
+      receiveBase(result, "getLimitedCreditHistoryRecords");
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getLimitedCreditHistoryRecords failed: unknown result");
+    }
+    public List<LoanHistory> getLimitedLoanHistoryRecords(long paymentId, long userId, long creditorId, long limit, long offset) throws org.apache.thrift.TException
+    {
+      send_getLimitedLoanHistoryRecords(paymentId, userId, creditorId, limit, offset);
+      return recv_getLimitedLoanHistoryRecords();
+    }
+    public void send_getLimitedLoanHistoryRecords(long paymentId, long userId, long creditorId, long limit, long offset) throws org.apache.thrift.TException
+    {
+      getLimitedLoanHistoryRecords_args args = new getLimitedLoanHistoryRecords_args();
+      args.setPaymentId(paymentId);
+      args.setUserId(userId);
+      args.setCreditorId(creditorId);
+      args.setLimit(limit);
+      args.setOffset(offset);
+      sendBase("getLimitedLoanHistoryRecords", args);
+    }
+    public List<LoanHistory> recv_getLimitedLoanHistoryRecords() throws org.apache.thrift.TException
+    {
+      getLimitedLoanHistoryRecords_result result = new getLimitedLoanHistoryRecords_result();
+      receiveBase(result, "getLimitedLoanHistoryRecords");
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getLimitedLoanHistoryRecords 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_processLoanTransaction();
+      }
+    }
+    public void getLimitedCreditHistoryRecords(long paymentId, long userId, long creditorId, long limit, long offset, org.apache.thrift.async.AsyncMethodCallback<getLimitedCreditHistoryRecords_call> resultHandler) throws org.apache.thrift.TException {
+      checkReady();
+      getLimitedCreditHistoryRecords_call method_call = new getLimitedCreditHistoryRecords_call(paymentId, userId, creditorId, limit, offset, resultHandler, this, ___protocolFactory, ___transport);
+      this.___currentMethod = method_call;
+      ___manager.call(method_call);
+    }
+    public static class getLimitedCreditHistoryRecords_call extends org.apache.thrift.async.TAsyncMethodCall {
+      private long paymentId;
+      private long userId;
+      private long creditorId;
+      private long limit;
+      private long offset;
+      public getLimitedCreditHistoryRecords_call(long paymentId, long userId, long creditorId, long limit, long offset, org.apache.thrift.async.AsyncMethodCallback<getLimitedCreditHistoryRecords_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.paymentId = paymentId;
+        this.userId = userId;
+        this.creditorId = creditorId;
+        this.limit = limit;
+        this.offset = offset;
+      }
+      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getLimitedCreditHistoryRecords", org.apache.thrift.protocol.TMessageType.CALL, 0));
+        getLimitedCreditHistoryRecords_args args = new getLimitedCreditHistoryRecords_args();
+        args.setPaymentId(paymentId);
+        args.setUserId(userId);
+        args.setCreditorId(creditorId);
+        args.setLimit(limit);
+        args.setOffset(offset);
+        args.write(prot);
+        prot.writeMessageEnd();
+      }
+      public List<CreditHistory> 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_getLimitedCreditHistoryRecords();
+      }
+    }
+    public void getLimitedLoanHistoryRecords(long paymentId, long userId, long creditorId, long limit, long offset, org.apache.thrift.async.AsyncMethodCallback<getLimitedLoanHistoryRecords_call> resultHandler) throws org.apache.thrift.TException {
+      checkReady();
+      getLimitedLoanHistoryRecords_call method_call = new getLimitedLoanHistoryRecords_call(paymentId, userId, creditorId, limit, offset, resultHandler, this, ___protocolFactory, ___transport);
+      this.___currentMethod = method_call;
+      ___manager.call(method_call);
+    }
+    public static class getLimitedLoanHistoryRecords_call extends org.apache.thrift.async.TAsyncMethodCall {
+      private long paymentId;
+      private long userId;
+      private long creditorId;
+      private long limit;
+      private long offset;
+      public getLimitedLoanHistoryRecords_call(long paymentId, long userId, long creditorId, long limit, long offset, org.apache.thrift.async.AsyncMethodCallback<getLimitedLoanHistoryRecords_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.paymentId = paymentId;
+        this.userId = userId;
+        this.creditorId = creditorId;
+        this.limit = limit;
+        this.offset = offset;
+      }
+      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getLimitedLoanHistoryRecords", org.apache.thrift.protocol.TMessageType.CALL, 0));
+        getLimitedLoanHistoryRecords_args args = new getLimitedLoanHistoryRecords_args();
+        args.setPaymentId(paymentId);
+        args.setUserId(userId);
+        args.setCreditorId(creditorId);
+        args.setLimit(limit);
+        args.setOffset(offset);
+        args.write(prot);
+        prot.writeMessageEnd();
+      }
+      public List<LoanHistory> 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_getLimitedLoanHistoryRecords();
+      }
+    }
     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("processCreditTransaction", new processCreditTransaction());
       processMap.put("getLoanPayableForUserToCreditor", new getLoanPayableForUserToCreditor());
       processMap.put("getLoanHistoryRecordsForTransaction", new getLoanHistoryRecordsForTransaction());
       processMap.put("getLoanHistoryRecordsForUserAndCreditor", new getLoanHistoryRecordsForUserAndCreditor());
       processMap.put("processLoanTransaction", new processLoanTransaction());
+      processMap.put("getLimitedCreditHistoryRecords", new getLimitedCreditHistoryRecords());
+      processMap.put("getLimitedLoanHistoryRecords", new getLimitedLoanHistoryRecords());
       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());
+        }
         return result;
+      }
+    }
+    private static class getLimitedCreditHistoryRecords<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getLimitedCreditHistoryRecords_args> {
+      public getLimitedCreditHistoryRecords() {
+        super("getLimitedCreditHistoryRecords");
+      }
+      protected getLimitedCreditHistoryRecords_args getEmptyArgsInstance() {
+        return new getLimitedCreditHistoryRecords_args();
+      }
+      protected getLimitedCreditHistoryRecords_result getResult(I iface, getLimitedCreditHistoryRecords_args args) throws org.apache.thrift.TException {
+        getLimitedCreditHistoryRecords_result result = new getLimitedCreditHistoryRecords_result();
+        result.success = iface.getLimitedCreditHistoryRecords(args.paymentId, args.userId, args.creditorId, args.limit, args.offset);
+        return result;
+      }
+    }
+    private static class getLimitedLoanHistoryRecords<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getLimitedLoanHistoryRecords_args> {
+      public getLimitedLoanHistoryRecords() {
+        super("getLimitedLoanHistoryRecords");
+      }
+      protected getLimitedLoanHistoryRecords_args getEmptyArgsInstance() {
+        return new getLimitedLoanHistoryRecords_args();
+      }
+      protected getLimitedLoanHistoryRecords_result getResult(I iface, getLimitedLoanHistoryRecords_args args) throws org.apache.thrift.TException {
+        getLimitedLoanHistoryRecords_result result = new getLimitedLoanHistoryRecords_result();
+        result.success = iface.getLimitedLoanHistoryRecords(args.paymentId, args.userId, args.creditorId, args.limit, args.offset);
+        return result;
+      }
+    }
     private static class getReturnOrderInfo<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getReturnOrderInfo_args> {
       public getReturnOrderInfo() {
         super("getReturnOrderInfo");
+      }
+      }
+    }
     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 getLimitedCreditHistoryRecords_args implements org.apache.thrift.TBase<getLimitedCreditHistoryRecords_args, getLimitedCreditHistoryRecords_args._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getLimitedCreditHistoryRecords_args");
+    private static final org.apache.thrift.protocol.TField PAYMENT_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("paymentId", org.apache.thrift.protocol.TType.I64, (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 CREDITOR_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("creditorId", org.apache.thrift.protocol.TType.I64, (short)3);
+    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)4);
+    private static final org.apache.thrift.protocol.TField OFFSET_FIELD_DESC = new org.apache.thrift.protocol.TField("offset", org.apache.thrift.protocol.TType.I64, (short)5);
+    private long paymentId; // required
+    private long userId; // required
+    private long creditorId; // required
+    private long limit; // required
+    private long offset; // 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 {
+      PAYMENT_ID((short)1, "paymentId"),
+      USER_ID((short)2, "userId"),
+      CREDITOR_ID((short)3, "creditorId"),
+      LIMIT((short)4, "limit"),
+      OFFSET((short)5, "offset");
+      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: // PAYMENT_ID
+            return PAYMENT_ID;
+          case 2: // USER_ID
+            return USER_ID;
+          case 3: // CREDITOR_ID
+            return CREDITOR_ID;
+          case 4: // LIMIT
+            return LIMIT;
+          case 5: // OFFSET
+            return OFFSET;
+          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 __PAYMENTID_ISSET_ID = 0;
+    private static final int __USERID_ISSET_ID = 1;
+    private static final int __CREDITORID_ISSET_ID = 2;
+    private static final int __LIMIT_ISSET_ID = 3;
+    private static final int __OFFSET_ISSET_ID = 4;
+    private BitSet __isset_bit_vector = new BitSet(5);
+    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.PAYMENT_ID, new org.apache.thrift.meta_data.FieldMetaData("paymentId", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      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.CREDITOR_ID, new org.apache.thrift.meta_data.FieldMetaData("creditorId", 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)));
+      tmpMap.put(_Fields.OFFSET, new org.apache.thrift.meta_data.FieldMetaData("offset", 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(getLimitedCreditHistoryRecords_args.class, metaDataMap);
+    }
+    public getLimitedCreditHistoryRecords_args() {
+    }
+    public getLimitedCreditHistoryRecords_args(
+      long paymentId,
+      long userId,
+      long creditorId,
+      long limit,
+      long offset)
+    {
+      this();
+      this.paymentId = paymentId;
+      setPaymentIdIsSet(true);
+      this.userId = userId;
+      setUserIdIsSet(true);
+      this.creditorId = creditorId;
+      setCreditorIdIsSet(true);
+      this.limit = limit;
+      setLimitIsSet(true);
+      this.offset = offset;
+      setOffsetIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getLimitedCreditHistoryRecords_args(getLimitedCreditHistoryRecords_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.paymentId = other.paymentId;
+      this.userId = other.userId;
+      this.creditorId = other.creditorId;
+      this.limit = other.limit;
+      this.offset = other.offset;
+    }
+    public getLimitedCreditHistoryRecords_args deepCopy() {
+      return new getLimitedCreditHistoryRecords_args(this);
+    }
+    @Override
+    public void clear() {
+      setPaymentIdIsSet(false);
+      this.paymentId = 0;
+      setUserIdIsSet(false);
+      this.userId = 0;
+      setCreditorIdIsSet(false);
+      this.creditorId = 0;
+      setLimitIsSet(false);
+      this.limit = 0;
+      setOffsetIsSet(false);
+      this.offset = 0;
+    }
+    public long getPaymentId() {
+      return this.paymentId;
+    }
+    public void setPaymentId(long paymentId) {
+      this.paymentId = paymentId;
+      setPaymentIdIsSet(true);
+    }
+    public void unsetPaymentId() {
+      __isset_bit_vector.clear(__PAYMENTID_ISSET_ID);
+    }
+    /** Returns true if field paymentId is set (has been assigned a value) and false otherwise */
+    public boolean isSetPaymentId() {
+      return __isset_bit_vector.get(__PAYMENTID_ISSET_ID);
+    }
+    public void setPaymentIdIsSet(boolean value) {
+      __isset_bit_vector.set(__PAYMENTID_ISSET_ID, value);
+    }
+    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 getCreditorId() {
+      return this.creditorId;
+    }
+    public void setCreditorId(long creditorId) {
+      this.creditorId = creditorId;
+      setCreditorIdIsSet(true);
+    }
+    public void unsetCreditorId() {
+      __isset_bit_vector.clear(__CREDITORID_ISSET_ID);
+    }
+    /** Returns true if field creditorId is set (has been assigned a value) and false otherwise */
+    public boolean isSetCreditorId() {
+      return __isset_bit_vector.get(__CREDITORID_ISSET_ID);
+    }
+    public void setCreditorIdIsSet(boolean value) {
+      __isset_bit_vector.set(__CREDITORID_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 long getOffset() {
+      return this.offset;
+    }
+    public void setOffset(long offset) {
+      this.offset = offset;
+      setOffsetIsSet(true);
+    }
+    public void unsetOffset() {
+      __isset_bit_vector.clear(__OFFSET_ISSET_ID);
+    }
+    /** Returns true if field offset is set (has been assigned a value) and false otherwise */
+    public boolean isSetOffset() {
+      return __isset_bit_vector.get(__OFFSET_ISSET_ID);
+    }
+    public void setOffsetIsSet(boolean value) {
+      __isset_bit_vector.set(__OFFSET_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case PAYMENT_ID:
+        if (value == null) {
+          unsetPaymentId();
+        } else {
+          setPaymentId((Long)value);
+        }
+        break;
+      case USER_ID:
+        if (value == null) {
+          unsetUserId();
+        } else {
+          setUserId((Long)value);
+        }
+        break;
+      case CREDITOR_ID:
+        if (value == null) {
+          unsetCreditorId();
+        } else {
+          setCreditorId((Long)value);
+        }
+        break;
+      case LIMIT:
+        if (value == null) {
+          unsetLimit();
+        } else {
+          setLimit((Long)value);
+        }
+        break;
+      case OFFSET:
+        if (value == null) {
+          unsetOffset();
+        } else {
+          setOffset((Long)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case PAYMENT_ID:
+        return Long.valueOf(getPaymentId());
+      case USER_ID:
+        return Long.valueOf(getUserId());
+      case CREDITOR_ID:
+        return Long.valueOf(getCreditorId());
+      case LIMIT:
+        return Long.valueOf(getLimit());
+      case OFFSET:
+        return Long.valueOf(getOffset());
+      }
+      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 PAYMENT_ID:
+        return isSetPaymentId();
+      case USER_ID:
+        return isSetUserId();
+      case CREDITOR_ID:
+        return isSetCreditorId();
+      case LIMIT:
+        return isSetLimit();
+      case OFFSET:
+        return isSetOffset();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof getLimitedCreditHistoryRecords_args)
+        return this.equals((getLimitedCreditHistoryRecords_args)that);
+      return false;
+    }
+    public boolean equals(getLimitedCreditHistoryRecords_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_paymentId = true;
+      boolean that_present_paymentId = true;
+      if (this_present_paymentId || that_present_paymentId) {
+        if (!(this_present_paymentId && that_present_paymentId))
+          return false;
+        if (this.paymentId != that.paymentId)
+          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_creditorId = true;
+      boolean that_present_creditorId = true;
+      if (this_present_creditorId || that_present_creditorId) {
+        if (!(this_present_creditorId && that_present_creditorId))
+          return false;
+        if (this.creditorId != that.creditorId)
+          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;
+      }
+      boolean this_present_offset = true;
+      boolean that_present_offset = true;
+      if (this_present_offset || that_present_offset) {
+        if (!(this_present_offset && that_present_offset))
+          return false;
+        if (this.offset != that.offset)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getLimitedCreditHistoryRecords_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getLimitedCreditHistoryRecords_args typedOther = (getLimitedCreditHistoryRecords_args)other;
+      lastComparison = Boolean.valueOf(isSetPaymentId()).compareTo(typedOther.isSetPaymentId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetPaymentId()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.paymentId, typedOther.paymentId);
+        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(isSetCreditorId()).compareTo(typedOther.isSetCreditorId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetCreditorId()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.creditorId, typedOther.creditorId);
+        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;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetOffset()).compareTo(typedOther.isSetOffset());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetOffset()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.offset, typedOther.offset);
+        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: // PAYMENT_ID
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.paymentId = iprot.readI64();
+              setPaymentIdIsSet(true);
+            } 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: // CREDITOR_ID
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.creditorId = iprot.readI64();
+              setCreditorIdIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 4: // 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;
+          case 5: // OFFSET
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.offset = iprot.readI64();
+              setOffsetIsSet(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);
+      oprot.writeFieldBegin(PAYMENT_ID_FIELD_DESC);
+      oprot.writeI64(this.paymentId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(USER_ID_FIELD_DESC);
+      oprot.writeI64(this.userId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(CREDITOR_ID_FIELD_DESC);
+      oprot.writeI64(this.creditorId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(LIMIT_FIELD_DESC);
+      oprot.writeI64(this.limit);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(OFFSET_FIELD_DESC);
+      oprot.writeI64(this.offset);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getLimitedCreditHistoryRecords_args(");
+      boolean first = true;
+      sb.append("paymentId:");
+      sb.append(this.paymentId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("userId:");
+      sb.append(this.userId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("creditorId:");
+      sb.append(this.creditorId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("limit:");
+      sb.append(this.limit);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("offset:");
+      sb.append(this.offset);
+      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 getLimitedCreditHistoryRecords_result implements org.apache.thrift.TBase<getLimitedCreditHistoryRecords_result, getLimitedCreditHistoryRecords_result._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getLimitedCreditHistoryRecords_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<CreditHistory> 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, CreditHistory.class))));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getLimitedCreditHistoryRecords_result.class, metaDataMap);
+    }
+    public getLimitedCreditHistoryRecords_result() {
+    }
+    public getLimitedCreditHistoryRecords_result(
+      List<CreditHistory> success)
+    {
+      this();
+      this.success = success;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getLimitedCreditHistoryRecords_result(getLimitedCreditHistoryRecords_result other) {
+      if (other.isSetSuccess()) {
+        List<CreditHistory> __this__success = new ArrayList<CreditHistory>();
+        for (CreditHistory other_element : other.success) {
+          __this__success.add(new CreditHistory(other_element));
+        }
+        this.success = __this__success;
+      }
+    }
+    public getLimitedCreditHistoryRecords_result deepCopy() {
+      return new getLimitedCreditHistoryRecords_result(this);
+    }
+    @Override
+    public void clear() {
+      this.success = null;
+    }
+    public int getSuccessSize() {
+      return (this.success == null) ? 0 : this.success.size();
+    }
+    public java.util.Iterator<CreditHistory> getSuccessIterator() {
+      return (this.success == null) ? null : this.success.iterator();
+    }
+    public void addToSuccess(CreditHistory elem) {
+      if (this.success == null) {
+        this.success = new ArrayList<CreditHistory>();
+      }
+      this.success.add(elem);
+    }
+    public List<CreditHistory> getSuccess() {
+      return this.success;
+    }
+    public void setSuccess(List<CreditHistory> 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<CreditHistory>)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 getLimitedCreditHistoryRecords_result)
+        return this.equals((getLimitedCreditHistoryRecords_result)that);
+      return false;
+    }
+    public boolean equals(getLimitedCreditHistoryRecords_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(getLimitedCreditHistoryRecords_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getLimitedCreditHistoryRecords_result typedOther = (getLimitedCreditHistoryRecords_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 _list680 = iprot.readListBegin();
+                this.success = new ArrayList<CreditHistory>(_list680.size);
+                for (int _i681 = 0; _i681 < _list680.size; ++_i681)
+                {
+                  CreditHistory _elem682; // required
+                  _elem682 = new CreditHistory();
+                  _elem682.read(iprot);
+                  this.success.add(_elem682);
+                }
+                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 (CreditHistory _iter683 : this.success)
+          {
+            _iter683.write(oprot);
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getLimitedCreditHistoryRecords_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 getLimitedLoanHistoryRecords_args implements org.apache.thrift.TBase<getLimitedLoanHistoryRecords_args, getLimitedLoanHistoryRecords_args._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getLimitedLoanHistoryRecords_args");
+    private static final org.apache.thrift.protocol.TField PAYMENT_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("paymentId", org.apache.thrift.protocol.TType.I64, (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 CREDITOR_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("creditorId", org.apache.thrift.protocol.TType.I64, (short)3);
+    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)4);
+    private static final org.apache.thrift.protocol.TField OFFSET_FIELD_DESC = new org.apache.thrift.protocol.TField("offset", org.apache.thrift.protocol.TType.I64, (short)5);
+    private long paymentId; // required
+    private long userId; // required
+    private long creditorId; // required
+    private long limit; // required
+    private long offset; // 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 {
+      PAYMENT_ID((short)1, "paymentId"),
+      USER_ID((short)2, "userId"),
+      CREDITOR_ID((short)3, "creditorId"),
+      LIMIT((short)4, "limit"),
+      OFFSET((short)5, "offset");
+      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: // PAYMENT_ID
+            return PAYMENT_ID;
+          case 2: // USER_ID
+            return USER_ID;
+          case 3: // CREDITOR_ID
+            return CREDITOR_ID;
+          case 4: // LIMIT
+            return LIMIT;
+          case 5: // OFFSET
+            return OFFSET;
+          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 __PAYMENTID_ISSET_ID = 0;
+    private static final int __USERID_ISSET_ID = 1;
+    private static final int __CREDITORID_ISSET_ID = 2;
+    private static final int __LIMIT_ISSET_ID = 3;
+    private static final int __OFFSET_ISSET_ID = 4;
+    private BitSet __isset_bit_vector = new BitSet(5);
+    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.PAYMENT_ID, new org.apache.thrift.meta_data.FieldMetaData("paymentId", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      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.CREDITOR_ID, new org.apache.thrift.meta_data.FieldMetaData("creditorId", 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)));
+      tmpMap.put(_Fields.OFFSET, new org.apache.thrift.meta_data.FieldMetaData("offset", 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(getLimitedLoanHistoryRecords_args.class, metaDataMap);
+    }
+    public getLimitedLoanHistoryRecords_args() {
+    }
+    public getLimitedLoanHistoryRecords_args(
+      long paymentId,
+      long userId,
+      long creditorId,
+      long limit,
+      long offset)
+    {
+      this();
+      this.paymentId = paymentId;
+      setPaymentIdIsSet(true);
+      this.userId = userId;
+      setUserIdIsSet(true);
+      this.creditorId = creditorId;
+      setCreditorIdIsSet(true);
+      this.limit = limit;
+      setLimitIsSet(true);
+      this.offset = offset;
+      setOffsetIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getLimitedLoanHistoryRecords_args(getLimitedLoanHistoryRecords_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.paymentId = other.paymentId;
+      this.userId = other.userId;
+      this.creditorId = other.creditorId;
+      this.limit = other.limit;
+      this.offset = other.offset;
+    }
+    public getLimitedLoanHistoryRecords_args deepCopy() {
+      return new getLimitedLoanHistoryRecords_args(this);
+    }
+    @Override
+    public void clear() {
+      setPaymentIdIsSet(false);
+      this.paymentId = 0;
+      setUserIdIsSet(false);
+      this.userId = 0;
+      setCreditorIdIsSet(false);
+      this.creditorId = 0;
+      setLimitIsSet(false);
+      this.limit = 0;
+      setOffsetIsSet(false);
+      this.offset = 0;
+    }
+    public long getPaymentId() {
+      return this.paymentId;
+    }
+    public void setPaymentId(long paymentId) {
+      this.paymentId = paymentId;
+      setPaymentIdIsSet(true);
+    }
+    public void unsetPaymentId() {
+      __isset_bit_vector.clear(__PAYMENTID_ISSET_ID);
+    }
+    /** Returns true if field paymentId is set (has been assigned a value) and false otherwise */
+    public boolean isSetPaymentId() {
+      return __isset_bit_vector.get(__PAYMENTID_ISSET_ID);
+    }
+    public void setPaymentIdIsSet(boolean value) {
+      __isset_bit_vector.set(__PAYMENTID_ISSET_ID, value);
+    }
+    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 getCreditorId() {
+      return this.creditorId;
+    }
+    public void setCreditorId(long creditorId) {
+      this.creditorId = creditorId;
+      setCreditorIdIsSet(true);
+    }
+    public void unsetCreditorId() {
+      __isset_bit_vector.clear(__CREDITORID_ISSET_ID);
+    }
+    /** Returns true if field creditorId is set (has been assigned a value) and false otherwise */
+    public boolean isSetCreditorId() {
+      return __isset_bit_vector.get(__CREDITORID_ISSET_ID);
+    }
+    public void setCreditorIdIsSet(boolean value) {
+      __isset_bit_vector.set(__CREDITORID_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 long getOffset() {
+      return this.offset;
+    }
+    public void setOffset(long offset) {
+      this.offset = offset;
+      setOffsetIsSet(true);
+    }
+    public void unsetOffset() {
+      __isset_bit_vector.clear(__OFFSET_ISSET_ID);
+    }
+    /** Returns true if field offset is set (has been assigned a value) and false otherwise */
+    public boolean isSetOffset() {
+      return __isset_bit_vector.get(__OFFSET_ISSET_ID);
+    }
+    public void setOffsetIsSet(boolean value) {
+      __isset_bit_vector.set(__OFFSET_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case PAYMENT_ID:
+        if (value == null) {
+          unsetPaymentId();
+        } else {
+          setPaymentId((Long)value);
+        }
+        break;
+      case USER_ID:
+        if (value == null) {
+          unsetUserId();
+        } else {
+          setUserId((Long)value);
+        }
+        break;
+      case CREDITOR_ID:
+        if (value == null) {
+          unsetCreditorId();
+        } else {
+          setCreditorId((Long)value);
+        }
+        break;
+      case LIMIT:
+        if (value == null) {
+          unsetLimit();
+        } else {
+          setLimit((Long)value);
+        }
+        break;
+      case OFFSET:
+        if (value == null) {
+          unsetOffset();
+        } else {
+          setOffset((Long)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case PAYMENT_ID:
+        return Long.valueOf(getPaymentId());
+      case USER_ID:
+        return Long.valueOf(getUserId());
+      case CREDITOR_ID:
+        return Long.valueOf(getCreditorId());
+      case LIMIT:
+        return Long.valueOf(getLimit());
+      case OFFSET:
+        return Long.valueOf(getOffset());
+      }
+      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 PAYMENT_ID:
+        return isSetPaymentId();
+      case USER_ID:
+        return isSetUserId();
+      case CREDITOR_ID:
+        return isSetCreditorId();
+      case LIMIT:
+        return isSetLimit();
+      case OFFSET:
+        return isSetOffset();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof getLimitedLoanHistoryRecords_args)
+        return this.equals((getLimitedLoanHistoryRecords_args)that);
+      return false;
+    }
+    public boolean equals(getLimitedLoanHistoryRecords_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_paymentId = true;
+      boolean that_present_paymentId = true;
+      if (this_present_paymentId || that_present_paymentId) {
+        if (!(this_present_paymentId && that_present_paymentId))
+          return false;
+        if (this.paymentId != that.paymentId)
+          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_creditorId = true;
+      boolean that_present_creditorId = true;
+      if (this_present_creditorId || that_present_creditorId) {
+        if (!(this_present_creditorId && that_present_creditorId))
+          return false;
+        if (this.creditorId != that.creditorId)
+          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;
+      }
+      boolean this_present_offset = true;
+      boolean that_present_offset = true;
+      if (this_present_offset || that_present_offset) {
+        if (!(this_present_offset && that_present_offset))
+          return false;
+        if (this.offset != that.offset)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getLimitedLoanHistoryRecords_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getLimitedLoanHistoryRecords_args typedOther = (getLimitedLoanHistoryRecords_args)other;
+      lastComparison = Boolean.valueOf(isSetPaymentId()).compareTo(typedOther.isSetPaymentId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetPaymentId()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.paymentId, typedOther.paymentId);
+        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(isSetCreditorId()).compareTo(typedOther.isSetCreditorId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetCreditorId()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.creditorId, typedOther.creditorId);
+        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;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetOffset()).compareTo(typedOther.isSetOffset());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetOffset()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.offset, typedOther.offset);
+        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: // PAYMENT_ID
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.paymentId = iprot.readI64();
+              setPaymentIdIsSet(true);
+            } 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: // CREDITOR_ID
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.creditorId = iprot.readI64();
+              setCreditorIdIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 4: // 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;
+          case 5: // OFFSET
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.offset = iprot.readI64();
+              setOffsetIsSet(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);
+      oprot.writeFieldBegin(PAYMENT_ID_FIELD_DESC);
+      oprot.writeI64(this.paymentId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(USER_ID_FIELD_DESC);
+      oprot.writeI64(this.userId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(CREDITOR_ID_FIELD_DESC);
+      oprot.writeI64(this.creditorId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(LIMIT_FIELD_DESC);
+      oprot.writeI64(this.limit);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(OFFSET_FIELD_DESC);
+      oprot.writeI64(this.offset);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getLimitedLoanHistoryRecords_args(");
+      boolean first = true;
+      sb.append("paymentId:");
+      sb.append(this.paymentId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("userId:");
+      sb.append(this.userId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("creditorId:");
+      sb.append(this.creditorId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("limit:");
+      sb.append(this.limit);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("offset:");
+      sb.append(this.offset);
+      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 getLimitedLoanHistoryRecords_result implements org.apache.thrift.TBase<getLimitedLoanHistoryRecords_result, getLimitedLoanHistoryRecords_result._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getLimitedLoanHistoryRecords_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<LoanHistory> 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, LoanHistory.class))));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getLimitedLoanHistoryRecords_result.class, metaDataMap);
+    }
+    public getLimitedLoanHistoryRecords_result() {
+    }
+    public getLimitedLoanHistoryRecords_result(
+      List<LoanHistory> success)
+    {
+      this();
+      this.success = success;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getLimitedLoanHistoryRecords_result(getLimitedLoanHistoryRecords_result other) {
+      if (other.isSetSuccess()) {
+        List<LoanHistory> __this__success = new ArrayList<LoanHistory>();
+        for (LoanHistory other_element : other.success) {
+          __this__success.add(new LoanHistory(other_element));
+        }
+        this.success = __this__success;
+      }
+    }
+    public getLimitedLoanHistoryRecords_result deepCopy() {
+      return new getLimitedLoanHistoryRecords_result(this);
+    }
+    @Override
+    public void clear() {
+      this.success = null;
+    }
+    public int getSuccessSize() {
+      return (this.success == null) ? 0 : this.success.size();
+    }
+    public java.util.Iterator<LoanHistory> getSuccessIterator() {
+      return (this.success == null) ? null : this.success.iterator();
+    }
+    public void addToSuccess(LoanHistory elem) {
+      if (this.success == null) {
+        this.success = new ArrayList<LoanHistory>();
+      }
+      this.success.add(elem);
+    }
+    public List<LoanHistory> getSuccess() {
+      return this.success;
+    }
+    public void setSuccess(List<LoanHistory> 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<LoanHistory>)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 getLimitedLoanHistoryRecords_result)
+        return this.equals((getLimitedLoanHistoryRecords_result)that);
+      return false;
+    }
+    public boolean equals(getLimitedLoanHistoryRecords_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(getLimitedLoanHistoryRecords_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getLimitedLoanHistoryRecords_result typedOther = (getLimitedLoanHistoryRecords_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 _list684 = iprot.readListBegin();
+                this.success = new ArrayList<LoanHistory>(_list684.size);
+                for (int _i685 = 0; _i685 < _list684.size; ++_i685)
+                {
+                  LoanHistory _elem686; // required
+                  _elem686 = new LoanHistory();
+                  _elem686.read(iprot);
+                  this.success.add(_elem686);
+                }
+                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 (LoanHistory _iter687 : this.success)
+          {
+            _iter687.write(oprot);
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getLimitedLoanHistoryRecords_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 _list680 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list688 = iprot.readListBegin();
-                this.order_ids = new ArrayList<Long>(_list680.size);
+                this.order_ids = new ArrayList<Long>(_list688.size);
-                for (int _i681 = 0; _i681 < _list680.size; ++_i681)
+                for (int _i689 = 0; _i689 < _list688.size; ++_i689)
+                {
-                  long _elem682; // required
+                  long _elem690; // required
-                  _elem682 = iprot.readI64();
+                  _elem690 = iprot.readI64();
-                  this.order_ids.add(_elem682);
+                  this.order_ids.add(_elem690);
+                }
                 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 _iter683 : this.order_ids)
+          for (long _iter691 : this.order_ids)
+          {
-            oprot.writeI64(_iter683);
+            oprot.writeI64(_iter691);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map684 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map692 = iprot.readMapBegin();
-                this.success = new HashMap<Long,List<ReturnOrderInfo>>(2*_map684.size);
+                this.success = new HashMap<Long,List<ReturnOrderInfo>>(2*_map692.size);
-                for (int _i685 = 0; _i685 < _map684.size; ++_i685)
+                for (int _i693 = 0; _i693 < _map692.size; ++_i693)
+                {
-                  long _key686; // required
+                  long _key694; // required
-                  List<ReturnOrderInfo> _val687; // required
+                  List<ReturnOrderInfo> _val695; // required
-                  _key686 = iprot.readI64();
+                  _key694 = iprot.readI64();
+                  {
-                    org.apache.thrift.protocol.TList _list688 = iprot.readListBegin();
+                    org.apache.thrift.protocol.TList _list696 = iprot.readListBegin();
-                    _val687 = new ArrayList<ReturnOrderInfo>(_list688.size);
+                    _val695 = new ArrayList<ReturnOrderInfo>(_list696.size);
-                    for (int _i689 = 0; _i689 < _list688.size; ++_i689)
+                    for (int _i697 = 0; _i697 < _list696.size; ++_i697)
+                    {
-                      ReturnOrderInfo _elem690; // required
+                      ReturnOrderInfo _elem698; // required
-                      _elem690 = new ReturnOrderInfo();
+                      _elem698 = new ReturnOrderInfo();
-                      _elem690.read(iprot);
+                      _elem698.read(iprot);
-                      _val687.add(_elem690);
+                      _val695.add(_elem698);
+                    }
                     iprot.readListEnd();
+                  }
-                  this.success.put(_key686, _val687);
+                  this.success.put(_key694, _val695);
+                }
                 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>> _iter691 : this.success.entrySet())
+          for (Map.Entry<Long, List<ReturnOrderInfo>> _iter699 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter691.getKey());
+            oprot.writeI64(_iter699.getKey());
+            {
-              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter691.getValue().size()));
+              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter699.getValue().size()));
-              for (ReturnOrderInfo _iter692 : _iter691.getValue())
+              for (ReturnOrderInfo _iter700 : _iter699.getValue())
+              {
-                _iter692.write(oprot);
+                _iter700.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 _list693 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list701 = iprot.readListBegin();
-                this.order_ids = new ArrayList<Long>(_list693.size);
+                this.order_ids = new ArrayList<Long>(_list701.size);
-                for (int _i694 = 0; _i694 < _list693.size; ++_i694)
+                for (int _i702 = 0; _i702 < _list701.size; ++_i702)
+                {
-                  long _elem695; // required
+                  long _elem703; // required
-                  _elem695 = iprot.readI64();
+                  _elem703 = iprot.readI64();
-                  this.order_ids.add(_elem695);
+                  this.order_ids.add(_elem703);
+                }
                 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 _list696 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list704 = iprot.readListBegin();
-                this.statuses = new ArrayList<String>(_list696.size);
+                this.statuses = new ArrayList<String>(_list704.size);
-                for (int _i697 = 0; _i697 < _list696.size; ++_i697)
+                for (int _i705 = 0; _i705 < _list704.size; ++_i705)
+                {
-                  String _elem698; // required
+                  String _elem706; // required
-                  _elem698 = iprot.readString();
+                  _elem706 = iprot.readString();
-                  this.statuses.add(_elem698);
+                  this.statuses.add(_elem706);
+                }
                 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 _iter699 : this.order_ids)
+          for (long _iter707 : this.order_ids)
+          {
-            oprot.writeI64(_iter699);
+            oprot.writeI64(_iter707);
+          }
           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 _iter700 : this.statuses)
+          for (String _iter708 : this.statuses)
+          {
-            oprot.writeString(_iter700);
+            oprot.writeString(_iter708);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map701 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map709 = iprot.readMapBegin();
-                this.success = new HashMap<Long,List<ReturnOrderInfo>>(2*_map701.size);
+                this.success = new HashMap<Long,List<ReturnOrderInfo>>(2*_map709.size);
-                for (int _i702 = 0; _i702 < _map701.size; ++_i702)
+                for (int _i710 = 0; _i710 < _map709.size; ++_i710)
+                {
-                  long _key703; // required
+                  long _key711; // required
-                  List<ReturnOrderInfo> _val704; // required
+                  List<ReturnOrderInfo> _val712; // required
-                  _key703 = iprot.readI64();
+                  _key711 = iprot.readI64();
+                  {
-                    org.apache.thrift.protocol.TList _list705 = iprot.readListBegin();
+                    org.apache.thrift.protocol.TList _list713 = iprot.readListBegin();
-                    _val704 = new ArrayList<ReturnOrderInfo>(_list705.size);
+                    _val712 = new ArrayList<ReturnOrderInfo>(_list713.size);
-                    for (int _i706 = 0; _i706 < _list705.size; ++_i706)
+                    for (int _i714 = 0; _i714 < _list713.size; ++_i714)
+                    {
-                      ReturnOrderInfo _elem707; // required
+                      ReturnOrderInfo _elem715; // required
-                      _elem707 = new ReturnOrderInfo();
+                      _elem715 = new ReturnOrderInfo();
-                      _elem707.read(iprot);
+                      _elem715.read(iprot);
-                      _val704.add(_elem707);
+                      _val712.add(_elem715);
+                    }
                     iprot.readListEnd();
+                  }
-                  this.success.put(_key703, _val704);
+                  this.success.put(_key711, _val712);
+                }
                 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>> _iter708 : this.success.entrySet())
+          for (Map.Entry<Long, List<ReturnOrderInfo>> _iter716 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter708.getKey());
+            oprot.writeI64(_iter716.getKey());
+            {
-              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter708.getValue().size()));
+              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter716.getValue().size()));
-              for (ReturnOrderInfo _iter709 : _iter708.getValue())
+              for (ReturnOrderInfo _iter717 : _iter716.getValue())
+              {
-                _iter709.write(oprot);
+                _iter717.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 _map710 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map718 = iprot.readMapBegin();
-                this.orderReturnInfosMap = new HashMap<Long,List<ReturnOrderInfo>>(2*_map710.size);
+                this.orderReturnInfosMap = new HashMap<Long,List<ReturnOrderInfo>>(2*_map718.size);
-                for (int _i711 = 0; _i711 < _map710.size; ++_i711)
+                for (int _i719 = 0; _i719 < _map718.size; ++_i719)
+                {
-                  long _key712; // required
+                  long _key720; // required
-                  List<ReturnOrderInfo> _val713; // required
+                  List<ReturnOrderInfo> _val721; // required
-                  _key712 = iprot.readI64();
+                  _key720 = iprot.readI64();
+                  {
-                    org.apache.thrift.protocol.TList _list714 = iprot.readListBegin();
+                    org.apache.thrift.protocol.TList _list722 = iprot.readListBegin();
-                    _val713 = new ArrayList<ReturnOrderInfo>(_list714.size);
+                    _val721 = new ArrayList<ReturnOrderInfo>(_list722.size);
-                    for (int _i715 = 0; _i715 < _list714.size; ++_i715)
+                    for (int _i723 = 0; _i723 < _list722.size; ++_i723)
+                    {
-                      ReturnOrderInfo _elem716; // required
+                      ReturnOrderInfo _elem724; // required
-                      _elem716 = new ReturnOrderInfo();
+                      _elem724 = new ReturnOrderInfo();
-                      _elem716.read(iprot);
+                      _elem724.read(iprot);
-                      _val713.add(_elem716);
+                      _val721.add(_elem724);
+                    }
                     iprot.readListEnd();
+                  }
-                  this.orderReturnInfosMap.put(_key712, _val713);
+                  this.orderReturnInfosMap.put(_key720, _val721);
+                }
                 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>> _iter717 : this.orderReturnInfosMap.entrySet())
+          for (Map.Entry<Long, List<ReturnOrderInfo>> _iter725 : this.orderReturnInfosMap.entrySet())
+          {
-            oprot.writeI64(_iter717.getKey());
+            oprot.writeI64(_iter725.getKey());
+            {
-              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter717.getValue().size()));
+              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter725.getValue().size()));
-              for (ReturnOrderInfo _iter718 : _iter717.getValue())
+              for (ReturnOrderInfo _iter726 : _iter725.getValue())
+              {
-                _iter718.write(oprot);
+                _iter726.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 _map719 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map727 = iprot.readMapBegin();
-                this.success = new HashMap<Long,Boolean>(2*_map719.size);
+                this.success = new HashMap<Long,Boolean>(2*_map727.size);
-                for (int _i720 = 0; _i720 < _map719.size; ++_i720)
+                for (int _i728 = 0; _i728 < _map727.size; ++_i728)
+                {
-                  long _key721; // required
+                  long _key729; // required
-                  boolean _val722; // required
+                  boolean _val730; // required
-                  _key721 = iprot.readI64();
+                  _key729 = iprot.readI64();
-                  _val722 = iprot.readBool();
+                  _val730 = iprot.readBool();
-                  this.success.put(_key721, _val722);
+                  this.success.put(_key729, _val730);
+                }
                 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> _iter723 : this.success.entrySet())
+          for (Map.Entry<Long, Boolean> _iter731 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter723.getKey());
+            oprot.writeI64(_iter731.getKey());
-            oprot.writeBool(_iter723.getValue());
+            oprot.writeBool(_iter731.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 _list724 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list732 = iprot.readListBegin();
-                this.success = new ArrayList<ReturnOrderInfo>(_list724.size);
+                this.success = new ArrayList<ReturnOrderInfo>(_list732.size);
-                for (int _i725 = 0; _i725 < _list724.size; ++_i725)
+                for (int _i733 = 0; _i733 < _list732.size; ++_i733)
+                {
-                  ReturnOrderInfo _elem726; // required
+                  ReturnOrderInfo _elem734; // required
-                  _elem726 = new ReturnOrderInfo();
+                  _elem734 = new ReturnOrderInfo();
-                  _elem726.read(iprot);
+                  _elem734.read(iprot);
-                  this.success.add(_elem726);
+                  this.success.add(_elem734);
+                }
                 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 _iter727 : this.success)
+          for (ReturnOrderInfo _iter735 : this.success)
+          {
-            _iter727.write(oprot);
+            _iter735.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 _list728 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list736 = iprot.readListBegin();
-                this.success = new ArrayList<ReturnOrderInfo>(_list728.size);
+                this.success = new ArrayList<ReturnOrderInfo>(_list736.size);
-                for (int _i729 = 0; _i729 < _list728.size; ++_i729)
+                for (int _i737 = 0; _i737 < _list736.size; ++_i737)
+                {
-                  ReturnOrderInfo _elem730; // required
+                  ReturnOrderInfo _elem738; // required
-                  _elem730 = new ReturnOrderInfo();
+                  _elem738 = new ReturnOrderInfo();
-                  _elem730.read(iprot);
+                  _elem738.read(iprot);
-                  this.success.add(_elem730);
+                  this.success.add(_elem738);
+                }
                 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 _iter731 : this.success)
+          for (ReturnOrderInfo _iter739 : this.success)
+          {
-            _iter731.write(oprot);
+            _iter739.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 _list732 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list740 = iprot.readListBegin();
-                this.returnOrderIds = new ArrayList<Long>(_list732.size);
+                this.returnOrderIds = new ArrayList<Long>(_list740.size);
-                for (int _i733 = 0; _i733 < _list732.size; ++_i733)
+                for (int _i741 = 0; _i741 < _list740.size; ++_i741)
+                {
-                  long _elem734; // required
+                  long _elem742; // required
-                  _elem734 = iprot.readI64();
+                  _elem742 = iprot.readI64();
-                  this.returnOrderIds.add(_elem734);
+                  this.returnOrderIds.add(_elem742);
+                }
                 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 _iter735 : this.returnOrderIds)
+          for (long _iter743 : this.returnOrderIds)
+          {
-            oprot.writeI64(_iter735);
+            oprot.writeI64(_iter743);
+          }
           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 _list736 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list744 = iprot.readListBegin();
-                this.returnOrderIds = new ArrayList<Long>(_list736.size);
+                this.returnOrderIds = new ArrayList<Long>(_list744.size);
-                for (int _i737 = 0; _i737 < _list736.size; ++_i737)
+                for (int _i745 = 0; _i745 < _list744.size; ++_i745)
+                {
-                  long _elem738; // required
+                  long _elem746; // required
-                  _elem738 = iprot.readI64();
+                  _elem746 = iprot.readI64();
-                  this.returnOrderIds.add(_elem738);
+                  this.returnOrderIds.add(_elem746);
+                }
                 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 _iter739 : this.returnOrderIds)
+          for (long _iter747 : this.returnOrderIds)
+          {
-            oprot.writeI64(_iter739);
+            oprot.writeI64(_iter747);
+          }
           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 _list748 = iprot.readListBegin();
-                this.success = new ArrayList<ReturnOrderInfo>(_list740.size);
+                this.success = new ArrayList<ReturnOrderInfo>(_list748.size);
-                for (int _i741 = 0; _i741 < _list740.size; ++_i741)
+                for (int _i749 = 0; _i749 < _list748.size; ++_i749)
+                {
-                  ReturnOrderInfo _elem742; // required
+                  ReturnOrderInfo _elem750; // required
-                  _elem742 = new ReturnOrderInfo();
+                  _elem750 = new ReturnOrderInfo();
-                  _elem742.read(iprot);
+                  _elem750.read(iprot);
-                  this.success.add(_elem742);
+                  this.success.add(_elem750);
+                }
                 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 _iter751 : this.success)
+          {
-            _iter743.write(oprot);
+            _iter751.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 _map744 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map752 = iprot.readMapBegin();
-                this.returnOrdersMap = new HashMap<Long,Map<String,String>>(2*_map744.size);
+                this.returnOrdersMap = new HashMap<Long,Map<String,String>>(2*_map752.size);
-                for (int _i745 = 0; _i745 < _map744.size; ++_i745)
+                for (int _i753 = 0; _i753 < _map752.size; ++_i753)
+                {
-                  long _key746; // required
+                  long _key754; // required
-                  Map<String,String> _val747; // required
+                  Map<String,String> _val755; // required
-                  _key746 = iprot.readI64();
+                  _key754 = iprot.readI64();
+                  {
-                    org.apache.thrift.protocol.TMap _map748 = iprot.readMapBegin();
+                    org.apache.thrift.protocol.TMap _map756 = iprot.readMapBegin();
-                    _val747 = new HashMap<String,String>(2*_map748.size);
+                    _val755 = new HashMap<String,String>(2*_map756.size);
-                    for (int _i749 = 0; _i749 < _map748.size; ++_i749)
+                    for (int _i757 = 0; _i757 < _map756.size; ++_i757)
+                    {
-                      String _key750; // required
+                      String _key758; // required
-                      String _val751; // required
+                      String _val759; // required
-                      _key750 = iprot.readString();
+                      _key758 = iprot.readString();
-                      _val751 = iprot.readString();
+                      _val759 = iprot.readString();
-                      _val747.put(_key750, _val751);
+                      _val755.put(_key758, _val759);
+                    }
                     iprot.readMapEnd();
+                  }
-                  this.returnOrdersMap.put(_key746, _val747);
+                  this.returnOrdersMap.put(_key754, _val755);
+                }
                 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>> _iter752 : this.returnOrdersMap.entrySet())
+          for (Map.Entry<Long, Map<String,String>> _iter760 : this.returnOrdersMap.entrySet())
+          {
-            oprot.writeI64(_iter752.getKey());
+            oprot.writeI64(_iter760.getKey());
+            {
-              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter752.getValue().size()));
+              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter760.getValue().size()));
-              for (Map.Entry<String, String> _iter753 : _iter752.getValue().entrySet())
+              for (Map.Entry<String, String> _iter761 : _iter760.getValue().entrySet())
+              {
-                oprot.writeString(_iter753.getKey());
+                oprot.writeString(_iter761.getKey());
-                oprot.writeString(_iter753.getValue());
+                oprot.writeString(_iter761.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 _map754 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map762 = iprot.readMapBegin();
-                this.returnOrdersMap = new HashMap<Long,Boolean>(2*_map754.size);
+                this.returnOrdersMap = new HashMap<Long,Boolean>(2*_map762.size);
-                for (int _i755 = 0; _i755 < _map754.size; ++_i755)
+                for (int _i763 = 0; _i763 < _map762.size; ++_i763)
+                {
-                  long _key756; // required
+                  long _key764; // required
-                  boolean _val757; // required
+                  boolean _val765; // required
-                  _key756 = iprot.readI64();
+                  _key764 = iprot.readI64();
-                  _val757 = iprot.readBool();
+                  _val765 = iprot.readBool();
-                  this.returnOrdersMap.put(_key756, _val757);
+                  this.returnOrdersMap.put(_key764, _val765);
+                }
                 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> _iter758 : this.returnOrdersMap.entrySet())
+          for (Map.Entry<Long, Boolean> _iter766 : this.returnOrdersMap.entrySet())
+          {
-            oprot.writeI64(_iter758.getKey());
+            oprot.writeI64(_iter766.getKey());
-            oprot.writeBool(_iter758.getValue());
+            oprot.writeBool(_iter766.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 _map759 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map767 = iprot.readMapBegin();
-                this.returnOrdersMap = new HashMap<Long,Map<String,String>>(2*_map759.size);
+                this.returnOrdersMap = new HashMap<Long,Map<String,String>>(2*_map767.size);
-                for (int _i760 = 0; _i760 < _map759.size; ++_i760)
+                for (int _i768 = 0; _i768 < _map767.size; ++_i768)
+                {
-                  long _key761; // required
+                  long _key769; // required
-                  Map<String,String> _val762; // required
+                  Map<String,String> _val770; // required
-                  _key761 = iprot.readI64();
+                  _key769 = iprot.readI64();
+                  {
-                    org.apache.thrift.protocol.TMap _map763 = iprot.readMapBegin();
+                    org.apache.thrift.protocol.TMap _map771 = iprot.readMapBegin();
-                    _val762 = new HashMap<String,String>(2*_map763.size);
+                    _val770 = new HashMap<String,String>(2*_map771.size);
-                    for (int _i764 = 0; _i764 < _map763.size; ++_i764)
+                    for (int _i772 = 0; _i772 < _map771.size; ++_i772)
+                    {
-                      String _key765; // required
+                      String _key773; // required
-                      String _val766; // required
+                      String _val774; // required
-                      _key765 = iprot.readString();
+                      _key773 = iprot.readString();
-                      _val766 = iprot.readString();
+                      _val774 = iprot.readString();
-                      _val762.put(_key765, _val766);
+                      _val770.put(_key773, _val774);
+                    }
                     iprot.readMapEnd();
+                  }
-                  this.returnOrdersMap.put(_key761, _val762);
+                  this.returnOrdersMap.put(_key769, _val770);
+                }
                 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>> _iter767 : this.returnOrdersMap.entrySet())
+          for (Map.Entry<Long, Map<String,String>> _iter775 : this.returnOrdersMap.entrySet())
+          {
-            oprot.writeI64(_iter767.getKey());
+            oprot.writeI64(_iter775.getKey());
+            {
-              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter767.getValue().size()));
+              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter775.getValue().size()));
-              for (Map.Entry<String, String> _iter768 : _iter767.getValue().entrySet())
+              for (Map.Entry<String, String> _iter776 : _iter775.getValue().entrySet())
+              {
-                oprot.writeString(_iter768.getKey());
+                oprot.writeString(_iter776.getKey());
-                oprot.writeString(_iter768.getValue());
+                oprot.writeString(_iter776.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 _map769 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map777 = iprot.readMapBegin();
-                this.refundOrdersMap = new HashMap<Long,Map<String,String>>(2*_map769.size);
+                this.refundOrdersMap = new HashMap<Long,Map<String,String>>(2*_map777.size);
-                for (int _i770 = 0; _i770 < _map769.size; ++_i770)
+                for (int _i778 = 0; _i778 < _map777.size; ++_i778)
+                {
-                  long _key771; // required
+                  long _key779; // required
-                  Map<String,String> _val772; // required
+                  Map<String,String> _val780; // required
-                  _key771 = iprot.readI64();
+                  _key779 = iprot.readI64();
+                  {
-                    org.apache.thrift.protocol.TMap _map773 = iprot.readMapBegin();
+                    org.apache.thrift.protocol.TMap _map781 = iprot.readMapBegin();
-                    _val772 = new HashMap<String,String>(2*_map773.size);
+                    _val780 = new HashMap<String,String>(2*_map781.size);
-                    for (int _i774 = 0; _i774 < _map773.size; ++_i774)
+                    for (int _i782 = 0; _i782 < _map781.size; ++_i782)
+                    {
-                      String _key775; // required
+                      String _key783; // required
-                      String _val776; // required
+                      String _val784; // required
-                      _key775 = iprot.readString();
+                      _key783 = iprot.readString();
-                      _val776 = iprot.readString();
+                      _val784 = iprot.readString();
-                      _val772.put(_key775, _val776);
+                      _val780.put(_key783, _val784);
+                    }
                     iprot.readMapEnd();
+                  }
-                  this.refundOrdersMap.put(_key771, _val772);
+                  this.refundOrdersMap.put(_key779, _val780);
+                }
                 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>> _iter777 : this.refundOrdersMap.entrySet())
+          for (Map.Entry<Long, Map<String,String>> _iter785 : this.refundOrdersMap.entrySet())
+          {
-            oprot.writeI64(_iter777.getKey());
+            oprot.writeI64(_iter785.getKey());
+            {
-              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter777.getValue().size()));
+              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter785.getValue().size()));
-              for (Map.Entry<String, String> _iter778 : _iter777.getValue().entrySet())
+              for (Map.Entry<String, String> _iter786 : _iter785.getValue().entrySet())
+              {
-                oprot.writeString(_iter778.getKey());
+                oprot.writeString(_iter786.getKey());
-                oprot.writeString(_iter778.getValue());
+                oprot.writeString(_iter786.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 _list779 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list787 = iprot.readListBegin();
-                this.statusList = new ArrayList<ReturnTransactionStatus>(_list779.size);
+                this.statusList = new ArrayList<ReturnTransactionStatus>(_list787.size);
-                for (int _i780 = 0; _i780 < _list779.size; ++_i780)
+                for (int _i788 = 0; _i788 < _list787.size; ++_i788)
+                {
-                  ReturnTransactionStatus _elem781; // required
+                  ReturnTransactionStatus _elem789; // required
-                  _elem781 = ReturnTransactionStatus.findByValue(iprot.readI32());
+                  _elem789 = ReturnTransactionStatus.findByValue(iprot.readI32());
-                  this.statusList.add(_elem781);
+                  this.statusList.add(_elem789);
+                }
                 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 _iter782 : this.statusList)
+          for (ReturnTransactionStatus _iter790 : this.statusList)
+          {
-            oprot.writeI32(_iter782.getValue());
+            oprot.writeI32(_iter790.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 _list783 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list791 = iprot.readListBegin();
-                this.success = new ArrayList<ReturnTransaction>(_list783.size);
+                this.success = new ArrayList<ReturnTransaction>(_list791.size);
-                for (int _i784 = 0; _i784 < _list783.size; ++_i784)
+                for (int _i792 = 0; _i792 < _list791.size; ++_i792)
+                {
-                  ReturnTransaction _elem785; // required
+                  ReturnTransaction _elem793; // required
-                  _elem785 = new ReturnTransaction();
+                  _elem793 = new ReturnTransaction();
-                  _elem785.read(iprot);
+                  _elem793.read(iprot);
-                  this.success.add(_elem785);
+                  this.success.add(_elem793);
+                }
                 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 _iter786 : this.success)
+          for (ReturnTransaction _iter794 : this.success)
+          {
-            _iter786.write(oprot);
+            _iter794.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {

Subversion Repositories SmartDukaan

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