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 PaginatedCreditHistory getLimitedCreditHistoryRecords(long paymentId, long userId, long creditorId, long limit, long offset) throws org.apache.thrift.TException;
 
    public PaginatedLoanHistory getLimitedLoanHistoryRecords(long paymentId, long userId, long creditorId, long limit, long offset) throws org.apache.thrift.TException;
 
    public PaginatedUserSanction getUserSanctionsDetailsAsPerLimit(long userId, long creditorId, long limit, long offset) 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 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 getUserSanctionsDetailsAsPerLimit(long userId, long creditorId, long limit, long offset, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getUserSanctionsDetailsAsPerLimit_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 PaginatedCreditHistory 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();
    }
 

      args.setLimit(limit);
      args.setOffset(offset);
      sendBase("getLimitedCreditHistoryRecords", args);
    }
 
    public PaginatedCreditHistory 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 PaginatedLoanHistory 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();
    }
 

      args.setLimit(limit);
      args.setOffset(offset);
      sendBase("getLimitedLoanHistoryRecords", args);
    }
 
    public PaginatedLoanHistory 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 PaginatedUserSanction getUserSanctionsDetailsAsPerLimit(long userId, long creditorId, long limit, long offset) throws org.apache.thrift.TException
    {
      send_getUserSanctionsDetailsAsPerLimit(userId, creditorId, limit, offset);
      return recv_getUserSanctionsDetailsAsPerLimit();
    }
 
    public void send_getUserSanctionsDetailsAsPerLimit(long userId, long creditorId, long limit, long offset) throws org.apache.thrift.TException
    {
      getUserSanctionsDetailsAsPerLimit_args args = new getUserSanctionsDetailsAsPerLimit_args();
      args.setUserId(userId);
      args.setCreditorId(creditorId);
      args.setLimit(limit);
      args.setOffset(offset);
      sendBase("getUserSanctionsDetailsAsPerLimit", args);
    }
 
    public PaginatedUserSanction recv_getUserSanctionsDetailsAsPerLimit() throws org.apache.thrift.TException
    {
      getUserSanctionsDetailsAsPerLimit_result result = new getUserSanctionsDetailsAsPerLimit_result();
      receiveBase(result, "getUserSanctionsDetailsAsPerLimit");
      if (result.isSetSuccess()) {
        return result.success;
      }
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getUserSanctionsDetailsAsPerLimit failed: unknown result");
    }
 
    public ReturnOrderInfo getReturnOrderInfo(long id) throws TransactionServiceException, org.apache.thrift.TException
    {
      send_getReturnOrderInfo(id);
      return recv_getReturnOrderInfo();
    }

        args.setOffset(offset);
        args.write(prot);
        prot.writeMessageEnd();
      }
 
      public PaginatedCreditHistory 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);

        args.setOffset(offset);
        args.write(prot);
        prot.writeMessageEnd();
      }
 
      public PaginatedLoanHistory 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 getUserSanctionsDetailsAsPerLimit(long userId, long creditorId, long limit, long offset, org.apache.thrift.async.AsyncMethodCallback<getUserSanctionsDetailsAsPerLimit_call> resultHandler) throws org.apache.thrift.TException {
      checkReady();
      getUserSanctionsDetailsAsPerLimit_call method_call = new getUserSanctionsDetailsAsPerLimit_call(userId, creditorId, limit, offset, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }
 
    public static class getUserSanctionsDetailsAsPerLimit_call extends org.apache.thrift.async.TAsyncMethodCall {
      private long userId;
      private long creditorId;
      private long limit;
      private long offset;
      public getUserSanctionsDetailsAsPerLimit_call(long userId, long creditorId, long limit, long offset, org.apache.thrift.async.AsyncMethodCallback<getUserSanctionsDetailsAsPerLimit_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.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("getUserSanctionsDetailsAsPerLimit", org.apache.thrift.protocol.TMessageType.CALL, 0));
        getUserSanctionsDetailsAsPerLimit_args args = new getUserSanctionsDetailsAsPerLimit_args();
        args.setUserId(userId);
        args.setCreditorId(creditorId);
        args.setLimit(limit);
        args.setOffset(offset);
        args.write(prot);
        prot.writeMessageEnd();
      }
 
      public PaginatedUserSanction 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_getUserSanctionsDetailsAsPerLimit();
      }
    }
 
    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("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("getUserSanctionsDetailsAsPerLimit", new getUserSanctionsDetailsAsPerLimit());
      processMap.put("getReturnOrderInfo", new getReturnOrderInfo());
      processMap.put("getReturnOrderInfoList", new getReturnOrderInfoList());
      processMap.put("getReturnOrderInfoListAsByStatus", new getReturnOrderInfoListAsByStatus());
      processMap.put("updateReturnOrderInfo", new updateReturnOrderInfo());
      processMap.put("bulkUpdateReturnOrderInfo", new bulkUpdateReturnOrderInfo());

        result.success = iface.getLimitedLoanHistoryRecords(args.paymentId, args.userId, args.creditorId, args.limit, args.offset);
        return result;
      }
    }
 
    private static class getUserSanctionsDetailsAsPerLimit<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getUserSanctionsDetailsAsPerLimit_args> {
      public getUserSanctionsDetailsAsPerLimit() {
        super("getUserSanctionsDetailsAsPerLimit");
      }
 
      protected getUserSanctionsDetailsAsPerLimit_args getEmptyArgsInstance() {
        return new getUserSanctionsDetailsAsPerLimit_args();
      }
 
      protected getUserSanctionsDetailsAsPerLimit_result getResult(I iface, getUserSanctionsDetailsAsPerLimit_args args) throws org.apache.thrift.TException {
        getUserSanctionsDetailsAsPerLimit_result result = new getUserSanctionsDetailsAsPerLimit_result();
        result.success = iface.getUserSanctionsDetailsAsPerLimit(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");
      }
 

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list76 = iprot.readListBegin();
                this.success = new ArrayList<Transaction>(_list76.size);
                for (int _i77 = 0; _i77 < _list76.size; ++_i77)
                {
                  Transaction _elem78; // required
                  _elem78 = new Transaction();
                  _elem78.read(iprot);
                  this.success.add(_elem78);
                }
                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 (Transaction _iter79 : this.success)
          {
            _iter79.write(oprot);
          }
          oprot.writeListEnd();
        }
        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 _list80 = iprot.readListBegin();
                this.success = new ArrayList<Transaction>(_list80.size);
                for (int _i81 = 0; _i81 < _list80.size; ++_i81)
                {
                  Transaction _elem82; // required
                  _elem82 = new Transaction();
                  _elem82.read(iprot);
                  this.success.add(_elem82);
                }
                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 (Transaction _iter83 : this.success)
          {
            _iter83.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      } else if (this.isSetEx()) {

        }
        switch (field.id) {
          case 1: // STATUSES
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list84 = iprot.readListBegin();
                this.statuses = new ArrayList<OrderStatus>(_list84.size);
                for (int _i85 = 0; _i85 < _list84.size; ++_i85)
                {
                  OrderStatus _elem86; // required
                  _elem86 = OrderStatus.findByValue(iprot.readI32());
                  this.statuses.add(_elem86);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.statuses != null) {
        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
          for (OrderStatus _iter87 : this.statuses)
          {
            oprot.writeI32(_iter87.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 _list88 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list88.size);
                for (int _i89 = 0; _i89 < _list88.size; ++_i89)
                {
                  Order _elem90; // required
                  _elem90 = new Order();
                  _elem90.read(iprot);
                  this.success.add(_elem90);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter91 : this.success)
          {
            _iter91.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      } else if (this.isSetEx()) {

        }
        switch (field.id) {
          case 1: // STATUSES
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list92 = iprot.readListBegin();
                this.statuses = new ArrayList<OrderStatus>(_list92.size);
                for (int _i93 = 0; _i93 < _list92.size; ++_i93)
                {
                  OrderStatus _elem94; // required
                  _elem94 = OrderStatus.findByValue(iprot.readI32());
                  this.statuses.add(_elem94);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.statuses != null) {
        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
          for (OrderStatus _iter95 : this.statuses)
          {
            oprot.writeI32(_iter95.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 _list96 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list96.size);
                for (int _i97 = 0; _i97 < _list96.size; ++_i97)
                {
                  Order _elem98; // required
                  _elem98 = new Order();
                  _elem98.read(iprot);
                  this.success.add(_elem98);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter99 : this.success)
          {
            _iter99.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      } else if (this.isSetEx()) {

        }
        switch (field.id) {
          case 1: // STATUSES
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list100 = iprot.readListBegin();
                this.statuses = new ArrayList<OrderStatus>(_list100.size);
                for (int _i101 = 0; _i101 < _list100.size; ++_i101)
                {
                  OrderStatus _elem102; // required
                  _elem102 = OrderStatus.findByValue(iprot.readI32());
                  this.statuses.add(_elem102);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.statuses != null) {
        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
          for (OrderStatus _iter103 : this.statuses)
          {
            oprot.writeI32(_iter103.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 _list104 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list104.size);
                for (int _i105 = 0; _i105 < _list104.size; ++_i105)
                {
                  Order _elem106; // required
                  _elem106 = new Order();
                  _elem106.read(iprot);
                  this.success.add(_elem106);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter107 : this.success)
          {
            _iter107.write(oprot);
          }
          oprot.writeListEnd();
        }
        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 _list108 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list108.size);
                for (int _i109 = 0; _i109 < _list108.size; ++_i109)
                {
                  Order _elem110; // required
                  _elem110 = new Order();
                  _elem110.read(iprot);
                  this.success.add(_elem110);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter111 : this.success)
          {
            _iter111.write(oprot);
          }
          oprot.writeListEnd();
        }
        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 _list112 = iprot.readListBegin();
                this.success = new ArrayList<Long>(_list112.size);
                for (int _i113 = 0; _i113 < _list112.size; ++_i113)
                {
                  long _elem114; // required
                  _elem114 = iprot.readI64();
                  this.success.add(_elem114);
                }
                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.I64, this.success.size()));
          for (long _iter115 : this.success)
          {
            oprot.writeI64(_iter115);
          }
          oprot.writeListEnd();
        }
        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 _list116 = iprot.readListBegin();
                this.success = new ArrayList<Long>(_list116.size);
                for (int _i117 = 0; _i117 < _list116.size; ++_i117)
                {
                  long _elem118; // required
                  _elem118 = iprot.readI64();
                  this.success.add(_elem118);
                }
                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.I64, this.success.size()));
          for (long _iter119 : this.success)
          {
            oprot.writeI64(_iter119);
          }
          oprot.writeListEnd();
        }
        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 _list120 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list120.size);
                for (int _i121 = 0; _i121 < _list120.size; ++_i121)
                {
                  Order _elem122; // required
                  _elem122 = new Order();
                  _elem122.read(iprot);
                  this.success.add(_elem122);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter123 : this.success)
          {
            _iter123.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      } else if (this.isSetEx()) {

            }
            break;
          case 4: // STATUSES
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list124 = iprot.readListBegin();
                this.statuses = new ArrayList<OrderStatus>(_list124.size);
                for (int _i125 = 0; _i125 < _list124.size; ++_i125)
                {
                  OrderStatus _elem126; // required
                  _elem126 = OrderStatus.findByValue(iprot.readI32());
                  this.statuses.add(_elem126);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeFieldEnd();
      if (this.statuses != null) {
        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
          for (OrderStatus _iter127 : this.statuses)
          {
            oprot.writeI32(_iter127.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 _list128 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list128.size);
                for (int _i129 = 0; _i129 < _list128.size; ++_i129)
                {
                  Order _elem130; // required
                  _elem130 = new Order();
                  _elem130.read(iprot);
                  this.success.add(_elem130);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter131 : this.success)
          {
            _iter131.write(oprot);
          }
          oprot.writeListEnd();
        }
        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 _list132 = iprot.readListBegin();
                this.success = new ArrayList<LineItem>(_list132.size);
                for (int _i133 = 0; _i133 < _list132.size; ++_i133)
                {
                  LineItem _elem134; // required
                  _elem134 = new LineItem();
                  _elem134.read(iprot);
                  this.success.add(_elem134);
                }
                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 (LineItem _iter135 : this.success)
          {
            _iter135.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      } else if (this.isSetEx()) {

        }
        switch (field.id) {
          case 1: // ORDER_IDS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list136 = iprot.readListBegin();
                this.order_ids = new ArrayList<Long>(_list136.size);
                for (int _i137 = 0; _i137 < _list136.size; ++_i137)
                {
                  long _elem138; // required
                  _elem138 = iprot.readI64();
                  this.order_ids.add(_elem138);
                }
                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 _iter139 : this.order_ids)
          {
            oprot.writeI64(_iter139);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list140 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list140.size);
                for (int _i141 = 0; _i141 < _list140.size; ++_i141)
                {
                  Order _elem142; // required
                  _elem142 = new Order();
                  _elem142.read(iprot);
                  this.success.add(_elem142);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter143 : this.success)
          {
            _iter143.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 1: // ORDER_IDS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list144 = iprot.readListBegin();
                this.order_ids = new ArrayList<Long>(_list144.size);
                for (int _i145 = 0; _i145 < _list144.size; ++_i145)
                {
                  long _elem146; // required
                  _elem146 = iprot.readI64();
                  this.order_ids.add(_elem146);
                }
                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 _iter147 : this.order_ids)
          {
            oprot.writeI64(_iter147);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list148 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list148.size);
                for (int _i149 = 0; _i149 < _list148.size; ++_i149)
                {
                  Order _elem150; // required
                  _elem150 = new Order();
                  _elem150.read(iprot);
                  this.success.add(_elem150);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter151 : this.success)
          {
            _iter151.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 _list152 = iprot.readListBegin();
                this.success = new ArrayList<Alert>(_list152.size);
                for (int _i153 = 0; _i153 < _list152.size; ++_i153)
                {
                  Alert _elem154; // required
                  _elem154 = new Alert();
                  _elem154.read(iprot);
                  this.success.add(_elem154);
                }
                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 (Alert _iter155 : this.success)
          {
            _iter155.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 _list156 = iprot.readListBegin();
                this.success = new ArrayList<Double>(_list156.size);
                for (int _i157 = 0; _i157 < _list156.size; ++_i157)
                {
                  double _elem158; // required
                  _elem158 = iprot.readDouble();
                  this.success.add(_elem158);
                }
                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.DOUBLE, this.success.size()));
          for (double _iter159 : this.success)
          {
            oprot.writeDouble(_iter159);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list160 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list160.size);
                for (int _i161 = 0; _i161 < _list160.size; ++_i161)
                {
                  Order _elem162; // required
                  _elem162 = new Order();
                  _elem162.read(iprot);
                  this.success.add(_elem162);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter163 : this.success)
          {
            _iter163.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 _list164 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list164.size);
                for (int _i165 = 0; _i165 < _list164.size; ++_i165)
                {
                  Order _elem166; // required
                  _elem166 = new Order();
                  _elem166.read(iprot);
                  this.success.add(_elem166);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter167 : this.success)
          {
            _iter167.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      } else if (this.isSetEx()) {

            }
            break;
          case 3: // SERIAL_NUMBER
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list168 = iprot.readListBegin();
                this.serialNumber = new ArrayList<String>(_list168.size);
                for (int _i169 = 0; _i169 < _list168.size; ++_i169)
                {
                  String _elem170; // required
                  _elem170 = iprot.readString();
                  this.serialNumber.add(_elem170);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case 4: // ITEM_NUMBER
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list171 = iprot.readListBegin();
                this.itemNumber = new ArrayList<String>(_list171.size);
                for (int _i172 = 0; _i172 < _list171.size; ++_i172)
                {
                  String _elem173; // required
                  _elem173 = iprot.readString();
                  this.itemNumber.add(_elem173);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      }
      if (this.serialNumber != null) {
        oprot.writeFieldBegin(SERIAL_NUMBER_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.serialNumber.size()));
          for (String _iter174 : this.serialNumber)
          {
            oprot.writeString(_iter174);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }
      if (this.itemNumber != null) {
        oprot.writeFieldBegin(ITEM_NUMBER_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.itemNumber.size()));
          for (String _iter175 : this.itemNumber)
          {
            oprot.writeString(_iter175);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

            }
            break;
          case 4: // ORDER_IDS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list176 = iprot.readListBegin();
                this.orderIds = new ArrayList<Long>(_list176.size);
                for (int _i177 = 0; _i177 < _list176.size; ++_i177)
                {
                  long _elem178; // required
                  _elem178 = iprot.readI64();
                  this.orderIds.add(_elem178);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeFieldEnd();
      if (this.orderIds != null) {
        oprot.writeFieldBegin(ORDER_IDS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.orderIds.size()));
          for (long _iter179 : this.orderIds)
          {
            oprot.writeI64(_iter179);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

            }
            break;
          case 2: // ORDER_IDS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list180 = iprot.readListBegin();
                this.orderIds = new ArrayList<Long>(_list180.size);
                for (int _i181 = 0; _i181 < _list180.size; ++_i181)
                {
                  long _elem182; // required
                  _elem182 = iprot.readI64();
                  this.orderIds.add(_elem182);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case 3: // AWBS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list183 = iprot.readListBegin();
                this.awbs = new ArrayList<String>(_list183.size);
                for (int _i184 = 0; _i184 < _list183.size; ++_i184)
                {
                  String _elem185; // required
                  _elem185 = iprot.readString();
                  this.awbs.add(_elem185);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeFieldEnd();
      if (this.orderIds != null) {
        oprot.writeFieldBegin(ORDER_IDS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.orderIds.size()));
          for (long _iter186 : this.orderIds)
          {
            oprot.writeI64(_iter186);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }
      if (this.awbs != null) {
        oprot.writeFieldBegin(AWBS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.awbs.size()));
          for (String _iter187 : this.awbs)
          {
            oprot.writeString(_iter187);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

            }
            break;
          case 2: // PICKUP_DETAILS
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map188 = iprot.readMapBegin();
                this.pickupDetails = new HashMap<String,String>(2*_map188.size);
                for (int _i189 = 0; _i189 < _map188.size; ++_i189)
                {
                  String _key190; // required
                  String _val191; // required
                  _key190 = iprot.readString();
                  _val191 = iprot.readString();
                  this.pickupDetails.put(_key190, _val191);
                }
                iprot.readMapEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeFieldEnd();
      if (this.pickupDetails != null) {
        oprot.writeFieldBegin(PICKUP_DETAILS_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.pickupDetails.size()));
          for (Map.Entry<String, String> _iter192 : this.pickupDetails.entrySet())
          {
            oprot.writeString(_iter192.getKey());
            oprot.writeString(_iter192.getValue());
          }
          oprot.writeMapEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list193 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list193.size);
                for (int _i194 = 0; _i194 < _list193.size; ++_i194)
                {
                  Order _elem195; // required
                  _elem195 = new Order();
                  _elem195.read(iprot);
                  this.success.add(_elem195);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter196 : this.success)
          {
            _iter196.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

            }
            break;
          case 2: // DELIVERED_ORDERS
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map197 = iprot.readMapBegin();
                this.deliveredOrders = new HashMap<String,String>(2*_map197.size);
                for (int _i198 = 0; _i198 < _map197.size; ++_i198)
                {
                  String _key199; // required
                  String _val200; // required
                  _key199 = iprot.readString();
                  _val200 = iprot.readString();
                  this.deliveredOrders.put(_key199, _val200);
                }
                iprot.readMapEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeFieldEnd();
      if (this.deliveredOrders != null) {
        oprot.writeFieldBegin(DELIVERED_ORDERS_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.deliveredOrders.size()));
          for (Map.Entry<String, String> _iter201 : this.deliveredOrders.entrySet())
          {
            oprot.writeString(_iter201.getKey());
            oprot.writeString(_iter201.getValue());
          }
          oprot.writeMapEnd();
        }
        oprot.writeFieldEnd();
      }

            }
            break;
          case 2: // RETURNED_ORDERS
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map202 = iprot.readMapBegin();
                this.returnedOrders = new HashMap<String,String>(2*_map202.size);
                for (int _i203 = 0; _i203 < _map202.size; ++_i203)
                {
                  String _key204; // required
                  String _val205; // required
                  _key204 = iprot.readString();
                  _val205 = iprot.readString();
                  this.returnedOrders.put(_key204, _val205);
                }
                iprot.readMapEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeFieldEnd();
      if (this.returnedOrders != null) {
        oprot.writeFieldBegin(RETURNED_ORDERS_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.returnedOrders.size()));
          for (Map.Entry<String, String> _iter206 : this.returnedOrders.entrySet())
          {
            oprot.writeString(_iter206.getKey());
            oprot.writeString(_iter206.getValue());
          }
          oprot.writeMapEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list207 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list207.size);
                for (int _i208 = 0; _i208 < _list207.size; ++_i208)
                {
                  Order _elem209; // required
                  _elem209 = new Order();
                  _elem209.read(iprot);
                  this.success.add(_elem209);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter210 : this.success)
          {
            _iter210.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

            }
            break;
          case 2: // UNDELIVERED_ORDERS
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map211 = iprot.readMapBegin();
                this.undeliveredOrders = new HashMap<String,String>(2*_map211.size);
                for (int _i212 = 0; _i212 < _map211.size; ++_i212)
                {
                  String _key213; // required
                  String _val214; // required
                  _key213 = iprot.readString();
                  _val214 = iprot.readString();
                  this.undeliveredOrders.put(_key213, _val214);
                }
                iprot.readMapEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeFieldEnd();
      if (this.undeliveredOrders != null) {
        oprot.writeFieldBegin(UNDELIVERED_ORDERS_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.undeliveredOrders.size()));
          for (Map.Entry<String, String> _iter215 : this.undeliveredOrders.entrySet())
          {
            oprot.writeString(_iter215.getKey());
            oprot.writeString(_iter215.getValue());
          }
          oprot.writeMapEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list216 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list216.size);
                for (int _i217 = 0; _i217 < _list216.size; ++_i217)
                {
                  Order _elem218; // required
                  _elem218 = new Order();
                  _elem218.read(iprot);
                  this.success.add(_elem218);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter219 : this.success)
          {
            _iter219.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

            }
            break;
          case 2: // LOCAL_CONNECTED_ORDERS
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map220 = iprot.readMapBegin();
                this.local_connected_orders = new HashMap<String,String>(2*_map220.size);
                for (int _i221 = 0; _i221 < _map220.size; ++_i221)
                {
                  String _key222; // required
                  String _val223; // required
                  _key222 = iprot.readString();
                  _val223 = iprot.readString();
                  this.local_connected_orders.put(_key222, _val223);
                }
                iprot.readMapEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeFieldEnd();
      if (this.local_connected_orders != null) {
        oprot.writeFieldBegin(LOCAL_CONNECTED_ORDERS_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.local_connected_orders.size()));
          for (Map.Entry<String, String> _iter224 : this.local_connected_orders.entrySet())
          {
            oprot.writeString(_iter224.getKey());
            oprot.writeString(_iter224.getValue());
          }
          oprot.writeMapEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list225 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list225.size);
                for (int _i226 = 0; _i226 < _list225.size; ++_i226)
                {
                  Order _elem227; // required
                  _elem227 = new Order();
                  _elem227.read(iprot);
                  this.success.add(_elem227);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter228 : this.success)
          {
            _iter228.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

            }
            break;
          case 2: // DESTINATION_CITY_REACHED_ORDERS
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map229 = iprot.readMapBegin();
                this.destination_city_reached_orders = new HashMap<String,String>(2*_map229.size);
                for (int _i230 = 0; _i230 < _map229.size; ++_i230)
                {
                  String _key231; // required
                  String _val232; // required
                  _key231 = iprot.readString();
                  _val232 = iprot.readString();
                  this.destination_city_reached_orders.put(_key231, _val232);
                }
                iprot.readMapEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeFieldEnd();
      if (this.destination_city_reached_orders != null) {
        oprot.writeFieldBegin(DESTINATION_CITY_REACHED_ORDERS_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.destination_city_reached_orders.size()));
          for (Map.Entry<String, String> _iter233 : this.destination_city_reached_orders.entrySet())
          {
            oprot.writeString(_iter233.getKey());
            oprot.writeString(_iter233.getValue());
          }
          oprot.writeMapEnd();
        }
        oprot.writeFieldEnd();
      }

            }
            break;
          case 2: // FIRST_ATDL_ORDERS
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map234 = iprot.readMapBegin();
                this.first_atdl_orders = new HashMap<String,String>(2*_map234.size);
                for (int _i235 = 0; _i235 < _map234.size; ++_i235)
                {
                  String _key236; // required
                  String _val237; // required
                  _key236 = iprot.readString();
                  _val237 = iprot.readString();
                  this.first_atdl_orders.put(_key236, _val237);
                }
                iprot.readMapEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeFieldEnd();
      if (this.first_atdl_orders != null) {
        oprot.writeFieldBegin(FIRST_ATDL_ORDERS_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.first_atdl_orders.size()));
          for (Map.Entry<String, String> _iter238 : this.first_atdl_orders.entrySet())
          {
            oprot.writeString(_iter238.getKey());
            oprot.writeString(_iter238.getValue());
          }
          oprot.writeMapEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list239 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list239.size);
                for (int _i240 = 0; _i240 < _list239.size; ++_i240)
                {
                  Order _elem241; // required
                  _elem241 = new Order();
                  _elem241.read(iprot);
                  this.success.add(_elem241);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter242 : this.success)
          {
            _iter242.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 _list243 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list243.size);
                for (int _i244 = 0; _i244 < _list243.size; ++_i244)
                {
                  Order _elem245; // required
                  _elem245 = new Order();
                  _elem245.read(iprot);
                  this.success.add(_elem245);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter246 : this.success)
          {
            _iter246.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

      }
    }
 
    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);
      }
    }

            }
            break;
          case 2: // PICKUP_DETAILS
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map247 = iprot.readMapBegin();
                this.pickupDetails = new HashMap<String,String>(2*_map247.size);
                for (int _i248 = 0; _i248 < _map247.size; ++_i248)
                {
                  String _key249; // required
                  String _val250; // required
                  _key249 = iprot.readString();
                  _val250 = iprot.readString();
                  this.pickupDetails.put(_key249, _val250);
                }
                iprot.readMapEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeFieldEnd();
      if (this.pickupDetails != null) {
        oprot.writeFieldBegin(PICKUP_DETAILS_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.pickupDetails.size()));
          for (Map.Entry<String, String> _iter251 : this.pickupDetails.entrySet())
          {
            oprot.writeString(_iter251.getKey());
            oprot.writeString(_iter251.getValue());
          }
          oprot.writeMapEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list252 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list252.size);
                for (int _i253 = 0; _i253 < _list252.size; ++_i253)
                {
                  Order _elem254; // required
                  _elem254 = new Order();
                  _elem254.read(iprot);
                  this.success.add(_elem254);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter255 : this.success)
          {
            _iter255.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

            }
            break;
          case 2: // PICKUP_DETAILS
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map256 = iprot.readMapBegin();
                this.pickupDetails = new HashMap<String,String>(2*_map256.size);
                for (int _i257 = 0; _i257 < _map256.size; ++_i257)
                {
                  String _key258; // required
                  String _val259; // required
                  _key258 = iprot.readString();
                  _val259 = iprot.readString();
                  this.pickupDetails.put(_key258, _val259);
                }
                iprot.readMapEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeFieldEnd();
      if (this.pickupDetails != null) {
        oprot.writeFieldBegin(PICKUP_DETAILS_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.pickupDetails.size()));
          for (Map.Entry<String, String> _iter260 : this.pickupDetails.entrySet())
          {
            oprot.writeString(_iter260.getKey());
            oprot.writeString(_iter260.getValue());
          }
          oprot.writeMapEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list261 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list261.size);
                for (int _i262 = 0; _i262 < _list261.size; ++_i262)
                {
                  Order _elem263; // required
                  _elem263 = new Order();
                  _elem263.read(iprot);
                  this.success.add(_elem263);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter264 : this.success)
          {
            _iter264.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 _list265 = iprot.readListBegin();
                this.success = new ArrayList<ReturnOrder>(_list265.size);
                for (int _i266 = 0; _i266 < _list265.size; ++_i266)
                {
                  ReturnOrder _elem267; // required
                  _elem267 = new ReturnOrder();
                  _elem267.read(iprot);
                  this.success.add(_elem267);
                }
                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 (ReturnOrder _iter268 : this.success)
          {
            _iter268.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 _list269 = iprot.readListBegin();
                this.success = new ArrayList<ReturnOrder>(_list269.size);
                for (int _i270 = 0; _i270 < _list269.size; ++_i270)
                {
                  ReturnOrder _elem271; // required
                  _elem271 = new ReturnOrder();
                  _elem271.read(iprot);
                  this.success.add(_elem271);
                }
                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 (ReturnOrder _iter272 : this.success)
          {
            _iter272.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 1: // COLLECTED_AMOUNT_MAP
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map273 = iprot.readMapBegin();
                this.collectedAmountMap = new HashMap<String,Double>(2*_map273.size);
                for (int _i274 = 0; _i274 < _map273.size; ++_i274)
                {
                  String _key275; // required
                  double _val276; // required
                  _key275 = iprot.readString();
                  _val276 = iprot.readDouble();
                  this.collectedAmountMap.put(_key275, _val276);
                }
                iprot.readMapEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.collectedAmountMap != null) {
        oprot.writeFieldBegin(COLLECTED_AMOUNT_MAP_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.DOUBLE, this.collectedAmountMap.size()));
          for (Map.Entry<String, Double> _iter277 : this.collectedAmountMap.entrySet())
          {
            oprot.writeString(_iter277.getKey());
            oprot.writeDouble(_iter277.getValue());
          }
          oprot.writeMapEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map278 = iprot.readMapBegin();
                this.success = new HashMap<String,String>(2*_map278.size);
                for (int _i279 = 0; _i279 < _map278.size; ++_i279)
                {
                  String _key280; // required
                  String _val281; // required
                  _key280 = iprot.readString();
                  _val281 = iprot.readString();
                  this.success.put(_key280, _val281);
                }
                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.STRING, org.apache.thrift.protocol.TType.STRING, this.success.size()));
          for (Map.Entry<String, String> _iter282 : this.success.entrySet())
          {
            oprot.writeString(_iter282.getKey());
            oprot.writeString(_iter282.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 _list283 = iprot.readListBegin();
                this.success = new ArrayList<Long>(_list283.size);
                for (int _i284 = 0; _i284 < _list283.size; ++_i284)
                {
                  long _elem285; // required
                  _elem285 = iprot.readI64();
                  this.success.add(_elem285);
                }
                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.I64, this.success.size()));
          for (long _iter286 : this.success)
          {
            oprot.writeI64(_iter286);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map287 = iprot.readMapBegin();
                this.success = new HashMap<Long,Long>(2*_map287.size);
                for (int _i288 = 0; _i288 < _map287.size; ++_i288)
                {
                  long _key289; // required
                  long _val290; // required
                  _key289 = iprot.readI64();
                  _val290 = iprot.readI64();
                  this.success.put(_key289, _val290);
                }
                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.I64, this.success.size()));
          for (Map.Entry<Long, Long> _iter291 : this.success.entrySet())
          {
            oprot.writeI64(_iter291.getKey());
            oprot.writeI64(_iter291.getValue());
          }
          oprot.writeMapEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 1: // ITEM_IDS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list292 = iprot.readListBegin();
                this.itemIds = new ArrayList<Long>(_list292.size);
                for (int _i293 = 0; _i293 < _list292.size; ++_i293)
                {
                  long _elem294; // required
                  _elem294 = iprot.readI64();
                  this.itemIds.add(_elem294);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.itemIds != null) {
        oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.itemIds.size()));
          for (long _iter295 : this.itemIds)
          {
            oprot.writeI64(_iter295);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list296 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list296.size);
                for (int _i297 = 0; _i297 < _list296.size; ++_i297)
                {
                  Order _elem298; // required
                  _elem298 = new Order();
                  _elem298.read(iprot);
                  this.success.add(_elem298);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter299 : this.success)
          {
            _iter299.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map300 = iprot.readMapBegin();
                this.success = new HashMap<Integer,TimeoutSummary>(2*_map300.size);
                for (int _i301 = 0; _i301 < _map300.size; ++_i301)
                {
                  int _key302; // required
                  TimeoutSummary _val303; // required
                  _key302 = iprot.readI32();
                  _val303 = new TimeoutSummary();
                  _val303.read(iprot);
                  this.success.put(_key302, _val303);
                }
                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.I32, org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Map.Entry<Integer, TimeoutSummary> _iter304 : this.success.entrySet())
          {
            oprot.writeI32(_iter304.getKey());
            _iter304.getValue().write(oprot);
          }
          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 _list305 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list305.size);
                for (int _i306 = 0; _i306 < _list305.size; ++_i306)
                {
                  Order _elem307; // required
                  _elem307 = new Order();
                  _elem307.read(iprot);
                  this.success.add(_elem307);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter308 : this.success)
          {
            _iter308.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      } else if (this.isSetEx()) {

            }
            break;
          case 2: // ORDER_STATUS_LIST
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list309 = iprot.readListBegin();
                this.order_status_list = new ArrayList<OrderStatus>(_list309.size);
                for (int _i310 = 0; _i310 < _list309.size; ++_i310)
                {
                  OrderStatus _elem311; // required
                  _elem311 = OrderStatus.findByValue(iprot.readI32());
                  this.order_status_list.add(_elem311);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeFieldEnd();
      if (this.order_status_list != null) {
        oprot.writeFieldBegin(ORDER_STATUS_LIST_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.order_status_list.size()));
          for (OrderStatus _iter312 : this.order_status_list)
          {
            oprot.writeI32(_iter312.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 _list313 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list313.size);
                for (int _i314 = 0; _i314 < _list313.size; ++_i314)
                {
                  Order _elem315; // required
                  _elem315 = new Order();
                  _elem315.read(iprot);
                  this.success.add(_elem315);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter316 : this.success)
          {
            _iter316.write(oprot);
          }
          oprot.writeListEnd();
        }
        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 _list317 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list317.size);
                for (int _i318 = 0; _i318 < _list317.size; ++_i318)
                {
                  Order _elem319; // required
                  _elem319 = new Order();
                  _elem319.read(iprot);
                  this.success.add(_elem319);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter320 : this.success)
          {
            _iter320.write(oprot);
          }
          oprot.writeListEnd();
        }
        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 _list321 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list321.size);
                for (int _i322 = 0; _i322 < _list321.size; ++_i322)
                {
                  Order _elem323; // required
                  _elem323 = new Order();
                  _elem323.read(iprot);
                  this.success.add(_elem323);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter324 : this.success)
          {
            _iter324.write(oprot);
          }
          oprot.writeListEnd();
        }
        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 _list325 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list325.size);
                for (int _i326 = 0; _i326 < _list325.size; ++_i326)
                {
                  Order _elem327; // required
                  _elem327 = new Order();
                  _elem327.read(iprot);
                  this.success.add(_elem327);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter328 : this.success)
          {
            _iter328.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      } else if (this.isSetEx()) {

        }
        switch (field.id) {
          case 1: // MAP_AWBAND_AMOUNT
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map329 = iprot.readMapBegin();
                this.mapAWBAndAmount = new HashMap<Long,Double>(2*_map329.size);
                for (int _i330 = 0; _i330 < _map329.size; ++_i330)
                {
                  long _key331; // required
                  double _val332; // required
                  _key331 = iprot.readI64();
                  _val332 = iprot.readDouble();
                  this.mapAWBAndAmount.put(_key331, _val332);
                }
                iprot.readMapEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.mapAWBAndAmount != null) {
        oprot.writeFieldBegin(MAP_AWBAND_AMOUNT_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.DOUBLE, this.mapAWBAndAmount.size()));
          for (Map.Entry<Long, Double> _iter333 : this.mapAWBAndAmount.entrySet())
          {
            oprot.writeI64(_iter333.getKey());
            oprot.writeDouble(_iter333.getValue());
          }
          oprot.writeMapEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map334 = iprot.readMapBegin();
                this.success = new HashMap<Long,String>(2*_map334.size);
                for (int _i335 = 0; _i335 < _map334.size; ++_i335)
                {
                  long _key336; // required
                  String _val337; // required
                  _key336 = iprot.readI64();
                  _val337 = iprot.readString();
                  this.success.put(_key336, _val337);
                }
                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.STRING, this.success.size()));
          for (Map.Entry<Long, String> _iter338 : this.success.entrySet())
          {
            oprot.writeI64(_iter338.getKey());
            oprot.writeString(_iter338.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 _list339 = iprot.readListBegin();
                this.success = new ArrayList<PaymentSettlement>(_list339.size);
                for (int _i340 = 0; _i340 < _list339.size; ++_i340)
                {
                  PaymentSettlement _elem341; // required
                  _elem341 = new PaymentSettlement();
                  _elem341.read(iprot);
                  this.success.add(_elem341);
                }
                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 (PaymentSettlement _iter342 : this.success)
          {
            _iter342.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      } else if (this.isSetEx()) {

        }
        switch (field.id) {
          case 1: // ORDER_IDS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list343 = iprot.readListBegin();
                this.orderIds = new ArrayList<Long>(_list343.size);
                for (int _i344 = 0; _i344 < _list343.size; ++_i344)
                {
                  long _elem345; // required
                  _elem345 = iprot.readI64();
                  this.orderIds.add(_elem345);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.orderIds != null) {
        oprot.writeFieldBegin(ORDER_IDS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.orderIds.size()));
          for (long _iter346 : this.orderIds)
          {
            oprot.writeI64(_iter346);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list347 = iprot.readListBegin();
                this.success = new ArrayList<Long>(_list347.size);
                for (int _i348 = 0; _i348 < _list347.size; ++_i348)
                {
                  long _elem349; // required
                  _elem349 = iprot.readI64();
                  this.success.add(_elem349);
                }
                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.I64, this.success.size()));
          for (long _iter350 : this.success)
          {
            oprot.writeI64(_iter350);
          }
          oprot.writeListEnd();
        }
        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 _list351 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list351.size);
                for (int _i352 = 0; _i352 < _list351.size; ++_i352)
                {
                  Order _elem353; // required
                  _elem353 = new Order();
                  _elem353.read(iprot);
                  this.success.add(_elem353);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter354 : this.success)
          {
            _iter354.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      } else if (this.isSetEx()) {

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map355 = iprot.readMapBegin();
                this.success = new HashMap<Long,Long>(2*_map355.size);
                for (int _i356 = 0; _i356 < _map355.size; ++_i356)
                {
                  long _key357; // required
                  long _val358; // required
                  _key357 = iprot.readI64();
                  _val358 = iprot.readI64();
                  this.success.put(_key357, _val358);
                }
                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.I64, this.success.size()));
          for (Map.Entry<Long, Long> _iter359 : this.success.entrySet())
          {
            oprot.writeI64(_iter359.getKey());
            oprot.writeI64(_iter359.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 _list360 = iprot.readListBegin();
                this.success = new ArrayList<Long>(_list360.size);
                for (int _i361 = 0; _i361 < _list360.size; ++_i361)
                {
                  long _elem362; // required
                  _elem362 = iprot.readI64();
                  this.success.add(_elem362);
                }
                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.I64, this.success.size()));
          for (long _iter363 : this.success)
          {
            oprot.writeI64(_iter363);
          }
          oprot.writeListEnd();
        }
        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 _list364 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list364.size);
                for (int _i365 = 0; _i365 < _list364.size; ++_i365)
                {
                  Order _elem366; // required
                  _elem366 = new Order();
                  _elem366.read(iprot);
                  this.success.add(_elem366);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter367 : this.success)
          {
            _iter367.write(oprot);
          }
          oprot.writeListEnd();
        }
        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 _list368 = iprot.readListBegin();
                this.success = new ArrayList<CODVerificationAgent>(_list368.size);
                for (int _i369 = 0; _i369 < _list368.size; ++_i369)
                {
                  CODVerificationAgent _elem370; // required
                  _elem370 = new CODVerificationAgent();
                  _elem370.read(iprot);
                  this.success.add(_elem370);
                }
                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 (CODVerificationAgent _iter371 : this.success)
          {
            _iter371.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 _list372 = iprot.readListBegin();
                this.success = new ArrayList<Attribute>(_list372.size);
                for (int _i373 = 0; _i373 < _list372.size; ++_i373)
                {
                  Attribute _elem374; // required
                  _elem374 = new Attribute();
                  _elem374.read(iprot);
                  this.success.add(_elem374);
                }
                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 (Attribute _iter375 : this.success)
          {
            _iter375.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

            }
            break;
          case -1: // ATTRIBUTES
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list376 = iprot.readListBegin();
                this.attributes = new ArrayList<Attribute>(_list376.size);
                for (int _i377 = 0; _i377 < _list376.size; ++_i377)
                {
                  Attribute _elem378; // required
                  _elem378 = new Attribute();
                  _elem378.read(iprot);
                  this.attributes.add(_elem378);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.attributes != null) {
        oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.attributes.size()));
          for (Attribute _iter379 : this.attributes)
          {
            _iter379.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 _list380 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list380.size);
                for (int _i381 = 0; _i381 < _list380.size; ++_i381)
                {
                  Order _elem382; // required
                  _elem382 = new Order();
                  _elem382.read(iprot);
                  this.success.add(_elem382);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter383 : this.success)
          {
            _iter383.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 _list384 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list384.size);
                for (int _i385 = 0; _i385 < _list384.size; ++_i385)
                {
                  Order _elem386; // required
                  _elem386 = new Order();
                  _elem386.read(iprot);
                  this.success.add(_elem386);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter387 : this.success)
          {
            _iter387.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 _list388 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list388.size);
                for (int _i389 = 0; _i389 < _list388.size; ++_i389)
                {
                  Order _elem390; // required
                  _elem390 = new Order();
                  _elem390.read(iprot);
                  this.success.add(_elem390);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter391 : this.success)
          {
            _iter391.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 _list392 = iprot.readListBegin();
                this.success = new ArrayList<RechargeOrder>(_list392.size);
                for (int _i393 = 0; _i393 < _list392.size; ++_i393)
                {
                  RechargeOrder _elem394; // required
                  _elem394 = new RechargeOrder();
                  _elem394.read(iprot);
                  this.success.add(_elem394);
                }
                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 (RechargeOrder _iter395 : this.success)
          {
            _iter395.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 _list396 = iprot.readListBegin();
                this.success = new ArrayList<UserWalletHistory>(_list396.size);
                for (int _i397 = 0; _i397 < _list396.size; ++_i397)
                {
                  UserWalletHistory _elem398; // required
                  _elem398 = new UserWalletHistory();
                  _elem398.read(iprot);
                  this.success.add(_elem398);
                }
                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 (UserWalletHistory _iter399 : this.success)
          {
            _iter399.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map400 = iprot.readMapBegin();
                this.success = new HashMap<Long,String>(2*_map400.size);
                for (int _i401 = 0; _i401 < _map400.size; ++_i401)
                {
                  long _key402; // required
                  String _val403; // required
                  _key402 = iprot.readI64();
                  _val403 = iprot.readString();
                  this.success.put(_key402, _val403);
                }
                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.STRING, this.success.size()));
          for (Map.Entry<Long, String> _iter404 : this.success.entrySet())
          {
            oprot.writeI64(_iter404.getKey());
            oprot.writeString(_iter404.getValue());
          }
          oprot.writeMapEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list405 = iprot.readListBegin();
                this.success = new ArrayList<RechargeOrder>(_list405.size);
                for (int _i406 = 0; _i406 < _list405.size; ++_i406)
                {
                  RechargeOrder _elem407; // required
                  _elem407 = new RechargeOrder();
                  _elem407.read(iprot);
                  this.success.add(_elem407);
                }
                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 (RechargeOrder _iter408 : this.success)
          {
            _iter408.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 _list409 = iprot.readListBegin();
                this.success = new ArrayList<RechargeOrder>(_list409.size);
                for (int _i410 = 0; _i410 < _list409.size; ++_i410)
                {
                  RechargeOrder _elem411; // required
                  _elem411 = new RechargeOrder();
                  _elem411.read(iprot);
                  this.success.add(_elem411);
                }
                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 (RechargeOrder _iter412 : this.success)
          {
            _iter412.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 _list413 = iprot.readListBegin();
                this.success = new ArrayList<RechargePlan>(_list413.size);
                for (int _i414 = 0; _i414 < _list413.size; ++_i414)
                {
                  RechargePlan _elem415; // required
                  _elem415 = new RechargePlan();
                  _elem415.read(iprot);
                  this.success.add(_elem415);
                }
                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 (RechargePlan _iter416 : this.success)
          {
            _iter416.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 _list417 = iprot.readListBegin();
                this.success = new ArrayList<RechargeDenomination>(_list417.size);
                for (int _i418 = 0; _i418 < _list417.size; ++_i418)
                {
                  RechargeDenomination _elem419; // required
                  _elem419 = new RechargeDenomination();
                  _elem419.read(iprot);
                  this.success.add(_elem419);
                }
                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 (RechargeDenomination _iter420 : this.success)
          {
            _iter420.write(oprot);
          }
          oprot.writeListEnd();
        }
        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 _list421 = iprot.readListBegin();
                this.success = new ArrayList<EmiScheme>(_list421.size);
                for (int _i422 = 0; _i422 < _list421.size; ++_i422)
                {
                  EmiScheme _elem423; // required
                  _elem423 = new EmiScheme();
                  _elem423.read(iprot);
                  this.success.add(_elem423);
                }
                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 (EmiScheme _iter424 : this.success)
          {
            _iter424.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map425 = iprot.readMapBegin();
                this.success = new HashMap<Long,Double>(2*_map425.size);
                for (int _i426 = 0; _i426 < _map425.size; ++_i426)
                {
                  long _key427; // required
                  double _val428; // required
                  _key427 = iprot.readI64();
                  _val428 = iprot.readDouble();
                  this.success.put(_key427, _val428);
                }
                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.DOUBLE, this.success.size()));
          for (Map.Entry<Long, Double> _iter429 : this.success.entrySet())
          {
            oprot.writeI64(_iter429.getKey());
            oprot.writeDouble(_iter429.getValue());
          }
          oprot.writeMapEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list430 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list430.size);
                for (int _i431 = 0; _i431 < _list430.size; ++_i431)
                {
                  Order _elem432; // required
                  _elem432 = new Order();
                  _elem432.read(iprot);
                  this.success.add(_elem432);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter433 : this.success)
          {
            _iter433.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 _list434 = iprot.readListBegin();
                this.success = new ArrayList<String>(_list434.size);
                for (int _i435 = 0; _i435 < _list434.size; ++_i435)
                {
                  String _elem436; // required
                  _elem436 = iprot.readString();
                  this.success.add(_elem436);
                }
                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.STRING, this.success.size()));
          for (String _iter437 : this.success)
          {
            oprot.writeString(_iter437);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list438 = iprot.readListBegin();
                this.success = new ArrayList<RechargeTransaction>(_list438.size);
                for (int _i439 = 0; _i439 < _list438.size; ++_i439)
                {
                  RechargeTransaction _elem440; // required
                  _elem440 = new RechargeTransaction();
                  _elem440.read(iprot);
                  this.success.add(_elem440);
                }
                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 (RechargeTransaction _iter441 : this.success)
          {
            _iter441.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 _list442 = iprot.readListBegin();
                this.success = new ArrayList<RechargeTransaction>(_list442.size);
                for (int _i443 = 0; _i443 < _list442.size; ++_i443)
                {
                  RechargeTransaction _elem444; // required
                  _elem444 = new RechargeTransaction();
                  _elem444.read(iprot);
                  this.success.add(_elem444);
                }
                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 (RechargeTransaction _iter445 : this.success)
          {
            _iter445.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 _list446 = iprot.readListBegin();
                this.success = new ArrayList<FRC>(_list446.size);
                for (int _i447 = 0; _i447 < _list446.size; ++_i447)
                {
                  FRC _elem448; // required
                  _elem448 = new FRC();
                  _elem448.read(iprot);
                  this.success.add(_elem448);
                }
                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 (FRC _iter449 : this.success)
          {
            _iter449.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 _list450 = iprot.readListBegin();
                this.success = new ArrayList<RechargeTransaction>(_list450.size);
                for (int _i451 = 0; _i451 < _list450.size; ++_i451)
                {
                  RechargeTransaction _elem452; // required
                  _elem452 = new RechargeTransaction();
                  _elem452.read(iprot);
                  this.success.add(_elem452);
                }
                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 (RechargeTransaction _iter453 : this.success)
          {
            _iter453.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 _list454 = iprot.readListBegin();
                this.success = new ArrayList<TelecomCircle>(_list454.size);
                for (int _i455 = 0; _i455 < _list454.size; ++_i455)
                {
                  TelecomCircle _elem456; // required
                  _elem456 = new TelecomCircle();
                  _elem456.read(iprot);
                  this.success.add(_elem456);
                }
                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 (TelecomCircle _iter457 : this.success)
          {
            _iter457.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 1: // FRC_IDS_TO_DELETE
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list458 = iprot.readListBegin();
                this.frcIdsToDelete = new ArrayList<Long>(_list458.size);
                for (int _i459 = 0; _i459 < _list458.size; ++_i459)
                {
                  long _elem460; // required
                  _elem460 = iprot.readI64();
                  this.frcIdsToDelete.add(_elem460);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.frcIdsToDelete != null) {
        oprot.writeFieldBegin(FRC_IDS_TO_DELETE_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.frcIdsToDelete.size()));
          for (long _iter461 : this.frcIdsToDelete)
          {
            oprot.writeI64(_iter461);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list462 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list462.size);
                for (int _i463 = 0; _i463 < _list462.size; ++_i463)
                {
                  Order _elem464; // required
                  _elem464 = new Order();
                  _elem464.read(iprot);
                  this.success.add(_elem464);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter465 : this.success)
          {
            _iter465.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 _list466 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list466.size);
                for (int _i467 = 0; _i467 < _list466.size; ++_i467)
                {
                  Order _elem468; // required
                  _elem468 = new Order();
                  _elem468.read(iprot);
                  this.success.add(_elem468);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter469 : this.success)
          {
            _iter469.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 _list470 = iprot.readListBegin();
                this.success = new ArrayList<AmazonOrder>(_list470.size);
                for (int _i471 = 0; _i471 < _list470.size; ++_i471)
                {
                  AmazonOrder _elem472; // required
                  _elem472 = new AmazonOrder();
                  _elem472.read(iprot);
                  this.success.add(_elem472);
                }
                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 (AmazonOrder _iter473 : this.success)
          {
            _iter473.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

            }
            break;
          case 5: // STATUSES
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list474 = iprot.readListBegin();
                this.statuses = new ArrayList<OrderStatus>(_list474.size);
                for (int _i475 = 0; _i475 < _list474.size; ++_i475)
                {
                  OrderStatus _elem476; // required
                  _elem476 = OrderStatus.findByValue(iprot.readI32());
                  this.statuses.add(_elem476);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeFieldEnd();
      if (this.statuses != null) {
        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
          for (OrderStatus _iter477 : this.statuses)
          {
            oprot.writeI32(_iter477.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 _list478 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list478.size);
                for (int _i479 = 0; _i479 < _list478.size; ++_i479)
                {
                  Order _elem480; // required
                  _elem480 = new Order();
                  _elem480.read(iprot);
                  this.success.add(_elem480);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter481 : this.success)
          {
            _iter481.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 _list482 = iprot.readListBegin();
                this.success = new ArrayList<String>(_list482.size);
                for (int _i483 = 0; _i483 < _list482.size; ++_i483)
                {
                  String _elem484; // required
                  _elem484 = iprot.readString();
                  this.success.add(_elem484);
                }
                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.STRING, this.success.size()));
          for (String _iter485 : this.success)
          {
            oprot.writeString(_iter485);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list486 = iprot.readListBegin();
                this.success = new ArrayList<StoreOrderCollection>(_list486.size);
                for (int _i487 = 0; _i487 < _list486.size; ++_i487)
                {
                  StoreOrderCollection _elem488; // required
                  _elem488 = new StoreOrderCollection();
                  _elem488.read(iprot);
                  this.success.add(_elem488);
                }
                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 (StoreOrderCollection _iter489 : this.success)
          {
            _iter489.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 _list490 = iprot.readListBegin();
                this.success = new ArrayList<AmazonOrdersToAcknowledge>(_list490.size);
                for (int _i491 = 0; _i491 < _list490.size; ++_i491)
                {
                  AmazonOrdersToAcknowledge _elem492; // required
                  _elem492 = new AmazonOrdersToAcknowledge();
                  _elem492.read(iprot);
                  this.success.add(_elem492);
                }
                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 (AmazonOrdersToAcknowledge _iter493 : this.success)
          {
            _iter493.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 1: // AMAZON_ORDER_DELIVERY
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map494 = iprot.readMapBegin();
                this.amazonOrderDelivery = new HashMap<Long,Map<String,String>>(2*_map494.size);
                for (int _i495 = 0; _i495 < _map494.size; ++_i495)
                {
                  long _key496; // required
                  Map<String,String> _val497; // required
                  _key496 = iprot.readI64();
                  {
                    org.apache.thrift.protocol.TMap _map498 = iprot.readMapBegin();
                    _val497 = new HashMap<String,String>(2*_map498.size);
                    for (int _i499 = 0; _i499 < _map498.size; ++_i499)
                    {
                      String _key500; // required
                      String _val501; // required
                      _key500 = iprot.readString();
                      _val501 = iprot.readString();
                      _val497.put(_key500, _val501);
                    }
                    iprot.readMapEnd();
                  }
                  this.amazonOrderDelivery.put(_key496, _val497);
                }
                iprot.readMapEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.amazonOrderDelivery != null) {
        oprot.writeFieldBegin(AMAZON_ORDER_DELIVERY_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.MAP, this.amazonOrderDelivery.size()));
          for (Map.Entry<Long, Map<String,String>> _iter502 : this.amazonOrderDelivery.entrySet())
          {
            oprot.writeI64(_iter502.getKey());
            {
              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter502.getValue().size()));
              for (Map.Entry<String, String> _iter503 : _iter502.getValue().entrySet())
              {
                oprot.writeString(_iter503.getKey());
                oprot.writeString(_iter503.getValue());
              }
              oprot.writeMapEnd();
            }
          }
          oprot.writeMapEnd();

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list504 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list504.size);
                for (int _i505 = 0; _i505 < _list504.size; ++_i505)
                {
                  Order _elem506; // required
                  _elem506 = new Order();
                  _elem506.read(iprot);
                  this.success.add(_elem506);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter507 : this.success)
          {
            _iter507.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 _list508 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list508.size);
                for (int _i509 = 0; _i509 < _list508.size; ++_i509)
                {
                  Order _elem510; // required
                  _elem510 = new Order();
                  _elem510.read(iprot);
                  this.success.add(_elem510);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter511 : this.success)
          {
            _iter511.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 _list512 = iprot.readListBegin();
                this.success = new ArrayList<HotspotServiceMatrix>(_list512.size);
                for (int _i513 = 0; _i513 < _list512.size; ++_i513)
                {
                  HotspotServiceMatrix _elem514; // required
                  _elem514 = new HotspotServiceMatrix();
                  _elem514.read(iprot);
                  this.success.add(_elem514);
                }
                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 (HotspotServiceMatrix _iter515 : this.success)
          {
            _iter515.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 1: // VENDORS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list516 = iprot.readListBegin();
                this.vendors = new ArrayList<Long>(_list516.size);
                for (int _i517 = 0; _i517 < _list516.size; ++_i517)
                {
                  long _elem518; // required
                  _elem518 = iprot.readI64();
                  this.vendors.add(_elem518);
                }
                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 _list519 = iprot.readListBegin();
                this.statuses = new ArrayList<OrderStatus>(_list519.size);
                for (int _i520 = 0; _i520 < _list519.size; ++_i520)
                {
                  OrderStatus _elem521; // required
                  _elem521 = OrderStatus.findByValue(iprot.readI32());
                  this.statuses.add(_elem521);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.vendors != null) {
        oprot.writeFieldBegin(VENDORS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.vendors.size()));
          for (long _iter522 : this.vendors)
          {
            oprot.writeI64(_iter522);
          }
          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.I32, this.statuses.size()));
          for (OrderStatus _iter523 : this.statuses)
          {
            oprot.writeI32(_iter523.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 _list524 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list524.size);
                for (int _i525 = 0; _i525 < _list524.size; ++_i525)
                {
                  Order _elem526; // required
                  _elem526 = new Order();
                  _elem526.read(iprot);
                  this.success.add(_elem526);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter527 : this.success)
          {
            _iter527.write(oprot);
          }
          oprot.writeListEnd();
        }
        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 _list528 = iprot.readListBegin();
                this.success = new ArrayList<EbayOrder>(_list528.size);
                for (int _i529 = 0; _i529 < _list528.size; ++_i529)
                {
                  EbayOrder _elem530; // required
                  _elem530 = new EbayOrder();
                  _elem530.read(iprot);
                  this.success.add(_elem530);
                }
                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 (EbayOrder _iter531 : this.success)
          {
            _iter531.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 _list532 = iprot.readListBegin();
                this.success = new ArrayList<AmazonFbaSalesSnapshot>(_list532.size);
                for (int _i533 = 0; _i533 < _list532.size; ++_i533)
                {
                  AmazonFbaSalesSnapshot _elem534; // required
                  _elem534 = new AmazonFbaSalesSnapshot();
                  _elem534.read(iprot);
                  this.success.add(_elem534);
                }
                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 (AmazonFbaSalesSnapshot _iter535 : this.success)
          {
            _iter535.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 _list536 = iprot.readListBegin();
                this.success = new ArrayList<SnapdealOrder>(_list536.size);
                for (int _i537 = 0; _i537 < _list536.size; ++_i537)
                {
                  SnapdealOrder _elem538; // required
                  _elem538 = new SnapdealOrder();
                  _elem538.read(iprot);
                  this.success.add(_elem538);
                }
                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 (SnapdealOrder _iter539 : this.success)
          {
            _iter539.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map540 = iprot.readMapBegin();
                this.success = new HashMap<Long,Long>(2*_map540.size);
                for (int _i541 = 0; _i541 < _map540.size; ++_i541)
                {
                  long _key542; // required
                  long _val543; // required
                  _key542 = iprot.readI64();
                  _val543 = iprot.readI64();
                  this.success.put(_key542, _val543);
                }
                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.I64, this.success.size()));
          for (Map.Entry<Long, Long> _iter544 : this.success.entrySet())
          {
            oprot.writeI64(_iter544.getKey());
            oprot.writeI64(_iter544.getValue());
          }
          oprot.writeMapEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list545 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list545.size);
                for (int _i546 = 0; _i546 < _list545.size; ++_i546)
                {
                  Order _elem547; // required
                  _elem547 = new Order();
                  _elem547.read(iprot);
                  this.success.add(_elem547);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter548 : this.success)
          {
            _iter548.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      } else if (this.isSetEx()) {

        }
        switch (field.id) {
          case 1: // ORDERS
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map549 = iprot.readMapBegin();
                this.orders = new HashMap<String,List<List<String>>>(2*_map549.size);
                for (int _i550 = 0; _i550 < _map549.size; ++_i550)
                {
                  String _key551; // required
                  List<List<String>> _val552; // required
                  _key551 = iprot.readString();
                  {
                    org.apache.thrift.protocol.TList _list553 = iprot.readListBegin();
                    _val552 = new ArrayList<List<String>>(_list553.size);
                    for (int _i554 = 0; _i554 < _list553.size; ++_i554)
                    {
                      List<String> _elem555; // required
                      {
                        org.apache.thrift.protocol.TList _list556 = iprot.readListBegin();
                        _elem555 = new ArrayList<String>(_list556.size);
                        for (int _i557 = 0; _i557 < _list556.size; ++_i557)
                        {
                          String _elem558; // required
                          _elem558 = iprot.readString();
                          _elem555.add(_elem558);
                        }
                        iprot.readListEnd();
                      }
                      _val552.add(_elem555);
                    }
                    iprot.readListEnd();
                  }
                  this.orders.put(_key551, _val552);
                }
                iprot.readMapEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.orders != null) {
        oprot.writeFieldBegin(ORDERS_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.LIST, this.orders.size()));
          for (Map.Entry<String, List<List<String>>> _iter559 : this.orders.entrySet())
          {
            oprot.writeString(_iter559.getKey());
            {
              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.LIST, _iter559.getValue().size()));
              for (List<String> _iter560 : _iter559.getValue())
              {
                {
                  oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter560.size()));
                  for (String _iter561 : _iter560)
                  {
                    oprot.writeString(_iter561);
                  }
                  oprot.writeListEnd();
                }
              }
              oprot.writeListEnd();

        }
        switch (field.id) {
          case 1: // DELIVERED_ORDERS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list562 = iprot.readListBegin();
                this.delivered_orders = new ArrayList<List<String>>(_list562.size);
                for (int _i563 = 0; _i563 < _list562.size; ++_i563)
                {
                  List<String> _elem564; // required
                  {
                    org.apache.thrift.protocol.TList _list565 = iprot.readListBegin();
                    _elem564 = new ArrayList<String>(_list565.size);
                    for (int _i566 = 0; _i566 < _list565.size; ++_i566)
                    {
                      String _elem567; // required
                      _elem567 = iprot.readString();
                      _elem564.add(_elem567);
                    }
                    iprot.readListEnd();
                  }
                  this.delivered_orders.add(_elem564);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.delivered_orders != null) {
        oprot.writeFieldBegin(DELIVERED_ORDERS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.LIST, this.delivered_orders.size()));
          for (List<String> _iter568 : this.delivered_orders)
          {
            {
              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter568.size()));
              for (String _iter569 : _iter568)
              {
                oprot.writeString(_iter569);
              }
              oprot.writeListEnd();
            }
          }
          oprot.writeListEnd();

        }
        switch (field.id) {
          case 1: // AMAZONFBASALESSNAPSHOTLIST
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list570 = iprot.readListBegin();
                this.amazonfbasalessnapshotlist = new ArrayList<AmazonFbaSalesSnapshot>(_list570.size);
                for (int _i571 = 0; _i571 < _list570.size; ++_i571)
                {
                  AmazonFbaSalesSnapshot _elem572; // required
                  _elem572 = new AmazonFbaSalesSnapshot();
                  _elem572.read(iprot);
                  this.amazonfbasalessnapshotlist.add(_elem572);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.amazonfbasalessnapshotlist != null) {
        oprot.writeFieldBegin(AMAZONFBASALESSNAPSHOTLIST_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.amazonfbasalessnapshotlist.size()));
          for (AmazonFbaSalesSnapshot _iter573 : this.amazonfbasalessnapshotlist)
          {
            _iter573.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case -1: // FLIPKARTORDERIDS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list574 = iprot.readListBegin();
                this.flipkartorderids = new ArrayList<String>(_list574.size);
                for (int _i575 = 0; _i575 < _list574.size; ++_i575)
                {
                  String _elem576; // required
                  _elem576 = iprot.readString();
                  this.flipkartorderids.add(_elem576);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.flipkartorderids != null) {
        oprot.writeFieldBegin(FLIPKARTORDERIDS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.flipkartorderids.size()));
          for (String _iter577 : this.flipkartorderids)
          {
            oprot.writeString(_iter577);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map578 = iprot.readMapBegin();
                this.success = new HashMap<Long,Long>(2*_map578.size);
                for (int _i579 = 0; _i579 < _map578.size; ++_i579)
                {
                  long _key580; // required
                  long _val581; // required
                  _key580 = iprot.readI64();
                  _val581 = iprot.readI64();
                  this.success.put(_key580, _val581);
                }
                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.I64, this.success.size()));
          for (Map.Entry<Long, Long> _iter582 : this.success.entrySet())
          {
            oprot.writeI64(_iter582.getKey());
            oprot.writeI64(_iter582.getValue());
          }
          oprot.writeMapEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 1: // FBA_ORDER_RETURNS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list583 = iprot.readListBegin();
                this.fbaOrderReturns = new ArrayList<AmazonFbaOrderReturns>(_list583.size);
                for (int _i584 = 0; _i584 < _list583.size; ++_i584)
                {
                  AmazonFbaOrderReturns _elem585; // required
                  _elem585 = new AmazonFbaOrderReturns();
                  _elem585.read(iprot);
                  this.fbaOrderReturns.add(_elem585);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.fbaOrderReturns != null) {
        oprot.writeFieldBegin(FBA_ORDER_RETURNS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.fbaOrderReturns.size()));
          for (AmazonFbaOrderReturns _iter586 : this.fbaOrderReturns)
          {
            _iter586.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 _list587 = iprot.readListBegin();
                this.success = new ArrayList<AmazonFbaOrderReturns>(_list587.size);
                for (int _i588 = 0; _i588 < _list587.size; ++_i588)
                {
                  AmazonFbaOrderReturns _elem589; // required
                  _elem589 = new AmazonFbaOrderReturns();
                  _elem589.read(iprot);
                  this.success.add(_elem589);
                }
                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 (AmazonFbaOrderReturns _iter590 : this.success)
          {
            _iter590.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      } else if (this.isSetEx()) {

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map591 = iprot.readMapBegin();
                this.success = new HashMap<Long,Map<String,Long>>(2*_map591.size);
                for (int _i592 = 0; _i592 < _map591.size; ++_i592)
                {
                  long _key593; // required
                  Map<String,Long> _val594; // required
                  _key593 = iprot.readI64();
                  {
                    org.apache.thrift.protocol.TMap _map595 = iprot.readMapBegin();
                    _val594 = new HashMap<String,Long>(2*_map595.size);
                    for (int _i596 = 0; _i596 < _map595.size; ++_i596)
                    {
                      String _key597; // required
                      long _val598; // required
                      _key597 = iprot.readString();
                      _val598 = iprot.readI64();
                      _val594.put(_key597, _val598);
                    }
                    iprot.readMapEnd();
                  }
                  this.success.put(_key593, _val594);
                }
                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.MAP, this.success.size()));
          for (Map.Entry<Long, Map<String,Long>> _iter599 : this.success.entrySet())
          {
            oprot.writeI64(_iter599.getKey());
            {
              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I64, _iter599.getValue().size()));
              for (Map.Entry<String, Long> _iter600 : _iter599.getValue().entrySet())
              {
                oprot.writeString(_iter600.getKey());
                oprot.writeI64(_iter600.getValue());
              }
              oprot.writeMapEnd();
            }
          }
          oprot.writeMapEnd();

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list601 = iprot.readListBegin();
                this.success = new ArrayList<FlipkartOrder>(_list601.size);
                for (int _i602 = 0; _i602 < _list601.size; ++_i602)
                {
                  FlipkartOrder _elem603; // required
                  _elem603 = new FlipkartOrder();
                  _elem603.read(iprot);
                  this.success.add(_elem603);
                }
                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 (FlipkartOrder _iter604 : this.success)
          {
            _iter604.write(oprot);
          }
          oprot.writeListEnd();
        }
        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 _list605 = iprot.readListBegin();
                this.success = new ArrayList<FlipkartAdvantageOrder>(_list605.size);
                for (int _i606 = 0; _i606 < _list605.size; ++_i606)
                {
                  FlipkartAdvantageOrder _elem607; // required
                  _elem607 = new FlipkartAdvantageOrder();
                  _elem607.read(iprot);
                  this.success.add(_elem607);
                }
                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 (FlipkartAdvantageOrder _iter608 : this.success)
          {
            _iter608.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      } else if (this.isSetEx()) {

        }
        switch (field.id) {
          case 1: // FA_ORDERS_LIST
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list609 = iprot.readListBegin();
                this.faOrdersList = new ArrayList<FlipkartAdvantageOrder>(_list609.size);
                for (int _i610 = 0; _i610 < _list609.size; ++_i610)
                {
                  FlipkartAdvantageOrder _elem611; // required
                  _elem611 = new FlipkartAdvantageOrder();
                  _elem611.read(iprot);
                  this.faOrdersList.add(_elem611);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.faOrdersList != null) {
        oprot.writeFieldBegin(FA_ORDERS_LIST_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.faOrdersList.size()));
          for (FlipkartAdvantageOrder _iter612 : this.faOrdersList)
          {
            _iter612.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 1: // FLIPKARTFASALESSNAPSHOTLIST
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list613 = iprot.readListBegin();
                this.flipkartfasalessnapshotlist = new ArrayList<FlipkartFaSalesSnapshot>(_list613.size);
                for (int _i614 = 0; _i614 < _list613.size; ++_i614)
                {
                  FlipkartFaSalesSnapshot _elem615; // required
                  _elem615 = new FlipkartFaSalesSnapshot();
                  _elem615.read(iprot);
                  this.flipkartfasalessnapshotlist.add(_elem615);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.flipkartfasalessnapshotlist != null) {
        oprot.writeFieldBegin(FLIPKARTFASALESSNAPSHOTLIST_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.flipkartfasalessnapshotlist.size()));
          for (FlipkartFaSalesSnapshot _iter616 : this.flipkartfasalessnapshotlist)
          {
            _iter616.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 _list617 = iprot.readListBegin();
                this.success = new ArrayList<FlipkartFaSalesSnapshot>(_list617.size);
                for (int _i618 = 0; _i618 < _list617.size; ++_i618)
                {
                  FlipkartFaSalesSnapshot _elem619; // required
                  _elem619 = new FlipkartFaSalesSnapshot();
                  _elem619.read(iprot);
                  this.success.add(_elem619);
                }
                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 (FlipkartFaSalesSnapshot _iter620 : this.success)
          {
            _iter620.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case -1: // ORDERS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list621 = iprot.readListBegin();
                this.orders = new ArrayList<Long>(_list621.size);
                for (int _i622 = 0; _i622 < _list621.size; ++_i622)
                {
                  long _elem623; // required
                  _elem623 = iprot.readI64();
                  this.orders.add(_elem623);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.orders != null) {
        oprot.writeFieldBegin(ORDERS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.orders.size()));
          for (long _iter624 : this.orders)
          {
            oprot.writeI64(_iter624);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list625 = iprot.readListBegin();
                this.success = new ArrayList<Order>(_list625.size);
                for (int _i626 = 0; _i626 < _list625.size; ++_i626)
                {
                  Order _elem627; // required
                  _elem627 = new Order();
                  _elem627.read(iprot);
                  this.success.add(_elem627);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (Order _iter628 : this.success)
          {
            _iter628.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      } else if (this.isSetEx()) {

        }
        switch (field.id) {
          case 1: // ORDER_IDS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list629 = iprot.readListBegin();
                this.order_ids = new ArrayList<Long>(_list629.size);
                for (int _i630 = 0; _i630 < _list629.size; ++_i630)
                {
                  long _elem631; // required
                  _elem631 = iprot.readI64();
                  this.order_ids.add(_elem631);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

            }
            break;
          case 3: // ITEM_NUMBERS_MAP
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map632 = iprot.readMapBegin();
                this.itemNumbersMap = new HashMap<Long,List<String>>(2*_map632.size);
                for (int _i633 = 0; _i633 < _map632.size; ++_i633)
                {
                  long _key634; // required
                  List<String> _val635; // required
                  _key634 = iprot.readI64();
                  {
                    org.apache.thrift.protocol.TList _list636 = iprot.readListBegin();
                    _val635 = new ArrayList<String>(_list636.size);
                    for (int _i637 = 0; _i637 < _list636.size; ++_i637)
                    {
                      String _elem638; // required
                      _elem638 = iprot.readString();
                      _val635.add(_elem638);
                    }
                    iprot.readListEnd();
                  }
                  this.itemNumbersMap.put(_key634, _val635);
                }
                iprot.readMapEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case 4: // SERIAL_NUMBERS_MAP
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map639 = iprot.readMapBegin();
                this.serialNumbersMap = new HashMap<Long,List<String>>(2*_map639.size);
                for (int _i640 = 0; _i640 < _map639.size; ++_i640)
                {
                  long _key641; // required
                  List<String> _val642; // required
                  _key641 = iprot.readI64();
                  {
                    org.apache.thrift.protocol.TList _list643 = iprot.readListBegin();
                    _val642 = new ArrayList<String>(_list643.size);
                    for (int _i644 = 0; _i644 < _list643.size; ++_i644)
                    {
                      String _elem645; // required
                      _elem645 = iprot.readString();
                      _val642.add(_elem645);
                    }
                    iprot.readListEnd();
                  }
                  this.serialNumbersMap.put(_key641, _val642);
                }
                iprot.readMapEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case 5: // FREEBIE_WAREHOUSE_ID_MAP
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map646 = iprot.readMapBegin();
                this.freebieWarehouseIdMap = new HashMap<Long,List<Long>>(2*_map646.size);
                for (int _i647 = 0; _i647 < _map646.size; ++_i647)
                {
                  long _key648; // required
                  List<Long> _val649; // required
                  _key648 = iprot.readI64();
                  {
                    org.apache.thrift.protocol.TList _list650 = iprot.readListBegin();
                    _val649 = new ArrayList<Long>(_list650.size);
                    for (int _i651 = 0; _i651 < _list650.size; ++_i651)
                    {
                      long _elem652; // required
                      _elem652 = iprot.readI64();
                      _val649.add(_elem652);
                    }
                    iprot.readListEnd();
                  }
                  this.freebieWarehouseIdMap.put(_key648, _val649);
                }
                iprot.readMapEnd();
              }
            } 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 _iter653 : this.order_ids)
          {
            oprot.writeI64(_iter653);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

      }
      if (this.itemNumbersMap != null) {
        oprot.writeFieldBegin(ITEM_NUMBERS_MAP_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.LIST, this.itemNumbersMap.size()));
          for (Map.Entry<Long, List<String>> _iter654 : this.itemNumbersMap.entrySet())
          {
            oprot.writeI64(_iter654.getKey());
            {
              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter654.getValue().size()));
              for (String _iter655 : _iter654.getValue())
              {
                oprot.writeString(_iter655);
              }
              oprot.writeListEnd();
            }
          }
          oprot.writeMapEnd();

      }
      if (this.serialNumbersMap != null) {
        oprot.writeFieldBegin(SERIAL_NUMBERS_MAP_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.LIST, this.serialNumbersMap.size()));
          for (Map.Entry<Long, List<String>> _iter656 : this.serialNumbersMap.entrySet())
          {
            oprot.writeI64(_iter656.getKey());
            {
              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter656.getValue().size()));
              for (String _iter657 : _iter656.getValue())
              {
                oprot.writeString(_iter657);
              }
              oprot.writeListEnd();
            }
          }
          oprot.writeMapEnd();

      }
      if (this.freebieWarehouseIdMap != null) {
        oprot.writeFieldBegin(FREEBIE_WAREHOUSE_ID_MAP_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.LIST, this.freebieWarehouseIdMap.size()));
          for (Map.Entry<Long, List<Long>> _iter658 : this.freebieWarehouseIdMap.entrySet())
          {
            oprot.writeI64(_iter658.getKey());
            {
              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, _iter658.getValue().size()));
              for (long _iter659 : _iter658.getValue())
              {
                oprot.writeI64(_iter659);
              }
              oprot.writeListEnd();
            }
          }
          oprot.writeMapEnd();

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list660 = iprot.readListBegin();
                this.success = new ArrayList<HsOrder>(_list660.size);
                for (int _i661 = 0; _i661 < _list660.size; ++_i661)
                {
                  HsOrder _elem662; // required
                  _elem662 = new HsOrder();
                  _elem662.read(iprot);
                  this.success.add(_elem662);
                }
                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 (HsOrder _iter663 : this.success)
          {
            _iter663.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 _list664 = iprot.readListBegin();
                this.success = new ArrayList<UserSanction>(_list664.size);
                for (int _i665 = 0; _i665 < _list664.size; ++_i665)
                {
                  UserSanction _elem666; // required
                  _elem666 = new UserSanction();
                  _elem666.read(iprot);
                  this.success.add(_elem666);
                }
                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 (UserSanction _iter667 : this.success)
          {
            _iter667.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 _list668 = iprot.readListBegin();
                this.success = new ArrayList<CreditHistory>(_list668.size);
                for (int _i669 = 0; _i669 < _list668.size; ++_i669)
                {
                  CreditHistory _elem670; // required
                  _elem670 = new CreditHistory();
                  _elem670.read(iprot);
                  this.success.add(_elem670);
                }
                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 (CreditHistory _iter671 : this.success)
          {
            _iter671.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 _list672 = iprot.readListBegin();
                this.success = new ArrayList<CreditHistory>(_list672.size);
                for (int _i673 = 0; _i673 < _list672.size; ++_i673)
                {
                  CreditHistory _elem674; // required
                  _elem674 = new CreditHistory();
                  _elem674.read(iprot);
                  this.success.add(_elem674);
                }
                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 (CreditHistory _iter675 : this.success)
          {
            _iter675.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

            }
            break;
          case 4: // CREDIT_TXNS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list676 = iprot.readListBegin();
                this.creditTxns = new ArrayList<CreditHistory>(_list676.size);
                for (int _i677 = 0; _i677 < _list676.size; ++_i677)
                {
                  CreditHistory _elem678; // required
                  _elem678 = new CreditHistory();
                  _elem678.read(iprot);
                  this.creditTxns.add(_elem678);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeFieldEnd();
      if (this.creditTxns != null) {
        oprot.writeFieldBegin(CREDIT_TXNS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.creditTxns.size()));
          for (CreditHistory _iter679 : this.creditTxns)
          {
            _iter679.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 _list680 = iprot.readListBegin();
                this.success = new ArrayList<LoanHistory>(_list680.size);
                for (int _i681 = 0; _i681 < _list680.size; ++_i681)
                {
                  LoanHistory _elem682; // required
                  _elem682 = new LoanHistory();
                  _elem682.read(iprot);
                  this.success.add(_elem682);
                }
                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 (LoanHistory _iter683 : this.success)
          {
            _iter683.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 _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);

 
      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();
      }

            }
            break;
          case 4: // CREDIT_TXNS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list688 = iprot.readListBegin();
                this.creditTxns = new ArrayList<LoanHistory>(_list688.size);
                for (int _i689 = 0; _i689 < _list688.size; ++_i689)
                {
                  LoanHistory _elem690; // required
                  _elem690 = new LoanHistory();
                  _elem690.read(iprot);
                  this.creditTxns.add(_elem690);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeFieldEnd();
      if (this.creditTxns != null) {
        oprot.writeFieldBegin(CREDIT_TXNS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.creditTxns.size()));
          for (LoanHistory _iter691 : this.creditTxns)
          {
            _iter691.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

  }
 
  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.STRUCT, (short)0);
 
    private PaginatedCreditHistory 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");
 

 
    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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, PaginatedCreditHistory.class)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getLimitedCreditHistoryRecords_result.class, metaDataMap);
    }
 
    public getLimitedCreditHistoryRecords_result() {
    }
 
    public getLimitedCreditHistoryRecords_result(
      PaginatedCreditHistory success)
    {
      this();
      this.success = success;
    }
 
    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getLimitedCreditHistoryRecords_result(getLimitedCreditHistoryRecords_result other) {
      if (other.isSetSuccess()) {
 
 
        this.success = new PaginatedCreditHistory(other.success);
 
 
      }
    }
 
    public getLimitedCreditHistoryRecords_result deepCopy() {
      return new getLimitedCreditHistoryRecords_result(this);

    @Override
    public void clear() {
      this.success = null;
    }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
    public PaginatedCreditHistory getSuccess() {
      return this.success;
    }
 
    public void setSuccess(PaginatedCreditHistory success) {
      this.success = success;
    }
 
    public void unsetSuccess() {
      this.success = null;

      switch (field) {
      case SUCCESS:
        if (value == null) {
          unsetSuccess();
        } else {
          setSuccess((PaginatedCreditHistory)value);
        }
        break;
 
      }
    }

        if (field.type == org.apache.thrift.protocol.TType.STOP) { 
          break;
        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.STRUCT) {
 
 
              this.success = new PaginatedCreditHistory();
 
 
 
 
              this.success.read(iprot);
 
 
 
 
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
            }
            break;
          default:

    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);
 
 
 
 
        this.success.write(oprot);
 
 
 
        oprot.writeFieldEnd();
      }
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

  }
 
  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.STRUCT, (short)0);
 
    private PaginatedLoanHistory 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");
 

 
    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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, PaginatedLoanHistory.class)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getLimitedLoanHistoryRecords_result.class, metaDataMap);
    }
 
    public getLimitedLoanHistoryRecords_result() {
    }
 
    public getLimitedLoanHistoryRecords_result(
      PaginatedLoanHistory success)
    {
      this();
      this.success = success;
    }
 
    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getLimitedLoanHistoryRecords_result(getLimitedLoanHistoryRecords_result other) {
      if (other.isSetSuccess()) {
 
 
        this.success = new PaginatedLoanHistory(other.success);
 
 
      }
    }
 
    public getLimitedLoanHistoryRecords_result deepCopy() {
      return new getLimitedLoanHistoryRecords_result(this);

    @Override
    public void clear() {
      this.success = null;
    }
 
    public PaginatedLoanHistory getSuccess() {
      return this.success;
    }
 
    public void setSuccess(PaginatedLoanHistory 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((PaginatedLoanHistory)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.STRUCT) {
              this.success = new PaginatedLoanHistory();
              this.success.read(iprot);
            } 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);
        this.success.write(oprot);
        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 getUserSanctionsDetailsAsPerLimit_args implements org.apache.thrift.TBase<getUserSanctionsDetailsAsPerLimit_args, getUserSanctionsDetailsAsPerLimit_args._Fields>, java.io.Serializable, Cloneable   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getUserSanctionsDetailsAsPerLimit_args");
 
    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)1);
    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)2);
    private static final org.apache.thrift.protocol.TField LIMIT_FIELD_DESC = new org.apache.thrift.protocol.TField("limit", org.apache.thrift.protocol.TType.I64, (short)3);
    private static final org.apache.thrift.protocol.TField OFFSET_FIELD_DESC = new org.apache.thrift.protocol.TField("offset", org.apache.thrift.protocol.TType.I64, (short)4);
 
    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 {
      USER_ID((short)1, "userId"),
      CREDITOR_ID((short)2, "creditorId"),
      LIMIT((short)3, "limit"),
      OFFSET((short)4, "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: // USER_ID
            return USER_ID;
          case 2: // CREDITOR_ID
            return CREDITOR_ID;
          case 3: // LIMIT
            return LIMIT;
          case 4: // 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 __USERID_ISSET_ID = 0;
    private static final int __CREDITORID_ISSET_ID = 1;
    private static final int __LIMIT_ISSET_ID = 2;
    private static final int __OFFSET_ISSET_ID = 3;
    private BitSet __isset_bit_vector = new BitSet(4);
 
    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.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(getUserSanctionsDetailsAsPerLimit_args.class, metaDataMap);
    }
 
    public getUserSanctionsDetailsAsPerLimit_args() {
    }
 
    public getUserSanctionsDetailsAsPerLimit_args(
      long userId,
      long creditorId,
      long limit,
      long offset)
    {
      this();
      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 getUserSanctionsDetailsAsPerLimit_args(getUserSanctionsDetailsAsPerLimit_args other) {
      __isset_bit_vector.clear();
      __isset_bit_vector.or(other.__isset_bit_vector);
      this.userId = other.userId;
      this.creditorId = other.creditorId;
      this.limit = other.limit;
      this.offset = other.offset;
    }
 
    public getUserSanctionsDetailsAsPerLimit_args deepCopy() {
      return new getUserSanctionsDetailsAsPerLimit_args(this);
    }
 
    @Override
    public void clear() {
      setUserIdIsSet(false);
      this.userId = 0;
      setCreditorIdIsSet(false);
      this.creditorId = 0;
      setLimitIsSet(false);
      this.limit = 0;
      setOffsetIsSet(false);
      this.offset = 0;
    }
 
    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 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 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 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 getUserSanctionsDetailsAsPerLimit_args)
        return this.equals((getUserSanctionsDetailsAsPerLimit_args)that);
      return false;
    }
 
    public boolean equals(getUserSanctionsDetailsAsPerLimit_args that) {
      if (that == null)
        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(getUserSanctionsDetailsAsPerLimit_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }
 
      int lastComparison = 0;
      getUserSanctionsDetailsAsPerLimit_args typedOther = (getUserSanctionsDetailsAsPerLimit_args)other;
 
      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: // 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 2: // 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 3: // LIMIT
            if (field.type == org.apache.thrift.protocol.TType.I64) {
              this.limit = iprot.readI64();
              setLimitIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case 4: // 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(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("getUserSanctionsDetailsAsPerLimit_args(");
      boolean first = true;
 
      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 getUserSanctionsDetailsAsPerLimit_result implements org.apache.thrift.TBase<getUserSanctionsDetailsAsPerLimit_result, getUserSanctionsDetailsAsPerLimit_result._Fields>, java.io.Serializable, Cloneable   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getUserSanctionsDetailsAsPerLimit_result");
 
    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
 
    private PaginatedUserSanction 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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, PaginatedUserSanction.class)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getUserSanctionsDetailsAsPerLimit_result.class, metaDataMap);
    }
 
    public getUserSanctionsDetailsAsPerLimit_result() {
    }
 
    public getUserSanctionsDetailsAsPerLimit_result(
      PaginatedUserSanction success)
    {
      this();
      this.success = success;
    }
 
    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getUserSanctionsDetailsAsPerLimit_result(getUserSanctionsDetailsAsPerLimit_result other) {
      if (other.isSetSuccess()) {
        this.success = new PaginatedUserSanction(other.success);
      }
    }
 
    public getUserSanctionsDetailsAsPerLimit_result deepCopy() {
      return new getUserSanctionsDetailsAsPerLimit_result(this);
    }
 
    @Override
    public void clear() {
      this.success = null;
    }
 
    public PaginatedUserSanction getSuccess() {
      return this.success;
    }
 
    public void setSuccess(PaginatedUserSanction success) {
      this.success = success;
    }
 
    public void unsetSuccess() {
      this.success = null;

      switch (field) {
      case SUCCESS:
        if (value == null) {
          unsetSuccess();
        } else {
          setSuccess((PaginatedUserSanction)value);
        }
        break;
 
      }
    }

 
    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getUserSanctionsDetailsAsPerLimit_result)
        return this.equals((getUserSanctionsDetailsAsPerLimit_result)that);
      return false;
    }
 
    public boolean equals(getUserSanctionsDetailsAsPerLimit_result that) {
      if (that == null)
        return false;
 
      boolean this_present_success = true && this.isSetSuccess();
      boolean that_present_success = true && that.isSetSuccess();

    @Override
    public int hashCode() {
      return 0;
    }
 
    public int compareTo(getUserSanctionsDetailsAsPerLimit_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }
 
      int lastComparison = 0;
      getUserSanctionsDetailsAsPerLimit_result typedOther = (getUserSanctionsDetailsAsPerLimit_result)other;
 
      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
      if (lastComparison != 0) {
        return lastComparison;
      }

        if (field.type == org.apache.thrift.protocol.TType.STOP) { 
          break;
        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.STRUCT) {
 
 
              this.success = new PaginatedUserSanction();
 
 
 
 
              this.success.read(iprot);
 
 
 
 
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
            }
            break;
          default:

    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);
 
 
 
 
        this.success.write(oprot);
 
 
 
        oprot.writeFieldEnd();
      }
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }
 
    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getUserSanctionsDetailsAsPerLimit_result(");
      boolean first = true;
 
      sb.append("success:");
      if (this.success == null) {
        sb.append("null");

        }
        switch (field.id) {
          case 1: // ORDER_IDS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list692 = iprot.readListBegin();
                this.order_ids = new ArrayList<Long>(_list692.size);
                for (int _i693 = 0; _i693 < _list692.size; ++_i693)
                {
                  long _elem694; // required
                  _elem694 = iprot.readI64();
                  this.order_ids.add(_elem694);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.order_ids != null) {
        oprot.writeFieldBegin(ORDER_IDS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.order_ids.size()));
          for (long _iter695 : this.order_ids)
          {
            oprot.writeI64(_iter695);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map696 = iprot.readMapBegin();
                this.success = new HashMap<Long,List<ReturnOrderInfo>>(2*_map696.size);
                for (int _i697 = 0; _i697 < _map696.size; ++_i697)
                {
                  long _key698; // required
                  List<ReturnOrderInfo> _val699; // required
                  _key698 = iprot.readI64();
                  {
                    org.apache.thrift.protocol.TList _list700 = iprot.readListBegin();
                    _val699 = new ArrayList<ReturnOrderInfo>(_list700.size);
                    for (int _i701 = 0; _i701 < _list700.size; ++_i701)
                    {
                      ReturnOrderInfo _elem702; // required
                      _elem702 = new ReturnOrderInfo();
                      _elem702.read(iprot);
                      _val699.add(_elem702);
                    }
                    iprot.readListEnd();
                  }
                  this.success.put(_key698, _val699);
                }
                iprot.readMapEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.LIST, this.success.size()));
          for (Map.Entry<Long, List<ReturnOrderInfo>> _iter703 : this.success.entrySet())
          {
            oprot.writeI64(_iter703.getKey());
            {
              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter703.getValue().size()));
              for (ReturnOrderInfo _iter704 : _iter703.getValue())
              {
                _iter704.write(oprot);
              }
              oprot.writeListEnd();
            }
          }
          oprot.writeMapEnd();

        }
        switch (field.id) {
          case 1: // ORDER_IDS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list705 = iprot.readListBegin();
                this.order_ids = new ArrayList<Long>(_list705.size);
                for (int _i706 = 0; _i706 < _list705.size; ++_i706)
                {
                  long _elem707; // required
                  _elem707 = iprot.readI64();
                  this.order_ids.add(_elem707);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case 2: // STATUSES
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list708 = iprot.readListBegin();
                this.statuses = new ArrayList<String>(_list708.size);
                for (int _i709 = 0; _i709 < _list708.size; ++_i709)
                {
                  String _elem710; // required
                  _elem710 = iprot.readString();
                  this.statuses.add(_elem710);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.order_ids != null) {
        oprot.writeFieldBegin(ORDER_IDS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.order_ids.size()));
          for (long _iter711 : this.order_ids)
          {
            oprot.writeI64(_iter711);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }
      if (this.statuses != null) {
        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.statuses.size()));
          for (String _iter712 : this.statuses)
          {
            oprot.writeString(_iter712);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map713 = iprot.readMapBegin();
                this.success = new HashMap<Long,List<ReturnOrderInfo>>(2*_map713.size);
                for (int _i714 = 0; _i714 < _map713.size; ++_i714)
                {
                  long _key715; // required
                  List<ReturnOrderInfo> _val716; // required
                  _key715 = iprot.readI64();
                  {
                    org.apache.thrift.protocol.TList _list717 = iprot.readListBegin();
                    _val716 = new ArrayList<ReturnOrderInfo>(_list717.size);
                    for (int _i718 = 0; _i718 < _list717.size; ++_i718)
                    {
                      ReturnOrderInfo _elem719; // required
                      _elem719 = new ReturnOrderInfo();
                      _elem719.read(iprot);
                      _val716.add(_elem719);
                    }
                    iprot.readListEnd();
                  }
                  this.success.put(_key715, _val716);
                }
                iprot.readMapEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.LIST, this.success.size()));
          for (Map.Entry<Long, List<ReturnOrderInfo>> _iter720 : this.success.entrySet())
          {
            oprot.writeI64(_iter720.getKey());
            {
              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter720.getValue().size()));
              for (ReturnOrderInfo _iter721 : _iter720.getValue())
              {
                _iter721.write(oprot);
              }
              oprot.writeListEnd();
            }
          }
          oprot.writeMapEnd();

        }
        switch (field.id) {
          case 1: // ORDER_RETURN_INFOS_MAP
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map722 = iprot.readMapBegin();
                this.orderReturnInfosMap = new HashMap<Long,List<ReturnOrderInfo>>(2*_map722.size);
                for (int _i723 = 0; _i723 < _map722.size; ++_i723)
                {
                  long _key724; // required
                  List<ReturnOrderInfo> _val725; // required
                  _key724 = iprot.readI64();
                  {
                    org.apache.thrift.protocol.TList _list726 = iprot.readListBegin();
                    _val725 = new ArrayList<ReturnOrderInfo>(_list726.size);
                    for (int _i727 = 0; _i727 < _list726.size; ++_i727)
                    {
                      ReturnOrderInfo _elem728; // required
                      _elem728 = new ReturnOrderInfo();
                      _elem728.read(iprot);
                      _val725.add(_elem728);
                    }
                    iprot.readListEnd();
                  }
                  this.orderReturnInfosMap.put(_key724, _val725);
                }
                iprot.readMapEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.orderReturnInfosMap != null) {
        oprot.writeFieldBegin(ORDER_RETURN_INFOS_MAP_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.LIST, this.orderReturnInfosMap.size()));
          for (Map.Entry<Long, List<ReturnOrderInfo>> _iter729 : this.orderReturnInfosMap.entrySet())
          {
            oprot.writeI64(_iter729.getKey());
            {
              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter729.getValue().size()));
              for (ReturnOrderInfo _iter730 : _iter729.getValue())
              {
                _iter730.write(oprot);
              }
              oprot.writeListEnd();
            }
          }
          oprot.writeMapEnd();

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map731 = iprot.readMapBegin();
                this.success = new HashMap<Long,Boolean>(2*_map731.size);
                for (int _i732 = 0; _i732 < _map731.size; ++_i732)
                {
                  long _key733; // required
                  boolean _val734; // required
                  _key733 = iprot.readI64();
                  _val734 = iprot.readBool();
                  this.success.put(_key733, _val734);
                }
                iprot.readMapEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.BOOL, this.success.size()));
          for (Map.Entry<Long, Boolean> _iter735 : this.success.entrySet())
          {
            oprot.writeI64(_iter735.getKey());
            oprot.writeBool(_iter735.getValue());
          }
          oprot.writeMapEnd();
        }
        oprot.writeFieldEnd();
      } else if (this.isSetEx()) {

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list736 = iprot.readListBegin();
                this.success = new ArrayList<ReturnOrderInfo>(_list736.size);
                for (int _i737 = 0; _i737 < _list736.size; ++_i737)
                {
                  ReturnOrderInfo _elem738; // required
                  _elem738 = new ReturnOrderInfo();
                  _elem738.read(iprot);
                  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 _iter739 : this.success)
          {
            _iter739.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list740 = iprot.readListBegin();
                this.success = new ArrayList<ReturnOrderInfo>(_list740.size);
                for (int _i741 = 0; _i741 < _list740.size; ++_i741)
                {
                  ReturnOrderInfo _elem742; // required
                  _elem742 = new ReturnOrderInfo();
                  _elem742.read(iprot);
                  this.success.add(_elem742);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (ReturnOrderInfo _iter743 : this.success)
          {
            _iter743.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      } else if (this.isSetEx()) {

            }
            break;
          case 3: // RETURN_ORDER_IDS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list744 = iprot.readListBegin();
                this.returnOrderIds = new ArrayList<Long>(_list744.size);
                for (int _i745 = 0; _i745 < _list744.size; ++_i745)
                {
                  long _elem746; // required
                  _elem746 = iprot.readI64();
                  this.returnOrderIds.add(_elem746);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      }
      if (this.returnOrderIds != null) {
        oprot.writeFieldBegin(RETURN_ORDER_IDS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.returnOrderIds.size()));
          for (long _iter747 : this.returnOrderIds)
          {
            oprot.writeI64(_iter747);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 1: // RETURN_ORDER_IDS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list748 = iprot.readListBegin();
                this.returnOrderIds = new ArrayList<Long>(_list748.size);
                for (int _i749 = 0; _i749 < _list748.size; ++_i749)
                {
                  long _elem750; // required
                  _elem750 = iprot.readI64();
                  this.returnOrderIds.add(_elem750);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.returnOrderIds != null) {
        oprot.writeFieldBegin(RETURN_ORDER_IDS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.returnOrderIds.size()));
          for (long _iter751 : this.returnOrderIds)
          {
            oprot.writeI64(_iter751);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list752 = iprot.readListBegin();
                this.success = new ArrayList<ReturnOrderInfo>(_list752.size);
                for (int _i753 = 0; _i753 < _list752.size; ++_i753)
                {
                  ReturnOrderInfo _elem754; // required
                  _elem754 = new ReturnOrderInfo();
                  _elem754.read(iprot);
                  this.success.add(_elem754);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (ReturnOrderInfo _iter755 : this.success)
          {
            _iter755.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      } else if (this.isSetEx()) {

        }
        switch (field.id) {
          case 1: // RETURN_ORDERS_MAP
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map756 = iprot.readMapBegin();
                this.returnOrdersMap = new HashMap<Long,Map<String,String>>(2*_map756.size);
                for (int _i757 = 0; _i757 < _map756.size; ++_i757)
                {
                  long _key758; // required
                  Map<String,String> _val759; // required
                  _key758 = iprot.readI64();
                  {
                    org.apache.thrift.protocol.TMap _map760 = iprot.readMapBegin();
                    _val759 = new HashMap<String,String>(2*_map760.size);
                    for (int _i761 = 0; _i761 < _map760.size; ++_i761)
                    {
                      String _key762; // required
                      String _val763; // required
                      _key762 = iprot.readString();
                      _val763 = iprot.readString();
                      _val759.put(_key762, _val763);
                    }
                    iprot.readMapEnd();
                  }
                  this.returnOrdersMap.put(_key758, _val759);
                }
                iprot.readMapEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.returnOrdersMap != null) {
        oprot.writeFieldBegin(RETURN_ORDERS_MAP_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.MAP, this.returnOrdersMap.size()));
          for (Map.Entry<Long, Map<String,String>> _iter764 : this.returnOrdersMap.entrySet())
          {
            oprot.writeI64(_iter764.getKey());
            {
              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter764.getValue().size()));
              for (Map.Entry<String, String> _iter765 : _iter764.getValue().entrySet())
              {
                oprot.writeString(_iter765.getKey());
                oprot.writeString(_iter765.getValue());
              }
              oprot.writeMapEnd();
            }
          }
          oprot.writeMapEnd();

            }
            break;
          case 2: // RETURN_ORDERS_MAP
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map766 = iprot.readMapBegin();
                this.returnOrdersMap = new HashMap<Long,Boolean>(2*_map766.size);
                for (int _i767 = 0; _i767 < _map766.size; ++_i767)
                {
                  long _key768; // required
                  boolean _val769; // required
                  _key768 = iprot.readI64();
                  _val769 = iprot.readBool();
                  this.returnOrdersMap.put(_key768, _val769);
                }
                iprot.readMapEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeFieldEnd();
      if (this.returnOrdersMap != null) {
        oprot.writeFieldBegin(RETURN_ORDERS_MAP_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.BOOL, this.returnOrdersMap.size()));
          for (Map.Entry<Long, Boolean> _iter770 : this.returnOrdersMap.entrySet())
          {
            oprot.writeI64(_iter770.getKey());
            oprot.writeBool(_iter770.getValue());
          }
          oprot.writeMapEnd();
        }
        oprot.writeFieldEnd();
      }

            }
            break;
          case 2: // RETURN_ORDERS_MAP
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map771 = iprot.readMapBegin();
                this.returnOrdersMap = new HashMap<Long,Map<String,String>>(2*_map771.size);
                for (int _i772 = 0; _i772 < _map771.size; ++_i772)
                {
                  long _key773; // required
                  Map<String,String> _val774; // required
                  _key773 = iprot.readI64();
                  {
                    org.apache.thrift.protocol.TMap _map775 = iprot.readMapBegin();
                    _val774 = new HashMap<String,String>(2*_map775.size);
                    for (int _i776 = 0; _i776 < _map775.size; ++_i776)
                    {
                      String _key777; // required
                      String _val778; // required
                      _key777 = iprot.readString();
                      _val778 = iprot.readString();
                      _val774.put(_key777, _val778);
                    }
                    iprot.readMapEnd();
                  }
                  this.returnOrdersMap.put(_key773, _val774);
                }
                iprot.readMapEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeFieldEnd();
      if (this.returnOrdersMap != null) {
        oprot.writeFieldBegin(RETURN_ORDERS_MAP_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.MAP, this.returnOrdersMap.size()));
          for (Map.Entry<Long, Map<String,String>> _iter779 : this.returnOrdersMap.entrySet())
          {
            oprot.writeI64(_iter779.getKey());
            {
              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter779.getValue().size()));
              for (Map.Entry<String, String> _iter780 : _iter779.getValue().entrySet())
              {
                oprot.writeString(_iter780.getKey());
                oprot.writeString(_iter780.getValue());
              }
              oprot.writeMapEnd();
            }
          }
          oprot.writeMapEnd();

        }
        switch (field.id) {
          case 1: // REFUND_ORDERS_MAP
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map781 = iprot.readMapBegin();
                this.refundOrdersMap = new HashMap<Long,Map<String,String>>(2*_map781.size);
                for (int _i782 = 0; _i782 < _map781.size; ++_i782)
                {
                  long _key783; // required
                  Map<String,String> _val784; // required
                  _key783 = iprot.readI64();
                  {
                    org.apache.thrift.protocol.TMap _map785 = iprot.readMapBegin();
                    _val784 = new HashMap<String,String>(2*_map785.size);
                    for (int _i786 = 0; _i786 < _map785.size; ++_i786)
                    {
                      String _key787; // required
                      String _val788; // required
                      _key787 = iprot.readString();
                      _val788 = iprot.readString();
                      _val784.put(_key787, _val788);
                    }
                    iprot.readMapEnd();
                  }
                  this.refundOrdersMap.put(_key783, _val784);
                }
                iprot.readMapEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.refundOrdersMap != null) {
        oprot.writeFieldBegin(REFUND_ORDERS_MAP_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.MAP, this.refundOrdersMap.size()));
          for (Map.Entry<Long, Map<String,String>> _iter789 : this.refundOrdersMap.entrySet())
          {
            oprot.writeI64(_iter789.getKey());
            {
              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter789.getValue().size()));
              for (Map.Entry<String, String> _iter790 : _iter789.getValue().entrySet())
              {
                oprot.writeString(_iter790.getKey());
                oprot.writeString(_iter790.getValue());
              }
              oprot.writeMapEnd();
            }
          }
          oprot.writeMapEnd();

        }
        switch (field.id) {
          case 1: // STATUS_LIST
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list791 = iprot.readListBegin();
                this.statusList = new ArrayList<ReturnTransactionStatus>(_list791.size);
                for (int _i792 = 0; _i792 < _list791.size; ++_i792)
                {
                  ReturnTransactionStatus _elem793; // required
                  _elem793 = ReturnTransactionStatus.findByValue(iprot.readI32());
                  this.statusList.add(_elem793);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.statusList != null) {
        oprot.writeFieldBegin(STATUS_LIST_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statusList.size()));
          for (ReturnTransactionStatus _iter794 : this.statusList)
          {
            oprot.writeI32(_iter794.getValue());
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        }
        switch (field.id) {
          case 0: // SUCCESS
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list795 = iprot.readListBegin();
                this.success = new ArrayList<ReturnTransaction>(_list795.size);
                for (int _i796 = 0; _i796 < _list795.size; ++_i796)
                {
                  ReturnTransaction _elem797; // required
                  _elem797 = new ReturnTransaction();
                  _elem797.read(iprot);
                  this.success.add(_elem797);
                }
                iprot.readListEnd();
              }
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
          for (ReturnTransaction _iter798 : this.success)
          {
            _iter798.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      } else if (this.isSetEx()) {

Rev 18769	Rev 18794
Line 1145...	Line 1145...
1145		1145
1146	`public List<LoanHistory> getLoanHistoryRecordsForUserAndCreditor(long userId, long creditorId, CreditTxnType creditTxnType) throws org.apache.thrift.TException;`	1146	`public List<LoanHistory> getLoanHistoryRecordsForUserAndCreditor(long userId, long creditorId, CreditTxnType creditTxnType) throws org.apache.thrift.TException;`
1147		1147
1148	`public boolean processLoanTransaction(long paymentId, long userId, long creditorId, List<LoanHistory> creditTxns) throws TransactionServiceException, org.apache.thrift.TException;`	1148	`public boolean processLoanTransaction(long paymentId, long userId, long creditorId, List<LoanHistory> creditTxns) throws TransactionServiceException, org.apache.thrift.TException;`
1149		1149
1150	`public List<CreditHistory> getLimitedCreditHistoryRecords(long paymentId, long userId, long creditorId, long limit, long offset) throws org.apache.thrift.TException;`	1150	`public PaginatedCreditHistory getLimitedCreditHistoryRecords(long paymentId, long userId, long creditorId, long limit, long offset) throws org.apache.thrift.TException;`
1151		1151
1152	`public List<LoanHistory> getLimitedLoanHistoryRecords(long paymentId, long userId, long creditorId, long limit, long offset) throws org.apache.thrift.TException;`	1152	`public PaginatedLoanHistory getLimitedLoanHistoryRecords(long paymentId, long userId, long creditorId, long limit, long offset) throws org.apache.thrift.TException;`
-		1153
-		1154	`public PaginatedUserSanction getUserSanctionsDetailsAsPerLimit(long userId, long creditorId, long limit, long offset) throws org.apache.thrift.TException;`
1153		1155
1154	`public ReturnOrderInfo getReturnOrderInfo(long id) throws TransactionServiceException, org.apache.thrift.TException;`	1156	`public ReturnOrderInfo getReturnOrderInfo(long id) throws TransactionServiceException, org.apache.thrift.TException;`
1155		1157
1156	`public Map<Long,List<ReturnOrderInfo>> getReturnOrderInfoList(List<Long> order_ids) throws org.apache.thrift.TException;`	1158	`public Map<Long,List<ReturnOrderInfo>> getReturnOrderInfoList(List<Long> order_ids) throws org.apache.thrift.TException;`
1157		1159
Line 1723...	Line 1725...
1723		1725
1724	`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;`	1726	`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;`
1725		1727
1726	`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;`	1728	`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;`
1727		1729
-		1730	`public void getUserSanctionsDetailsAsPerLimit(long userId, long creditorId, long limit, long offset, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getUserSanctionsDetailsAsPerLimit_call> resultHandler) throws org.apache.thrift.TException;`
-		1731
1728	`public void getReturnOrderInfo(long id, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getReturnOrderInfo_call> resultHandler) throws org.apache.thrift.TException;`	1732	`public void getReturnOrderInfo(long id, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getReturnOrderInfo_call> resultHandler) throws org.apache.thrift.TException;`
1729		1733
1730	`public void getReturnOrderInfoList(List<Long> order_ids, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getReturnOrderInfoList_call> resultHandler) throws org.apache.thrift.TException;`	1734	`public void getReturnOrderInfoList(List<Long> order_ids, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getReturnOrderInfoList_call> resultHandler) throws org.apache.thrift.TException;`
1731		1735
1732	`public void getReturnOrderInfoListAsByStatus(List<Long> order_ids, List<String> statuses, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getReturnOrderInfoListAsByStatus_call> resultHandler) throws org.apache.thrift.TException;`	1736	`public void getReturnOrderInfoListAsByStatus(List<Long> order_ids, List<String> statuses, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getReturnOrderInfoListAsByStatus_call> resultHandler) throws org.apache.thrift.TException;`
Line 8274...	Line 8278...
8274	`throw result.pe;`	8278	`throw result.pe;`
8275	`}`	8279	`}`
8276	`throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "processLoanTransaction failed: unknown result");`	8280	`throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "processLoanTransaction failed: unknown result");`
8277	`}`	8281	`}`
8278		8282
8279	`public List<CreditHistory> getLimitedCreditHistoryRecords(long paymentId, long userId, long creditorId, long limit, long offset) throws org.apache.thrift.TException`	8283	`public PaginatedCreditHistory getLimitedCreditHistoryRecords(long paymentId, long userId, long creditorId, long limit, long offset) throws org.apache.thrift.TException`
8280	`{`	8284	`{`
8281	`send_getLimitedCreditHistoryRecords(paymentId, userId, creditorId, limit, offset);`	8285	`send_getLimitedCreditHistoryRecords(paymentId, userId, creditorId, limit, offset);`
8282	`return recv_getLimitedCreditHistoryRecords();`	8286	`return recv_getLimitedCreditHistoryRecords();`
8283	`}`	8287	`}`
8284		8288
Line 8291...	Line 8295...
8291	`args.setLimit(limit);`	8295	`args.setLimit(limit);`
8292	`args.setOffset(offset);`	8296	`args.setOffset(offset);`
8293	`sendBase("getLimitedCreditHistoryRecords", args);`	8297	`sendBase("getLimitedCreditHistoryRecords", args);`
8294	`}`	8298	`}`
8295		8299
8296	`public List<CreditHistory> recv_getLimitedCreditHistoryRecords() throws org.apache.thrift.TException`	8300	`public PaginatedCreditHistory recv_getLimitedCreditHistoryRecords() throws org.apache.thrift.TException`
8297	`{`	8301	`{`
8298	`getLimitedCreditHistoryRecords_result result = new getLimitedCreditHistoryRecords_result();`	8302	`getLimitedCreditHistoryRecords_result result = new getLimitedCreditHistoryRecords_result();`
8299	`receiveBase(result, "getLimitedCreditHistoryRecords");`	8303	`receiveBase(result, "getLimitedCreditHistoryRecords");`
8300	`if (result.isSetSuccess()) {`	8304	`if (result.isSetSuccess()) {`
8301	`return result.success;`	8305	`return result.success;`
8302	`}`	8306	`}`
8303	`throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getLimitedCreditHistoryRecords failed: unknown result");`	8307	`throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getLimitedCreditHistoryRecords failed: unknown result");`
8304	`}`	8308	`}`
8305		8309
8306	`public List<LoanHistory> getLimitedLoanHistoryRecords(long paymentId, long userId, long creditorId, long limit, long offset) throws org.apache.thrift.TException`	8310	`public PaginatedLoanHistory getLimitedLoanHistoryRecords(long paymentId, long userId, long creditorId, long limit, long offset) throws org.apache.thrift.TException`
8307	`{`	8311	`{`
8308	`send_getLimitedLoanHistoryRecords(paymentId, userId, creditorId, limit, offset);`	8312	`send_getLimitedLoanHistoryRecords(paymentId, userId, creditorId, limit, offset);`
8309	`return recv_getLimitedLoanHistoryRecords();`	8313	`return recv_getLimitedLoanHistoryRecords();`
8310	`}`	8314	`}`
8311		8315
Line 8318...	Line 8322...
8318	`args.setLimit(limit);`	8322	`args.setLimit(limit);`
8319	`args.setOffset(offset);`	8323	`args.setOffset(offset);`
8320	`sendBase("getLimitedLoanHistoryRecords", args);`	8324	`sendBase("getLimitedLoanHistoryRecords", args);`
8321	`}`	8325	`}`
8322		8326
8323	`public List<LoanHistory> recv_getLimitedLoanHistoryRecords() throws org.apache.thrift.TException`	8327	`public PaginatedLoanHistory recv_getLimitedLoanHistoryRecords() throws org.apache.thrift.TException`
8324	`{`	8328	`{`
8325	`getLimitedLoanHistoryRecords_result result = new getLimitedLoanHistoryRecords_result();`	8329	`getLimitedLoanHistoryRecords_result result = new getLimitedLoanHistoryRecords_result();`
8326	`receiveBase(result, "getLimitedLoanHistoryRecords");`	8330	`receiveBase(result, "getLimitedLoanHistoryRecords");`
8327	`if (result.isSetSuccess()) {`	8331	`if (result.isSetSuccess()) {`
8328	`return result.success;`	8332	`return result.success;`
8329	`}`	8333	`}`
8330	`throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getLimitedLoanHistoryRecords failed: unknown result");`	8334	`throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getLimitedLoanHistoryRecords failed: unknown result");`
8331	`}`	8335	`}`
8332		8336
-		8337	`public PaginatedUserSanction getUserSanctionsDetailsAsPerLimit(long userId, long creditorId, long limit, long offset) throws org.apache.thrift.TException`
-		8338	`{`
-		8339	`send_getUserSanctionsDetailsAsPerLimit(userId, creditorId, limit, offset);`
-		8340	`return recv_getUserSanctionsDetailsAsPerLimit();`
-		8341	`}`
-		8342
-		8343	`public void send_getUserSanctionsDetailsAsPerLimit(long userId, long creditorId, long limit, long offset) throws org.apache.thrift.TException`
-		8344	`{`
-		8345	`getUserSanctionsDetailsAsPerLimit_args args = new getUserSanctionsDetailsAsPerLimit_args();`
-		8346	`args.setUserId(userId);`
-		8347	`args.setCreditorId(creditorId);`
-		8348	`args.setLimit(limit);`
-		8349	`args.setOffset(offset);`
-		8350	`sendBase("getUserSanctionsDetailsAsPerLimit", args);`
-		8351	`}`
-		8352
-		8353	`public PaginatedUserSanction recv_getUserSanctionsDetailsAsPerLimit() throws org.apache.thrift.TException`
-		8354	`{`
-		8355	`getUserSanctionsDetailsAsPerLimit_result result = new getUserSanctionsDetailsAsPerLimit_result();`
-		8356	`receiveBase(result, "getUserSanctionsDetailsAsPerLimit");`
-		8357	`if (result.isSetSuccess()) {`
-		8358	`return result.success;`
-		8359	`}`
-		8360	`throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getUserSanctionsDetailsAsPerLimit failed: unknown result");`
-		8361	`}`
-		8362
8333	`public ReturnOrderInfo getReturnOrderInfo(long id) throws TransactionServiceException, org.apache.thrift.TException`	8363	`public ReturnOrderInfo getReturnOrderInfo(long id) throws TransactionServiceException, org.apache.thrift.TException`
8334	`{`	8364	`{`
8335	`send_getReturnOrderInfo(id);`	8365	`send_getReturnOrderInfo(id);`
8336	`return recv_getReturnOrderInfo();`	8366	`return recv_getReturnOrderInfo();`
8337	`}`	8367	`}`
Line 18063...	Line 18093...
18063	`args.setOffset(offset);`	18093	`args.setOffset(offset);`
18064	`args.write(prot);`	18094	`args.write(prot);`
18065	`prot.writeMessageEnd();`	18095	`prot.writeMessageEnd();`
18066	`}`	18096	`}`
18067		18097
18068	`public List<CreditHistory> getResult() throws org.apache.thrift.TException {`	18098	`public PaginatedCreditHistory getResult() throws org.apache.thrift.TException {`
18069	`if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {`	18099	`if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {`
18070	`throw new IllegalStateException("Method call not finished!");`	18100	`throw new IllegalStateException("Method call not finished!");`
18071	`}`	18101	`}`
18072	`org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());`	18102	`org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());`
18073	`org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);`	18103	`org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);`
Line 18107...	Line 18137...
18107	`args.setOffset(offset);`	18137	`args.setOffset(offset);`
18108	`args.write(prot);`	18138	`args.write(prot);`
18109	`prot.writeMessageEnd();`	18139	`prot.writeMessageEnd();`
18110	`}`	18140	`}`
18111		18141
18112	`public List<LoanHistory> getResult() throws org.apache.thrift.TException {`	18142	`public PaginatedLoanHistory getResult() throws org.apache.thrift.TException {`
18113	`if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {`	18143	`if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {`
18114	`throw new IllegalStateException("Method call not finished!");`	18144	`throw new IllegalStateException("Method call not finished!");`
18115	`}`	18145	`}`
18116	`org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());`	18146	`org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());`
18117	`org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);`	18147	`org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);`
18118	`return (new Client(prot)).recv_getLimitedLoanHistoryRecords();`	18148	`return (new Client(prot)).recv_getLimitedLoanHistoryRecords();`
18119	`}`	18149	`}`
18120	`}`	18150	`}`
18121		18151
-		18152	`public void getUserSanctionsDetailsAsPerLimit(long userId, long creditorId, long limit, long offset, org.apache.thrift.async.AsyncMethodCallback<getUserSanctionsDetailsAsPerLimit_call> resultHandler) throws org.apache.thrift.TException {`
-		18153	`checkReady();`
-		18154	`getUserSanctionsDetailsAsPerLimit_call method_call = new getUserSanctionsDetailsAsPerLimit_call(userId, creditorId, limit, offset, resultHandler, this, ___protocolFactory, ___transport);`
-		18155	`this.___currentMethod = method_call;`
-		18156	`___manager.call(method_call);`
-		18157	`}`
-		18158
-		18159	`public static class getUserSanctionsDetailsAsPerLimit_call extends org.apache.thrift.async.TAsyncMethodCall {`
-		18160	`private long userId;`
-		18161	`private long creditorId;`
-		18162	`private long limit;`
-		18163	`private long offset;`
-		18164	`public getUserSanctionsDetailsAsPerLimit_call(long userId, long creditorId, long limit, long offset, org.apache.thrift.async.AsyncMethodCallback<getUserSanctionsDetailsAsPerLimit_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 {`
-		18165	`super(client, protocolFactory, transport, resultHandler, false);`
-		18166	`this.userId = userId;`
-		18167	`this.creditorId = creditorId;`
-		18168	`this.limit = limit;`
-		18169	`this.offset = offset;`
-		18170	`}`
-		18171
-		18172	`public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {`
-		18173	`prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getUserSanctionsDetailsAsPerLimit", org.apache.thrift.protocol.TMessageType.CALL, 0));`
-		18174	`getUserSanctionsDetailsAsPerLimit_args args = new getUserSanctionsDetailsAsPerLimit_args();`
-		18175	`args.setUserId(userId);`
-		18176	`args.setCreditorId(creditorId);`
-		18177	`args.setLimit(limit);`
-		18178	`args.setOffset(offset);`
-		18179	`args.write(prot);`
-		18180	`prot.writeMessageEnd();`
-		18181	`}`
-		18182
-		18183	`public PaginatedUserSanction getResult() throws org.apache.thrift.TException {`
-		18184	`if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {`
-		18185	`throw new IllegalStateException("Method call not finished!");`
-		18186	`}`
-		18187	`org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());`
-		18188	`org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);`
-		18189	`return (new Client(prot)).recv_getUserSanctionsDetailsAsPerLimit();`
-		18190	`}`
-		18191	`}`
-		18192
18122	`public void getReturnOrderInfo(long id, org.apache.thrift.async.AsyncMethodCallback<getReturnOrderInfo_call> resultHandler) throws org.apache.thrift.TException {`	18193	`public void getReturnOrderInfo(long id, org.apache.thrift.async.AsyncMethodCallback<getReturnOrderInfo_call> resultHandler) throws org.apache.thrift.TException {`
18123	`checkReady();`	18194	`checkReady();`
18124	`getReturnOrderInfo_call method_call = new getReturnOrderInfo_call(id, resultHandler, this, ___protocolFactory, ___transport);`	18195	`getReturnOrderInfo_call method_call = new getReturnOrderInfo_call(id, resultHandler, this, ___protocolFactory, ___transport);`
18125	`this.___currentMethod = method_call;`	18196	`this.___currentMethod = method_call;`
18126	`___manager.call(method_call);`	18197	`___manager.call(method_call);`
Line 19071...	Line 19142...
19071	`processMap.put("getLoanHistoryRecordsForTransaction", new getLoanHistoryRecordsForTransaction());`	19142	`processMap.put("getLoanHistoryRecordsForTransaction", new getLoanHistoryRecordsForTransaction());`
19072	`processMap.put("getLoanHistoryRecordsForUserAndCreditor", new getLoanHistoryRecordsForUserAndCreditor());`	19143	`processMap.put("getLoanHistoryRecordsForUserAndCreditor", new getLoanHistoryRecordsForUserAndCreditor());`
19073	`processMap.put("processLoanTransaction", new processLoanTransaction());`	19144	`processMap.put("processLoanTransaction", new processLoanTransaction());`
19074	`processMap.put("getLimitedCreditHistoryRecords", new getLimitedCreditHistoryRecords());`	19145	`processMap.put("getLimitedCreditHistoryRecords", new getLimitedCreditHistoryRecords());`
19075	`processMap.put("getLimitedLoanHistoryRecords", new getLimitedLoanHistoryRecords());`	19146	`processMap.put("getLimitedLoanHistoryRecords", new getLimitedLoanHistoryRecords());`
-		19147	`processMap.put("getUserSanctionsDetailsAsPerLimit", new getUserSanctionsDetailsAsPerLimit());`
19076	`processMap.put("getReturnOrderInfo", new getReturnOrderInfo());`	19148	`processMap.put("getReturnOrderInfo", new getReturnOrderInfo());`
19077	`processMap.put("getReturnOrderInfoList", new getReturnOrderInfoList());`	19149	`processMap.put("getReturnOrderInfoList", new getReturnOrderInfoList());`
19078	`processMap.put("getReturnOrderInfoListAsByStatus", new getReturnOrderInfoListAsByStatus());`	19150	`processMap.put("getReturnOrderInfoListAsByStatus", new getReturnOrderInfoListAsByStatus());`
19079	`processMap.put("updateReturnOrderInfo", new updateReturnOrderInfo());`	19151	`processMap.put("updateReturnOrderInfo", new updateReturnOrderInfo());`
19080	`processMap.put("bulkUpdateReturnOrderInfo", new bulkUpdateReturnOrderInfo());`	19152	`processMap.put("bulkUpdateReturnOrderInfo", new bulkUpdateReturnOrderInfo());`
Line 23877...	Line 23949...
23877	`result.success = iface.getLimitedLoanHistoryRecords(args.paymentId, args.userId, args.creditorId, args.limit, args.offset);`	23949	`result.success = iface.getLimitedLoanHistoryRecords(args.paymentId, args.userId, args.creditorId, args.limit, args.offset);`
23878	`return result;`	23950	`return result;`
23879	`}`	23951	`}`
23880	`}`	23952	`}`
23881		23953
-		23954	`private static class getUserSanctionsDetailsAsPerLimit<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getUserSanctionsDetailsAsPerLimit_args> {`
-		23955	`public getUserSanctionsDetailsAsPerLimit() {`
-		23956	`super("getUserSanctionsDetailsAsPerLimit");`
-		23957	`}`
-		23958
-		23959	`protected getUserSanctionsDetailsAsPerLimit_args getEmptyArgsInstance() {`
-		23960	`return new getUserSanctionsDetailsAsPerLimit_args();`
-		23961	`}`
-		23962
-		23963	`protected getUserSanctionsDetailsAsPerLimit_result getResult(I iface, getUserSanctionsDetailsAsPerLimit_args args) throws org.apache.thrift.TException {`
-		23964	`getUserSanctionsDetailsAsPerLimit_result result = new getUserSanctionsDetailsAsPerLimit_result();`
-		23965	`result.success = iface.getUserSanctionsDetailsAsPerLimit(args.userId, args.creditorId, args.limit, args.offset);`
-		23966	`return result;`
-		23967	`}`
-		23968	`}`
-		23969
23882	`private static class getReturnOrderInfo<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getReturnOrderInfo_args> {`	23970	`private static class getReturnOrderInfo<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getReturnOrderInfo_args> {`
23883	`public getReturnOrderInfo() {`	23971	`public getReturnOrderInfo() {`
23884	`super("getReturnOrderInfo");`	23972	`super("getReturnOrderInfo");`
23885	`}`	23973	`}`
23886		23974
Line 26508...	Line 26596...
26508	`}`	26596	`}`
26509	`switch (field.id) {`	26597	`switch (field.id) {`
26510	`case 0: // SUCCESS`	26598	`case 0: // SUCCESS`
26511	`if (field.type == org.apache.thrift.protocol.TType.LIST) {`	26599	`if (field.type == org.apache.thrift.protocol.TType.LIST) {`
26512	`{`	26600	`{`
26513	`org.apache.thrift.protocol.TList _list64 = iprot.readListBegin();`	26601	`org.apache.thrift.protocol.TList _list76 = iprot.readListBegin();`
26514	`this.success = new ArrayList<Transaction>(_list64.size);`	26602	`this.success = new ArrayList<Transaction>(_list76.size);`
26515	`for (int _i65 = 0; _i65 < _list64.size; ++_i65)`	26603	`for (int _i77 = 0; _i77 < _list76.size; ++_i77)`
26516	`{`	26604	`{`
26517	`Transaction _elem66; // required`	26605	`Transaction _elem78; // required`
26518	`_elem66 = new Transaction();`	26606	`_elem78 = new Transaction();`
26519	`_elem66.read(iprot);`	26607	`_elem78.read(iprot);`
26520	`this.success.add(_elem66);`	26608	`this.success.add(_elem78);`
26521	`}`	26609	`}`
26522	`iprot.readListEnd();`	26610	`iprot.readListEnd();`
26523	`}`	26611	`}`
26524	`} else {`	26612	`} else {`
26525	`org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);`	26613	`org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);`
Line 26547...	Line 26635...
26547		26635
26548	`if (this.isSetSuccess()) {`	26636	`if (this.isSetSuccess()) {`
26549	`oprot.writeFieldBegin(SUCCESS_FIELD_DESC);`	26637	`oprot.writeFieldBegin(SUCCESS_FIELD_DESC);`
26550	`{`	26638	`{`
26551	`oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));`	26639	`oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));`
26552	`for (Transaction _iter67 : this.success)`	26640	`for (Transaction _iter79 : this.success)`
26553	`{`	26641	`{`
26554	`_iter67.write(oprot);`	26642	`_iter79.write(oprot);`
26555	`}`	26643	`}`
26556	`oprot.writeListEnd();`	26644	`oprot.writeListEnd();`
26557	`}`	26645	`}`
26558	`oprot.writeFieldEnd();`	26646	`oprot.writeFieldEnd();`
26559	`} else if (this.isSetEx()) {`	26647	`} else if (this.isSetEx()) {`
Line 27221...	Line 27309...
27221	`}`	27309	`}`
27222	`switch (field.id) {`	27310	`switch (field.id) {`
27223	`case 0: // SUCCESS`	27311	`case 0: // SUCCESS`
27224	`if (field.type == org.apache.thrift.protocol.TType.LIST) {`	27312	`if (field.type == org.apache.thrift.protocol.TType.LIST) {`
27225	`{`	27313	`{`
27226	`org.apache.thrift.protocol.TList _list68 = iprot.readListBegin();`	27314	`org.apache.thrift.protocol.TList _list80 = iprot.readListBegin();`
27227	`this.success = new ArrayList<Transaction>(_list68.size);`	27315	`this.success = new ArrayList<Transaction>(_list80.size);`
27228	`for (int _i69 = 0; _i69 < _list68.size; ++_i69)`	27316	`for (int _i81 = 0; _i81 < _list80.size; ++_i81)`
27229	`{`	27317	`{`
27230	`Transaction _elem70; // required`	27318	`Transaction _elem82; // required`
27231	`_elem70 = new Transaction();`	27319	`_elem82 = new Transaction();`
27232	`_elem70.read(iprot);`	27320	`_elem82.read(iprot);`
27233	`this.success.add(_elem70);`	27321	`this.success.add(_elem82);`
27234	`}`	27322	`}`
27235	`iprot.readListEnd();`	27323	`iprot.readListEnd();`
27236	`}`	27324	`}`
27237	`} else {`	27325	`} else {`
27238	`org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);`	27326	`org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);`
Line 27260...	Line 27348...
27260		27348
27261	`if (this.isSetSuccess()) {`	27349	`if (this.isSetSuccess()) {`
27262	`oprot.writeFieldBegin(SUCCESS_FIELD_DESC);`	27350	`oprot.writeFieldBegin(SUCCESS_FIELD_DESC);`
27263	`{`	27351	`{`
27264	`oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));`	27352	`oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));`
27265	`for (Transaction _iter71 : this.success)`	27353	`for (Transaction _iter83 : this.success)`
27266	`{`	27354	`{`
27267	`_iter71.write(oprot);`	27355	`_iter83.write(oprot);`
27268	`}`	27356	`}`
27269	`oprot.writeListEnd();`	27357	`oprot.writeListEnd();`
27270	`}`	27358	`}`
27271	`oprot.writeFieldEnd();`	27359	`oprot.writeFieldEnd();`
27272	`} else if (this.isSetEx()) {`	27360	`} else if (this.isSetEx()) {`
Line 30287...	Line 30375...
30287	`}`	30375	`}`
30288	`switch (field.id) {`	30376	`switch (field.id) {`
30289	`case 1: // STATUSES`	30377	`case 1: // STATUSES`
30290	`if (field.type == org.apache.thrift.protocol.TType.LIST) {`	30378	`if (field.type == org.apache.thrift.protocol.TType.LIST) {`
30291	`{`	30379	`{`
30292	`org.apache.thrift.protocol.TList _list72 = iprot.readListBegin();`	30380	`org.apache.thrift.protocol.TList _list84 = iprot.readListBegin();`
30293	`this.statuses = new ArrayList<OrderStatus>(_list72.size);`	30381	`this.statuses = new ArrayList<OrderStatus>(_list84.size);`
30294	`for (int _i73 = 0; _i73 < _list72.size; ++_i73)`	30382	`for (int _i85 = 0; _i85 < _list84.size; ++_i85)`
30295	`{`	30383	`{`
30296	`OrderStatus _elem74; // required`	30384	`OrderStatus _elem86; // required`
30297	`_elem74 = OrderStatus.findByValue(iprot.readI32());`	30385	`_elem86 = OrderStatus.findByValue(iprot.readI32());`
30298	`this.statuses.add(_elem74);`	30386	`this.statuses.add(_elem86);`
30299	`}`	30387	`}`
30300	`iprot.readListEnd();`	30388	`iprot.readListEnd();`
30301	`}`	30389	`}`
30302	`} else {`	30390	`} else {`
30303	`org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);`	30391	`org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);`
Line 30342...	Line 30430...
30342	`oprot.writeStructBegin(STRUCT_DESC);`	30430	`oprot.writeStructBegin(STRUCT_DESC);`
30343	`if (this.statuses != null) {`	30431	`if (this.statuses != null) {`
30344	`oprot.writeFieldBegin(STATUSES_FIELD_DESC);`	30432	`oprot.writeFieldBegin(STATUSES_FIELD_DESC);`
30345	`{`	30433	`{`
30346	`oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));`	30434	`oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));`
30347	`for (OrderStatus _iter75 : this.statuses)`	30435	`for (OrderStatus _iter87 : this.statuses)`
30348	`{`	30436	`{`
30349	`oprot.writeI32(_iter75.getValue());`	30437	`oprot.writeI32(_iter87.getValue());`
30350	`}`	30438	`}`
30351	`oprot.writeListEnd();`	30439	`oprot.writeListEnd();`
30352	`}`	30440	`}`
30353	`oprot.writeFieldEnd();`	30441	`oprot.writeFieldEnd();`
30354	`}`	30442	`}`
Line 30733...	Line 30821...
30733	`}`	30821	`}`
30734	`switch (field.id) {`	30822	`switch (field.id) {`
30735	`case 0: // SUCCESS`	30823	`case 0: // SUCCESS`
30736	`if (field.type == org.apache.thrift.protocol.TType.LIST) {`	30824	`if (field.type == org.apache.thrift.protocol.TType.LIST) {`
30737	`{`	30825	`{`
30738	`org.apache.thrift.protocol.TList _list76 = iprot.readListBegin();`	30826	`org.apache.thrift.protocol.TList _list88 = iprot.readListBegin();`
30739	`this.success = new ArrayList<Order>(_list76.size);`	30827	`this.success = new ArrayList<Order>(_list88.size);`
30740	`for (int _i77 = 0; _i77 < _list76.size; ++_i77)`	30828	`for (int _i89 = 0; _i89 < _list88.size; ++_i89)`
30741	`{`	30829	`{`
30742	`Order _elem78; // required`	30830	`Order _elem90; // required`
30743	`_elem78 = new Order();`	30831	`_elem90 = new Order();`
30744	`_elem78.read(iprot);`	30832	`_elem90.read(iprot);`
30745	`this.success.add(_elem78);`	30833	`this.success.add(_elem90);`
30746	`}`	30834	`}`
30747	`iprot.readListEnd();`	30835	`iprot.readListEnd();`
30748	`}`	30836	`}`
30749	`} else {`	30837	`} else {`
30750	`org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);`	30838	`org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);`
Line 30772...	Line 30860...
30772		30860
30773	`if (this.isSetSuccess()) {`	30861	`if (this.isSetSuccess()) {`
30774	`oprot.writeFieldBegin(SUCCESS_FIELD_DESC);`	30862	`oprot.writeFieldBegin(SUCCESS_FIELD_DESC);`
30775	`{`	30863	`{`
30776	`oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));`	30864	`oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));`
30777	`for (Order _iter79 : this.success)`	30865	`for (Order _iter91 : this.success)`
30778	`{`	30866	`{`
30779	`_iter79.write(oprot);`	30867	`_iter91.write(oprot);`
30780	`}`	30868	`}`
30781	`oprot.writeListEnd();`	30869	`oprot.writeListEnd();`
30782	`}`	30870	`}`
30783	`oprot.writeFieldEnd();`	30871	`oprot.writeFieldEnd();`
30784	`} else if (this.isSetEx()) {`	30872	`} else if (this.isSetEx()) {`
Line 31359...	Line 31447...
31359	`}`	31447	`}`
31360	`switch (field.id) {`	31448	`switch (field.id) {`
31361	`case 1: // STATUSES`	31449	`case 1: // STATUSES`
31362	`if (field.type == org.apache.thrift.protocol.TType.LIST) {`	31450	`if (field.type == org.apache.thrift.protocol.TType.LIST) {`
31363	`{`	31451	`{`
31364	`org.apache.thrift.protocol.TList _list80 = iprot.readListBegin();`	31452	`org.apache.thrift.protocol.TList _list92 = iprot.readListBegin();`
31365	`this.statuses = new ArrayList<OrderStatus>(_list80.size);`	31453	`this.statuses = new ArrayList<OrderStatus>(_list92.size);`
31366	`for (int _i81 = 0; _i81 < _list80.size; ++_i81)`	31454	`for (int _i93 = 0; _i93 < _list92.size; ++_i93)`
31367	`{`	31455	`{`
31368	`OrderStatus _elem82; // required`	31456	`OrderStatus _elem94; // required`
31369	`_elem82 = OrderStatus.findByValue(iprot.readI32());`	31457	`_elem94 = OrderStatus.findByValue(iprot.readI32());`
31370	`this.statuses.add(_elem82);`	31458	`this.statuses.add(_elem94);`
31371	`}`	31459	`}`
31372	`iprot.readListEnd();`	31460	`iprot.readListEnd();`
31373	`}`	31461	`}`
31374	`} else {`	31462	`} else {`
31375	`org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);`	31463	`org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);`
Line 31422...	Line 31510...
31422	`oprot.writeStructBegin(STRUCT_DESC);`	31510	`oprot.writeStructBegin(STRUCT_DESC);`
31423	`if (this.statuses != null) {`	31511	`if (this.statuses != null) {`
31424	`oprot.writeFieldBegin(STATUSES_FIELD_DESC);`	31512	`oprot.writeFieldBegin(STATUSES_FIELD_DESC);`
31425	`{`	31513	`{`
31426	`oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));`	31514	`oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));`
31427	`for (OrderStatus _iter83 : this.statuses)`	31515	`for (OrderStatus _iter95 : this.statuses)`
31428	`{`	31516	`{`
31429	`oprot.writeI32(_iter83.getValue());`	31517	`oprot.writeI32(_iter95.getValue());`
31430	`}`	31518	`}`
31431	`oprot.writeListEnd();`	31519	`oprot.writeListEnd();`
31432	`}`	31520	`}`
31433	`oprot.writeFieldEnd();`	31521	`oprot.writeFieldEnd();`
31434	`}`	31522	`}`
Line 31818...	Line 31906...
31818	`}`	31906	`}`
31819	`switch (field.id) {`	31907	`switch (field.id) {`
31820	`case 0: // SUCCESS`	31908	`case 0: // SUCCESS`
31821	`if (field.type == org.apache.thrift.protocol.TType.LIST) {`	31909	`if (field.type == org.apache.thrift.protocol.TType.LIST) {`
31822	`{`	31910	`{`
31823	`org.apache.thrift.protocol.TList _list84 = iprot.readListBegin();`	31911	`org.apache.thrift.protocol.TList _list96 = iprot.readListBegin();`
31824	`this.success = new ArrayList<Order>(_list84.size);`	31912	`this.success = new ArrayList<Order>(_list96.size);`
31825	`for (int _i85 = 0; _i85 < _list84.size; ++_i85)`	31913	`for (int _i97 = 0; _i97 < _list96.size; ++_i97)`
31826	`{`	31914	`{`
31827	`Order _elem86; // required`	31915	`Order _elem98; // required`
31828	`_elem86 = new Order();`	31916	`_elem98 = new Order();`
31829	`_elem86.read(iprot);`	31917	`_elem98.read(iprot);`
31830	`this.success.add(_elem86);`	31918	`this.success.add(_elem98);`
31831	`}`	31919	`}`
31832	`iprot.readListEnd();`	31920	`iprot.readListEnd();`
31833	`}`	31921	`}`
31834	`} else {`	31922	`} else {`
31835	`org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);`	31923	`org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);`
Line 31857...	Line 31945...
31857		31945
31858	`if (this.isSetSuccess()) {`	31946	`if (this.isSetSuccess()) {`
31859	`oprot.writeFieldBegin(SUCCESS_FIELD_DESC);`	31947	`oprot.writeFieldBegin(SUCCESS_FIELD_DESC);`
31860	`{`	31948	`{`
31861	`oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));`	31949	`oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));`
31862	`for (Order _iter87 : this.success)`	31950	`for (Order _iter99 : this.success)`
31863	`{`	31951	`{`
31864	`_iter87.write(oprot);`	31952	`_iter99.write(oprot);`
31865	`}`	31953	`}`
31866	`oprot.writeListEnd();`	31954	`oprot.writeListEnd();`
31867	`}`	31955	`}`
31868	`oprot.writeFieldEnd();`	31956	`oprot.writeFieldEnd();`
31869	`} else if (this.isSetEx()) {`	31957	`} else if (this.isSetEx()) {`
Line 32308...	Line 32396...
32308	`}`	32396	`}`
32309	`switch (field.id) {`	32397	`switch (field.id) {`
32310	`case 1: // STATUSES`	32398	`case 1: // STATUSES`
32311	`if (field.type == org.apache.thrift.protocol.TType.LIST) {`	32399	`if (field.type == org.apache.thrift.protocol.TType.LIST) {`
32312	`{`	32400	`{`
32313	`org.apache.thrift.protocol.TList _list88 = iprot.readListBegin();`	32401	`org.apache.thrift.protocol.TList _list100 = iprot.readListBegin();`
32314	`this.statuses = new ArrayList<OrderStatus>(_list88.size);`	32402	`this.statuses = new ArrayList<OrderStatus>(_list100.size);`
32315	`for (int _i89 = 0; _i89 < _list88.size; ++_i89)`	32403	`for (int _i101 = 0; _i101 < _list100.size; ++_i101)`
32316	`{`	32404	`{`
32317	`OrderStatus _elem90; // required`	32405	`OrderStatus _elem102; // required`
32318	`_elem90 = OrderStatus.findByValue(iprot.readI32());`	32406	`_elem102 = OrderStatus.findByValue(iprot.readI32());`
32319	`this.statuses.add(_elem90);`	32407	`this.statuses.add(_elem102);`
32320	`}`	32408	`}`
32321	`iprot.readListEnd();`	32409	`iprot.readListEnd();`
32322	`}`	32410	`}`
32323	`} else {`	32411	`} else {`
32324	`org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);`	32412	`org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);`
Line 32355...	Line 32443...
32355	`oprot.writeStructBegin(STRUCT_DESC);`	32443	`oprot.writeStructBegin(STRUCT_DESC);`
32356	`if (this.statuses != null) {`	32444	`if (this.statuses != null) {`
32357	`oprot.writeFieldBegin(STATUSES_FIELD_DESC);`	32445	`oprot.writeFieldBegin(STATUSES_FIELD_DESC);`
32358	`{`	32446	`{`
32359	`oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));`	32447	`oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));`
32360	`for (OrderStatus _iter91 : this.statuses)`	32448	`for (OrderStatus _iter103 : this.statuses)`
32361	`{`	32449	`{`
32362	`oprot.writeI32(_iter91.getValue());`	32450	`oprot.writeI32(_iter103.getValue());`
32363	`}`	32451	`}`
32364	`oprot.writeListEnd();`	32452	`oprot.writeListEnd();`
32365	`}`	32453	`}`
32366	`oprot.writeFieldEnd();`	32454	`oprot.writeFieldEnd();`
32367	`}`	32455	`}`
Line 33678...	Line 33766...
33678	`}`	33766	`}`
33679	`switch (field.id) {`	33767	`switch (field.id) {`
33680	`case 0: // SUCCESS`	33768	`case 0: // SUCCESS`
33681	`if (field.type == org.apache.thrift.protocol.TType.LIST) {`	33769	`if (field.type == org.apache.thrift.protocol.TType.LIST) {`
33682	`{`	33770	`{`
33683	`org.apache.thrift.protocol.TList _list92 = iprot.readListBegin();`	33771	`org.apache.thrift.protocol.TList _list104 = iprot.readListBegin();`
33684	`this.success = new ArrayList<Order>(_list92.size);`	33772	`this.success = new ArrayList<Order>(_list104.size);`
33685	`for (int _i93 = 0; _i93 < _list92.size; ++_i93)`	33773	`for (int _i105 = 0; _i105 < _list104.size; ++_i105)`
33686	`{`	33774	`{`
33687	`Order _elem94; // required`	33775	`Order _elem106; // required`
33688	`_elem94 = new Order();`	33776	`_elem106 = new Order();`
33689	`_elem94.read(iprot);`	33777	`_elem106.read(iprot);`
33690	`this.success.add(_elem94);`	33778	`this.success.add(_elem106);`
33691	`}`	33779	`}`
33692	`iprot.readListEnd();`	33780	`iprot.readListEnd();`
33693	`}`	33781	`}`
33694	`} else {`	33782	`} else {`
33695	`org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);`	33783	`org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);`
Line 33717...	Line 33805...
33717		33805
33718	`if (this.isSetSuccess()) {`	33806	`if (this.isSetSuccess()) {`
33719	`oprot.writeFieldBegin(SUCCESS_FIELD_DESC);`	33807	`oprot.writeFieldBegin(SUCCESS_FIELD_DESC);`
33720	`{`	33808	`{`
33721	`oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));`	33809	`oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));`
33722	`for (Order _iter95 : this.success)`	33810	`for (Order _iter107 : this.success)`
33723	`{`	33811	`{`
33724	`_iter95.write(oprot);`	33812	`_iter107.write(oprot);`
33725	`}`	33813	`}`
33726	`oprot.writeListEnd();`	33814	`oprot.writeListEnd();`
33727	`}`	33815	`}`
33728	`oprot.writeFieldEnd();`	33816	`oprot.writeFieldEnd();`
33729	`} else if (this.isSetEx()) {`	33817	`} else if (this.isSetEx()) {`
Line 34721...	Line 34809...
34721	`}`	34809	`}`
34722	`switch (field.id) {`	34810	`switch (field.id) {`
34723	`case 0: // SUCCESS`	34811	`case 0: // SUCCESS`
34724	`if (field.type == org.apache.thrift.protocol.TType.LIST) {`	34812	`if (field.type == org.apache.thrift.protocol.TType.LIST) {`
34725	`{`	34813	`{`
34726	`org.apache.thrift.protocol.TList _list96 = iprot.readListBegin();`	34814	`org.apache.thrift.protocol.TList _list108 = iprot.readListBegin();`
34727	`this.success = new ArrayList<Order>(_list96.size);`	34815	`this.success = new ArrayList<Order>(_list108.size);`
34728	`for (int _i97 = 0; _i97 < _list96.size; ++_i97)`	34816	`for (int _i109 = 0; _i109 < _list108.size; ++_i109)`
34729	`{`	34817	`{`
34730	`Order _elem98; // required`	34818	`Order _elem110; // required`
34731	`_elem98 = new Order();`	34819	`_elem110 = new Order();`
34732	`_elem98.read(iprot);`	34820	`_elem110.read(iprot);`
34733	`this.success.add(_elem98);`	34821	`this.success.add(_elem110);`
34734	`}`	34822	`}`
34735	`iprot.readListEnd();`	34823	`iprot.readListEnd();`

Subversion Repositories SmartDukaan

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