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



     * @param transactionId
     * @param customerId
     */
    public List<Order> getOrdersForTransaction(long transactionId, long customerId) throws TransactionServiceException, TException;
 
    /**
     * Returns list of orders for the given customer created between the given dates and having the given statuses.
     * Pass and empty list to ignore filtering on statuses.
     * 
     * @param customerId
     * @param from_date
     * @param to_date
     * @param statuses
     */
    public List<Order> getOrdersForCustomer(long customerId, long from_date, long to_date, List<OrderStatus> statuses) throws TransactionServiceException, TException;
 
    public long createOrder(Order order) throws TransactionServiceException, TException;
 
    public Order getOrder(long id) throws TransactionServiceException, TException;
 

        throw result.ex;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
    }
 
    public List<Order> getOrdersForCustomer(long customerId, long from_date, long to_date, List<OrderStatus> statuses) throws TransactionServiceException, TException
    {
      send_getOrdersForCustomer(customerId, from_date, to_date, statuses);
      return recv_getOrdersForCustomer();
    }
 
    public void send_getOrdersForCustomer(long customerId, long from_date, long to_date, List<OrderStatus> statuses) throws TException
    {
      oprot_.writeMessageBegin(new TMessage("getOrdersForCustomer", TMessageType.CALL, seqid_));
      getOrdersForCustomer_args args = new getOrdersForCustomer_args();
      args.customerId = customerId;
      args.from_date = from_date;
      args.to_date = to_date;
      args.statuses = statuses;
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
    }
 

        getOrdersForCustomer_args args = new getOrdersForCustomer_args();
        args.read(iprot);
        iprot.readMessageEnd();
        getOrdersForCustomer_result result = new getOrdersForCustomer_result();
        try {
          result.success = iface_.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses);
        } catch (TransactionServiceException ex) {
          result.ex = ex;
        } catch (Throwable th) {
          LOGGER.error("Internal error processing getOrdersForCustomer", th);
          TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getOrdersForCustomer");

    private static final TStruct STRUCT_DESC = new TStruct("getOrdersForCustomer_args");
 
    private static final TField CUSTOMER_ID_FIELD_DESC = new TField("customerId", TType.I64, (short)1);
    private static final TField FROM_DATE_FIELD_DESC = new TField("from_date", TType.I64, (short)2);
    private static final TField TO_DATE_FIELD_DESC = new TField("to_date", TType.I64, (short)3);
    private static final TField STATUSES_FIELD_DESC = new TField("statuses", TType.LIST, (short)4);
 
    private long customerId;
    private long from_date;
    private long to_date;
    private List<OrderStatus> statuses;
 
    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements TFieldIdEnum {
      CUSTOMER_ID((short)1, "customerId"),
      FROM_DATE((short)2, "from_date"),
      TO_DATE((short)3, "to_date"),
 
 
 
 
      STATUSES((short)4, "statuses");
 
      private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
 
      static {

          new FieldValueMetaData(TType.I64)));
      put(_Fields.FROM_DATE, new FieldMetaData("from_date", TFieldRequirementType.DEFAULT, 
          new FieldValueMetaData(TType.I64)));
      put(_Fields.TO_DATE, new FieldMetaData("to_date", TFieldRequirementType.DEFAULT, 
          new FieldValueMetaData(TType.I64)));
      put(_Fields.STATUSES, new FieldMetaData("statuses", TFieldRequirementType.DEFAULT, 
          new ListMetaData(TType.LIST, 
              new EnumMetaData(TType.ENUM, OrderStatus.class))));
    }});
 
    static {
      FieldMetaData.addStructMetaDataMap(getOrdersForCustomer_args.class, metaDataMap);
    }

 
    public getOrdersForCustomer_args(
      long customerId,
      long from_date,
      long to_date,
      List<OrderStatus> statuses)
    {
      this();
      this.customerId = customerId;
      setCustomerIdIsSet(true);
      this.from_date = from_date;
      setFrom_dateIsSet(true);
      this.to_date = to_date;
      setTo_dateIsSet(true);
      this.statuses = statuses;
    }
 
    /**
     * Performs a deep copy on <i>other</i>.
     */

      __isset_bit_vector.clear();
      __isset_bit_vector.or(other.__isset_bit_vector);
      this.customerId = other.customerId;
      this.from_date = other.from_date;
      this.to_date = other.to_date;
      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;
      }
    }
 
    public getOrdersForCustomer_args deepCopy() {
      return new getOrdersForCustomer_args(this);

 
    public void setTo_dateIsSet(boolean value) {
      __isset_bit_vector.set(__TO_DATE_ISSET_ID, value);
    }
 
 
 
 
 
    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 getOrdersForCustomer_args setStatuses(List<OrderStatus> statuses) {
      this.statuses = statuses;
      return this;
    }
 
    public void unsetStatuses() {
      this.statuses = null;
    }
 
    /** Returns true if field statuses is set (has been asigned a value) and false otherwise */
    public boolean isSetStatuses() {
      return this.statuses != null;
    }
 
    public void setStatusesIsSet(boolean value) {
      if (!value) {
        this.statuses = null;
      }
    }
 
    public void setFieldValue(_Fields field, Object value) {
      switch (field) {

        } else {
          setTo_date((Long)value);
        }
        break;
 
      case STATUSES:
        if (value == null) {
          unsetStatuses();
        } else {
          setStatuses((List<OrderStatus>)value);
        }
        break;
 
      }
    }

        return new Long(getFrom_date());
 
      case TO_DATE:
        return new Long(getTo_date());
 
      case STATUSES:
        return getStatuses();
 
      }
      throw new IllegalStateException();
    }
 

        return isSetCustomerId();
      case FROM_DATE:
        return isSetFrom_date();
      case TO_DATE:
        return isSetTo_date();
      case STATUSES:
        return isSetStatuses();
      }
      throw new IllegalStateException();
    }
 
    public boolean isSet(int fieldID) {

          return false;
        if (this.to_date != that.to_date)
          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;
      }
 
      return true;
    }

      }
      lastComparison = TBaseHelper.compareTo(to_date, typedOther.to_date);
      if (lastComparison != 0) {
        return lastComparison;
      }
      lastComparison = Boolean.valueOf(isSetStatuses()).compareTo(isSetStatuses());
      if (lastComparison != 0) {
        return lastComparison;
      }
      lastComparison = TBaseHelper.compareTo(statuses, typedOther.statuses);
      if (lastComparison != 0) {
        return lastComparison;
      }
      return 0;
    }

                setTo_dateIsSet(true);
              } else { 
                TProtocolUtil.skip(iprot, field.type);
              }
              break;
            case STATUSES:
              if (field.type == TType.LIST) {
                {
                  TList _list36 = iprot.readListBegin();
                  this.statuses = new ArrayList<OrderStatus>(_list36.size);
                  for (int _i37 = 0; _i37 < _list36.size; ++_i37)
                  {
                    OrderStatus _elem38;
                    _elem38 = OrderStatus.findByValue(iprot.readI32());
                    this.statuses.add(_elem38);
                  }
                  iprot.readListEnd();
                }
              } else { 
                TProtocolUtil.skip(iprot, field.type);
              }
              break;
          }

      oprot.writeI64(this.from_date);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(TO_DATE_FIELD_DESC);
      oprot.writeI64(this.to_date);
      oprot.writeFieldEnd();
      if (this.statuses != null) {
        oprot.writeFieldBegin(STATUSES_FIELD_DESC);
        {
          oprot.writeListBegin(new TList(TType.I32, this.statuses.size()));
          for (OrderStatus _iter39 : this.statuses)
          {
            oprot.writeI32(_iter39.getValue());
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

      if (!first) sb.append(", ");
      sb.append("to_date:");
      sb.append(this.to_date);
      first = false;
      if (!first) sb.append(", ");
      sb.append("statuses:");
      if (this.statuses == null) {
        sb.append("null");
      } else {
 
 
 
 
 
        sb.append(this.statuses);
 
 
 
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

        } else {
          switch (fieldId) {
            case SUCCESS:
              if (field.type == TType.LIST) {
                {
                  TList _list40 = iprot.readListBegin();
                  this.success = new ArrayList<Order>(_list40.size);
                  for (int _i41 = 0; _i41 < _list40.size; ++_i41)
                  {
                    Order _elem42;
                    _elem42 = new Order();
                    _elem42.read(iprot);
                    this.success.add(_elem42);
                  }
                  iprot.readListEnd();
                }
              } else { 
                TProtocolUtil.skip(iprot, field.type);

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

        } else {
          switch (fieldId) {
            case SUCCESS:
              if (field.type == TType.LIST) {
                {
                  TList _list44 = iprot.readListBegin();
                  this.success = new ArrayList<LineItem>(_list44.size);
                  for (int _i45 = 0; _i45 < _list44.size; ++_i45)
                  {
                    LineItem _elem46;
                    _elem46 = new LineItem();
                    _elem46.read(iprot);
                    this.success.add(_elem46);
                  }
                  iprot.readListEnd();
                }
              } else { 
                TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
          for (LineItem _iter47 : this.success)
          {
            _iter47.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      } else if (this.isSetEx()) {

        } else {
          switch (fieldId) {
            case SUCCESS:
              if (field.type == TType.LIST) {
                {
                  TList _list48 = iprot.readListBegin();
                  this.success = new ArrayList<Order>(_list48.size);
                  for (int _i49 = 0; _i49 < _list48.size; ++_i49)
                  {
                    Order _elem50;
                    _elem50 = new Order();
                    _elem50.read(iprot);
                    this.success.add(_elem50);
                  }
                  iprot.readListEnd();
                }
              } else { 
                TProtocolUtil.skip(iprot, field.type);

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

              }
              break;
            case PICKUP_DETAILS:
              if (field.type == TType.MAP) {
                {
                  TMap _map52 = iprot.readMapBegin();
                  this.pickupDetails = new HashMap<String,String>(2*_map52.size);
                  for (int _i53 = 0; _i53 < _map52.size; ++_i53)
                  {
                    String _key54;
                    String _val55;
                    _key54 = iprot.readString();
                    _val55 = iprot.readString();
                    this.pickupDetails.put(_key54, _val55);
                  }
                  iprot.readMapEnd();
                }
              } else { 
                TProtocolUtil.skip(iprot, field.type);

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

        } else {
          switch (fieldId) {
            case SUCCESS:
              if (field.type == TType.LIST) {
                {
                  TList _list57 = iprot.readListBegin();
                  this.success = new ArrayList<Order>(_list57.size);
                  for (int _i58 = 0; _i58 < _list57.size; ++_i58)
                  {
                    Order _elem59;
                    _elem59 = new Order();
                    _elem59.read(iprot);
                    this.success.add(_elem59);
                  }
                  iprot.readListEnd();
                }
              } else { 
                TProtocolUtil.skip(iprot, field.type);

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

              }
              break;
            case DELIVERED_ORDERS:
              if (field.type == TType.MAP) {
                {
                  TMap _map61 = iprot.readMapBegin();
                  this.deliveredOrders = new HashMap<String,String>(2*_map61.size);
                  for (int _i62 = 0; _i62 < _map61.size; ++_i62)
                  {
                    String _key63;
                    String _val64;
                    _key63 = iprot.readString();
                    _val64 = iprot.readString();
                    this.deliveredOrders.put(_key63, _val64);
                  }
                  iprot.readMapEnd();
                }
              } else { 
                TProtocolUtil.skip(iprot, field.type);

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

              }
              break;
            case RETURNED_ORDERS:
              if (field.type == TType.MAP) {
                {
                  TMap _map66 = iprot.readMapBegin();
                  this.returnedOrders = new HashMap<String,String>(2*_map66.size);
                  for (int _i67 = 0; _i67 < _map66.size; ++_i67)
                  {
                    String _key68;
                    String _val69;
                    _key68 = iprot.readString();
                    _val69 = iprot.readString();
                    this.returnedOrders.put(_key68, _val69);
                  }
                  iprot.readMapEnd();
                }
              } else { 
                TProtocolUtil.skip(iprot, field.type);

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

              }
              break;
            case UNDELIVERED_ORDERS:
              if (field.type == TType.MAP) {
                {
                  TMap _map71 = iprot.readMapBegin();
                  this.undeliveredOrders = new HashMap<String,String>(2*_map71.size);
                  for (int _i72 = 0; _i72 < _map71.size; ++_i72)
                  {
                    String _key73;
                    String _val74;
                    _key73 = iprot.readString();
                    _val74 = iprot.readString();
                    this.undeliveredOrders.put(_key73, _val74);
                  }
                  iprot.readMapEnd();
                }
              } else { 
                TProtocolUtil.skip(iprot, field.type);

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

        } else {
          switch (fieldId) {
            case SUCCESS:
              if (field.type == TType.LIST) {
                {
                  TList _list76 = iprot.readListBegin();
                  this.success = new ArrayList<Order>(_list76.size);
                  for (int _i77 = 0; _i77 < _list76.size; ++_i77)
                  {
                    Order _elem78;
                    _elem78 = new Order();
                    _elem78.read(iprot);
                    this.success.add(_elem78);
                  }
                  iprot.readListEnd();
                }
              } else { 
                TProtocolUtil.skip(iprot, field.type);

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

        } else {
          switch (fieldId) {
            case SUCCESS:
              if (field.type == TType.LIST) {
                {
                  TList _list80 = iprot.readListBegin();
                  this.success = new ArrayList<Alert>(_list80.size);
                  for (int _i81 = 0; _i81 < _list80.size; ++_i81)
                  {
                    Alert _elem82;
                    _elem82 = new Alert();
                    _elem82.read(iprot);
                    this.success.add(_elem82);
                  }
                  iprot.readListEnd();
                }
              } else { 
                TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
          for (Alert _iter83 : this.success)
          {
            _iter83.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        } else {
          switch (fieldId) {
            case SUCCESS:
              if (field.type == TType.LIST) {
                {
                  TList _list84 = iprot.readListBegin();
                  this.success = new ArrayList<Double>(_list84.size);
                  for (int _i85 = 0; _i85 < _list84.size; ++_i85)
                  {
                    double _elem86;
                    _elem86 = iprot.readDouble();
                    this.success.add(_elem86);
                  }
                  iprot.readListEnd();
                }
              } else { 
                TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new TList(TType.DOUBLE, this.success.size()));
          for (double _iter87 : this.success)
          {
            oprot.writeDouble(_iter87);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

        } else {
          switch (fieldId) {
            case SUCCESS:
              if (field.type == TType.LIST) {
                {
                  TList _list88 = iprot.readListBegin();
                  this.success = new ArrayList<Order>(_list88.size);
                  for (int _i89 = 0; _i89 < _list88.size; ++_i89)
                  {
                    Order _elem90;
                    _elem90 = new Order();
                    _elem90.read(iprot);
                    this.success.add(_elem90);
                  }
                  iprot.readListEnd();
                }
              } else { 
                TProtocolUtil.skip(iprot, field.type);

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

              }
              break;
            case PICKUP_DETAILS:
              if (field.type == TType.MAP) {
                {
                  TMap _map92 = iprot.readMapBegin();
                  this.pickupDetails = new HashMap<String,String>(2*_map92.size);
                  for (int _i93 = 0; _i93 < _map92.size; ++_i93)
                  {
                    String _key94;
                    String _val95;
                    _key94 = iprot.readString();
                    _val95 = iprot.readString();
                    this.pickupDetails.put(_key94, _val95);
                  }
                  iprot.readMapEnd();
                }
              } else { 
                TProtocolUtil.skip(iprot, field.type);

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

        } else {
          switch (fieldId) {
            case SUCCESS:
              if (field.type == TType.LIST) {
                {
                  TList _list97 = iprot.readListBegin();
                  this.success = new ArrayList<Order>(_list97.size);
                  for (int _i98 = 0; _i98 < _list97.size; ++_i98)
                  {
                    Order _elem99;
                    _elem99 = new Order();
                    _elem99.read(iprot);
                    this.success.add(_elem99);
                  }
                  iprot.readListEnd();
                }
              } else { 
                TProtocolUtil.skip(iprot, field.type);

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

        } else {
          switch (fieldId) {
            case SUCCESS:
              if (field.type == TType.LIST) {
                {
                  TList _list101 = iprot.readListBegin();
                  this.success = new ArrayList<ReturnOrder>(_list101.size);
                  for (int _i102 = 0; _i102 < _list101.size; ++_i102)
                  {
                    ReturnOrder _elem103;
                    _elem103 = new ReturnOrder();
                    _elem103.read(iprot);
                    this.success.add(_elem103);
                  }
                  iprot.readListEnd();
                }
              } else { 
                TProtocolUtil.skip(iprot, field.type);

 
      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
          for (ReturnOrder _iter104 : this.success)
          {
            _iter104.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }

Rev 2842	Rev 3014
Line 110...	Line 110...
110	`* @param transactionId`	110	`* @param transactionId`
111	`* @param customerId`	111	`* @param customerId`
112	`*/`	112	`*/`
113	`public List<Order> getOrdersForTransaction(long transactionId, long customerId) throws TransactionServiceException, TException;`	113	`public List<Order> getOrdersForTransaction(long transactionId, long customerId) throws TransactionServiceException, TException;`
114		114
-		115	`/**`
-		116	`* Returns list of orders for the given customer created between the given dates and having the given statuses.`
-		117	`* Pass and empty list to ignore filtering on statuses.`
-		118	`*`
-		119	`* @param customerId`
-		120	`* @param from_date`
-		121	`* @param to_date`
-		122	`* @param statuses`
-		123	`*/`
115	`public List<Order> getOrdersForCustomer(long customerId, long from_date, long to_date, OrderStatus status) throws TransactionServiceException, TException;`	124	`public List<Order> getOrdersForCustomer(long customerId, long from_date, long to_date, List<OrderStatus> statuses) throws TransactionServiceException, TException;`
116		125
117	`public long createOrder(Order order) throws TransactionServiceException, TException;`	126	`public long createOrder(Order order) throws TransactionServiceException, TException;`
118		127
119	`public Order getOrder(long id) throws TransactionServiceException, TException;`	128	`public Order getOrder(long id) throws TransactionServiceException, TException;`
120		129
Line 1052...	Line 1061...
1052	`throw result.ex;`	1061	`throw result.ex;`
1053	`}`	1062	`}`
1054	`throw new TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");`	1063	`throw new TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");`
1055	`}`	1064	`}`
1056		1065
1057	`public List<Order> getOrdersForCustomer(long customerId, long from_date, long to_date, OrderStatus status) throws TransactionServiceException, TException`	1066	`public List<Order> getOrdersForCustomer(long customerId, long from_date, long to_date, List<OrderStatus> statuses) throws TransactionServiceException, TException`
1058	`{`	1067	`{`
1059	`send_getOrdersForCustomer(customerId, from_date, to_date, status);`	1068	`send_getOrdersForCustomer(customerId, from_date, to_date, statuses);`
1060	`return recv_getOrdersForCustomer();`	1069	`return recv_getOrdersForCustomer();`
1061	`}`	1070	`}`
1062		1071
1063	`public void send_getOrdersForCustomer(long customerId, long from_date, long to_date, OrderStatus status) throws TException`	1072	`public void send_getOrdersForCustomer(long customerId, long from_date, long to_date, List<OrderStatus> statuses) throws TException`
1064	`{`	1073	`{`
1065	`oprot_.writeMessageBegin(new TMessage("getOrdersForCustomer", TMessageType.CALL, seqid_));`	1074	`oprot_.writeMessageBegin(new TMessage("getOrdersForCustomer", TMessageType.CALL, seqid_));`
1066	`getOrdersForCustomer_args args = new getOrdersForCustomer_args();`	1075	`getOrdersForCustomer_args args = new getOrdersForCustomer_args();`
1067	`args.customerId = customerId;`	1076	`args.customerId = customerId;`
1068	`args.from_date = from_date;`	1077	`args.from_date = from_date;`
1069	`args.to_date = to_date;`	1078	`args.to_date = to_date;`
1070	`args.status = status;`	1079	`args.statuses = statuses;`
1071	`args.write(oprot_);`	1080	`args.write(oprot_);`
1072	`oprot_.writeMessageEnd();`	1081	`oprot_.writeMessageEnd();`
1073	`oprot_.getTransport().flush();`	1082	`oprot_.getTransport().flush();`
1074	`}`	1083	`}`
1075		1084
Line 2732...	Line 2741...
2732	`getOrdersForCustomer_args args = new getOrdersForCustomer_args();`	2741	`getOrdersForCustomer_args args = new getOrdersForCustomer_args();`
2733	`args.read(iprot);`	2742	`args.read(iprot);`
2734	`iprot.readMessageEnd();`	2743	`iprot.readMessageEnd();`
2735	`getOrdersForCustomer_result result = new getOrdersForCustomer_result();`	2744	`getOrdersForCustomer_result result = new getOrdersForCustomer_result();`
2736	`try {`	2745	`try {`
2737	`result.success = iface_.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.status);`	2746	`result.success = iface_.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses);`
2738	`} catch (TransactionServiceException ex) {`	2747	`} catch (TransactionServiceException ex) {`
2739	`result.ex = ex;`	2748	`result.ex = ex;`
2740	`} catch (Throwable th) {`	2749	`} catch (Throwable th) {`
2741	`LOGGER.error("Internal error processing getOrdersForCustomer", th);`	2750	`LOGGER.error("Internal error processing getOrdersForCustomer", th);`
2742	`TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getOrdersForCustomer");`	2751	`TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing getOrdersForCustomer");`
Line 17041...	Line 17050...
17041	`private static final TStruct STRUCT_DESC = new TStruct("getOrdersForCustomer_args");`	17050	`private static final TStruct STRUCT_DESC = new TStruct("getOrdersForCustomer_args");`
17042		17051
17043	`private static final TField CUSTOMER_ID_FIELD_DESC = new TField("customerId", TType.I64, (short)1);`	17052	`private static final TField CUSTOMER_ID_FIELD_DESC = new TField("customerId", TType.I64, (short)1);`
17044	`private static final TField FROM_DATE_FIELD_DESC = new TField("from_date", TType.I64, (short)2);`	17053	`private static final TField FROM_DATE_FIELD_DESC = new TField("from_date", TType.I64, (short)2);`
17045	`private static final TField TO_DATE_FIELD_DESC = new TField("to_date", TType.I64, (short)3);`	17054	`private static final TField TO_DATE_FIELD_DESC = new TField("to_date", TType.I64, (short)3);`
17046	`private static final TField STATUS_FIELD_DESC = new TField("status", TType.I32, (short)4);`	17055	`private static final TField STATUSES_FIELD_DESC = new TField("statuses", TType.LIST, (short)4);`
17047		17056
17048	`private long customerId;`	17057	`private long customerId;`
17049	`private long from_date;`	17058	`private long from_date;`
17050	`private long to_date;`	17059	`private long to_date;`
17051	`private OrderStatus status;`	17060	`private List<OrderStatus> statuses;`
17052		17061
17053	`/** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */`	17062	`/** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */`
17054	`public enum _Fields implements TFieldIdEnum {`	17063	`public enum _Fields implements TFieldIdEnum {`
17055	`CUSTOMER_ID((short)1, "customerId"),`	17064	`CUSTOMER_ID((short)1, "customerId"),`
17056	`FROM_DATE((short)2, "from_date"),`	17065	`FROM_DATE((short)2, "from_date"),`
17057	`TO_DATE((short)3, "to_date"),`	17066	`TO_DATE((short)3, "to_date"),`
17058	`/**`	-
17059	`*`	-
17060	`* @see OrderStatus`	-
17061	`*/`	-
17062	`STATUS((short)4, "status");`	17067	`STATUSES((short)4, "statuses");`
17063		17068
17064	`private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();`	17069	`private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();`
17065	`private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();`	17070	`private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();`
17066		17071
17067	`static {`	17072	`static {`
Line 17123...	Line 17128...
17123	`new FieldValueMetaData(TType.I64)));`	17128	`new FieldValueMetaData(TType.I64)));`
17124	`put(_Fields.FROM_DATE, new FieldMetaData("from_date", TFieldRequirementType.DEFAULT,`	17129	`put(_Fields.FROM_DATE, new FieldMetaData("from_date", TFieldRequirementType.DEFAULT,`
17125	`new FieldValueMetaData(TType.I64)));`	17130	`new FieldValueMetaData(TType.I64)));`
17126	`put(_Fields.TO_DATE, new FieldMetaData("to_date", TFieldRequirementType.DEFAULT,`	17131	`put(_Fields.TO_DATE, new FieldMetaData("to_date", TFieldRequirementType.DEFAULT,`
17127	`new FieldValueMetaData(TType.I64)));`	17132	`new FieldValueMetaData(TType.I64)));`
17128	`put(_Fields.STATUS, new FieldMetaData("status", TFieldRequirementType.DEFAULT,`	17133	`put(_Fields.STATUSES, new FieldMetaData("statuses", TFieldRequirementType.DEFAULT,`
-		17134	`new ListMetaData(TType.LIST,`
17129	`new EnumMetaData(TType.ENUM, OrderStatus.class)));`	17135	`new EnumMetaData(TType.ENUM, OrderStatus.class))));`
17130	`}});`	17136	`}});`
17131		17137
17132	`static {`	17138	`static {`
17133	`FieldMetaData.addStructMetaDataMap(getOrdersForCustomer_args.class, metaDataMap);`	17139	`FieldMetaData.addStructMetaDataMap(getOrdersForCustomer_args.class, metaDataMap);`
17134	`}`	17140	`}`
Line 17138...	Line 17144...
17138		17144
17139	`public getOrdersForCustomer_args(`	17145	`public getOrdersForCustomer_args(`
17140	`long customerId,`	17146	`long customerId,`
17141	`long from_date,`	17147	`long from_date,`
17142	`long to_date,`	17148	`long to_date,`
17143	`OrderStatus status)`	17149	`List<OrderStatus> statuses)`
17144	`{`	17150	`{`
17145	`this();`	17151	`this();`
17146	`this.customerId = customerId;`	17152	`this.customerId = customerId;`
17147	`setCustomerIdIsSet(true);`	17153	`setCustomerIdIsSet(true);`
17148	`this.from_date = from_date;`	17154	`this.from_date = from_date;`
17149	`setFrom_dateIsSet(true);`	17155	`setFrom_dateIsSet(true);`
17150	`this.to_date = to_date;`	17156	`this.to_date = to_date;`
17151	`setTo_dateIsSet(true);`	17157	`setTo_dateIsSet(true);`
17152	`this.status = status;`	17158	`this.statuses = statuses;`
17153	`}`	17159	`}`
17154		17160
17155	`/**`	17161	`/**`
17156	`* Performs a deep copy on <i>other</i>.`	17162	`* Performs a deep copy on <i>other</i>.`
17157	`*/`	17163	`*/`
Line 17159...	Line 17165...
17159	`__isset_bit_vector.clear();`	17165	`__isset_bit_vector.clear();`
17160	`__isset_bit_vector.or(other.__isset_bit_vector);`	17166	`__isset_bit_vector.or(other.__isset_bit_vector);`
17161	`this.customerId = other.customerId;`	17167	`this.customerId = other.customerId;`
17162	`this.from_date = other.from_date;`	17168	`this.from_date = other.from_date;`
17163	`this.to_date = other.to_date;`	17169	`this.to_date = other.to_date;`
17164	`if (other.isSetStatus()) {`	17170	`if (other.isSetStatuses()) {`
-		17171	`List<OrderStatus> __this__statuses = new ArrayList<OrderStatus>();`
-		17172	`for (OrderStatus other_element : other.statuses) {`
-		17173	`__this__statuses.add(other_element);`
-		17174	`}`
17165	`this.status = other.status;`	17175	`this.statuses = __this__statuses;`
17166	`}`	17176	`}`
17167	`}`	17177	`}`
17168		17178
17169	`public getOrdersForCustomer_args deepCopy() {`	17179	`public getOrdersForCustomer_args deepCopy() {`
17170	`return new getOrdersForCustomer_args(this);`	17180	`return new getOrdersForCustomer_args(this);`
Line 17242...	Line 17252...
17242		17252
17243	`public void setTo_dateIsSet(boolean value) {`	17253	`public void setTo_dateIsSet(boolean value) {`
17244	`__isset_bit_vector.set(__TO_DATE_ISSET_ID, value);`	17254	`__isset_bit_vector.set(__TO_DATE_ISSET_ID, value);`
17245	`}`	17255	`}`
17246		17256
17247	`/**`	-
17248	`*`	-
17249	`* @see OrderStatus`	-
17250	`*/`	-
17251	`public OrderStatus getStatus() {`	17257	`public int getStatusesSize() {`
17252	`return this.status;`	17258	`return (this.statuses == null) ? 0 : this.statuses.size();`
17253	`}`	17259	`}`
17254		17260
-		17261	`public java.util.Iterator<OrderStatus> getStatusesIterator() {`
-		17262	`return (this.statuses == null) ? null : this.statuses.iterator();`
17255	`/**`	17263	`}`
-		17264
-		17265	`public void addToStatuses(OrderStatus elem) {`
-		17266	`if (this.statuses == null) {`
-		17267	`this.statuses = new ArrayList<OrderStatus>();`
17256	`*`	17268	`}`
-		17269	`this.statuses.add(elem);`
-		17270	`}`
-		17271
-		17272	`public List<OrderStatus> getStatuses() {`
17257	`* @see OrderStatus`	17273	`return this.statuses;`
17258	`*/`	17274	`}`
-		17275
17259	`public getOrdersForCustomer_args setStatus(OrderStatus status) {`	17276	`public getOrdersForCustomer_args setStatuses(List<OrderStatus> statuses) {`
17260	`this.status = status;`	17277	`this.statuses = statuses;`
17261	`return this;`	17278	`return this;`
17262	`}`	17279	`}`
17263		17280
17264	`public void unsetStatus() {`	17281	`public void unsetStatuses() {`
17265	`this.status = null;`	17282	`this.statuses = null;`
17266	`}`	17283	`}`
17267		17284
17268	`/** Returns true if field status is set (has been asigned a value) and false otherwise */`	17285	`/** Returns true if field statuses is set (has been asigned a value) and false otherwise */`
17269	`public boolean isSetStatus() {`	17286	`public boolean isSetStatuses() {`
17270	`return this.status != null;`	17287	`return this.statuses != null;`
17271	`}`	17288	`}`
17272		17289
17273	`public void setStatusIsSet(boolean value) {`	17290	`public void setStatusesIsSet(boolean value) {`
17274	`if (!value) {`	17291	`if (!value) {`
17275	`this.status = null;`	17292	`this.statuses = null;`
17276	`}`	17293	`}`
17277	`}`	17294	`}`
17278		17295
17279	`public void setFieldValue(_Fields field, Object value) {`	17296	`public void setFieldValue(_Fields field, Object value) {`
17280	`switch (field) {`	17297	`switch (field) {`
Line 17300...	Line 17317...
17300	`} else {`	17317	`} else {`
17301	`setTo_date((Long)value);`	17318	`setTo_date((Long)value);`
17302	`}`	17319	`}`
17303	`break;`	17320	`break;`
17304		17321
17305	`case STATUS:`	17322	`case STATUSES:`
17306	`if (value == null) {`	17323	`if (value == null) {`
17307	`unsetStatus();`	17324	`unsetStatuses();`
17308	`} else {`	17325	`} else {`
17309	`setStatus((OrderStatus)value);`	17326	`setStatuses((List<OrderStatus>)value);`
17310	`}`	17327	`}`
17311	`break;`	17328	`break;`
17312		17329
17313	`}`	17330	`}`
17314	`}`	17331	`}`
Line 17326...	Line 17343...
17326	`return new Long(getFrom_date());`	17343	`return new Long(getFrom_date());`
17327		17344
17328	`case TO_DATE:`	17345	`case TO_DATE:`
17329	`return new Long(getTo_date());`	17346	`return new Long(getTo_date());`
17330		17347
17331	`case STATUS:`	17348	`case STATUSES:`
17332	`return getStatus();`	17349	`return getStatuses();`
17333		17350
17334	`}`	17351	`}`
17335	`throw new IllegalStateException();`	17352	`throw new IllegalStateException();`
17336	`}`	17353	`}`
17337		17354
Line 17346...	Line 17363...
17346	`return isSetCustomerId();`	17363	`return isSetCustomerId();`
17347	`case FROM_DATE:`	17364	`case FROM_DATE:`
17348	`return isSetFrom_date();`	17365	`return isSetFrom_date();`
17349	`case TO_DATE:`	17366	`case TO_DATE:`
17350	`return isSetTo_date();`	17367	`return isSetTo_date();`
17351	`case STATUS:`	17368	`case STATUSES:`
17352	`return isSetStatus();`	17369	`return isSetStatuses();`
17353	`}`	17370	`}`
17354	`throw new IllegalStateException();`	17371	`throw new IllegalStateException();`
17355	`}`	17372	`}`
17356		17373
17357	`public boolean isSet(int fieldID) {`	17374	`public boolean isSet(int fieldID) {`
Line 17396...	Line 17413...
17396	`return false;`	17413	`return false;`
17397	`if (this.to_date != that.to_date)`	17414	`if (this.to_date != that.to_date)`
17398	`return false;`	17415	`return false;`
17399	`}`	17416	`}`
17400		17417
17401	`boolean this_present_status = true && this.isSetStatus();`	17418	`boolean this_present_statuses = true && this.isSetStatuses();`
17402	`boolean that_present_status = true && that.isSetStatus();`	17419	`boolean that_present_statuses = true && that.isSetStatuses();`
17403	`if (this_present_status \|\| that_present_status) {`	17420	`if (this_present_statuses \|\| that_present_statuses) {`
17404	`if (!(this_present_status && that_present_status))`	17421	`if (!(this_present_statuses && that_present_statuses))`
17405	`return false;`	17422	`return false;`
17406	`if (!this.status.equals(that.status))`	17423	`if (!this.statuses.equals(that.statuses))`
17407	`return false;`	17424	`return false;`
17408	`}`	17425	`}`
17409		17426
17410	`return true;`	17427	`return true;`
17411	`}`	17428	`}`
Line 17445...	Line 17462...
17445	`}`	17462	`}`
17446	`lastComparison = TBaseHelper.compareTo(to_date, typedOther.to_date);`	17463	`lastComparison = TBaseHelper.compareTo(to_date, typedOther.to_date);`
17447	`if (lastComparison != 0) {`	17464	`if (lastComparison != 0) {`
17448	`return lastComparison;`	17465	`return lastComparison;`
17449	`}`	17466	`}`
17450	`lastComparison = Boolean.valueOf(isSetStatus()).compareTo(isSetStatus());`	17467	`lastComparison = Boolean.valueOf(isSetStatuses()).compareTo(isSetStatuses());`
17451	`if (lastComparison != 0) {`	17468	`if (lastComparison != 0) {`
17452	`return lastComparison;`	17469	`return lastComparison;`
17453	`}`	17470	`}`
17454	`lastComparison = TBaseHelper.compareTo(status, typedOther.status);`	17471	`lastComparison = TBaseHelper.compareTo(statuses, typedOther.statuses);`
17455	`if (lastComparison != 0) {`	17472	`if (lastComparison != 0) {`
17456	`return lastComparison;`	17473	`return lastComparison;`
17457	`}`	17474	`}`
17458	`return 0;`	17475	`return 0;`
17459	`}`	17476	`}`
Line 17494...	Line 17511...
17494	`setTo_dateIsSet(true);`	17511	`setTo_dateIsSet(true);`
17495	`} else {`	17512	`} else {`
17496	`TProtocolUtil.skip(iprot, field.type);`	17513	`TProtocolUtil.skip(iprot, field.type);`
17497	`}`	17514	`}`
17498	`break;`	17515	`break;`
17499	`case STATUS:`	17516	`case STATUSES:`
17500	`if (field.type == TType.I32) {`	17517	`if (field.type == TType.LIST) {`
-		17518	`{`
-		17519	`TList _list36 = iprot.readListBegin();`
-		17520	`this.statuses = new ArrayList<OrderStatus>(_list36.size);`
-		17521	`for (int _i37 = 0; _i37 < _list36.size; ++_i37)`
-		17522	`{`
-		17523	`OrderStatus _elem38;`
17501	`this.status = OrderStatus.findByValue(iprot.readI32());`	17524	`_elem38 = OrderStatus.findByValue(iprot.readI32());`
-		17525	`this.statuses.add(_elem38);`
-		17526	`}`
-		17527	`iprot.readListEnd();`
-		17528	`}`
17502	`} else {`	17529	`} else {`
17503	`TProtocolUtil.skip(iprot, field.type);`	17530	`TProtocolUtil.skip(iprot, field.type);`
17504	`}`	17531	`}`
17505	`break;`	17532	`break;`
17506	`}`	17533	`}`
Line 17522...	Line 17549...
17522	`oprot.writeI64(this.from_date);`	17549	`oprot.writeI64(this.from_date);`
17523	`oprot.writeFieldEnd();`	17550	`oprot.writeFieldEnd();`
17524	`oprot.writeFieldBegin(TO_DATE_FIELD_DESC);`	17551	`oprot.writeFieldBegin(TO_DATE_FIELD_DESC);`
17525	`oprot.writeI64(this.to_date);`	17552	`oprot.writeI64(this.to_date);`
17526	`oprot.writeFieldEnd();`	17553	`oprot.writeFieldEnd();`
17527	`if (this.status != null) {`	17554	`if (this.statuses != null) {`
17528	`oprot.writeFieldBegin(STATUS_FIELD_DESC);`	17555	`oprot.writeFieldBegin(STATUSES_FIELD_DESC);`
-		17556	`{`
-		17557	`oprot.writeListBegin(new TList(TType.I32, this.statuses.size()));`
-		17558	`for (OrderStatus _iter39 : this.statuses)`
-		17559	`{`
17529	`oprot.writeI32(this.status.getValue());`	17560	`oprot.writeI32(_iter39.getValue());`
-		17561	`}`
-		17562	`oprot.writeListEnd();`
-		17563	`}`
17530	`oprot.writeFieldEnd();`	17564	`oprot.writeFieldEnd();`
17531	`}`	17565	`}`
17532	`oprot.writeFieldStop();`	17566	`oprot.writeFieldStop();`
17533	`oprot.writeStructEnd();`	17567	`oprot.writeStructEnd();`
17534	`}`	17568	`}`
Line 17548...	Line 17582...
17548	`if (!first) sb.append(", ");`	17582	`if (!first) sb.append(", ");`
17549	`sb.append("to_date:");`	17583	`sb.append("to_date:");`
17550	`sb.append(this.to_date);`	17584	`sb.append(this.to_date);`
17551	`first = false;`	17585	`first = false;`
17552	`if (!first) sb.append(", ");`	17586	`if (!first) sb.append(", ");`
17553	`sb.append("status:");`	17587	`sb.append("statuses:");`
17554	`if (this.status == null) {`	17588	`if (this.statuses == null) {`
17555	`sb.append("null");`	17589	`sb.append("null");`
17556	`} else {`	17590	`} else {`
17557	`String status_name = status.name();`	-
17558	`if (status_name != null) {`	-
17559	`sb.append(status_name);`	-
17560	`sb.append(" (");`	-
17561	`}`	-
17562	`sb.append(this.status);`	17591	`sb.append(this.statuses);`
17563	`if (status_name != null) {`	-
17564	`sb.append(")");`	-
17565	`}`	-
17566	`}`	17592	`}`
17567	`first = false;`	17593	`first = false;`
17568	`sb.append(")");`	17594	`sb.append(")");`
17569	`return sb.toString();`	17595	`return sb.toString();`
17570	`}`	17596	`}`
Line 17891...	Line 17917...
17891	`} else {`	17917	`} else {`
17892	`switch (fieldId) {`	17918	`switch (fieldId) {`
17893	`case SUCCESS:`	17919	`case SUCCESS:`
17894	`if (field.type == TType.LIST) {`	17920	`if (field.type == TType.LIST) {`
17895	`{`	17921	`{`
17896	`TList _list36 = iprot.readListBegin();`	17922	`TList _list40 = iprot.readListBegin();`
17897	`this.success = new ArrayList<Order>(_list36.size);`	17923	`this.success = new ArrayList<Order>(_list40.size);`
17898	`for (int _i37 = 0; _i37 < _list36.size; ++_i37)`	17924	`for (int _i41 = 0; _i41 < _list40.size; ++_i41)`
17899	`{`	17925	`{`
17900	`Order _elem38;`	17926	`Order _elem42;`
17901	`_elem38 = new Order();`	17927	`_elem42 = new Order();`
17902	`_elem38.read(iprot);`	17928	`_elem42.read(iprot);`
17903	`this.success.add(_elem38);`	17929	`this.success.add(_elem42);`
17904	`}`	17930	`}`
17905	`iprot.readListEnd();`	17931	`iprot.readListEnd();`
17906	`}`	17932	`}`
17907	`} else {`	17933	`} else {`
17908	`TProtocolUtil.skip(iprot, field.type);`	17934	`TProtocolUtil.skip(iprot, field.type);`
Line 17929...	Line 17955...
17929		17955
17930	`if (this.isSetSuccess()) {`	17956	`if (this.isSetSuccess()) {`
17931	`oprot.writeFieldBegin(SUCCESS_FIELD_DESC);`	17957	`oprot.writeFieldBegin(SUCCESS_FIELD_DESC);`
17932	`{`	17958	`{`
17933	`oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));`	17959	`oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));`
17934	`for (Order _iter39 : this.success)`	17960	`for (Order _iter43 : this.success)`
17935	`{`	17961	`{`
17936	`_iter39.write(oprot);`	17962	`_iter43.write(oprot);`
17937	`}`	17963	`}`
17938	`oprot.writeListEnd();`	17964	`oprot.writeListEnd();`
17939	`}`	17965	`}`
17940	`oprot.writeFieldEnd();`	17966	`oprot.writeFieldEnd();`
17941	`} else if (this.isSetEx()) {`	17967	`} else if (this.isSetEx()) {`
Line 19859...	Line 19885...
19859	`} else {`	19885	`} else {`
19860	`switch (fieldId) {`	19886	`switch (fieldId) {`
19861	`case SUCCESS:`	19887	`case SUCCESS:`
19862	`if (field.type == TType.LIST) {`	19888	`if (field.type == TType.LIST) {`
19863	`{`	19889	`{`
19864	`TList _list40 = iprot.readListBegin();`	19890	`TList _list44 = iprot.readListBegin();`
19865	`this.success = new ArrayList<LineItem>(_list40.size);`	19891	`this.success = new ArrayList<LineItem>(_list44.size);`
19866	`for (int _i41 = 0; _i41 < _list40.size; ++_i41)`	19892	`for (int _i45 = 0; _i45 < _list44.size; ++_i45)`
19867	`{`	19893	`{`
19868	`LineItem _elem42;`	19894	`LineItem _elem46;`
19869	`_elem42 = new LineItem();`	19895	`_elem46 = new LineItem();`
19870	`_elem42.read(iprot);`	19896	`_elem46.read(iprot);`
19871	`this.success.add(_elem42);`	19897	`this.success.add(_elem46);`
19872	`}`	19898	`}`
19873	`iprot.readListEnd();`	19899	`iprot.readListEnd();`
19874	`}`	19900	`}`
19875	`} else {`	19901	`} else {`
19876	`TProtocolUtil.skip(iprot, field.type);`	19902	`TProtocolUtil.skip(iprot, field.type);`
Line 19897...	Line 19923...
19897		19923
19898	`if (this.isSetSuccess()) {`	19924	`if (this.isSetSuccess()) {`
19899	`oprot.writeFieldBegin(SUCCESS_FIELD_DESC);`	19925	`oprot.writeFieldBegin(SUCCESS_FIELD_DESC);`
19900	`{`	19926	`{`
19901	`oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));`	19927	`oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));`
19902	`for (LineItem _iter43 : this.success)`	19928	`for (LineItem _iter47 : this.success)`
19903	`{`	19929	`{`
19904	`_iter43.write(oprot);`	19930	`_iter47.write(oprot);`
19905	`}`	19931	`}`
19906	`oprot.writeListEnd();`	19932	`oprot.writeListEnd();`
19907	`}`	19933	`}`
19908	`oprot.writeFieldEnd();`	19934	`oprot.writeFieldEnd();`
19909	`} else if (this.isSetEx()) {`	19935	`} else if (this.isSetEx()) {`
Line 21260...	Line 21286...
21260	`} else {`	21286	`} else {`
21261	`switch (fieldId) {`	21287	`switch (fieldId) {`
21262	`case SUCCESS:`	21288	`case SUCCESS:`
21263	`if (field.type == TType.LIST) {`	21289	`if (field.type == TType.LIST) {`
21264	`{`	21290	`{`
21265	`TList _list44 = iprot.readListBegin();`	21291	`TList _list48 = iprot.readListBegin();`
21266	`this.success = new ArrayList<Order>(_list44.size);`	21292	`this.success = new ArrayList<Order>(_list48.size);`
21267	`for (int _i45 = 0; _i45 < _list44.size; ++_i45)`	21293	`for (int _i49 = 0; _i49 < _list48.size; ++_i49)`
21268	`{`	21294	`{`
21269	`Order _elem46;`	21295	`Order _elem50;`
21270	`_elem46 = new Order();`	21296	`_elem50 = new Order();`
21271	`_elem46.read(iprot);`	21297	`_elem50.read(iprot);`
21272	`this.success.add(_elem46);`	21298	`this.success.add(_elem50);`
21273	`}`	21299	`}`
21274	`iprot.readListEnd();`	21300	`iprot.readListEnd();`
21275	`}`	21301	`}`
21276	`} else {`	21302	`} else {`
21277	`TProtocolUtil.skip(iprot, field.type);`	21303	`TProtocolUtil.skip(iprot, field.type);`
Line 21298...	Line 21324...
21298		21324
21299	`if (this.isSetSuccess()) {`	21325	`if (this.isSetSuccess()) {`
21300	`oprot.writeFieldBegin(SUCCESS_FIELD_DESC);`	21326	`oprot.writeFieldBegin(SUCCESS_FIELD_DESC);`
21301	`{`	21327	`{`
21302	`oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));`	21328	`oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));`
21303	`for (Order _iter47 : this.success)`	21329	`for (Order _iter51 : this.success)`
21304	`{`	21330	`{`
21305	`_iter47.write(oprot);`	21331	`_iter51.write(oprot);`
21306	`}`	21332	`}`
21307	`oprot.writeListEnd();`	21333	`oprot.writeListEnd();`
21308	`}`	21334	`}`
21309	`oprot.writeFieldEnd();`	21335	`oprot.writeFieldEnd();`
21310	`} else if (this.isSetEx()) {`	21336	`} else if (this.isSetEx()) {`
Line 23010...	Line 23036...
23010	`}`	23036	`}`
23011	`break;`	23037	`break;`
23012	`case PICKUP_DETAILS:`	23038	`case PICKUP_DETAILS:`
23013	`if (field.type == TType.MAP) {`	23039	`if (field.type == TType.MAP) {`
23014	`{`	23040	`{`
23015	`TMap _map48 = iprot.readMapBegin();`	23041	`TMap _map52 = iprot.readMapBegin();`
23016	`this.pickupDetails = new HashMap<String,String>(2*_map48.size);`	23042	`this.pickupDetails = new HashMap<String,String>(2*_map52.size);`
23017	`for (int _i49 = 0; _i49 < _map48.size; ++_i49)`	23043	`for (int _i53 = 0; _i53 < _map52.size; ++_i53)`
23018	`{`	23044	`{`
23019	`String _key50;`	23045	`String _key54;`
23020	`String _val51;`	23046	`String _val55;`
23021	`_key50 = iprot.readString();`	23047	`_key54 = iprot.readString();`
23022	`_val51 = iprot.readString();`	23048	`_val55 = iprot.readString();`
23023	`this.pickupDetails.put(_key50, _val51);`	23049	`this.pickupDetails.put(_key54, _val55);`
23024	`}`	23050	`}`
23025	`iprot.readMapEnd();`	23051	`iprot.readMapEnd();`
23026	`}`	23052	`}`
23027	`} else {`	23053	`} else {`
23028	`TProtocolUtil.skip(iprot, field.type);`	23054	`TProtocolUtil.skip(iprot, field.type);`
Line 23045...	Line 23071...
23045	`oprot.writeFieldEnd();`	23071	`oprot.writeFieldEnd();`
23046	`if (this.pickupDetails != null) {`	23072	`if (this.pickupDetails != null) {`
23047	`oprot.writeFieldBegin(PICKUP_DETAILS_FIELD_DESC);`	23073	`oprot.writeFieldBegin(PICKUP_DETAILS_FIELD_DESC);`
23048	`{`	23074	`{`
23049	`oprot.writeMapBegin(new TMap(TType.STRING, TType.STRING, this.pickupDetails.size()));`	23075	`oprot.writeMapBegin(new TMap(TType.STRING, TType.STRING, this.pickupDetails.size()));`
23050	`for (Map.Entry<String, String> _iter52 : this.pickupDetails.entrySet())`	23076	`for (Map.Entry<String, String> _iter56 : this.pickupDetails.entrySet())`
23051	`{`	23077	`{`
23052	`oprot.writeString(_iter52.getKey());`	23078	`oprot.writeString(_iter56.getKey());`
23053	`oprot.writeString(_iter52.getValue());`	23079	`oprot.writeString(_iter56.getValue());`
23054	`}`	23080	`}`
23055	`oprot.writeMapEnd();`	23081	`oprot.writeMapEnd();`
23056	`}`	23082	`}`
23057	`oprot.writeFieldEnd();`	23083	`oprot.writeFieldEnd();`
23058	`}`	23084	`}`
Line 23402...	Line 23428...
23402	`} else {`	23428	`} else {`
23403	`switch (fieldId) {`	23429	`switch (fieldId) {`
23404	`case SUCCESS:`	23430	`case SUCCESS:`
23405	`if (field.type == TType.LIST) {`	23431	`if (field.type == TType.LIST) {`
23406	`{`	23432	`{`
23407	`TList _list53 = iprot.readListBegin();`	23433	`TList _list57 = iprot.readListBegin();`
23408	`this.success = new ArrayList<Order>(_list53.size);`	23434	`this.success = new ArrayList<Order>(_list57.size);`
23409	`for (int _i54 = 0; _i54 < _list53.size; ++_i54)`	23435	`for (int _i58 = 0; _i58 < _list57.size; ++_i58)`
23410	`{`	23436	`{`
23411	`Order _elem55;`	23437	`Order _elem59;`
23412	`_elem55 = new Order();`	23438	`_elem59 = new Order();`
23413	`_elem55.read(iprot);`	23439	`_elem59.read(iprot);`
23414	`this.success.add(_elem55);`	23440	`this.success.add(_elem59);`
23415	`}`	23441	`}`
23416	`iprot.readListEnd();`	23442	`iprot.readListEnd();`
23417	`}`	23443	`}`
23418	`} else {`	23444	`} else {`
23419	`TProtocolUtil.skip(iprot, field.type);`	23445	`TProtocolUtil.skip(iprot, field.type);`
Line 23440...	Line 23466...
23440		23466
23441	`if (this.isSetSuccess()) {`	23467	`if (this.isSetSuccess()) {`
23442	`oprot.writeFieldBegin(SUCCESS_FIELD_DESC);`	23468	`oprot.writeFieldBegin(SUCCESS_FIELD_DESC);`
23443	`{`	23469	`{`
23444	`oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));`	23470	`oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));`
23445	`for (Order _iter56 : this.success)`	23471	`for (Order _iter60 : this.success)`
23446	`{`	23472	`{`
23447	`_iter56.write(oprot);`	23473	`_iter60.write(oprot);`
23448	`}`	23474	`}`
23449	`oprot.writeListEnd();`	23475	`oprot.writeListEnd();`
23450	`}`	23476	`}`
23451	`oprot.writeFieldEnd();`	23477	`oprot.writeFieldEnd();`
23452	`} else if (this.isSetEx()) {`	23478	`} else if (this.isSetEx()) {`

Subversion Repositories SmartDukaan

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