Subversion Repositories SmartDukaan

Rev

Rev 640 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 640 Rev 684
Line 1153... Line 1153...
1153
 
1153
 
1154
    }
1154
    }
1155
 
1155
 
1156
  }
1156
  }
1157
 
1157
 
1158
  public static class createTransaction_args implements TBase<createTransaction_args._Fields>, java.io.Serializable, Cloneable   {
1158
  public static class createTransaction_args implements TBase<createTransaction_args._Fields>, java.io.Serializable, Cloneable, Comparable<createTransaction_args>   {
1159
    private static final TStruct STRUCT_DESC = new TStruct("createTransaction_args");
1159
    private static final TStruct STRUCT_DESC = new TStruct("createTransaction_args");
1160
 
1160
 
1161
    private static final TField TRANSACTION_FIELD_DESC = new TField("transaction", TType.STRUCT, (short)1);
1161
    private static final TField TRANSACTION_FIELD_DESC = new TField("transaction", TType.STRUCT, (short)1);
1162
 
1162
 
1163
    private Transaction transaction;
1163
    private Transaction transaction;
Line 1351... Line 1351...
1351
    @Override
1351
    @Override
1352
    public int hashCode() {
1352
    public int hashCode() {
1353
      return 0;
1353
      return 0;
1354
    }
1354
    }
1355
 
1355
 
-
 
1356
    public int compareTo(createTransaction_args other) {
-
 
1357
      if (!getClass().equals(other.getClass())) {
-
 
1358
        return getClass().getName().compareTo(other.getClass().getName());
-
 
1359
      }
-
 
1360
 
-
 
1361
      int lastComparison = 0;
-
 
1362
      createTransaction_args typedOther = (createTransaction_args)other;
-
 
1363
 
-
 
1364
      lastComparison = Boolean.valueOf(isSetTransaction()).compareTo(isSetTransaction());
-
 
1365
      if (lastComparison != 0) {
-
 
1366
        return lastComparison;
-
 
1367
      }
-
 
1368
      lastComparison = TBaseHelper.compareTo(transaction, typedOther.transaction);
-
 
1369
      if (lastComparison != 0) {
-
 
1370
        return lastComparison;
-
 
1371
      }
-
 
1372
      return 0;
-
 
1373
    }
-
 
1374
 
1356
    public void read(TProtocol iprot) throws TException {
1375
    public void read(TProtocol iprot) throws TException {
1357
      TField field;
1376
      TField field;
1358
      iprot.readStructBegin();
1377
      iprot.readStructBegin();
1359
      while (true)
1378
      while (true)
1360
      {
1379
      {
Line 2057... Line 2076...
2057
      // check for required fields
2076
      // check for required fields
2058
    }
2077
    }
2059
 
2078
 
2060
  }
2079
  }
2061
 
2080
 
2062
  public static class getTransaction_result implements TBase<getTransaction_result._Fields>, java.io.Serializable, Cloneable   {
2081
  public static class getTransaction_result implements TBase<getTransaction_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTransaction_result>   {
2063
    private static final TStruct STRUCT_DESC = new TStruct("getTransaction_result");
2082
    private static final TStruct STRUCT_DESC = new TStruct("getTransaction_result");
2064
 
2083
 
2065
    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRUCT, (short)0);
2084
    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRUCT, (short)0);
2066
    private static final TField EX_FIELD_DESC = new TField("ex", TType.STRUCT, (short)1);
2085
    private static final TField EX_FIELD_DESC = new TField("ex", TType.STRUCT, (short)1);
2067
 
2086
 
Line 2311... Line 2330...
2311
    @Override
2330
    @Override
2312
    public int hashCode() {
2331
    public int hashCode() {
2313
      return 0;
2332
      return 0;
2314
    }
2333
    }
2315
 
2334
 
-
 
2335
    public int compareTo(getTransaction_result other) {
-
 
2336
      if (!getClass().equals(other.getClass())) {
-
 
2337
        return getClass().getName().compareTo(other.getClass().getName());
-
 
2338
      }
-
 
2339
 
-
 
2340
      int lastComparison = 0;
-
 
2341
      getTransaction_result typedOther = (getTransaction_result)other;
-
 
2342
 
-
 
2343
      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
-
 
2344
      if (lastComparison != 0) {
-
 
2345
        return lastComparison;
-
 
2346
      }
-
 
2347
      lastComparison = TBaseHelper.compareTo(success, typedOther.success);
-
 
2348
      if (lastComparison != 0) {
-
 
2349
        return lastComparison;
-
 
2350
      }
-
 
2351
      lastComparison = Boolean.valueOf(isSetEx()).compareTo(isSetEx());
-
 
2352
      if (lastComparison != 0) {
-
 
2353
        return lastComparison;
-
 
2354
      }
-
 
2355
      lastComparison = TBaseHelper.compareTo(ex, typedOther.ex);
-
 
2356
      if (lastComparison != 0) {
-
 
2357
        return lastComparison;
-
 
2358
      }
-
 
2359
      return 0;
-
 
2360
    }
-
 
2361
 
2316
    public void read(TProtocol iprot) throws TException {
2362
    public void read(TProtocol iprot) throws TException {
2317
      TField field;
2363
      TField field;
2318
      iprot.readStructBegin();
2364
      iprot.readStructBegin();
2319
      while (true)
2365
      while (true)
2320
      {
2366
      {
Line 2933... Line 2979...
2933
      // check for required fields
2979
      // check for required fields
2934
    }
2980
    }
2935
 
2981
 
2936
  }
2982
  }
2937
 
2983
 
2938
  public static class getTransactionsForCustomer_result implements TBase<getTransactionsForCustomer_result._Fields>, java.io.Serializable, Cloneable   {
2984
  public static class getTransactionsForCustomer_result implements TBase<getTransactionsForCustomer_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTransactionsForCustomer_result>   {
2939
    private static final TStruct STRUCT_DESC = new TStruct("getTransactionsForCustomer_result");
2985
    private static final TStruct STRUCT_DESC = new TStruct("getTransactionsForCustomer_result");
2940
 
2986
 
2941
    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
2987
    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
2942
    private static final TField EX_FIELD_DESC = new TField("ex", TType.STRUCT, (short)1);
2988
    private static final TField EX_FIELD_DESC = new TField("ex", TType.STRUCT, (short)1);
2943
 
2989
 
Line 3207... Line 3253...
3207
    @Override
3253
    @Override
3208
    public int hashCode() {
3254
    public int hashCode() {
3209
      return 0;
3255
      return 0;
3210
    }
3256
    }
3211
 
3257
 
-
 
3258
    public int compareTo(getTransactionsForCustomer_result other) {
-
 
3259
      if (!getClass().equals(other.getClass())) {
-
 
3260
        return getClass().getName().compareTo(other.getClass().getName());
-
 
3261
      }
-
 
3262
 
-
 
3263
      int lastComparison = 0;
-
 
3264
      getTransactionsForCustomer_result typedOther = (getTransactionsForCustomer_result)other;
-
 
3265
 
-
 
3266
      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
-
 
3267
      if (lastComparison != 0) {
-
 
3268
        return lastComparison;
-
 
3269
      }
-
 
3270
      lastComparison = TBaseHelper.compareTo(success, typedOther.success);
-
 
3271
      if (lastComparison != 0) {
-
 
3272
        return lastComparison;
-
 
3273
      }
-
 
3274
      lastComparison = Boolean.valueOf(isSetEx()).compareTo(isSetEx());
-
 
3275
      if (lastComparison != 0) {
-
 
3276
        return lastComparison;
-
 
3277
      }
-
 
3278
      lastComparison = TBaseHelper.compareTo(ex, typedOther.ex);
-
 
3279
      if (lastComparison != 0) {
-
 
3280
        return lastComparison;
-
 
3281
      }
-
 
3282
      return 0;
-
 
3283
    }
-
 
3284
 
3212
    public void read(TProtocol iprot) throws TException {
3285
    public void read(TProtocol iprot) throws TException {
3213
      TField field;
3286
      TField field;
3214
      iprot.readStructBegin();
3287
      iprot.readStructBegin();
3215
      while (true)
3288
      while (true)
3216
      {
3289
      {
Line 3224... Line 3297...
3224
        } else {
3297
        } else {
3225
          switch (fieldId) {
3298
          switch (fieldId) {
3226
            case SUCCESS:
3299
            case SUCCESS:
3227
              if (field.type == TType.LIST) {
3300
              if (field.type == TType.LIST) {
3228
                {
3301
                {
3229
                  TList _list13 = iprot.readListBegin();
3302
                  TList _list8 = iprot.readListBegin();
3230
                  this.success = new ArrayList<Transaction>(_list13.size);
3303
                  this.success = new ArrayList<Transaction>(_list8.size);
3231
                  for (int _i14 = 0; _i14 < _list13.size; ++_i14)
3304
                  for (int _i9 = 0; _i9 < _list8.size; ++_i9)
3232
                  {
3305
                  {
3233
                    Transaction _elem15;
3306
                    Transaction _elem10;
3234
                    _elem15 = new Transaction();
3307
                    _elem10 = new Transaction();
3235
                    _elem15.read(iprot);
3308
                    _elem10.read(iprot);
3236
                    this.success.add(_elem15);
3309
                    this.success.add(_elem10);
3237
                  }
3310
                  }
3238
                  iprot.readListEnd();
3311
                  iprot.readListEnd();
3239
                }
3312
                }
3240
              } else { 
3313
              } else { 
3241
                TProtocolUtil.skip(iprot, field.type);
3314
                TProtocolUtil.skip(iprot, field.type);
Line 3262... Line 3335...
3262
 
3335
 
3263
      if (this.isSetSuccess()) {
3336
      if (this.isSetSuccess()) {
3264
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
3337
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
3265
        {
3338
        {
3266
          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
3339
          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
3267
          for (Transaction _iter16 : this.success)
3340
          for (Transaction _iter11 : this.success)
3268
          {
3341
          {
3269
            _iter16.write(oprot);
3342
            _iter11.write(oprot);
3270
          }
3343
          }
3271
          oprot.writeListEnd();
3344
          oprot.writeListEnd();
3272
        }
3345
        }
3273
        oprot.writeFieldEnd();
3346
        oprot.writeFieldEnd();
3274
      } else if (this.isSetEx()) {
3347
      } else if (this.isSetEx()) {
Line 3586... Line 3659...
3586
      // check for required fields
3659
      // check for required fields
3587
    }
3660
    }
3588
 
3661
 
3589
  }
3662
  }
3590
 
3663
 
3591
  public static class getTransactionsForShoppingCartId_result implements TBase<getTransactionsForShoppingCartId_result._Fields>, java.io.Serializable, Cloneable   {
3664
  public static class getTransactionsForShoppingCartId_result implements TBase<getTransactionsForShoppingCartId_result._Fields>, java.io.Serializable, Cloneable, Comparable<getTransactionsForShoppingCartId_result>   {
3592
    private static final TStruct STRUCT_DESC = new TStruct("getTransactionsForShoppingCartId_result");
3665
    private static final TStruct STRUCT_DESC = new TStruct("getTransactionsForShoppingCartId_result");
3593
 
3666
 
3594
    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
3667
    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
3595
    private static final TField EX_FIELD_DESC = new TField("ex", TType.STRUCT, (short)1);
3668
    private static final TField EX_FIELD_DESC = new TField("ex", TType.STRUCT, (short)1);
3596
 
3669
 
Line 3860... Line 3933...
3860
    @Override
3933
    @Override
3861
    public int hashCode() {
3934
    public int hashCode() {
3862
      return 0;
3935
      return 0;
3863
    }
3936
    }
3864
 
3937
 
-
 
3938
    public int compareTo(getTransactionsForShoppingCartId_result other) {
-
 
3939
      if (!getClass().equals(other.getClass())) {
-
 
3940
        return getClass().getName().compareTo(other.getClass().getName());
-
 
3941
      }
-
 
3942
 
-
 
3943
      int lastComparison = 0;
-
 
3944
      getTransactionsForShoppingCartId_result typedOther = (getTransactionsForShoppingCartId_result)other;
-
 
3945
 
-
 
3946
      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
-
 
3947
      if (lastComparison != 0) {
-
 
3948
        return lastComparison;
-
 
3949
      }
-
 
3950
      lastComparison = TBaseHelper.compareTo(success, typedOther.success);
-
 
3951
      if (lastComparison != 0) {
-
 
3952
        return lastComparison;
-
 
3953
      }
-
 
3954
      lastComparison = Boolean.valueOf(isSetEx()).compareTo(isSetEx());
-
 
3955
      if (lastComparison != 0) {
-
 
3956
        return lastComparison;
-
 
3957
      }
-
 
3958
      lastComparison = TBaseHelper.compareTo(ex, typedOther.ex);
-
 
3959
      if (lastComparison != 0) {
-
 
3960
        return lastComparison;
-
 
3961
      }
-
 
3962
      return 0;
-
 
3963
    }
-
 
3964
 
3865
    public void read(TProtocol iprot) throws TException {
3965
    public void read(TProtocol iprot) throws TException {
3866
      TField field;
3966
      TField field;
3867
      iprot.readStructBegin();
3967
      iprot.readStructBegin();
3868
      while (true)
3968
      while (true)
3869
      {
3969
      {
Line 3877... Line 3977...
3877
        } else {
3977
        } else {
3878
          switch (fieldId) {
3978
          switch (fieldId) {
3879
            case SUCCESS:
3979
            case SUCCESS:
3880
              if (field.type == TType.LIST) {
3980
              if (field.type == TType.LIST) {
3881
                {
3981
                {
3882
                  TList _list17 = iprot.readListBegin();
3982
                  TList _list12 = iprot.readListBegin();
3883
                  this.success = new ArrayList<Transaction>(_list17.size);
3983
                  this.success = new ArrayList<Transaction>(_list12.size);
3884
                  for (int _i18 = 0; _i18 < _list17.size; ++_i18)
3984
                  for (int _i13 = 0; _i13 < _list12.size; ++_i13)
3885
                  {
3985
                  {
3886
                    Transaction _elem19;
3986
                    Transaction _elem14;
3887
                    _elem19 = new Transaction();
3987
                    _elem14 = new Transaction();
3888
                    _elem19.read(iprot);
3988
                    _elem14.read(iprot);
3889
                    this.success.add(_elem19);
3989
                    this.success.add(_elem14);
3890
                  }
3990
                  }
3891
                  iprot.readListEnd();
3991
                  iprot.readListEnd();
3892
                }
3992
                }
3893
              } else { 
3993
              } else { 
3894
                TProtocolUtil.skip(iprot, field.type);
3994
                TProtocolUtil.skip(iprot, field.type);
Line 3915... Line 4015...
3915
 
4015
 
3916
      if (this.isSetSuccess()) {
4016
      if (this.isSetSuccess()) {
3917
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
4017
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
3918
        {
4018
        {
3919
          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
4019
          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
3920
          for (Transaction _iter20 : this.success)
4020
          for (Transaction _iter15 : this.success)
3921
          {
4021
          {
3922
            _iter20.write(oprot);
4022
            _iter15.write(oprot);
3923
          }
4023
          }
3924
          oprot.writeListEnd();
4024
          oprot.writeListEnd();
3925
        }
4025
        }
3926
        oprot.writeFieldEnd();
4026
        oprot.writeFieldEnd();
3927
      } else if (this.isSetEx()) {
4027
      } else if (this.isSetEx()) {
Line 6308... Line 6408...
6308
        } else {
6408
        } else {
6309
          switch (fieldId) {
6409
          switch (fieldId) {
6310
            case SUCCESS:
6410
            case SUCCESS:
6311
              if (field.type == TType.LIST) {
6411
              if (field.type == TType.LIST) {
6312
                {
6412
                {
6313
                  TList _list21 = iprot.readListBegin();
6413
                  TList _list16 = iprot.readListBegin();
6314
                  this.success = new ArrayList<Order>(_list21.size);
6414
                  this.success = new ArrayList<Order>(_list16.size);
6315
                  for (int _i22 = 0; _i22 < _list21.size; ++_i22)
6415
                  for (int _i17 = 0; _i17 < _list16.size; ++_i17)
6316
                  {
6416
                  {
6317
                    Order _elem23;
6417
                    Order _elem18;
6318
                    _elem23 = new Order();
6418
                    _elem18 = new Order();
6319
                    _elem23.read(iprot);
6419
                    _elem18.read(iprot);
6320
                    this.success.add(_elem23);
6420
                    this.success.add(_elem18);
6321
                  }
6421
                  }
6322
                  iprot.readListEnd();
6422
                  iprot.readListEnd();
6323
                }
6423
                }
6324
              } else { 
6424
              } else { 
6325
                TProtocolUtil.skip(iprot, field.type);
6425
                TProtocolUtil.skip(iprot, field.type);
Line 6346... Line 6446...
6346
 
6446
 
6347
      if (this.isSetSuccess()) {
6447
      if (this.isSetSuccess()) {
6348
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
6448
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
6349
        {
6449
        {
6350
          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
6450
          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
6351
          for (Order _iter24 : this.success)
6451
          for (Order _iter19 : this.success)
6352
          {
6452
          {
6353
            _iter24.write(oprot);
6453
            _iter19.write(oprot);
6354
          }
6454
          }
6355
          oprot.writeListEnd();
6455
          oprot.writeListEnd();
6356
        }
6456
        }
6357
        oprot.writeFieldEnd();
6457
        oprot.writeFieldEnd();
6358
      } else if (this.isSetEx()) {
6458
      } else if (this.isSetEx()) {
Line 8704... Line 8804...
8704
        } else {
8804
        } else {
8705
          switch (fieldId) {
8805
          switch (fieldId) {
8706
            case SUCCESS:
8806
            case SUCCESS:
8707
              if (field.type == TType.LIST) {
8807
              if (field.type == TType.LIST) {
8708
                {
8808
                {
8709
                  TList _list25 = iprot.readListBegin();
8809
                  TList _list20 = iprot.readListBegin();
8710
                  this.success = new ArrayList<Order>(_list25.size);
8810
                  this.success = new ArrayList<Order>(_list20.size);
8711
                  for (int _i26 = 0; _i26 < _list25.size; ++_i26)
8811
                  for (int _i21 = 0; _i21 < _list20.size; ++_i21)
8712
                  {
8812
                  {
8713
                    Order _elem27;
8813
                    Order _elem22;
8714
                    _elem27 = new Order();
8814
                    _elem22 = new Order();
8715
                    _elem27.read(iprot);
8815
                    _elem22.read(iprot);
8716
                    this.success.add(_elem27);
8816
                    this.success.add(_elem22);
8717
                  }
8817
                  }
8718
                  iprot.readListEnd();
8818
                  iprot.readListEnd();
8719
                }
8819
                }
8720
              } else { 
8820
              } else { 
8721
                TProtocolUtil.skip(iprot, field.type);
8821
                TProtocolUtil.skip(iprot, field.type);
Line 8742... Line 8842...
8742
 
8842
 
8743
      if (this.isSetSuccess()) {
8843
      if (this.isSetSuccess()) {
8744
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
8844
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
8745
        {
8845
        {
8746
          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
8846
          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
8747
          for (Order _iter28 : this.success)
8847
          for (Order _iter23 : this.success)
8748
          {
8848
          {
8749
            _iter28.write(oprot);
8849
            _iter23.write(oprot);
8750
          }
8850
          }
8751
          oprot.writeListEnd();
8851
          oprot.writeListEnd();
8752
        }
8852
        }
8753
        oprot.writeFieldEnd();
8853
        oprot.writeFieldEnd();
8754
      } else if (this.isSetEx()) {
8854
      } else if (this.isSetEx()) {
Line 9644... Line 9744...
9644
        } else {
9744
        } else {
9645
          switch (fieldId) {
9745
          switch (fieldId) {
9646
            case SUCCESS:
9746
            case SUCCESS:
9647
              if (field.type == TType.LIST) {
9747
              if (field.type == TType.LIST) {
9648
                {
9748
                {
9649
                  TList _list29 = iprot.readListBegin();
9749
                  TList _list24 = iprot.readListBegin();
9650
                  this.success = new ArrayList<Order>(_list29.size);
9750
                  this.success = new ArrayList<Order>(_list24.size);
9651
                  for (int _i30 = 0; _i30 < _list29.size; ++_i30)
9751
                  for (int _i25 = 0; _i25 < _list24.size; ++_i25)
9652
                  {
9752
                  {
9653
                    Order _elem31;
9753
                    Order _elem26;
9654
                    _elem31 = new Order();
9754
                    _elem26 = new Order();
9655
                    _elem31.read(iprot);
9755
                    _elem26.read(iprot);
9656
                    this.success.add(_elem31);
9756
                    this.success.add(_elem26);
9657
                  }
9757
                  }
9658
                  iprot.readListEnd();
9758
                  iprot.readListEnd();
9659
                }
9759
                }
9660
              } else { 
9760
              } else { 
9661
                TProtocolUtil.skip(iprot, field.type);
9761
                TProtocolUtil.skip(iprot, field.type);
Line 9682... Line 9782...
9682
 
9782
 
9683
      if (this.isSetSuccess()) {
9783
      if (this.isSetSuccess()) {
9684
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
9784
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
9685
        {
9785
        {
9686
          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
9786
          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
9687
          for (Order _iter32 : this.success)
9787
          for (Order _iter27 : this.success)
9688
          {
9788
          {
9689
            _iter32.write(oprot);
9789
            _iter27.write(oprot);
9690
          }
9790
          }
9691
          oprot.writeListEnd();
9791
          oprot.writeListEnd();
9692
        }
9792
        }
9693
        oprot.writeFieldEnd();
9793
        oprot.writeFieldEnd();
9694
      } else if (this.isSetEx()) {
9794
      } else if (this.isSetEx()) {
Line 11612... Line 11712...
11612
        } else {
11712
        } else {
11613
          switch (fieldId) {
11713
          switch (fieldId) {
11614
            case SUCCESS:
11714
            case SUCCESS:
11615
              if (field.type == TType.LIST) {
11715
              if (field.type == TType.LIST) {
11616
                {
11716
                {
11617
                  TList _list33 = iprot.readListBegin();
11717
                  TList _list28 = iprot.readListBegin();
11618
                  this.success = new ArrayList<LineItem>(_list33.size);
11718
                  this.success = new ArrayList<LineItem>(_list28.size);
11619
                  for (int _i34 = 0; _i34 < _list33.size; ++_i34)
11719
                  for (int _i29 = 0; _i29 < _list28.size; ++_i29)
11620
                  {
11720
                  {
11621
                    LineItem _elem35;
11721
                    LineItem _elem30;
11622
                    _elem35 = new LineItem();
11722
                    _elem30 = new LineItem();
11623
                    _elem35.read(iprot);
11723
                    _elem30.read(iprot);
11624
                    this.success.add(_elem35);
11724
                    this.success.add(_elem30);
11625
                  }
11725
                  }
11626
                  iprot.readListEnd();
11726
                  iprot.readListEnd();
11627
                }
11727
                }
11628
              } else { 
11728
              } else { 
11629
                TProtocolUtil.skip(iprot, field.type);
11729
                TProtocolUtil.skip(iprot, field.type);
Line 11650... Line 11750...
11650
 
11750
 
11651
      if (this.isSetSuccess()) {
11751
      if (this.isSetSuccess()) {
11652
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
11752
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
11653
        {
11753
        {
11654
          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
11754
          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
11655
          for (LineItem _iter36 : this.success)
11755
          for (LineItem _iter31 : this.success)
11656
          {
11756
          {
11657
            _iter36.write(oprot);
11757
            _iter31.write(oprot);
11658
          }
11758
          }
11659
          oprot.writeListEnd();
11759
          oprot.writeListEnd();
11660
        }
11760
        }
11661
        oprot.writeFieldEnd();
11761
        oprot.writeFieldEnd();
11662
      } else if (this.isSetEx()) {
11762
      } else if (this.isSetEx()) {
Line 12306... Line 12406...
12306
        } else {
12406
        } else {
12307
          switch (fieldId) {
12407
          switch (fieldId) {
12308
            case SUCCESS:
12408
            case SUCCESS:
12309
              if (field.type == TType.LIST) {
12409
              if (field.type == TType.LIST) {
12310
                {
12410
                {
12311
                  TList _list37 = iprot.readListBegin();
12411
                  TList _list32 = iprot.readListBegin();
12312
                  this.success = new ArrayList<Alert>(_list37.size);
12412
                  this.success = new ArrayList<Alert>(_list32.size);
12313
                  for (int _i38 = 0; _i38 < _list37.size; ++_i38)
12413
                  for (int _i33 = 0; _i33 < _list32.size; ++_i33)
12314
                  {
12414
                  {
12315
                    Alert _elem39;
12415
                    Alert _elem34;
12316
                    _elem39 = new Alert();
12416
                    _elem34 = new Alert();
12317
                    _elem39.read(iprot);
12417
                    _elem34.read(iprot);
12318
                    this.success.add(_elem39);
12418
                    this.success.add(_elem34);
12319
                  }
12419
                  }
12320
                  iprot.readListEnd();
12420
                  iprot.readListEnd();
12321
                }
12421
                }
12322
              } else { 
12422
              } else { 
12323
                TProtocolUtil.skip(iprot, field.type);
12423
                TProtocolUtil.skip(iprot, field.type);
Line 12336... Line 12436...
12336
 
12436
 
12337
      if (this.isSetSuccess()) {
12437
      if (this.isSetSuccess()) {
12338
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
12438
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
12339
        {
12439
        {
12340
          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
12440
          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
12341
          for (Alert _iter40 : this.success)
12441
          for (Alert _iter35 : this.success)
12342
          {
12442
          {
12343
            _iter40.write(oprot);
12443
            _iter35.write(oprot);
12344
          }
12444
          }
12345
          oprot.writeListEnd();
12445
          oprot.writeListEnd();
12346
        }
12446
        }
12347
        oprot.writeFieldEnd();
12447
        oprot.writeFieldEnd();
12348
      }
12448
      }