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;
     /**
      * 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.
+     *
      * @param providerId
      * @param orderId
      */
     public List<Attribute> getAllAttributesForOrderId(long orderId) throws org.apache.thrift.TException;
     /**
+     * sets attributes for an order
+     *
+     * @param orderId
+     * @param attributes
+     */
+    public void setOrderAttributes(long orderId, List<Attribute> attributes) throws org.apache.thrift.TException;
+    /**
      * sets attributes for all orders in a transaction
+     *
      * @param transactionId
      * @param attribute
      */
     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 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 markOrdersAsDelivered(long providerId, Map<String,String> deliveredOrders, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.markOrdersAsDelivered_call> resultHandler) throws org.apache.thrift.TException;
     public void getAllVerificationAgents(long minOrderId, long maxOrderId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getAllVerificationAgents_call> resultHandler) throws org.apache.thrift.TException;
     public void getAllAttributesForOrderId(long orderId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getAllAttributesForOrderId_call> resultHandler) throws org.apache.thrift.TException;
+    public void setOrderAttributes(long orderId, List<Attribute> attributes, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.setOrderAttributes_call> resultHandler) throws org.apache.thrift.TException;
     public void setOrderAttributeForTransaction(long transactionId, Attribute attribute, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.setOrderAttributeForTransaction_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;
         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
+    {
+      send_markOrdersAsReturnedFromStore(providerId, orderIds);
+      return recv_markOrdersAsReturnedFromStore();
+    }
+    public void send_markOrdersAsReturnedFromStore(long providerId, List<Long> orderIds) throws org.apache.thrift.TException
+    {
+      markOrdersAsReturnedFromStore_args args = new markOrdersAsReturnedFromStore_args();
+      args.setProviderId(providerId);
+      args.setOrderIds(orderIds);
+      sendBase("markOrdersAsReturnedFromStore", args);
+    }
+    public boolean recv_markOrdersAsReturnedFromStore() throws TransactionServiceException, org.apache.thrift.TException
+    {
+      markOrdersAsReturnedFromStore_result result = new markOrdersAsReturnedFromStore_result();
+      receiveBase(result, "markOrdersAsReturnedFromStore");
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      if (result.ex != null) {
+        throw result.ex;
+      }
+      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
+    }
     public void markOrdersAsPickedUp(long providerId, Map<String,String> pickupDetails) throws TransactionServiceException, org.apache.thrift.TException
+    {
       send_markOrdersAsPickedUp(providerId, pickupDetails);
       recv_markOrdersAsPickedUp();
+    }
         return result.success;
+      }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
+    }
+    public void setOrderAttributes(long orderId, List<Attribute> attributes) throws org.apache.thrift.TException
+    {
+      send_setOrderAttributes(orderId, attributes);
+      recv_setOrderAttributes();
+    }
+    public void send_setOrderAttributes(long orderId, List<Attribute> attributes) throws org.apache.thrift.TException
+    {
+      setOrderAttributes_args args = new setOrderAttributes_args();
+      args.setOrderId(orderId);
+      args.setAttributes(attributes);
+      sendBase("setOrderAttributes", args);
+    }
+    public void recv_setOrderAttributes() throws org.apache.thrift.TException
+    {
+      setOrderAttributes_result result = new setOrderAttributes_result();
+      receiveBase(result, "setOrderAttributes");
+      return;
+    }
     public void setOrderAttributeForTransaction(long transactionId, Attribute attribute) throws org.apache.thrift.TException
+    {
       send_setOrderAttributeForTransaction(transactionId, attribute);
       recv_setOrderAttributeForTransaction();
+    }
         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 {
+      checkReady();
+      markOrdersAsReturnedFromStore_call method_call = new markOrdersAsReturnedFromStore_call(providerId, orderIds, 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;
+      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 {
+        super(client, protocolFactory, transport, resultHandler, false);
+        this.providerId = providerId;
+        this.orderIds = orderIds;
+      }
+      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.write(prot);
+        prot.writeMessageEnd();
+      }
+      public boolean getResult() throws TransactionServiceException, org.apache.thrift.TException {
+        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+          throw new IllegalStateException("Method call not finished!");
+        }
+        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+        return (new Client(prot)).recv_markOrdersAsReturnedFromStore();
+      }
+    }
     public void markOrdersAsPickedUp(long providerId, Map<String,String> pickupDetails, org.apache.thrift.async.AsyncMethodCallback<markOrdersAsPickedUp_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       markOrdersAsPickedUp_call method_call = new markOrdersAsPickedUp_call(providerId, pickupDetails, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         return (new Client(prot)).recv_getAllAttributesForOrderId();
+      }
+    }
+    public void setOrderAttributes(long orderId, List<Attribute> attributes, org.apache.thrift.async.AsyncMethodCallback<setOrderAttributes_call> resultHandler) throws org.apache.thrift.TException {
+      checkReady();
+      setOrderAttributes_call method_call = new setOrderAttributes_call(orderId, attributes, resultHandler, this, ___protocolFactory, ___transport);
+      this.___currentMethod = method_call;
+      ___manager.call(method_call);
+    }
+    public static class setOrderAttributes_call extends org.apache.thrift.async.TAsyncMethodCall {
+      private long orderId;
+      private List<Attribute> attributes;
+      public setOrderAttributes_call(long orderId, List<Attribute> attributes, org.apache.thrift.async.AsyncMethodCallback<setOrderAttributes_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.orderId = orderId;
+        this.attributes = attributes;
+      }
+      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("setOrderAttributes", org.apache.thrift.protocol.TMessageType.CALL, 0));
+        setOrderAttributes_args args = new setOrderAttributes_args();
+        args.setOrderId(orderId);
+        args.setAttributes(attributes);
+        args.write(prot);
+        prot.writeMessageEnd();
+      }
+      public void 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);
+        (new Client(prot)).recv_setOrderAttributes();
+      }
+    }
     public void setOrderAttributeForTransaction(long transactionId, Attribute attribute, org.apache.thrift.async.AsyncMethodCallback<setOrderAttributeForTransaction_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       setOrderAttributeForTransaction_call method_call = new setOrderAttributeForTransaction_call(transactionId, attribute, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
       processMap.put("verifyOrder", new verifyOrder());
       processMap.put("acceptOrder", new acceptOrder());
       processMap.put("addBillingDetails", new addBillingDetails());
       processMap.put("addInvoiceNumber", new addInvoiceNumber());
       processMap.put("markOrdersAsShippedFromWarehouse", new markOrdersAsShippedFromWarehouse());
+      processMap.put("markOrdersAsReturnedFromStore", new markOrdersAsReturnedFromStore());
       processMap.put("markOrdersAsPickedUp", new markOrdersAsPickedUp());
       processMap.put("getOrdersNotPickedUp", new getOrdersNotPickedUp());
       processMap.put("markOrdersAsDelivered", new markOrdersAsDelivered());
       processMap.put("markAsRTOrders", new markAsRTOrders());
       processMap.put("getRTOrders", new getRTOrders());
       processMap.put("updateOrderAsPaidToVendor", new updateOrderAsPaidToVendor());
       processMap.put("updateOrderOnlyAsPaidToVendor", new updateOrderOnlyAsPaidToVendor());
       processMap.put("getRefundedOrdersMarkedPaid", new getRefundedOrdersMarkedPaid());
       processMap.put("getAllVerificationAgents", new getAllVerificationAgents());
       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("acceptOrderForItem", new acceptOrderForItem());
       return processMap;
+        }
         return result;
+      }
+    }
+    private static class markOrdersAsReturnedFromStore<I extends Iface> extends org.apache.thrift.ProcessFunction<I, markOrdersAsReturnedFromStore_args> {
+      public markOrdersAsReturnedFromStore() {
+        super("markOrdersAsReturnedFromStore");
+      }
+      protected markOrdersAsReturnedFromStore_args getEmptyArgsInstance() {
+        return new markOrdersAsReturnedFromStore_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.setSuccessIsSet(true);
+        } catch (TransactionServiceException ex) {
+          result.ex = ex;
+        }
+        return result;
+      }
+    }
     private static class markOrdersAsPickedUp<I extends Iface> extends org.apache.thrift.ProcessFunction<I, markOrdersAsPickedUp_args> {
       public markOrdersAsPickedUp() {
         super("markOrdersAsPickedUp");
+      }
         result.success = iface.getAllAttributesForOrderId(args.orderId);
         return result;
+      }
+    }
+    private static class setOrderAttributes<I extends Iface> extends org.apache.thrift.ProcessFunction<I, setOrderAttributes_args> {
+      public setOrderAttributes() {
+        super("setOrderAttributes");
+      }
+      protected setOrderAttributes_args getEmptyArgsInstance() {
+        return new setOrderAttributes_args();
+      }
+      protected setOrderAttributes_result getResult(I iface, setOrderAttributes_args args) throws org.apache.thrift.TException {
+        setOrderAttributes_result result = new setOrderAttributes_result();
+        iface.setOrderAttributes(args.orderId, args.attributes);
+        return result;
+      }
+    }
     private static class setOrderAttributeForTransaction<I extends Iface> extends org.apache.thrift.ProcessFunction<I, setOrderAttributeForTransaction_args> {
       public setOrderAttributeForTransaction() {
         super("setOrderAttributeForTransaction");
+      }
+      }
+    }
+  }
+  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 long providerId; // required
+    private List<Long> orderIds; // 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");
+      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: // PROVIDER_ID
+            return PROVIDER_ID;
+          case 2: // ORDER_IDS
+            return ORDER_IDS;
+          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 __PROVIDERID_ISSET_ID = 0;
+    private BitSet __isset_bit_vector = new BitSet(1);
+    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+    static {
+      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+      tmpMap.put(_Fields.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))));
+      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)
+    {
+      this();
+      this.providerId = providerId;
+      setProviderIdIsSet(true);
+      this.orderIds = orderIds;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public markOrdersAsReturnedFromStore_args(markOrdersAsReturnedFromStore_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.providerId = other.providerId;
+      if (other.isSetOrderIds()) {
+        List<Long> __this__orderIds = new ArrayList<Long>();
+        for (Long other_element : other.orderIds) {
+          __this__orderIds.add(other_element);
+        }
+        this.orderIds = __this__orderIds;
+      }
+    }
+    public markOrdersAsReturnedFromStore_args deepCopy() {
+      return new markOrdersAsReturnedFromStore_args(this);
+    }
+    @Override
+    public void clear() {
+      setProviderIdIsSet(false);
+      this.providerId = 0;
+      this.orderIds = null;
+    }
+    public long getProviderId() {
+      return this.providerId;
+    }
+    public void setProviderId(long providerId) {
+      this.providerId = providerId;
+      setProviderIdIsSet(true);
+    }
+    public void unsetProviderId() {
+      __isset_bit_vector.clear(__PROVIDERID_ISSET_ID);
+    }
+    /** Returns true if field providerId is set (has been assigned a value) and false otherwise */
+    public boolean isSetProviderId() {
+      return __isset_bit_vector.get(__PROVIDERID_ISSET_ID);
+    }
+    public void setProviderIdIsSet(boolean value) {
+      __isset_bit_vector.set(__PROVIDERID_ISSET_ID, value);
+    }
+    public int getOrderIdsSize() {
+      return (this.orderIds == null) ? 0 : this.orderIds.size();
+    }
+    public java.util.Iterator<Long> getOrderIdsIterator() {
+      return (this.orderIds == null) ? null : this.orderIds.iterator();
+    }
+    public void addToOrderIds(long elem) {
+      if (this.orderIds == null) {
+        this.orderIds = new ArrayList<Long>();
+      }
+      this.orderIds.add(elem);
+    }
+    public List<Long> getOrderIds() {
+      return this.orderIds;
+    }
+    public void setOrderIds(List<Long> orderIds) {
+      this.orderIds = orderIds;
+    }
+    public void unsetOrderIds() {
+      this.orderIds = null;
+    }
+    /** Returns true if field orderIds is set (has been assigned a value) and false otherwise */
+    public boolean isSetOrderIds() {
+      return this.orderIds != null;
+    }
+    public void setOrderIdsIsSet(boolean value) {
+      if (!value) {
+        this.orderIds = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case PROVIDER_ID:
+        if (value == null) {
+          unsetProviderId();
+        } else {
+          setProviderId((Long)value);
+        }
+        break;
+      case ORDER_IDS:
+        if (value == null) {
+          unsetOrderIds();
+        } else {
+          setOrderIds((List<Long>)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case PROVIDER_ID:
+        return Long.valueOf(getProviderId());
+      case ORDER_IDS:
+        return getOrderIds();
+      }
+      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 PROVIDER_ID:
+        return isSetProviderId();
+      case ORDER_IDS:
+        return isSetOrderIds();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof markOrdersAsReturnedFromStore_args)
+        return this.equals((markOrdersAsReturnedFromStore_args)that);
+      return false;
+    }
+    public boolean equals(markOrdersAsReturnedFromStore_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_providerId = true;
+      boolean that_present_providerId = true;
+      if (this_present_providerId || that_present_providerId) {
+        if (!(this_present_providerId && that_present_providerId))
+          return false;
+        if (this.providerId != that.providerId)
+          return false;
+      }
+      boolean this_present_orderIds = true && this.isSetOrderIds();
+      boolean that_present_orderIds = true && that.isSetOrderIds();
+      if (this_present_orderIds || that_present_orderIds) {
+        if (!(this_present_orderIds && that_present_orderIds))
+          return false;
+        if (!this.orderIds.equals(that.orderIds))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(markOrdersAsReturnedFromStore_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      markOrdersAsReturnedFromStore_args typedOther = (markOrdersAsReturnedFromStore_args)other;
+      lastComparison = Boolean.valueOf(isSetProviderId()).compareTo(typedOther.isSetProviderId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetProviderId()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.providerId, typedOther.providerId);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetOrderIds()).compareTo(typedOther.isSetOrderIds());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetOrderIds()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.orderIds, typedOther.orderIds);
+        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: // PROVIDER_ID
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.providerId = iprot.readI64();
+              setProviderIdIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 2: // ORDER_IDS
+            if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
+                org.apache.thrift.protocol.TList _list140 = iprot.readListBegin();
+                this.orderIds = new ArrayList<Long>(_list140.size);
+                for (int _i141 = 0; _i141 < _list140.size; ++_i141)
+                {
+                  long _elem142; // required
+                  _elem142 = iprot.readI64();
+                  this.orderIds.add(_elem142);
+                }
+                iprot.readListEnd();
+              }
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+      validate();
+      oprot.writeStructBegin(STRUCT_DESC);
+      oprot.writeFieldBegin(PROVIDER_ID_FIELD_DESC);
+      oprot.writeI64(this.providerId);
+      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)
+          {
+            oprot.writeI64(_iter143);
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("markOrdersAsReturnedFromStore_args(");
+      boolean first = true;
+      sb.append("providerId:");
+      sb.append(this.providerId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("orderIds:");
+      if (this.orderIds == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.orderIds);
+      }
+      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 markOrdersAsReturnedFromStore_result implements org.apache.thrift.TBase<markOrdersAsReturnedFromStore_result, markOrdersAsReturnedFromStore_result._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("markOrdersAsReturnedFromStore_result");
+    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.BOOL, (short)0);
+    private static final org.apache.thrift.protocol.TField EX_FIELD_DESC = new org.apache.thrift.protocol.TField("ex", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+    private boolean success; // required
+    private TransactionServiceException ex; // required
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+      SUCCESS((short)0, "success"),
+      EX((short)1, "ex");
+      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+      static {
+        for (_Fields field : EnumSet.allOf(_Fields.class)) {
+          byName.put(field.getFieldName(), field);
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, or null if its not found.
+       */
+      public static _Fields findByThriftId(int fieldId) {
+        switch(fieldId) {
+          case 0: // SUCCESS
+            return SUCCESS;
+          case 1: // EX
+            return EX;
+          default:
+            return null;
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, throwing an exception
+       * if it is not found.
+       */
+      public static _Fields findByThriftIdOrThrow(int fieldId) {
+        _Fields fields = findByThriftId(fieldId);
+        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+        return fields;
+      }
+      /**
+       * Find the _Fields constant that matches name, or null if its not found.
+       */
+      public static _Fields findByName(String name) {
+        return byName.get(name);
+      }
+      private final short _thriftId;
+      private final String _fieldName;
+      _Fields(short thriftId, String fieldName) {
+        _thriftId = thriftId;
+        _fieldName = fieldName;
+      }
+      public short getThriftFieldId() {
+        return _thriftId;
+      }
+      public String getFieldName() {
+        return _fieldName;
+      }
+    }
+    // isset id assignments
+    private static final int __SUCCESS_ISSET_ID = 0;
+    private BitSet __isset_bit_vector = new BitSet(1);
+    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+    static {
+      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+      tmpMap.put(_Fields.EX, new org.apache.thrift.meta_data.FieldMetaData("ex", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(markOrdersAsReturnedFromStore_result.class, metaDataMap);
+    }
+    public markOrdersAsReturnedFromStore_result() {
+    }
+    public markOrdersAsReturnedFromStore_result(
+      boolean success,
+      TransactionServiceException ex)
+    {
+      this();
+      this.success = success;
+      setSuccessIsSet(true);
+      this.ex = ex;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public markOrdersAsReturnedFromStore_result(markOrdersAsReturnedFromStore_result other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.success = other.success;
+      if (other.isSetEx()) {
+        this.ex = new TransactionServiceException(other.ex);
+      }
+    }
+    public markOrdersAsReturnedFromStore_result deepCopy() {
+      return new markOrdersAsReturnedFromStore_result(this);
+    }
+    @Override
+    public void clear() {
+      setSuccessIsSet(false);
+      this.success = false;
+      this.ex = null;
+    }
+    public boolean isSuccess() {
+      return this.success;
+    }
+    public void setSuccess(boolean success) {
+      this.success = success;
+      setSuccessIsSet(true);
+    }
+    public void unsetSuccess() {
+      __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
+    }
+    /** Returns true if field success is set (has been assigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
+    }
+    public void setSuccessIsSet(boolean value) {
+      __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
+    }
+    public TransactionServiceException getEx() {
+      return this.ex;
+    }
+    public void setEx(TransactionServiceException ex) {
+      this.ex = ex;
+    }
+    public void unsetEx() {
+      this.ex = null;
+    }
+    /** Returns true if field ex is set (has been assigned a value) and false otherwise */
+    public boolean isSetEx() {
+      return this.ex != null;
+    }
+    public void setExIsSet(boolean value) {
+      if (!value) {
+        this.ex = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((Boolean)value);
+        }
+        break;
+      case EX:
+        if (value == null) {
+          unsetEx();
+        } else {
+          setEx((TransactionServiceException)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case SUCCESS:
+        return Boolean.valueOf(isSuccess());
+      case EX:
+        return getEx();
+      }
+      throw new IllegalStateException();
+    }
+    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+    public boolean isSet(_Fields field) {
+      if (field == null) {
+        throw new IllegalArgumentException();
+      }
+      switch (field) {
+      case SUCCESS:
+        return isSetSuccess();
+      case EX:
+        return isSetEx();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof markOrdersAsReturnedFromStore_result)
+        return this.equals((markOrdersAsReturnedFromStore_result)that);
+      return false;
+    }
+    public boolean equals(markOrdersAsReturnedFromStore_result that) {
+      if (that == null)
+        return false;
+      boolean this_present_success = true;
+      boolean that_present_success = true;
+      if (this_present_success || that_present_success) {
+        if (!(this_present_success && that_present_success))
+          return false;
+        if (this.success != that.success)
+          return false;
+      }
+      boolean this_present_ex = true && this.isSetEx();
+      boolean that_present_ex = true && that.isSetEx();
+      if (this_present_ex || that_present_ex) {
+        if (!(this_present_ex && that_present_ex))
+          return false;
+        if (!this.ex.equals(that.ex))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(markOrdersAsReturnedFromStore_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      markOrdersAsReturnedFromStore_result typedOther = (markOrdersAsReturnedFromStore_result)other;
+      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetSuccess()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetEx()).compareTo(typedOther.isSetEx());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetEx()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ex, typedOther.ex);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      return 0;
+    }
+    public _Fields fieldForId(int fieldId) {
+      return _Fields.findByThriftId(fieldId);
+    }
+    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField field;
+      iprot.readStructBegin();
+      while (true)
+      {
+        field = iprot.readFieldBegin();
+        if (field.type == org.apache.thrift.protocol.TType.STOP) {
+          break;
+        }
+        switch (field.id) {
+          case 0: // SUCCESS
+            if (field.type == org.apache.thrift.protocol.TType.BOOL) {
+              this.success = iprot.readBool();
+              setSuccessIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 1: // EX
+            if (field.type == org.apache.thrift.protocol.TType.STRUCT) {
+              this.ex = new TransactionServiceException();
+              this.ex.read(iprot);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        oprot.writeBool(this.success);
+        oprot.writeFieldEnd();
+      } else if (this.isSetEx()) {
+        oprot.writeFieldBegin(EX_FIELD_DESC);
+        this.ex.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("markOrdersAsReturnedFromStore_result(");
+      boolean first = true;
+      sb.append("success:");
+      sb.append(this.success);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("ex:");
+      if (this.ex == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.ex);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws org.apache.thrift.TException {
+      // check for required fields
+    }
+    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+      try {
+        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+      try {
+        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+  }
   public static class markOrdersAsPickedUp_args implements org.apache.thrift.TBase<markOrdersAsPickedUp_args, markOrdersAsPickedUp_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("markOrdersAsPickedUp_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 PICKUP_DETAILS_FIELD_DESC = new org.apache.thrift.protocol.TField("pickupDetails", org.apache.thrift.protocol.TType.MAP, (short)2);
+            }
             break;
           case 2: // PICKUP_DETAILS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map140 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map144 = iprot.readMapBegin();
-                this.pickupDetails = new HashMap<String,String>(2*_map140.size);
+                this.pickupDetails = new HashMap<String,String>(2*_map144.size);
-                for (int _i141 = 0; _i141 < _map140.size; ++_i141)
+                for (int _i145 = 0; _i145 < _map144.size; ++_i145)
+                {
-                  String _key142; // required
+                  String _key146; // required
-                  String _val143; // required
+                  String _val147; // required
-                  _key142 = iprot.readString();
+                  _key146 = iprot.readString();
-                  _val143 = iprot.readString();
+                  _val147 = iprot.readString();
-                  this.pickupDetails.put(_key142, _val143);
+                  this.pickupDetails.put(_key146, _val147);
+                }
                 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> _iter144 : this.pickupDetails.entrySet())
+          for (Map.Entry<String, String> _iter148 : this.pickupDetails.entrySet())
+          {
-            oprot.writeString(_iter144.getKey());
+            oprot.writeString(_iter148.getKey());
-            oprot.writeString(_iter144.getValue());
+            oprot.writeString(_iter148.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 _list145 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list149 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list145.size);
+                this.success = new ArrayList<Order>(_list149.size);
-                for (int _i146 = 0; _i146 < _list145.size; ++_i146)
+                for (int _i150 = 0; _i150 < _list149.size; ++_i150)
+                {
-                  Order _elem147; // required
+                  Order _elem151; // required
-                  _elem147 = new Order();
+                  _elem151 = new Order();
-                  _elem147.read(iprot);
+                  _elem151.read(iprot);
-                  this.success.add(_elem147);
+                  this.success.add(_elem151);
+                }
                 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 _iter148 : this.success)
+          for (Order _iter152 : this.success)
+          {
-            _iter148.write(oprot);
+            _iter152.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 _map149 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map153 = iprot.readMapBegin();
-                this.deliveredOrders = new HashMap<String,String>(2*_map149.size);
+                this.deliveredOrders = new HashMap<String,String>(2*_map153.size);
-                for (int _i150 = 0; _i150 < _map149.size; ++_i150)
+                for (int _i154 = 0; _i154 < _map153.size; ++_i154)
+                {
-                  String _key151; // required
+                  String _key155; // required
-                  String _val152; // required
+                  String _val156; // required
-                  _key151 = iprot.readString();
+                  _key155 = iprot.readString();
-                  _val152 = iprot.readString();
+                  _val156 = iprot.readString();
-                  this.deliveredOrders.put(_key151, _val152);
+                  this.deliveredOrders.put(_key155, _val156);
+                }
                 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> _iter153 : this.deliveredOrders.entrySet())
+          for (Map.Entry<String, String> _iter157 : this.deliveredOrders.entrySet())
+          {
-            oprot.writeString(_iter153.getKey());
+            oprot.writeString(_iter157.getKey());
-            oprot.writeString(_iter153.getValue());
+            oprot.writeString(_iter157.getValue());
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }
+            }
             break;
           case 2: // RETURNED_ORDERS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map154 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map158 = iprot.readMapBegin();
-                this.returnedOrders = new HashMap<String,String>(2*_map154.size);
+                this.returnedOrders = new HashMap<String,String>(2*_map158.size);
-                for (int _i155 = 0; _i155 < _map154.size; ++_i155)
+                for (int _i159 = 0; _i159 < _map158.size; ++_i159)
+                {
-                  String _key156; // required
+                  String _key160; // required
-                  String _val157; // required
+                  String _val161; // required
-                  _key156 = iprot.readString();
+                  _key160 = iprot.readString();
-                  _val157 = iprot.readString();
+                  _val161 = iprot.readString();
-                  this.returnedOrders.put(_key156, _val157);
+                  this.returnedOrders.put(_key160, _val161);
+                }
                 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> _iter158 : this.returnedOrders.entrySet())
+          for (Map.Entry<String, String> _iter162 : this.returnedOrders.entrySet())
+          {
-            oprot.writeString(_iter158.getKey());
+            oprot.writeString(_iter162.getKey());
-            oprot.writeString(_iter158.getValue());
+            oprot.writeString(_iter162.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 _list159 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list163 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list159.size);
+                this.success = new ArrayList<Order>(_list163.size);
-                for (int _i160 = 0; _i160 < _list159.size; ++_i160)
+                for (int _i164 = 0; _i164 < _list163.size; ++_i164)
+                {
-                  Order _elem161; // required
+                  Order _elem165; // required
-                  _elem161 = new Order();
+                  _elem165 = new Order();
-                  _elem161.read(iprot);
+                  _elem165.read(iprot);
-                  this.success.add(_elem161);
+                  this.success.add(_elem165);
+                }
                 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 _iter162 : this.success)
+          for (Order _iter166 : this.success)
+          {
-            _iter162.write(oprot);
+            _iter166.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 _map163 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map167 = iprot.readMapBegin();
-                this.undeliveredOrders = new HashMap<String,String>(2*_map163.size);
+                this.undeliveredOrders = new HashMap<String,String>(2*_map167.size);
-                for (int _i164 = 0; _i164 < _map163.size; ++_i164)
+                for (int _i168 = 0; _i168 < _map167.size; ++_i168)
+                {
-                  String _key165; // required
+                  String _key169; // required
-                  String _val166; // required
+                  String _val170; // required
-                  _key165 = iprot.readString();
+                  _key169 = iprot.readString();
-                  _val166 = iprot.readString();
+                  _val170 = iprot.readString();
-                  this.undeliveredOrders.put(_key165, _val166);
+                  this.undeliveredOrders.put(_key169, _val170);
+                }
                 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> _iter167 : this.undeliveredOrders.entrySet())
+          for (Map.Entry<String, String> _iter171 : this.undeliveredOrders.entrySet())
+          {
-            oprot.writeString(_iter167.getKey());
+            oprot.writeString(_iter171.getKey());
-            oprot.writeString(_iter167.getValue());
+            oprot.writeString(_iter171.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 _list168 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list172 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list168.size);
+                this.success = new ArrayList<Order>(_list172.size);
-                for (int _i169 = 0; _i169 < _list168.size; ++_i169)
+                for (int _i173 = 0; _i173 < _list172.size; ++_i173)
+                {
-                  Order _elem170; // required
+                  Order _elem174; // required
-                  _elem170 = new Order();
+                  _elem174 = new Order();
-                  _elem170.read(iprot);
+                  _elem174.read(iprot);
-                  this.success.add(_elem170);
+                  this.success.add(_elem174);
+                }
                 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 _iter171 : this.success)
+          for (Order _iter175 : this.success)
+          {
-            _iter171.write(oprot);
+            _iter175.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 _map172 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map176 = iprot.readMapBegin();
-                this.local_connected_orders = new HashMap<String,String>(2*_map172.size);
+                this.local_connected_orders = new HashMap<String,String>(2*_map176.size);
-                for (int _i173 = 0; _i173 < _map172.size; ++_i173)
+                for (int _i177 = 0; _i177 < _map176.size; ++_i177)
+                {
-                  String _key174; // required
+                  String _key178; // required
-                  String _val175; // required
+                  String _val179; // required
-                  _key174 = iprot.readString();
+                  _key178 = iprot.readString();
-                  _val175 = iprot.readString();
+                  _val179 = iprot.readString();
-                  this.local_connected_orders.put(_key174, _val175);
+                  this.local_connected_orders.put(_key178, _val179);
+                }
                 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> _iter176 : this.local_connected_orders.entrySet())
+          for (Map.Entry<String, String> _iter180 : this.local_connected_orders.entrySet())
+          {
-            oprot.writeString(_iter176.getKey());
+            oprot.writeString(_iter180.getKey());
-            oprot.writeString(_iter176.getValue());
+            oprot.writeString(_iter180.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 _list177 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list181 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list177.size);
+                this.success = new ArrayList<Order>(_list181.size);
-                for (int _i178 = 0; _i178 < _list177.size; ++_i178)
+                for (int _i182 = 0; _i182 < _list181.size; ++_i182)
+                {
-                  Order _elem179; // required
+                  Order _elem183; // required
-                  _elem179 = new Order();
+                  _elem183 = new Order();
-                  _elem179.read(iprot);
+                  _elem183.read(iprot);
-                  this.success.add(_elem179);
+                  this.success.add(_elem183);
+                }
                 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 _iter180 : this.success)
+          for (Order _iter184 : this.success)
+          {
-            _iter180.write(oprot);
+            _iter184.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 _map181 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map185 = iprot.readMapBegin();
-                this.destination_city_reached_orders = new HashMap<String,String>(2*_map181.size);
+                this.destination_city_reached_orders = new HashMap<String,String>(2*_map185.size);
-                for (int _i182 = 0; _i182 < _map181.size; ++_i182)
+                for (int _i186 = 0; _i186 < _map185.size; ++_i186)
+                {
-                  String _key183; // required
+                  String _key187; // required
-                  String _val184; // required
+                  String _val188; // required
-                  _key183 = iprot.readString();
+                  _key187 = iprot.readString();
-                  _val184 = iprot.readString();
+                  _val188 = iprot.readString();
-                  this.destination_city_reached_orders.put(_key183, _val184);
+                  this.destination_city_reached_orders.put(_key187, _val188);
+                }
                 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> _iter185 : this.destination_city_reached_orders.entrySet())
+          for (Map.Entry<String, String> _iter189 : this.destination_city_reached_orders.entrySet())
+          {
-            oprot.writeString(_iter185.getKey());
+            oprot.writeString(_iter189.getKey());
-            oprot.writeString(_iter185.getValue());
+            oprot.writeString(_iter189.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 _map186 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map190 = iprot.readMapBegin();
-                this.first_atdl_orders = new HashMap<String,String>(2*_map186.size);
+                this.first_atdl_orders = new HashMap<String,String>(2*_map190.size);
-                for (int _i187 = 0; _i187 < _map186.size; ++_i187)
+                for (int _i191 = 0; _i191 < _map190.size; ++_i191)
+                {
-                  String _key188; // required
+                  String _key192; // required
-                  String _val189; // required
+                  String _val193; // required
-                  _key188 = iprot.readString();
+                  _key192 = iprot.readString();
-                  _val189 = iprot.readString();
+                  _val193 = iprot.readString();
-                  this.first_atdl_orders.put(_key188, _val189);
+                  this.first_atdl_orders.put(_key192, _val193);
+                }
                 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> _iter190 : this.first_atdl_orders.entrySet())
+          for (Map.Entry<String, String> _iter194 : this.first_atdl_orders.entrySet())
+          {
-            oprot.writeString(_iter190.getKey());
+            oprot.writeString(_iter194.getKey());
-            oprot.writeString(_iter190.getValue());
+            oprot.writeString(_iter194.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 _list191 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list195 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list191.size);
+                this.success = new ArrayList<Order>(_list195.size);
-                for (int _i192 = 0; _i192 < _list191.size; ++_i192)
+                for (int _i196 = 0; _i196 < _list195.size; ++_i196)
+                {
-                  Order _elem193; // required
+                  Order _elem197; // required
-                  _elem193 = new Order();
+                  _elem197 = new Order();
-                  _elem193.read(iprot);
+                  _elem197.read(iprot);
-                  this.success.add(_elem193);
+                  this.success.add(_elem197);
+                }
                 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 _iter194 : this.success)
+          for (Order _iter198 : this.success)
+          {
-            _iter194.write(oprot);
+            _iter198.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 _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();
+      }
+            }
             break;
           case 2: // PICKUP_DETAILS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map199 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map203 = iprot.readMapBegin();
-                this.pickupDetails = new HashMap<String,String>(2*_map199.size);
+                this.pickupDetails = new HashMap<String,String>(2*_map203.size);
-                for (int _i200 = 0; _i200 < _map199.size; ++_i200)
+                for (int _i204 = 0; _i204 < _map203.size; ++_i204)
+                {
-                  String _key201; // required
+                  String _key205; // required
-                  String _val202; // required
+                  String _val206; // required
-                  _key201 = iprot.readString();
+                  _key205 = iprot.readString();
-                  _val202 = iprot.readString();
+                  _val206 = iprot.readString();
-                  this.pickupDetails.put(_key201, _val202);
+                  this.pickupDetails.put(_key205, _val206);
+                }
                 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> _iter203 : this.pickupDetails.entrySet())
+          for (Map.Entry<String, String> _iter207 : this.pickupDetails.entrySet())
+          {
-            oprot.writeString(_iter203.getKey());
+            oprot.writeString(_iter207.getKey());
-            oprot.writeString(_iter203.getValue());
+            oprot.writeString(_iter207.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 _list204 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list208 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list204.size);
+                this.success = new ArrayList<Order>(_list208.size);
-                for (int _i205 = 0; _i205 < _list204.size; ++_i205)
+                for (int _i209 = 0; _i209 < _list208.size; ++_i209)
+                {
-                  Order _elem206; // required
+                  Order _elem210; // required
-                  _elem206 = new Order();
+                  _elem210 = new Order();
-                  _elem206.read(iprot);
+                  _elem210.read(iprot);
-                  this.success.add(_elem206);
+                  this.success.add(_elem210);
+                }
                 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 _iter207 : this.success)
+          for (Order _iter211 : this.success)
+          {
-            _iter207.write(oprot);
+            _iter211.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 _map208 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map212 = iprot.readMapBegin();
-                this.pickupDetails = new HashMap<String,String>(2*_map208.size);
+                this.pickupDetails = new HashMap<String,String>(2*_map212.size);
-                for (int _i209 = 0; _i209 < _map208.size; ++_i209)
+                for (int _i213 = 0; _i213 < _map212.size; ++_i213)
+                {
-                  String _key210; // required
+                  String _key214; // required
-                  String _val211; // required
+                  String _val215; // required
-                  _key210 = iprot.readString();
+                  _key214 = iprot.readString();
-                  _val211 = iprot.readString();
+                  _val215 = iprot.readString();
-                  this.pickupDetails.put(_key210, _val211);
+                  this.pickupDetails.put(_key214, _val215);
+                }
                 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> _iter212 : this.pickupDetails.entrySet())
+          for (Map.Entry<String, String> _iter216 : this.pickupDetails.entrySet())
+          {
-            oprot.writeString(_iter212.getKey());
+            oprot.writeString(_iter216.getKey());
-            oprot.writeString(_iter212.getValue());
+            oprot.writeString(_iter216.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 _list213 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list217 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list213.size);
+                this.success = new ArrayList<Order>(_list217.size);
-                for (int _i214 = 0; _i214 < _list213.size; ++_i214)
+                for (int _i218 = 0; _i218 < _list217.size; ++_i218)
+                {
-                  Order _elem215; // required
+                  Order _elem219; // required
-                  _elem215 = new Order();
+                  _elem219 = new Order();
-                  _elem215.read(iprot);
+                  _elem219.read(iprot);
-                  this.success.add(_elem215);
+                  this.success.add(_elem219);
+                }
                 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 _iter216 : this.success)
+          for (Order _iter220 : this.success)
+          {
-            _iter216.write(oprot);
+            _iter220.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);
+      }
+    }
+      }
+    }
     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);
+      }
+    }
+      }
+    }
     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 _list217 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list221 = iprot.readListBegin();
-                this.success = new ArrayList<ReturnOrder>(_list217.size);
+                this.success = new ArrayList<ReturnOrder>(_list221.size);
-                for (int _i218 = 0; _i218 < _list217.size; ++_i218)
+                for (int _i222 = 0; _i222 < _list221.size; ++_i222)
+                {
-                  ReturnOrder _elem219; // required
+                  ReturnOrder _elem223; // required
-                  _elem219 = new ReturnOrder();
+                  _elem223 = new ReturnOrder();
-                  _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 (ReturnOrder _iter220 : this.success)
+          for (ReturnOrder _iter224 : this.success)
+          {
-            _iter220.write(oprot);
+            _iter224.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 _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 1: // COLLECTED_AMOUNT_MAP
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map225 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map229 = iprot.readMapBegin();
-                this.collectedAmountMap = new HashMap<String,Double>(2*_map225.size);
+                this.collectedAmountMap = new HashMap<String,Double>(2*_map229.size);
-                for (int _i226 = 0; _i226 < _map225.size; ++_i226)
+                for (int _i230 = 0; _i230 < _map229.size; ++_i230)
+                {
-                  String _key227; // required
+                  String _key231; // required
-                  double _val228; // required
+                  double _val232; // required
-                  _key227 = iprot.readString();
+                  _key231 = iprot.readString();
-                  _val228 = iprot.readDouble();
+                  _val232 = iprot.readDouble();
-                  this.collectedAmountMap.put(_key227, _val228);
+                  this.collectedAmountMap.put(_key231, _val232);
+                }
                 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> _iter229 : this.collectedAmountMap.entrySet())
+          for (Map.Entry<String, Double> _iter233 : this.collectedAmountMap.entrySet())
+          {
-            oprot.writeString(_iter229.getKey());
+            oprot.writeString(_iter233.getKey());
-            oprot.writeDouble(_iter229.getValue());
+            oprot.writeDouble(_iter233.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 _map230 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map234 = iprot.readMapBegin();
-                this.success = new HashMap<String,String>(2*_map230.size);
+                this.success = new HashMap<String,String>(2*_map234.size);
-                for (int _i231 = 0; _i231 < _map230.size; ++_i231)
+                for (int _i235 = 0; _i235 < _map234.size; ++_i235)
+                {
-                  String _key232; // required
+                  String _key236; // required
-                  String _val233; // required
+                  String _val237; // required
-                  _key232 = iprot.readString();
+                  _key236 = iprot.readString();
-                  _val233 = iprot.readString();
+                  _val237 = iprot.readString();
-                  this.success.put(_key232, _val233);
+                  this.success.put(_key236, _val237);
+                }
                 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> _iter234 : this.success.entrySet())
+          for (Map.Entry<String, String> _iter238 : this.success.entrySet())
+          {
-            oprot.writeString(_iter234.getKey());
+            oprot.writeString(_iter238.getKey());
-            oprot.writeString(_iter234.getValue());
+            oprot.writeString(_iter238.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 _list235 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list239 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list235.size);
+                this.success = new ArrayList<Long>(_list239.size);
-                for (int _i236 = 0; _i236 < _list235.size; ++_i236)
+                for (int _i240 = 0; _i240 < _list239.size; ++_i240)
+                {
-                  long _elem237; // required
+                  long _elem241; // required
-                  _elem237 = iprot.readI64();
+                  _elem241 = iprot.readI64();
-                  this.success.add(_elem237);
+                  this.success.add(_elem241);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
-          for (long _iter238 : this.success)
+          for (long _iter242 : this.success)
+          {
-            oprot.writeI64(_iter238);
+            oprot.writeI64(_iter242);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map239 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map243 = iprot.readMapBegin();
-                this.success = new HashMap<Long,Long>(2*_map239.size);
+                this.success = new HashMap<Long,Long>(2*_map243.size);
-                for (int _i240 = 0; _i240 < _map239.size; ++_i240)
+                for (int _i244 = 0; _i244 < _map243.size; ++_i244)
+                {
-                  long _key241; // required
+                  long _key245; // required
-                  long _val242; // required
+                  long _val246; // required
-                  _key241 = iprot.readI64();
+                  _key245 = iprot.readI64();
-                  _val242 = iprot.readI64();
+                  _val246 = iprot.readI64();
-                  this.success.put(_key241, _val242);
+                  this.success.put(_key245, _val246);
+                }
                 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> _iter243 : this.success.entrySet())
+          for (Map.Entry<Long, Long> _iter247 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter243.getKey());
+            oprot.writeI64(_iter247.getKey());
-            oprot.writeI64(_iter243.getValue());
+            oprot.writeI64(_iter247.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 _list244 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list248 = iprot.readListBegin();
-                this.itemIds = new ArrayList<Long>(_list244.size);
+                this.itemIds = new ArrayList<Long>(_list248.size);
-                for (int _i245 = 0; _i245 < _list244.size; ++_i245)
+                for (int _i249 = 0; _i249 < _list248.size; ++_i249)
+                {
-                  long _elem246; // required
+                  long _elem250; // required
-                  _elem246 = iprot.readI64();
+                  _elem250 = iprot.readI64();
-                  this.itemIds.add(_elem246);
+                  this.itemIds.add(_elem250);
+                }
                 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 _iter247 : this.itemIds)
+          for (long _iter251 : this.itemIds)
+          {
-            oprot.writeI64(_iter247);
+            oprot.writeI64(_iter251);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             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.success = new ArrayList<Order>(_list248.size);
+                this.success = new ArrayList<Order>(_list252.size);
-                for (int _i249 = 0; _i249 < _list248.size; ++_i249)
+                for (int _i253 = 0; _i253 < _list252.size; ++_i253)
+                {
-                  Order _elem250; // required
+                  Order _elem254; // required
-                  _elem250 = new Order();
+                  _elem254 = new Order();
-                  _elem250.read(iprot);
+                  _elem254.read(iprot);
-                  this.success.add(_elem250);
+                  this.success.add(_elem254);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Order _iter251 : this.success)
+          for (Order _iter255 : this.success)
+          {
-            _iter251.write(oprot);
+            _iter255.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 _map252 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map256 = iprot.readMapBegin();
-                this.success = new HashMap<Integer,TimeoutSummary>(2*_map252.size);
+                this.success = new HashMap<Integer,TimeoutSummary>(2*_map256.size);
-                for (int _i253 = 0; _i253 < _map252.size; ++_i253)
+                for (int _i257 = 0; _i257 < _map256.size; ++_i257)
+                {
-                  int _key254; // required
+                  int _key258; // required
-                  TimeoutSummary _val255; // required
+                  TimeoutSummary _val259; // required
-                  _key254 = iprot.readI32();
+                  _key258 = iprot.readI32();
-                  _val255 = new TimeoutSummary();
+                  _val259 = new TimeoutSummary();
-                  _val255.read(iprot);
+                  _val259.read(iprot);
-                  this.success.put(_key254, _val255);
+                  this.success.put(_key258, _val259);
+                }
                 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> _iter256 : this.success.entrySet())
+          for (Map.Entry<Integer, TimeoutSummary> _iter260 : this.success.entrySet())
+          {
-            oprot.writeI32(_iter256.getKey());
+            oprot.writeI32(_iter260.getKey());
-            _iter256.getValue().write(oprot);
+            _iter260.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 _list257 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list261 = iprot.readListBegin();
-                this.order_status_list = new ArrayList<OrderStatus>(_list257.size);
+                this.order_status_list = new ArrayList<OrderStatus>(_list261.size);
-                for (int _i258 = 0; _i258 < _list257.size; ++_i258)
+                for (int _i262 = 0; _i262 < _list261.size; ++_i262)
+                {
-                  OrderStatus _elem259; // required
+                  OrderStatus _elem263; // required
-                  _elem259 = OrderStatus.findByValue(iprot.readI32());
+                  _elem263 = OrderStatus.findByValue(iprot.readI32());
-                  this.order_status_list.add(_elem259);
+                  this.order_status_list.add(_elem263);
+                }
                 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 _iter260 : this.order_status_list)
+          for (OrderStatus _iter264 : this.order_status_list)
+          {
-            oprot.writeI32(_iter260.getValue());
+            oprot.writeI32(_iter264.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 _list261 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list265 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list261.size);
+                this.success = new ArrayList<Order>(_list265.size);
-                for (int _i262 = 0; _i262 < _list261.size; ++_i262)
+                for (int _i266 = 0; _i266 < _list265.size; ++_i266)
+                {
-                  Order _elem263; // required
+                  Order _elem267; // required
-                  _elem263 = new Order();
+                  _elem267 = new Order();
-                  _elem263.read(iprot);
+                  _elem267.read(iprot);
-                  this.success.add(_elem263);
+                  this.success.add(_elem267);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Order _iter264 : this.success)
+          for (Order _iter268 : this.success)
+          {
-            _iter264.write(oprot);
+            _iter268.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 _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 1: // MAP_AWBAND_AMOUNT
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map277 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map281 = iprot.readMapBegin();
-                this.mapAWBAndAmount = new HashMap<Long,Double>(2*_map277.size);
+                this.mapAWBAndAmount = new HashMap<Long,Double>(2*_map281.size);
-                for (int _i278 = 0; _i278 < _map277.size; ++_i278)
+                for (int _i282 = 0; _i282 < _map281.size; ++_i282)
+                {
-                  long _key279; // required
+                  long _key283; // required
-                  double _val280; // required
+                  double _val284; // required
-                  _key279 = iprot.readI64();
+                  _key283 = iprot.readI64();
-                  _val280 = iprot.readDouble();
+                  _val284 = iprot.readDouble();
-                  this.mapAWBAndAmount.put(_key279, _val280);
+                  this.mapAWBAndAmount.put(_key283, _val284);
+                }
                 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> _iter281 : this.mapAWBAndAmount.entrySet())
+          for (Map.Entry<Long, Double> _iter285 : this.mapAWBAndAmount.entrySet())
+          {
-            oprot.writeI64(_iter281.getKey());
+            oprot.writeI64(_iter285.getKey());
-            oprot.writeDouble(_iter281.getValue());
+            oprot.writeDouble(_iter285.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 _map282 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map286 = iprot.readMapBegin();
-                this.success = new HashMap<Long,String>(2*_map282.size);
+                this.success = new HashMap<Long,String>(2*_map286.size);
-                for (int _i283 = 0; _i283 < _map282.size; ++_i283)
+                for (int _i287 = 0; _i287 < _map286.size; ++_i287)
+                {
-                  long _key284; // required
+                  long _key288; // required
-                  String _val285; // required
+                  String _val289; // required
-                  _key284 = iprot.readI64();
+                  _key288 = iprot.readI64();
-                  _val285 = iprot.readString();
+                  _val289 = iprot.readString();
-                  this.success.put(_key284, _val285);
+                  this.success.put(_key288, _val289);
+                }
                 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> _iter286 : this.success.entrySet())
+          for (Map.Entry<Long, String> _iter290 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter286.getKey());
+            oprot.writeI64(_iter290.getKey());
-            oprot.writeString(_iter286.getValue());
+            oprot.writeString(_iter290.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 _list287 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list291 = iprot.readListBegin();
-                this.success = new ArrayList<PaymentSettlement>(_list287.size);
+                this.success = new ArrayList<PaymentSettlement>(_list291.size);
-                for (int _i288 = 0; _i288 < _list287.size; ++_i288)
+                for (int _i292 = 0; _i292 < _list291.size; ++_i292)
+                {
-                  PaymentSettlement _elem289; // required
+                  PaymentSettlement _elem293; // required
-                  _elem289 = new PaymentSettlement();
+                  _elem293 = new PaymentSettlement();
-                  _elem289.read(iprot);
+                  _elem293.read(iprot);
-                  this.success.add(_elem289);
+                  this.success.add(_elem293);
+                }
                 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 _iter290 : this.success)
+          for (PaymentSettlement _iter294 : this.success)
+          {
-            _iter290.write(oprot);
+            _iter294.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 _list291 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list295 = iprot.readListBegin();
-                this.orderIds = new ArrayList<Long>(_list291.size);
+                this.orderIds = new ArrayList<Long>(_list295.size);
-                for (int _i292 = 0; _i292 < _list291.size; ++_i292)
+                for (int _i296 = 0; _i296 < _list295.size; ++_i296)
+                {
-                  long _elem293; // required
+                  long _elem297; // required
-                  _elem293 = iprot.readI64();
+                  _elem297 = iprot.readI64();
-                  this.orderIds.add(_elem293);
+                  this.orderIds.add(_elem297);
+                }
                 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 _iter294 : this.orderIds)
+          for (long _iter298 : this.orderIds)
+          {
-            oprot.writeI64(_iter294);
+            oprot.writeI64(_iter298);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list295 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list299 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list295.size);
+                this.success = 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.success.add(_elem297);
+                  this.success.add(_elem301);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
-          for (long _iter298 : this.success)
+          for (long _iter302 : this.success)
+          {
-            oprot.writeI64(_iter298);
+            oprot.writeI64(_iter302);
+          }
           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 _list299 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list303 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list299.size);
+                this.success = new ArrayList<Order>(_list303.size);
-                for (int _i300 = 0; _i300 < _list299.size; ++_i300)
+                for (int _i304 = 0; _i304 < _list303.size; ++_i304)
+                {
-                  Order _elem301; // required
+                  Order _elem305; // required
-                  _elem301 = new Order();
+                  _elem305 = new Order();
-                  _elem301.read(iprot);
+                  _elem305.read(iprot);
-                  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.STRUCT, this.success.size()));
-          for (Order _iter302 : this.success)
+          for (Order _iter306 : this.success)
+          {
-            _iter302.write(oprot);
+            _iter306.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 _map303 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map307 = iprot.readMapBegin();
-                this.success = new HashMap<Long,Long>(2*_map303.size);
+                this.success = new HashMap<Long,Long>(2*_map307.size);
-                for (int _i304 = 0; _i304 < _map303.size; ++_i304)
+                for (int _i308 = 0; _i308 < _map307.size; ++_i308)
+                {
-                  long _key305; // required
+                  long _key309; // required
-                  long _val306; // required
+                  long _val310; // required
-                  _key305 = iprot.readI64();
+                  _key309 = iprot.readI64();
-                  _val306 = iprot.readI64();
+                  _val310 = iprot.readI64();
-                  this.success.put(_key305, _val306);
+                  this.success.put(_key309, _val310);
+                }
                 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> _iter307 : this.success.entrySet())
+          for (Map.Entry<Long, Long> _iter311 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter307.getKey());
+            oprot.writeI64(_iter311.getKey());
-            oprot.writeI64(_iter307.getValue());
+            oprot.writeI64(_iter311.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 _list308 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list312 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list308.size);
+                this.success = new ArrayList<Long>(_list312.size);
-                for (int _i309 = 0; _i309 < _list308.size; ++_i309)
+                for (int _i313 = 0; _i313 < _list312.size; ++_i313)
+                {
-                  long _elem310; // required
+                  long _elem314; // required
-                  _elem310 = iprot.readI64();
+                  _elem314 = iprot.readI64();
-                  this.success.add(_elem310);
+                  this.success.add(_elem314);
+                }
                 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 _iter311 : this.success)
+          for (long _iter315 : this.success)
+          {
-            oprot.writeI64(_iter311);
+            oprot.writeI64(_iter315);
+          }
           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 _list312 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list316 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list312.size);
+                this.success = new ArrayList<Order>(_list316.size);
-                for (int _i313 = 0; _i313 < _list312.size; ++_i313)
+                for (int _i317 = 0; _i317 < _list316.size; ++_i317)
+                {
-                  Order _elem314; // required
+                  Order _elem318; // required
-                  _elem314 = new Order();
+                  _elem318 = new Order();
-                  _elem314.read(iprot);
+                  _elem318.read(iprot);
-                  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.STRUCT, this.success.size()));
-          for (Order _iter315 : this.success)
+          for (Order _iter319 : this.success)
+          {
-            _iter315.write(oprot);
+            _iter319.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 _list316 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list320 = iprot.readListBegin();
-                this.success = new ArrayList<CODVerificationAgent>(_list316.size);
+                this.success = new ArrayList<CODVerificationAgent>(_list320.size);
-                for (int _i317 = 0; _i317 < _list316.size; ++_i317)
+                for (int _i321 = 0; _i321 < _list320.size; ++_i321)
+                {
-                  CODVerificationAgent _elem318; // required
+                  CODVerificationAgent _elem322; // required
-                  _elem318 = new CODVerificationAgent();
+                  _elem322 = new CODVerificationAgent();
-                  _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 (CODVerificationAgent _iter319 : this.success)
+          for (CODVerificationAgent _iter323 : this.success)
+          {
-            _iter319.write(oprot);
+            _iter323.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 _list320 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list324 = iprot.readListBegin();
-                this.success = new ArrayList<Attribute>(_list320.size);
+                this.success = new ArrayList<Attribute>(_list324.size);
-                for (int _i321 = 0; _i321 < _list320.size; ++_i321)
+                for (int _i325 = 0; _i325 < _list324.size; ++_i325)
+                {
-                  Attribute _elem322; // required
+                  Attribute _elem326; // required
-                  _elem322 = new Attribute();
+                  _elem326 = new Attribute();
-                  _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 (Attribute _iter323 : this.success)
+          for (Attribute _iter327 : this.success)
+          {
-            _iter323.write(oprot);
+            _iter327.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+      }
+    }
+  }
+  public static class setOrderAttributes_args implements org.apache.thrift.TBase<setOrderAttributes_args, setOrderAttributes_args._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("setOrderAttributes_args");
+    private static final org.apache.thrift.protocol.TField ORDER_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("orderId", org.apache.thrift.protocol.TType.I64, (short)1);
+    private static final org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.LIST, (short)-1);
+    private long orderId; // required
+    private List<Attribute> attributes; // 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 {
+      ORDER_ID((short)1, "orderId"),
+      ATTRIBUTES((short)-1, "attributes");
+      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: // ORDER_ID
+            return ORDER_ID;
+          case -1: // ATTRIBUTES
+            return ATTRIBUTES;
+          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 __ORDERID_ISSET_ID = 0;
+    private BitSet __isset_bit_vector = new BitSet(1);
+    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+    static {
+      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+      tmpMap.put(_Fields.ORDER_ID, new org.apache.thrift.meta_data.FieldMetaData("orderId", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      tmpMap.put(_Fields.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", 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, Attribute.class))));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(setOrderAttributes_args.class, metaDataMap);
+    }
+    public setOrderAttributes_args() {
+    }
+    public setOrderAttributes_args(
+      long orderId,
+      List<Attribute> attributes)
+    {
+      this();
+      this.orderId = orderId;
+      setOrderIdIsSet(true);
+      this.attributes = attributes;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public setOrderAttributes_args(setOrderAttributes_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.orderId = other.orderId;
+      if (other.isSetAttributes()) {
+        List<Attribute> __this__attributes = new ArrayList<Attribute>();
+        for (Attribute other_element : other.attributes) {
+          __this__attributes.add(new Attribute(other_element));
+        }
+        this.attributes = __this__attributes;
+      }
+    }
+    public setOrderAttributes_args deepCopy() {
+      return new setOrderAttributes_args(this);
+    }
+    @Override
+    public void clear() {
+      setOrderIdIsSet(false);
+      this.orderId = 0;
+      this.attributes = null;
+    }
+    public long getOrderId() {
+      return this.orderId;
+    }
+    public void setOrderId(long orderId) {
+      this.orderId = orderId;
+      setOrderIdIsSet(true);
+    }
+    public void unsetOrderId() {
+      __isset_bit_vector.clear(__ORDERID_ISSET_ID);
+    }
+    /** Returns true if field orderId is set (has been assigned a value) and false otherwise */
+    public boolean isSetOrderId() {
+      return __isset_bit_vector.get(__ORDERID_ISSET_ID);
+    }
+    public void setOrderIdIsSet(boolean value) {
+      __isset_bit_vector.set(__ORDERID_ISSET_ID, value);
+    }
+    public int getAttributesSize() {
+      return (this.attributes == null) ? 0 : this.attributes.size();
+    }
+    public java.util.Iterator<Attribute> getAttributesIterator() {
+      return (this.attributes == null) ? null : this.attributes.iterator();
+    }
+    public void addToAttributes(Attribute elem) {
+      if (this.attributes == null) {
+        this.attributes = new ArrayList<Attribute>();
+      }
+      this.attributes.add(elem);
+    }
+    public List<Attribute> getAttributes() {
+      return this.attributes;
+    }
+    public void setAttributes(List<Attribute> attributes) {
+      this.attributes = attributes;
+    }
+    public void unsetAttributes() {
+      this.attributes = null;
+    }
+    /** Returns true if field attributes is set (has been assigned a value) and false otherwise */
+    public boolean isSetAttributes() {
+      return this.attributes != null;
+    }
+    public void setAttributesIsSet(boolean value) {
+      if (!value) {
+        this.attributes = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case ORDER_ID:
+        if (value == null) {
+          unsetOrderId();
+        } else {
+          setOrderId((Long)value);
+        }
+        break;
+      case ATTRIBUTES:
+        if (value == null) {
+          unsetAttributes();
+        } else {
+          setAttributes((List<Attribute>)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case ORDER_ID:
+        return Long.valueOf(getOrderId());
+      case ATTRIBUTES:
+        return getAttributes();
+      }
+      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 ORDER_ID:
+        return isSetOrderId();
+      case ATTRIBUTES:
+        return isSetAttributes();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof setOrderAttributes_args)
+        return this.equals((setOrderAttributes_args)that);
+      return false;
+    }
+    public boolean equals(setOrderAttributes_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_orderId = true;
+      boolean that_present_orderId = true;
+      if (this_present_orderId || that_present_orderId) {
+        if (!(this_present_orderId && that_present_orderId))
+          return false;
+        if (this.orderId != that.orderId)
+          return false;
+      }
+      boolean this_present_attributes = true && this.isSetAttributes();
+      boolean that_present_attributes = true && that.isSetAttributes();
+      if (this_present_attributes || that_present_attributes) {
+        if (!(this_present_attributes && that_present_attributes))
+          return false;
+        if (!this.attributes.equals(that.attributes))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(setOrderAttributes_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      setOrderAttributes_args typedOther = (setOrderAttributes_args)other;
+      lastComparison = Boolean.valueOf(isSetOrderId()).compareTo(typedOther.isSetOrderId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetOrderId()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.orderId, typedOther.orderId);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetAttributes()).compareTo(typedOther.isSetAttributes());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetAttributes()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, typedOther.attributes);
+        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: // ORDER_ID
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.orderId = iprot.readI64();
+              setOrderIdIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case -1: // ATTRIBUTES
+            if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
+                org.apache.thrift.protocol.TList _list328 = iprot.readListBegin();
+                this.attributes = new ArrayList<Attribute>(_list328.size);
+                for (int _i329 = 0; _i329 < _list328.size; ++_i329)
+                {
+                  Attribute _elem330; // required
+                  _elem330 = new Attribute();
+                  _elem330.read(iprot);
+                  this.attributes.add(_elem330);
+                }
+                iprot.readListEnd();
+              }
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+      validate();
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.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)
+          {
+            _iter331.write(oprot);
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldBegin(ORDER_ID_FIELD_DESC);
+      oprot.writeI64(this.orderId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("setOrderAttributes_args(");
+      boolean first = true;
+      sb.append("orderId:");
+      sb.append(this.orderId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("attributes:");
+      if (this.attributes == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.attributes);
+      }
+      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 setOrderAttributes_result implements org.apache.thrift.TBase<setOrderAttributes_result, setOrderAttributes_result._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("setOrderAttributes_result");
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+;
+      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) {
+          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;
+      }
+    }
+    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);
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(setOrderAttributes_result.class, metaDataMap);
+    }
+    public setOrderAttributes_result() {
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public setOrderAttributes_result(setOrderAttributes_result other) {
+    }
+    public setOrderAttributes_result deepCopy() {
+      return new setOrderAttributes_result(this);
+    }
+    @Override
+    public void clear() {
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      }
+      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) {
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof setOrderAttributes_result)
+        return this.equals((setOrderAttributes_result)that);
+      return false;
+    }
+    public boolean equals(setOrderAttributes_result that) {
+      if (that == null)
+        return false;
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(setOrderAttributes_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      setOrderAttributes_result typedOther = (setOrderAttributes_result)other;
+      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) {
+          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);
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("setOrderAttributes_result(");
+      boolean first = true;
+      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 setOrderAttributeForTransaction_args implements org.apache.thrift.TBase<setOrderAttributeForTransaction_args, setOrderAttributeForTransaction_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("setOrderAttributeForTransaction_args");
     private static final org.apache.thrift.protocol.TField TRANSACTION_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("transactionId", org.apache.thrift.protocol.TType.I64, (short)1);
     private static final org.apache.thrift.protocol.TField ATTRIBUTE_FIELD_DESC = new org.apache.thrift.protocol.TField("attribute", org.apache.thrift.protocol.TType.STRUCT, (short)-1);
+        }
         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 _list332 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list324.size);
+                this.success = new ArrayList<Order>(_list332.size);
-                for (int _i325 = 0; _i325 < _list324.size; ++_i325)
+                for (int _i333 = 0; _i333 < _list332.size; ++_i333)
+                {
-                  Order _elem326; // required
+                  Order _elem334; // required
-                  _elem326 = new Order();
+                  _elem334 = new Order();
-                  _elem326.read(iprot);
+                  _elem334.read(iprot);
-                  this.success.add(_elem326);
+                  this.success.add(_elem334);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Order _iter327 : this.success)
+          for (Order _iter335 : this.success)
+          {
-            _iter327.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 _list328 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list336 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list328.size);
+                this.success = new ArrayList<Order>(_list336.size);
-                for (int _i329 = 0; _i329 < _list328.size; ++_i329)
+                for (int _i337 = 0; _i337 < _list336.size; ++_i337)
+                {
-                  Order _elem330; // required
+                  Order _elem338; // required
-                  _elem330 = new Order();
+                  _elem338 = new Order();
-                  _elem330.read(iprot);
+                  _elem338.read(iprot);
-                  this.success.add(_elem330);
+                  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 _iter331 : this.success)
+          for (Order _iter339 : this.success)
+          {
-            _iter331.write(oprot);
+            _iter339.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }

Subversion Repositories SmartDukaan

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