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

      * @param fulfilmentWarehouseId
      * @param billingWarehouseId
      */
     public void acceptOrderForItem(long itemId, long quantity, long fulfilmentWarehouseId, long billingWarehouseId) throws org.apache.thrift.TException;
+    public RechargeOrder createRechargeOrder(RechargeOrder rechargeOrder) throws TransactionServiceException, org.apache.thrift.TException;
+    public void updateRechargeOrderStatus(long rechargeOrderId, RechargeOrderStatus rechargeOrderStatus) throws TransactionServiceException, org.apache.thrift.TException;
+    public RechargeResponse activateRechargeTxn(List<RechargeCoupon> rechargeCoupons) throws TransactionServiceException, org.apache.thrift.TException;
+    public List<RechargeOrder> getRechargeOrders(long customerId) throws org.apache.thrift.TException;
+    public List<RechargeCoupon> getRechargeCoupons(long customerId, RechargeCouponStatus rechargeCouponStatus) throws org.apache.thrift.TException;
+  }
   public interface AsyncIface extends in.shop2020.generic.GenericService .AsyncIface {
     public void createTransaction(Transaction transaction, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.createTransaction_call> resultHandler) throws org.apache.thrift.TException;
     public void getOrderAttributeValue(long orderId, String attributeName, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getOrderAttributeValue_call> resultHandler) throws org.apache.thrift.TException;
     public void acceptOrderForItem(long itemId, long quantity, long fulfilmentWarehouseId, long billingWarehouseId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.acceptOrderForItem_call> resultHandler) throws org.apache.thrift.TException;
+    public void createRechargeOrder(RechargeOrder rechargeOrder, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.createRechargeOrder_call> resultHandler) throws org.apache.thrift.TException;
+    public void updateRechargeOrderStatus(long rechargeOrderId, RechargeOrderStatus rechargeOrderStatus, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.updateRechargeOrderStatus_call> resultHandler) throws org.apache.thrift.TException;
+    public void activateRechargeTxn(List<RechargeCoupon> rechargeCoupons, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.activateRechargeTxn_call> resultHandler) throws org.apache.thrift.TException;
+    public void getRechargeOrders(long customerId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getRechargeOrders_call> resultHandler) throws org.apache.thrift.TException;
+    public void getRechargeCoupons(long customerId, RechargeCouponStatus rechargeCouponStatus, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getRechargeCoupons_call> resultHandler) throws org.apache.thrift.TException;
+  }
   public static class Client extends in.shop2020.generic.GenericService.Client implements Iface {
     public static class Factory implements org.apache.thrift.TServiceClientFactory<Client> {
       public Factory() {}
       acceptOrderForItem_result result = new acceptOrderForItem_result();
       receiveBase(result, "acceptOrderForItem");
       return;
+    }
+    public RechargeOrder createRechargeOrder(RechargeOrder rechargeOrder) throws TransactionServiceException, org.apache.thrift.TException
+    {
+      send_createRechargeOrder(rechargeOrder);
+      return recv_createRechargeOrder();
+    }
+    public void send_createRechargeOrder(RechargeOrder rechargeOrder) throws org.apache.thrift.TException
+    {
+      createRechargeOrder_args args = new createRechargeOrder_args();
+      args.setRechargeOrder(rechargeOrder);
+      sendBase("createRechargeOrder", args);
+    }
+    public RechargeOrder recv_createRechargeOrder() throws TransactionServiceException, org.apache.thrift.TException
+    {
+      createRechargeOrder_result result = new createRechargeOrder_result();
+      receiveBase(result, "createRechargeOrder");
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      if (result.ex != null) {
+        throw result.ex;
+      }
+      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
+    }
+    public void updateRechargeOrderStatus(long rechargeOrderId, RechargeOrderStatus rechargeOrderStatus) throws TransactionServiceException, org.apache.thrift.TException
+    {
+      send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus);
+      recv_updateRechargeOrderStatus();
+    }
+    public void send_updateRechargeOrderStatus(long rechargeOrderId, RechargeOrderStatus rechargeOrderStatus) throws org.apache.thrift.TException
+    {
+      updateRechargeOrderStatus_args args = new updateRechargeOrderStatus_args();
+      args.setRechargeOrderId(rechargeOrderId);
+      args.setRechargeOrderStatus(rechargeOrderStatus);
+      sendBase("updateRechargeOrderStatus", args);
+    }
+    public void recv_updateRechargeOrderStatus() throws TransactionServiceException, org.apache.thrift.TException
+    {
+      updateRechargeOrderStatus_result result = new updateRechargeOrderStatus_result();
+      receiveBase(result, "updateRechargeOrderStatus");
+      if (result.ex != null) {
+        throw result.ex;
+      }
+      return;
+    }
+    public RechargeResponse activateRechargeTxn(List<RechargeCoupon> rechargeCoupons) throws TransactionServiceException, org.apache.thrift.TException
+    {
+      send_activateRechargeTxn(rechargeCoupons);
+      return recv_activateRechargeTxn();
+    }
+    public void send_activateRechargeTxn(List<RechargeCoupon> rechargeCoupons) throws org.apache.thrift.TException
+    {
+      activateRechargeTxn_args args = new activateRechargeTxn_args();
+      args.setRechargeCoupons(rechargeCoupons);
+      sendBase("activateRechargeTxn", args);
+    }
+    public RechargeResponse recv_activateRechargeTxn() throws TransactionServiceException, org.apache.thrift.TException
+    {
+      activateRechargeTxn_result result = new activateRechargeTxn_result();
+      receiveBase(result, "activateRechargeTxn");
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      if (result.ex != null) {
+        throw result.ex;
+      }
+      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
+    }
+    public List<RechargeOrder> getRechargeOrders(long customerId) throws org.apache.thrift.TException
+    {
+      send_getRechargeOrders(customerId);
+      return recv_getRechargeOrders();
+    }
+    public void send_getRechargeOrders(long customerId) throws org.apache.thrift.TException
+    {
+      getRechargeOrders_args args = new getRechargeOrders_args();
+      args.setCustomerId(customerId);
+      sendBase("getRechargeOrders", args);
+    }
+    public List<RechargeOrder> recv_getRechargeOrders() throws org.apache.thrift.TException
+    {
+      getRechargeOrders_result result = new getRechargeOrders_result();
+      receiveBase(result, "getRechargeOrders");
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
+    }
+    public List<RechargeCoupon> getRechargeCoupons(long customerId, RechargeCouponStatus rechargeCouponStatus) throws org.apache.thrift.TException
+    {
+      send_getRechargeCoupons(customerId, rechargeCouponStatus);
+      return recv_getRechargeCoupons();
+    }
+    public void send_getRechargeCoupons(long customerId, RechargeCouponStatus rechargeCouponStatus) throws org.apache.thrift.TException
+    {
+      getRechargeCoupons_args args = new getRechargeCoupons_args();
+      args.setCustomerId(customerId);
+      args.setRechargeCouponStatus(rechargeCouponStatus);
+      sendBase("getRechargeCoupons", args);
+    }
+    public List<RechargeCoupon> recv_getRechargeCoupons() throws org.apache.thrift.TException
+    {
+      getRechargeCoupons_result result = new getRechargeCoupons_result();
+      receiveBase(result, "getRechargeCoupons");
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getRechargeCoupons failed: unknown result");
+    }
+  }
   public static class AsyncClient extends in.shop2020.generic.GenericService.AsyncClient implements AsyncIface {
     public static class Factory implements org.apache.thrift.async.TAsyncClientFactory<AsyncClient> {
       private org.apache.thrift.async.TAsyncClientManager clientManager;
       private org.apache.thrift.protocol.TProtocolFactory protocolFactory;
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         (new Client(prot)).recv_acceptOrderForItem();
+      }
+    }
+    public void createRechargeOrder(RechargeOrder rechargeOrder, org.apache.thrift.async.AsyncMethodCallback<createRechargeOrder_call> resultHandler) throws org.apache.thrift.TException {
+      checkReady();
+      createRechargeOrder_call method_call = new createRechargeOrder_call(rechargeOrder, resultHandler, this, ___protocolFactory, ___transport);
+      this.___currentMethod = method_call;
+      ___manager.call(method_call);
+    }
+    public static class createRechargeOrder_call extends org.apache.thrift.async.TAsyncMethodCall {
+      private RechargeOrder rechargeOrder;
+      public createRechargeOrder_call(RechargeOrder rechargeOrder, org.apache.thrift.async.AsyncMethodCallback<createRechargeOrder_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.rechargeOrder = rechargeOrder;
+      }
+      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("createRechargeOrder", org.apache.thrift.protocol.TMessageType.CALL, 0));
+        createRechargeOrder_args args = new createRechargeOrder_args();
+        args.setRechargeOrder(rechargeOrder);
+        args.write(prot);
+        prot.writeMessageEnd();
+      }
+      public RechargeOrder getResult() throws TransactionServiceException, 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_createRechargeOrder();
+      }
+    }
+    public void updateRechargeOrderStatus(long rechargeOrderId, RechargeOrderStatus rechargeOrderStatus, org.apache.thrift.async.AsyncMethodCallback<updateRechargeOrderStatus_call> resultHandler) throws org.apache.thrift.TException {
+      checkReady();
+      updateRechargeOrderStatus_call method_call = new updateRechargeOrderStatus_call(rechargeOrderId, rechargeOrderStatus, resultHandler, this, ___protocolFactory, ___transport);
+      this.___currentMethod = method_call;
+      ___manager.call(method_call);
+    }
+    public static class updateRechargeOrderStatus_call extends org.apache.thrift.async.TAsyncMethodCall {
+      private long rechargeOrderId;
+      private RechargeOrderStatus rechargeOrderStatus;
+      public updateRechargeOrderStatus_call(long rechargeOrderId, RechargeOrderStatus rechargeOrderStatus, org.apache.thrift.async.AsyncMethodCallback<updateRechargeOrderStatus_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.rechargeOrderId = rechargeOrderId;
+        this.rechargeOrderStatus = rechargeOrderStatus;
+      }
+      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("updateRechargeOrderStatus", org.apache.thrift.protocol.TMessageType.CALL, 0));
+        updateRechargeOrderStatus_args args = new updateRechargeOrderStatus_args();
+        args.setRechargeOrderId(rechargeOrderId);
+        args.setRechargeOrderStatus(rechargeOrderStatus);
+        args.write(prot);
+        prot.writeMessageEnd();
+      }
+      public void getResult() throws TransactionServiceException, 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);
+        (new Client(prot)).recv_updateRechargeOrderStatus();
+      }
+    }
+    public void activateRechargeTxn(List<RechargeCoupon> rechargeCoupons, org.apache.thrift.async.AsyncMethodCallback<activateRechargeTxn_call> resultHandler) throws org.apache.thrift.TException {
+      checkReady();
+      activateRechargeTxn_call method_call = new activateRechargeTxn_call(rechargeCoupons, resultHandler, this, ___protocolFactory, ___transport);
+      this.___currentMethod = method_call;
+      ___manager.call(method_call);
+    }
+    public static class activateRechargeTxn_call extends org.apache.thrift.async.TAsyncMethodCall {
+      private List<RechargeCoupon> rechargeCoupons;
+      public activateRechargeTxn_call(List<RechargeCoupon> rechargeCoupons, org.apache.thrift.async.AsyncMethodCallback<activateRechargeTxn_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.rechargeCoupons = rechargeCoupons;
+      }
+      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("activateRechargeTxn", org.apache.thrift.protocol.TMessageType.CALL, 0));
+        activateRechargeTxn_args args = new activateRechargeTxn_args();
+        args.setRechargeCoupons(rechargeCoupons);
+        args.write(prot);
+        prot.writeMessageEnd();
+      }
+      public RechargeResponse getResult() throws TransactionServiceException, 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_activateRechargeTxn();
+      }
+    }
+    public void getRechargeOrders(long customerId, org.apache.thrift.async.AsyncMethodCallback<getRechargeOrders_call> resultHandler) throws org.apache.thrift.TException {
+      checkReady();
+      getRechargeOrders_call method_call = new getRechargeOrders_call(customerId, resultHandler, this, ___protocolFactory, ___transport);
+      this.___currentMethod = method_call;
+      ___manager.call(method_call);
+    }
+    public static class getRechargeOrders_call extends org.apache.thrift.async.TAsyncMethodCall {
+      private long customerId;
+      public getRechargeOrders_call(long customerId, org.apache.thrift.async.AsyncMethodCallback<getRechargeOrders_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.customerId = customerId;
+      }
+      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRechargeOrders", org.apache.thrift.protocol.TMessageType.CALL, 0));
+        getRechargeOrders_args args = new getRechargeOrders_args();
+        args.setCustomerId(customerId);
+        args.write(prot);
+        prot.writeMessageEnd();
+      }
+      public List<RechargeOrder> 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_getRechargeOrders();
+      }
+    }
+    public void getRechargeCoupons(long customerId, RechargeCouponStatus rechargeCouponStatus, org.apache.thrift.async.AsyncMethodCallback<getRechargeCoupons_call> resultHandler) throws org.apache.thrift.TException {
+      checkReady();
+      getRechargeCoupons_call method_call = new getRechargeCoupons_call(customerId, rechargeCouponStatus, resultHandler, this, ___protocolFactory, ___transport);
+      this.___currentMethod = method_call;
+      ___manager.call(method_call);
+    }
+    public static class getRechargeCoupons_call extends org.apache.thrift.async.TAsyncMethodCall {
+      private long customerId;
+      private RechargeCouponStatus rechargeCouponStatus;
+      public getRechargeCoupons_call(long customerId, RechargeCouponStatus rechargeCouponStatus, org.apache.thrift.async.AsyncMethodCallback<getRechargeCoupons_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.customerId = customerId;
+        this.rechargeCouponStatus = rechargeCouponStatus;
+      }
+      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getRechargeCoupons", org.apache.thrift.protocol.TMessageType.CALL, 0));
+        getRechargeCoupons_args args = new getRechargeCoupons_args();
+        args.setCustomerId(customerId);
+        args.setRechargeCouponStatus(rechargeCouponStatus);
+        args.write(prot);
+        prot.writeMessageEnd();
+      }
+      public List<RechargeCoupon> 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_getRechargeCoupons();
+      }
+    }
+  }
   public static class Processor<I extends Iface> extends in.shop2020.generic.GenericService.Processor implements org.apache.thrift.TProcessor {
     private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
     public Processor(I iface) {
       processMap.put("getReceivePendingOrders", new getReceivePendingOrders());
       processMap.put("getReceivedAtStoreOrders", new getReceivedAtStoreOrders());
       processMap.put("getOrdersCollectionAtStore", new getOrdersCollectionAtStore());
       processMap.put("getOrderAttributeValue", new getOrderAttributeValue());
       processMap.put("acceptOrderForItem", new acceptOrderForItem());
+      processMap.put("createRechargeOrder", new createRechargeOrder());
+      processMap.put("updateRechargeOrderStatus", new updateRechargeOrderStatus());
+      processMap.put("activateRechargeTxn", new activateRechargeTxn());
+      processMap.put("getRechargeOrders", new getRechargeOrders());
+      processMap.put("getRechargeCoupons", new getRechargeCoupons());
       return processMap;
+    }
     private static class createTransaction<I extends Iface> extends org.apache.thrift.ProcessFunction<I, createTransaction_args> {
       public createTransaction() {
         iface.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId);
         return result;
+      }
+    }
+    private static class createRechargeOrder<I extends Iface> extends org.apache.thrift.ProcessFunction<I, createRechargeOrder_args> {
+      public createRechargeOrder() {
+        super("createRechargeOrder");
+      }
+      protected createRechargeOrder_args getEmptyArgsInstance() {
+        return new createRechargeOrder_args();
+      }
+      protected createRechargeOrder_result getResult(I iface, createRechargeOrder_args args) throws org.apache.thrift.TException {
+        createRechargeOrder_result result = new createRechargeOrder_result();
+        try {
+          result.success = iface.createRechargeOrder(args.rechargeOrder);
+        } catch (TransactionServiceException ex) {
+          result.ex = ex;
+        }
+        return result;
+      }
+    }
+    private static class updateRechargeOrderStatus<I extends Iface> extends org.apache.thrift.ProcessFunction<I, updateRechargeOrderStatus_args> {
+      public updateRechargeOrderStatus() {
+        super("updateRechargeOrderStatus");
+      }
+      protected updateRechargeOrderStatus_args getEmptyArgsInstance() {
+        return new updateRechargeOrderStatus_args();
+      }
+      protected updateRechargeOrderStatus_result getResult(I iface, updateRechargeOrderStatus_args args) throws org.apache.thrift.TException {
+        updateRechargeOrderStatus_result result = new updateRechargeOrderStatus_result();
+        try {
+          iface.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus);
+        } catch (TransactionServiceException ex) {
+          result.ex = ex;
+        }
+        return result;
+      }
+    }
+    private static class activateRechargeTxn<I extends Iface> extends org.apache.thrift.ProcessFunction<I, activateRechargeTxn_args> {
+      public activateRechargeTxn() {
+        super("activateRechargeTxn");
+      }
+      protected activateRechargeTxn_args getEmptyArgsInstance() {
+        return new activateRechargeTxn_args();
+      }
+      protected activateRechargeTxn_result getResult(I iface, activateRechargeTxn_args args) throws org.apache.thrift.TException {
+        activateRechargeTxn_result result = new activateRechargeTxn_result();
+        try {
+          result.success = iface.activateRechargeTxn(args.rechargeCoupons);
+        } catch (TransactionServiceException ex) {
+          result.ex = ex;
+        }
+        return result;
+      }
+    }
+    private static class getRechargeOrders<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getRechargeOrders_args> {
+      public getRechargeOrders() {
+        super("getRechargeOrders");
+      }
+      protected getRechargeOrders_args getEmptyArgsInstance() {
+        return new getRechargeOrders_args();
+      }
+      protected getRechargeOrders_result getResult(I iface, getRechargeOrders_args args) throws org.apache.thrift.TException {
+        getRechargeOrders_result result = new getRechargeOrders_result();
+        result.success = iface.getRechargeOrders(args.customerId);
+        return result;
+      }
+    }
+    private static class getRechargeCoupons<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getRechargeCoupons_args> {
+      public getRechargeCoupons() {
+        super("getRechargeCoupons");
+      }
+      protected getRechargeCoupons_args getEmptyArgsInstance() {
+        return new getRechargeCoupons_args();
+      }
+      protected getRechargeCoupons_result getResult(I iface, getRechargeCoupons_args args) throws org.apache.thrift.TException {
+        getRechargeCoupons_result result = new getRechargeCoupons_result();
+        result.success = iface.getRechargeCoupons(args.customerId, args.rechargeCouponStatus);
+        return result;
+      }
+    }
+  }
   public static class createTransaction_args implements org.apache.thrift.TBase<createTransaction_args, createTransaction_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("createTransaction_args");
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list36 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list40 = iprot.readListBegin();
-                this.success = new ArrayList<Transaction>(_list36.size);
+                this.success = new ArrayList<Transaction>(_list40.size);
-                for (int _i37 = 0; _i37 < _list36.size; ++_i37)
+                for (int _i41 = 0; _i41 < _list40.size; ++_i41)
+                {
-                  Transaction _elem38; // required
+                  Transaction _elem42; // required
-                  _elem38 = new Transaction();
+                  _elem42 = new Transaction();
-                  _elem38.read(iprot);
+                  _elem42.read(iprot);
-                  this.success.add(_elem38);
+                  this.success.add(_elem42);
+                }
                 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 _iter39 : this.success)
+          for (Transaction _iter43 : this.success)
+          {
-            _iter39.write(oprot);
+            _iter43.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 _list40 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list44 = iprot.readListBegin();
-                this.success = new ArrayList<Transaction>(_list40.size);
+                this.success = new ArrayList<Transaction>(_list44.size);
-                for (int _i41 = 0; _i41 < _list40.size; ++_i41)
+                for (int _i45 = 0; _i45 < _list44.size; ++_i45)
+                {
-                  Transaction _elem42; // required
+                  Transaction _elem46; // required
-                  _elem42 = new Transaction();
+                  _elem46 = new Transaction();
-                  _elem42.read(iprot);
+                  _elem46.read(iprot);
-                  this.success.add(_elem42);
+                  this.success.add(_elem46);
+                }
                 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 _iter43 : this.success)
+          for (Transaction _iter47 : this.success)
+          {
-            _iter43.write(oprot);
+            _iter47.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 _list44 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list48 = iprot.readListBegin();
-                this.statuses = new ArrayList<OrderStatus>(_list44.size);
+                this.statuses = new ArrayList<OrderStatus>(_list48.size);
-                for (int _i45 = 0; _i45 < _list44.size; ++_i45)
+                for (int _i49 = 0; _i49 < _list48.size; ++_i49)
+                {
-                  OrderStatus _elem46; // required
+                  OrderStatus _elem50; // required
-                  _elem46 = OrderStatus.findByValue(iprot.readI32());
+                  _elem50 = OrderStatus.findByValue(iprot.readI32());
-                  this.statuses.add(_elem46);
+                  this.statuses.add(_elem50);
+                }
                 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 _iter47 : this.statuses)
+          for (OrderStatus _iter51 : this.statuses)
+          {
-            oprot.writeI32(_iter47.getValue());
+            oprot.writeI32(_iter51.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 _list48 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list52 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list48.size);
+                this.success = new ArrayList<Order>(_list52.size);
-                for (int _i49 = 0; _i49 < _list48.size; ++_i49)
+                for (int _i53 = 0; _i53 < _list52.size; ++_i53)
+                {
-                  Order _elem50; // required
+                  Order _elem54; // required
-                  _elem50 = new Order();
+                  _elem54 = new Order();
-                  _elem50.read(iprot);
+                  _elem54.read(iprot);
-                  this.success.add(_elem50);
+                  this.success.add(_elem54);
+                }
                 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 _iter51 : this.success)
+          for (Order _iter55 : this.success)
+          {
-            _iter51.write(oprot);
+            _iter55.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 _list52 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list56 = iprot.readListBegin();
-                this.statuses = new ArrayList<OrderStatus>(_list52.size);
+                this.statuses = new ArrayList<OrderStatus>(_list56.size);
-                for (int _i53 = 0; _i53 < _list52.size; ++_i53)
+                for (int _i57 = 0; _i57 < _list56.size; ++_i57)
+                {
-                  OrderStatus _elem54; // required
+                  OrderStatus _elem58; // required
-                  _elem54 = OrderStatus.findByValue(iprot.readI32());
+                  _elem58 = OrderStatus.findByValue(iprot.readI32());
-                  this.statuses.add(_elem54);
+                  this.statuses.add(_elem58);
+                }
                 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 _iter55 : this.statuses)
+          for (OrderStatus _iter59 : this.statuses)
+          {
-            oprot.writeI32(_iter55.getValue());
+            oprot.writeI32(_iter59.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 _list56 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list60 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list56.size);
+                this.success = new ArrayList<Order>(_list60.size);
-                for (int _i57 = 0; _i57 < _list56.size; ++_i57)
+                for (int _i61 = 0; _i61 < _list60.size; ++_i61)
+                {
-                  Order _elem58; // required
+                  Order _elem62; // required
-                  _elem58 = new Order();
+                  _elem62 = new Order();
-                  _elem58.read(iprot);
+                  _elem62.read(iprot);
-                  this.success.add(_elem58);
+                  this.success.add(_elem62);
+                }
                 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 _iter59 : this.success)
+          for (Order _iter63 : this.success)
+          {
-            _iter59.write(oprot);
+            _iter63.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 _list60 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list64 = iprot.readListBegin();
-                this.statuses = new ArrayList<OrderStatus>(_list60.size);
+                this.statuses = new ArrayList<OrderStatus>(_list64.size);
-                for (int _i61 = 0; _i61 < _list60.size; ++_i61)
+                for (int _i65 = 0; _i65 < _list64.size; ++_i65)
+                {
-                  OrderStatus _elem62; // required
+                  OrderStatus _elem66; // required
-                  _elem62 = OrderStatus.findByValue(iprot.readI32());
+                  _elem66 = OrderStatus.findByValue(iprot.readI32());
-                  this.statuses.add(_elem62);
+                  this.statuses.add(_elem66);
+                }
                 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 _iter63 : this.statuses)
+          for (OrderStatus _iter67 : this.statuses)
+          {
-            oprot.writeI32(_iter63.getValue());
+            oprot.writeI32(_iter67.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 _list64 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list68 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list64.size);
+                this.success = new ArrayList<Order>(_list68.size);
-                for (int _i65 = 0; _i65 < _list64.size; ++_i65)
+                for (int _i69 = 0; _i69 < _list68.size; ++_i69)
+                {
-                  Order _elem66; // required
+                  Order _elem70; // required
-                  _elem66 = new Order();
+                  _elem70 = new Order();
-                  _elem66.read(iprot);
+                  _elem70.read(iprot);
-                  this.success.add(_elem66);
+                  this.success.add(_elem70);
+                }
                 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 _iter67 : this.success)
+          for (Order _iter71 : this.success)
+          {
-            _iter67.write(oprot);
+            _iter71.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 _list68 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list72 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list68.size);
+                this.success = new ArrayList<Order>(_list72.size);
-                for (int _i69 = 0; _i69 < _list68.size; ++_i69)
+                for (int _i73 = 0; _i73 < _list72.size; ++_i73)
+                {
-                  Order _elem70; // required
+                  Order _elem74; // required
-                  _elem70 = new Order();
+                  _elem74 = new Order();
-                  _elem70.read(iprot);
+                  _elem74.read(iprot);
-                  this.success.add(_elem70);
+                  this.success.add(_elem74);
+                }
                 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 _iter71 : this.success)
+          for (Order _iter75 : this.success)
+          {
-            _iter71.write(oprot);
+            _iter75.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 _list72 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list76 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list72.size);
+                this.success = new ArrayList<Long>(_list76.size);
-                for (int _i73 = 0; _i73 < _list72.size; ++_i73)
+                for (int _i77 = 0; _i77 < _list76.size; ++_i77)
+                {
-                  long _elem74; // required
+                  long _elem78; // required
-                  _elem74 = iprot.readI64();
+                  _elem78 = iprot.readI64();
-                  this.success.add(_elem74);
+                  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.I64, this.success.size()));
-          for (long _iter75 : this.success)
+          for (long _iter79 : this.success)
+          {
-            oprot.writeI64(_iter75);
+            oprot.writeI64(_iter79);
+          }
           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 _list76 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list80 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list76.size);
+                this.success = new ArrayList<Long>(_list80.size);
-                for (int _i77 = 0; _i77 < _list76.size; ++_i77)
+                for (int _i81 = 0; _i81 < _list80.size; ++_i81)
+                {
-                  long _elem78; // required
+                  long _elem82; // required
-                  _elem78 = iprot.readI64();
+                  _elem82 = iprot.readI64();
-                  this.success.add(_elem78);
+                  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.I64, this.success.size()));
-          for (long _iter79 : this.success)
+          for (long _iter83 : this.success)
+          {
-            oprot.writeI64(_iter79);
+            oprot.writeI64(_iter83);
+          }
           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();
+                org.apache.thrift.protocol.TList _list84 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list80.size);
+                this.success = new ArrayList<Order>(_list84.size);
-                for (int _i81 = 0; _i81 < _list80.size; ++_i81)
+                for (int _i85 = 0; _i85 < _list84.size; ++_i85)
+                {
-                  Order _elem82; // required
+                  Order _elem86; // required
-                  _elem82 = new Order();
+                  _elem86 = new Order();
-                  _elem82.read(iprot);
+                  _elem86.read(iprot);
-                  this.success.add(_elem82);
+                  this.success.add(_elem86);
+                }
                 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 _iter83 : this.success)
+          for (Order _iter87 : this.success)
+          {
-            _iter83.write(oprot);
+            _iter87.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 _list84 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list88 = iprot.readListBegin();
-                this.statuses = new ArrayList<OrderStatus>(_list84.size);
+                this.statuses = new ArrayList<OrderStatus>(_list88.size);
-                for (int _i85 = 0; _i85 < _list84.size; ++_i85)
+                for (int _i89 = 0; _i89 < _list88.size; ++_i89)
+                {
-                  OrderStatus _elem86; // required
+                  OrderStatus _elem90; // required
-                  _elem86 = OrderStatus.findByValue(iprot.readI32());
+                  _elem90 = OrderStatus.findByValue(iprot.readI32());
-                  this.statuses.add(_elem86);
+                  this.statuses.add(_elem90);
+                }
                 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 _iter87 : this.statuses)
+          for (OrderStatus _iter91 : this.statuses)
+          {
-            oprot.writeI32(_iter87.getValue());
+            oprot.writeI32(_iter91.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();
+                org.apache.thrift.protocol.TList _list92 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list88.size);
+                this.success = new ArrayList<Order>(_list92.size);
-                for (int _i89 = 0; _i89 < _list88.size; ++_i89)
+                for (int _i93 = 0; _i93 < _list92.size; ++_i93)
+                {
-                  Order _elem90; // required
+                  Order _elem94; // required
-                  _elem90 = new Order();
+                  _elem94 = new Order();
-                  _elem90.read(iprot);
+                  _elem94.read(iprot);
-                  this.success.add(_elem90);
+                  this.success.add(_elem94);
+                }
                 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)
+          for (Order _iter95 : this.success)
+          {
-            _iter91.write(oprot);
+            _iter95.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 _list92 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list96 = iprot.readListBegin();
-                this.success = new ArrayList<LineItem>(_list92.size);
+                this.success = new ArrayList<LineItem>(_list96.size);
-                for (int _i93 = 0; _i93 < _list92.size; ++_i93)
+                for (int _i97 = 0; _i97 < _list96.size; ++_i97)
+                {
-                  LineItem _elem94; // required
+                  LineItem _elem98; // required
-                  _elem94 = new LineItem();
+                  _elem98 = new LineItem();
-                  _elem94.read(iprot);
+                  _elem98.read(iprot);
-                  this.success.add(_elem94);
+                  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 (LineItem _iter95 : this.success)
+          for (LineItem _iter99 : this.success)
+          {
-            _iter95.write(oprot);
+            _iter99.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 _list96 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list100 = iprot.readListBegin();
-                this.order_ids = new ArrayList<Long>(_list96.size);
+                this.order_ids = new ArrayList<Long>(_list100.size);
-                for (int _i97 = 0; _i97 < _list96.size; ++_i97)
+                for (int _i101 = 0; _i101 < _list100.size; ++_i101)
+                {
-                  long _elem98; // required
+                  long _elem102; // required
-                  _elem98 = iprot.readI64();
+                  _elem102 = iprot.readI64();
-                  this.order_ids.add(_elem98);
+                  this.order_ids.add(_elem102);
+                }
                 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 _iter99 : this.order_ids)
+          for (long _iter103 : this.order_ids)
+          {
-            oprot.writeI64(_iter99);
+            oprot.writeI64(_iter103);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list100 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list104 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list100.size);
+                this.success = new ArrayList<Order>(_list104.size);
-                for (int _i101 = 0; _i101 < _list100.size; ++_i101)
+                for (int _i105 = 0; _i105 < _list104.size; ++_i105)
+                {
-                  Order _elem102; // required
+                  Order _elem106; // required
-                  _elem102 = new Order();
+                  _elem106 = new Order();
-                  _elem102.read(iprot);
+                  _elem106.read(iprot);
-                  this.success.add(_elem102);
+                  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 _iter103 : this.success)
+          for (Order _iter107 : this.success)
+          {
-            _iter103.write(oprot);
+            _iter107.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 _list104 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list108 = iprot.readListBegin();
-                this.order_ids = new ArrayList<Long>(_list104.size);
+                this.order_ids = new ArrayList<Long>(_list108.size);
-                for (int _i105 = 0; _i105 < _list104.size; ++_i105)
+                for (int _i109 = 0; _i109 < _list108.size; ++_i109)
+                {
-                  long _elem106; // required
+                  long _elem110; // required
-                  _elem106 = iprot.readI64();
+                  _elem110 = iprot.readI64();
-                  this.order_ids.add(_elem106);
+                  this.order_ids.add(_elem110);
+                }
                 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 _iter107 : this.order_ids)
+          for (long _iter111 : this.order_ids)
+          {
-            oprot.writeI64(_iter107);
+            oprot.writeI64(_iter111);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list108 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list112 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list108.size);
+                this.success = new ArrayList<Order>(_list112.size);
-                for (int _i109 = 0; _i109 < _list108.size; ++_i109)
+                for (int _i113 = 0; _i113 < _list112.size; ++_i113)
+                {
-                  Order _elem110; // required
+                  Order _elem114; // required
-                  _elem110 = new Order();
+                  _elem114 = new Order();
-                  _elem110.read(iprot);
+                  _elem114.read(iprot);
-                  this.success.add(_elem110);
+                  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.STRUCT, this.success.size()));
-          for (Order _iter111 : this.success)
+          for (Order _iter115 : this.success)
+          {
-            _iter111.write(oprot);
+            _iter115.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 _list112 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list116 = iprot.readListBegin();
-                this.success = new ArrayList<Alert>(_list112.size);
+                this.success = new ArrayList<Alert>(_list116.size);
-                for (int _i113 = 0; _i113 < _list112.size; ++_i113)
+                for (int _i117 = 0; _i117 < _list116.size; ++_i117)
+                {
-                  Alert _elem114; // required
+                  Alert _elem118; // required
-                  _elem114 = new Alert();
+                  _elem118 = new Alert();
-                  _elem114.read(iprot);
+                  _elem118.read(iprot);
-                  this.success.add(_elem114);
+                  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.STRUCT, this.success.size()));
-          for (Alert _iter115 : this.success)
+          for (Alert _iter119 : this.success)
+          {
-            _iter115.write(oprot);
+            _iter119.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 _list116 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list120 = iprot.readListBegin();
-                this.success = new ArrayList<Double>(_list116.size);
+                this.success = new ArrayList<Double>(_list120.size);
-                for (int _i117 = 0; _i117 < _list116.size; ++_i117)
+                for (int _i121 = 0; _i121 < _list120.size; ++_i121)
+                {
-                  double _elem118; // required
+                  double _elem122; // required
-                  _elem118 = iprot.readDouble();
+                  _elem122 = iprot.readDouble();
-                  this.success.add(_elem118);
+                  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.DOUBLE, this.success.size()));
-          for (double _iter119 : this.success)
+          for (double _iter123 : this.success)
+          {
-            oprot.writeDouble(_iter119);
+            oprot.writeDouble(_iter123);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list120 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list124 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list120.size);
+                this.success = new ArrayList<Order>(_list124.size);
-                for (int _i121 = 0; _i121 < _list120.size; ++_i121)
+                for (int _i125 = 0; _i125 < _list124.size; ++_i125)
+                {
-                  Order _elem122; // required
+                  Order _elem126; // required
-                  _elem122 = new Order();
+                  _elem126 = new Order();
-                  _elem122.read(iprot);
+                  _elem126.read(iprot);
-                  this.success.add(_elem122);
+                  this.success.add(_elem126);
+                }
                 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)
+          for (Order _iter127 : this.success)
+          {
-            _iter123.write(oprot);
+            _iter127.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 _list124 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list128 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list124.size);
+                this.success = new ArrayList<Order>(_list128.size);
-                for (int _i125 = 0; _i125 < _list124.size; ++_i125)
+                for (int _i129 = 0; _i129 < _list128.size; ++_i129)
+                {
-                  Order _elem126; // required
+                  Order _elem130; // required
-                  _elem126 = new Order();
+                  _elem130 = new Order();
-                  _elem126.read(iprot);
+                  _elem130.read(iprot);
-                  this.success.add(_elem126);
+                  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 _iter127 : this.success)
+          for (Order _iter131 : this.success)
+          {
-            _iter127.write(oprot);
+            _iter131.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 _list128 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list132 = iprot.readListBegin();
-                this.serialNumber = new ArrayList<String>(_list128.size);
+                this.serialNumber = new ArrayList<String>(_list132.size);
-                for (int _i129 = 0; _i129 < _list128.size; ++_i129)
+                for (int _i133 = 0; _i133 < _list132.size; ++_i133)
+                {
-                  String _elem130; // required
+                  String _elem134; // required
-                  _elem130 = iprot.readString();
+                  _elem134 = iprot.readString();
-                  this.serialNumber.add(_elem130);
+                  this.serialNumber.add(_elem134);
+                }
                 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 _list131 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list135 = iprot.readListBegin();
-                this.itemNumber = new ArrayList<String>(_list131.size);
+                this.itemNumber = new ArrayList<String>(_list135.size);
-                for (int _i132 = 0; _i132 < _list131.size; ++_i132)
+                for (int _i136 = 0; _i136 < _list135.size; ++_i136)
+                {
-                  String _elem133; // required
+                  String _elem137; // required
-                  _elem133 = iprot.readString();
+                  _elem137 = iprot.readString();
-                  this.itemNumber.add(_elem133);
+                  this.itemNumber.add(_elem137);
+                }
                 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 _iter134 : this.serialNumber)
+          for (String _iter138 : this.serialNumber)
+          {
-            oprot.writeString(_iter134);
+            oprot.writeString(_iter138);
+          }
           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 _iter135 : this.itemNumber)
+          for (String _iter139 : this.itemNumber)
+          {
-            oprot.writeString(_iter135);
+            oprot.writeString(_iter139);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+            }
             break;
           case 4: // ORDER_IDS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list136 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list140 = iprot.readListBegin();
-                this.orderIds = new ArrayList<Long>(_list136.size);
+                this.orderIds = new ArrayList<Long>(_list140.size);
-                for (int _i137 = 0; _i137 < _list136.size; ++_i137)
+                for (int _i141 = 0; _i141 < _list140.size; ++_i141)
+                {
-                  long _elem138; // required
+                  long _elem142; // required
-                  _elem138 = iprot.readI64();
+                  _elem142 = iprot.readI64();
-                  this.orderIds.add(_elem138);
+                  this.orderIds.add(_elem142);
+                }
                 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 _iter139 : this.orderIds)
+          for (long _iter143 : this.orderIds)
+          {
-            oprot.writeI64(_iter139);
+            oprot.writeI64(_iter143);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+            }
             break;
           case 2: // ORDER_IDS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list140 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list144 = iprot.readListBegin();
-                this.orderIds = new ArrayList<Long>(_list140.size);
+                this.orderIds = new ArrayList<Long>(_list144.size);
-                for (int _i141 = 0; _i141 < _list140.size; ++_i141)
+                for (int _i145 = 0; _i145 < _list144.size; ++_i145)
+                {
-                  long _elem142; // required
+                  long _elem146; // required
-                  _elem142 = iprot.readI64();
+                  _elem146 = iprot.readI64();
-                  this.orderIds.add(_elem142);
+                  this.orderIds.add(_elem146);
+                }
                 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 _list143 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list147 = iprot.readListBegin();
-                this.awbs = new ArrayList<String>(_list143.size);
+                this.awbs = new ArrayList<String>(_list147.size);
-                for (int _i144 = 0; _i144 < _list143.size; ++_i144)
+                for (int _i148 = 0; _i148 < _list147.size; ++_i148)
+                {
-                  String _elem145; // required
+                  String _elem149; // required
-                  _elem145 = iprot.readString();
+                  _elem149 = iprot.readString();
-                  this.awbs.add(_elem145);
+                  this.awbs.add(_elem149);
+                }
                 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 _iter146 : this.orderIds)
+          for (long _iter150 : this.orderIds)
+          {
-            oprot.writeI64(_iter146);
+            oprot.writeI64(_iter150);
+          }
           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 _iter147 : this.awbs)
+          for (String _iter151 : this.awbs)
+          {
-            oprot.writeString(_iter147);
+            oprot.writeString(_iter151);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+            }
             break;
           case 2: // PICKUP_DETAILS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map148 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map152 = iprot.readMapBegin();
-                this.pickupDetails = new HashMap<String,String>(2*_map148.size);
+                this.pickupDetails = new HashMap<String,String>(2*_map152.size);
-                for (int _i149 = 0; _i149 < _map148.size; ++_i149)
+                for (int _i153 = 0; _i153 < _map152.size; ++_i153)
+                {
-                  String _key150; // required
+                  String _key154; // required
-                  String _val151; // required
+                  String _val155; // required
-                  _key150 = iprot.readString();
+                  _key154 = iprot.readString();
-                  _val151 = iprot.readString();
+                  _val155 = iprot.readString();
-                  this.pickupDetails.put(_key150, _val151);
+                  this.pickupDetails.put(_key154, _val155);
+                }
                 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> _iter152 : this.pickupDetails.entrySet())
+          for (Map.Entry<String, String> _iter156 : this.pickupDetails.entrySet())
+          {
-            oprot.writeString(_iter152.getKey());
+            oprot.writeString(_iter156.getKey());
-            oprot.writeString(_iter152.getValue());
+            oprot.writeString(_iter156.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 _list153 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list157 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list153.size);
+                this.success = new ArrayList<Order>(_list157.size);
-                for (int _i154 = 0; _i154 < _list153.size; ++_i154)
+                for (int _i158 = 0; _i158 < _list157.size; ++_i158)
+                {
-                  Order _elem155; // required
+                  Order _elem159; // required
-                  _elem155 = new Order();
+                  _elem159 = new Order();
-                  _elem155.read(iprot);
+                  _elem159.read(iprot);
-                  this.success.add(_elem155);
+                  this.success.add(_elem159);
+                }
                 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 _iter156 : this.success)
+          for (Order _iter160 : this.success)
+          {
-            _iter156.write(oprot);
+            _iter160.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 _map157 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map161 = iprot.readMapBegin();
-                this.deliveredOrders = new HashMap<String,String>(2*_map157.size);
+                this.deliveredOrders = new HashMap<String,String>(2*_map161.size);
-                for (int _i158 = 0; _i158 < _map157.size; ++_i158)
+                for (int _i162 = 0; _i162 < _map161.size; ++_i162)
+                {
-                  String _key159; // required
+                  String _key163; // required
-                  String _val160; // required
+                  String _val164; // required
-                  _key159 = iprot.readString();
+                  _key163 = iprot.readString();
-                  _val160 = iprot.readString();
+                  _val164 = iprot.readString();
-                  this.deliveredOrders.put(_key159, _val160);
+                  this.deliveredOrders.put(_key163, _val164);
+                }
                 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> _iter161 : this.deliveredOrders.entrySet())
+          for (Map.Entry<String, String> _iter165 : this.deliveredOrders.entrySet())
+          {
-            oprot.writeString(_iter161.getKey());
+            oprot.writeString(_iter165.getKey());
-            oprot.writeString(_iter161.getValue());
+            oprot.writeString(_iter165.getValue());
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }
+            }
             break;
           case 2: // RETURNED_ORDERS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map162 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map166 = iprot.readMapBegin();
-                this.returnedOrders = new HashMap<String,String>(2*_map162.size);
+                this.returnedOrders = new HashMap<String,String>(2*_map166.size);
-                for (int _i163 = 0; _i163 < _map162.size; ++_i163)
+                for (int _i167 = 0; _i167 < _map166.size; ++_i167)
+                {
-                  String _key164; // required
+                  String _key168; // required
-                  String _val165; // required
+                  String _val169; // required
-                  _key164 = iprot.readString();
+                  _key168 = iprot.readString();
-                  _val165 = iprot.readString();
+                  _val169 = iprot.readString();
-                  this.returnedOrders.put(_key164, _val165);
+                  this.returnedOrders.put(_key168, _val169);
+                }
                 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> _iter166 : this.returnedOrders.entrySet())
+          for (Map.Entry<String, String> _iter170 : this.returnedOrders.entrySet())
+          {
-            oprot.writeString(_iter166.getKey());
+            oprot.writeString(_iter170.getKey());
-            oprot.writeString(_iter166.getValue());
+            oprot.writeString(_iter170.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 _list167 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list171 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list167.size);
+                this.success = new ArrayList<Order>(_list171.size);
-                for (int _i168 = 0; _i168 < _list167.size; ++_i168)
+                for (int _i172 = 0; _i172 < _list171.size; ++_i172)
+                {
-                  Order _elem169; // required
+                  Order _elem173; // required
-                  _elem169 = new Order();
+                  _elem173 = new Order();
-                  _elem169.read(iprot);
+                  _elem173.read(iprot);
-                  this.success.add(_elem169);
+                  this.success.add(_elem173);
+                }
                 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 _iter170 : this.success)
+          for (Order _iter174 : this.success)
+          {
-            _iter170.write(oprot);
+            _iter174.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 _map171 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map175 = iprot.readMapBegin();
-                this.undeliveredOrders = new HashMap<String,String>(2*_map171.size);
+                this.undeliveredOrders = new HashMap<String,String>(2*_map175.size);
-                for (int _i172 = 0; _i172 < _map171.size; ++_i172)
+                for (int _i176 = 0; _i176 < _map175.size; ++_i176)
+                {
-                  String _key173; // required
+                  String _key177; // required
-                  String _val174; // required
+                  String _val178; // required
-                  _key173 = iprot.readString();
+                  _key177 = iprot.readString();
-                  _val174 = iprot.readString();
+                  _val178 = iprot.readString();
-                  this.undeliveredOrders.put(_key173, _val174);
+                  this.undeliveredOrders.put(_key177, _val178);
+                }
                 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> _iter175 : this.undeliveredOrders.entrySet())
+          for (Map.Entry<String, String> _iter179 : this.undeliveredOrders.entrySet())
+          {
-            oprot.writeString(_iter175.getKey());
+            oprot.writeString(_iter179.getKey());
-            oprot.writeString(_iter175.getValue());
+            oprot.writeString(_iter179.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 _list176 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list180 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list176.size);
+                this.success = new ArrayList<Order>(_list180.size);
-                for (int _i177 = 0; _i177 < _list176.size; ++_i177)
+                for (int _i181 = 0; _i181 < _list180.size; ++_i181)
+                {
-                  Order _elem178; // required
+                  Order _elem182; // required
-                  _elem178 = new Order();
+                  _elem182 = new Order();
-                  _elem178.read(iprot);
+                  _elem182.read(iprot);
-                  this.success.add(_elem178);
+                  this.success.add(_elem182);
+                }
                 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 _iter179 : this.success)
+          for (Order _iter183 : this.success)
+          {
-            _iter179.write(oprot);
+            _iter183.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 _map180 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map184 = iprot.readMapBegin();
-                this.local_connected_orders = new HashMap<String,String>(2*_map180.size);
+                this.local_connected_orders = new HashMap<String,String>(2*_map184.size);
-                for (int _i181 = 0; _i181 < _map180.size; ++_i181)
+                for (int _i185 = 0; _i185 < _map184.size; ++_i185)
+                {
-                  String _key182; // required
+                  String _key186; // required
-                  String _val183; // required
+                  String _val187; // required
-                  _key182 = iprot.readString();
+                  _key186 = iprot.readString();
-                  _val183 = iprot.readString();
+                  _val187 = iprot.readString();
-                  this.local_connected_orders.put(_key182, _val183);
+                  this.local_connected_orders.put(_key186, _val187);
+                }
                 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> _iter184 : this.local_connected_orders.entrySet())
+          for (Map.Entry<String, String> _iter188 : this.local_connected_orders.entrySet())
+          {
-            oprot.writeString(_iter184.getKey());
+            oprot.writeString(_iter188.getKey());
-            oprot.writeString(_iter184.getValue());
+            oprot.writeString(_iter188.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 _list185 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list189 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list185.size);
+                this.success = new ArrayList<Order>(_list189.size);
-                for (int _i186 = 0; _i186 < _list185.size; ++_i186)
+                for (int _i190 = 0; _i190 < _list189.size; ++_i190)
+                {
-                  Order _elem187; // required
+                  Order _elem191; // required
-                  _elem187 = new Order();
+                  _elem191 = new Order();
-                  _elem187.read(iprot);
+                  _elem191.read(iprot);
-                  this.success.add(_elem187);
+                  this.success.add(_elem191);
+                }
                 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 _iter188 : this.success)
+          for (Order _iter192 : this.success)
+          {
-            _iter188.write(oprot);
+            _iter192.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 _map189 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map193 = iprot.readMapBegin();
-                this.destination_city_reached_orders = new HashMap<String,String>(2*_map189.size);
+                this.destination_city_reached_orders = new HashMap<String,String>(2*_map193.size);
-                for (int _i190 = 0; _i190 < _map189.size; ++_i190)
+                for (int _i194 = 0; _i194 < _map193.size; ++_i194)
+                {
-                  String _key191; // required
+                  String _key195; // required
-                  String _val192; // required
+                  String _val196; // required
-                  _key191 = iprot.readString();
+                  _key195 = iprot.readString();
-                  _val192 = iprot.readString();
+                  _val196 = iprot.readString();
-                  this.destination_city_reached_orders.put(_key191, _val192);
+                  this.destination_city_reached_orders.put(_key195, _val196);
+                }
                 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> _iter193 : this.destination_city_reached_orders.entrySet())
+          for (Map.Entry<String, String> _iter197 : this.destination_city_reached_orders.entrySet())
+          {
-            oprot.writeString(_iter193.getKey());
+            oprot.writeString(_iter197.getKey());
-            oprot.writeString(_iter193.getValue());
+            oprot.writeString(_iter197.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 _map194 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map198 = iprot.readMapBegin();
-                this.first_atdl_orders = new HashMap<String,String>(2*_map194.size);
+                this.first_atdl_orders = new HashMap<String,String>(2*_map198.size);
-                for (int _i195 = 0; _i195 < _map194.size; ++_i195)
+                for (int _i199 = 0; _i199 < _map198.size; ++_i199)
+                {
-                  String _key196; // required
+                  String _key200; // required
-                  String _val197; // required
+                  String _val201; // required
-                  _key196 = iprot.readString();
+                  _key200 = iprot.readString();
-                  _val197 = iprot.readString();
+                  _val201 = iprot.readString();
-                  this.first_atdl_orders.put(_key196, _val197);
+                  this.first_atdl_orders.put(_key200, _val201);
+                }
                 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> _iter198 : this.first_atdl_orders.entrySet())
+          for (Map.Entry<String, String> _iter202 : this.first_atdl_orders.entrySet())
+          {
-            oprot.writeString(_iter198.getKey());
+            oprot.writeString(_iter202.getKey());
-            oprot.writeString(_iter198.getValue());
+            oprot.writeString(_iter202.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 _list199 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list203 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list199.size);
+                this.success = new ArrayList<Order>(_list203.size);
-                for (int _i200 = 0; _i200 < _list199.size; ++_i200)
+                for (int _i204 = 0; _i204 < _list203.size; ++_i204)
+                {
-                  Order _elem201; // required
+                  Order _elem205; // required
-                  _elem201 = new Order();
+                  _elem205 = new Order();
-                  _elem201.read(iprot);
+                  _elem205.read(iprot);
-                  this.success.add(_elem201);
+                  this.success.add(_elem205);
+                }
                 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 _iter202 : this.success)
+          for (Order _iter206 : this.success)
+          {
-            _iter202.write(oprot);
+            _iter206.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 _list203 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list207 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list203.size);
+                this.success = new ArrayList<Order>(_list207.size);
-                for (int _i204 = 0; _i204 < _list203.size; ++_i204)
+                for (int _i208 = 0; _i208 < _list207.size; ++_i208)
+                {
-                  Order _elem205; // required
+                  Order _elem209; // required
-                  _elem205 = new Order();
+                  _elem209 = new Order();
-                  _elem205.read(iprot);
+                  _elem209.read(iprot);
-                  this.success.add(_elem205);
+                  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 _iter206 : this.success)
+          for (Order _iter210 : this.success)
+          {
-            _iter206.write(oprot);
+            _iter210.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+      }
+    }
     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);
+      }
+    }
+            }
             break;
           case 2: // PICKUP_DETAILS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map207 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map211 = iprot.readMapBegin();
-                this.pickupDetails = new HashMap<String,String>(2*_map207.size);
+                this.pickupDetails = new HashMap<String,String>(2*_map211.size);
-                for (int _i208 = 0; _i208 < _map207.size; ++_i208)
+                for (int _i212 = 0; _i212 < _map211.size; ++_i212)
+                {
-                  String _key209; // required
+                  String _key213; // required
-                  String _val210; // required
+                  String _val214; // required
-                  _key209 = iprot.readString();
+                  _key213 = iprot.readString();
-                  _val210 = iprot.readString();
+                  _val214 = iprot.readString();
-                  this.pickupDetails.put(_key209, _val210);
+                  this.pickupDetails.put(_key213, _val214);
+                }
                 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> _iter211 : this.pickupDetails.entrySet())
+          for (Map.Entry<String, String> _iter215 : this.pickupDetails.entrySet())
+          {
-            oprot.writeString(_iter211.getKey());
+            oprot.writeString(_iter215.getKey());
-            oprot.writeString(_iter211.getValue());
+            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 _list212 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list216 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list212.size);
+                this.success = new ArrayList<Order>(_list216.size);
-                for (int _i213 = 0; _i213 < _list212.size; ++_i213)
+                for (int _i217 = 0; _i217 < _list216.size; ++_i217)
+                {
-                  Order _elem214; // required
+                  Order _elem218; // required
-                  _elem214 = new Order();
+                  _elem218 = new Order();
-                  _elem214.read(iprot);
+                  _elem218.read(iprot);
-                  this.success.add(_elem214);
+                  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 _iter215 : this.success)
+          for (Order _iter219 : this.success)
+          {
-            _iter215.write(oprot);
+            _iter219.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 _map216 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map220 = iprot.readMapBegin();
-                this.pickupDetails = new HashMap<String,String>(2*_map216.size);
+                this.pickupDetails = new HashMap<String,String>(2*_map220.size);
-                for (int _i217 = 0; _i217 < _map216.size; ++_i217)
+                for (int _i221 = 0; _i221 < _map220.size; ++_i221)
+                {
-                  String _key218; // required
+                  String _key222; // required
-                  String _val219; // required
+                  String _val223; // required
-                  _key218 = iprot.readString();
+                  _key222 = iprot.readString();
-                  _val219 = iprot.readString();
+                  _val223 = iprot.readString();
-                  this.pickupDetails.put(_key218, _val219);
+                  this.pickupDetails.put(_key222, _val223);
+                }
                 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> _iter220 : this.pickupDetails.entrySet())
+          for (Map.Entry<String, String> _iter224 : this.pickupDetails.entrySet())
+          {
-            oprot.writeString(_iter220.getKey());
+            oprot.writeString(_iter224.getKey());
-            oprot.writeString(_iter220.getValue());
+            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 _list221 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list225 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list221.size);
+                this.success = new ArrayList<Order>(_list225.size);
-                for (int _i222 = 0; _i222 < _list221.size; ++_i222)
+                for (int _i226 = 0; _i226 < _list225.size; ++_i226)
+                {
-                  Order _elem223; // required
+                  Order _elem227; // required
-                  _elem223 = new Order();
+                  _elem227 = new Order();
-                  _elem223.read(iprot);
+                  _elem227.read(iprot);
-                  this.success.add(_elem223);
+                  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 _iter224 : this.success)
+          for (Order _iter228 : this.success)
+          {
-            _iter224.write(oprot);
+            _iter228.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+      }
+    }
     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);
+      }
+    }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list225 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list229 = iprot.readListBegin();
-                this.success = new ArrayList<ReturnOrder>(_list225.size);
+                this.success = new ArrayList<ReturnOrder>(_list229.size);
-                for (int _i226 = 0; _i226 < _list225.size; ++_i226)
+                for (int _i230 = 0; _i230 < _list229.size; ++_i230)
+                {
-                  ReturnOrder _elem227; // required
+                  ReturnOrder _elem231; // required
-                  _elem227 = new ReturnOrder();
+                  _elem231 = new ReturnOrder();
-                  _elem227.read(iprot);
+                  _elem231.read(iprot);
-                  this.success.add(_elem227);
+                  this.success.add(_elem231);
+                }
                 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 _iter228 : this.success)
+          for (ReturnOrder _iter232 : this.success)
+          {
-            _iter228.write(oprot);
+            _iter232.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 _list229 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list233 = iprot.readListBegin();
-                this.success = new ArrayList<ReturnOrder>(_list229.size);
+                this.success = new ArrayList<ReturnOrder>(_list233.size);
-                for (int _i230 = 0; _i230 < _list229.size; ++_i230)
+                for (int _i234 = 0; _i234 < _list233.size; ++_i234)
+                {
-                  ReturnOrder _elem231; // required
+                  ReturnOrder _elem235; // required
-                  _elem231 = new ReturnOrder();
+                  _elem235 = new ReturnOrder();
-                  _elem231.read(iprot);
+                  _elem235.read(iprot);
-                  this.success.add(_elem231);
+                  this.success.add(_elem235);
+                }
                 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 _iter232 : this.success)
+          for (ReturnOrder _iter236 : this.success)
+          {
-            _iter232.write(oprot);
+            _iter236.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 _map233 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map237 = iprot.readMapBegin();
-                this.collectedAmountMap = new HashMap<String,Double>(2*_map233.size);
+                this.collectedAmountMap = new HashMap<String,Double>(2*_map237.size);
-                for (int _i234 = 0; _i234 < _map233.size; ++_i234)
+                for (int _i238 = 0; _i238 < _map237.size; ++_i238)
+                {
-                  String _key235; // required
+                  String _key239; // required
-                  double _val236; // required
+                  double _val240; // required
-                  _key235 = iprot.readString();
+                  _key239 = iprot.readString();
-                  _val236 = iprot.readDouble();
+                  _val240 = iprot.readDouble();
-                  this.collectedAmountMap.put(_key235, _val236);
+                  this.collectedAmountMap.put(_key239, _val240);
+                }
                 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> _iter237 : this.collectedAmountMap.entrySet())
+          for (Map.Entry<String, Double> _iter241 : this.collectedAmountMap.entrySet())
+          {
-            oprot.writeString(_iter237.getKey());
+            oprot.writeString(_iter241.getKey());
-            oprot.writeDouble(_iter237.getValue());
+            oprot.writeDouble(_iter241.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 _map238 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map242 = iprot.readMapBegin();
-                this.success = new HashMap<String,String>(2*_map238.size);
+                this.success = new HashMap<String,String>(2*_map242.size);
-                for (int _i239 = 0; _i239 < _map238.size; ++_i239)
+                for (int _i243 = 0; _i243 < _map242.size; ++_i243)
+                {
-                  String _key240; // required
+                  String _key244; // required
-                  String _val241; // required
+                  String _val245; // required
-                  _key240 = iprot.readString();
+                  _key244 = iprot.readString();
-                  _val241 = iprot.readString();
+                  _val245 = iprot.readString();
-                  this.success.put(_key240, _val241);
+                  this.success.put(_key244, _val245);
+                }
                 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> _iter242 : this.success.entrySet())
+          for (Map.Entry<String, String> _iter246 : this.success.entrySet())
+          {
-            oprot.writeString(_iter242.getKey());
+            oprot.writeString(_iter246.getKey());
-            oprot.writeString(_iter242.getValue());
+            oprot.writeString(_iter246.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 _list243 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list247 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list243.size);
+                this.success = new ArrayList<Long>(_list247.size);
-                for (int _i244 = 0; _i244 < _list243.size; ++_i244)
+                for (int _i248 = 0; _i248 < _list247.size; ++_i248)
+                {
-                  long _elem245; // required
+                  long _elem249; // required
-                  _elem245 = iprot.readI64();
+                  _elem249 = iprot.readI64();
-                  this.success.add(_elem245);
+                  this.success.add(_elem249);
+                }
                 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 _iter246 : this.success)
+          for (long _iter250 : this.success)
+          {
-            oprot.writeI64(_iter246);
+            oprot.writeI64(_iter250);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map247 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map251 = iprot.readMapBegin();
-                this.success = new HashMap<Long,Long>(2*_map247.size);
+                this.success = new HashMap<Long,Long>(2*_map251.size);
-                for (int _i248 = 0; _i248 < _map247.size; ++_i248)
+                for (int _i252 = 0; _i252 < _map251.size; ++_i252)
+                {
-                  long _key249; // required
+                  long _key253; // required
-                  long _val250; // required
+                  long _val254; // required
-                  _key249 = iprot.readI64();
+                  _key253 = iprot.readI64();
-                  _val250 = iprot.readI64();
+                  _val254 = iprot.readI64();
-                  this.success.put(_key249, _val250);
+                  this.success.put(_key253, _val254);
+                }
                 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> _iter251 : this.success.entrySet())
+          for (Map.Entry<Long, Long> _iter255 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter251.getKey());
+            oprot.writeI64(_iter255.getKey());
-            oprot.writeI64(_iter251.getValue());
+            oprot.writeI64(_iter255.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 _list252 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list256 = iprot.readListBegin();
-                this.itemIds = new ArrayList<Long>(_list252.size);
+                this.itemIds = new ArrayList<Long>(_list256.size);
-                for (int _i253 = 0; _i253 < _list252.size; ++_i253)
+                for (int _i257 = 0; _i257 < _list256.size; ++_i257)
+                {
-                  long _elem254; // required
+                  long _elem258; // required
-                  _elem254 = iprot.readI64();
+                  _elem258 = iprot.readI64();
-                  this.itemIds.add(_elem254);
+                  this.itemIds.add(_elem258);
+                }
                 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 _iter255 : this.itemIds)
+          for (long _iter259 : this.itemIds)
+          {
-            oprot.writeI64(_iter255);
+            oprot.writeI64(_iter259);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list256 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list260 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list256.size);
+                this.success = new ArrayList<Order>(_list260.size);
-                for (int _i257 = 0; _i257 < _list256.size; ++_i257)
+                for (int _i261 = 0; _i261 < _list260.size; ++_i261)
+                {
-                  Order _elem258; // required
+                  Order _elem262; // required
-                  _elem258 = new Order();
+                  _elem262 = new Order();
-                  _elem258.read(iprot);
+                  _elem262.read(iprot);
-                  this.success.add(_elem258);
+                  this.success.add(_elem262);
+                }
                 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 _iter259 : this.success)
+          for (Order _iter263 : this.success)
+          {
-            _iter259.write(oprot);
+            _iter263.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 _map260 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map264 = iprot.readMapBegin();
-                this.success = new HashMap<Integer,TimeoutSummary>(2*_map260.size);
+                this.success = new HashMap<Integer,TimeoutSummary>(2*_map264.size);
-                for (int _i261 = 0; _i261 < _map260.size; ++_i261)
+                for (int _i265 = 0; _i265 < _map264.size; ++_i265)
+                {
-                  int _key262; // required
+                  int _key266; // required
-                  TimeoutSummary _val263; // required
+                  TimeoutSummary _val267; // required
-                  _key262 = iprot.readI32();
+                  _key266 = iprot.readI32();
-                  _val263 = new TimeoutSummary();
+                  _val267 = new TimeoutSummary();
-                  _val263.read(iprot);
+                  _val267.read(iprot);
-                  this.success.put(_key262, _val263);
+                  this.success.put(_key266, _val267);
+                }
                 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> _iter264 : this.success.entrySet())
+          for (Map.Entry<Integer, TimeoutSummary> _iter268 : this.success.entrySet())
+          {
-            oprot.writeI32(_iter264.getKey());
+            oprot.writeI32(_iter268.getKey());
-            _iter264.getValue().write(oprot);
+            _iter268.getValue().write(oprot);
+          }
           oprot.writeMapEnd();
+        }
         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 _list265 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list269 = iprot.readListBegin();
-                this.order_status_list = new ArrayList<OrderStatus>(_list265.size);
+                this.order_status_list = new ArrayList<OrderStatus>(_list269.size);
-                for (int _i266 = 0; _i266 < _list265.size; ++_i266)
+                for (int _i270 = 0; _i270 < _list269.size; ++_i270)
+                {
-                  OrderStatus _elem267; // required
+                  OrderStatus _elem271; // required
-                  _elem267 = OrderStatus.findByValue(iprot.readI32());
+                  _elem271 = OrderStatus.findByValue(iprot.readI32());
-                  this.order_status_list.add(_elem267);
+                  this.order_status_list.add(_elem271);
+                }
                 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 _iter268 : this.order_status_list)
+          for (OrderStatus _iter272 : this.order_status_list)
+          {
-            oprot.writeI32(_iter268.getValue());
+            oprot.writeI32(_iter272.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 _list269 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list273 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list269.size);
+                this.success = new ArrayList<Order>(_list273.size);
-                for (int _i270 = 0; _i270 < _list269.size; ++_i270)
+                for (int _i274 = 0; _i274 < _list273.size; ++_i274)
+                {
-                  Order _elem271; // required
+                  Order _elem275; // required
-                  _elem271 = new Order();
+                  _elem275 = new Order();
-                  _elem271.read(iprot);
+                  _elem275.read(iprot);
-                  this.success.add(_elem271);
+                  this.success.add(_elem275);
+                }
                 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 _iter272 : this.success)
+          for (Order _iter276 : this.success)
+          {
-            _iter272.write(oprot);
+            _iter276.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 _list273 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list277 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list273.size);
+                this.success = new ArrayList<Order>(_list277.size);
-                for (int _i274 = 0; _i274 < _list273.size; ++_i274)
+                for (int _i278 = 0; _i278 < _list277.size; ++_i278)
+                {
-                  Order _elem275; // required
+                  Order _elem279; // required
-                  _elem275 = new Order();
+                  _elem279 = new Order();
-                  _elem275.read(iprot);
+                  _elem279.read(iprot);
-                  this.success.add(_elem275);
+                  this.success.add(_elem279);
+                }
                 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 _iter276 : this.success)
+          for (Order _iter280 : this.success)
+          {
-            _iter276.write(oprot);
+            _iter280.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 _list277 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list281 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list277.size);
+                this.success = new ArrayList<Order>(_list281.size);
-                for (int _i278 = 0; _i278 < _list277.size; ++_i278)
+                for (int _i282 = 0; _i282 < _list281.size; ++_i282)
+                {
-                  Order _elem279; // required
+                  Order _elem283; // required
-                  _elem279 = new Order();
+                  _elem283 = new Order();
-                  _elem279.read(iprot);
+                  _elem283.read(iprot);
-                  this.success.add(_elem279);
+                  this.success.add(_elem283);
+                }
                 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 _iter280 : this.success)
+          for (Order _iter284 : this.success)
+          {
-            _iter280.write(oprot);
+            _iter284.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 _list281 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list285 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list281.size);
+                this.success = new ArrayList<Order>(_list285.size);
-                for (int _i282 = 0; _i282 < _list281.size; ++_i282)
+                for (int _i286 = 0; _i286 < _list285.size; ++_i286)
+                {
-                  Order _elem283; // required
+                  Order _elem287; // required
-                  _elem283 = new Order();
+                  _elem287 = new Order();
-                  _elem283.read(iprot);
+                  _elem287.read(iprot);
-                  this.success.add(_elem283);
+                  this.success.add(_elem287);
+                }
                 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 _iter284 : this.success)
+          for (Order _iter288 : this.success)
+          {
-            _iter284.write(oprot);
+            _iter288.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 _map285 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map289 = iprot.readMapBegin();
-                this.mapAWBAndAmount = new HashMap<Long,Double>(2*_map285.size);
+                this.mapAWBAndAmount = new HashMap<Long,Double>(2*_map289.size);
-                for (int _i286 = 0; _i286 < _map285.size; ++_i286)
+                for (int _i290 = 0; _i290 < _map289.size; ++_i290)
+                {
-                  long _key287; // required
+                  long _key291; // required
-                  double _val288; // required
+                  double _val292; // required
-                  _key287 = iprot.readI64();
+                  _key291 = iprot.readI64();
-                  _val288 = iprot.readDouble();
+                  _val292 = iprot.readDouble();
-                  this.mapAWBAndAmount.put(_key287, _val288);
+                  this.mapAWBAndAmount.put(_key291, _val292);
+                }
                 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> _iter289 : this.mapAWBAndAmount.entrySet())
+          for (Map.Entry<Long, Double> _iter293 : this.mapAWBAndAmount.entrySet())
+          {
-            oprot.writeI64(_iter289.getKey());
+            oprot.writeI64(_iter293.getKey());
-            oprot.writeDouble(_iter289.getValue());
+            oprot.writeDouble(_iter293.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 _map290 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map294 = iprot.readMapBegin();
-                this.success = new HashMap<Long,String>(2*_map290.size);
+                this.success = new HashMap<Long,String>(2*_map294.size);
-                for (int _i291 = 0; _i291 < _map290.size; ++_i291)
+                for (int _i295 = 0; _i295 < _map294.size; ++_i295)
+                {
-                  long _key292; // required
+                  long _key296; // required
-                  String _val293; // required
+                  String _val297; // required
-                  _key292 = iprot.readI64();
+                  _key296 = iprot.readI64();
-                  _val293 = iprot.readString();
+                  _val297 = iprot.readString();
-                  this.success.put(_key292, _val293);
+                  this.success.put(_key296, _val297);
+                }
                 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> _iter294 : this.success.entrySet())
+          for (Map.Entry<Long, String> _iter298 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter294.getKey());
+            oprot.writeI64(_iter298.getKey());
-            oprot.writeString(_iter294.getValue());
+            oprot.writeString(_iter298.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 _list295 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list299 = iprot.readListBegin();
-                this.success = new ArrayList<PaymentSettlement>(_list295.size);
+                this.success = new ArrayList<PaymentSettlement>(_list299.size);
-                for (int _i296 = 0; _i296 < _list295.size; ++_i296)
+                for (int _i300 = 0; _i300 < _list299.size; ++_i300)
+                {
-                  PaymentSettlement _elem297; // required
+                  PaymentSettlement _elem301; // required
-                  _elem297 = new PaymentSettlement();
+                  _elem301 = new PaymentSettlement();
-                  _elem297.read(iprot);
+                  _elem301.read(iprot);
-                  this.success.add(_elem297);
+                  this.success.add(_elem301);
+                }
                 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 _iter298 : this.success)
+          for (PaymentSettlement _iter302 : this.success)
+          {
-            _iter298.write(oprot);
+            _iter302.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 _list299 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list303 = iprot.readListBegin();
-                this.orderIds = new ArrayList<Long>(_list299.size);
+                this.orderIds = new ArrayList<Long>(_list303.size);
-                for (int _i300 = 0; _i300 < _list299.size; ++_i300)
+                for (int _i304 = 0; _i304 < _list303.size; ++_i304)
+                {
-                  long _elem301; // required
+                  long _elem305; // required
-                  _elem301 = iprot.readI64();
+                  _elem305 = iprot.readI64();
-                  this.orderIds.add(_elem301);
+                  this.orderIds.add(_elem305);
+                }
                 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 _iter302 : this.orderIds)
+          for (long _iter306 : this.orderIds)
+          {
-            oprot.writeI64(_iter302);
+            oprot.writeI64(_iter306);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list303 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list307 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list303.size);
+                this.success = new ArrayList<Long>(_list307.size);
-                for (int _i304 = 0; _i304 < _list303.size; ++_i304)
+                for (int _i308 = 0; _i308 < _list307.size; ++_i308)
+                {
-                  long _elem305; // required
+                  long _elem309; // required
-                  _elem305 = iprot.readI64();
+                  _elem309 = iprot.readI64();
-                  this.success.add(_elem305);
+                  this.success.add(_elem309);
+                }
                 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 _iter306 : this.success)
+          for (long _iter310 : this.success)
+          {
-            oprot.writeI64(_iter306);
+            oprot.writeI64(_iter310);
+          }
           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 _list307 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list311 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list307.size);
+                this.success = new ArrayList<Order>(_list311.size);
-                for (int _i308 = 0; _i308 < _list307.size; ++_i308)
+                for (int _i312 = 0; _i312 < _list311.size; ++_i312)
+                {
-                  Order _elem309; // required
+                  Order _elem313; // required
-                  _elem309 = new Order();
+                  _elem313 = new Order();
-                  _elem309.read(iprot);
+                  _elem313.read(iprot);
-                  this.success.add(_elem309);
+                  this.success.add(_elem313);
+                }
                 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 _iter310 : this.success)
+          for (Order _iter314 : this.success)
+          {
-            _iter310.write(oprot);
+            _iter314.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 _map311 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map315 = iprot.readMapBegin();
-                this.success = new HashMap<Long,Long>(2*_map311.size);
+                this.success = new HashMap<Long,Long>(2*_map315.size);
-                for (int _i312 = 0; _i312 < _map311.size; ++_i312)
+                for (int _i316 = 0; _i316 < _map315.size; ++_i316)
+                {
-                  long _key313; // required
+                  long _key317; // required
-                  long _val314; // required
+                  long _val318; // required
-                  _key313 = iprot.readI64();
+                  _key317 = iprot.readI64();
-                  _val314 = iprot.readI64();
+                  _val318 = iprot.readI64();
-                  this.success.put(_key313, _val314);
+                  this.success.put(_key317, _val318);
+                }
                 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> _iter315 : this.success.entrySet())
+          for (Map.Entry<Long, Long> _iter319 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter315.getKey());
+            oprot.writeI64(_iter319.getKey());
-            oprot.writeI64(_iter315.getValue());
+            oprot.writeI64(_iter319.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 _list316 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list320 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list316.size);
+                this.success = new ArrayList<Long>(_list320.size);
-                for (int _i317 = 0; _i317 < _list316.size; ++_i317)
+                for (int _i321 = 0; _i321 < _list320.size; ++_i321)
+                {
-                  long _elem318; // required
+                  long _elem322; // required
-                  _elem318 = iprot.readI64();
+                  _elem322 = iprot.readI64();
-                  this.success.add(_elem318);
+                  this.success.add(_elem322);
+                }
                 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 _iter319 : this.success)
+          for (long _iter323 : this.success)
+          {
-            oprot.writeI64(_iter319);
+            oprot.writeI64(_iter323);
+          }
           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 _list320 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list324 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list320.size);
+                this.success = new ArrayList<Order>(_list324.size);
-                for (int _i321 = 0; _i321 < _list320.size; ++_i321)
+                for (int _i325 = 0; _i325 < _list324.size; ++_i325)
+                {
-                  Order _elem322; // required
+                  Order _elem326; // required
-                  _elem322 = new Order();
+                  _elem326 = new Order();
-                  _elem322.read(iprot);
+                  _elem326.read(iprot);
-                  this.success.add(_elem322);
+                  this.success.add(_elem326);
+                }
                 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 _iter323 : this.success)
+          for (Order _iter327 : this.success)
+          {
-            _iter323.write(oprot);
+            _iter327.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 _list324 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list328 = iprot.readListBegin();
-                this.success = new ArrayList<CODVerificationAgent>(_list324.size);
+                this.success = new ArrayList<CODVerificationAgent>(_list328.size);
-                for (int _i325 = 0; _i325 < _list324.size; ++_i325)
+                for (int _i329 = 0; _i329 < _list328.size; ++_i329)
+                {
-                  CODVerificationAgent _elem326; // required
+                  CODVerificationAgent _elem330; // required
-                  _elem326 = new CODVerificationAgent();
+                  _elem330 = new CODVerificationAgent();
-                  _elem326.read(iprot);
+                  _elem330.read(iprot);
-                  this.success.add(_elem326);
+                  this.success.add(_elem330);
+                }
                 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 _iter327 : this.success)
+          for (CODVerificationAgent _iter331 : this.success)
+          {
-            _iter327.write(oprot);
+            _iter331.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 _list328 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list332 = iprot.readListBegin();
-                this.success = new ArrayList<Attribute>(_list328.size);
+                this.success = new ArrayList<Attribute>(_list332.size);
-                for (int _i329 = 0; _i329 < _list328.size; ++_i329)
+                for (int _i333 = 0; _i333 < _list332.size; ++_i333)
+                {
-                  Attribute _elem330; // required
+                  Attribute _elem334; // required
-                  _elem330 = new Attribute();
+                  _elem334 = new Attribute();
-                  _elem330.read(iprot);
+                  _elem334.read(iprot);
-                  this.success.add(_elem330);
+                  this.success.add(_elem334);
+                }
                 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 _iter331 : this.success)
+          for (Attribute _iter335 : this.success)
+          {
-            _iter331.write(oprot);
+            _iter335.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+            }
             break;
           case -1: // ATTRIBUTES
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list332 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list336 = iprot.readListBegin();
-                this.attributes = new ArrayList<Attribute>(_list332.size);
+                this.attributes = new ArrayList<Attribute>(_list336.size);
-                for (int _i333 = 0; _i333 < _list332.size; ++_i333)
+                for (int _i337 = 0; _i337 < _list336.size; ++_i337)
+                {
-                  Attribute _elem334; // required
+                  Attribute _elem338; // required
-                  _elem334 = new Attribute();
+                  _elem338 = new Attribute();
-                  _elem334.read(iprot);
+                  _elem338.read(iprot);
-                  this.attributes.add(_elem334);
+                  this.attributes.add(_elem338);
+                }
                 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 _iter335 : this.attributes)
+          for (Attribute _iter339 : this.attributes)
+          {
-            _iter335.write(oprot);
+            _iter339.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 _list336 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list340 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list336.size);
+                this.success = new ArrayList<Order>(_list340.size);
-                for (int _i337 = 0; _i337 < _list336.size; ++_i337)
+                for (int _i341 = 0; _i341 < _list340.size; ++_i341)
+                {
-                  Order _elem338; // required
+                  Order _elem342; // required
-                  _elem338 = new Order();
+                  _elem342 = new Order();
-                  _elem338.read(iprot);
+                  _elem342.read(iprot);
-                  this.success.add(_elem338);
+                  this.success.add(_elem342);
+                }
                 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 _iter339 : this.success)
+          for (Order _iter343 : this.success)
+          {
-            _iter339.write(oprot);
+            _iter343.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 _list340 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list344 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list340.size);
+                this.success = new ArrayList<Order>(_list344.size);
-                for (int _i341 = 0; _i341 < _list340.size; ++_i341)
+                for (int _i345 = 0; _i345 < _list344.size; ++_i345)
+                {
-                  Order _elem342; // required
+                  Order _elem346; // required
-                  _elem342 = new Order();
+                  _elem346 = new Order();
-                  _elem342.read(iprot);
+                  _elem346.read(iprot);
-                  this.success.add(_elem342);
+                  this.success.add(_elem346);
+                }
                 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 _iter343 : this.success)
+          for (Order _iter347 : this.success)
+          {
-            _iter343.write(oprot);
+            _iter347.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 _list344 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list348 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list344.size);
+                this.success = new ArrayList<Order>(_list348.size);
-                for (int _i345 = 0; _i345 < _list344.size; ++_i345)
+                for (int _i349 = 0; _i349 < _list348.size; ++_i349)
+                {
-                  Order _elem346; // required
+                  Order _elem350; // required
-                  _elem346 = new Order();
+                  _elem350 = new Order();
-                  _elem346.read(iprot);
+                  _elem350.read(iprot);
-                  this.success.add(_elem346);
+                  this.success.add(_elem350);
+                }
                 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 _iter347 : this.success)
+          for (Order _iter351 : this.success)
+          {
-            _iter347.write(oprot);
+            _iter351.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
       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 createRechargeOrder_args implements org.apache.thrift.TBase<createRechargeOrder_args, createRechargeOrder_args._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("createRechargeOrder_args");
+    private static final org.apache.thrift.protocol.TField RECHARGE_ORDER_FIELD_DESC = new org.apache.thrift.protocol.TField("rechargeOrder", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+    private RechargeOrder rechargeOrder; // 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 {
+      RECHARGE_ORDER((short)1, "rechargeOrder");
+      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: // RECHARGE_ORDER
+            return RECHARGE_ORDER;
+          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.RECHARGE_ORDER, new org.apache.thrift.meta_data.FieldMetaData("rechargeOrder", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, RechargeOrder.class)));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(createRechargeOrder_args.class, metaDataMap);
+    }
+    public createRechargeOrder_args() {
+    }
+    public createRechargeOrder_args(
+      RechargeOrder rechargeOrder)
+    {
+      this();
+      this.rechargeOrder = rechargeOrder;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public createRechargeOrder_args(createRechargeOrder_args other) {
+      if (other.isSetRechargeOrder()) {
+        this.rechargeOrder = new RechargeOrder(other.rechargeOrder);
+      }
+    }
+    public createRechargeOrder_args deepCopy() {
+      return new createRechargeOrder_args(this);
+    }
+    @Override
+    public void clear() {
+      this.rechargeOrder = null;
+    }
+    public RechargeOrder getRechargeOrder() {
+      return this.rechargeOrder;
+    }
+    public void setRechargeOrder(RechargeOrder rechargeOrder) {
+      this.rechargeOrder = rechargeOrder;
+    }
+    public void unsetRechargeOrder() {
+      this.rechargeOrder = null;
+    }
+    /** Returns true if field rechargeOrder is set (has been assigned a value) and false otherwise */
+    public boolean isSetRechargeOrder() {
+      return this.rechargeOrder != null;
+    }
+    public void setRechargeOrderIsSet(boolean value) {
+      if (!value) {
+        this.rechargeOrder = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case RECHARGE_ORDER:
+        if (value == null) {
+          unsetRechargeOrder();
+        } else {
+          setRechargeOrder((RechargeOrder)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case RECHARGE_ORDER:
+        return getRechargeOrder();
+      }
+      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 RECHARGE_ORDER:
+        return isSetRechargeOrder();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof createRechargeOrder_args)
+        return this.equals((createRechargeOrder_args)that);
+      return false;
+    }
+    public boolean equals(createRechargeOrder_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_rechargeOrder = true && this.isSetRechargeOrder();
+      boolean that_present_rechargeOrder = true && that.isSetRechargeOrder();
+      if (this_present_rechargeOrder || that_present_rechargeOrder) {
+        if (!(this_present_rechargeOrder && that_present_rechargeOrder))
+          return false;
+        if (!this.rechargeOrder.equals(that.rechargeOrder))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(createRechargeOrder_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      createRechargeOrder_args typedOther = (createRechargeOrder_args)other;
+      lastComparison = Boolean.valueOf(isSetRechargeOrder()).compareTo(typedOther.isSetRechargeOrder());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetRechargeOrder()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rechargeOrder, typedOther.rechargeOrder);
+        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: // RECHARGE_ORDER
+            if (field.type == org.apache.thrift.protocol.TType.STRUCT) {
+              this.rechargeOrder = new RechargeOrder();
+              this.rechargeOrder.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 {
+      validate();
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.rechargeOrder != null) {
+        oprot.writeFieldBegin(RECHARGE_ORDER_FIELD_DESC);
+        this.rechargeOrder.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("createRechargeOrder_args(");
+      boolean first = true;
+      sb.append("rechargeOrder:");
+      if (this.rechargeOrder == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.rechargeOrder);
+      }
+      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 createRechargeOrder_result implements org.apache.thrift.TBase<createRechargeOrder_result, createRechargeOrder_result._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("createRechargeOrder_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 static final org.apache.thrift.protocol.TField EX_FIELD_DESC = new org.apache.thrift.protocol.TField("ex", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+    private RechargeOrder success; // required
+    private TransactionServiceException ex; // 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"),
+      EX((short)1, "ex");
+      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;
+          case 1: // EX
+            return EX;
+          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, RechargeOrder.class)));
+      tmpMap.put(_Fields.EX, new org.apache.thrift.meta_data.FieldMetaData("ex", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(createRechargeOrder_result.class, metaDataMap);
+    }
+    public createRechargeOrder_result() {
+    }
+    public createRechargeOrder_result(
+      RechargeOrder success,
+      TransactionServiceException ex)
+    {
+      this();
+      this.success = success;
+      this.ex = ex;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public createRechargeOrder_result(createRechargeOrder_result other) {
+      if (other.isSetSuccess()) {
+        this.success = new RechargeOrder(other.success);
+      }
+      if (other.isSetEx()) {
+        this.ex = new TransactionServiceException(other.ex);
+      }
+    }
+    public createRechargeOrder_result deepCopy() {
+      return new createRechargeOrder_result(this);
+    }
+    @Override
+    public void clear() {
+      this.success = null;
+      this.ex = null;
+    }
+    public RechargeOrder getSuccess() {
+      return this.success;
+    }
+    public void setSuccess(RechargeOrder 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 TransactionServiceException getEx() {
+      return this.ex;
+    }
+    public void setEx(TransactionServiceException ex) {
+      this.ex = ex;
+    }
+    public void unsetEx() {
+      this.ex = null;
+    }
+    /** Returns true if field ex is set (has been assigned a value) and false otherwise */
+    public boolean isSetEx() {
+      return this.ex != null;
+    }
+    public void setExIsSet(boolean value) {
+      if (!value) {
+        this.ex = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((RechargeOrder)value);
+        }
+        break;
+      case EX:
+        if (value == null) {
+          unsetEx();
+        } else {
+          setEx((TransactionServiceException)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case SUCCESS:
+        return getSuccess();
+      case EX:
+        return getEx();
+      }
+      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();
+      case EX:
+        return isSetEx();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof createRechargeOrder_result)
+        return this.equals((createRechargeOrder_result)that);
+      return false;
+    }
+    public boolean equals(createRechargeOrder_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;
+      }
+      boolean this_present_ex = true && this.isSetEx();
+      boolean that_present_ex = true && that.isSetEx();
+      if (this_present_ex || that_present_ex) {
+        if (!(this_present_ex && that_present_ex))
+          return false;
+        if (!this.ex.equals(that.ex))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(createRechargeOrder_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      createRechargeOrder_result typedOther = (createRechargeOrder_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;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetEx()).compareTo(typedOther.isSetEx());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetEx()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ex, typedOther.ex);
+        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 RechargeOrder();
+              this.success.read(iprot);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 1: // EX
+            if (field.type == org.apache.thrift.protocol.TType.STRUCT) {
+              this.ex = new TransactionServiceException();
+              this.ex.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();
+      } else if (this.isSetEx()) {
+        oprot.writeFieldBegin(EX_FIELD_DESC);
+        this.ex.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("createRechargeOrder_result(");
+      boolean first = true;
+      sb.append("success:");
+      if (this.success == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.success);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("ex:");
+      if (this.ex == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.ex);
+      }
+      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 updateRechargeOrderStatus_args implements org.apache.thrift.TBase<updateRechargeOrderStatus_args, updateRechargeOrderStatus_args._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("updateRechargeOrderStatus_args");
+    private static final org.apache.thrift.protocol.TField RECHARGE_ORDER_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("rechargeOrderId", org.apache.thrift.protocol.TType.I64, (short)1);
+    private static final org.apache.thrift.protocol.TField RECHARGE_ORDER_STATUS_FIELD_DESC = new org.apache.thrift.protocol.TField("rechargeOrderStatus", org.apache.thrift.protocol.TType.I32, (short)2);
+    private long rechargeOrderId; // required
+    private RechargeOrderStatus rechargeOrderStatus; // 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 {
+      RECHARGE_ORDER_ID((short)1, "rechargeOrderId"),
+      /**
+       *
+       * @see RechargeOrderStatus
+       */
+      RECHARGE_ORDER_STATUS((short)2, "rechargeOrderStatus");
+      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: // RECHARGE_ORDER_ID
+            return RECHARGE_ORDER_ID;
+          case 2: // RECHARGE_ORDER_STATUS
+            return RECHARGE_ORDER_STATUS;
+          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 __RECHARGEORDERID_ISSET_ID = 0;
+    private BitSet __isset_bit_vector = new BitSet(1);
+    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.RECHARGE_ORDER_ID, new org.apache.thrift.meta_data.FieldMetaData("rechargeOrderId", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      tmpMap.put(_Fields.RECHARGE_ORDER_STATUS, new org.apache.thrift.meta_data.FieldMetaData("rechargeOrderStatus", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, RechargeOrderStatus.class)));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(updateRechargeOrderStatus_args.class, metaDataMap);
+    }
+    public updateRechargeOrderStatus_args() {
+    }
+    public updateRechargeOrderStatus_args(
+      long rechargeOrderId,
+      RechargeOrderStatus rechargeOrderStatus)
+    {
+      this();
+      this.rechargeOrderId = rechargeOrderId;
+      setRechargeOrderIdIsSet(true);
+      this.rechargeOrderStatus = rechargeOrderStatus;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public updateRechargeOrderStatus_args(updateRechargeOrderStatus_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.rechargeOrderId = other.rechargeOrderId;
+      if (other.isSetRechargeOrderStatus()) {
+        this.rechargeOrderStatus = other.rechargeOrderStatus;
+      }
+    }
+    public updateRechargeOrderStatus_args deepCopy() {
+      return new updateRechargeOrderStatus_args(this);
+    }
+    @Override
+    public void clear() {
+      setRechargeOrderIdIsSet(false);
+      this.rechargeOrderId = 0;
+      this.rechargeOrderStatus = null;
+    }
+    public long getRechargeOrderId() {
+      return this.rechargeOrderId;
+    }
+    public void setRechargeOrderId(long rechargeOrderId) {
+      this.rechargeOrderId = rechargeOrderId;
+      setRechargeOrderIdIsSet(true);
+    }
+    public void unsetRechargeOrderId() {
+      __isset_bit_vector.clear(__RECHARGEORDERID_ISSET_ID);
+    }
+    /** Returns true if field rechargeOrderId is set (has been assigned a value) and false otherwise */
+    public boolean isSetRechargeOrderId() {
+      return __isset_bit_vector.get(__RECHARGEORDERID_ISSET_ID);
+    }
+    public void setRechargeOrderIdIsSet(boolean value) {
+      __isset_bit_vector.set(__RECHARGEORDERID_ISSET_ID, value);
+    }
+    /**
+     *
+     * @see RechargeOrderStatus
+     */
+    public RechargeOrderStatus getRechargeOrderStatus() {
+      return this.rechargeOrderStatus;
+    }
+    /**
+     *
+     * @see RechargeOrderStatus
+     */
+    public void setRechargeOrderStatus(RechargeOrderStatus rechargeOrderStatus) {
+      this.rechargeOrderStatus = rechargeOrderStatus;
+    }
+    public void unsetRechargeOrderStatus() {
+      this.rechargeOrderStatus = null;
+    }
+    /** Returns true if field rechargeOrderStatus is set (has been assigned a value) and false otherwise */
+    public boolean isSetRechargeOrderStatus() {
+      return this.rechargeOrderStatus != null;
+    }
+    public void setRechargeOrderStatusIsSet(boolean value) {
+      if (!value) {
+        this.rechargeOrderStatus = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case RECHARGE_ORDER_ID:
+        if (value == null) {
+          unsetRechargeOrderId();
+        } else {
+          setRechargeOrderId((Long)value);
+        }
+        break;
+      case RECHARGE_ORDER_STATUS:
+        if (value == null) {
+          unsetRechargeOrderStatus();
+        } else {
+          setRechargeOrderStatus((RechargeOrderStatus)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case RECHARGE_ORDER_ID:
+        return Long.valueOf(getRechargeOrderId());
+      case RECHARGE_ORDER_STATUS:
+        return getRechargeOrderStatus();
+      }
+      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 RECHARGE_ORDER_ID:
+        return isSetRechargeOrderId();
+      case RECHARGE_ORDER_STATUS:
+        return isSetRechargeOrderStatus();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof updateRechargeOrderStatus_args)
+        return this.equals((updateRechargeOrderStatus_args)that);
+      return false;
+    }
+    public boolean equals(updateRechargeOrderStatus_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_rechargeOrderId = true;
+      boolean that_present_rechargeOrderId = true;
+      if (this_present_rechargeOrderId || that_present_rechargeOrderId) {
+        if (!(this_present_rechargeOrderId && that_present_rechargeOrderId))
+          return false;
+        if (this.rechargeOrderId != that.rechargeOrderId)
+          return false;
+      }
+      boolean this_present_rechargeOrderStatus = true && this.isSetRechargeOrderStatus();
+      boolean that_present_rechargeOrderStatus = true && that.isSetRechargeOrderStatus();
+      if (this_present_rechargeOrderStatus || that_present_rechargeOrderStatus) {
+        if (!(this_present_rechargeOrderStatus && that_present_rechargeOrderStatus))
+          return false;
+        if (!this.rechargeOrderStatus.equals(that.rechargeOrderStatus))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(updateRechargeOrderStatus_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      updateRechargeOrderStatus_args typedOther = (updateRechargeOrderStatus_args)other;
+      lastComparison = Boolean.valueOf(isSetRechargeOrderId()).compareTo(typedOther.isSetRechargeOrderId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetRechargeOrderId()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rechargeOrderId, typedOther.rechargeOrderId);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetRechargeOrderStatus()).compareTo(typedOther.isSetRechargeOrderStatus());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetRechargeOrderStatus()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rechargeOrderStatus, typedOther.rechargeOrderStatus);
+        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: // RECHARGE_ORDER_ID
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.rechargeOrderId = iprot.readI64();
+              setRechargeOrderIdIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 2: // RECHARGE_ORDER_STATUS
+            if (field.type == org.apache.thrift.protocol.TType.I32) {
+              this.rechargeOrderStatus = RechargeOrderStatus.findByValue(iprot.readI32());
+            } 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(RECHARGE_ORDER_ID_FIELD_DESC);
+      oprot.writeI64(this.rechargeOrderId);
+      oprot.writeFieldEnd();
+      if (this.rechargeOrderStatus != null) {
+        oprot.writeFieldBegin(RECHARGE_ORDER_STATUS_FIELD_DESC);
+        oprot.writeI32(this.rechargeOrderStatus.getValue());
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("updateRechargeOrderStatus_args(");
+      boolean first = true;
+      sb.append("rechargeOrderId:");
+      sb.append(this.rechargeOrderId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("rechargeOrderStatus:");
+      if (this.rechargeOrderStatus == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.rechargeOrderStatus);
+      }
+      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 updateRechargeOrderStatus_result implements org.apache.thrift.TBase<updateRechargeOrderStatus_result, updateRechargeOrderStatus_result._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("updateRechargeOrderStatus_result");
+    private static final org.apache.thrift.protocol.TField EX_FIELD_DESC = new org.apache.thrift.protocol.TField("ex", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+    private TransactionServiceException ex; // 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 {
+      EX((short)1, "ex");
+      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: // EX
+            return EX;
+          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.EX, new org.apache.thrift.meta_data.FieldMetaData("ex", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(updateRechargeOrderStatus_result.class, metaDataMap);
+    }
+    public updateRechargeOrderStatus_result() {
+    }
+    public updateRechargeOrderStatus_result(
+      TransactionServiceException ex)
+    {
+      this();
+      this.ex = ex;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public updateRechargeOrderStatus_result(updateRechargeOrderStatus_result other) {
+      if (other.isSetEx()) {
+        this.ex = new TransactionServiceException(other.ex);
+      }
+    }
+    public updateRechargeOrderStatus_result deepCopy() {
+      return new updateRechargeOrderStatus_result(this);
+    }
+    @Override
+    public void clear() {
+      this.ex = null;
+    }
+    public TransactionServiceException getEx() {
+      return this.ex;
+    }
+    public void setEx(TransactionServiceException ex) {
+      this.ex = ex;
+    }
+    public void unsetEx() {
+      this.ex = null;
+    }
+    /** Returns true if field ex is set (has been assigned a value) and false otherwise */
+    public boolean isSetEx() {
+      return this.ex != null;
+    }
+    public void setExIsSet(boolean value) {
+      if (!value) {
+        this.ex = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case EX:
+        if (value == null) {
+          unsetEx();
+        } else {
+          setEx((TransactionServiceException)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case EX:
+        return getEx();
+      }
+      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 EX:
+        return isSetEx();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof updateRechargeOrderStatus_result)
+        return this.equals((updateRechargeOrderStatus_result)that);
+      return false;
+    }
+    public boolean equals(updateRechargeOrderStatus_result that) {
+      if (that == null)
+        return false;
+      boolean this_present_ex = true && this.isSetEx();
+      boolean that_present_ex = true && that.isSetEx();
+      if (this_present_ex || that_present_ex) {
+        if (!(this_present_ex && that_present_ex))
+          return false;
+        if (!this.ex.equals(that.ex))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(updateRechargeOrderStatus_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      updateRechargeOrderStatus_result typedOther = (updateRechargeOrderStatus_result)other;
+      lastComparison = Boolean.valueOf(isSetEx()).compareTo(typedOther.isSetEx());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetEx()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ex, typedOther.ex);
+        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: // EX
+            if (field.type == org.apache.thrift.protocol.TType.STRUCT) {
+              this.ex = new TransactionServiceException();
+              this.ex.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.isSetEx()) {
+        oprot.writeFieldBegin(EX_FIELD_DESC);
+        this.ex.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("updateRechargeOrderStatus_result(");
+      boolean first = true;
+      sb.append("ex:");
+      if (this.ex == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.ex);
+      }
+      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 activateRechargeTxn_args implements org.apache.thrift.TBase<activateRechargeTxn_args, activateRechargeTxn_args._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("activateRechargeTxn_args");
+    private static final org.apache.thrift.protocol.TField RECHARGE_COUPONS_FIELD_DESC = new org.apache.thrift.protocol.TField("rechargeCoupons", org.apache.thrift.protocol.TType.LIST, (short)1);
+    private List<RechargeCoupon> rechargeCoupons; // 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 {
+      RECHARGE_COUPONS((short)1, "rechargeCoupons");
+      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: // RECHARGE_COUPONS
+            return RECHARGE_COUPONS;
+          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.RECHARGE_COUPONS, new org.apache.thrift.meta_data.FieldMetaData("rechargeCoupons", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+              new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, RechargeCoupon.class))));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(activateRechargeTxn_args.class, metaDataMap);
+    }
+    public activateRechargeTxn_args() {
+    }
+    public activateRechargeTxn_args(
+      List<RechargeCoupon> rechargeCoupons)
+    {
+      this();
+      this.rechargeCoupons = rechargeCoupons;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public activateRechargeTxn_args(activateRechargeTxn_args other) {
+      if (other.isSetRechargeCoupons()) {
+        List<RechargeCoupon> __this__rechargeCoupons = new ArrayList<RechargeCoupon>();
+        for (RechargeCoupon other_element : other.rechargeCoupons) {
+          __this__rechargeCoupons.add(new RechargeCoupon(other_element));
+        }
+        this.rechargeCoupons = __this__rechargeCoupons;
+      }
+    }
+    public activateRechargeTxn_args deepCopy() {
+      return new activateRechargeTxn_args(this);
+    }
+    @Override
+    public void clear() {
+      this.rechargeCoupons = null;
+    }
+    public int getRechargeCouponsSize() {
+      return (this.rechargeCoupons == null) ? 0 : this.rechargeCoupons.size();
+    }
+    public java.util.Iterator<RechargeCoupon> getRechargeCouponsIterator() {
+      return (this.rechargeCoupons == null) ? null : this.rechargeCoupons.iterator();
+    }
+    public void addToRechargeCoupons(RechargeCoupon elem) {
+      if (this.rechargeCoupons == null) {
+        this.rechargeCoupons = new ArrayList<RechargeCoupon>();
+      }
+      this.rechargeCoupons.add(elem);
+    }
+    public List<RechargeCoupon> getRechargeCoupons() {
+      return this.rechargeCoupons;
+    }
+    public void setRechargeCoupons(List<RechargeCoupon> rechargeCoupons) {
+      this.rechargeCoupons = rechargeCoupons;
+    }
+    public void unsetRechargeCoupons() {
+      this.rechargeCoupons = null;
+    }
+    /** Returns true if field rechargeCoupons is set (has been assigned a value) and false otherwise */
+    public boolean isSetRechargeCoupons() {
+      return this.rechargeCoupons != null;
+    }
+    public void setRechargeCouponsIsSet(boolean value) {
+      if (!value) {
+        this.rechargeCoupons = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case RECHARGE_COUPONS:
+        if (value == null) {
+          unsetRechargeCoupons();
+        } else {
+          setRechargeCoupons((List<RechargeCoupon>)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case RECHARGE_COUPONS:
+        return getRechargeCoupons();
+      }
+      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 RECHARGE_COUPONS:
+        return isSetRechargeCoupons();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof activateRechargeTxn_args)
+        return this.equals((activateRechargeTxn_args)that);
+      return false;
+    }
+    public boolean equals(activateRechargeTxn_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_rechargeCoupons = true && this.isSetRechargeCoupons();
+      boolean that_present_rechargeCoupons = true && that.isSetRechargeCoupons();
+      if (this_present_rechargeCoupons || that_present_rechargeCoupons) {
+        if (!(this_present_rechargeCoupons && that_present_rechargeCoupons))
+          return false;
+        if (!this.rechargeCoupons.equals(that.rechargeCoupons))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(activateRechargeTxn_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      activateRechargeTxn_args typedOther = (activateRechargeTxn_args)other;
+      lastComparison = Boolean.valueOf(isSetRechargeCoupons()).compareTo(typedOther.isSetRechargeCoupons());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetRechargeCoupons()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rechargeCoupons, typedOther.rechargeCoupons);
+        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: // RECHARGE_COUPONS
+            if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
+                org.apache.thrift.protocol.TList _list352 = iprot.readListBegin();
+                this.rechargeCoupons = new ArrayList<RechargeCoupon>(_list352.size);
+                for (int _i353 = 0; _i353 < _list352.size; ++_i353)
+                {
+                  RechargeCoupon _elem354; // required
+                  _elem354 = new RechargeCoupon();
+                  _elem354.read(iprot);
+                  this.rechargeCoupons.add(_elem354);
+                }
+                iprot.readListEnd();
+              }
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+      validate();
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.rechargeCoupons != null) {
+        oprot.writeFieldBegin(RECHARGE_COUPONS_FIELD_DESC);
+        {
+          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.rechargeCoupons.size()));
+          for (RechargeCoupon _iter355 : this.rechargeCoupons)
+          {
+            _iter355.write(oprot);
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("activateRechargeTxn_args(");
+      boolean first = true;
+      sb.append("rechargeCoupons:");
+      if (this.rechargeCoupons == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.rechargeCoupons);
+      }
+      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 activateRechargeTxn_result implements org.apache.thrift.TBase<activateRechargeTxn_result, activateRechargeTxn_result._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("activateRechargeTxn_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 static final org.apache.thrift.protocol.TField EX_FIELD_DESC = new org.apache.thrift.protocol.TField("ex", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+    private RechargeResponse success; // required
+    private TransactionServiceException ex; // 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"),
+      EX((short)1, "ex");
+      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;
+          case 1: // EX
+            return EX;
+          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, RechargeResponse.class)));
+      tmpMap.put(_Fields.EX, new org.apache.thrift.meta_data.FieldMetaData("ex", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(activateRechargeTxn_result.class, metaDataMap);
+    }
+    public activateRechargeTxn_result() {
+    }
+    public activateRechargeTxn_result(
+      RechargeResponse success,
+      TransactionServiceException ex)
+    {
+      this();
+      this.success = success;
+      this.ex = ex;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public activateRechargeTxn_result(activateRechargeTxn_result other) {
+      if (other.isSetSuccess()) {
+        this.success = new RechargeResponse(other.success);
+      }
+      if (other.isSetEx()) {
+        this.ex = new TransactionServiceException(other.ex);
+      }
+    }
+    public activateRechargeTxn_result deepCopy() {
+      return new activateRechargeTxn_result(this);
+    }
+    @Override
+    public void clear() {
+      this.success = null;
+      this.ex = null;
+    }
+    public RechargeResponse getSuccess() {
+      return this.success;
+    }
+    public void setSuccess(RechargeResponse 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 TransactionServiceException getEx() {
+      return this.ex;
+    }
+    public void setEx(TransactionServiceException ex) {
+      this.ex = ex;
+    }
+    public void unsetEx() {
+      this.ex = null;
+    }
+    /** Returns true if field ex is set (has been assigned a value) and false otherwise */
+    public boolean isSetEx() {
+      return this.ex != null;
+    }
+    public void setExIsSet(boolean value) {
+      if (!value) {
+        this.ex = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((RechargeResponse)value);
+        }
+        break;
+      case EX:
+        if (value == null) {
+          unsetEx();
+        } else {
+          setEx((TransactionServiceException)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case SUCCESS:
+        return getSuccess();
+      case EX:
+        return getEx();
+      }
+      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();
+      case EX:
+        return isSetEx();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof activateRechargeTxn_result)
+        return this.equals((activateRechargeTxn_result)that);
+      return false;
+    }
+    public boolean equals(activateRechargeTxn_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;
+      }
+      boolean this_present_ex = true && this.isSetEx();
+      boolean that_present_ex = true && that.isSetEx();
+      if (this_present_ex || that_present_ex) {
+        if (!(this_present_ex && that_present_ex))
+          return false;
+        if (!this.ex.equals(that.ex))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(activateRechargeTxn_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      activateRechargeTxn_result typedOther = (activateRechargeTxn_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;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetEx()).compareTo(typedOther.isSetEx());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetEx()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ex, typedOther.ex);
+        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 RechargeResponse();
+              this.success.read(iprot);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 1: // EX
+            if (field.type == org.apache.thrift.protocol.TType.STRUCT) {
+              this.ex = new TransactionServiceException();
+              this.ex.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();
+      } else if (this.isSetEx()) {
+        oprot.writeFieldBegin(EX_FIELD_DESC);
+        this.ex.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("activateRechargeTxn_result(");
+      boolean first = true;
+      sb.append("success:");
+      if (this.success == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.success);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("ex:");
+      if (this.ex == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.ex);
+      }
+      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 getRechargeOrders_args implements org.apache.thrift.TBase<getRechargeOrders_args, getRechargeOrders_args._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRechargeOrders_args");
+    private static final org.apache.thrift.protocol.TField CUSTOMER_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("customerId", org.apache.thrift.protocol.TType.I64, (short)1);
+    private long customerId; // 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 {
+      CUSTOMER_ID((short)1, "customerId");
+      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: // CUSTOMER_ID
+            return CUSTOMER_ID;
+          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 __CUSTOMERID_ISSET_ID = 0;
+    private BitSet __isset_bit_vector = new BitSet(1);
+    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.CUSTOMER_ID, new org.apache.thrift.meta_data.FieldMetaData("customerId", 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(getRechargeOrders_args.class, metaDataMap);
+    }
+    public getRechargeOrders_args() {
+    }
+    public getRechargeOrders_args(
+      long customerId)
+    {
+      this();
+      this.customerId = customerId;
+      setCustomerIdIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getRechargeOrders_args(getRechargeOrders_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.customerId = other.customerId;
+    }
+    public getRechargeOrders_args deepCopy() {
+      return new getRechargeOrders_args(this);
+    }
+    @Override
+    public void clear() {
+      setCustomerIdIsSet(false);
+      this.customerId = 0;
+    }
+    public long getCustomerId() {
+      return this.customerId;
+    }
+    public void setCustomerId(long customerId) {
+      this.customerId = customerId;
+      setCustomerIdIsSet(true);
+    }
+    public void unsetCustomerId() {
+      __isset_bit_vector.clear(__CUSTOMERID_ISSET_ID);
+    }
+    /** Returns true if field customerId is set (has been assigned a value) and false otherwise */
+    public boolean isSetCustomerId() {
+      return __isset_bit_vector.get(__CUSTOMERID_ISSET_ID);
+    }
+    public void setCustomerIdIsSet(boolean value) {
+      __isset_bit_vector.set(__CUSTOMERID_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case CUSTOMER_ID:
+        if (value == null) {
+          unsetCustomerId();
+        } else {
+          setCustomerId((Long)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case CUSTOMER_ID:
+        return Long.valueOf(getCustomerId());
+      }
+      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 CUSTOMER_ID:
+        return isSetCustomerId();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof getRechargeOrders_args)
+        return this.equals((getRechargeOrders_args)that);
+      return false;
+    }
+    public boolean equals(getRechargeOrders_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_customerId = true;
+      boolean that_present_customerId = true;
+      if (this_present_customerId || that_present_customerId) {
+        if (!(this_present_customerId && that_present_customerId))
+          return false;
+        if (this.customerId != that.customerId)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getRechargeOrders_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getRechargeOrders_args typedOther = (getRechargeOrders_args)other;
+      lastComparison = Boolean.valueOf(isSetCustomerId()).compareTo(typedOther.isSetCustomerId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetCustomerId()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.customerId, typedOther.customerId);
+        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: // CUSTOMER_ID
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.customerId = iprot.readI64();
+              setCustomerIdIsSet(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(CUSTOMER_ID_FIELD_DESC);
+      oprot.writeI64(this.customerId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getRechargeOrders_args(");
+      boolean first = true;
+      sb.append("customerId:");
+      sb.append(this.customerId);
+      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 getRechargeOrders_result implements org.apache.thrift.TBase<getRechargeOrders_result, getRechargeOrders_result._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRechargeOrders_result");
+    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0);
+    private List<RechargeOrder> success; // required
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+      SUCCESS((short)0, "success");
+      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+      static {
+        for (_Fields field : EnumSet.allOf(_Fields.class)) {
+          byName.put(field.getFieldName(), field);
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, or null if its not found.
+       */
+      public static _Fields findByThriftId(int fieldId) {
+        switch(fieldId) {
+          case 0: // SUCCESS
+            return SUCCESS;
+          default:
+            return null;
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, throwing an exception
+       * if it is not found.
+       */
+      public static _Fields findByThriftIdOrThrow(int fieldId) {
+        _Fields fields = findByThriftId(fieldId);
+        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+        return fields;
+      }
+      /**
+       * Find the _Fields constant that matches name, or null if its not found.
+       */
+      public static _Fields findByName(String name) {
+        return byName.get(name);
+      }
+      private final short _thriftId;
+      private final String _fieldName;
+      _Fields(short thriftId, String fieldName) {
+        _thriftId = thriftId;
+        _fieldName = fieldName;
+      }
+      public short getThriftFieldId() {
+        return _thriftId;
+      }
+      public String getFieldName() {
+        return _fieldName;
+      }
+    }
+    // isset id assignments
+    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+    static {
+      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+              new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, RechargeOrder.class))));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRechargeOrders_result.class, metaDataMap);
+    }
+    public getRechargeOrders_result() {
+    }
+    public getRechargeOrders_result(
+      List<RechargeOrder> success)
+    {
+      this();
+      this.success = success;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getRechargeOrders_result(getRechargeOrders_result other) {
+      if (other.isSetSuccess()) {
+        List<RechargeOrder> __this__success = new ArrayList<RechargeOrder>();
+        for (RechargeOrder other_element : other.success) {
+          __this__success.add(new RechargeOrder(other_element));
+        }
+        this.success = __this__success;
+      }
+    }
+    public getRechargeOrders_result deepCopy() {
+      return new getRechargeOrders_result(this);
+    }
+    @Override
+    public void clear() {
+      this.success = null;
+    }
+    public int getSuccessSize() {
+      return (this.success == null) ? 0 : this.success.size();
+    }
+    public java.util.Iterator<RechargeOrder> getSuccessIterator() {
+      return (this.success == null) ? null : this.success.iterator();
+    }
+    public void addToSuccess(RechargeOrder elem) {
+      if (this.success == null) {
+        this.success = new ArrayList<RechargeOrder>();
+      }
+      this.success.add(elem);
+    }
+    public List<RechargeOrder> getSuccess() {
+      return this.success;
+    }
+    public void setSuccess(List<RechargeOrder> success) {
+      this.success = success;
+    }
+    public void unsetSuccess() {
+      this.success = null;
+    }
+    /** Returns true if field success is set (has been assigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return this.success != null;
+    }
+    public void setSuccessIsSet(boolean value) {
+      if (!value) {
+        this.success = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((List<RechargeOrder>)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 getRechargeOrders_result)
+        return this.equals((getRechargeOrders_result)that);
+      return false;
+    }
+    public boolean equals(getRechargeOrders_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(getRechargeOrders_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getRechargeOrders_result typedOther = (getRechargeOrders_result)other;
+      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetSuccess()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      return 0;
+    }
+    public _Fields fieldForId(int fieldId) {
+      return _Fields.findByThriftId(fieldId);
+    }
+    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField field;
+      iprot.readStructBegin();
+      while (true)
+      {
+        field = iprot.readFieldBegin();
+        if (field.type == org.apache.thrift.protocol.TType.STOP) {
+          break;
+        }
+        switch (field.id) {
+          case 0: // SUCCESS
+            if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
+                org.apache.thrift.protocol.TList _list356 = iprot.readListBegin();
+                this.success = new ArrayList<RechargeOrder>(_list356.size);
+                for (int _i357 = 0; _i357 < _list356.size; ++_i357)
+                {
+                  RechargeOrder _elem358; // required
+                  _elem358 = new RechargeOrder();
+                  _elem358.read(iprot);
+                  this.success.add(_elem358);
+                }
+                iprot.readListEnd();
+              }
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
+          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
+          for (RechargeOrder _iter359 : this.success)
+          {
+            _iter359.write(oprot);
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getRechargeOrders_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 getRechargeCoupons_args implements org.apache.thrift.TBase<getRechargeCoupons_args, getRechargeCoupons_args._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRechargeCoupons_args");
+    private static final org.apache.thrift.protocol.TField CUSTOMER_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("customerId", org.apache.thrift.protocol.TType.I64, (short)1);
+    private static final org.apache.thrift.protocol.TField RECHARGE_COUPON_STATUS_FIELD_DESC = new org.apache.thrift.protocol.TField("rechargeCouponStatus", org.apache.thrift.protocol.TType.I32, (short)2);
+    private long customerId; // required
+    private RechargeCouponStatus rechargeCouponStatus; // 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 {
+      CUSTOMER_ID((short)1, "customerId"),
+      /**
+       *
+       * @see RechargeCouponStatus
+       */
+      RECHARGE_COUPON_STATUS((short)2, "rechargeCouponStatus");
+      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: // CUSTOMER_ID
+            return CUSTOMER_ID;
+          case 2: // RECHARGE_COUPON_STATUS
+            return RECHARGE_COUPON_STATUS;
+          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 __CUSTOMERID_ISSET_ID = 0;
+    private BitSet __isset_bit_vector = new BitSet(1);
+    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.CUSTOMER_ID, new org.apache.thrift.meta_data.FieldMetaData("customerId", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      tmpMap.put(_Fields.RECHARGE_COUPON_STATUS, new org.apache.thrift.meta_data.FieldMetaData("rechargeCouponStatus", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, RechargeCouponStatus.class)));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRechargeCoupons_args.class, metaDataMap);
+    }
+    public getRechargeCoupons_args() {
+    }
+    public getRechargeCoupons_args(
+      long customerId,
+      RechargeCouponStatus rechargeCouponStatus)
+    {
+      this();
+      this.customerId = customerId;
+      setCustomerIdIsSet(true);
+      this.rechargeCouponStatus = rechargeCouponStatus;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getRechargeCoupons_args(getRechargeCoupons_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.customerId = other.customerId;
+      if (other.isSetRechargeCouponStatus()) {
+        this.rechargeCouponStatus = other.rechargeCouponStatus;
+      }
+    }
+    public getRechargeCoupons_args deepCopy() {
+      return new getRechargeCoupons_args(this);
+    }
+    @Override
+    public void clear() {
+      setCustomerIdIsSet(false);
+      this.customerId = 0;
+      this.rechargeCouponStatus = null;
+    }
+    public long getCustomerId() {
+      return this.customerId;
+    }
+    public void setCustomerId(long customerId) {
+      this.customerId = customerId;
+      setCustomerIdIsSet(true);
+    }
+    public void unsetCustomerId() {
+      __isset_bit_vector.clear(__CUSTOMERID_ISSET_ID);
+    }
+    /** Returns true if field customerId is set (has been assigned a value) and false otherwise */
+    public boolean isSetCustomerId() {
+      return __isset_bit_vector.get(__CUSTOMERID_ISSET_ID);
+    }
+    public void setCustomerIdIsSet(boolean value) {
+      __isset_bit_vector.set(__CUSTOMERID_ISSET_ID, value);
+    }
+    /**
+     *
+     * @see RechargeCouponStatus
+     */
+    public RechargeCouponStatus getRechargeCouponStatus() {
+      return this.rechargeCouponStatus;
+    }
+    /**
+     *
+     * @see RechargeCouponStatus
+     */
+    public void setRechargeCouponStatus(RechargeCouponStatus rechargeCouponStatus) {
+      this.rechargeCouponStatus = rechargeCouponStatus;
+    }
+    public void unsetRechargeCouponStatus() {
+      this.rechargeCouponStatus = null;
+    }
+    /** Returns true if field rechargeCouponStatus is set (has been assigned a value) and false otherwise */
+    public boolean isSetRechargeCouponStatus() {
+      return this.rechargeCouponStatus != null;
+    }
+    public void setRechargeCouponStatusIsSet(boolean value) {
+      if (!value) {
+        this.rechargeCouponStatus = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case CUSTOMER_ID:
+        if (value == null) {
+          unsetCustomerId();
+        } else {
+          setCustomerId((Long)value);
+        }
+        break;
+      case RECHARGE_COUPON_STATUS:
+        if (value == null) {
+          unsetRechargeCouponStatus();
+        } else {
+          setRechargeCouponStatus((RechargeCouponStatus)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case CUSTOMER_ID:
+        return Long.valueOf(getCustomerId());
+      case RECHARGE_COUPON_STATUS:
+        return getRechargeCouponStatus();
+      }
+      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 CUSTOMER_ID:
+        return isSetCustomerId();
+      case RECHARGE_COUPON_STATUS:
+        return isSetRechargeCouponStatus();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof getRechargeCoupons_args)
+        return this.equals((getRechargeCoupons_args)that);
+      return false;
+    }
+    public boolean equals(getRechargeCoupons_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_customerId = true;
+      boolean that_present_customerId = true;
+      if (this_present_customerId || that_present_customerId) {
+        if (!(this_present_customerId && that_present_customerId))
+          return false;
+        if (this.customerId != that.customerId)
+          return false;
+      }
+      boolean this_present_rechargeCouponStatus = true && this.isSetRechargeCouponStatus();
+      boolean that_present_rechargeCouponStatus = true && that.isSetRechargeCouponStatus();
+      if (this_present_rechargeCouponStatus || that_present_rechargeCouponStatus) {
+        if (!(this_present_rechargeCouponStatus && that_present_rechargeCouponStatus))
+          return false;
+        if (!this.rechargeCouponStatus.equals(that.rechargeCouponStatus))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getRechargeCoupons_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getRechargeCoupons_args typedOther = (getRechargeCoupons_args)other;
+      lastComparison = Boolean.valueOf(isSetCustomerId()).compareTo(typedOther.isSetCustomerId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetCustomerId()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.customerId, typedOther.customerId);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetRechargeCouponStatus()).compareTo(typedOther.isSetRechargeCouponStatus());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetRechargeCouponStatus()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rechargeCouponStatus, typedOther.rechargeCouponStatus);
+        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: // CUSTOMER_ID
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.customerId = iprot.readI64();
+              setCustomerIdIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 2: // RECHARGE_COUPON_STATUS
+            if (field.type == org.apache.thrift.protocol.TType.I32) {
+              this.rechargeCouponStatus = RechargeCouponStatus.findByValue(iprot.readI32());
+            } 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(CUSTOMER_ID_FIELD_DESC);
+      oprot.writeI64(this.customerId);
+      oprot.writeFieldEnd();
+      if (this.rechargeCouponStatus != null) {
+        oprot.writeFieldBegin(RECHARGE_COUPON_STATUS_FIELD_DESC);
+        oprot.writeI32(this.rechargeCouponStatus.getValue());
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getRechargeCoupons_args(");
+      boolean first = true;
+      sb.append("customerId:");
+      sb.append(this.customerId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("rechargeCouponStatus:");
+      if (this.rechargeCouponStatus == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.rechargeCouponStatus);
+      }
+      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 getRechargeCoupons_result implements org.apache.thrift.TBase<getRechargeCoupons_result, getRechargeCoupons_result._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getRechargeCoupons_result");
+    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0);
+    private List<RechargeCoupon> success; // required
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+      SUCCESS((short)0, "success");
+      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+      static {
+        for (_Fields field : EnumSet.allOf(_Fields.class)) {
+          byName.put(field.getFieldName(), field);
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, or null if its not found.
+       */
+      public static _Fields findByThriftId(int fieldId) {
+        switch(fieldId) {
+          case 0: // SUCCESS
+            return SUCCESS;
+          default:
+            return null;
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, throwing an exception
+       * if it is not found.
+       */
+      public static _Fields findByThriftIdOrThrow(int fieldId) {
+        _Fields fields = findByThriftId(fieldId);
+        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+        return fields;
+      }
+      /**
+       * Find the _Fields constant that matches name, or null if its not found.
+       */
+      public static _Fields findByName(String name) {
+        return byName.get(name);
+      }
+      private final short _thriftId;
+      private final String _fieldName;
+      _Fields(short thriftId, String fieldName) {
+        _thriftId = thriftId;
+        _fieldName = fieldName;
+      }
+      public short getThriftFieldId() {
+        return _thriftId;
+      }
+      public String getFieldName() {
+        return _fieldName;
+      }
+    }
+    // isset id assignments
+    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+    static {
+      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+              new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, RechargeCoupon.class))));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getRechargeCoupons_result.class, metaDataMap);
+    }
+    public getRechargeCoupons_result() {
+    }
+    public getRechargeCoupons_result(
+      List<RechargeCoupon> success)
+    {
+      this();
+      this.success = success;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getRechargeCoupons_result(getRechargeCoupons_result other) {
+      if (other.isSetSuccess()) {
+        List<RechargeCoupon> __this__success = new ArrayList<RechargeCoupon>();
+        for (RechargeCoupon other_element : other.success) {
+          __this__success.add(new RechargeCoupon(other_element));
+        }
+        this.success = __this__success;
+      }
+    }
+    public getRechargeCoupons_result deepCopy() {
+      return new getRechargeCoupons_result(this);
+    }
+    @Override
+    public void clear() {
+      this.success = null;
+    }
+    public int getSuccessSize() {
+      return (this.success == null) ? 0 : this.success.size();
+    }
+    public java.util.Iterator<RechargeCoupon> getSuccessIterator() {
+      return (this.success == null) ? null : this.success.iterator();
+    }
+    public void addToSuccess(RechargeCoupon elem) {
+      if (this.success == null) {
+        this.success = new ArrayList<RechargeCoupon>();
+      }
+      this.success.add(elem);
+    }
+    public List<RechargeCoupon> getSuccess() {
+      return this.success;
+    }
+    public void setSuccess(List<RechargeCoupon> success) {
+      this.success = success;
+    }
+    public void unsetSuccess() {
+      this.success = null;
+    }
+    /** Returns true if field success is set (has been assigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return this.success != null;
+    }
+    public void setSuccessIsSet(boolean value) {
+      if (!value) {
+        this.success = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((List<RechargeCoupon>)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 getRechargeCoupons_result)
+        return this.equals((getRechargeCoupons_result)that);
+      return false;
+    }
+    public boolean equals(getRechargeCoupons_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(getRechargeCoupons_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getRechargeCoupons_result typedOther = (getRechargeCoupons_result)other;
+      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetSuccess()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      return 0;
+    }
+    public _Fields fieldForId(int fieldId) {
+      return _Fields.findByThriftId(fieldId);
+    }
+    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField field;
+      iprot.readStructBegin();
+      while (true)
+      {
+        field = iprot.readFieldBegin();
+        if (field.type == org.apache.thrift.protocol.TType.STOP) {
+          break;
+        }
+        switch (field.id) {
+          case 0: // SUCCESS
+            if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
+                org.apache.thrift.protocol.TList _list360 = iprot.readListBegin();
+                this.success = new ArrayList<RechargeCoupon>(_list360.size);
+                for (int _i361 = 0; _i361 < _list360.size; ++_i361)
+                {
+                  RechargeCoupon _elem362; // required
+                  _elem362 = new RechargeCoupon();
+                  _elem362.read(iprot);
+                  this.success.add(_elem362);
+                }
+                iprot.readListEnd();
+              }
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
+          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
+          for (RechargeCoupon _iter363 : this.success)
+          {
+            _iter363.write(oprot);
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getRechargeCoupons_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 {

Subversion Repositories SmartDukaan

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