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

      * @param cod
      * @param orderIds
      */
     public boolean markOrdersAsShippedFromWarehouse(long warehouseId, long providerId, boolean cod, List<Long> orderIds) throws TransactionServiceException, org.apache.thrift.TException;
-    public boolean markOrdersAsReturnedFromStore(long providerId, List<Long> orderIds) throws TransactionServiceException, org.apache.thrift.TException;
+    public boolean markOrdersAsReturnedFromStore(long providerId, List<Long> orderIds, List<String> awbs) throws TransactionServiceException, org.apache.thrift.TException;
     /**
      * Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
      * Raises an exception if we encounter report for an AWB number that we did not ship.
+     *
     public List<Order> getReceivePendingOrders(long storeId) throws org.apache.thrift.TException;
     public List<Order> getReceivedAtStoreOrders(long storeId) throws org.apache.thrift.TException;
+    public List<Order> getOrdersCollectionAtStore(long storeId, long fromDate, long toDate, boolean onlyCod) throws org.apache.thrift.TException;
     /**
      * Accepts appropriate order for an item in a given billingWarehouse. Usually
      * invoked while scanning IN of items.
+     *
      * @param itemId
     public void addInvoiceNumber(long orderId, String invoiceNumber, String color, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.addInvoiceNumber_call> resultHandler) throws org.apache.thrift.TException;
     public void markOrdersAsShippedFromWarehouse(long warehouseId, long providerId, boolean cod, List<Long> orderIds, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.markOrdersAsShippedFromWarehouse_call> resultHandler) throws org.apache.thrift.TException;
-    public void markOrdersAsReturnedFromStore(long providerId, List<Long> orderIds, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.markOrdersAsReturnedFromStore_call> resultHandler) throws org.apache.thrift.TException;
+    public void markOrdersAsReturnedFromStore(long providerId, List<Long> orderIds, List<String> awbs, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.markOrdersAsReturnedFromStore_call> resultHandler) throws org.apache.thrift.TException;
     public void markOrdersAsPickedUp(long providerId, Map<String,String> pickupDetails, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.markOrdersAsPickedUp_call> resultHandler) throws org.apache.thrift.TException;
     public void getOrdersNotPickedUp(long providerId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getOrdersNotPickedUp_call> resultHandler) throws org.apache.thrift.TException;
     public void getReceivePendingOrders(long storeId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getReceivePendingOrders_call> resultHandler) throws org.apache.thrift.TException;
     public void getReceivedAtStoreOrders(long storeId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getReceivedAtStoreOrders_call> resultHandler) throws org.apache.thrift.TException;
+    public void getOrdersCollectionAtStore(long storeId, long fromDate, long toDate, boolean onlyCod, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getOrdersCollectionAtStore_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 static class Client extends in.shop2020.generic.GenericService.Client implements Iface {
         throw result.ex;
+      }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
+    }
-    public boolean markOrdersAsReturnedFromStore(long providerId, List<Long> orderIds) throws TransactionServiceException, org.apache.thrift.TException
+    public boolean markOrdersAsReturnedFromStore(long providerId, List<Long> orderIds, List<String> awbs) throws TransactionServiceException, org.apache.thrift.TException
+    {
-      send_markOrdersAsReturnedFromStore(providerId, orderIds);
+      send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs);
       return recv_markOrdersAsReturnedFromStore();
+    }
-    public void send_markOrdersAsReturnedFromStore(long providerId, List<Long> orderIds) throws org.apache.thrift.TException
+    public void send_markOrdersAsReturnedFromStore(long providerId, List<Long> orderIds, List<String> awbs) throws org.apache.thrift.TException
+    {
       markOrdersAsReturnedFromStore_args args = new markOrdersAsReturnedFromStore_args();
       args.setProviderId(providerId);
       args.setOrderIds(orderIds);
+      args.setAwbs(awbs);
       sendBase("markOrdersAsReturnedFromStore", args);
+    }
     public boolean recv_markOrdersAsReturnedFromStore() throws TransactionServiceException, org.apache.thrift.TException
+    {
         return result.success;
+      }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
+    }
+    public List<Order> getOrdersCollectionAtStore(long storeId, long fromDate, long toDate, boolean onlyCod) throws org.apache.thrift.TException
+    {
+      send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod);
+      return recv_getOrdersCollectionAtStore();
+    }
+    public void send_getOrdersCollectionAtStore(long storeId, long fromDate, long toDate, boolean onlyCod) throws org.apache.thrift.TException
+    {
+      getOrdersCollectionAtStore_args args = new getOrdersCollectionAtStore_args();
+      args.setStoreId(storeId);
+      args.setFromDate(fromDate);
+      args.setToDate(toDate);
+      args.setOnlyCod(onlyCod);
+      sendBase("getOrdersCollectionAtStore", args);
+    }
+    public List<Order> recv_getOrdersCollectionAtStore() throws org.apache.thrift.TException
+    {
+      getOrdersCollectionAtStore_result result = new getOrdersCollectionAtStore_result();
+      receiveBase(result, "getOrdersCollectionAtStore");
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
+    }
     public void acceptOrderForItem(long itemId, long quantity, long fulfilmentWarehouseId, long billingWarehouseId) throws org.apache.thrift.TException
+    {
       send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId);
       recv_acceptOrderForItem();
+    }
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         return (new Client(prot)).recv_markOrdersAsShippedFromWarehouse();
+      }
+    }
-    public void markOrdersAsReturnedFromStore(long providerId, List<Long> orderIds, org.apache.thrift.async.AsyncMethodCallback<markOrdersAsReturnedFromStore_call> resultHandler) throws org.apache.thrift.TException {
+    public void markOrdersAsReturnedFromStore(long providerId, List<Long> orderIds, List<String> awbs, org.apache.thrift.async.AsyncMethodCallback<markOrdersAsReturnedFromStore_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
-      markOrdersAsReturnedFromStore_call method_call = new markOrdersAsReturnedFromStore_call(providerId, orderIds, resultHandler, this, ___protocolFactory, ___transport);
+      markOrdersAsReturnedFromStore_call method_call = new markOrdersAsReturnedFromStore_call(providerId, orderIds, awbs, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
+    }
     public static class markOrdersAsReturnedFromStore_call extends org.apache.thrift.async.TAsyncMethodCall {
       private long providerId;
       private List<Long> orderIds;
+      private List<String> awbs;
-      public markOrdersAsReturnedFromStore_call(long providerId, List<Long> orderIds, org.apache.thrift.async.AsyncMethodCallback<markOrdersAsReturnedFromStore_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 {
+      public markOrdersAsReturnedFromStore_call(long providerId, List<Long> orderIds, List<String> awbs, org.apache.thrift.async.AsyncMethodCallback<markOrdersAsReturnedFromStore_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.providerId = providerId;
         this.orderIds = orderIds;
+        this.awbs = awbs;
+      }
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
         prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("markOrdersAsReturnedFromStore", org.apache.thrift.protocol.TMessageType.CALL, 0));
         markOrdersAsReturnedFromStore_args args = new markOrdersAsReturnedFromStore_args();
         args.setProviderId(providerId);
         args.setOrderIds(orderIds);
+        args.setAwbs(awbs);
         args.write(prot);
         prot.writeMessageEnd();
+      }
       public boolean getResult() throws TransactionServiceException, org.apache.thrift.TException {
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         return (new Client(prot)).recv_getReceivedAtStoreOrders();
+      }
+    }
+    public void getOrdersCollectionAtStore(long storeId, long fromDate, long toDate, boolean onlyCod, org.apache.thrift.async.AsyncMethodCallback<getOrdersCollectionAtStore_call> resultHandler) throws org.apache.thrift.TException {
+      checkReady();
+      getOrdersCollectionAtStore_call method_call = new getOrdersCollectionAtStore_call(storeId, fromDate, toDate, onlyCod, resultHandler, this, ___protocolFactory, ___transport);
+      this.___currentMethod = method_call;
+      ___manager.call(method_call);
+    }
+    public static class getOrdersCollectionAtStore_call extends org.apache.thrift.async.TAsyncMethodCall {
+      private long storeId;
+      private long fromDate;
+      private long toDate;
+      private boolean onlyCod;
+      public getOrdersCollectionAtStore_call(long storeId, long fromDate, long toDate, boolean onlyCod, org.apache.thrift.async.AsyncMethodCallback<getOrdersCollectionAtStore_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.storeId = storeId;
+        this.fromDate = fromDate;
+        this.toDate = toDate;
+        this.onlyCod = onlyCod;
+      }
+      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getOrdersCollectionAtStore", org.apache.thrift.protocol.TMessageType.CALL, 0));
+        getOrdersCollectionAtStore_args args = new getOrdersCollectionAtStore_args();
+        args.setStoreId(storeId);
+        args.setFromDate(fromDate);
+        args.setToDate(toDate);
+        args.setOnlyCod(onlyCod);
+        args.write(prot);
+        prot.writeMessageEnd();
+      }
+      public List<Order> 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_getOrdersCollectionAtStore();
+      }
+    }
     public void acceptOrderForItem(long itemId, long quantity, long fulfilmentWarehouseId, long billingWarehouseId, org.apache.thrift.async.AsyncMethodCallback<acceptOrderForItem_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       acceptOrderForItem_call method_call = new acceptOrderForItem_call(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
       processMap.put("getAllAttributesForOrderId", new getAllAttributesForOrderId());
       processMap.put("setOrderAttributes", new setOrderAttributes());
       processMap.put("setOrderAttributeForTransaction", new setOrderAttributeForTransaction());
       processMap.put("getReceivePendingOrders", new getReceivePendingOrders());
       processMap.put("getReceivedAtStoreOrders", new getReceivedAtStoreOrders());
+      processMap.put("getOrdersCollectionAtStore", new getOrdersCollectionAtStore());
       processMap.put("acceptOrderForItem", new acceptOrderForItem());
       return processMap;
+    }
     private static class createTransaction<I extends Iface> extends org.apache.thrift.ProcessFunction<I, createTransaction_args> {
+      }
       protected markOrdersAsReturnedFromStore_result getResult(I iface, markOrdersAsReturnedFromStore_args args) throws org.apache.thrift.TException {
         markOrdersAsReturnedFromStore_result result = new markOrdersAsReturnedFromStore_result();
         try {
-          result.success = iface.markOrdersAsReturnedFromStore(args.providerId, args.orderIds);
+          result.success = iface.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs);
           result.setSuccessIsSet(true);
         } catch (TransactionServiceException ex) {
           result.ex = ex;
+        }
         return result;
         result.success = iface.getReceivedAtStoreOrders(args.storeId);
         return result;
+      }
+    }
+    private static class getOrdersCollectionAtStore<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getOrdersCollectionAtStore_args> {
+      public getOrdersCollectionAtStore() {
+        super("getOrdersCollectionAtStore");
+      }
+      protected getOrdersCollectionAtStore_args getEmptyArgsInstance() {
+        return new getOrdersCollectionAtStore_args();
+      }
+      protected getOrdersCollectionAtStore_result getResult(I iface, getOrdersCollectionAtStore_args args) throws org.apache.thrift.TException {
+        getOrdersCollectionAtStore_result result = new getOrdersCollectionAtStore_result();
+        result.success = iface.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod);
+        return result;
+      }
+    }
     private static class acceptOrderForItem<I extends Iface> extends org.apache.thrift.ProcessFunction<I, acceptOrderForItem_args> {
       public acceptOrderForItem() {
         super("acceptOrderForItem");
+      }
   public static class markOrdersAsReturnedFromStore_args implements org.apache.thrift.TBase<markOrdersAsReturnedFromStore_args, markOrdersAsReturnedFromStore_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("markOrdersAsReturnedFromStore_args");
     private static final org.apache.thrift.protocol.TField PROVIDER_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("providerId", org.apache.thrift.protocol.TType.I64, (short)1);
     private static final org.apache.thrift.protocol.TField ORDER_IDS_FIELD_DESC = new org.apache.thrift.protocol.TField("orderIds", org.apache.thrift.protocol.TType.LIST, (short)2);
+    private static final org.apache.thrift.protocol.TField AWBS_FIELD_DESC = new org.apache.thrift.protocol.TField("awbs", org.apache.thrift.protocol.TType.LIST, (short)3);
     private long providerId; // required
     private List<Long> orderIds; // required
+    private List<String> awbs; // 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 {
       PROVIDER_ID((short)1, "providerId"),
-      ORDER_IDS((short)2, "orderIds");
+      ORDER_IDS((short)2, "orderIds"),
+      AWBS((short)3, "awbs");
       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
       static {
         for (_Fields field : EnumSet.allOf(_Fields.class)) {
         switch(fieldId) {
           case 1: // PROVIDER_ID
             return PROVIDER_ID;
           case 2: // ORDER_IDS
             return ORDER_IDS;
+          case 3: // AWBS
+            return AWBS;
           default:
             return null;
+        }
+      }
       tmpMap.put(_Fields.PROVIDER_ID, new org.apache.thrift.meta_data.FieldMetaData("providerId", org.apache.thrift.TFieldRequirementType.DEFAULT,
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
       tmpMap.put(_Fields.ORDER_IDS, new org.apache.thrift.meta_data.FieldMetaData("orderIds", org.apache.thrift.TFieldRequirementType.DEFAULT,
           new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
               new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))));
+      tmpMap.put(_Fields.AWBS, new org.apache.thrift.meta_data.FieldMetaData("awbs", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+              new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
       org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(markOrdersAsReturnedFromStore_args.class, metaDataMap);
+    }
     public markOrdersAsReturnedFromStore_args() {
+    }
     public markOrdersAsReturnedFromStore_args(
       long providerId,
-      List<Long> orderIds)
+      List<Long> orderIds,
+      List<String> awbs)
+    {
       this();
       this.providerId = providerId;
       setProviderIdIsSet(true);
       this.orderIds = orderIds;
+      this.awbs = awbs;
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
         for (Long other_element : other.orderIds) {
           __this__orderIds.add(other_element);
+        }
         this.orderIds = __this__orderIds;
+      }
+      if (other.isSetAwbs()) {
+        List<String> __this__awbs = new ArrayList<String>();
+        for (String other_element : other.awbs) {
+          __this__awbs.add(other_element);
+        }
+        this.awbs = __this__awbs;
+      }
+    }
     public markOrdersAsReturnedFromStore_args deepCopy() {
       return new markOrdersAsReturnedFromStore_args(this);
+    }
     @Override
     public void clear() {
       setProviderIdIsSet(false);
       this.providerId = 0;
       this.orderIds = null;
+      this.awbs = null;
+    }
     public long getProviderId() {
       return this.providerId;
+    }
       if (!value) {
         this.orderIds = null;
+      }
+    }
+    public int getAwbsSize() {
+      return (this.awbs == null) ? 0 : this.awbs.size();
+    }
+    public java.util.Iterator<String> getAwbsIterator() {
+      return (this.awbs == null) ? null : this.awbs.iterator();
+    }
+    public void addToAwbs(String elem) {
+      if (this.awbs == null) {
+        this.awbs = new ArrayList<String>();
+      }
+      this.awbs.add(elem);
+    }
+    public List<String> getAwbs() {
+      return this.awbs;
+    }
+    public void setAwbs(List<String> awbs) {
+      this.awbs = awbs;
+    }
+    public void unsetAwbs() {
+      this.awbs = null;
+    }
+    /** Returns true if field awbs is set (has been assigned a value) and false otherwise */
+    public boolean isSetAwbs() {
+      return this.awbs != null;
+    }
+    public void setAwbsIsSet(boolean value) {
+      if (!value) {
+        this.awbs = null;
+      }
+    }
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case PROVIDER_ID:
         if (value == null) {
           unsetProviderId();
         } else {
           setOrderIds((List<Long>)value);
+        }
         break;
+      case AWBS:
+        if (value == null) {
+          unsetAwbs();
+        } else {
+          setAwbs((List<String>)value);
+        }
+        break;
+      }
+    }
     public Object getFieldValue(_Fields field) {
       switch (field) {
         return Long.valueOf(getProviderId());
       case ORDER_IDS:
         return getOrderIds();
+      case AWBS:
+        return getAwbs();
+      }
       throw new IllegalStateException();
+    }
     /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
       switch (field) {
       case PROVIDER_ID:
         return isSetProviderId();
       case ORDER_IDS:
         return isSetOrderIds();
+      case AWBS:
+        return isSetAwbs();
+      }
       throw new IllegalStateException();
+    }
     @Override
           return false;
         if (!this.orderIds.equals(that.orderIds))
           return false;
+      }
+      boolean this_present_awbs = true && this.isSetAwbs();
+      boolean that_present_awbs = true && that.isSetAwbs();
+      if (this_present_awbs || that_present_awbs) {
+        if (!(this_present_awbs && that_present_awbs))
+          return false;
+        if (!this.awbs.equals(that.awbs))
+          return false;
+      }
       return true;
+    }
     @Override
     public int hashCode() {
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.orderIds, typedOther.orderIds);
         if (lastComparison != 0) {
           return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetAwbs()).compareTo(typedOther.isSetAwbs());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetAwbs()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.awbs, typedOther.awbs);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
       return 0;
+    }
     public _Fields fieldForId(int fieldId) {
       return _Fields.findByThriftId(fieldId);
+              }
             } 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();
+                this.awbs = new ArrayList<String>(_list143.size);
+                for (int _i144 = 0; _i144 < _list143.size; ++_i144)
+                {
+                  String _elem145; // required
+                  _elem145 = iprot.readString();
+                  this.awbs.add(_elem145);
+                }
+                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();
+      }
       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 _iter143 : this.orderIds)
+          for (long _iter146 : this.orderIds)
+          {
-            oprot.writeI64(_iter143);
+            oprot.writeI64(_iter146);
+          }
+          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)
+          {
+            oprot.writeString(_iter147);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
         sb.append("null");
       } else {
         sb.append(this.orderIds);
+      }
       first = false;
+      if (!first) sb.append(", ");
+      sb.append("awbs:");
+      if (this.awbs == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.awbs);
+      }
+      first = false;
       sb.append(")");
       return sb.toString();
+    }
     public void validate() throws org.apache.thrift.TException {
+            }
             break;
           case 2: // PICKUP_DETAILS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map144 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map148 = iprot.readMapBegin();
-                this.pickupDetails = new HashMap<String,String>(2*_map144.size);
+                this.pickupDetails = new HashMap<String,String>(2*_map148.size);
-                for (int _i145 = 0; _i145 < _map144.size; ++_i145)
+                for (int _i149 = 0; _i149 < _map148.size; ++_i149)
+                {
-                  String _key146; // required
+                  String _key150; // required
-                  String _val147; // required
+                  String _val151; // required
-                  _key146 = iprot.readString();
+                  _key150 = iprot.readString();
-                  _val147 = iprot.readString();
+                  _val151 = iprot.readString();
-                  this.pickupDetails.put(_key146, _val147);
+                  this.pickupDetails.put(_key150, _val151);
+                }
                 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> _iter148 : this.pickupDetails.entrySet())
+          for (Map.Entry<String, String> _iter152 : this.pickupDetails.entrySet())
+          {
-            oprot.writeString(_iter148.getKey());
+            oprot.writeString(_iter152.getKey());
-            oprot.writeString(_iter148.getValue());
+            oprot.writeString(_iter152.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 _list149 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list153 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list149.size);
+                this.success = new ArrayList<Order>(_list153.size);
-                for (int _i150 = 0; _i150 < _list149.size; ++_i150)
+                for (int _i154 = 0; _i154 < _list153.size; ++_i154)
+                {
-                  Order _elem151; // required
+                  Order _elem155; // required
-                  _elem151 = new Order();
+                  _elem155 = new Order();
-                  _elem151.read(iprot);
+                  _elem155.read(iprot);
-                  this.success.add(_elem151);
+                  this.success.add(_elem155);
+                }
                 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 _iter152 : this.success)
+          for (Order _iter156 : this.success)
+          {
-            _iter152.write(oprot);
+            _iter156.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 _map153 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map157 = iprot.readMapBegin();
-                this.deliveredOrders = new HashMap<String,String>(2*_map153.size);
+                this.deliveredOrders = new HashMap<String,String>(2*_map157.size);
-                for (int _i154 = 0; _i154 < _map153.size; ++_i154)
+                for (int _i158 = 0; _i158 < _map157.size; ++_i158)
+                {
-                  String _key155; // required
+                  String _key159; // required
-                  String _val156; // required
+                  String _val160; // required
-                  _key155 = iprot.readString();
+                  _key159 = iprot.readString();
-                  _val156 = iprot.readString();
+                  _val160 = iprot.readString();
-                  this.deliveredOrders.put(_key155, _val156);
+                  this.deliveredOrders.put(_key159, _val160);
+                }
                 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> _iter157 : this.deliveredOrders.entrySet())
+          for (Map.Entry<String, String> _iter161 : this.deliveredOrders.entrySet())
+          {
-            oprot.writeString(_iter157.getKey());
+            oprot.writeString(_iter161.getKey());
-            oprot.writeString(_iter157.getValue());
+            oprot.writeString(_iter161.getValue());
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }
+            }
             break;
           case 2: // RETURNED_ORDERS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map158 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map162 = iprot.readMapBegin();
-                this.returnedOrders = new HashMap<String,String>(2*_map158.size);
+                this.returnedOrders = new HashMap<String,String>(2*_map162.size);
-                for (int _i159 = 0; _i159 < _map158.size; ++_i159)
+                for (int _i163 = 0; _i163 < _map162.size; ++_i163)
+                {
-                  String _key160; // required
+                  String _key164; // required
-                  String _val161; // required
+                  String _val165; // required
-                  _key160 = iprot.readString();
+                  _key164 = iprot.readString();
-                  _val161 = iprot.readString();
+                  _val165 = iprot.readString();
-                  this.returnedOrders.put(_key160, _val161);
+                  this.returnedOrders.put(_key164, _val165);
+                }
                 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> _iter162 : this.returnedOrders.entrySet())
+          for (Map.Entry<String, String> _iter166 : this.returnedOrders.entrySet())
+          {
-            oprot.writeString(_iter162.getKey());
+            oprot.writeString(_iter166.getKey());
-            oprot.writeString(_iter162.getValue());
+            oprot.writeString(_iter166.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 _list163 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list167 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list163.size);
+                this.success = new ArrayList<Order>(_list167.size);
-                for (int _i164 = 0; _i164 < _list163.size; ++_i164)
+                for (int _i168 = 0; _i168 < _list167.size; ++_i168)
+                {
-                  Order _elem165; // required
+                  Order _elem169; // required
-                  _elem165 = new Order();
+                  _elem169 = new Order();
-                  _elem165.read(iprot);
+                  _elem169.read(iprot);
-                  this.success.add(_elem165);
+                  this.success.add(_elem169);
+                }
                 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 _iter166 : this.success)
+          for (Order _iter170 : this.success)
+          {
-            _iter166.write(oprot);
+            _iter170.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 _map167 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map171 = iprot.readMapBegin();
-                this.undeliveredOrders = new HashMap<String,String>(2*_map167.size);
+                this.undeliveredOrders = new HashMap<String,String>(2*_map171.size);
-                for (int _i168 = 0; _i168 < _map167.size; ++_i168)
+                for (int _i172 = 0; _i172 < _map171.size; ++_i172)
+                {
-                  String _key169; // required
+                  String _key173; // required
-                  String _val170; // required
+                  String _val174; // required
-                  _key169 = iprot.readString();
+                  _key173 = iprot.readString();
-                  _val170 = iprot.readString();
+                  _val174 = iprot.readString();
-                  this.undeliveredOrders.put(_key169, _val170);
+                  this.undeliveredOrders.put(_key173, _val174);
+                }
                 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> _iter171 : this.undeliveredOrders.entrySet())
+          for (Map.Entry<String, String> _iter175 : this.undeliveredOrders.entrySet())
+          {
-            oprot.writeString(_iter171.getKey());
+            oprot.writeString(_iter175.getKey());
-            oprot.writeString(_iter171.getValue());
+            oprot.writeString(_iter175.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 _list172 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list176 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list172.size);
+                this.success = new ArrayList<Order>(_list176.size);
-                for (int _i173 = 0; _i173 < _list172.size; ++_i173)
+                for (int _i177 = 0; _i177 < _list176.size; ++_i177)
+                {
-                  Order _elem174; // required
+                  Order _elem178; // required
-                  _elem174 = new Order();
+                  _elem178 = new Order();
-                  _elem174.read(iprot);
+                  _elem178.read(iprot);
-                  this.success.add(_elem174);
+                  this.success.add(_elem178);
+                }
                 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 _iter175 : this.success)
+          for (Order _iter179 : this.success)
+          {
-            _iter175.write(oprot);
+            _iter179.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 _map176 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map180 = iprot.readMapBegin();
-                this.local_connected_orders = new HashMap<String,String>(2*_map176.size);
+                this.local_connected_orders = new HashMap<String,String>(2*_map180.size);
-                for (int _i177 = 0; _i177 < _map176.size; ++_i177)
+                for (int _i181 = 0; _i181 < _map180.size; ++_i181)
+                {
-                  String _key178; // required
+                  String _key182; // required
-                  String _val179; // required
+                  String _val183; // required
-                  _key178 = iprot.readString();
+                  _key182 = iprot.readString();
-                  _val179 = iprot.readString();
+                  _val183 = iprot.readString();
-                  this.local_connected_orders.put(_key178, _val179);
+                  this.local_connected_orders.put(_key182, _val183);
+                }
                 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> _iter180 : this.local_connected_orders.entrySet())
+          for (Map.Entry<String, String> _iter184 : this.local_connected_orders.entrySet())
+          {
-            oprot.writeString(_iter180.getKey());
+            oprot.writeString(_iter184.getKey());
-            oprot.writeString(_iter180.getValue());
+            oprot.writeString(_iter184.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 _list181 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list185 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list181.size);
+                this.success = new ArrayList<Order>(_list185.size);
-                for (int _i182 = 0; _i182 < _list181.size; ++_i182)
+                for (int _i186 = 0; _i186 < _list185.size; ++_i186)
+                {
-                  Order _elem183; // required
+                  Order _elem187; // required
-                  _elem183 = new Order();
+                  _elem187 = new Order();
-                  _elem183.read(iprot);
+                  _elem187.read(iprot);
-                  this.success.add(_elem183);
+                  this.success.add(_elem187);
+                }
                 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 _iter184 : this.success)
+          for (Order _iter188 : this.success)
+          {
-            _iter184.write(oprot);
+            _iter188.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 _map185 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map189 = iprot.readMapBegin();
-                this.destination_city_reached_orders = new HashMap<String,String>(2*_map185.size);
+                this.destination_city_reached_orders = new HashMap<String,String>(2*_map189.size);
-                for (int _i186 = 0; _i186 < _map185.size; ++_i186)
+                for (int _i190 = 0; _i190 < _map189.size; ++_i190)
+                {
-                  String _key187; // required
+                  String _key191; // required
-                  String _val188; // required
+                  String _val192; // required
-                  _key187 = iprot.readString();
+                  _key191 = iprot.readString();
-                  _val188 = iprot.readString();
+                  _val192 = iprot.readString();
-                  this.destination_city_reached_orders.put(_key187, _val188);
+                  this.destination_city_reached_orders.put(_key191, _val192);
+                }
                 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> _iter189 : this.destination_city_reached_orders.entrySet())
+          for (Map.Entry<String, String> _iter193 : this.destination_city_reached_orders.entrySet())
+          {
-            oprot.writeString(_iter189.getKey());
+            oprot.writeString(_iter193.getKey());
-            oprot.writeString(_iter189.getValue());
+            oprot.writeString(_iter193.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 _map190 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map194 = iprot.readMapBegin();
-                this.first_atdl_orders = new HashMap<String,String>(2*_map190.size);
+                this.first_atdl_orders = new HashMap<String,String>(2*_map194.size);
-                for (int _i191 = 0; _i191 < _map190.size; ++_i191)
+                for (int _i195 = 0; _i195 < _map194.size; ++_i195)
+                {
-                  String _key192; // required
+                  String _key196; // required
-                  String _val193; // required
+                  String _val197; // required
-                  _key192 = iprot.readString();
+                  _key196 = iprot.readString();
-                  _val193 = iprot.readString();
+                  _val197 = iprot.readString();
-                  this.first_atdl_orders.put(_key192, _val193);
+                  this.first_atdl_orders.put(_key196, _val197);
+                }
                 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> _iter194 : this.first_atdl_orders.entrySet())
+          for (Map.Entry<String, String> _iter198 : this.first_atdl_orders.entrySet())
+          {
-            oprot.writeString(_iter194.getKey());
+            oprot.writeString(_iter198.getKey());
-            oprot.writeString(_iter194.getValue());
+            oprot.writeString(_iter198.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 _list195 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list199 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list195.size);
+                this.success = new ArrayList<Order>(_list199.size);
-                for (int _i196 = 0; _i196 < _list195.size; ++_i196)
+                for (int _i200 = 0; _i200 < _list199.size; ++_i200)
+                {
-                  Order _elem197; // required
+                  Order _elem201; // required
-                  _elem197 = new Order();
+                  _elem201 = new Order();
-                  _elem197.read(iprot);
+                  _elem201.read(iprot);
-                  this.success.add(_elem197);
+                  this.success.add(_elem201);
+                }
                 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 _iter198 : this.success)
+          for (Order _iter202 : this.success)
+          {
-            _iter198.write(oprot);
+            _iter202.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 _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();
+      }
+            }
             break;
           case 2: // PICKUP_DETAILS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map203 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map207 = iprot.readMapBegin();
-                this.pickupDetails = new HashMap<String,String>(2*_map203.size);
+                this.pickupDetails = new HashMap<String,String>(2*_map207.size);
-                for (int _i204 = 0; _i204 < _map203.size; ++_i204)
+                for (int _i208 = 0; _i208 < _map207.size; ++_i208)
+                {
-                  String _key205; // required
+                  String _key209; // required
-                  String _val206; // required
+                  String _val210; // required
-                  _key205 = iprot.readString();
+                  _key209 = iprot.readString();
-                  _val206 = iprot.readString();
+                  _val210 = iprot.readString();
-                  this.pickupDetails.put(_key205, _val206);
+                  this.pickupDetails.put(_key209, _val210);
+                }
                 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> _iter207 : this.pickupDetails.entrySet())
+          for (Map.Entry<String, String> _iter211 : this.pickupDetails.entrySet())
+          {
-            oprot.writeString(_iter207.getKey());
+            oprot.writeString(_iter211.getKey());
-            oprot.writeString(_iter207.getValue());
+            oprot.writeString(_iter211.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 _list208 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list212 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list208.size);
+                this.success = new ArrayList<Order>(_list212.size);
-                for (int _i209 = 0; _i209 < _list208.size; ++_i209)
+                for (int _i213 = 0; _i213 < _list212.size; ++_i213)
+                {
-                  Order _elem210; // required
+                  Order _elem214; // required
-                  _elem210 = new Order();
+                  _elem214 = new Order();
-                  _elem210.read(iprot);
+                  _elem214.read(iprot);
-                  this.success.add(_elem210);
+                  this.success.add(_elem214);
+                }
                 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 _iter211 : this.success)
+          for (Order _iter215 : this.success)
+          {
-            _iter211.write(oprot);
+            _iter215.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 _map212 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map216 = iprot.readMapBegin();
-                this.pickupDetails = new HashMap<String,String>(2*_map212.size);
+                this.pickupDetails = new HashMap<String,String>(2*_map216.size);
-                for (int _i213 = 0; _i213 < _map212.size; ++_i213)
+                for (int _i217 = 0; _i217 < _map216.size; ++_i217)
+                {
-                  String _key214; // required
+                  String _key218; // required
-                  String _val215; // required
+                  String _val219; // required
-                  _key214 = iprot.readString();
+                  _key218 = iprot.readString();
-                  _val215 = iprot.readString();
+                  _val219 = iprot.readString();
-                  this.pickupDetails.put(_key214, _val215);
+                  this.pickupDetails.put(_key218, _val219);
+                }
                 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> _iter216 : this.pickupDetails.entrySet())
+          for (Map.Entry<String, String> _iter220 : this.pickupDetails.entrySet())
+          {
-            oprot.writeString(_iter216.getKey());
+            oprot.writeString(_iter220.getKey());
-            oprot.writeString(_iter216.getValue());
+            oprot.writeString(_iter220.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 _list217 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list221 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list217.size);
+                this.success = new ArrayList<Order>(_list221.size);
-                for (int _i218 = 0; _i218 < _list217.size; ++_i218)
+                for (int _i222 = 0; _i222 < _list221.size; ++_i222)
+                {
-                  Order _elem219; // required
+                  Order _elem223; // required
-                  _elem219 = new Order();
+                  _elem223 = new Order();
-                  _elem219.read(iprot);
+                  _elem223.read(iprot);
-                  this.success.add(_elem219);
+                  this.success.add(_elem223);
+                }
                 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 _iter220 : this.success)
+          for (Order _iter224 : this.success)
+          {
-            _iter220.write(oprot);
+            _iter224.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 _list221 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list225 = iprot.readListBegin();
-                this.success = new ArrayList<ReturnOrder>(_list221.size);
+                this.success = new ArrayList<ReturnOrder>(_list225.size);
-                for (int _i222 = 0; _i222 < _list221.size; ++_i222)
+                for (int _i226 = 0; _i226 < _list225.size; ++_i226)
+                {
-                  ReturnOrder _elem223; // required
+                  ReturnOrder _elem227; // required
-                  _elem223 = new ReturnOrder();
+                  _elem227 = new ReturnOrder();
-                  _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 (ReturnOrder _iter224 : this.success)
+          for (ReturnOrder _iter228 : this.success)
+          {
-            _iter224.write(oprot);
+            _iter228.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 _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 1: // COLLECTED_AMOUNT_MAP
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map229 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map233 = iprot.readMapBegin();
-                this.collectedAmountMap = new HashMap<String,Double>(2*_map229.size);
+                this.collectedAmountMap = new HashMap<String,Double>(2*_map233.size);
-                for (int _i230 = 0; _i230 < _map229.size; ++_i230)
+                for (int _i234 = 0; _i234 < _map233.size; ++_i234)
+                {
-                  String _key231; // required
+                  String _key235; // required
-                  double _val232; // required
+                  double _val236; // required
-                  _key231 = iprot.readString();
+                  _key235 = iprot.readString();
-                  _val232 = iprot.readDouble();
+                  _val236 = iprot.readDouble();
-                  this.collectedAmountMap.put(_key231, _val232);
+                  this.collectedAmountMap.put(_key235, _val236);
+                }
                 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> _iter233 : this.collectedAmountMap.entrySet())
+          for (Map.Entry<String, Double> _iter237 : this.collectedAmountMap.entrySet())
+          {
-            oprot.writeString(_iter233.getKey());
+            oprot.writeString(_iter237.getKey());
-            oprot.writeDouble(_iter233.getValue());
+            oprot.writeDouble(_iter237.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 _map234 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map238 = iprot.readMapBegin();
-                this.success = new HashMap<String,String>(2*_map234.size);
+                this.success = new HashMap<String,String>(2*_map238.size);
-                for (int _i235 = 0; _i235 < _map234.size; ++_i235)
+                for (int _i239 = 0; _i239 < _map238.size; ++_i239)
+                {
-                  String _key236; // required
+                  String _key240; // required
-                  String _val237; // required
+                  String _val241; // required
-                  _key236 = iprot.readString();
+                  _key240 = iprot.readString();
-                  _val237 = iprot.readString();
+                  _val241 = iprot.readString();
-                  this.success.put(_key236, _val237);
+                  this.success.put(_key240, _val241);
+                }
                 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> _iter238 : this.success.entrySet())
+          for (Map.Entry<String, String> _iter242 : this.success.entrySet())
+          {
-            oprot.writeString(_iter238.getKey());
+            oprot.writeString(_iter242.getKey());
-            oprot.writeString(_iter238.getValue());
+            oprot.writeString(_iter242.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 _list239 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list243 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list239.size);
+                this.success = new ArrayList<Long>(_list243.size);
-                for (int _i240 = 0; _i240 < _list239.size; ++_i240)
+                for (int _i244 = 0; _i244 < _list243.size; ++_i244)
+                {
-                  long _elem241; // required
+                  long _elem245; // required
-                  _elem241 = iprot.readI64();
+                  _elem245 = iprot.readI64();
-                  this.success.add(_elem241);
+                  this.success.add(_elem245);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
-          for (long _iter242 : this.success)
+          for (long _iter246 : this.success)
+          {
-            oprot.writeI64(_iter242);
+            oprot.writeI64(_iter246);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map243 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map247 = iprot.readMapBegin();
-                this.success = new HashMap<Long,Long>(2*_map243.size);
+                this.success = new HashMap<Long,Long>(2*_map247.size);
-                for (int _i244 = 0; _i244 < _map243.size; ++_i244)
+                for (int _i248 = 0; _i248 < _map247.size; ++_i248)
+                {
-                  long _key245; // required
+                  long _key249; // required
-                  long _val246; // required
+                  long _val250; // required
-                  _key245 = iprot.readI64();
+                  _key249 = iprot.readI64();
-                  _val246 = iprot.readI64();
+                  _val250 = iprot.readI64();
-                  this.success.put(_key245, _val246);
+                  this.success.put(_key249, _val250);
+                }
                 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> _iter247 : this.success.entrySet())
+          for (Map.Entry<Long, Long> _iter251 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter247.getKey());
+            oprot.writeI64(_iter251.getKey());
-            oprot.writeI64(_iter247.getValue());
+            oprot.writeI64(_iter251.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 _list248 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list252 = iprot.readListBegin();
-                this.itemIds = new ArrayList<Long>(_list248.size);
+                this.itemIds = new ArrayList<Long>(_list252.size);
-                for (int _i249 = 0; _i249 < _list248.size; ++_i249)
+                for (int _i253 = 0; _i253 < _list252.size; ++_i253)
+                {
-                  long _elem250; // required
+                  long _elem254; // required
-                  _elem250 = iprot.readI64();
+                  _elem254 = iprot.readI64();
-                  this.itemIds.add(_elem250);
+                  this.itemIds.add(_elem254);
+                }
                 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 _iter251 : this.itemIds)
+          for (long _iter255 : this.itemIds)
+          {
-            oprot.writeI64(_iter251);
+            oprot.writeI64(_iter255);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list252 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list256 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list252.size);
+                this.success = new ArrayList<Order>(_list256.size);
-                for (int _i253 = 0; _i253 < _list252.size; ++_i253)
+                for (int _i257 = 0; _i257 < _list256.size; ++_i257)
+                {
-                  Order _elem254; // required
+                  Order _elem258; // required
-                  _elem254 = new Order();
+                  _elem258 = new Order();
-                  _elem254.read(iprot);
+                  _elem258.read(iprot);
-                  this.success.add(_elem254);
+                  this.success.add(_elem258);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Order _iter255 : this.success)
+          for (Order _iter259 : this.success)
+          {
-            _iter255.write(oprot);
+            _iter259.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 _map256 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map260 = iprot.readMapBegin();
-                this.success = new HashMap<Integer,TimeoutSummary>(2*_map256.size);
+                this.success = new HashMap<Integer,TimeoutSummary>(2*_map260.size);
-                for (int _i257 = 0; _i257 < _map256.size; ++_i257)
+                for (int _i261 = 0; _i261 < _map260.size; ++_i261)
+                {
-                  int _key258; // required
+                  int _key262; // required
-                  TimeoutSummary _val259; // required
+                  TimeoutSummary _val263; // required
-                  _key258 = iprot.readI32();
+                  _key262 = iprot.readI32();
-                  _val259 = new TimeoutSummary();
+                  _val263 = new TimeoutSummary();
-                  _val259.read(iprot);
+                  _val263.read(iprot);
-                  this.success.put(_key258, _val259);
+                  this.success.put(_key262, _val263);
+                }
                 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> _iter260 : this.success.entrySet())
+          for (Map.Entry<Integer, TimeoutSummary> _iter264 : this.success.entrySet())
+          {
-            oprot.writeI32(_iter260.getKey());
+            oprot.writeI32(_iter264.getKey());
-            _iter260.getValue().write(oprot);
+            _iter264.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 _list261 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list265 = iprot.readListBegin();
-                this.order_status_list = new ArrayList<OrderStatus>(_list261.size);
+                this.order_status_list = new ArrayList<OrderStatus>(_list265.size);
-                for (int _i262 = 0; _i262 < _list261.size; ++_i262)
+                for (int _i266 = 0; _i266 < _list265.size; ++_i266)
+                {
-                  OrderStatus _elem263; // required
+                  OrderStatus _elem267; // required
-                  _elem263 = OrderStatus.findByValue(iprot.readI32());
+                  _elem267 = OrderStatus.findByValue(iprot.readI32());
-                  this.order_status_list.add(_elem263);
+                  this.order_status_list.add(_elem267);
+                }
                 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 _iter264 : this.order_status_list)
+          for (OrderStatus _iter268 : this.order_status_list)
+          {
-            oprot.writeI32(_iter264.getValue());
+            oprot.writeI32(_iter268.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 _list265 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list269 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list265.size);
+                this.success = new ArrayList<Order>(_list269.size);
-                for (int _i266 = 0; _i266 < _list265.size; ++_i266)
+                for (int _i270 = 0; _i270 < _list269.size; ++_i270)
+                {
-                  Order _elem267; // required
+                  Order _elem271; // required
-                  _elem267 = new Order();
+                  _elem271 = new Order();
-                  _elem267.read(iprot);
+                  _elem271.read(iprot);
-                  this.success.add(_elem267);
+                  this.success.add(_elem271);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Order _iter268 : this.success)
+          for (Order _iter272 : this.success)
+          {
-            _iter268.write(oprot);
+            _iter272.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 _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 1: // MAP_AWBAND_AMOUNT
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map281 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map285 = iprot.readMapBegin();
-                this.mapAWBAndAmount = new HashMap<Long,Double>(2*_map281.size);
+                this.mapAWBAndAmount = new HashMap<Long,Double>(2*_map285.size);
-                for (int _i282 = 0; _i282 < _map281.size; ++_i282)
+                for (int _i286 = 0; _i286 < _map285.size; ++_i286)
+                {
-                  long _key283; // required
+                  long _key287; // required
-                  double _val284; // required
+                  double _val288; // required
-                  _key283 = iprot.readI64();
+                  _key287 = iprot.readI64();
-                  _val284 = iprot.readDouble();
+                  _val288 = iprot.readDouble();
-                  this.mapAWBAndAmount.put(_key283, _val284);
+                  this.mapAWBAndAmount.put(_key287, _val288);
+                }
                 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> _iter285 : this.mapAWBAndAmount.entrySet())
+          for (Map.Entry<Long, Double> _iter289 : this.mapAWBAndAmount.entrySet())
+          {
-            oprot.writeI64(_iter285.getKey());
+            oprot.writeI64(_iter289.getKey());
-            oprot.writeDouble(_iter285.getValue());
+            oprot.writeDouble(_iter289.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 _map286 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map290 = iprot.readMapBegin();
-                this.success = new HashMap<Long,String>(2*_map286.size);
+                this.success = new HashMap<Long,String>(2*_map290.size);
-                for (int _i287 = 0; _i287 < _map286.size; ++_i287)
+                for (int _i291 = 0; _i291 < _map290.size; ++_i291)
+                {
-                  long _key288; // required
+                  long _key292; // required
-                  String _val289; // required
+                  String _val293; // required
-                  _key288 = iprot.readI64();
+                  _key292 = iprot.readI64();
-                  _val289 = iprot.readString();
+                  _val293 = iprot.readString();
-                  this.success.put(_key288, _val289);
+                  this.success.put(_key292, _val293);
+                }
                 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> _iter290 : this.success.entrySet())
+          for (Map.Entry<Long, String> _iter294 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter290.getKey());
+            oprot.writeI64(_iter294.getKey());
-            oprot.writeString(_iter290.getValue());
+            oprot.writeString(_iter294.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 _list291 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list295 = iprot.readListBegin();
-                this.success = new ArrayList<PaymentSettlement>(_list291.size);
+                this.success = new ArrayList<PaymentSettlement>(_list295.size);
-                for (int _i292 = 0; _i292 < _list291.size; ++_i292)
+                for (int _i296 = 0; _i296 < _list295.size; ++_i296)
+                {
-                  PaymentSettlement _elem293; // required
+                  PaymentSettlement _elem297; // required
-                  _elem293 = new PaymentSettlement();
+                  _elem297 = new PaymentSettlement();
-                  _elem293.read(iprot);
+                  _elem297.read(iprot);
-                  this.success.add(_elem293);
+                  this.success.add(_elem297);
+                }
                 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 _iter294 : this.success)
+          for (PaymentSettlement _iter298 : this.success)
+          {
-            _iter294.write(oprot);
+            _iter298.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 _list295 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list299 = iprot.readListBegin();
-                this.orderIds = new ArrayList<Long>(_list295.size);
+                this.orderIds = new ArrayList<Long>(_list299.size);
-                for (int _i296 = 0; _i296 < _list295.size; ++_i296)
+                for (int _i300 = 0; _i300 < _list299.size; ++_i300)
+                {
-                  long _elem297; // required
+                  long _elem301; // required
-                  _elem297 = iprot.readI64();
+                  _elem301 = iprot.readI64();
-                  this.orderIds.add(_elem297);
+                  this.orderIds.add(_elem301);
+                }
                 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 _iter298 : this.orderIds)
+          for (long _iter302 : this.orderIds)
+          {
-            oprot.writeI64(_iter298);
+            oprot.writeI64(_iter302);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             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.success = new ArrayList<Long>(_list299.size);
+                this.success = 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.success.add(_elem301);
+                  this.success.add(_elem305);
+                }
                 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 _iter302 : this.success)
+          for (long _iter306 : this.success)
+          {
-            oprot.writeI64(_iter302);
+            oprot.writeI64(_iter306);
+          }
           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 _list303 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list307 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list303.size);
+                this.success = new ArrayList<Order>(_list307.size);
-                for (int _i304 = 0; _i304 < _list303.size; ++_i304)
+                for (int _i308 = 0; _i308 < _list307.size; ++_i308)
+                {
-                  Order _elem305; // required
+                  Order _elem309; // required
-                  _elem305 = new Order();
+                  _elem309 = new Order();
-                  _elem305.read(iprot);
+                  _elem309.read(iprot);
-                  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.STRUCT, this.success.size()));
-          for (Order _iter306 : this.success)
+          for (Order _iter310 : this.success)
+          {
-            _iter306.write(oprot);
+            _iter310.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 _map307 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map311 = iprot.readMapBegin();
-                this.success = new HashMap<Long,Long>(2*_map307.size);
+                this.success = new HashMap<Long,Long>(2*_map311.size);
-                for (int _i308 = 0; _i308 < _map307.size; ++_i308)
+                for (int _i312 = 0; _i312 < _map311.size; ++_i312)
+                {
-                  long _key309; // required
+                  long _key313; // required
-                  long _val310; // required
+                  long _val314; // required
-                  _key309 = iprot.readI64();
+                  _key313 = iprot.readI64();
-                  _val310 = iprot.readI64();
+                  _val314 = iprot.readI64();
-                  this.success.put(_key309, _val310);
+                  this.success.put(_key313, _val314);
+                }
                 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> _iter311 : this.success.entrySet())
+          for (Map.Entry<Long, Long> _iter315 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter311.getKey());
+            oprot.writeI64(_iter315.getKey());
-            oprot.writeI64(_iter311.getValue());
+            oprot.writeI64(_iter315.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 _list312 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list316 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list312.size);
+                this.success = new ArrayList<Long>(_list316.size);
-                for (int _i313 = 0; _i313 < _list312.size; ++_i313)
+                for (int _i317 = 0; _i317 < _list316.size; ++_i317)
+                {
-                  long _elem314; // required
+                  long _elem318; // required
-                  _elem314 = iprot.readI64();
+                  _elem318 = iprot.readI64();
-                  this.success.add(_elem314);
+                  this.success.add(_elem318);
+                }
                 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 _iter315 : this.success)
+          for (long _iter319 : this.success)
+          {
-            oprot.writeI64(_iter315);
+            oprot.writeI64(_iter319);
+          }
           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 _list316 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list320 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list316.size);
+                this.success = new ArrayList<Order>(_list320.size);
-                for (int _i317 = 0; _i317 < _list316.size; ++_i317)
+                for (int _i321 = 0; _i321 < _list320.size; ++_i321)
+                {
-                  Order _elem318; // required
+                  Order _elem322; // required
-                  _elem318 = new Order();
+                  _elem322 = new Order();
-                  _elem318.read(iprot);
+                  _elem322.read(iprot);
-                  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.STRUCT, this.success.size()));
-          for (Order _iter319 : this.success)
+          for (Order _iter323 : this.success)
+          {
-            _iter319.write(oprot);
+            _iter323.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 _list320 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list324 = iprot.readListBegin();
-                this.success = new ArrayList<CODVerificationAgent>(_list320.size);
+                this.success = new ArrayList<CODVerificationAgent>(_list324.size);
-                for (int _i321 = 0; _i321 < _list320.size; ++_i321)
+                for (int _i325 = 0; _i325 < _list324.size; ++_i325)
+                {
-                  CODVerificationAgent _elem322; // required
+                  CODVerificationAgent _elem326; // required
-                  _elem322 = new CODVerificationAgent();
+                  _elem326 = new CODVerificationAgent();
-                  _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 (CODVerificationAgent _iter323 : this.success)
+          for (CODVerificationAgent _iter327 : this.success)
+          {
-            _iter323.write(oprot);
+            _iter327.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 _list324 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list328 = iprot.readListBegin();
-                this.success = new ArrayList<Attribute>(_list324.size);
+                this.success = new ArrayList<Attribute>(_list328.size);
-                for (int _i325 = 0; _i325 < _list324.size; ++_i325)
+                for (int _i329 = 0; _i329 < _list328.size; ++_i329)
+                {
-                  Attribute _elem326; // required
+                  Attribute _elem330; // required
-                  _elem326 = new Attribute();
+                  _elem330 = new Attribute();
-                  _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 (Attribute _iter327 : this.success)
+          for (Attribute _iter331 : this.success)
+          {
-            _iter327.write(oprot);
+            _iter331.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+            }
             break;
           case -1: // ATTRIBUTES
             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.attributes = new ArrayList<Attribute>(_list328.size);
+                this.attributes = 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.attributes.add(_elem330);
+                  this.attributes.add(_elem334);
+                }
                 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 _iter331 : this.attributes)
+          for (Attribute _iter335 : this.attributes)
+          {
-            _iter331.write(oprot);
+            _iter335.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 _list332 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list336 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list332.size);
+                this.success = new ArrayList<Order>(_list336.size);
-                for (int _i333 = 0; _i333 < _list332.size; ++_i333)
+                for (int _i337 = 0; _i337 < _list336.size; ++_i337)
+                {
-                  Order _elem334; // required
+                  Order _elem338; // required
-                  _elem334 = new Order();
+                  _elem338 = new Order();
-                  _elem334.read(iprot);
+                  _elem338.read(iprot);
-                  this.success.add(_elem334);
+                  this.success.add(_elem338);
+                }
                 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 _iter335 : this.success)
+          for (Order _iter339 : this.success)
+          {
-            _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();
+      }
       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 getOrdersCollectionAtStore_args implements org.apache.thrift.TBase<getOrdersCollectionAtStore_args, getOrdersCollectionAtStore_args._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getOrdersCollectionAtStore_args");
+    private static final org.apache.thrift.protocol.TField STORE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("storeId", org.apache.thrift.protocol.TType.I64, (short)1);
+    private static final org.apache.thrift.protocol.TField FROM_DATE_FIELD_DESC = new org.apache.thrift.protocol.TField("fromDate", org.apache.thrift.protocol.TType.I64, (short)2);
+    private static final org.apache.thrift.protocol.TField TO_DATE_FIELD_DESC = new org.apache.thrift.protocol.TField("toDate", org.apache.thrift.protocol.TType.I64, (short)3);
+    private static final org.apache.thrift.protocol.TField ONLY_COD_FIELD_DESC = new org.apache.thrift.protocol.TField("onlyCod", org.apache.thrift.protocol.TType.BOOL, (short)4);
+    private long storeId; // required
+    private long fromDate; // required
+    private long toDate; // required
+    private boolean onlyCod; // 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 {
+      STORE_ID((short)1, "storeId"),
+      FROM_DATE((short)2, "fromDate"),
+      TO_DATE((short)3, "toDate"),
+      ONLY_COD((short)4, "onlyCod");
+      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: // STORE_ID
+            return STORE_ID;
+          case 2: // FROM_DATE
+            return FROM_DATE;
+          case 3: // TO_DATE
+            return TO_DATE;
+          case 4: // ONLY_COD
+            return ONLY_COD;
+          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 __STOREID_ISSET_ID = 0;
+    private static final int __FROMDATE_ISSET_ID = 1;
+    private static final int __TODATE_ISSET_ID = 2;
+    private static final int __ONLYCOD_ISSET_ID = 3;
+    private BitSet __isset_bit_vector = new BitSet(4);
+    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+    static {
+      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+      tmpMap.put(_Fields.STORE_ID, new org.apache.thrift.meta_data.FieldMetaData("storeId", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      tmpMap.put(_Fields.FROM_DATE, new org.apache.thrift.meta_data.FieldMetaData("fromDate", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      tmpMap.put(_Fields.TO_DATE, new org.apache.thrift.meta_data.FieldMetaData("toDate", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      tmpMap.put(_Fields.ONLY_COD, new org.apache.thrift.meta_data.FieldMetaData("onlyCod", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getOrdersCollectionAtStore_args.class, metaDataMap);
+    }
+    public getOrdersCollectionAtStore_args() {
+    }
+    public getOrdersCollectionAtStore_args(
+      long storeId,
+      long fromDate,
+      long toDate,
+      boolean onlyCod)
+    {
+      this();
+      this.storeId = storeId;
+      setStoreIdIsSet(true);
+      this.fromDate = fromDate;
+      setFromDateIsSet(true);
+      this.toDate = toDate;
+      setToDateIsSet(true);
+      this.onlyCod = onlyCod;
+      setOnlyCodIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getOrdersCollectionAtStore_args(getOrdersCollectionAtStore_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.storeId = other.storeId;
+      this.fromDate = other.fromDate;
+      this.toDate = other.toDate;
+      this.onlyCod = other.onlyCod;
+    }
+    public getOrdersCollectionAtStore_args deepCopy() {
+      return new getOrdersCollectionAtStore_args(this);
+    }
+    @Override
+    public void clear() {
+      setStoreIdIsSet(false);
+      this.storeId = 0;
+      setFromDateIsSet(false);
+      this.fromDate = 0;
+      setToDateIsSet(false);
+      this.toDate = 0;
+      setOnlyCodIsSet(false);
+      this.onlyCod = false;
+    }
+    public long getStoreId() {
+      return this.storeId;
+    }
+    public void setStoreId(long storeId) {
+      this.storeId = storeId;
+      setStoreIdIsSet(true);
+    }
+    public void unsetStoreId() {
+      __isset_bit_vector.clear(__STOREID_ISSET_ID);
+    }
+    /** Returns true if field storeId is set (has been assigned a value) and false otherwise */
+    public boolean isSetStoreId() {
+      return __isset_bit_vector.get(__STOREID_ISSET_ID);
+    }
+    public void setStoreIdIsSet(boolean value) {
+      __isset_bit_vector.set(__STOREID_ISSET_ID, value);
+    }
+    public long getFromDate() {
+      return this.fromDate;
+    }
+    public void setFromDate(long fromDate) {
+      this.fromDate = fromDate;
+      setFromDateIsSet(true);
+    }
+    public void unsetFromDate() {
+      __isset_bit_vector.clear(__FROMDATE_ISSET_ID);
+    }
+    /** Returns true if field fromDate is set (has been assigned a value) and false otherwise */
+    public boolean isSetFromDate() {
+      return __isset_bit_vector.get(__FROMDATE_ISSET_ID);
+    }
+    public void setFromDateIsSet(boolean value) {
+      __isset_bit_vector.set(__FROMDATE_ISSET_ID, value);
+    }
+    public long getToDate() {
+      return this.toDate;
+    }
+    public void setToDate(long toDate) {
+      this.toDate = toDate;
+      setToDateIsSet(true);
+    }
+    public void unsetToDate() {
+      __isset_bit_vector.clear(__TODATE_ISSET_ID);
+    }
+    /** Returns true if field toDate is set (has been assigned a value) and false otherwise */
+    public boolean isSetToDate() {
+      return __isset_bit_vector.get(__TODATE_ISSET_ID);
+    }
+    public void setToDateIsSet(boolean value) {
+      __isset_bit_vector.set(__TODATE_ISSET_ID, value);
+    }
+    public boolean isOnlyCod() {
+      return this.onlyCod;
+    }
+    public void setOnlyCod(boolean onlyCod) {
+      this.onlyCod = onlyCod;
+      setOnlyCodIsSet(true);
+    }
+    public void unsetOnlyCod() {
+      __isset_bit_vector.clear(__ONLYCOD_ISSET_ID);
+    }
+    /** Returns true if field onlyCod is set (has been assigned a value) and false otherwise */
+    public boolean isSetOnlyCod() {
+      return __isset_bit_vector.get(__ONLYCOD_ISSET_ID);
+    }
+    public void setOnlyCodIsSet(boolean value) {
+      __isset_bit_vector.set(__ONLYCOD_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case STORE_ID:
+        if (value == null) {
+          unsetStoreId();
+        } else {
+          setStoreId((Long)value);
+        }
+        break;
+      case FROM_DATE:
+        if (value == null) {
+          unsetFromDate();
+        } else {
+          setFromDate((Long)value);
+        }
+        break;
+      case TO_DATE:
+        if (value == null) {
+          unsetToDate();
+        } else {
+          setToDate((Long)value);
+        }
+        break;
+      case ONLY_COD:
+        if (value == null) {
+          unsetOnlyCod();
+        } else {
+          setOnlyCod((Boolean)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case STORE_ID:
+        return Long.valueOf(getStoreId());
+      case FROM_DATE:
+        return Long.valueOf(getFromDate());
+      case TO_DATE:
+        return Long.valueOf(getToDate());
+      case ONLY_COD:
+        return Boolean.valueOf(isOnlyCod());
+      }
+      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 STORE_ID:
+        return isSetStoreId();
+      case FROM_DATE:
+        return isSetFromDate();
+      case TO_DATE:
+        return isSetToDate();
+      case ONLY_COD:
+        return isSetOnlyCod();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof getOrdersCollectionAtStore_args)
+        return this.equals((getOrdersCollectionAtStore_args)that);
+      return false;
+    }
+    public boolean equals(getOrdersCollectionAtStore_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_storeId = true;
+      boolean that_present_storeId = true;
+      if (this_present_storeId || that_present_storeId) {
+        if (!(this_present_storeId && that_present_storeId))
+          return false;
+        if (this.storeId != that.storeId)
+          return false;
+      }
+      boolean this_present_fromDate = true;
+      boolean that_present_fromDate = true;
+      if (this_present_fromDate || that_present_fromDate) {
+        if (!(this_present_fromDate && that_present_fromDate))
+          return false;
+        if (this.fromDate != that.fromDate)
+          return false;
+      }
+      boolean this_present_toDate = true;
+      boolean that_present_toDate = true;
+      if (this_present_toDate || that_present_toDate) {
+        if (!(this_present_toDate && that_present_toDate))
+          return false;
+        if (this.toDate != that.toDate)
+          return false;
+      }
+      boolean this_present_onlyCod = true;
+      boolean that_present_onlyCod = true;
+      if (this_present_onlyCod || that_present_onlyCod) {
+        if (!(this_present_onlyCod && that_present_onlyCod))
+          return false;
+        if (this.onlyCod != that.onlyCod)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getOrdersCollectionAtStore_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getOrdersCollectionAtStore_args typedOther = (getOrdersCollectionAtStore_args)other;
+      lastComparison = Boolean.valueOf(isSetStoreId()).compareTo(typedOther.isSetStoreId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetStoreId()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.storeId, typedOther.storeId);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetFromDate()).compareTo(typedOther.isSetFromDate());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetFromDate()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fromDate, typedOther.fromDate);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetToDate()).compareTo(typedOther.isSetToDate());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetToDate()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.toDate, typedOther.toDate);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetOnlyCod()).compareTo(typedOther.isSetOnlyCod());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetOnlyCod()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.onlyCod, typedOther.onlyCod);
+        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: // STORE_ID
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.storeId = iprot.readI64();
+              setStoreIdIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 2: // FROM_DATE
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.fromDate = iprot.readI64();
+              setFromDateIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 3: // TO_DATE
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.toDate = iprot.readI64();
+              setToDateIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 4: // ONLY_COD
+            if (field.type == org.apache.thrift.protocol.TType.BOOL) {
+              this.onlyCod = iprot.readBool();
+              setOnlyCodIsSet(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(STORE_ID_FIELD_DESC);
+      oprot.writeI64(this.storeId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(FROM_DATE_FIELD_DESC);
+      oprot.writeI64(this.fromDate);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(TO_DATE_FIELD_DESC);
+      oprot.writeI64(this.toDate);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(ONLY_COD_FIELD_DESC);
+      oprot.writeBool(this.onlyCod);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getOrdersCollectionAtStore_args(");
+      boolean first = true;
+      sb.append("storeId:");
+      sb.append(this.storeId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("fromDate:");
+      sb.append(this.fromDate);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("toDate:");
+      sb.append(this.toDate);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("onlyCod:");
+      sb.append(this.onlyCod);
+      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 getOrdersCollectionAtStore_result implements org.apache.thrift.TBase<getOrdersCollectionAtStore_result, getOrdersCollectionAtStore_result._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getOrdersCollectionAtStore_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<Order> 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, Order.class))));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getOrdersCollectionAtStore_result.class, metaDataMap);
+    }
+    public getOrdersCollectionAtStore_result() {
+    }
+    public getOrdersCollectionAtStore_result(
+      List<Order> success)
+    {
+      this();
+      this.success = success;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getOrdersCollectionAtStore_result(getOrdersCollectionAtStore_result other) {
+      if (other.isSetSuccess()) {
+        List<Order> __this__success = new ArrayList<Order>();
+        for (Order other_element : other.success) {
+          __this__success.add(new Order(other_element));
+        }
+        this.success = __this__success;
+      }
+    }
+    public getOrdersCollectionAtStore_result deepCopy() {
+      return new getOrdersCollectionAtStore_result(this);
+    }
+    @Override
+    public void clear() {
+      this.success = null;
+    }
+    public int getSuccessSize() {
+      return (this.success == null) ? 0 : this.success.size();
+    }
+    public java.util.Iterator<Order> getSuccessIterator() {
+      return (this.success == null) ? null : this.success.iterator();
+    }
+    public void addToSuccess(Order elem) {
+      if (this.success == null) {
+        this.success = new ArrayList<Order>();
+      }
+      this.success.add(elem);
+    }
+    public List<Order> getSuccess() {
+      return this.success;
+    }
+    public void setSuccess(List<Order> 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<Order>)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 getOrdersCollectionAtStore_result)
+        return this.equals((getOrdersCollectionAtStore_result)that);
+      return false;
+    }
+    public boolean equals(getOrdersCollectionAtStore_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(getOrdersCollectionAtStore_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getOrdersCollectionAtStore_result typedOther = (getOrdersCollectionAtStore_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 _list344 = iprot.readListBegin();
+                this.success = new ArrayList<Order>(_list344.size);
+                for (int _i345 = 0; _i345 < _list344.size; ++_i345)
+                {
+                  Order _elem346; // required
+                  _elem346 = new Order();
+                  _elem346.read(iprot);
+                  this.success.add(_elem346);
+                }
+                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 (Order _iter347 : this.success)
+          {
+            _iter347.write(oprot);
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getOrdersCollectionAtStore_result(");
+      boolean first = true;
+      sb.append("success:");
+      if (this.success == null) {
+        sb.append("null");
       } else {
         sb.append(this.success);
+      }
       first = false;
       sb.append(")");

Subversion Repositories SmartDukaan

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