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

     public boolean enqueueTransactionInfoEmail(long transactionId) throws TransactionServiceException, org.apache.thrift.TException;
     public List<Order> getAllOrders(OrderStatus status, long from_date, long to_date, long warehouse_id) throws TransactionServiceException, org.apache.thrift.TException;
     /**
+     * Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
+     * Pass the status as null and the limit as 0 to ignore them.
+     *
+     * @param statuses
+     * @param offset
+     * @param limit
+     * @param warehouse_id
+     */
+    public List<Order> getOrdersInBatch(List<OrderStatus> statuses, long offset, long limit, long warehouse_id) throws TransactionServiceException, org.apache.thrift.TException;
+    /**
+     * Returns the count of orders with the given statuses assigned to the given warehouse.
+     *
+     * @param statuses
+     * @param warehouseId
+     */
+    public int getOrderCount(List<OrderStatus> statuses, long warehouseId) throws TransactionServiceException, org.apache.thrift.TException;
+    /**
      * Returns orders within a range of their billing dates
+     *
      * @param status
      * @param start_billing_date
      * @param end_billing_date
     public void enqueueTransactionInfoEmail(long transactionId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.enqueueTransactionInfoEmail_call> resultHandler) throws org.apache.thrift.TException;
     public void getAllOrders(OrderStatus status, long from_date, long to_date, long warehouse_id, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getAllOrders_call> resultHandler) throws org.apache.thrift.TException;
+    public void getOrdersInBatch(List<OrderStatus> statuses, long offset, long limit, long warehouse_id, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getOrdersInBatch_call> resultHandler) throws org.apache.thrift.TException;
+    public void getOrderCount(List<OrderStatus> statuses, long warehouseId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getOrderCount_call> resultHandler) throws org.apache.thrift.TException;
     public void getOrdersByBillingDate(OrderStatus status, long start_billing_date, long end_billing_date, long warehouse_id, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getOrdersByBillingDate_call> resultHandler) throws org.apache.thrift.TException;
     public void getOrdersByShippingDate(long fromShippingDate, long toShippingDate, long providerId, long warehouseId, boolean cod, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getOrdersByShippingDate_call> resultHandler) throws org.apache.thrift.TException;
     public void getReturnableOrdersForCustomer(long customer_id, long limit, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getReturnableOrdersForCustomer_call> resultHandler) throws org.apache.thrift.TException;
         throw result.ex;
+      }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
+    }
+    public List<Order> getOrdersInBatch(List<OrderStatus> statuses, long offset, long limit, long warehouse_id) throws TransactionServiceException, org.apache.thrift.TException
+    {
+      send_getOrdersInBatch(statuses, offset, limit, warehouse_id);
+      return recv_getOrdersInBatch();
+    }
+    public void send_getOrdersInBatch(List<OrderStatus> statuses, long offset, long limit, long warehouse_id) throws org.apache.thrift.TException
+    {
+      getOrdersInBatch_args args = new getOrdersInBatch_args();
+      args.setStatuses(statuses);
+      args.setOffset(offset);
+      args.setLimit(limit);
+      args.setWarehouse_id(warehouse_id);
+      sendBase("getOrdersInBatch", args);
+    }
+    public List<Order> recv_getOrdersInBatch() throws TransactionServiceException, org.apache.thrift.TException
+    {
+      getOrdersInBatch_result result = new getOrdersInBatch_result();
+      receiveBase(result, "getOrdersInBatch");
+      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, "getOrdersInBatch failed: unknown result");
+    }
+    public int getOrderCount(List<OrderStatus> statuses, long warehouseId) throws TransactionServiceException, org.apache.thrift.TException
+    {
+      send_getOrderCount(statuses, warehouseId);
+      return recv_getOrderCount();
+    }
+    public void send_getOrderCount(List<OrderStatus> statuses, long warehouseId) throws org.apache.thrift.TException
+    {
+      getOrderCount_args args = new getOrderCount_args();
+      args.setStatuses(statuses);
+      args.setWarehouseId(warehouseId);
+      sendBase("getOrderCount", args);
+    }
+    public int recv_getOrderCount() throws TransactionServiceException, org.apache.thrift.TException
+    {
+      getOrderCount_result result = new getOrderCount_result();
+      receiveBase(result, "getOrderCount");
+      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, "getOrderCount failed: unknown result");
+    }
     public List<Order> getOrdersByBillingDate(OrderStatus status, long start_billing_date, long end_billing_date, long warehouse_id) throws TransactionServiceException, org.apache.thrift.TException
+    {
       send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id);
       return recv_getOrdersByBillingDate();
+    }
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         return (new Client(prot)).recv_getAllOrders();
+      }
+    }
+    public void getOrdersInBatch(List<OrderStatus> statuses, long offset, long limit, long warehouse_id, org.apache.thrift.async.AsyncMethodCallback<getOrdersInBatch_call> resultHandler) throws org.apache.thrift.TException {
+      checkReady();
+      getOrdersInBatch_call method_call = new getOrdersInBatch_call(statuses, offset, limit, warehouse_id, resultHandler, this, ___protocolFactory, ___transport);
+      this.___currentMethod = method_call;
+      ___manager.call(method_call);
+    }
+    public static class getOrdersInBatch_call extends org.apache.thrift.async.TAsyncMethodCall {
+      private List<OrderStatus> statuses;
+      private long offset;
+      private long limit;
+      private long warehouse_id;
+      public getOrdersInBatch_call(List<OrderStatus> statuses, long offset, long limit, long warehouse_id, org.apache.thrift.async.AsyncMethodCallback<getOrdersInBatch_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.statuses = statuses;
+        this.offset = offset;
+        this.limit = limit;
+        this.warehouse_id = warehouse_id;
+      }
+      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getOrdersInBatch", org.apache.thrift.protocol.TMessageType.CALL, 0));
+        getOrdersInBatch_args args = new getOrdersInBatch_args();
+        args.setStatuses(statuses);
+        args.setOffset(offset);
+        args.setLimit(limit);
+        args.setWarehouse_id(warehouse_id);
+        args.write(prot);
+        prot.writeMessageEnd();
+      }
+      public List<Order> 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_getOrdersInBatch();
+      }
+    }
+    public void getOrderCount(List<OrderStatus> statuses, long warehouseId, org.apache.thrift.async.AsyncMethodCallback<getOrderCount_call> resultHandler) throws org.apache.thrift.TException {
+      checkReady();
+      getOrderCount_call method_call = new getOrderCount_call(statuses, warehouseId, resultHandler, this, ___protocolFactory, ___transport);
+      this.___currentMethod = method_call;
+      ___manager.call(method_call);
+    }
+    public static class getOrderCount_call extends org.apache.thrift.async.TAsyncMethodCall {
+      private List<OrderStatus> statuses;
+      private long warehouseId;
+      public getOrderCount_call(List<OrderStatus> statuses, long warehouseId, org.apache.thrift.async.AsyncMethodCallback<getOrderCount_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.statuses = statuses;
+        this.warehouseId = warehouseId;
+      }
+      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getOrderCount", org.apache.thrift.protocol.TMessageType.CALL, 0));
+        getOrderCount_args args = new getOrderCount_args();
+        args.setStatuses(statuses);
+        args.setWarehouseId(warehouseId);
+        args.write(prot);
+        prot.writeMessageEnd();
+      }
+      public int 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_getOrderCount();
+      }
+    }
     public void getOrdersByBillingDate(OrderStatus status, long start_billing_date, long end_billing_date, long warehouse_id, org.apache.thrift.async.AsyncMethodCallback<getOrdersByBillingDate_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       getOrdersByBillingDate_call method_call = new getOrdersByBillingDate_call(status, start_billing_date, end_billing_date, warehouse_id, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
       processMap.put("getTransactionsForShoppingCartId", new getTransactionsForShoppingCartId());
       processMap.put("getTransactionStatus", new getTransactionStatus());
       processMap.put("changeTransactionStatus", new changeTransactionStatus());
       processMap.put("enqueueTransactionInfoEmail", new enqueueTransactionInfoEmail());
       processMap.put("getAllOrders", new getAllOrders());
+      processMap.put("getOrdersInBatch", new getOrdersInBatch());
+      processMap.put("getOrderCount", new getOrderCount());
       processMap.put("getOrdersByBillingDate", new getOrdersByBillingDate());
       processMap.put("getOrdersByShippingDate", new getOrdersByShippingDate());
       processMap.put("getReturnableOrdersForCustomer", new getReturnableOrdersForCustomer());
       processMap.put("getCancellableOrdersForCustomer", new getCancellableOrdersForCustomer());
       processMap.put("changeOrderStatus", new changeOrderStatus());
+        }
         return result;
+      }
+    }
+    private static class getOrdersInBatch<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getOrdersInBatch_args> {
+      public getOrdersInBatch() {
+        super("getOrdersInBatch");
+      }
+      protected getOrdersInBatch_args getEmptyArgsInstance() {
+        return new getOrdersInBatch_args();
+      }
+      protected getOrdersInBatch_result getResult(I iface, getOrdersInBatch_args args) throws org.apache.thrift.TException {
+        getOrdersInBatch_result result = new getOrdersInBatch_result();
+        try {
+          result.success = iface.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id);
+        } catch (TransactionServiceException ex) {
+          result.ex = ex;
+        }
+        return result;
+      }
+    }
+    private static class getOrderCount<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getOrderCount_args> {
+      public getOrderCount() {
+        super("getOrderCount");
+      }
+      protected getOrderCount_args getEmptyArgsInstance() {
+        return new getOrderCount_args();
+      }
+      protected getOrderCount_result getResult(I iface, getOrderCount_args args) throws org.apache.thrift.TException {
+        getOrderCount_result result = new getOrderCount_result();
+        try {
+          result.success = iface.getOrderCount(args.statuses, args.warehouseId);
+          result.setSuccessIsSet(true);
+        } catch (TransactionServiceException ex) {
+          result.ex = ex;
+        }
+        return result;
+      }
+    }
     private static class getOrdersByBillingDate<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getOrdersByBillingDate_args> {
       public getOrdersByBillingDate() {
         super("getOrdersByBillingDate");
+      }
+      }
+    }
+  }
+  public static class getOrdersInBatch_args implements org.apache.thrift.TBase<getOrdersInBatch_args, getOrdersInBatch_args._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getOrdersInBatch_args");
+    private static final org.apache.thrift.protocol.TField STATUSES_FIELD_DESC = new org.apache.thrift.protocol.TField("statuses", org.apache.thrift.protocol.TType.LIST, (short)1);
+    private static final org.apache.thrift.protocol.TField OFFSET_FIELD_DESC = new org.apache.thrift.protocol.TField("offset", org.apache.thrift.protocol.TType.I64, (short)2);
+    private static final org.apache.thrift.protocol.TField LIMIT_FIELD_DESC = new org.apache.thrift.protocol.TField("limit", org.apache.thrift.protocol.TType.I64, (short)3);
+    private static final org.apache.thrift.protocol.TField WAREHOUSE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("warehouse_id", org.apache.thrift.protocol.TType.I64, (short)4);
+    private List<OrderStatus> statuses; // required
+    private long offset; // required
+    private long limit; // required
+    private long warehouse_id; // 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 {
+      STATUSES((short)1, "statuses"),
+      OFFSET((short)2, "offset"),
+      LIMIT((short)3, "limit"),
+      WAREHOUSE_ID((short)4, "warehouse_id");
+      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: // STATUSES
+            return STATUSES;
+          case 2: // OFFSET
+            return OFFSET;
+          case 3: // LIMIT
+            return LIMIT;
+          case 4: // WAREHOUSE_ID
+            return WAREHOUSE_ID;
+          default:
+            return null;
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, throwing an exception
+       * if it is not found.
+       */
+      public static _Fields findByThriftIdOrThrow(int fieldId) {
+        _Fields fields = findByThriftId(fieldId);
+        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+        return fields;
+      }
+      /**
+       * Find the _Fields constant that matches name, or null if its not found.
+       */
+      public static _Fields findByName(String name) {
+        return byName.get(name);
+      }
+      private final short _thriftId;
+      private final String _fieldName;
+      _Fields(short thriftId, String fieldName) {
+        _thriftId = thriftId;
+        _fieldName = fieldName;
+      }
+      public short getThriftFieldId() {
+        return _thriftId;
+      }
+      public String getFieldName() {
+        return _fieldName;
+      }
+    }
+    // isset id assignments
+    private static final int __OFFSET_ISSET_ID = 0;
+    private static final int __LIMIT_ISSET_ID = 1;
+    private static final int __WAREHOUSE_ID_ISSET_ID = 2;
+    private BitSet __isset_bit_vector = new BitSet(3);
+    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.STATUSES, new org.apache.thrift.meta_data.FieldMetaData("statuses", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+              new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, OrderStatus.class))));
+      tmpMap.put(_Fields.OFFSET, new org.apache.thrift.meta_data.FieldMetaData("offset", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      tmpMap.put(_Fields.LIMIT, new org.apache.thrift.meta_data.FieldMetaData("limit", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      tmpMap.put(_Fields.WAREHOUSE_ID, new org.apache.thrift.meta_data.FieldMetaData("warehouse_id", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getOrdersInBatch_args.class, metaDataMap);
+    }
+    public getOrdersInBatch_args() {
+    }
+    public getOrdersInBatch_args(
+      List<OrderStatus> statuses,
+      long offset,
+      long limit,
+      long warehouse_id)
+    {
+      this();
+      this.statuses = statuses;
+      this.offset = offset;
+      setOffsetIsSet(true);
+      this.limit = limit;
+      setLimitIsSet(true);
+      this.warehouse_id = warehouse_id;
+      setWarehouse_idIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getOrdersInBatch_args(getOrdersInBatch_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      if (other.isSetStatuses()) {
+        List<OrderStatus> __this__statuses = new ArrayList<OrderStatus>();
+        for (OrderStatus other_element : other.statuses) {
+          __this__statuses.add(other_element);
+        }
+        this.statuses = __this__statuses;
+      }
+      this.offset = other.offset;
+      this.limit = other.limit;
+      this.warehouse_id = other.warehouse_id;
+    }
+    public getOrdersInBatch_args deepCopy() {
+      return new getOrdersInBatch_args(this);
+    }
+    @Override
+    public void clear() {
+      this.statuses = null;
+      setOffsetIsSet(false);
+      this.offset = 0;
+      setLimitIsSet(false);
+      this.limit = 0;
+      setWarehouse_idIsSet(false);
+      this.warehouse_id = 0;
+    }
+    public int getStatusesSize() {
+      return (this.statuses == null) ? 0 : this.statuses.size();
+    }
+    public java.util.Iterator<OrderStatus> getStatusesIterator() {
+      return (this.statuses == null) ? null : this.statuses.iterator();
+    }
+    public void addToStatuses(OrderStatus elem) {
+      if (this.statuses == null) {
+        this.statuses = new ArrayList<OrderStatus>();
+      }
+      this.statuses.add(elem);
+    }
+    public List<OrderStatus> getStatuses() {
+      return this.statuses;
+    }
+    public void setStatuses(List<OrderStatus> statuses) {
+      this.statuses = statuses;
+    }
+    public void unsetStatuses() {
+      this.statuses = null;
+    }
+    /** Returns true if field statuses is set (has been assigned a value) and false otherwise */
+    public boolean isSetStatuses() {
+      return this.statuses != null;
+    }
+    public void setStatusesIsSet(boolean value) {
+      if (!value) {
+        this.statuses = null;
+      }
+    }
+    public long getOffset() {
+      return this.offset;
+    }
+    public void setOffset(long offset) {
+      this.offset = offset;
+      setOffsetIsSet(true);
+    }
+    public void unsetOffset() {
+      __isset_bit_vector.clear(__OFFSET_ISSET_ID);
+    }
+    /** Returns true if field offset is set (has been assigned a value) and false otherwise */
+    public boolean isSetOffset() {
+      return __isset_bit_vector.get(__OFFSET_ISSET_ID);
+    }
+    public void setOffsetIsSet(boolean value) {
+      __isset_bit_vector.set(__OFFSET_ISSET_ID, value);
+    }
+    public long getLimit() {
+      return this.limit;
+    }
+    public void setLimit(long limit) {
+      this.limit = limit;
+      setLimitIsSet(true);
+    }
+    public void unsetLimit() {
+      __isset_bit_vector.clear(__LIMIT_ISSET_ID);
+    }
+    /** Returns true if field limit is set (has been assigned a value) and false otherwise */
+    public boolean isSetLimit() {
+      return __isset_bit_vector.get(__LIMIT_ISSET_ID);
+    }
+    public void setLimitIsSet(boolean value) {
+      __isset_bit_vector.set(__LIMIT_ISSET_ID, value);
+    }
+    public long getWarehouse_id() {
+      return this.warehouse_id;
+    }
+    public void setWarehouse_id(long warehouse_id) {
+      this.warehouse_id = warehouse_id;
+      setWarehouse_idIsSet(true);
+    }
+    public void unsetWarehouse_id() {
+      __isset_bit_vector.clear(__WAREHOUSE_ID_ISSET_ID);
+    }
+    /** Returns true if field warehouse_id is set (has been assigned a value) and false otherwise */
+    public boolean isSetWarehouse_id() {
+      return __isset_bit_vector.get(__WAREHOUSE_ID_ISSET_ID);
+    }
+    public void setWarehouse_idIsSet(boolean value) {
+      __isset_bit_vector.set(__WAREHOUSE_ID_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case STATUSES:
+        if (value == null) {
+          unsetStatuses();
+        } else {
+          setStatuses((List<OrderStatus>)value);
+        }
+        break;
+      case OFFSET:
+        if (value == null) {
+          unsetOffset();
+        } else {
+          setOffset((Long)value);
+        }
+        break;
+      case LIMIT:
+        if (value == null) {
+          unsetLimit();
+        } else {
+          setLimit((Long)value);
+        }
+        break;
+      case WAREHOUSE_ID:
+        if (value == null) {
+          unsetWarehouse_id();
+        } else {
+          setWarehouse_id((Long)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case STATUSES:
+        return getStatuses();
+      case OFFSET:
+        return Long.valueOf(getOffset());
+      case LIMIT:
+        return Long.valueOf(getLimit());
+      case WAREHOUSE_ID:
+        return Long.valueOf(getWarehouse_id());
+      }
+      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 STATUSES:
+        return isSetStatuses();
+      case OFFSET:
+        return isSetOffset();
+      case LIMIT:
+        return isSetLimit();
+      case WAREHOUSE_ID:
+        return isSetWarehouse_id();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof getOrdersInBatch_args)
+        return this.equals((getOrdersInBatch_args)that);
+      return false;
+    }
+    public boolean equals(getOrdersInBatch_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_statuses = true && this.isSetStatuses();
+      boolean that_present_statuses = true && that.isSetStatuses();
+      if (this_present_statuses || that_present_statuses) {
+        if (!(this_present_statuses && that_present_statuses))
+          return false;
+        if (!this.statuses.equals(that.statuses))
+          return false;
+      }
+      boolean this_present_offset = true;
+      boolean that_present_offset = true;
+      if (this_present_offset || that_present_offset) {
+        if (!(this_present_offset && that_present_offset))
+          return false;
+        if (this.offset != that.offset)
+          return false;
+      }
+      boolean this_present_limit = true;
+      boolean that_present_limit = true;
+      if (this_present_limit || that_present_limit) {
+        if (!(this_present_limit && that_present_limit))
+          return false;
+        if (this.limit != that.limit)
+          return false;
+      }
+      boolean this_present_warehouse_id = true;
+      boolean that_present_warehouse_id = true;
+      if (this_present_warehouse_id || that_present_warehouse_id) {
+        if (!(this_present_warehouse_id && that_present_warehouse_id))
+          return false;
+        if (this.warehouse_id != that.warehouse_id)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getOrdersInBatch_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getOrdersInBatch_args typedOther = (getOrdersInBatch_args)other;
+      lastComparison = Boolean.valueOf(isSetStatuses()).compareTo(typedOther.isSetStatuses());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetStatuses()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.statuses, typedOther.statuses);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetOffset()).compareTo(typedOther.isSetOffset());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetOffset()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.offset, typedOther.offset);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetLimit()).compareTo(typedOther.isSetLimit());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetLimit()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.limit, typedOther.limit);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetWarehouse_id()).compareTo(typedOther.isSetWarehouse_id());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetWarehouse_id()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.warehouse_id, typedOther.warehouse_id);
+        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: // STATUSES
+            if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
+                org.apache.thrift.protocol.TList _list20 = iprot.readListBegin();
+                this.statuses = new ArrayList<OrderStatus>(_list20.size);
+                for (int _i21 = 0; _i21 < _list20.size; ++_i21)
+                {
+                  OrderStatus _elem22; // required
+                  _elem22 = OrderStatus.findByValue(iprot.readI32());
+                  this.statuses.add(_elem22);
+                }
+                iprot.readListEnd();
+              }
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 2: // OFFSET
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.offset = iprot.readI64();
+              setOffsetIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 3: // LIMIT
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.limit = iprot.readI64();
+              setLimitIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 4: // WAREHOUSE_ID
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.warehouse_id = iprot.readI64();
+              setWarehouse_idIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+      validate();
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.statuses != null) {
+        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
+        {
+          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
+          for (OrderStatus _iter23 : this.statuses)
+          {
+            oprot.writeI32(_iter23.getValue());
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldBegin(OFFSET_FIELD_DESC);
+      oprot.writeI64(this.offset);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(LIMIT_FIELD_DESC);
+      oprot.writeI64(this.limit);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(WAREHOUSE_ID_FIELD_DESC);
+      oprot.writeI64(this.warehouse_id);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getOrdersInBatch_args(");
+      boolean first = true;
+      sb.append("statuses:");
+      if (this.statuses == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.statuses);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("offset:");
+      sb.append(this.offset);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("limit:");
+      sb.append(this.limit);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("warehouse_id:");
+      sb.append(this.warehouse_id);
+      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 getOrdersInBatch_result implements org.apache.thrift.TBase<getOrdersInBatch_result, getOrdersInBatch_result._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getOrdersInBatch_result");
+    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0);
+    private 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 List<Order> success; // required
+    private TransactionServiceException ex; // required
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+      SUCCESS((short)0, "success"),
+      EX((short)1, "ex");
+      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+      static {
+        for (_Fields field : EnumSet.allOf(_Fields.class)) {
+          byName.put(field.getFieldName(), field);
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, or null if its not found.
+       */
+      public static _Fields findByThriftId(int fieldId) {
+        switch(fieldId) {
+          case 0: // SUCCESS
+            return SUCCESS;
+          case 1: // EX
+            return EX;
+          default:
+            return null;
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, throwing an exception
+       * if it is not found.
+       */
+      public static _Fields findByThriftIdOrThrow(int fieldId) {
+        _Fields fields = findByThriftId(fieldId);
+        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+        return fields;
+      }
+      /**
+       * Find the _Fields constant that matches name, or null if its not found.
+       */
+      public static _Fields findByName(String name) {
+        return byName.get(name);
+      }
+      private final short _thriftId;
+      private final String _fieldName;
+      _Fields(short thriftId, String fieldName) {
+        _thriftId = thriftId;
+        _fieldName = fieldName;
+      }
+      public short getThriftFieldId() {
+        return _thriftId;
+      }
+      public String getFieldName() {
+        return _fieldName;
+      }
+    }
+    // isset id assignments
+    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+    static {
+      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+              new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Order.class))));
+      tmpMap.put(_Fields.EX, new org.apache.thrift.meta_data.FieldMetaData("ex", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getOrdersInBatch_result.class, metaDataMap);
+    }
+    public getOrdersInBatch_result() {
+    }
+    public getOrdersInBatch_result(
+      List<Order> success,
+      TransactionServiceException ex)
+    {
+      this();
+      this.success = success;
+      this.ex = ex;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getOrdersInBatch_result(getOrdersInBatch_result other) {
+      if (other.isSetSuccess()) {
+        List<Order> __this__success = new ArrayList<Order>();
+        for (Order other_element : other.success) {
+          __this__success.add(new Order(other_element));
+        }
+        this.success = __this__success;
+      }
+      if (other.isSetEx()) {
+        this.ex = new TransactionServiceException(other.ex);
+      }
+    }
+    public getOrdersInBatch_result deepCopy() {
+      return new getOrdersInBatch_result(this);
+    }
+    @Override
+    public void clear() {
+      this.success = null;
+      this.ex = null;
+    }
+    public int getSuccessSize() {
+      return (this.success == null) ? 0 : this.success.size();
+    }
+    public java.util.Iterator<Order> getSuccessIterator() {
+      return (this.success == null) ? null : this.success.iterator();
+    }
+    public void addToSuccess(Order elem) {
+      if (this.success == null) {
+        this.success = new ArrayList<Order>();
+      }
+      this.success.add(elem);
+    }
+    public List<Order> getSuccess() {
+      return this.success;
+    }
+    public void setSuccess(List<Order> success) {
+      this.success = success;
+    }
+    public void unsetSuccess() {
+      this.success = null;
+    }
+    /** Returns true if field success is set (has been assigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return this.success != null;
+    }
+    public void setSuccessIsSet(boolean value) {
+      if (!value) {
+        this.success = null;
+      }
+    }
+    public 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((List<Order>)value);
+        }
+        break;
+      case EX:
+        if (value == null) {
+          unsetEx();
+        } else {
+          setEx((TransactionServiceException)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case SUCCESS:
+        return getSuccess();
+      case EX:
+        return getEx();
+      }
+      throw new IllegalStateException();
+    }
+    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+    public boolean isSet(_Fields field) {
+      if (field == null) {
+        throw new IllegalArgumentException();
+      }
+      switch (field) {
+      case SUCCESS:
+        return isSetSuccess();
+      case EX:
+        return isSetEx();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof getOrdersInBatch_result)
+        return this.equals((getOrdersInBatch_result)that);
+      return false;
+    }
+    public boolean equals(getOrdersInBatch_result that) {
+      if (that == null)
+        return false;
+      boolean this_present_success = true && this.isSetSuccess();
+      boolean that_present_success = true && that.isSetSuccess();
+      if (this_present_success || that_present_success) {
+        if (!(this_present_success && that_present_success))
+          return false;
+        if (!this.success.equals(that.success))
+          return false;
+      }
+      boolean this_present_ex = true && this.isSetEx();
+      boolean that_present_ex = true && that.isSetEx();
+      if (this_present_ex || that_present_ex) {
+        if (!(this_present_ex && that_present_ex))
+          return false;
+        if (!this.ex.equals(that.ex))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getOrdersInBatch_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getOrdersInBatch_result typedOther = (getOrdersInBatch_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.LIST) {
+              {
+                org.apache.thrift.protocol.TList _list24 = iprot.readListBegin();
+                this.success = new ArrayList<Order>(_list24.size);
+                for (int _i25 = 0; _i25 < _list24.size; ++_i25)
+                {
+                  Order _elem26; // required
+                  _elem26 = new Order();
+                  _elem26.read(iprot);
+                  this.success.add(_elem26);
+                }
+                iprot.readListEnd();
+              }
+            } 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.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
+          for (Order _iter27 : this.success)
+          {
+            _iter27.write(oprot);
+          }
+          oprot.writeListEnd();
+        }
+        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("getOrdersInBatch_result(");
+      boolean first = true;
+      sb.append("success:");
+      if (this.success == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.success);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("ex:");
+      if (this.ex == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.ex);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws org.apache.thrift.TException {
+      // check for required fields
+    }
+    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+      try {
+        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+      try {
+        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+  }
+  public static class getOrderCount_args implements org.apache.thrift.TBase<getOrderCount_args, getOrderCount_args._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getOrderCount_args");
+    private static final org.apache.thrift.protocol.TField STATUSES_FIELD_DESC = new org.apache.thrift.protocol.TField("statuses", org.apache.thrift.protocol.TType.LIST, (short)1);
+    private static final org.apache.thrift.protocol.TField WAREHOUSE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("warehouseId", org.apache.thrift.protocol.TType.I64, (short)2);
+    private List<OrderStatus> statuses; // required
+    private long warehouseId; // 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 {
+      STATUSES((short)1, "statuses"),
+      WAREHOUSE_ID((short)2, "warehouseId");
+      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: // STATUSES
+            return STATUSES;
+          case 2: // WAREHOUSE_ID
+            return WAREHOUSE_ID;
+          default:
+            return null;
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, throwing an exception
+       * if it is not found.
+       */
+      public static _Fields findByThriftIdOrThrow(int fieldId) {
+        _Fields fields = findByThriftId(fieldId);
+        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+        return fields;
+      }
+      /**
+       * Find the _Fields constant that matches name, or null if its not found.
+       */
+      public static _Fields findByName(String name) {
+        return byName.get(name);
+      }
+      private final short _thriftId;
+      private final String _fieldName;
+      _Fields(short thriftId, String fieldName) {
+        _thriftId = thriftId;
+        _fieldName = fieldName;
+      }
+      public short getThriftFieldId() {
+        return _thriftId;
+      }
+      public String getFieldName() {
+        return _fieldName;
+      }
+    }
+    // isset id assignments
+    private static final int __WAREHOUSEID_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.STATUSES, new org.apache.thrift.meta_data.FieldMetaData("statuses", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+              new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, OrderStatus.class))));
+      tmpMap.put(_Fields.WAREHOUSE_ID, new org.apache.thrift.meta_data.FieldMetaData("warehouseId", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getOrderCount_args.class, metaDataMap);
+    }
+    public getOrderCount_args() {
+    }
+    public getOrderCount_args(
+      List<OrderStatus> statuses,
+      long warehouseId)
+    {
+      this();
+      this.statuses = statuses;
+      this.warehouseId = warehouseId;
+      setWarehouseIdIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getOrderCount_args(getOrderCount_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      if (other.isSetStatuses()) {
+        List<OrderStatus> __this__statuses = new ArrayList<OrderStatus>();
+        for (OrderStatus other_element : other.statuses) {
+          __this__statuses.add(other_element);
+        }
+        this.statuses = __this__statuses;
+      }
+      this.warehouseId = other.warehouseId;
+    }
+    public getOrderCount_args deepCopy() {
+      return new getOrderCount_args(this);
+    }
+    @Override
+    public void clear() {
+      this.statuses = null;
+      setWarehouseIdIsSet(false);
+      this.warehouseId = 0;
+    }
+    public int getStatusesSize() {
+      return (this.statuses == null) ? 0 : this.statuses.size();
+    }
+    public java.util.Iterator<OrderStatus> getStatusesIterator() {
+      return (this.statuses == null) ? null : this.statuses.iterator();
+    }
+    public void addToStatuses(OrderStatus elem) {
+      if (this.statuses == null) {
+        this.statuses = new ArrayList<OrderStatus>();
+      }
+      this.statuses.add(elem);
+    }
+    public List<OrderStatus> getStatuses() {
+      return this.statuses;
+    }
+    public void setStatuses(List<OrderStatus> statuses) {
+      this.statuses = statuses;
+    }
+    public void unsetStatuses() {
+      this.statuses = null;
+    }
+    /** Returns true if field statuses is set (has been assigned a value) and false otherwise */
+    public boolean isSetStatuses() {
+      return this.statuses != null;
+    }
+    public void setStatusesIsSet(boolean value) {
+      if (!value) {
+        this.statuses = null;
+      }
+    }
+    public long getWarehouseId() {
+      return this.warehouseId;
+    }
+    public void setWarehouseId(long warehouseId) {
+      this.warehouseId = warehouseId;
+      setWarehouseIdIsSet(true);
+    }
+    public void unsetWarehouseId() {
+      __isset_bit_vector.clear(__WAREHOUSEID_ISSET_ID);
+    }
+    /** Returns true if field warehouseId is set (has been assigned a value) and false otherwise */
+    public boolean isSetWarehouseId() {
+      return __isset_bit_vector.get(__WAREHOUSEID_ISSET_ID);
+    }
+    public void setWarehouseIdIsSet(boolean value) {
+      __isset_bit_vector.set(__WAREHOUSEID_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case STATUSES:
+        if (value == null) {
+          unsetStatuses();
+        } else {
+          setStatuses((List<OrderStatus>)value);
+        }
+        break;
+      case WAREHOUSE_ID:
+        if (value == null) {
+          unsetWarehouseId();
+        } else {
+          setWarehouseId((Long)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case STATUSES:
+        return getStatuses();
+      case WAREHOUSE_ID:
+        return Long.valueOf(getWarehouseId());
+      }
+      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 STATUSES:
+        return isSetStatuses();
+      case WAREHOUSE_ID:
+        return isSetWarehouseId();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof getOrderCount_args)
+        return this.equals((getOrderCount_args)that);
+      return false;
+    }
+    public boolean equals(getOrderCount_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_statuses = true && this.isSetStatuses();
+      boolean that_present_statuses = true && that.isSetStatuses();
+      if (this_present_statuses || that_present_statuses) {
+        if (!(this_present_statuses && that_present_statuses))
+          return false;
+        if (!this.statuses.equals(that.statuses))
+          return false;
+      }
+      boolean this_present_warehouseId = true;
+      boolean that_present_warehouseId = true;
+      if (this_present_warehouseId || that_present_warehouseId) {
+        if (!(this_present_warehouseId && that_present_warehouseId))
+          return false;
+        if (this.warehouseId != that.warehouseId)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getOrderCount_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getOrderCount_args typedOther = (getOrderCount_args)other;
+      lastComparison = Boolean.valueOf(isSetStatuses()).compareTo(typedOther.isSetStatuses());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetStatuses()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.statuses, typedOther.statuses);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetWarehouseId()).compareTo(typedOther.isSetWarehouseId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetWarehouseId()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.warehouseId, typedOther.warehouseId);
+        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: // STATUSES
+            if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
+                org.apache.thrift.protocol.TList _list28 = iprot.readListBegin();
+                this.statuses = new ArrayList<OrderStatus>(_list28.size);
+                for (int _i29 = 0; _i29 < _list28.size; ++_i29)
+                {
+                  OrderStatus _elem30; // required
+                  _elem30 = OrderStatus.findByValue(iprot.readI32());
+                  this.statuses.add(_elem30);
+                }
+                iprot.readListEnd();
+              }
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 2: // WAREHOUSE_ID
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.warehouseId = iprot.readI64();
+              setWarehouseIdIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+      validate();
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.statuses != null) {
+        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
+        {
+          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
+          for (OrderStatus _iter31 : this.statuses)
+          {
+            oprot.writeI32(_iter31.getValue());
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldBegin(WAREHOUSE_ID_FIELD_DESC);
+      oprot.writeI64(this.warehouseId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getOrderCount_args(");
+      boolean first = true;
+      sb.append("statuses:");
+      if (this.statuses == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.statuses);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("warehouseId:");
+      sb.append(this.warehouseId);
+      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 getOrderCount_result implements org.apache.thrift.TBase<getOrderCount_result, getOrderCount_result._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getOrderCount_result");
+    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.I32, (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 int 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.I32)));
+      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(getOrderCount_result.class, metaDataMap);
+    }
+    public getOrderCount_result() {
+    }
+    public getOrderCount_result(
+      int success,
+      TransactionServiceException ex)
+    {
+      this();
+      this.success = success;
+      setSuccessIsSet(true);
+      this.ex = ex;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getOrderCount_result(getOrderCount_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 getOrderCount_result deepCopy() {
+      return new getOrderCount_result(this);
+    }
+    @Override
+    public void clear() {
+      setSuccessIsSet(false);
+      this.success = 0;
+      this.ex = null;
+    }
+    public int getSuccess() {
+      return this.success;
+    }
+    public void setSuccess(int 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((Integer)value);
+        }
+        break;
+      case EX:
+        if (value == null) {
+          unsetEx();
+        } else {
+          setEx((TransactionServiceException)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case SUCCESS:
+        return Integer.valueOf(getSuccess());
+      case EX:
+        return getEx();
+      }
+      throw new IllegalStateException();
+    }
+    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+    public boolean isSet(_Fields field) {
+      if (field == null) {
+        throw new IllegalArgumentException();
+      }
+      switch (field) {
+      case SUCCESS:
+        return isSetSuccess();
+      case EX:
+        return isSetEx();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof getOrderCount_result)
+        return this.equals((getOrderCount_result)that);
+      return false;
+    }
+    public boolean equals(getOrderCount_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(getOrderCount_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getOrderCount_result typedOther = (getOrderCount_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.I32) {
+              this.success = iprot.readI32();
+              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.writeI32(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("getOrderCount_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 getOrdersByBillingDate_args implements org.apache.thrift.TBase<getOrdersByBillingDate_args, getOrdersByBillingDate_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getOrdersByBillingDate_args");
     private static final org.apache.thrift.protocol.TField STATUS_FIELD_DESC = new org.apache.thrift.protocol.TField("status", org.apache.thrift.protocol.TType.I32, (short)1);
     private static final org.apache.thrift.protocol.TField START_BILLING_DATE_FIELD_DESC = new org.apache.thrift.protocol.TField("start_billing_date", org.apache.thrift.protocol.TType.I64, (short)2);
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list20 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list32 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list20.size);
+                this.success = new ArrayList<Order>(_list32.size);
-                for (int _i21 = 0; _i21 < _list20.size; ++_i21)
+                for (int _i33 = 0; _i33 < _list32.size; ++_i33)
+                {
-                  Order _elem22; // required
+                  Order _elem34; // required
-                  _elem22 = new Order();
+                  _elem34 = new Order();
-                  _elem22.read(iprot);
+                  _elem34.read(iprot);
-                  this.success.add(_elem22);
+                  this.success.add(_elem34);
+                }
                 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 _iter23 : this.success)
+          for (Order _iter35 : this.success)
+          {
-            _iter23.write(oprot);
+            _iter35.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 _list24 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list36 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list24.size);
+                this.success = new ArrayList<Order>(_list36.size);
-                for (int _i25 = 0; _i25 < _list24.size; ++_i25)
+                for (int _i37 = 0; _i37 < _list36.size; ++_i37)
+                {
-                  Order _elem26; // required
+                  Order _elem38; // required
-                  _elem26 = new Order();
+                  _elem38 = new Order();
-                  _elem26.read(iprot);
+                  _elem38.read(iprot);
-                  this.success.add(_elem26);
+                  this.success.add(_elem38);
+                }
                 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 _iter27 : this.success)
+          for (Order _iter39 : this.success)
+          {
-            _iter27.write(oprot);
+            _iter39.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 _list28 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list40 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list28.size);
+                this.success = new ArrayList<Long>(_list40.size);
-                for (int _i29 = 0; _i29 < _list28.size; ++_i29)
+                for (int _i41 = 0; _i41 < _list40.size; ++_i41)
+                {
-                  long _elem30; // required
+                  long _elem42; // required
-                  _elem30 = iprot.readI64();
+                  _elem42 = iprot.readI64();
-                  this.success.add(_elem30);
+                  this.success.add(_elem42);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
-          for (long _iter31 : this.success)
+          for (long _iter43 : this.success)
+          {
-            oprot.writeI64(_iter31);
+            oprot.writeI64(_iter43);
+          }
           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 _list32 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list44 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list32.size);
+                this.success = new ArrayList<Long>(_list44.size);
-                for (int _i33 = 0; _i33 < _list32.size; ++_i33)
+                for (int _i45 = 0; _i45 < _list44.size; ++_i45)
+                {
-                  long _elem34; // required
+                  long _elem46; // required
-                  _elem34 = iprot.readI64();
+                  _elem46 = iprot.readI64();
-                  this.success.add(_elem34);
+                  this.success.add(_elem46);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
-          for (long _iter35 : this.success)
+          for (long _iter47 : this.success)
+          {
-            oprot.writeI64(_iter35);
+            oprot.writeI64(_iter47);
+          }
           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 _list36 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list48 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list36.size);
+                this.success = new ArrayList<Order>(_list48.size);
-                for (int _i37 = 0; _i37 < _list36.size; ++_i37)
+                for (int _i49 = 0; _i49 < _list48.size; ++_i49)
+                {
-                  Order _elem38; // required
+                  Order _elem50; // required
-                  _elem38 = new Order();
+                  _elem50 = new Order();
-                  _elem38.read(iprot);
+                  _elem50.read(iprot);
-                  this.success.add(_elem38);
+                  this.success.add(_elem50);
+                }
                 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 _iter39 : this.success)
+          for (Order _iter51 : this.success)
+          {
-            _iter39.write(oprot);
+            _iter51.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+            }
             break;
           case 4: // STATUSES
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list40 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list52 = iprot.readListBegin();
-                this.statuses = new ArrayList<OrderStatus>(_list40.size);
+                this.statuses = new ArrayList<OrderStatus>(_list52.size);
-                for (int _i41 = 0; _i41 < _list40.size; ++_i41)
+                for (int _i53 = 0; _i53 < _list52.size; ++_i53)
+                {
-                  OrderStatus _elem42; // required
+                  OrderStatus _elem54; // required
-                  _elem42 = OrderStatus.findByValue(iprot.readI32());
+                  _elem54 = OrderStatus.findByValue(iprot.readI32());
-                  this.statuses.add(_elem42);
+                  this.statuses.add(_elem54);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeFieldEnd();
       if (this.statuses != null) {
         oprot.writeFieldBegin(STATUSES_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
-          for (OrderStatus _iter43 : this.statuses)
+          for (OrderStatus _iter55 : this.statuses)
+          {
-            oprot.writeI32(_iter43.getValue());
+            oprot.writeI32(_iter55.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 _list44 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list56 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list44.size);
+                this.success = new ArrayList<Order>(_list56.size);
-                for (int _i45 = 0; _i45 < _list44.size; ++_i45)
+                for (int _i57 = 0; _i57 < _list56.size; ++_i57)
+                {
-                  Order _elem46; // required
+                  Order _elem58; // required
-                  _elem46 = new Order();
+                  _elem58 = new Order();
-                  _elem46.read(iprot);
+                  _elem58.read(iprot);
-                  this.success.add(_elem46);
+                  this.success.add(_elem58);
+                }
                 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 _iter47 : this.success)
+          for (Order _iter59 : this.success)
+          {
-            _iter47.write(oprot);
+            _iter59.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 _list48 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list60 = iprot.readListBegin();
-                this.success = new ArrayList<LineItem>(_list48.size);
+                this.success = new ArrayList<LineItem>(_list60.size);
-                for (int _i49 = 0; _i49 < _list48.size; ++_i49)
+                for (int _i61 = 0; _i61 < _list60.size; ++_i61)
+                {
-                  LineItem _elem50; // required
+                  LineItem _elem62; // required
-                  _elem50 = new LineItem();
+                  _elem62 = new LineItem();
-                  _elem50.read(iprot);
+                  _elem62.read(iprot);
-                  this.success.add(_elem50);
+                  this.success.add(_elem62);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (LineItem _iter51 : this.success)
+          for (LineItem _iter63 : this.success)
+          {
-            _iter51.write(oprot);
+            _iter63.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 _list52 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list64 = iprot.readListBegin();
-                this.success = new ArrayList<Alert>(_list52.size);
+                this.success = new ArrayList<Alert>(_list64.size);
-                for (int _i53 = 0; _i53 < _list52.size; ++_i53)
+                for (int _i65 = 0; _i65 < _list64.size; ++_i65)
+                {
-                  Alert _elem54; // required
+                  Alert _elem66; // required
-                  _elem54 = new Alert();
+                  _elem66 = new Alert();
-                  _elem54.read(iprot);
+                  _elem66.read(iprot);
-                  this.success.add(_elem54);
+                  this.success.add(_elem66);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Alert _iter55 : this.success)
+          for (Alert _iter67 : this.success)
+          {
-            _iter55.write(oprot);
+            _iter67.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 _list56 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list68 = iprot.readListBegin();
-                this.success = new ArrayList<Double>(_list56.size);
+                this.success = new ArrayList<Double>(_list68.size);
-                for (int _i57 = 0; _i57 < _list56.size; ++_i57)
+                for (int _i69 = 0; _i69 < _list68.size; ++_i69)
+                {
-                  double _elem58; // required
+                  double _elem70; // required
-                  _elem58 = iprot.readDouble();
+                  _elem70 = iprot.readDouble();
-                  this.success.add(_elem58);
+                  this.success.add(_elem70);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.DOUBLE, this.success.size()));
-          for (double _iter59 : this.success)
+          for (double _iter71 : this.success)
+          {
-            oprot.writeDouble(_iter59);
+            oprot.writeDouble(_iter71);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list60 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list72 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list60.size);
+                this.success = new ArrayList<Order>(_list72.size);
-                for (int _i61 = 0; _i61 < _list60.size; ++_i61)
+                for (int _i73 = 0; _i73 < _list72.size; ++_i73)
+                {
-                  Order _elem62; // required
+                  Order _elem74; // required
-                  _elem62 = new Order();
+                  _elem74 = new Order();
-                  _elem62.read(iprot);
+                  _elem74.read(iprot);
-                  this.success.add(_elem62);
+                  this.success.add(_elem74);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Order _iter63 : this.success)
+          for (Order _iter75 : this.success)
+          {
-            _iter63.write(oprot);
+            _iter75.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 _list64 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list76 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list64.size);
+                this.success = new ArrayList<Order>(_list76.size);
-                for (int _i65 = 0; _i65 < _list64.size; ++_i65)
+                for (int _i77 = 0; _i77 < _list76.size; ++_i77)
+                {
-                  Order _elem66; // required
+                  Order _elem78; // required
-                  _elem66 = new Order();
+                  _elem78 = new Order();
-                  _elem66.read(iprot);
+                  _elem78.read(iprot);
-                  this.success.add(_elem66);
+                  this.success.add(_elem78);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Order _iter67 : this.success)
+          for (Order _iter79 : this.success)
+          {
-            _iter67.write(oprot);
+            _iter79.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+            }
             break;
           case 2: // PICKUP_DETAILS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map68 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map80 = iprot.readMapBegin();
-                this.pickupDetails = new HashMap<String,String>(2*_map68.size);
+                this.pickupDetails = new HashMap<String,String>(2*_map80.size);
-                for (int _i69 = 0; _i69 < _map68.size; ++_i69)
+                for (int _i81 = 0; _i81 < _map80.size; ++_i81)
+                {
-                  String _key70; // required
+                  String _key82; // required
-                  String _val71; // required
+                  String _val83; // required
-                  _key70 = iprot.readString();
+                  _key82 = iprot.readString();
-                  _val71 = iprot.readString();
+                  _val83 = iprot.readString();
-                  this.pickupDetails.put(_key70, _val71);
+                  this.pickupDetails.put(_key82, _val83);
+                }
                 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> _iter72 : this.pickupDetails.entrySet())
+          for (Map.Entry<String, String> _iter84 : this.pickupDetails.entrySet())
+          {
-            oprot.writeString(_iter72.getKey());
+            oprot.writeString(_iter84.getKey());
-            oprot.writeString(_iter72.getValue());
+            oprot.writeString(_iter84.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 _list73 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list85 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list73.size);
+                this.success = new ArrayList<Order>(_list85.size);
-                for (int _i74 = 0; _i74 < _list73.size; ++_i74)
+                for (int _i86 = 0; _i86 < _list85.size; ++_i86)
+                {
-                  Order _elem75; // required
+                  Order _elem87; // required
-                  _elem75 = new Order();
+                  _elem87 = new Order();
-                  _elem75.read(iprot);
+                  _elem87.read(iprot);
-                  this.success.add(_elem75);
+                  this.success.add(_elem87);
+                }
                 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 _iter76 : this.success)
+          for (Order _iter88 : this.success)
+          {
-            _iter76.write(oprot);
+            _iter88.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+            }
             break;
           case 2: // DELIVERED_ORDERS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map77 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map89 = iprot.readMapBegin();
-                this.deliveredOrders = new HashMap<String,String>(2*_map77.size);
+                this.deliveredOrders = new HashMap<String,String>(2*_map89.size);
-                for (int _i78 = 0; _i78 < _map77.size; ++_i78)
+                for (int _i90 = 0; _i90 < _map89.size; ++_i90)
+                {
-                  String _key79; // required
+                  String _key91; // required
-                  String _val80; // required
+                  String _val92; // required
-                  _key79 = iprot.readString();
+                  _key91 = iprot.readString();
-                  _val80 = iprot.readString();
+                  _val92 = iprot.readString();
-                  this.deliveredOrders.put(_key79, _val80);
+                  this.deliveredOrders.put(_key91, _val92);
+                }
                 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> _iter81 : this.deliveredOrders.entrySet())
+          for (Map.Entry<String, String> _iter93 : this.deliveredOrders.entrySet())
+          {
-            oprot.writeString(_iter81.getKey());
+            oprot.writeString(_iter93.getKey());
-            oprot.writeString(_iter81.getValue());
+            oprot.writeString(_iter93.getValue());
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }
+            }
             break;
           case 2: // RETURNED_ORDERS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map82 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map94 = iprot.readMapBegin();
-                this.returnedOrders = new HashMap<String,String>(2*_map82.size);
+                this.returnedOrders = new HashMap<String,String>(2*_map94.size);
-                for (int _i83 = 0; _i83 < _map82.size; ++_i83)
+                for (int _i95 = 0; _i95 < _map94.size; ++_i95)
+                {
-                  String _key84; // required
+                  String _key96; // required
-                  String _val85; // required
+                  String _val97; // required
-                  _key84 = iprot.readString();
+                  _key96 = iprot.readString();
-                  _val85 = iprot.readString();
+                  _val97 = iprot.readString();
-                  this.returnedOrders.put(_key84, _val85);
+                  this.returnedOrders.put(_key96, _val97);
+                }
                 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> _iter86 : this.returnedOrders.entrySet())
+          for (Map.Entry<String, String> _iter98 : this.returnedOrders.entrySet())
+          {
-            oprot.writeString(_iter86.getKey());
+            oprot.writeString(_iter98.getKey());
-            oprot.writeString(_iter86.getValue());
+            oprot.writeString(_iter98.getValue());
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }
+            }
             break;
           case 2: // UNDELIVERED_ORDERS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map87 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map99 = iprot.readMapBegin();
-                this.undeliveredOrders = new HashMap<String,String>(2*_map87.size);
+                this.undeliveredOrders = new HashMap<String,String>(2*_map99.size);
-                for (int _i88 = 0; _i88 < _map87.size; ++_i88)
+                for (int _i100 = 0; _i100 < _map99.size; ++_i100)
+                {
-                  String _key89; // required
+                  String _key101; // required
-                  String _val90; // required
+                  String _val102; // required
-                  _key89 = iprot.readString();
+                  _key101 = iprot.readString();
-                  _val90 = iprot.readString();
+                  _val102 = iprot.readString();
-                  this.undeliveredOrders.put(_key89, _val90);
+                  this.undeliveredOrders.put(_key101, _val102);
+                }
                 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> _iter91 : this.undeliveredOrders.entrySet())
+          for (Map.Entry<String, String> _iter103 : this.undeliveredOrders.entrySet())
+          {
-            oprot.writeString(_iter91.getKey());
+            oprot.writeString(_iter103.getKey());
-            oprot.writeString(_iter91.getValue());
+            oprot.writeString(_iter103.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 _list92 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list104 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list92.size);
+                this.success = new ArrayList<Order>(_list104.size);
-                for (int _i93 = 0; _i93 < _list92.size; ++_i93)
+                for (int _i105 = 0; _i105 < _list104.size; ++_i105)
+                {
-                  Order _elem94; // required
+                  Order _elem106; // required
-                  _elem94 = new Order();
+                  _elem106 = new Order();
-                  _elem94.read(iprot);
+                  _elem106.read(iprot);
-                  this.success.add(_elem94);
+                  this.success.add(_elem106);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Order _iter95 : this.success)
+          for (Order _iter107 : this.success)
+          {
-            _iter95.write(oprot);
+            _iter107.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 _map96 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map108 = iprot.readMapBegin();
-                this.pickupDetails = new HashMap<String,String>(2*_map96.size);
+                this.pickupDetails = new HashMap<String,String>(2*_map108.size);
-                for (int _i97 = 0; _i97 < _map96.size; ++_i97)
+                for (int _i109 = 0; _i109 < _map108.size; ++_i109)
+                {
-                  String _key98; // required
+                  String _key110; // required
-                  String _val99; // required
+                  String _val111; // required
-                  _key98 = iprot.readString();
+                  _key110 = iprot.readString();
-                  _val99 = iprot.readString();
+                  _val111 = iprot.readString();
-                  this.pickupDetails.put(_key98, _val99);
+                  this.pickupDetails.put(_key110, _val111);
+                }
                 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> _iter100 : this.pickupDetails.entrySet())
+          for (Map.Entry<String, String> _iter112 : this.pickupDetails.entrySet())
+          {
-            oprot.writeString(_iter100.getKey());
+            oprot.writeString(_iter112.getKey());
-            oprot.writeString(_iter100.getValue());
+            oprot.writeString(_iter112.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 _list101 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list113 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list101.size);
+                this.success = new ArrayList<Order>(_list113.size);
-                for (int _i102 = 0; _i102 < _list101.size; ++_i102)
+                for (int _i114 = 0; _i114 < _list113.size; ++_i114)
+                {
-                  Order _elem103; // required
+                  Order _elem115; // required
-                  _elem103 = new Order();
+                  _elem115 = new Order();
-                  _elem103.read(iprot);
+                  _elem115.read(iprot);
-                  this.success.add(_elem103);
+                  this.success.add(_elem115);
+                }
                 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 _iter104 : this.success)
+          for (Order _iter116 : this.success)
+          {
-            _iter104.write(oprot);
+            _iter116.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 _list105 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list117 = iprot.readListBegin();
-                this.success = new ArrayList<ReturnOrder>(_list105.size);
+                this.success = new ArrayList<ReturnOrder>(_list117.size);
-                for (int _i106 = 0; _i106 < _list105.size; ++_i106)
+                for (int _i118 = 0; _i118 < _list117.size; ++_i118)
+                {
-                  ReturnOrder _elem107; // required
+                  ReturnOrder _elem119; // required
-                  _elem107 = new ReturnOrder();
+                  _elem119 = new ReturnOrder();
-                  _elem107.read(iprot);
+                  _elem119.read(iprot);
-                  this.success.add(_elem107);
+                  this.success.add(_elem119);
+                }
                 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 _iter108 : this.success)
+          for (ReturnOrder _iter120 : this.success)
+          {
-            _iter108.write(oprot);
+            _iter120.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 _map109 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map121 = iprot.readMapBegin();
-                this.collectedAmountMap = new HashMap<String,Double>(2*_map109.size);
+                this.collectedAmountMap = new HashMap<String,Double>(2*_map121.size);
-                for (int _i110 = 0; _i110 < _map109.size; ++_i110)
+                for (int _i122 = 0; _i122 < _map121.size; ++_i122)
+                {
-                  String _key111; // required
+                  String _key123; // required
-                  double _val112; // required
+                  double _val124; // required
-                  _key111 = iprot.readString();
+                  _key123 = iprot.readString();
-                  _val112 = iprot.readDouble();
+                  _val124 = iprot.readDouble();
-                  this.collectedAmountMap.put(_key111, _val112);
+                  this.collectedAmountMap.put(_key123, _val124);
+                }
                 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> _iter113 : this.collectedAmountMap.entrySet())
+          for (Map.Entry<String, Double> _iter125 : this.collectedAmountMap.entrySet())
+          {
-            oprot.writeString(_iter113.getKey());
+            oprot.writeString(_iter125.getKey());
-            oprot.writeDouble(_iter113.getValue());
+            oprot.writeDouble(_iter125.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 _map114 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map126 = iprot.readMapBegin();
-                this.success = new HashMap<String,String>(2*_map114.size);
+                this.success = new HashMap<String,String>(2*_map126.size);
-                for (int _i115 = 0; _i115 < _map114.size; ++_i115)
+                for (int _i127 = 0; _i127 < _map126.size; ++_i127)
+                {
-                  String _key116; // required
+                  String _key128; // required
-                  String _val117; // required
+                  String _val129; // required
-                  _key116 = iprot.readString();
+                  _key128 = iprot.readString();
-                  _val117 = iprot.readString();
+                  _val129 = iprot.readString();
-                  this.success.put(_key116, _val117);
+                  this.success.put(_key128, _val129);
+                }
                 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> _iter118 : this.success.entrySet())
+          for (Map.Entry<String, String> _iter130 : this.success.entrySet())
+          {
-            oprot.writeString(_iter118.getKey());
+            oprot.writeString(_iter130.getKey());
-            oprot.writeString(_iter118.getValue());
+            oprot.writeString(_iter130.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 _list119 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list131 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list119.size);
+                this.success = new ArrayList<Long>(_list131.size);
-                for (int _i120 = 0; _i120 < _list119.size; ++_i120)
+                for (int _i132 = 0; _i132 < _list131.size; ++_i132)
+                {
-                  long _elem121; // required
+                  long _elem133; // required
-                  _elem121 = iprot.readI64();
+                  _elem133 = iprot.readI64();
-                  this.success.add(_elem121);
+                  this.success.add(_elem133);
+                }
                 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 _iter122 : this.success)
+          for (long _iter134 : this.success)
+          {
-            oprot.writeI64(_iter122);
+            oprot.writeI64(_iter134);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map123 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map135 = iprot.readMapBegin();
-                this.success = new HashMap<Long,Long>(2*_map123.size);
+                this.success = new HashMap<Long,Long>(2*_map135.size);
-                for (int _i124 = 0; _i124 < _map123.size; ++_i124)
+                for (int _i136 = 0; _i136 < _map135.size; ++_i136)
+                {
-                  long _key125; // required
+                  long _key137; // required
-                  long _val126; // required
+                  long _val138; // required
-                  _key125 = iprot.readI64();
+                  _key137 = iprot.readI64();
-                  _val126 = iprot.readI64();
+                  _val138 = iprot.readI64();
-                  this.success.put(_key125, _val126);
+                  this.success.put(_key137, _val138);
+                }
                 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> _iter127 : this.success.entrySet())
+          for (Map.Entry<Long, Long> _iter139 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter127.getKey());
+            oprot.writeI64(_iter139.getKey());
-            oprot.writeI64(_iter127.getValue());
+            oprot.writeI64(_iter139.getValue());
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }

Subversion Repositories SmartDukaan

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