Subversion Repositories SmartDukaan

Rev

Rev 1629 | Rev 1886 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 1629 Rev 1731
Line 208... Line 208...
208
     * Returns the number of distinct customers who have done successful transactions
208
     * Returns the number of distinct customers who have done successful transactions
209
     */
209
     */
210
    public long getNoOfCustomersWithSuccessfulTransaction() throws TException;
210
    public long getNoOfCustomersWithSuccessfulTransaction() throws TException;
211
 
211
 
212
    /**
212
    /**
213
     * Returns the maximum amount of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
213
     * Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
-
 
214
     * List contains two values, first minimum amount and second maximum amount.
214
     */
215
     */
215
    public double getMaxValidOrderAmount() throws TException;
216
    public List<Double> getValidOrdersAmountRange() throws TException;
216
 
-
 
217
    /**
-
 
218
     * Returns the minimum amount of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
-
 
219
     */
-
 
220
    public double getMinValidOrderAmount() throws TException;
-
 
221
 
217
 
222
  }
218
  }
223
 
219
 
224
  public static class Client implements Iface {
220
  public static class Client implements Iface {
225
    public Client(TProtocol prot)
221
    public Client(TProtocol prot)
Line 1503... Line 1499...
1503
        return result.success;
1499
        return result.success;
1504
      }
1500
      }
1505
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1501
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1506
    }
1502
    }
1507
 
1503
 
1508
    public double getMaxValidOrderAmount() throws TException
1504
    public List<Double> getValidOrdersAmountRange() throws TException
1509
    {
-
 
1510
      send_getMaxValidOrderAmount();
-
 
1511
      return recv_getMaxValidOrderAmount();
-
 
1512
    }
-
 
1513
 
-
 
1514
    public void send_getMaxValidOrderAmount() throws TException
-
 
1515
    {
-
 
1516
      oprot_.writeMessageBegin(new TMessage("getMaxValidOrderAmount", TMessageType.CALL, seqid_));
-
 
1517
      getMaxValidOrderAmount_args args = new getMaxValidOrderAmount_args();
-
 
1518
      args.write(oprot_);
-
 
1519
      oprot_.writeMessageEnd();
-
 
1520
      oprot_.getTransport().flush();
-
 
1521
    }
-
 
1522
 
-
 
1523
    public double recv_getMaxValidOrderAmount() throws TException
-
 
1524
    {
-
 
1525
      TMessage msg = iprot_.readMessageBegin();
-
 
1526
      if (msg.type == TMessageType.EXCEPTION) {
-
 
1527
        TApplicationException x = TApplicationException.read(iprot_);
-
 
1528
        iprot_.readMessageEnd();
-
 
1529
        throw x;
-
 
1530
      }
-
 
1531
      getMaxValidOrderAmount_result result = new getMaxValidOrderAmount_result();
-
 
1532
      result.read(iprot_);
-
 
1533
      iprot_.readMessageEnd();
-
 
1534
      if (result.isSetSuccess()) {
-
 
1535
        return result.success;
-
 
1536
      }
-
 
1537
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getMaxValidOrderAmount failed: unknown result");
-
 
1538
    }
-
 
1539
 
-
 
1540
    public double getMinValidOrderAmount() throws TException
-
 
1541
    {
1505
    {
1542
      send_getMinValidOrderAmount();
1506
      send_getValidOrdersAmountRange();
1543
      return recv_getMinValidOrderAmount();
1507
      return recv_getValidOrdersAmountRange();
1544
    }
1508
    }
1545
 
1509
 
1546
    public void send_getMinValidOrderAmount() throws TException
1510
    public void send_getValidOrdersAmountRange() throws TException
1547
    {
1511
    {
1548
      oprot_.writeMessageBegin(new TMessage("getMinValidOrderAmount", TMessageType.CALL, seqid_));
1512
      oprot_.writeMessageBegin(new TMessage("getValidOrdersAmountRange", TMessageType.CALL, seqid_));
1549
      getMinValidOrderAmount_args args = new getMinValidOrderAmount_args();
1513
      getValidOrdersAmountRange_args args = new getValidOrdersAmountRange_args();
1550
      args.write(oprot_);
1514
      args.write(oprot_);
1551
      oprot_.writeMessageEnd();
1515
      oprot_.writeMessageEnd();
1552
      oprot_.getTransport().flush();
1516
      oprot_.getTransport().flush();
1553
    }
1517
    }
1554
 
1518
 
1555
    public double recv_getMinValidOrderAmount() throws TException
1519
    public List<Double> recv_getValidOrdersAmountRange() throws TException
1556
    {
1520
    {
1557
      TMessage msg = iprot_.readMessageBegin();
1521
      TMessage msg = iprot_.readMessageBegin();
1558
      if (msg.type == TMessageType.EXCEPTION) {
1522
      if (msg.type == TMessageType.EXCEPTION) {
1559
        TApplicationException x = TApplicationException.read(iprot_);
1523
        TApplicationException x = TApplicationException.read(iprot_);
1560
        iprot_.readMessageEnd();
1524
        iprot_.readMessageEnd();
1561
        throw x;
1525
        throw x;
1562
      }
1526
      }
1563
      getMinValidOrderAmount_result result = new getMinValidOrderAmount_result();
1527
      getValidOrdersAmountRange_result result = new getValidOrdersAmountRange_result();
1564
      result.read(iprot_);
1528
      result.read(iprot_);
1565
      iprot_.readMessageEnd();
1529
      iprot_.readMessageEnd();
1566
      if (result.isSetSuccess()) {
1530
      if (result.isSetSuccess()) {
1567
        return result.success;
1531
        return result.success;
1568
      }
1532
      }
1569
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getMinValidOrderAmount failed: unknown result");
1533
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1570
    }
1534
    }
1571
 
1535
 
1572
  }
1536
  }
1573
  public static class Processor implements TProcessor {
1537
  public static class Processor implements TProcessor {
1574
    private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
1538
    private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
Line 1608... Line 1572...
1608
      processMap_.put("getUndeliveredOrders", new getUndeliveredOrders());
1572
      processMap_.put("getUndeliveredOrders", new getUndeliveredOrders());
1609
      processMap_.put("getAlerts", new getAlerts());
1573
      processMap_.put("getAlerts", new getAlerts());
1610
      processMap_.put("setAlert", new setAlert());
1574
      processMap_.put("setAlert", new setAlert());
1611
      processMap_.put("getValidOrderCount", new getValidOrderCount());
1575
      processMap_.put("getValidOrderCount", new getValidOrderCount());
1612
      processMap_.put("getNoOfCustomersWithSuccessfulTransaction", new getNoOfCustomersWithSuccessfulTransaction());
1576
      processMap_.put("getNoOfCustomersWithSuccessfulTransaction", new getNoOfCustomersWithSuccessfulTransaction());
1613
      processMap_.put("getMaxValidOrderAmount", new getMaxValidOrderAmount());
-
 
1614
      processMap_.put("getMinValidOrderAmount", new getMinValidOrderAmount());
1577
      processMap_.put("getValidOrdersAmountRange", new getValidOrdersAmountRange());
1615
    }
1578
    }
1616
 
1579
 
1617
    protected static interface ProcessFunction {
1580
    protected static interface ProcessFunction {
1618
      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException;
1581
      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException;
1619
    }
1582
    }
Line 2558... Line 2521...
2558
        oprot.getTransport().flush();
2521
        oprot.getTransport().flush();
2559
      }
2522
      }
2560
 
2523
 
2561
    }
2524
    }
2562
 
2525
 
2563
    private class getMaxValidOrderAmount implements ProcessFunction {
2526
    private class getValidOrdersAmountRange implements ProcessFunction {
2564
      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
-
 
2565
      {
-
 
2566
        getMaxValidOrderAmount_args args = new getMaxValidOrderAmount_args();
-
 
2567
        args.read(iprot);
-
 
2568
        iprot.readMessageEnd();
-
 
2569
        getMaxValidOrderAmount_result result = new getMaxValidOrderAmount_result();
-
 
2570
        result.success = iface_.getMaxValidOrderAmount();
-
 
2571
        result.setSuccessIsSet(true);
-
 
2572
        oprot.writeMessageBegin(new TMessage("getMaxValidOrderAmount", TMessageType.REPLY, seqid));
-
 
2573
        result.write(oprot);
-
 
2574
        oprot.writeMessageEnd();
-
 
2575
        oprot.getTransport().flush();
-
 
2576
      }
-
 
2577
 
-
 
2578
    }
-
 
2579
 
-
 
2580
    private class getMinValidOrderAmount implements ProcessFunction {
-
 
2581
      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2527
      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
2582
      {
2528
      {
2583
        getMinValidOrderAmount_args args = new getMinValidOrderAmount_args();
2529
        getValidOrdersAmountRange_args args = new getValidOrdersAmountRange_args();
2584
        args.read(iprot);
2530
        args.read(iprot);
2585
        iprot.readMessageEnd();
2531
        iprot.readMessageEnd();
2586
        getMinValidOrderAmount_result result = new getMinValidOrderAmount_result();
2532
        getValidOrdersAmountRange_result result = new getValidOrdersAmountRange_result();
2587
        result.success = iface_.getMinValidOrderAmount();
2533
        result.success = iface_.getValidOrdersAmountRange();
2588
        result.setSuccessIsSet(true);
-
 
2589
        oprot.writeMessageBegin(new TMessage("getMinValidOrderAmount", TMessageType.REPLY, seqid));
2534
        oprot.writeMessageBegin(new TMessage("getValidOrdersAmountRange", TMessageType.REPLY, seqid));
2590
        result.write(oprot);
2535
        result.write(oprot);
2591
        oprot.writeMessageEnd();
2536
        oprot.writeMessageEnd();
2592
        oprot.getTransport().flush();
2537
        oprot.getTransport().flush();
2593
      }
2538
      }
2594
 
2539
 
Line 27236... Line 27181...
27236
      // check for required fields
27181
      // check for required fields
27237
    }
27182
    }
27238
 
27183
 
27239
  }
27184
  }
27240
 
27185
 
27241
  public static class getMaxValidOrderAmount_args implements TBase<getMaxValidOrderAmount_args._Fields>, java.io.Serializable, Cloneable, Comparable<getMaxValidOrderAmount_args>   {
27186
  public static class getValidOrdersAmountRange_args implements TBase<getValidOrdersAmountRange_args._Fields>, java.io.Serializable, Cloneable, Comparable<getValidOrdersAmountRange_args>   {
27242
    private static final TStruct STRUCT_DESC = new TStruct("getMaxValidOrderAmount_args");
27187
    private static final TStruct STRUCT_DESC = new TStruct("getValidOrdersAmountRange_args");
27243
 
27188
 
27244
 
27189
 
27245
 
27190
 
27246
    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
27191
    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
27247
    public enum _Fields implements TFieldIdEnum {
27192
    public enum _Fields implements TFieldIdEnum {
Line 27299... Line 27244...
27299
    }
27244
    }
27300
    public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
27245
    public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
27301
    }});
27246
    }});
27302
 
27247
 
27303
    static {
27248
    static {
27304
      FieldMetaData.addStructMetaDataMap(getMaxValidOrderAmount_args.class, metaDataMap);
27249
      FieldMetaData.addStructMetaDataMap(getValidOrdersAmountRange_args.class, metaDataMap);
27305
    }
27250
    }
27306
 
27251
 
27307
    public getMaxValidOrderAmount_args() {
27252
    public getValidOrdersAmountRange_args() {
27308
    }
27253
    }
27309
 
27254
 
27310
    /**
27255
    /**
27311
     * Performs a deep copy on <i>other</i>.
27256
     * Performs a deep copy on <i>other</i>.
27312
     */
27257
     */
27313
    public getMaxValidOrderAmount_args(getMaxValidOrderAmount_args other) {
27258
    public getValidOrdersAmountRange_args(getValidOrdersAmountRange_args other) {
27314
    }
27259
    }
27315
 
27260
 
27316
    public getMaxValidOrderAmount_args deepCopy() {
27261
    public getValidOrdersAmountRange_args deepCopy() {
27317
      return new getMaxValidOrderAmount_args(this);
27262
      return new getValidOrdersAmountRange_args(this);
27318
    }
27263
    }
27319
 
27264
 
27320
    @Deprecated
27265
    @Deprecated
27321
    public getMaxValidOrderAmount_args clone() {
27266
    public getValidOrdersAmountRange_args clone() {
27322
      return new getMaxValidOrderAmount_args(this);
27267
      return new getValidOrdersAmountRange_args(this);
27323
    }
27268
    }
27324
 
27269
 
27325
    public void setFieldValue(_Fields field, Object value) {
27270
    public void setFieldValue(_Fields field, Object value) {
27326
      switch (field) {
27271
      switch (field) {
27327
      }
27272
      }
Line 27354... Line 27299...
27354
 
27299
 
27355
    @Override
27300
    @Override
27356
    public boolean equals(Object that) {
27301
    public boolean equals(Object that) {
27357
      if (that == null)
27302
      if (that == null)
27358
        return false;
27303
        return false;
27359
      if (that instanceof getMaxValidOrderAmount_args)
27304
      if (that instanceof getValidOrdersAmountRange_args)
27360
        return this.equals((getMaxValidOrderAmount_args)that);
27305
        return this.equals((getValidOrdersAmountRange_args)that);
27361
      return false;
27306
      return false;
27362
    }
27307
    }
27363
 
27308
 
27364
    public boolean equals(getMaxValidOrderAmount_args that) {
27309
    public boolean equals(getValidOrdersAmountRange_args that) {
27365
      if (that == null)
27310
      if (that == null)
27366
        return false;
27311
        return false;
27367
 
27312
 
27368
      return true;
27313
      return true;
27369
    }
27314
    }
Line 27371... Line 27316...
27371
    @Override
27316
    @Override
27372
    public int hashCode() {
27317
    public int hashCode() {
27373
      return 0;
27318
      return 0;
27374
    }
27319
    }
27375
 
27320
 
27376
    public int compareTo(getMaxValidOrderAmount_args other) {
27321
    public int compareTo(getValidOrdersAmountRange_args other) {
27377
      if (!getClass().equals(other.getClass())) {
27322
      if (!getClass().equals(other.getClass())) {
27378
        return getClass().getName().compareTo(other.getClass().getName());
27323
        return getClass().getName().compareTo(other.getClass().getName());
27379
      }
27324
      }
27380
 
27325
 
27381
      int lastComparison = 0;
27326
      int lastComparison = 0;
27382
      getMaxValidOrderAmount_args typedOther = (getMaxValidOrderAmount_args)other;
27327
      getValidOrdersAmountRange_args typedOther = (getValidOrdersAmountRange_args)other;
27383
 
27328
 
27384
      return 0;
27329
      return 0;
27385
    }
27330
    }
27386
 
27331
 
27387
    public void read(TProtocol iprot) throws TException {
27332
    public void read(TProtocol iprot) throws TException {
Line 27414... Line 27359...
27414
      oprot.writeStructEnd();
27359
      oprot.writeStructEnd();
27415
    }
27360
    }
27416
 
27361
 
27417
    @Override
27362
    @Override
27418
    public String toString() {
27363
    public String toString() {
27419
      StringBuilder sb = new StringBuilder("getMaxValidOrderAmount_args(");
27364
      StringBuilder sb = new StringBuilder("getValidOrdersAmountRange_args(");
27420
      boolean first = true;
27365
      boolean first = true;
27421
 
27366
 
27422
      sb.append(")");
27367
      sb.append(")");
27423
      return sb.toString();
27368
      return sb.toString();
27424
    }
27369
    }
Line 27427... Line 27372...
27427
      // check for required fields
27372
      // check for required fields
27428
    }
27373
    }
27429
 
27374
 
27430
  }
27375
  }
27431
 
27376
 
27432
  public static class getMaxValidOrderAmount_result implements TBase<getMaxValidOrderAmount_result._Fields>, java.io.Serializable, Cloneable, Comparable<getMaxValidOrderAmount_result>   {
27377
  public static class getValidOrdersAmountRange_result implements TBase<getValidOrdersAmountRange_result._Fields>, java.io.Serializable, Cloneable, Comparable<getValidOrdersAmountRange_result>   {
27433
    private static final TStruct STRUCT_DESC = new TStruct("getMaxValidOrderAmount_result");
27378
    private static final TStruct STRUCT_DESC = new TStruct("getValidOrdersAmountRange_result");
27434
 
27379
 
27435
    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.DOUBLE, (short)0);
27380
    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
27436
 
27381
 
27437
    private double success;
27382
    private List<Double> success;
27438
 
27383
 
27439
    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
27384
    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
27440
    public enum _Fields implements TFieldIdEnum {
27385
    public enum _Fields implements TFieldIdEnum {
27441
      SUCCESS((short)0, "success");
27386
      SUCCESS((short)0, "success");
27442
 
27387
 
Line 27490... Line 27435...
27490
        return _fieldName;
27435
        return _fieldName;
27491
      }
27436
      }
27492
    }
27437
    }
27493
 
27438
 
27494
    // isset id assignments
27439
    // isset id assignments
27495
    private static final int __SUCCESS_ISSET_ID = 0;
-
 
27496
    private BitSet __isset_bit_vector = new BitSet(1);
-
 
27497
 
27440
 
27498
    public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
27441
    public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
27499
      put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, 
27442
      put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, 
-
 
27443
          new ListMetaData(TType.LIST, 
27500
          new FieldValueMetaData(TType.DOUBLE)));
27444
              new FieldValueMetaData(TType.DOUBLE))));
27501
    }});
27445
    }});
27502
 
27446
 
27503
    static {
27447
    static {
27504
      FieldMetaData.addStructMetaDataMap(getMaxValidOrderAmount_result.class, metaDataMap);
27448
      FieldMetaData.addStructMetaDataMap(getValidOrdersAmountRange_result.class, metaDataMap);
27505
    }
27449
    }
27506
 
27450
 
27507
    public getMaxValidOrderAmount_result() {
27451
    public getValidOrdersAmountRange_result() {
27508
    }
27452
    }
27509
 
27453
 
27510
    public getMaxValidOrderAmount_result(
27454
    public getValidOrdersAmountRange_result(
27511
      double success)
27455
      List<Double> success)
27512
    {
27456
    {
27513
      this();
27457
      this();
27514
      this.success = success;
27458
      this.success = success;
27515
      setSuccessIsSet(true);
-
 
27516
    }
27459
    }
27517
 
27460
 
27518
    /**
27461
    /**
27519
     * Performs a deep copy on <i>other</i>.
27462
     * Performs a deep copy on <i>other</i>.
27520
     */
27463
     */
27521
    public getMaxValidOrderAmount_result(getMaxValidOrderAmount_result other) {
27464
    public getValidOrdersAmountRange_result(getValidOrdersAmountRange_result other) {
27522
      __isset_bit_vector.clear();
-
 
27523
      __isset_bit_vector.or(other.__isset_bit_vector);
-
 
27524
      this.success = other.success;
-
 
27525
    }
-
 
27526
 
-
 
27527
    public getMaxValidOrderAmount_result deepCopy() {
-
 
27528
      return new getMaxValidOrderAmount_result(this);
-
 
27529
    }
-
 
27530
 
-
 
27531
    @Deprecated
-
 
27532
    public getMaxValidOrderAmount_result clone() {
-
 
27533
      return new getMaxValidOrderAmount_result(this);
-
 
27534
    }
-
 
27535
 
-
 
27536
    public double getSuccess() {
-
 
27537
      return this.success;
-
 
27538
    }
-
 
27539
 
-
 
27540
    public getMaxValidOrderAmount_result setSuccess(double success) {
-
 
27541
      this.success = success;
-
 
27542
      setSuccessIsSet(true);
-
 
27543
      return this;
-
 
27544
    }
-
 
27545
 
-
 
27546
    public void unsetSuccess() {
-
 
27547
      __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
-
 
27548
    }
-
 
27549
 
-
 
27550
    /** Returns true if field success is set (has been asigned a value) and false otherwise */
-
 
27551
    public boolean isSetSuccess() {
-
 
27552
      return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
-
 
27553
    }
-
 
27554
 
-
 
27555
    public void setSuccessIsSet(boolean value) {
-
 
27556
      __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
-
 
27557
    }
-
 
27558
 
-
 
27559
    public void setFieldValue(_Fields field, Object value) {
-
 
27560
      switch (field) {
-
 
27561
      case SUCCESS:
-
 
27562
        if (value == null) {
-
 
27563
          unsetSuccess();
-
 
27564
        } else {
-
 
27565
          setSuccess((Double)value);
-
 
27566
        }
-
 
27567
        break;
-
 
27568
 
-
 
27569
      }
-
 
27570
    }
-
 
27571
 
-
 
27572
    public void setFieldValue(int fieldID, Object value) {
-
 
27573
      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
-
 
27574
    }
-
 
27575
 
-
 
27576
    public Object getFieldValue(_Fields field) {
-
 
27577
      switch (field) {
-
 
27578
      case SUCCESS:
-
 
27579
        return new Double(getSuccess());
-
 
27580
 
-
 
27581
      }
-
 
27582
      throw new IllegalStateException();
-
 
27583
    }
-
 
27584
 
-
 
27585
    public Object getFieldValue(int fieldId) {
-
 
27586
      return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
-
 
27587
    }
-
 
27588
 
-
 
27589
    /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
-
 
27590
    public boolean isSet(_Fields field) {
-
 
27591
      switch (field) {
-
 
27592
      case SUCCESS:
-
 
27593
        return isSetSuccess();
27465
      if (other.isSetSuccess()) {
27594
      }
-
 
27595
      throw new IllegalStateException();
-
 
27596
    }
-
 
27597
 
-
 
27598
    public boolean isSet(int fieldID) {
-
 
27599
      return isSet(_Fields.findByThriftIdOrThrow(fieldID));
-
 
27600
    }
-
 
27601
 
-
 
27602
    @Override
-
 
27603
    public boolean equals(Object that) {
-
 
27604
      if (that == null)
-
 
27605
        return false;
-
 
27606
      if (that instanceof getMaxValidOrderAmount_result)
-
 
27607
        return this.equals((getMaxValidOrderAmount_result)that);
-
 
27608
      return false;
-
 
27609
    }
-
 
27610
 
-
 
27611
    public boolean equals(getMaxValidOrderAmount_result that) {
-
 
27612
      if (that == null)
-
 
27613
        return false;
-
 
27614
 
-
 
27615
      boolean this_present_success = true;
-
 
27616
      boolean that_present_success = true;
-
 
27617
      if (this_present_success || that_present_success) {
-
 
27618
        if (!(this_present_success && that_present_success))
27466
        List<Double> __this__success = new ArrayList<Double>();
27619
          return false;
-
 
27620
        if (this.success != that.success)
27467
        for (Double other_element : other.success) {
27621
          return false;
-
 
27622
      }
-
 
27623
 
-
 
27624
      return true;
-
 
27625
    }
-
 
27626
 
-
 
27627
    @Override
-
 
27628
    public int hashCode() {
-
 
27629
      return 0;
-
 
27630
    }
-
 
27631
 
-
 
27632
    public int compareTo(getMaxValidOrderAmount_result other) {
-
 
27633
      if (!getClass().equals(other.getClass())) {
-
 
27634
        return getClass().getName().compareTo(other.getClass().getName());
-
 
27635
      }
-
 
27636
 
-
 
27637
      int lastComparison = 0;
-
 
27638
      getMaxValidOrderAmount_result typedOther = (getMaxValidOrderAmount_result)other;
-
 
27639
 
-
 
27640
      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
-
 
27641
      if (lastComparison != 0) {
-
 
27642
        return lastComparison;
-
 
27643
      }
-
 
27644
      lastComparison = TBaseHelper.compareTo(success, typedOther.success);
-
 
27645
      if (lastComparison != 0) {
-
 
27646
        return lastComparison;
-
 
27647
      }
-
 
27648
      return 0;
-
 
27649
    }
-
 
27650
 
-
 
27651
    public void read(TProtocol iprot) throws TException {
-
 
27652
      TField field;
-
 
27653
      iprot.readStructBegin();
-
 
27654
      while (true)
-
 
27655
      {
-
 
27656
        field = iprot.readFieldBegin();
-
 
27657
        if (field.type == TType.STOP) { 
-
 
27658
          break;
-
 
27659
        }
-
 
27660
        _Fields fieldId = _Fields.findByThriftId(field.id);
-
 
27661
        if (fieldId == null) {
-
 
27662
          TProtocolUtil.skip(iprot, field.type);
-
 
27663
        } else {
-
 
27664
          switch (fieldId) {
-
 
27665
            case SUCCESS:
-
 
27666
              if (field.type == TType.DOUBLE) {
-
 
27667
                this.success = iprot.readDouble();
27468
          __this__success.add(other_element);
27668
                setSuccessIsSet(true);
-
 
27669
              } else { 
-
 
27670
                TProtocolUtil.skip(iprot, field.type);
-
 
27671
              }
-
 
27672
              break;
-
 
27673
          }
-
 
27674
          iprot.readFieldEnd();
-
 
27675
        }
-
 
27676
      }
-
 
27677
      iprot.readStructEnd();
-
 
27678
      validate();
-
 
27679
    }
-
 
27680
 
-
 
27681
    public void write(TProtocol oprot) throws TException {
-
 
27682
      oprot.writeStructBegin(STRUCT_DESC);
-
 
27683
 
-
 
27684
      if (this.isSetSuccess()) {
-
 
27685
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
-
 
27686
        oprot.writeDouble(this.success);
-
 
27687
        oprot.writeFieldEnd();
-
 
27688
      }
-
 
27689
      oprot.writeFieldStop();
-
 
27690
      oprot.writeStructEnd();
-
 
27691
    }
-
 
27692
 
-
 
27693
    @Override
-
 
27694
    public String toString() {
-
 
27695
      StringBuilder sb = new StringBuilder("getMaxValidOrderAmount_result(");
-
 
27696
      boolean first = true;
-
 
27697
 
-
 
27698
      sb.append("success:");
-
 
27699
      sb.append(this.success);
-
 
27700
      first = false;
-
 
27701
      sb.append(")");
-
 
27702
      return sb.toString();
-
 
27703
    }
-
 
27704
 
-
 
27705
    public void validate() throws TException {
-
 
27706
      // check for required fields
-
 
27707
    }
-
 
27708
 
-
 
27709
  }
-
 
27710
 
-
 
27711
  public static class getMinValidOrderAmount_args implements TBase<getMinValidOrderAmount_args._Fields>, java.io.Serializable, Cloneable, Comparable<getMinValidOrderAmount_args>   {
-
 
27712
    private static final TStruct STRUCT_DESC = new TStruct("getMinValidOrderAmount_args");
-
 
27713
 
-
 
27714
 
-
 
27715
 
-
 
27716
    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
-
 
27717
    public enum _Fields implements TFieldIdEnum {
-
 
27718
;
-
 
27719
 
-
 
27720
      private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
-
 
27721
      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
-
 
27722
 
-
 
27723
      static {
-
 
27724
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
-
 
27725
          byId.put((int)field._thriftId, field);
-
 
27726
          byName.put(field.getFieldName(), field);
-
 
27727
        }
27469
        }
-
 
27470
        this.success = __this__success;
27728
      }
27471
      }
27729
 
-
 
27730
      /**
-
 
27731
       * Find the _Fields constant that matches fieldId, or null if its not found.
-
 
27732
       */
-
 
27733
      public static _Fields findByThriftId(int fieldId) {
-
 
27734
        return byId.get(fieldId);
-
 
27735
      }
-
 
27736
 
-
 
27737
      /**
-
 
27738
       * Find the _Fields constant that matches fieldId, throwing an exception
-
 
27739
       * if it is not found.
-
 
27740
       */
-
 
27741
      public static _Fields findByThriftIdOrThrow(int fieldId) {
-
 
27742
        _Fields fields = findByThriftId(fieldId);
-
 
27743
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
-
 
27744
        return fields;
-
 
27745
      }
-
 
27746
 
-
 
27747
      /**
-
 
27748
       * Find the _Fields constant that matches name, or null if its not found.
-
 
27749
       */
-
 
27750
      public static _Fields findByName(String name) {
-
 
27751
        return byName.get(name);
-
 
27752
      }
-
 
27753
 
-
 
27754
      private final short _thriftId;
-
 
27755
      private final String _fieldName;
-
 
27756
 
-
 
27757
      _Fields(short thriftId, String fieldName) {
-
 
27758
        _thriftId = thriftId;
-
 
27759
        _fieldName = fieldName;
-
 
27760
      }
-
 
27761
 
-
 
27762
      public short getThriftFieldId() {
-
 
27763
        return _thriftId;
-
 
27764
      }
-
 
27765
 
-
 
27766
      public String getFieldName() {
-
 
27767
        return _fieldName;
-
 
27768
      }
-
 
27769
    }
-
 
27770
    public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
-
 
27771
    }});
-
 
27772
 
-
 
27773
    static {
-
 
27774
      FieldMetaData.addStructMetaDataMap(getMinValidOrderAmount_args.class, metaDataMap);
-
 
27775
    }
27472
    }
27776
 
27473
 
27777
    public getMinValidOrderAmount_args() {
-
 
27778
    }
-
 
27779
 
-
 
27780
    /**
-
 
27781
     * Performs a deep copy on <i>other</i>.
-
 
27782
     */
-
 
27783
    public getMinValidOrderAmount_args(getMinValidOrderAmount_args other) {
-
 
27784
    }
-
 
27785
 
-
 
27786
    public getMinValidOrderAmount_args deepCopy() {
27474
    public getValidOrdersAmountRange_result deepCopy() {
27787
      return new getMinValidOrderAmount_args(this);
27475
      return new getValidOrdersAmountRange_result(this);
27788
    }
27476
    }
27789
 
27477
 
27790
    @Deprecated
27478
    @Deprecated
27791
    public getMinValidOrderAmount_args clone() {
27479
    public getValidOrdersAmountRange_result clone() {
27792
      return new getMinValidOrderAmount_args(this);
27480
      return new getValidOrdersAmountRange_result(this);
27793
    }
-
 
27794
 
-
 
27795
    public void setFieldValue(_Fields field, Object value) {
-
 
27796
      switch (field) {
-
 
27797
      }
-
 
27798
    }
-
 
27799
 
-
 
27800
    public void setFieldValue(int fieldID, Object value) {
-
 
27801
      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
-
 
27802
    }
-
 
27803
 
-
 
27804
    public Object getFieldValue(_Fields field) {
-
 
27805
      switch (field) {
-
 
27806
      }
-
 
27807
      throw new IllegalStateException();
-
 
27808
    }
-
 
27809
 
-
 
27810
    public Object getFieldValue(int fieldId) {
-
 
27811
      return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
-
 
27812
    }
-
 
27813
 
-
 
27814
    /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
-
 
27815
    public boolean isSet(_Fields field) {
-
 
27816
      switch (field) {
-
 
27817
      }
-
 
27818
      throw new IllegalStateException();
-
 
27819
    }
-
 
27820
 
-
 
27821
    public boolean isSet(int fieldID) {
-
 
27822
      return isSet(_Fields.findByThriftIdOrThrow(fieldID));
-
 
27823
    }
27481
    }
27824
 
27482
 
27825
    @Override
-
 
27826
    public boolean equals(Object that) {
-
 
27827
      if (that == null)
-
 
27828
        return false;
-
 
27829
      if (that instanceof getMinValidOrderAmount_args)
-
 
27830
        return this.equals((getMinValidOrderAmount_args)that);
-
 
27831
      return false;
-
 
27832
    }
-
 
27833
 
-
 
27834
    public boolean equals(getMinValidOrderAmount_args that) {
-
 
27835
      if (that == null)
-
 
27836
        return false;
-
 
27837
 
-
 
27838
      return true;
-
 
27839
    }
-
 
27840
 
-
 
27841
    @Override
-
 
27842
    public int hashCode() {
27483
    public int getSuccessSize() {
27843
      return 0;
-
 
27844
    }
-
 
27845
 
-
 
27846
    public int compareTo(getMinValidOrderAmount_args other) {
-
 
27847
      if (!getClass().equals(other.getClass())) {
-
 
27848
        return getClass().getName().compareTo(other.getClass().getName());
27484
      return (this.success == null) ? 0 : this.success.size();
27849
      }
-
 
27850
 
-
 
27851
      int lastComparison = 0;
-
 
27852
      getMinValidOrderAmount_args typedOther = (getMinValidOrderAmount_args)other;
-
 
27853
 
-
 
27854
      return 0;
-
 
27855
    }
-
 
27856
 
-
 
27857
    public void read(TProtocol iprot) throws TException {
-
 
27858
      TField field;
-
 
27859
      iprot.readStructBegin();
-
 
27860
      while (true)
-
 
27861
      {
-
 
27862
        field = iprot.readFieldBegin();
-
 
27863
        if (field.type == TType.STOP) { 
-
 
27864
          break;
-
 
27865
        }
-
 
27866
        _Fields fieldId = _Fields.findByThriftId(field.id);
-
 
27867
        if (fieldId == null) {
-
 
27868
          TProtocolUtil.skip(iprot, field.type);
-
 
27869
        } else {
-
 
27870
          switch (fieldId) {
-
 
27871
          }
-
 
27872
          iprot.readFieldEnd();
-
 
27873
        }
-
 
27874
      }
-
 
27875
      iprot.readStructEnd();
-
 
27876
      validate();
-
 
27877
    }
-
 
27878
 
-
 
27879
    public void write(TProtocol oprot) throws TException {
-
 
27880
      validate();
-
 
27881
 
-
 
27882
      oprot.writeStructBegin(STRUCT_DESC);
-
 
27883
      oprot.writeFieldStop();
-
 
27884
      oprot.writeStructEnd();
-
 
27885
    }
-
 
27886
 
-
 
27887
    @Override
-
 
27888
    public String toString() {
-
 
27889
      StringBuilder sb = new StringBuilder("getMinValidOrderAmount_args(");
-
 
27890
      boolean first = true;
-
 
27891
 
-
 
27892
      sb.append(")");
-
 
27893
      return sb.toString();
-
 
27894
    }
27485
    }
27895
 
27486
 
27896
    public void validate() throws TException {
27487
    public java.util.Iterator<Double> getSuccessIterator() {
27897
      // check for required fields
27488
      return (this.success == null) ? null : this.success.iterator();
27898
    }
27489
    }
27899
 
27490
 
27900
  }
-
 
27901
 
-
 
27902
  public static class getMinValidOrderAmount_result implements TBase<getMinValidOrderAmount_result._Fields>, java.io.Serializable, Cloneable, Comparable<getMinValidOrderAmount_result>   {
-
 
27903
    private static final TStruct STRUCT_DESC = new TStruct("getMinValidOrderAmount_result");
-
 
27904
 
-
 
27905
    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.DOUBLE, (short)0);
-
 
27906
 
-
 
27907
    private double success;
-
 
27908
 
-
 
27909
    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
-
 
27910
    public enum _Fields implements TFieldIdEnum {
27491
    public void addToSuccess(double elem) {
27911
      SUCCESS((short)0, "success");
-
 
27912
 
-
 
27913
      private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
-
 
27914
      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
-
 
27915
 
-
 
27916
      static {
-
 
27917
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
-
 
27918
          byId.put((int)field._thriftId, field);
-
 
27919
          byName.put(field.getFieldName(), field);
-
 
27920
        }
-
 
27921
      }
-
 
27922
 
-
 
27923
      /**
-
 
27924
       * Find the _Fields constant that matches fieldId, or null if its not found.
-
 
27925
       */
-
 
27926
      public static _Fields findByThriftId(int fieldId) {
-
 
27927
        return byId.get(fieldId);
-
 
27928
      }
-
 
27929
 
-
 
27930
      /**
-
 
27931
       * Find the _Fields constant that matches fieldId, throwing an exception
-
 
27932
       * if it is not found.
27492
      if (this.success == null) {
27933
       */
-
 
27934
      public static _Fields findByThriftIdOrThrow(int fieldId) {
-
 
27935
        _Fields fields = findByThriftId(fieldId);
27493
        this.success = new ArrayList<Double>();
27936
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
-
 
27937
        return fields;
-
 
27938
      }
-
 
27939
 
-
 
27940
      /**
-
 
27941
       * Find the _Fields constant that matches name, or null if its not found.
-
 
27942
       */
-
 
27943
      public static _Fields findByName(String name) {
-
 
27944
        return byName.get(name);
-
 
27945
      }
-
 
27946
 
-
 
27947
      private final short _thriftId;
-
 
27948
      private final String _fieldName;
-
 
27949
 
-
 
27950
      _Fields(short thriftId, String fieldName) {
-
 
27951
        _thriftId = thriftId;
-
 
27952
        _fieldName = fieldName;
-
 
27953
      }
-
 
27954
 
-
 
27955
      public short getThriftFieldId() {
-
 
27956
        return _thriftId;
-
 
27957
      }
-
 
27958
 
-
 
27959
      public String getFieldName() {
-
 
27960
        return _fieldName;
-
 
27961
      }
27494
      }
-
 
27495
      this.success.add(elem);
27962
    }
27496
    }
27963
 
27497
 
27964
    // isset id assignments
-
 
27965
    private static final int __SUCCESS_ISSET_ID = 0;
-
 
27966
    private BitSet __isset_bit_vector = new BitSet(1);
-
 
27967
 
-
 
27968
    public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
-
 
27969
      put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, 
-
 
27970
          new FieldValueMetaData(TType.DOUBLE)));
-
 
27971
    }});
-
 
27972
 
-
 
27973
    static {
-
 
27974
      FieldMetaData.addStructMetaDataMap(getMinValidOrderAmount_result.class, metaDataMap);
-
 
27975
    }
-
 
27976
 
-
 
27977
    public getMinValidOrderAmount_result() {
-
 
27978
    }
-
 
27979
 
-
 
27980
    public getMinValidOrderAmount_result(
-
 
27981
      double success)
-
 
27982
    {
-
 
27983
      this();
-
 
27984
      this.success = success;
-
 
27985
      setSuccessIsSet(true);
-
 
27986
    }
-
 
27987
 
-
 
27988
    /**
-
 
27989
     * Performs a deep copy on <i>other</i>.
-
 
27990
     */
-
 
27991
    public getMinValidOrderAmount_result(getMinValidOrderAmount_result other) {
-
 
27992
      __isset_bit_vector.clear();
-
 
27993
      __isset_bit_vector.or(other.__isset_bit_vector);
-
 
27994
      this.success = other.success;
-
 
27995
    }
-
 
27996
 
-
 
27997
    public getMinValidOrderAmount_result deepCopy() {
-
 
27998
      return new getMinValidOrderAmount_result(this);
-
 
27999
    }
-
 
28000
 
-
 
28001
    @Deprecated
-
 
28002
    public getMinValidOrderAmount_result clone() {
-
 
28003
      return new getMinValidOrderAmount_result(this);
-
 
28004
    }
-
 
28005
 
-
 
28006
    public double getSuccess() {
27498
    public List<Double> getSuccess() {
28007
      return this.success;
27499
      return this.success;
28008
    }
27500
    }
28009
 
27501
 
28010
    public getMinValidOrderAmount_result setSuccess(double success) {
27502
    public getValidOrdersAmountRange_result setSuccess(List<Double> success) {
28011
      this.success = success;
27503
      this.success = success;
28012
      setSuccessIsSet(true);
-
 
28013
      return this;
27504
      return this;
28014
    }
27505
    }
28015
 
27506
 
28016
    public void unsetSuccess() {
27507
    public void unsetSuccess() {
28017
      __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
27508
      this.success = null;
28018
    }
27509
    }
28019
 
27510
 
28020
    /** Returns true if field success is set (has been asigned a value) and false otherwise */
27511
    /** Returns true if field success is set (has been asigned a value) and false otherwise */
28021
    public boolean isSetSuccess() {
27512
    public boolean isSetSuccess() {
28022
      return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
27513
      return this.success != null;
28023
    }
27514
    }
28024
 
27515
 
28025
    public void setSuccessIsSet(boolean value) {
27516
    public void setSuccessIsSet(boolean value) {
-
 
27517
      if (!value) {
28026
      __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
27518
        this.success = null;
-
 
27519
      }
28027
    }
27520
    }
28028
 
27521
 
28029
    public void setFieldValue(_Fields field, Object value) {
27522
    public void setFieldValue(_Fields field, Object value) {
28030
      switch (field) {
27523
      switch (field) {
28031
      case SUCCESS:
27524
      case SUCCESS:
28032
        if (value == null) {
27525
        if (value == null) {
28033
          unsetSuccess();
27526
          unsetSuccess();
28034
        } else {
27527
        } else {
28035
          setSuccess((Double)value);
27528
          setSuccess((List<Double>)value);
28036
        }
27529
        }
28037
        break;
27530
        break;
28038
 
27531
 
28039
      }
27532
      }
28040
    }
27533
    }
Line 28044... Line 27537...
28044
    }
27537
    }
28045
 
27538
 
28046
    public Object getFieldValue(_Fields field) {
27539
    public Object getFieldValue(_Fields field) {
28047
      switch (field) {
27540
      switch (field) {
28048
      case SUCCESS:
27541
      case SUCCESS:
28049
        return new Double(getSuccess());
27542
        return getSuccess();
28050
 
27543
 
28051
      }
27544
      }
28052
      throw new IllegalStateException();
27545
      throw new IllegalStateException();
28053
    }
27546
    }
28054
 
27547
 
Line 28071... Line 27564...
28071
 
27564
 
28072
    @Override
27565
    @Override
28073
    public boolean equals(Object that) {
27566
    public boolean equals(Object that) {
28074
      if (that == null)
27567
      if (that == null)
28075
        return false;
27568
        return false;
28076
      if (that instanceof getMinValidOrderAmount_result)
27569
      if (that instanceof getValidOrdersAmountRange_result)
28077
        return this.equals((getMinValidOrderAmount_result)that);
27570
        return this.equals((getValidOrdersAmountRange_result)that);
28078
      return false;
27571
      return false;
28079
    }
27572
    }
28080
 
27573
 
28081
    public boolean equals(getMinValidOrderAmount_result that) {
27574
    public boolean equals(getValidOrdersAmountRange_result that) {
28082
      if (that == null)
27575
      if (that == null)
28083
        return false;
27576
        return false;
28084
 
27577
 
28085
      boolean this_present_success = true;
27578
      boolean this_present_success = true && this.isSetSuccess();
28086
      boolean that_present_success = true;
27579
      boolean that_present_success = true && that.isSetSuccess();
28087
      if (this_present_success || that_present_success) {
27580
      if (this_present_success || that_present_success) {
28088
        if (!(this_present_success && that_present_success))
27581
        if (!(this_present_success && that_present_success))
28089
          return false;
27582
          return false;
28090
        if (this.success != that.success)
27583
        if (!this.success.equals(that.success))
28091
          return false;
27584
          return false;
28092
      }
27585
      }
28093
 
27586
 
28094
      return true;
27587
      return true;
28095
    }
27588
    }
Line 28097... Line 27590...
28097
    @Override
27590
    @Override
28098
    public int hashCode() {
27591
    public int hashCode() {
28099
      return 0;
27592
      return 0;
28100
    }
27593
    }
28101
 
27594
 
28102
    public int compareTo(getMinValidOrderAmount_result other) {
27595
    public int compareTo(getValidOrdersAmountRange_result other) {
28103
      if (!getClass().equals(other.getClass())) {
27596
      if (!getClass().equals(other.getClass())) {
28104
        return getClass().getName().compareTo(other.getClass().getName());
27597
        return getClass().getName().compareTo(other.getClass().getName());
28105
      }
27598
      }
28106
 
27599
 
28107
      int lastComparison = 0;
27600
      int lastComparison = 0;
28108
      getMinValidOrderAmount_result typedOther = (getMinValidOrderAmount_result)other;
27601
      getValidOrdersAmountRange_result typedOther = (getValidOrdersAmountRange_result)other;
28109
 
27602
 
28110
      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
27603
      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
28111
      if (lastComparison != 0) {
27604
      if (lastComparison != 0) {
28112
        return lastComparison;
27605
        return lastComparison;
28113
      }
27606
      }
Line 28131... Line 27624...
28131
        if (fieldId == null) {
27624
        if (fieldId == null) {
28132
          TProtocolUtil.skip(iprot, field.type);
27625
          TProtocolUtil.skip(iprot, field.type);
28133
        } else {
27626
        } else {
28134
          switch (fieldId) {
27627
          switch (fieldId) {
28135
            case SUCCESS:
27628
            case SUCCESS:
28136
              if (field.type == TType.DOUBLE) {
27629
              if (field.type == TType.LIST) {
-
 
27630
                {
-
 
27631
                  TList _list80 = iprot.readListBegin();
-
 
27632
                  this.success = new ArrayList<Double>(_list80.size);
-
 
27633
                  for (int _i81 = 0; _i81 < _list80.size; ++_i81)
-
 
27634
                  {
-
 
27635
                    double _elem82;
28137
                this.success = iprot.readDouble();
27636
                    _elem82 = iprot.readDouble();
28138
                setSuccessIsSet(true);
27637
                    this.success.add(_elem82);
-
 
27638
                  }
-
 
27639
                  iprot.readListEnd();
-
 
27640
                }
28139
              } else { 
27641
              } else { 
28140
                TProtocolUtil.skip(iprot, field.type);
27642
                TProtocolUtil.skip(iprot, field.type);
28141
              }
27643
              }
28142
              break;
27644
              break;
28143
          }
27645
          }
Line 28151... Line 27653...
28151
    public void write(TProtocol oprot) throws TException {
27653
    public void write(TProtocol oprot) throws TException {
28152
      oprot.writeStructBegin(STRUCT_DESC);
27654
      oprot.writeStructBegin(STRUCT_DESC);
28153
 
27655
 
28154
      if (this.isSetSuccess()) {
27656
      if (this.isSetSuccess()) {
28155
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
27657
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
-
 
27658
        {
-
 
27659
          oprot.writeListBegin(new TList(TType.DOUBLE, this.success.size()));
-
 
27660
          for (double _iter83 : this.success)
-
 
27661
          {
28156
        oprot.writeDouble(this.success);
27662
            oprot.writeDouble(_iter83);
-
 
27663
          }
-
 
27664
          oprot.writeListEnd();
-
 
27665
        }
28157
        oprot.writeFieldEnd();
27666
        oprot.writeFieldEnd();
28158
      }
27667
      }
28159
      oprot.writeFieldStop();
27668
      oprot.writeFieldStop();
28160
      oprot.writeStructEnd();
27669
      oprot.writeStructEnd();
28161
    }
27670
    }
28162
 
27671
 
28163
    @Override
27672
    @Override
28164
    public String toString() {
27673
    public String toString() {
28165
      StringBuilder sb = new StringBuilder("getMinValidOrderAmount_result(");
27674
      StringBuilder sb = new StringBuilder("getValidOrdersAmountRange_result(");
28166
      boolean first = true;
27675
      boolean first = true;
28167
 
27676
 
28168
      sb.append("success:");
27677
      sb.append("success:");
-
 
27678
      if (this.success == null) {
-
 
27679
        sb.append("null");
-
 
27680
      } else {
28169
      sb.append(this.success);
27681
        sb.append(this.success);
-
 
27682
      }
28170
      first = false;
27683
      first = false;
28171
      sb.append(")");
27684
      sb.append(")");
28172
      return sb.toString();
27685
      return sb.toString();
28173
    }
27686
    }
28174
 
27687