Subversion Repositories SmartDukaan

Rev

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

Rev 2708 Rev 2747
Line 3309... Line 3309...
3309
        } else {
3309
        } else {
3310
          switch (fieldId) {
3310
          switch (fieldId) {
3311
            case SUCCESS:
3311
            case SUCCESS:
3312
              if (field.type == TType.LIST) {
3312
              if (field.type == TType.LIST) {
3313
                {
3313
                {
3314
                  TList _list8 = iprot.readListBegin();
3314
                  TList _list12 = iprot.readListBegin();
3315
                  this.success = new ArrayList<Payment>(_list8.size);
3315
                  this.success = new ArrayList<Payment>(_list12.size);
3316
                  for (int _i9 = 0; _i9 < _list8.size; ++_i9)
3316
                  for (int _i13 = 0; _i13 < _list12.size; ++_i13)
3317
                  {
3317
                  {
3318
                    Payment _elem10;
3318
                    Payment _elem14;
3319
                    _elem10 = new Payment();
3319
                    _elem14 = new Payment();
3320
                    _elem10.read(iprot);
3320
                    _elem14.read(iprot);
3321
                    this.success.add(_elem10);
3321
                    this.success.add(_elem14);
3322
                  }
3322
                  }
3323
                  iprot.readListEnd();
3323
                  iprot.readListEnd();
3324
                }
3324
                }
3325
              } else { 
3325
              } else { 
3326
                TProtocolUtil.skip(iprot, field.type);
3326
                TProtocolUtil.skip(iprot, field.type);
Line 3347... Line 3347...
3347
 
3347
 
3348
      if (this.isSetSuccess()) {
3348
      if (this.isSetSuccess()) {
3349
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
3349
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
3350
        {
3350
        {
3351
          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
3351
          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
3352
          for (Payment _iter11 : this.success)
3352
          for (Payment _iter15 : this.success)
3353
          {
3353
          {
3354
            _iter11.write(oprot);
3354
            _iter15.write(oprot);
3355
          }
3355
          }
3356
          oprot.writeListEnd();
3356
          oprot.writeListEnd();
3357
        }
3357
        }
3358
        oprot.writeFieldEnd();
3358
        oprot.writeFieldEnd();
3359
      } else if (this.isSetPe()) {
3359
      } else if (this.isSetPe()) {
Line 4249... Line 4249...
4249
        } else {
4249
        } else {
4250
          switch (fieldId) {
4250
          switch (fieldId) {
4251
            case SUCCESS:
4251
            case SUCCESS:
4252
              if (field.type == TType.LIST) {
4252
              if (field.type == TType.LIST) {
4253
                {
4253
                {
4254
                  TList _list12 = iprot.readListBegin();
4254
                  TList _list16 = iprot.readListBegin();
4255
                  this.success = new ArrayList<Payment>(_list12.size);
4255
                  this.success = new ArrayList<Payment>(_list16.size);
4256
                  for (int _i13 = 0; _i13 < _list12.size; ++_i13)
4256
                  for (int _i17 = 0; _i17 < _list16.size; ++_i17)
4257
                  {
4257
                  {
4258
                    Payment _elem14;
4258
                    Payment _elem18;
4259
                    _elem14 = new Payment();
4259
                    _elem18 = new Payment();
4260
                    _elem14.read(iprot);
4260
                    _elem18.read(iprot);
4261
                    this.success.add(_elem14);
4261
                    this.success.add(_elem18);
4262
                  }
4262
                  }
4263
                  iprot.readListEnd();
4263
                  iprot.readListEnd();
4264
                }
4264
                }
4265
              } else { 
4265
              } else { 
4266
                TProtocolUtil.skip(iprot, field.type);
4266
                TProtocolUtil.skip(iprot, field.type);
Line 4287... Line 4287...
4287
 
4287
 
4288
      if (this.isSetSuccess()) {
4288
      if (this.isSetSuccess()) {
4289
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
4289
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
4290
        {
4290
        {
4291
          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
4291
          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
4292
          for (Payment _iter15 : this.success)
4292
          for (Payment _iter19 : this.success)
4293
          {
4293
          {
4294
            _iter15.write(oprot);
4294
            _iter19.write(oprot);
4295
          }
4295
          }
4296
          oprot.writeListEnd();
4296
          oprot.writeListEnd();
4297
        }
4297
        }
4298
        oprot.writeFieldEnd();
4298
        oprot.writeFieldEnd();
4299
      } else if (this.isSetPe()) {
4299
      } else if (this.isSetPe()) {
Line 6215... Line 6215...
6215
        } else {
6215
        } else {
6216
          switch (fieldId) {
6216
          switch (fieldId) {
6217
            case SUCCESS:
6217
            case SUCCESS:
6218
              if (field.type == TType.LIST) {
6218
              if (field.type == TType.LIST) {
6219
                {
6219
                {
6220
                  TList _list16 = iprot.readListBegin();
6220
                  TList _list20 = iprot.readListBegin();
6221
                  this.success = new ArrayList<Payment>(_list16.size);
6221
                  this.success = new ArrayList<Payment>(_list20.size);
6222
                  for (int _i17 = 0; _i17 < _list16.size; ++_i17)
6222
                  for (int _i21 = 0; _i21 < _list20.size; ++_i21)
6223
                  {
6223
                  {
6224
                    Payment _elem18;
6224
                    Payment _elem22;
6225
                    _elem18 = new Payment();
6225
                    _elem22 = new Payment();
6226
                    _elem18.read(iprot);
6226
                    _elem22.read(iprot);
6227
                    this.success.add(_elem18);
6227
                    this.success.add(_elem22);
6228
                  }
6228
                  }
6229
                  iprot.readListEnd();
6229
                  iprot.readListEnd();
6230
                }
6230
                }
6231
              } else { 
6231
              } else { 
6232
                TProtocolUtil.skip(iprot, field.type);
6232
                TProtocolUtil.skip(iprot, field.type);
Line 6253... Line 6253...
6253
 
6253
 
6254
      if (this.isSetSuccess()) {
6254
      if (this.isSetSuccess()) {
6255
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
6255
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
6256
        {
6256
        {
6257
          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
6257
          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
6258
          for (Payment _iter19 : this.success)
6258
          for (Payment _iter23 : this.success)
6259
          {
6259
          {
6260
            _iter19.write(oprot);
6260
            _iter23.write(oprot);
6261
          }
6261
          }
6262
          oprot.writeListEnd();
6262
          oprot.writeListEnd();
6263
        }
6263
        }
6264
        oprot.writeFieldEnd();
6264
        oprot.writeFieldEnd();
6265
      } else if (this.isSetPe()) {
6265
      } else if (this.isSetPe()) {
Line 7349... Line 7349...
7349
              }
7349
              }
7350
              break;
7350
              break;
7351
            case ATTRIBUTES:
7351
            case ATTRIBUTES:
7352
              if (field.type == TType.LIST) {
7352
              if (field.type == TType.LIST) {
7353
                {
7353
                {
7354
                  TList _list20 = iprot.readListBegin();
7354
                  TList _list24 = iprot.readListBegin();
7355
                  this.attributes = new ArrayList<Attribute>(_list20.size);
7355
                  this.attributes = new ArrayList<Attribute>(_list24.size);
7356
                  for (int _i21 = 0; _i21 < _list20.size; ++_i21)
7356
                  for (int _i25 = 0; _i25 < _list24.size; ++_i25)
7357
                  {
7357
                  {
7358
                    Attribute _elem22;
7358
                    Attribute _elem26;
7359
                    _elem22 = new Attribute();
7359
                    _elem26 = new Attribute();
7360
                    _elem22.read(iprot);
7360
                    _elem26.read(iprot);
7361
                    this.attributes.add(_elem22);
7361
                    this.attributes.add(_elem26);
7362
                  }
7362
                  }
7363
                  iprot.readListEnd();
7363
                  iprot.readListEnd();
7364
                }
7364
                }
7365
              } else { 
7365
              } else { 
7366
                TProtocolUtil.skip(iprot, field.type);
7366
                TProtocolUtil.skip(iprot, field.type);
Line 7433... Line 7433...
7433
      }
7433
      }
7434
      if (this.attributes != null) {
7434
      if (this.attributes != null) {
7435
        oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
7435
        oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
7436
        {
7436
        {
7437
          oprot.writeListBegin(new TList(TType.STRUCT, this.attributes.size()));
7437
          oprot.writeListBegin(new TList(TType.STRUCT, this.attributes.size()));
7438
          for (Attribute _iter23 : this.attributes)
7438
          for (Attribute _iter27 : this.attributes)
7439
          {
7439
          {
7440
            _iter23.write(oprot);
7440
            _iter27.write(oprot);
7441
          }
7441
          }
7442
          oprot.writeListEnd();
7442
          oprot.writeListEnd();
7443
        }
7443
        }
7444
        oprot.writeFieldEnd();
7444
        oprot.writeFieldEnd();
7445
      }
7445
      }
Line 8367... Line 8367...
8367
        } else {
8367
        } else {
8368
          switch (fieldId) {
8368
          switch (fieldId) {
8369
            case SUCCESS:
8369
            case SUCCESS:
8370
              if (field.type == TType.LIST) {
8370
              if (field.type == TType.LIST) {
8371
                {
8371
                {
8372
                  TList _list24 = iprot.readListBegin();
8372
                  TList _list28 = iprot.readListBegin();
8373
                  this.success = new ArrayList<Double>(_list24.size);
8373
                  this.success = new ArrayList<Double>(_list28.size);
8374
                  for (int _i25 = 0; _i25 < _list24.size; ++_i25)
8374
                  for (int _i29 = 0; _i29 < _list28.size; ++_i29)
8375
                  {
8375
                  {
8376
                    double _elem26;
8376
                    double _elem30;
8377
                    _elem26 = iprot.readDouble();
8377
                    _elem30 = iprot.readDouble();
8378
                    this.success.add(_elem26);
8378
                    this.success.add(_elem30);
8379
                  }
8379
                  }
8380
                  iprot.readListEnd();
8380
                  iprot.readListEnd();
8381
                }
8381
                }
8382
              } else { 
8382
              } else { 
8383
                TProtocolUtil.skip(iprot, field.type);
8383
                TProtocolUtil.skip(iprot, field.type);
Line 8396... Line 8396...
8396
 
8396
 
8397
      if (this.isSetSuccess()) {
8397
      if (this.isSetSuccess()) {
8398
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
8398
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
8399
        {
8399
        {
8400
          oprot.writeListBegin(new TList(TType.DOUBLE, this.success.size()));
8400
          oprot.writeListBegin(new TList(TType.DOUBLE, this.success.size()));
8401
          for (double _iter27 : this.success)
8401
          for (double _iter31 : this.success)
8402
          {
8402
          {
8403
            oprot.writeDouble(_iter27);
8403
            oprot.writeDouble(_iter31);
8404
          }
8404
          }
8405
          oprot.writeListEnd();
8405
          oprot.writeListEnd();
8406
        }
8406
        }
8407
        oprot.writeFieldEnd();
8407
        oprot.writeFieldEnd();
8408
      }
8408
      }
Line 8670... Line 8670...
8670
        } else {
8670
        } else {
8671
          switch (fieldId) {
8671
          switch (fieldId) {
8672
            case PAYMENT_PARAMS:
8672
            case PAYMENT_PARAMS:
8673
              if (field.type == TType.MAP) {
8673
              if (field.type == TType.MAP) {
8674
                {
8674
                {
8675
                  TMap _map28 = iprot.readMapBegin();
8675
                  TMap _map32 = iprot.readMapBegin();
8676
                  this.paymentParams = new HashMap<String,String>(2*_map28.size);
8676
                  this.paymentParams = new HashMap<String,String>(2*_map32.size);
8677
                  for (int _i29 = 0; _i29 < _map28.size; ++_i29)
8677
                  for (int _i33 = 0; _i33 < _map32.size; ++_i33)
8678
                  {
8678
                  {
8679
                    String _key30;
8679
                    String _key34;
8680
                    String _val31;
8680
                    String _val35;
8681
                    _key30 = iprot.readString();
8681
                    _key34 = iprot.readString();
8682
                    _val31 = iprot.readString();
8682
                    _val35 = iprot.readString();
8683
                    this.paymentParams.put(_key30, _val31);
8683
                    this.paymentParams.put(_key34, _val35);
8684
                  }
8684
                  }
8685
                  iprot.readMapEnd();
8685
                  iprot.readMapEnd();
8686
                }
8686
                }
8687
              } else { 
8687
              } else { 
8688
                TProtocolUtil.skip(iprot, field.type);
8688
                TProtocolUtil.skip(iprot, field.type);
Line 8702... Line 8702...
8702
      oprot.writeStructBegin(STRUCT_DESC);
8702
      oprot.writeStructBegin(STRUCT_DESC);
8703
      if (this.paymentParams != null) {
8703
      if (this.paymentParams != null) {
8704
        oprot.writeFieldBegin(PAYMENT_PARAMS_FIELD_DESC);
8704
        oprot.writeFieldBegin(PAYMENT_PARAMS_FIELD_DESC);
8705
        {
8705
        {
8706
          oprot.writeMapBegin(new TMap(TType.STRING, TType.STRING, this.paymentParams.size()));
8706
          oprot.writeMapBegin(new TMap(TType.STRING, TType.STRING, this.paymentParams.size()));
8707
          for (Map.Entry<String, String> _iter32 : this.paymentParams.entrySet())
8707
          for (Map.Entry<String, String> _iter36 : this.paymentParams.entrySet())
8708
          {
8708
          {
8709
            oprot.writeString(_iter32.getKey());
8709
            oprot.writeString(_iter36.getKey());
8710
            oprot.writeString(_iter32.getValue());
8710
            oprot.writeString(_iter36.getValue());
8711
          }
8711
          }
8712
          oprot.writeMapEnd();
8712
          oprot.writeMapEnd();
8713
        }
8713
        }
8714
        oprot.writeFieldEnd();
8714
        oprot.writeFieldEnd();
8715
      }
8715
      }
Line 9676... Line 9676...
9676
        } else {
9676
        } else {
9677
          switch (fieldId) {
9677
          switch (fieldId) {
9678
            case SUCCESS:
9678
            case SUCCESS:
9679
              if (field.type == TType.MAP) {
9679
              if (field.type == TType.MAP) {
9680
                {
9680
                {
9681
                  TMap _map33 = iprot.readMapBegin();
9681
                  TMap _map37 = iprot.readMapBegin();
9682
                  this.success = new HashMap<String,String>(2*_map33.size);
9682
                  this.success = new HashMap<String,String>(2*_map37.size);
9683
                  for (int _i34 = 0; _i34 < _map33.size; ++_i34)
9683
                  for (int _i38 = 0; _i38 < _map37.size; ++_i38)
9684
                  {
9684
                  {
9685
                    String _key35;
9685
                    String _key39;
9686
                    String _val36;
9686
                    String _val40;
9687
                    _key35 = iprot.readString();
9687
                    _key39 = iprot.readString();
9688
                    _val36 = iprot.readString();
9688
                    _val40 = iprot.readString();
9689
                    this.success.put(_key35, _val36);
9689
                    this.success.put(_key39, _val40);
9690
                  }
9690
                  }
9691
                  iprot.readMapEnd();
9691
                  iprot.readMapEnd();
9692
                }
9692
                }
9693
              } else { 
9693
              } else { 
9694
                TProtocolUtil.skip(iprot, field.type);
9694
                TProtocolUtil.skip(iprot, field.type);
Line 9715... Line 9715...
9715
 
9715
 
9716
      if (this.isSetSuccess()) {
9716
      if (this.isSetSuccess()) {
9717
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
9717
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
9718
        {
9718
        {
9719
          oprot.writeMapBegin(new TMap(TType.STRING, TType.STRING, this.success.size()));
9719
          oprot.writeMapBegin(new TMap(TType.STRING, TType.STRING, this.success.size()));
9720
          for (Map.Entry<String, String> _iter37 : this.success.entrySet())
9720
          for (Map.Entry<String, String> _iter41 : this.success.entrySet())
9721
          {
9721
          {
9722
            oprot.writeString(_iter37.getKey());
9722
            oprot.writeString(_iter41.getKey());
9723
            oprot.writeString(_iter37.getValue());
9723
            oprot.writeString(_iter41.getValue());
9724
          }
9724
          }
9725
          oprot.writeMapEnd();
9725
          oprot.writeMapEnd();
9726
        }
9726
        }
9727
        oprot.writeFieldEnd();
9727
        oprot.writeFieldEnd();
9728
      } else if (this.isSetPe()) {
9728
      } else if (this.isSetPe()) {
Line 10336... Line 10336...
10336
        } else {
10336
        } else {
10337
          switch (fieldId) {
10337
          switch (fieldId) {
10338
            case SUCCESS:
10338
            case SUCCESS:
10339
              if (field.type == TType.MAP) {
10339
              if (field.type == TType.MAP) {
10340
                {
10340
                {
10341
                  TMap _map38 = iprot.readMapBegin();
10341
                  TMap _map42 = iprot.readMapBegin();
10342
                  this.success = new HashMap<String,String>(2*_map38.size);
10342
                  this.success = new HashMap<String,String>(2*_map42.size);
10343
                  for (int _i39 = 0; _i39 < _map38.size; ++_i39)
10343
                  for (int _i43 = 0; _i43 < _map42.size; ++_i43)
10344
                  {
10344
                  {
10345
                    String _key40;
10345
                    String _key44;
10346
                    String _val41;
10346
                    String _val45;
10347
                    _key40 = iprot.readString();
10347
                    _key44 = iprot.readString();
10348
                    _val41 = iprot.readString();
10348
                    _val45 = iprot.readString();
10349
                    this.success.put(_key40, _val41);
10349
                    this.success.put(_key44, _val45);
10350
                  }
10350
                  }
10351
                  iprot.readMapEnd();
10351
                  iprot.readMapEnd();
10352
                }
10352
                }
10353
              } else { 
10353
              } else { 
10354
                TProtocolUtil.skip(iprot, field.type);
10354
                TProtocolUtil.skip(iprot, field.type);
Line 10375... Line 10375...
10375
 
10375
 
10376
      if (this.isSetSuccess()) {
10376
      if (this.isSetSuccess()) {
10377
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
10377
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
10378
        {
10378
        {
10379
          oprot.writeMapBegin(new TMap(TType.STRING, TType.STRING, this.success.size()));
10379
          oprot.writeMapBegin(new TMap(TType.STRING, TType.STRING, this.success.size()));
10380
          for (Map.Entry<String, String> _iter42 : this.success.entrySet())
10380
          for (Map.Entry<String, String> _iter46 : this.success.entrySet())
10381
          {
10381
          {
10382
            oprot.writeString(_iter42.getKey());
10382
            oprot.writeString(_iter46.getKey());
10383
            oprot.writeString(_iter42.getValue());
10383
            oprot.writeString(_iter46.getValue());
10384
          }
10384
          }
10385
          oprot.writeMapEnd();
10385
          oprot.writeMapEnd();
10386
        }
10386
        }
10387
        oprot.writeFieldEnd();
10387
        oprot.writeFieldEnd();
10388
      } else if (this.isSetPe()) {
10388
      } else if (this.isSetPe()) {