Subversion Repositories SmartDukaan

Rev

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

Rev 18598 Rev 18719
Line 592... Line 592...
592
 
592
 
593
    public HsItem getHsItem(String hsItemId) throws org.apache.thrift.TException;
593
    public HsItem getHsItem(String hsItemId) throws org.apache.thrift.TException;
594
 
594
 
595
    public void updateHsItem(HsItem hsItem) throws org.apache.thrift.TException;
595
    public void updateHsItem(HsItem hsItem) throws org.apache.thrift.TException;
596
 
596
 
597
    public Item getPricingForDtr(long catalogItemId) throws org.apache.thrift.TException;
597
    public DtrPricing getPricingForDtr(long catalogItemId) throws org.apache.thrift.TException;
598
 
598
 
599
    public List<Amazonlisted> getAllItemstoListOnFbd() throws org.apache.thrift.TException;
599
    public List<Amazonlisted> getAllItemstoListOnFbd() throws org.apache.thrift.TException;
600
 
600
 
601
    public List<Amazonlisted> getAllFbdListedItems() throws org.apache.thrift.TException;
601
    public List<Amazonlisted> getAllFbdListedItems() throws org.apache.thrift.TException;
602
 
602
 
Line 5420... Line 5420...
5420
      updateHsItem_result result = new updateHsItem_result();
5420
      updateHsItem_result result = new updateHsItem_result();
5421
      receiveBase(result, "updateHsItem");
5421
      receiveBase(result, "updateHsItem");
5422
      return;
5422
      return;
5423
    }
5423
    }
5424
 
5424
 
5425
    public Item getPricingForDtr(long catalogItemId) throws org.apache.thrift.TException
5425
    public DtrPricing getPricingForDtr(long catalogItemId) throws org.apache.thrift.TException
5426
    {
5426
    {
5427
      send_getPricingForDtr(catalogItemId);
5427
      send_getPricingForDtr(catalogItemId);
5428
      return recv_getPricingForDtr();
5428
      return recv_getPricingForDtr();
5429
    }
5429
    }
5430
 
5430
 
Line 5433... Line 5433...
5433
      getPricingForDtr_args args = new getPricingForDtr_args();
5433
      getPricingForDtr_args args = new getPricingForDtr_args();
5434
      args.setCatalogItemId(catalogItemId);
5434
      args.setCatalogItemId(catalogItemId);
5435
      sendBase("getPricingForDtr", args);
5435
      sendBase("getPricingForDtr", args);
5436
    }
5436
    }
5437
 
5437
 
5438
    public Item recv_getPricingForDtr() throws org.apache.thrift.TException
5438
    public DtrPricing recv_getPricingForDtr() throws org.apache.thrift.TException
5439
    {
5439
    {
5440
      getPricingForDtr_result result = new getPricingForDtr_result();
5440
      getPricingForDtr_result result = new getPricingForDtr_result();
5441
      receiveBase(result, "getPricingForDtr");
5441
      receiveBase(result, "getPricingForDtr");
5442
      if (result.isSetSuccess()) {
5442
      if (result.isSetSuccess()) {
5443
        return result.success;
5443
        return result.success;
Line 11768... Line 11768...
11768
        args.setCatalogItemId(catalogItemId);
11768
        args.setCatalogItemId(catalogItemId);
11769
        args.write(prot);
11769
        args.write(prot);
11770
        prot.writeMessageEnd();
11770
        prot.writeMessageEnd();
11771
      }
11771
      }
11772
 
11772
 
11773
      public Item getResult() throws org.apache.thrift.TException {
11773
      public DtrPricing getResult() throws org.apache.thrift.TException {
11774
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
11774
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
11775
          throw new IllegalStateException("Method call not finished!");
11775
          throw new IllegalStateException("Method call not finished!");
11776
        }
11776
        }
11777
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
11777
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
11778
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
11778
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
Line 17890... Line 17890...
17890
        }
17890
        }
17891
        switch (field.id) {
17891
        switch (field.id) {
17892
          case 1: // ITEM_IDS
17892
          case 1: // ITEM_IDS
17893
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
17893
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
17894
              {
17894
              {
17895
                org.apache.thrift.protocol.TList _list17 = iprot.readListBegin();
17895
                org.apache.thrift.protocol.TList _list22 = iprot.readListBegin();
17896
                this.itemIds = new ArrayList<Long>(_list17.size);
17896
                this.itemIds = new ArrayList<Long>(_list22.size);
17897
                for (int _i18 = 0; _i18 < _list17.size; ++_i18)
17897
                for (int _i23 = 0; _i23 < _list22.size; ++_i23)
17898
                {
17898
                {
17899
                  long _elem19; // required
17899
                  long _elem24; // required
17900
                  _elem19 = iprot.readI64();
17900
                  _elem24 = iprot.readI64();
17901
                  this.itemIds.add(_elem19);
17901
                  this.itemIds.add(_elem24);
17902
                }
17902
                }
17903
                iprot.readListEnd();
17903
                iprot.readListEnd();
17904
              }
17904
              }
17905
            } else { 
17905
            } else { 
17906
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
17906
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 17921... Line 17921...
17921
      oprot.writeStructBegin(STRUCT_DESC);
17921
      oprot.writeStructBegin(STRUCT_DESC);
17922
      if (this.itemIds != null) {
17922
      if (this.itemIds != null) {
17923
        oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
17923
        oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
17924
        {
17924
        {
17925
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.itemIds.size()));
17925
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.itemIds.size()));
17926
          for (long _iter20 : this.itemIds)
17926
          for (long _iter25 : this.itemIds)
17927
          {
17927
          {
17928
            oprot.writeI64(_iter20);
17928
            oprot.writeI64(_iter25);
17929
          }
17929
          }
17930
          oprot.writeListEnd();
17930
          oprot.writeListEnd();
17931
        }
17931
        }
17932
        oprot.writeFieldEnd();
17932
        oprot.writeFieldEnd();
17933
      }
17933
      }
Line 18294... Line 18294...
18294
        }
18294
        }
18295
        switch (field.id) {
18295
        switch (field.id) {
18296
          case 0: // SUCCESS
18296
          case 0: // SUCCESS
18297
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
18297
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
18298
              {
18298
              {
18299
                org.apache.thrift.protocol.TMap _map21 = iprot.readMapBegin();
18299
                org.apache.thrift.protocol.TMap _map26 = iprot.readMapBegin();
18300
                this.success = new HashMap<Long,Boolean>(2*_map21.size);
18300
                this.success = new HashMap<Long,Boolean>(2*_map26.size);
18301
                for (int _i22 = 0; _i22 < _map21.size; ++_i22)
18301
                for (int _i27 = 0; _i27 < _map26.size; ++_i27)
18302
                {
18302
                {
18303
                  long _key23; // required
18303
                  long _key28; // required
18304
                  boolean _val24; // required
18304
                  boolean _val29; // required
18305
                  _key23 = iprot.readI64();
18305
                  _key28 = iprot.readI64();
18306
                  _val24 = iprot.readBool();
18306
                  _val29 = iprot.readBool();
18307
                  this.success.put(_key23, _val24);
18307
                  this.success.put(_key28, _val29);
18308
                }
18308
                }
18309
                iprot.readMapEnd();
18309
                iprot.readMapEnd();
18310
              }
18310
              }
18311
            } else { 
18311
            } else { 
18312
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
18312
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 18334... Line 18334...
18334
 
18334
 
18335
      if (this.isSetSuccess()) {
18335
      if (this.isSetSuccess()) {
18336
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
18336
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
18337
        {
18337
        {
18338
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.BOOL, this.success.size()));
18338
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.BOOL, this.success.size()));
18339
          for (Map.Entry<Long, Boolean> _iter25 : this.success.entrySet())
18339
          for (Map.Entry<Long, Boolean> _iter30 : this.success.entrySet())
18340
          {
18340
          {
18341
            oprot.writeI64(_iter25.getKey());
18341
            oprot.writeI64(_iter30.getKey());
18342
            oprot.writeBool(_iter25.getValue());
18342
            oprot.writeBool(_iter30.getValue());
18343
          }
18343
          }
18344
          oprot.writeMapEnd();
18344
          oprot.writeMapEnd();
18345
        }
18345
        }
18346
        oprot.writeFieldEnd();
18346
        oprot.writeFieldEnd();
18347
      } else if (this.isSetIsex()) {
18347
      } else if (this.isSetIsex()) {
Line 22111... Line 22111...
22111
        }
22111
        }
22112
        switch (field.id) {
22112
        switch (field.id) {
22113
          case 1: // ITEM_IDS
22113
          case 1: // ITEM_IDS
22114
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
22114
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
22115
              {
22115
              {
22116
                org.apache.thrift.protocol.TList _list26 = iprot.readListBegin();
22116
                org.apache.thrift.protocol.TList _list31 = iprot.readListBegin();
22117
                this.item_ids = new ArrayList<Long>(_list26.size);
22117
                this.item_ids = new ArrayList<Long>(_list31.size);
22118
                for (int _i27 = 0; _i27 < _list26.size; ++_i27)
22118
                for (int _i32 = 0; _i32 < _list31.size; ++_i32)
22119
                {
22119
                {
22120
                  long _elem28; // required
22120
                  long _elem33; // required
22121
                  _elem28 = iprot.readI64();
22121
                  _elem33 = iprot.readI64();
22122
                  this.item_ids.add(_elem28);
22122
                  this.item_ids.add(_elem33);
22123
                }
22123
                }
22124
                iprot.readListEnd();
22124
                iprot.readListEnd();
22125
              }
22125
              }
22126
            } else { 
22126
            } else { 
22127
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
22127
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 22142... Line 22142...
22142
      oprot.writeStructBegin(STRUCT_DESC);
22142
      oprot.writeStructBegin(STRUCT_DESC);
22143
      if (this.item_ids != null) {
22143
      if (this.item_ids != null) {
22144
        oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
22144
        oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
22145
        {
22145
        {
22146
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.item_ids.size()));
22146
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.item_ids.size()));
22147
          for (long _iter29 : this.item_ids)
22147
          for (long _iter34 : this.item_ids)
22148
          {
22148
          {
22149
            oprot.writeI64(_iter29);
22149
            oprot.writeI64(_iter34);
22150
          }
22150
          }
22151
          oprot.writeListEnd();
22151
          oprot.writeListEnd();
22152
        }
22152
        }
22153
        oprot.writeFieldEnd();
22153
        oprot.writeFieldEnd();
22154
      }
22154
      }
Line 22515... Line 22515...
22515
        }
22515
        }
22516
        switch (field.id) {
22516
        switch (field.id) {
22517
          case 0: // SUCCESS
22517
          case 0: // SUCCESS
22518
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
22518
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
22519
              {
22519
              {
22520
                org.apache.thrift.protocol.TMap _map30 = iprot.readMapBegin();
22520
                org.apache.thrift.protocol.TMap _map35 = iprot.readMapBegin();
22521
                this.success = new HashMap<Long,Item>(2*_map30.size);
22521
                this.success = new HashMap<Long,Item>(2*_map35.size);
22522
                for (int _i31 = 0; _i31 < _map30.size; ++_i31)
22522
                for (int _i36 = 0; _i36 < _map35.size; ++_i36)
22523
                {
22523
                {
22524
                  long _key32; // required
22524
                  long _key37; // required
22525
                  Item _val33; // required
22525
                  Item _val38; // required
22526
                  _key32 = iprot.readI64();
22526
                  _key37 = iprot.readI64();
22527
                  _val33 = new Item();
22527
                  _val38 = new Item();
22528
                  _val33.read(iprot);
22528
                  _val38.read(iprot);
22529
                  this.success.put(_key32, _val33);
22529
                  this.success.put(_key37, _val38);
22530
                }
22530
                }
22531
                iprot.readMapEnd();
22531
                iprot.readMapEnd();
22532
              }
22532
              }
22533
            } else { 
22533
            } else { 
22534
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
22534
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 22556... Line 22556...
22556
 
22556
 
22557
      if (this.isSetSuccess()) {
22557
      if (this.isSetSuccess()) {
22558
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
22558
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
22559
        {
22559
        {
22560
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
22560
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
22561
          for (Map.Entry<Long, Item> _iter34 : this.success.entrySet())
22561
          for (Map.Entry<Long, Item> _iter39 : this.success.entrySet())
22562
          {
22562
          {
22563
            oprot.writeI64(_iter34.getKey());
22563
            oprot.writeI64(_iter39.getKey());
22564
            _iter34.getValue().write(oprot);
22564
            _iter39.getValue().write(oprot);
22565
          }
22565
          }
22566
          oprot.writeMapEnd();
22566
          oprot.writeMapEnd();
22567
        }
22567
        }
22568
        oprot.writeFieldEnd();
22568
        oprot.writeFieldEnd();
22569
      } else if (this.isSetCex()) {
22569
      } else if (this.isSetCex()) {
Line 23231... Line 23231...
23231
        }
23231
        }
23232
        switch (field.id) {
23232
        switch (field.id) {
23233
          case 0: // SUCCESS
23233
          case 0: // SUCCESS
23234
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
23234
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
23235
              {
23235
              {
23236
                org.apache.thrift.protocol.TList _list35 = iprot.readListBegin();
23236
                org.apache.thrift.protocol.TList _list40 = iprot.readListBegin();
23237
                this.success = new ArrayList<Item>(_list35.size);
23237
                this.success = new ArrayList<Item>(_list40.size);
23238
                for (int _i36 = 0; _i36 < _list35.size; ++_i36)
23238
                for (int _i41 = 0; _i41 < _list40.size; ++_i41)
23239
                {
23239
                {
23240
                  Item _elem37; // required
23240
                  Item _elem42; // required
23241
                  _elem37 = new Item();
23241
                  _elem42 = new Item();
23242
                  _elem37.read(iprot);
23242
                  _elem42.read(iprot);
23243
                  this.success.add(_elem37);
23243
                  this.success.add(_elem42);
23244
                }
23244
                }
23245
                iprot.readListEnd();
23245
                iprot.readListEnd();
23246
              }
23246
              }
23247
            } else { 
23247
            } else { 
23248
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
23248
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 23270... Line 23270...
23270
 
23270
 
23271
      if (this.isSetSuccess()) {
23271
      if (this.isSetSuccess()) {
23272
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
23272
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
23273
        {
23273
        {
23274
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
23274
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
23275
          for (Item _iter38 : this.success)
23275
          for (Item _iter43 : this.success)
23276
          {
23276
          {
23277
            _iter38.write(oprot);
23277
            _iter43.write(oprot);
23278
          }
23278
          }
23279
          oprot.writeListEnd();
23279
          oprot.writeListEnd();
23280
        }
23280
        }
23281
        oprot.writeFieldEnd();
23281
        oprot.writeFieldEnd();
23282
      } else if (this.isSetCex()) {
23282
      } else if (this.isSetCex()) {
Line 23944... Line 23944...
23944
        }
23944
        }
23945
        switch (field.id) {
23945
        switch (field.id) {
23946
          case 0: // SUCCESS
23946
          case 0: // SUCCESS
23947
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
23947
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
23948
              {
23948
              {
23949
                org.apache.thrift.protocol.TList _list39 = iprot.readListBegin();
23949
                org.apache.thrift.protocol.TList _list44 = iprot.readListBegin();
23950
                this.success = new ArrayList<Item>(_list39.size);
23950
                this.success = new ArrayList<Item>(_list44.size);
23951
                for (int _i40 = 0; _i40 < _list39.size; ++_i40)
23951
                for (int _i45 = 0; _i45 < _list44.size; ++_i45)
23952
                {
23952
                {
23953
                  Item _elem41; // required
23953
                  Item _elem46; // required
23954
                  _elem41 = new Item();
23954
                  _elem46 = new Item();
23955
                  _elem41.read(iprot);
23955
                  _elem46.read(iprot);
23956
                  this.success.add(_elem41);
23956
                  this.success.add(_elem46);
23957
                }
23957
                }
23958
                iprot.readListEnd();
23958
                iprot.readListEnd();
23959
              }
23959
              }
23960
            } else { 
23960
            } else { 
23961
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
23961
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 23983... Line 23983...
23983
 
23983
 
23984
      if (this.isSetSuccess()) {
23984
      if (this.isSetSuccess()) {
23985
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
23985
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
23986
        {
23986
        {
23987
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
23987
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
23988
          for (Item _iter42 : this.success)
23988
          for (Item _iter47 : this.success)
23989
          {
23989
          {
23990
            _iter42.write(oprot);
23990
            _iter47.write(oprot);
23991
          }
23991
          }
23992
          oprot.writeListEnd();
23992
          oprot.writeListEnd();
23993
        }
23993
        }
23994
        oprot.writeFieldEnd();
23994
        oprot.writeFieldEnd();
23995
      } else if (this.isSetCex()) {
23995
      } else if (this.isSetCex()) {
Line 24657... Line 24657...
24657
        }
24657
        }
24658
        switch (field.id) {
24658
        switch (field.id) {
24659
          case 0: // SUCCESS
24659
          case 0: // SUCCESS
24660
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
24660
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
24661
              {
24661
              {
24662
                org.apache.thrift.protocol.TList _list43 = iprot.readListBegin();
24662
                org.apache.thrift.protocol.TList _list48 = iprot.readListBegin();
24663
                this.success = new ArrayList<Item>(_list43.size);
24663
                this.success = new ArrayList<Item>(_list48.size);
24664
                for (int _i44 = 0; _i44 < _list43.size; ++_i44)
24664
                for (int _i49 = 0; _i49 < _list48.size; ++_i49)
24665
                {
24665
                {
24666
                  Item _elem45; // required
24666
                  Item _elem50; // required
24667
                  _elem45 = new Item();
24667
                  _elem50 = new Item();
24668
                  _elem45.read(iprot);
24668
                  _elem50.read(iprot);
24669
                  this.success.add(_elem45);
24669
                  this.success.add(_elem50);
24670
                }
24670
                }
24671
                iprot.readListEnd();
24671
                iprot.readListEnd();
24672
              }
24672
              }
24673
            } else { 
24673
            } else { 
24674
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
24674
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 24696... Line 24696...
24696
 
24696
 
24697
      if (this.isSetSuccess()) {
24697
      if (this.isSetSuccess()) {
24698
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
24698
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
24699
        {
24699
        {
24700
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
24700
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
24701
          for (Item _iter46 : this.success)
24701
          for (Item _iter51 : this.success)
24702
          {
24702
          {
24703
            _iter46.write(oprot);
24703
            _iter51.write(oprot);
24704
          }
24704
          }
24705
          oprot.writeListEnd();
24705
          oprot.writeListEnd();
24706
        }
24706
        }
24707
        oprot.writeFieldEnd();
24707
        oprot.writeFieldEnd();
24708
      } else if (this.isSetCex()) {
24708
      } else if (this.isSetCex()) {
Line 25382... Line 25382...
25382
        }
25382
        }
25383
        switch (field.id) {
25383
        switch (field.id) {
25384
          case 0: // SUCCESS
25384
          case 0: // SUCCESS
25385
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
25385
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
25386
              {
25386
              {
25387
                org.apache.thrift.protocol.TList _list47 = iprot.readListBegin();
25387
                org.apache.thrift.protocol.TList _list52 = iprot.readListBegin();
25388
                this.success = new ArrayList<Item>(_list47.size);
25388
                this.success = new ArrayList<Item>(_list52.size);
25389
                for (int _i48 = 0; _i48 < _list47.size; ++_i48)
25389
                for (int _i53 = 0; _i53 < _list52.size; ++_i53)
25390
                {
25390
                {
25391
                  Item _elem49; // required
25391
                  Item _elem54; // required
25392
                  _elem49 = new Item();
25392
                  _elem54 = new Item();
25393
                  _elem49.read(iprot);
25393
                  _elem54.read(iprot);
25394
                  this.success.add(_elem49);
25394
                  this.success.add(_elem54);
25395
                }
25395
                }
25396
                iprot.readListEnd();
25396
                iprot.readListEnd();
25397
              }
25397
              }
25398
            } else { 
25398
            } else { 
25399
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
25399
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 25421... Line 25421...
25421
 
25421
 
25422
      if (this.isSetSuccess()) {
25422
      if (this.isSetSuccess()) {
25423
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
25423
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
25424
        {
25424
        {
25425
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
25425
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
25426
          for (Item _iter50 : this.success)
25426
          for (Item _iter55 : this.success)
25427
          {
25427
          {
25428
            _iter50.write(oprot);
25428
            _iter55.write(oprot);
25429
          }
25429
          }
25430
          oprot.writeListEnd();
25430
          oprot.writeListEnd();
25431
        }
25431
        }
25432
        oprot.writeFieldEnd();
25432
        oprot.writeFieldEnd();
25433
      } else if (this.isSetCex()) {
25433
      } else if (this.isSetCex()) {
Line 26580... Line 26580...
26580
      }
26580
      }
26581
    }
26581
    }
26582
 
26582
 
26583
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
26583
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
26584
      try {
26584
      try {
26585
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
-
 
26586
        __isset_bit_vector = new BitSet(1);
-
 
26587
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
26585
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
26588
      } catch (org.apache.thrift.TException te) {
26586
      } catch (org.apache.thrift.TException te) {
26589
        throw new java.io.IOException(te);
26587
        throw new java.io.IOException(te);
26590
      }
26588
      }
26591
    }
26589
    }
Line 27290... Line 27288...
27290
        }
27288
        }
27291
        switch (field.id) {
27289
        switch (field.id) {
27292
          case 0: // SUCCESS
27290
          case 0: // SUCCESS
27293
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
27291
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
27294
              {
27292
              {
27295
                org.apache.thrift.protocol.TMap _map51 = iprot.readMapBegin();
27293
                org.apache.thrift.protocol.TMap _map56 = iprot.readMapBegin();
27296
                this.success = new HashMap<Long,Double>(2*_map51.size);
27294
                this.success = new HashMap<Long,Double>(2*_map56.size);
27297
                for (int _i52 = 0; _i52 < _map51.size; ++_i52)
27295
                for (int _i57 = 0; _i57 < _map56.size; ++_i57)
27298
                {
27296
                {
27299
                  long _key53; // required
27297
                  long _key58; // required
27300
                  double _val54; // required
27298
                  double _val59; // required
27301
                  _key53 = iprot.readI64();
27299
                  _key58 = iprot.readI64();
27302
                  _val54 = iprot.readDouble();
27300
                  _val59 = iprot.readDouble();
27303
                  this.success.put(_key53, _val54);
27301
                  this.success.put(_key58, _val59);
27304
                }
27302
                }
27305
                iprot.readMapEnd();
27303
                iprot.readMapEnd();
27306
              }
27304
              }
27307
            } else { 
27305
            } else { 
27308
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
27306
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 27330... Line 27328...
27330
 
27328
 
27331
      if (this.isSetSuccess()) {
27329
      if (this.isSetSuccess()) {
27332
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
27330
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
27333
        {
27331
        {
27334
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.DOUBLE, this.success.size()));
27332
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.DOUBLE, this.success.size()));
27335
          for (Map.Entry<Long, Double> _iter55 : this.success.entrySet())
27333
          for (Map.Entry<Long, Double> _iter60 : this.success.entrySet())
27336
          {
27334
          {
27337
            oprot.writeI64(_iter55.getKey());
27335
            oprot.writeI64(_iter60.getKey());
27338
            oprot.writeDouble(_iter55.getValue());
27336
            oprot.writeDouble(_iter60.getValue());
27339
          }
27337
          }
27340
          oprot.writeMapEnd();
27338
          oprot.writeMapEnd();
27341
        }
27339
        }
27342
        oprot.writeFieldEnd();
27340
        oprot.writeFieldEnd();
27343
      } else if (this.isSetCex()) {
27341
      } else if (this.isSetCex()) {
Line 28086... Line 28084...
28086
        }
28084
        }
28087
        switch (field.id) {
28085
        switch (field.id) {
28088
          case 0: // SUCCESS
28086
          case 0: // SUCCESS
28089
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
28087
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
28090
              {
28088
              {
28091
                org.apache.thrift.protocol.TList _list56 = iprot.readListBegin();
28089
                org.apache.thrift.protocol.TList _list61 = iprot.readListBegin();
28092
                this.success = new ArrayList<Item>(_list56.size);
28090
                this.success = new ArrayList<Item>(_list61.size);
28093
                for (int _i57 = 0; _i57 < _list56.size; ++_i57)
28091
                for (int _i62 = 0; _i62 < _list61.size; ++_i62)
28094
                {
28092
                {
28095
                  Item _elem58; // required
28093
                  Item _elem63; // required
28096
                  _elem58 = new Item();
28094
                  _elem63 = new Item();
28097
                  _elem58.read(iprot);
28095
                  _elem63.read(iprot);
28098
                  this.success.add(_elem58);
28096
                  this.success.add(_elem63);
28099
                }
28097
                }
28100
                iprot.readListEnd();
28098
                iprot.readListEnd();
28101
              }
28099
              }
28102
            } else { 
28100
            } else { 
28103
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
28101
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 28125... Line 28123...
28125
 
28123
 
28126
      if (this.isSetSuccess()) {
28124
      if (this.isSetSuccess()) {
28127
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
28125
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
28128
        {
28126
        {
28129
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
28127
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
28130
          for (Item _iter59 : this.success)
28128
          for (Item _iter64 : this.success)
28131
          {
28129
          {
28132
            _iter59.write(oprot);
28130
            _iter64.write(oprot);
28133
          }
28131
          }
28134
          oprot.writeListEnd();
28132
          oprot.writeListEnd();
28135
        }
28133
        }
28136
        oprot.writeFieldEnd();
28134
        oprot.writeFieldEnd();
28137
      } else if (this.isSetCex()) {
28135
      } else if (this.isSetCex()) {
Line 28980... Line 28978...
28980
        }
28978
        }
28981
        switch (field.id) {
28979
        switch (field.id) {
28982
          case 0: // SUCCESS
28980
          case 0: // SUCCESS
28983
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
28981
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
28984
              {
28982
              {
28985
                org.apache.thrift.protocol.TList _list60 = iprot.readListBegin();
28983
                org.apache.thrift.protocol.TList _list65 = iprot.readListBegin();
28986
                this.success = new ArrayList<Item>(_list60.size);
28984
                this.success = new ArrayList<Item>(_list65.size);
28987
                for (int _i61 = 0; _i61 < _list60.size; ++_i61)
28985
                for (int _i66 = 0; _i66 < _list65.size; ++_i66)
28988
                {
28986
                {
28989
                  Item _elem62; // required
28987
                  Item _elem67; // required
28990
                  _elem62 = new Item();
28988
                  _elem67 = new Item();
28991
                  _elem62.read(iprot);
28989
                  _elem67.read(iprot);
28992
                  this.success.add(_elem62);
28990
                  this.success.add(_elem67);
28993
                }
28991
                }
28994
                iprot.readListEnd();
28992
                iprot.readListEnd();
28995
              }
28993
              }
28996
            } else { 
28994
            } else { 
28997
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
28995
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 29019... Line 29017...
29019
 
29017
 
29020
      if (this.isSetSuccess()) {
29018
      if (this.isSetSuccess()) {
29021
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
29019
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
29022
        {
29020
        {
29023
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
29021
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
29024
          for (Item _iter63 : this.success)
29022
          for (Item _iter68 : this.success)
29025
          {
29023
          {
29026
            _iter63.write(oprot);
29024
            _iter68.write(oprot);
29027
          }
29025
          }
29028
          oprot.writeListEnd();
29026
          oprot.writeListEnd();
29029
        }
29027
        }
29030
        oprot.writeFieldEnd();
29028
        oprot.writeFieldEnd();
29031
      } else if (this.isSetCex()) {
29029
      } else if (this.isSetCex()) {
Line 30286... Line 30284...
30286
        }
30284
        }
30287
        switch (field.id) {
30285
        switch (field.id) {
30288
          case 0: // SUCCESS
30286
          case 0: // SUCCESS
30289
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
30287
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
30290
              {
30288
              {
30291
                org.apache.thrift.protocol.TList _list64 = iprot.readListBegin();
30289
                org.apache.thrift.protocol.TList _list69 = iprot.readListBegin();
30292
                this.success = new ArrayList<Item>(_list64.size);
30290
                this.success = new ArrayList<Item>(_list69.size);
30293
                for (int _i65 = 0; _i65 < _list64.size; ++_i65)
30291
                for (int _i70 = 0; _i70 < _list69.size; ++_i70)
30294
                {
30292
                {
30295
                  Item _elem66; // required
30293
                  Item _elem71; // required
30296
                  _elem66 = new Item();
30294
                  _elem71 = new Item();
30297
                  _elem66.read(iprot);
30295
                  _elem71.read(iprot);
30298
                  this.success.add(_elem66);
30296
                  this.success.add(_elem71);
30299
                }
30297
                }
30300
                iprot.readListEnd();
30298
                iprot.readListEnd();
30301
              }
30299
              }
30302
            } else { 
30300
            } else { 
30303
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
30301
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 30325... Line 30323...
30325
 
30323
 
30326
      if (this.isSetSuccess()) {
30324
      if (this.isSetSuccess()) {
30327
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
30325
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
30328
        {
30326
        {
30329
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
30327
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
30330
          for (Item _iter67 : this.success)
30328
          for (Item _iter72 : this.success)
30331
          {
30329
          {
30332
            _iter67.write(oprot);
30330
            _iter72.write(oprot);
30333
          }
30331
          }
30334
          oprot.writeListEnd();
30332
          oprot.writeListEnd();
30335
        }
30333
        }
30336
        oprot.writeFieldEnd();
30334
        oprot.writeFieldEnd();
30337
      } else if (this.isSetIsex()) {
30335
      } else if (this.isSetIsex()) {
Line 31253... Line 31251...
31253
        }
31251
        }
31254
        switch (field.id) {
31252
        switch (field.id) {
31255
          case 0: // SUCCESS
31253
          case 0: // SUCCESS
31256
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
31254
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
31257
              {
31255
              {
31258
                org.apache.thrift.protocol.TList _list68 = iprot.readListBegin();
31256
                org.apache.thrift.protocol.TList _list73 = iprot.readListBegin();
31259
                this.success = new ArrayList<Long>(_list68.size);
31257
                this.success = new ArrayList<Long>(_list73.size);
31260
                for (int _i69 = 0; _i69 < _list68.size; ++_i69)
31258
                for (int _i74 = 0; _i74 < _list73.size; ++_i74)
31261
                {
31259
                {
31262
                  long _elem70; // required
31260
                  long _elem75; // required
31263
                  _elem70 = iprot.readI64();
31261
                  _elem75 = iprot.readI64();
31264
                  this.success.add(_elem70);
31262
                  this.success.add(_elem75);
31265
                }
31263
                }
31266
                iprot.readListEnd();
31264
                iprot.readListEnd();
31267
              }
31265
              }
31268
            } else { 
31266
            } else { 
31269
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
31267
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 31291... Line 31289...
31291
 
31289
 
31292
      if (this.isSetSuccess()) {
31290
      if (this.isSetSuccess()) {
31293
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
31291
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
31294
        {
31292
        {
31295
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
31293
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
31296
          for (long _iter71 : this.success)
31294
          for (long _iter76 : this.success)
31297
          {
31295
          {
31298
            oprot.writeI64(_iter71);
31296
            oprot.writeI64(_iter76);
31299
          }
31297
          }
31300
          oprot.writeListEnd();
31298
          oprot.writeListEnd();
31301
        }
31299
        }
31302
        oprot.writeFieldEnd();
31300
        oprot.writeFieldEnd();
31303
      } else if (this.isSetCex()) {
31301
      } else if (this.isSetCex()) {
Line 32452... Line 32450...
32452
        }
32450
        }
32453
        switch (field.id) {
32451
        switch (field.id) {
32454
          case 0: // SUCCESS
32452
          case 0: // SUCCESS
32455
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
32453
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
32456
              {
32454
              {
32457
                org.apache.thrift.protocol.TList _list72 = iprot.readListBegin();
32455
                org.apache.thrift.protocol.TList _list77 = iprot.readListBegin();
32458
                this.success = new ArrayList<Item>(_list72.size);
32456
                this.success = new ArrayList<Item>(_list77.size);
32459
                for (int _i73 = 0; _i73 < _list72.size; ++_i73)
32457
                for (int _i78 = 0; _i78 < _list77.size; ++_i78)
32460
                {
32458
                {
32461
                  Item _elem74; // required
32459
                  Item _elem79; // required
32462
                  _elem74 = new Item();
32460
                  _elem79 = new Item();
32463
                  _elem74.read(iprot);
32461
                  _elem79.read(iprot);
32464
                  this.success.add(_elem74);
32462
                  this.success.add(_elem79);
32465
                }
32463
                }
32466
                iprot.readListEnd();
32464
                iprot.readListEnd();
32467
              }
32465
              }
32468
            } else { 
32466
            } else { 
32469
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
32467
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 32491... Line 32489...
32491
 
32489
 
32492
      if (this.isSetSuccess()) {
32490
      if (this.isSetSuccess()) {
32493
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
32491
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
32494
        {
32492
        {
32495
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
32493
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
32496
          for (Item _iter75 : this.success)
32494
          for (Item _iter80 : this.success)
32497
          {
32495
          {
32498
            _iter75.write(oprot);
32496
            _iter80.write(oprot);
32499
          }
32497
          }
32500
          oprot.writeListEnd();
32498
          oprot.writeListEnd();
32501
        }
32499
        }
32502
        oprot.writeFieldEnd();
32500
        oprot.writeFieldEnd();
32503
      } else if (this.isSetIsex()) {
32501
      } else if (this.isSetIsex()) {
Line 33419... Line 33417...
33419
        }
33417
        }
33420
        switch (field.id) {
33418
        switch (field.id) {
33421
          case 0: // SUCCESS
33419
          case 0: // SUCCESS
33422
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
33420
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
33423
              {
33421
              {
33424
                org.apache.thrift.protocol.TList _list76 = iprot.readListBegin();
33422
                org.apache.thrift.protocol.TList _list81 = iprot.readListBegin();
33425
                this.success = new ArrayList<Long>(_list76.size);
33423
                this.success = new ArrayList<Long>(_list81.size);
33426
                for (int _i77 = 0; _i77 < _list76.size; ++_i77)
33424
                for (int _i82 = 0; _i82 < _list81.size; ++_i82)
33427
                {
33425
                {
33428
                  long _elem78; // required
33426
                  long _elem83; // required
33429
                  _elem78 = iprot.readI64();
33427
                  _elem83 = iprot.readI64();
33430
                  this.success.add(_elem78);
33428
                  this.success.add(_elem83);
33431
                }
33429
                }
33432
                iprot.readListEnd();
33430
                iprot.readListEnd();
33433
              }
33431
              }
33434
            } else { 
33432
            } else { 
33435
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
33433
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 33457... Line 33455...
33457
 
33455
 
33458
      if (this.isSetSuccess()) {
33456
      if (this.isSetSuccess()) {
33459
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
33457
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
33460
        {
33458
        {
33461
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
33459
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
33462
          for (long _iter79 : this.success)
33460
          for (long _iter84 : this.success)
33463
          {
33461
          {
33464
            oprot.writeI64(_iter79);
33462
            oprot.writeI64(_iter84);
33465
          }
33463
          }
33466
          oprot.writeListEnd();
33464
          oprot.writeListEnd();
33467
        }
33465
        }
33468
        oprot.writeFieldEnd();
33466
        oprot.writeFieldEnd();
33469
      } else if (this.isSetCex()) {
33467
      } else if (this.isSetCex()) {
Line 34618... Line 34616...
34618
        }
34616
        }
34619
        switch (field.id) {
34617
        switch (field.id) {
34620
          case 0: // SUCCESS
34618
          case 0: // SUCCESS
34621
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
34619
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
34622
              {
34620
              {
34623
                org.apache.thrift.protocol.TList _list80 = iprot.readListBegin();
34621
                org.apache.thrift.protocol.TList _list85 = iprot.readListBegin();
34624
                this.success = new ArrayList<Item>(_list80.size);
34622
                this.success = new ArrayList<Item>(_list85.size);
34625
                for (int _i81 = 0; _i81 < _list80.size; ++_i81)
34623
                for (int _i86 = 0; _i86 < _list85.size; ++_i86)
34626
                {
34624
                {
34627
                  Item _elem82; // required
34625
                  Item _elem87; // required
34628
                  _elem82 = new Item();
34626
                  _elem87 = new Item();
34629
                  _elem82.read(iprot);
34627
                  _elem87.read(iprot);
34630
                  this.success.add(_elem82);
34628
                  this.success.add(_elem87);
34631
                }
34629
                }
34632
                iprot.readListEnd();
34630
                iprot.readListEnd();
34633
              }
34631
              }
34634
            } else { 
34632
            } else { 
34635
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
34633
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 34657... Line 34655...
34657
 
34655
 
34658
      if (this.isSetSuccess()) {
34656
      if (this.isSetSuccess()) {
34659
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
34657
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
34660
        {
34658
        {
34661
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
34659
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
34662
          for (Item _iter83 : this.success)
34660
          for (Item _iter88 : this.success)
34663
          {
34661
          {
34664
            _iter83.write(oprot);
34662
            _iter88.write(oprot);
34665
          }
34663
          }
34666
          oprot.writeListEnd();
34664
          oprot.writeListEnd();
34667
        }
34665
        }
34668
        oprot.writeFieldEnd();
34666
        oprot.writeFieldEnd();
34669
      } else if (this.isSetIsex()) {
34667
      } else if (this.isSetIsex()) {
Line 35585... Line 35583...
35585
        }
35583
        }
35586
        switch (field.id) {
35584
        switch (field.id) {
35587
          case 0: // SUCCESS
35585
          case 0: // SUCCESS
35588
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
35586
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
35589
              {
35587
              {
35590
                org.apache.thrift.protocol.TList _list84 = iprot.readListBegin();
35588
                org.apache.thrift.protocol.TList _list89 = iprot.readListBegin();
35591
                this.success = new ArrayList<Long>(_list84.size);
35589
                this.success = new ArrayList<Long>(_list89.size);
35592
                for (int _i85 = 0; _i85 < _list84.size; ++_i85)
35590
                for (int _i90 = 0; _i90 < _list89.size; ++_i90)
35593
                {
35591
                {
35594
                  long _elem86; // required
35592
                  long _elem91; // required
35595
                  _elem86 = iprot.readI64();
35593
                  _elem91 = iprot.readI64();
35596
                  this.success.add(_elem86);
35594
                  this.success.add(_elem91);
35597
                }
35595
                }
35598
                iprot.readListEnd();
35596
                iprot.readListEnd();
35599
              }
35597
              }
35600
            } else { 
35598
            } else { 
35601
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
35599
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 35623... Line 35621...
35623
 
35621
 
35624
      if (this.isSetSuccess()) {
35622
      if (this.isSetSuccess()) {
35625
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
35623
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
35626
        {
35624
        {
35627
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
35625
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
35628
          for (long _iter87 : this.success)
35626
          for (long _iter92 : this.success)
35629
          {
35627
          {
35630
            oprot.writeI64(_iter87);
35628
            oprot.writeI64(_iter92);
35631
          }
35629
          }
35632
          oprot.writeListEnd();
35630
          oprot.writeListEnd();
35633
        }
35631
        }
35634
        oprot.writeFieldEnd();
35632
        oprot.writeFieldEnd();
35635
      } else if (this.isSetCex()) {
35633
      } else if (this.isSetCex()) {
Line 36784... Line 36782...
36784
        }
36782
        }
36785
        switch (field.id) {
36783
        switch (field.id) {
36786
          case 0: // SUCCESS
36784
          case 0: // SUCCESS
36787
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
36785
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
36788
              {
36786
              {
36789
                org.apache.thrift.protocol.TList _list88 = iprot.readListBegin();
36787
                org.apache.thrift.protocol.TList _list93 = iprot.readListBegin();
36790
                this.success = new ArrayList<Item>(_list88.size);
36788
                this.success = new ArrayList<Item>(_list93.size);
36791
                for (int _i89 = 0; _i89 < _list88.size; ++_i89)
36789
                for (int _i94 = 0; _i94 < _list93.size; ++_i94)
36792
                {
36790
                {
36793
                  Item _elem90; // required
36791
                  Item _elem95; // required
36794
                  _elem90 = new Item();
36792
                  _elem95 = new Item();
36795
                  _elem90.read(iprot);
36793
                  _elem95.read(iprot);
36796
                  this.success.add(_elem90);
36794
                  this.success.add(_elem95);
36797
                }
36795
                }
36798
                iprot.readListEnd();
36796
                iprot.readListEnd();
36799
              }
36797
              }
36800
            } else { 
36798
            } else { 
36801
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
36799
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 36823... Line 36821...
36823
 
36821
 
36824
      if (this.isSetSuccess()) {
36822
      if (this.isSetSuccess()) {
36825
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
36823
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
36826
        {
36824
        {
36827
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
36825
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
36828
          for (Item _iter91 : this.success)
36826
          for (Item _iter96 : this.success)
36829
          {
36827
          {
36830
            _iter91.write(oprot);
36828
            _iter96.write(oprot);
36831
          }
36829
          }
36832
          oprot.writeListEnd();
36830
          oprot.writeListEnd();
36833
        }
36831
        }
36834
        oprot.writeFieldEnd();
36832
        oprot.writeFieldEnd();
36835
      } else if (this.isSetIsex()) {
36833
      } else if (this.isSetIsex()) {
Line 37365... Line 37363...
37365
            }
37363
            }
37366
            break;
37364
            break;
37367
          case 4: // CATEGORIES
37365
          case 4: // CATEGORIES
37368
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
37366
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
37369
              {
37367
              {
37370
                org.apache.thrift.protocol.TList _list92 = iprot.readListBegin();
37368
                org.apache.thrift.protocol.TList _list97 = iprot.readListBegin();
37371
                this.categories = new ArrayList<Long>(_list92.size);
37369
                this.categories = new ArrayList<Long>(_list97.size);
37372
                for (int _i93 = 0; _i93 < _list92.size; ++_i93)
37370
                for (int _i98 = 0; _i98 < _list97.size; ++_i98)
37373
                {
37371
                {
37374
                  long _elem94; // required
37372
                  long _elem99; // required
37375
                  _elem94 = iprot.readI64();
37373
                  _elem99 = iprot.readI64();
37376
                  this.categories.add(_elem94);
37374
                  this.categories.add(_elem99);
37377
                }
37375
                }
37378
                iprot.readListEnd();
37376
                iprot.readListEnd();
37379
              }
37377
              }
37380
            } else { 
37378
            } else { 
37381
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
37379
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 37407... Line 37405...
37407
      }
37405
      }
37408
      if (this.categories != null) {
37406
      if (this.categories != null) {
37409
        oprot.writeFieldBegin(CATEGORIES_FIELD_DESC);
37407
        oprot.writeFieldBegin(CATEGORIES_FIELD_DESC);
37410
        {
37408
        {
37411
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.categories.size()));
37409
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.categories.size()));
37412
          for (long _iter95 : this.categories)
37410
          for (long _iter100 : this.categories)
37413
          {
37411
          {
37414
            oprot.writeI64(_iter95);
37412
            oprot.writeI64(_iter100);
37415
          }
37413
          }
37416
          oprot.writeListEnd();
37414
          oprot.writeListEnd();
37417
        }
37415
        }
37418
        oprot.writeFieldEnd();
37416
        oprot.writeFieldEnd();
37419
      }
37417
      }
Line 37791... Line 37789...
37791
        }
37789
        }
37792
        switch (field.id) {
37790
        switch (field.id) {
37793
          case 0: // SUCCESS
37791
          case 0: // SUCCESS
37794
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
37792
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
37795
              {
37793
              {
37796
                org.apache.thrift.protocol.TList _list96 = iprot.readListBegin();
37794
                org.apache.thrift.protocol.TList _list101 = iprot.readListBegin();
37797
                this.success = new ArrayList<Long>(_list96.size);
37795
                this.success = new ArrayList<Long>(_list101.size);
37798
                for (int _i97 = 0; _i97 < _list96.size; ++_i97)
37796
                for (int _i102 = 0; _i102 < _list101.size; ++_i102)
37799
                {
37797
                {
37800
                  long _elem98; // required
37798
                  long _elem103; // required
37801
                  _elem98 = iprot.readI64();
37799
                  _elem103 = iprot.readI64();
37802
                  this.success.add(_elem98);
37800
                  this.success.add(_elem103);
37803
                }
37801
                }
37804
                iprot.readListEnd();
37802
                iprot.readListEnd();
37805
              }
37803
              }
37806
            } else { 
37804
            } else { 
37807
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
37805
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 37829... Line 37827...
37829
 
37827
 
37830
      if (this.isSetSuccess()) {
37828
      if (this.isSetSuccess()) {
37831
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
37829
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
37832
        {
37830
        {
37833
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
37831
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
37834
          for (long _iter99 : this.success)
37832
          for (long _iter104 : this.success)
37835
          {
37833
          {
37836
            oprot.writeI64(_iter99);
37834
            oprot.writeI64(_iter104);
37837
          }
37835
          }
37838
          oprot.writeListEnd();
37836
          oprot.writeListEnd();
37839
        }
37837
        }
37840
        oprot.writeFieldEnd();
37838
        oprot.writeFieldEnd();
37841
      } else if (this.isSetCex()) {
37839
      } else if (this.isSetCex()) {
Line 40591... Line 40589...
40591
        }
40589
        }
40592
        switch (field.id) {
40590
        switch (field.id) {
40593
          case 0: // SUCCESS
40591
          case 0: // SUCCESS
40594
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
40592
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
40595
              {
40593
              {
40596
                org.apache.thrift.protocol.TList _list100 = iprot.readListBegin();
40594
                org.apache.thrift.protocol.TList _list105 = iprot.readListBegin();
40597
                this.success = new ArrayList<Category>(_list100.size);
40595
                this.success = new ArrayList<Category>(_list105.size);
40598
                for (int _i101 = 0; _i101 < _list100.size; ++_i101)
40596
                for (int _i106 = 0; _i106 < _list105.size; ++_i106)
40599
                {
40597
                {
40600
                  Category _elem102; // required
40598
                  Category _elem107; // required
40601
                  _elem102 = new Category();
40599
                  _elem107 = new Category();
40602
                  _elem102.read(iprot);
40600
                  _elem107.read(iprot);
40603
                  this.success.add(_elem102);
40601
                  this.success.add(_elem107);
40604
                }
40602
                }
40605
                iprot.readListEnd();
40603
                iprot.readListEnd();
40606
              }
40604
              }
40607
            } else { 
40605
            } else { 
40608
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
40606
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 40622... Line 40620...
40622
 
40620
 
40623
      if (this.isSetSuccess()) {
40621
      if (this.isSetSuccess()) {
40624
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
40622
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
40625
        {
40623
        {
40626
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
40624
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
40627
          for (Category _iter103 : this.success)
40625
          for (Category _iter108 : this.success)
40628
          {
40626
          {
40629
            _iter103.write(oprot);
40627
            _iter108.write(oprot);
40630
          }
40628
          }
40631
          oprot.writeListEnd();
40629
          oprot.writeListEnd();
40632
        }
40630
        }
40633
        oprot.writeFieldEnd();
40631
        oprot.writeFieldEnd();
40634
      }
40632
      }
Line 41216... Line 41214...
41216
        }
41214
        }
41217
        switch (field.id) {
41215
        switch (field.id) {
41218
          case 0: // SUCCESS
41216
          case 0: // SUCCESS
41219
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
41217
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
41220
              {
41218
              {
41221
                org.apache.thrift.protocol.TList _list104 = iprot.readListBegin();
41219
                org.apache.thrift.protocol.TList _list109 = iprot.readListBegin();
41222
                this.success = new ArrayList<Item>(_list104.size);
41220
                this.success = new ArrayList<Item>(_list109.size);
41223
                for (int _i105 = 0; _i105 < _list104.size; ++_i105)
41221
                for (int _i110 = 0; _i110 < _list109.size; ++_i110)
41224
                {
41222
                {
41225
                  Item _elem106; // required
41223
                  Item _elem111; // required
41226
                  _elem106 = new Item();
41224
                  _elem111 = new Item();
41227
                  _elem106.read(iprot);
41225
                  _elem111.read(iprot);
41228
                  this.success.add(_elem106);
41226
                  this.success.add(_elem111);
41229
                }
41227
                }
41230
                iprot.readListEnd();
41228
                iprot.readListEnd();
41231
              }
41229
              }
41232
            } else { 
41230
            } else { 
41233
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
41231
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 41247... Line 41245...
41247
 
41245
 
41248
      if (this.isSetSuccess()) {
41246
      if (this.isSetSuccess()) {
41249
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
41247
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
41250
        {
41248
        {
41251
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
41249
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
41252
          for (Item _iter107 : this.success)
41250
          for (Item _iter112 : this.success)
41253
          {
41251
          {
41254
            _iter107.write(oprot);
41252
            _iter112.write(oprot);
41255
          }
41253
          }
41256
          oprot.writeListEnd();
41254
          oprot.writeListEnd();
41257
        }
41255
        }
41258
        oprot.writeFieldEnd();
41256
        oprot.writeFieldEnd();
41259
      }
41257
      }
Line 44443... Line 44441...
44443
        }
44441
        }
44444
        switch (field.id) {
44442
        switch (field.id) {
44445
          case 0: // SUCCESS
44443
          case 0: // SUCCESS
44446
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
44444
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
44447
              {
44445
              {
44448
                org.apache.thrift.protocol.TList _list108 = iprot.readListBegin();
44446
                org.apache.thrift.protocol.TList _list113 = iprot.readListBegin();
44449
                this.success = new ArrayList<String>(_list108.size);
44447
                this.success = new ArrayList<String>(_list113.size);
44450
                for (int _i109 = 0; _i109 < _list108.size; ++_i109)
44448
                for (int _i114 = 0; _i114 < _list113.size; ++_i114)
44451
                {
44449
                {
44452
                  String _elem110; // required
44450
                  String _elem115; // required
44453
                  _elem110 = iprot.readString();
44451
                  _elem115 = iprot.readString();
44454
                  this.success.add(_elem110);
44452
                  this.success.add(_elem115);
44455
                }
44453
                }
44456
                iprot.readListEnd();
44454
                iprot.readListEnd();
44457
              }
44455
              }
44458
            } else { 
44456
            } else { 
44459
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
44457
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 44473... Line 44471...
44473
 
44471
 
44474
      if (this.isSetSuccess()) {
44472
      if (this.isSetSuccess()) {
44475
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
44473
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
44476
        {
44474
        {
44477
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
44475
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
44478
          for (String _iter111 : this.success)
44476
          for (String _iter116 : this.success)
44479
          {
44477
          {
44480
            oprot.writeString(_iter111);
44478
            oprot.writeString(_iter116);
44481
          }
44479
          }
44482
          oprot.writeListEnd();
44480
          oprot.writeListEnd();
44483
        }
44481
        }
44484
        oprot.writeFieldEnd();
44482
        oprot.writeFieldEnd();
44485
      }
44483
      }
Line 45067... Line 45065...
45067
        }
45065
        }
45068
        switch (field.id) {
45066
        switch (field.id) {
45069
          case 0: // SUCCESS
45067
          case 0: // SUCCESS
45070
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
45068
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
45071
              {
45069
              {
45072
                org.apache.thrift.protocol.TList _list112 = iprot.readListBegin();
45070
                org.apache.thrift.protocol.TList _list117 = iprot.readListBegin();
45073
                this.success = new ArrayList<Long>(_list112.size);
45071
                this.success = new ArrayList<Long>(_list117.size);
45074
                for (int _i113 = 0; _i113 < _list112.size; ++_i113)
45072
                for (int _i118 = 0; _i118 < _list117.size; ++_i118)
45075
                {
45073
                {
45076
                  long _elem114; // required
45074
                  long _elem119; // required
45077
                  _elem114 = iprot.readI64();
45075
                  _elem119 = iprot.readI64();
45078
                  this.success.add(_elem114);
45076
                  this.success.add(_elem119);
45079
                }
45077
                }
45080
                iprot.readListEnd();
45078
                iprot.readListEnd();
45081
              }
45079
              }
45082
            } else { 
45080
            } else { 
45083
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
45081
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 45097... Line 45095...
45097
 
45095
 
45098
      if (this.isSetSuccess()) {
45096
      if (this.isSetSuccess()) {
45099
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
45097
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
45100
        {
45098
        {
45101
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
45099
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
45102
          for (long _iter115 : this.success)
45100
          for (long _iter120 : this.success)
45103
          {
45101
          {
45104
            oprot.writeI64(_iter115);
45102
            oprot.writeI64(_iter120);
45105
          }
45103
          }
45106
          oprot.writeListEnd();
45104
          oprot.writeListEnd();
45107
        }
45105
        }
45108
        oprot.writeFieldEnd();
45106
        oprot.writeFieldEnd();
45109
      }
45107
      }
Line 45606... Line 45604...
45606
        }
45604
        }
45607
        switch (field.id) {
45605
        switch (field.id) {
45608
          case 0: // SUCCESS
45606
          case 0: // SUCCESS
45609
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
45607
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
45610
              {
45608
              {
45611
                org.apache.thrift.protocol.TMap _map116 = iprot.readMapBegin();
45609
                org.apache.thrift.protocol.TMap _map121 = iprot.readMapBegin();
45612
                this.success = new HashMap<Long,List<String>>(2*_map116.size);
45610
                this.success = new HashMap<Long,List<String>>(2*_map121.size);
45613
                for (int _i117 = 0; _i117 < _map116.size; ++_i117)
45611
                for (int _i122 = 0; _i122 < _map121.size; ++_i122)
45614
                {
45612
                {
45615
                  long _key118; // required
45613
                  long _key123; // required
45616
                  List<String> _val119; // required
45614
                  List<String> _val124; // required
45617
                  _key118 = iprot.readI64();
45615
                  _key123 = iprot.readI64();
45618
                  {
45616
                  {
45619
                    org.apache.thrift.protocol.TList _list120 = iprot.readListBegin();
45617
                    org.apache.thrift.protocol.TList _list125 = iprot.readListBegin();
45620
                    _val119 = new ArrayList<String>(_list120.size);
45618
                    _val124 = new ArrayList<String>(_list125.size);
45621
                    for (int _i121 = 0; _i121 < _list120.size; ++_i121)
45619
                    for (int _i126 = 0; _i126 < _list125.size; ++_i126)
45622
                    {
45620
                    {
45623
                      String _elem122; // required
45621
                      String _elem127; // required
45624
                      _elem122 = iprot.readString();
45622
                      _elem127 = iprot.readString();
45625
                      _val119.add(_elem122);
45623
                      _val124.add(_elem127);
45626
                    }
45624
                    }
45627
                    iprot.readListEnd();
45625
                    iprot.readListEnd();
45628
                  }
45626
                  }
45629
                  this.success.put(_key118, _val119);
45627
                  this.success.put(_key123, _val124);
45630
                }
45628
                }
45631
                iprot.readMapEnd();
45629
                iprot.readMapEnd();
45632
              }
45630
              }
45633
            } else { 
45631
            } else { 
45634
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
45632
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 45648... Line 45646...
45648
 
45646
 
45649
      if (this.isSetSuccess()) {
45647
      if (this.isSetSuccess()) {
45650
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
45648
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
45651
        {
45649
        {
45652
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.LIST, this.success.size()));
45650
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.LIST, this.success.size()));
45653
          for (Map.Entry<Long, List<String>> _iter123 : this.success.entrySet())
45651
          for (Map.Entry<Long, List<String>> _iter128 : this.success.entrySet())
45654
          {
45652
          {
45655
            oprot.writeI64(_iter123.getKey());
45653
            oprot.writeI64(_iter128.getKey());
45656
            {
45654
            {
45657
              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter123.getValue().size()));
45655
              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter128.getValue().size()));
45658
              for (String _iter124 : _iter123.getValue())
45656
              for (String _iter129 : _iter128.getValue())
45659
              {
45657
              {
45660
                oprot.writeString(_iter124);
45658
                oprot.writeString(_iter129);
45661
              }
45659
              }
45662
              oprot.writeListEnd();
45660
              oprot.writeListEnd();
45663
            }
45661
            }
45664
          }
45662
          }
45665
          oprot.writeMapEnd();
45663
          oprot.writeMapEnd();
Line 47332... Line 47330...
47332
        }
47330
        }
47333
        switch (field.id) {
47331
        switch (field.id) {
47334
          case 0: // SUCCESS
47332
          case 0: // SUCCESS
47335
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
47333
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
47336
              {
47334
              {
47337
                org.apache.thrift.protocol.TList _list125 = iprot.readListBegin();
47335
                org.apache.thrift.protocol.TList _list130 = iprot.readListBegin();
47338
                this.success = new ArrayList<Banner>(_list125.size);
47336
                this.success = new ArrayList<Banner>(_list130.size);
47339
                for (int _i126 = 0; _i126 < _list125.size; ++_i126)
47337
                for (int _i131 = 0; _i131 < _list130.size; ++_i131)
47340
                {
47338
                {
47341
                  Banner _elem127; // required
47339
                  Banner _elem132; // required
47342
                  _elem127 = new Banner();
47340
                  _elem132 = new Banner();
47343
                  _elem127.read(iprot);
47341
                  _elem132.read(iprot);
47344
                  this.success.add(_elem127);
47342
                  this.success.add(_elem132);
47345
                }
47343
                }
47346
                iprot.readListEnd();
47344
                iprot.readListEnd();
47347
              }
47345
              }
47348
            } else { 
47346
            } else { 
47349
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
47347
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 47363... Line 47361...
47363
 
47361
 
47364
      if (this.isSetSuccess()) {
47362
      if (this.isSetSuccess()) {
47365
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
47363
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
47366
        {
47364
        {
47367
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
47365
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
47368
          for (Banner _iter128 : this.success)
47366
          for (Banner _iter133 : this.success)
47369
          {
47367
          {
47370
            _iter128.write(oprot);
47368
            _iter133.write(oprot);
47371
          }
47369
          }
47372
          oprot.writeListEnd();
47370
          oprot.writeListEnd();
47373
        }
47371
        }
47374
        oprot.writeFieldEnd();
47372
        oprot.writeFieldEnd();
47375
      }
47373
      }
Line 49247... Line 49245...
49247
        }
49245
        }
49248
        switch (field.id) {
49246
        switch (field.id) {
49249
          case 0: // SUCCESS
49247
          case 0: // SUCCESS
49250
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
49248
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
49251
              {
49249
              {
49252
                org.apache.thrift.protocol.TMap _map129 = iprot.readMapBegin();
49250
                org.apache.thrift.protocol.TMap _map134 = iprot.readMapBegin();
49253
                this.success = new HashMap<String,List<Banner>>(2*_map129.size);
49251
                this.success = new HashMap<String,List<Banner>>(2*_map134.size);
49254
                for (int _i130 = 0; _i130 < _map129.size; ++_i130)
49252
                for (int _i135 = 0; _i135 < _map134.size; ++_i135)
49255
                {
49253
                {
49256
                  String _key131; // required
49254
                  String _key136; // required
49257
                  List<Banner> _val132; // required
49255
                  List<Banner> _val137; // required
49258
                  _key131 = iprot.readString();
49256
                  _key136 = iprot.readString();
49259
                  {
49257
                  {
49260
                    org.apache.thrift.protocol.TList _list133 = iprot.readListBegin();
49258
                    org.apache.thrift.protocol.TList _list138 = iprot.readListBegin();
49261
                    _val132 = new ArrayList<Banner>(_list133.size);
49259
                    _val137 = new ArrayList<Banner>(_list138.size);
49262
                    for (int _i134 = 0; _i134 < _list133.size; ++_i134)
49260
                    for (int _i139 = 0; _i139 < _list138.size; ++_i139)
49263
                    {
49261
                    {
49264
                      Banner _elem135; // required
49262
                      Banner _elem140; // required
49265
                      _elem135 = new Banner();
49263
                      _elem140 = new Banner();
49266
                      _elem135.read(iprot);
49264
                      _elem140.read(iprot);
49267
                      _val132.add(_elem135);
49265
                      _val137.add(_elem140);
49268
                    }
49266
                    }
49269
                    iprot.readListEnd();
49267
                    iprot.readListEnd();
49270
                  }
49268
                  }
49271
                  this.success.put(_key131, _val132);
49269
                  this.success.put(_key136, _val137);
49272
                }
49270
                }
49273
                iprot.readMapEnd();
49271
                iprot.readMapEnd();
49274
              }
49272
              }
49275
            } else { 
49273
            } else { 
49276
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
49274
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 49290... Line 49288...
49290
 
49288
 
49291
      if (this.isSetSuccess()) {
49289
      if (this.isSetSuccess()) {
49292
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
49290
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
49293
        {
49291
        {
49294
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.LIST, this.success.size()));
49292
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.LIST, this.success.size()));
49295
          for (Map.Entry<String, List<Banner>> _iter136 : this.success.entrySet())
49293
          for (Map.Entry<String, List<Banner>> _iter141 : this.success.entrySet())
49296
          {
49294
          {
49297
            oprot.writeString(_iter136.getKey());
49295
            oprot.writeString(_iter141.getKey());
49298
            {
49296
            {
49299
              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter136.getValue().size()));
49297
              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter141.getValue().size()));
49300
              for (Banner _iter137 : _iter136.getValue())
49298
              for (Banner _iter142 : _iter141.getValue())
49301
              {
49299
              {
49302
                _iter137.write(oprot);
49300
                _iter142.write(oprot);
49303
              }
49301
              }
49304
              oprot.writeListEnd();
49302
              oprot.writeListEnd();
49305
            }
49303
            }
49306
          }
49304
          }
49307
          oprot.writeMapEnd();
49305
          oprot.writeMapEnd();
Line 49598... Line 49596...
49598
        }
49596
        }
49599
        switch (field.id) {
49597
        switch (field.id) {
49600
          case 1: // BANNER_MAPS
49598
          case 1: // BANNER_MAPS
49601
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
49599
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
49602
              {
49600
              {
49603
                org.apache.thrift.protocol.TList _list138 = iprot.readListBegin();
49601
                org.apache.thrift.protocol.TList _list143 = iprot.readListBegin();
49604
                this.bannerMaps = new ArrayList<BannerMap>(_list138.size);
49602
                this.bannerMaps = new ArrayList<BannerMap>(_list143.size);
49605
                for (int _i139 = 0; _i139 < _list138.size; ++_i139)
49603
                for (int _i144 = 0; _i144 < _list143.size; ++_i144)
49606
                {
49604
                {
49607
                  BannerMap _elem140; // required
49605
                  BannerMap _elem145; // required
49608
                  _elem140 = new BannerMap();
49606
                  _elem145 = new BannerMap();
49609
                  _elem140.read(iprot);
49607
                  _elem145.read(iprot);
49610
                  this.bannerMaps.add(_elem140);
49608
                  this.bannerMaps.add(_elem145);
49611
                }
49609
                }
49612
                iprot.readListEnd();
49610
                iprot.readListEnd();
49613
              }
49611
              }
49614
            } else { 
49612
            } else { 
49615
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
49613
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 49630... Line 49628...
49630
      oprot.writeStructBegin(STRUCT_DESC);
49628
      oprot.writeStructBegin(STRUCT_DESC);
49631
      if (this.bannerMaps != null) {
49629
      if (this.bannerMaps != null) {
49632
        oprot.writeFieldBegin(BANNER_MAPS_FIELD_DESC);
49630
        oprot.writeFieldBegin(BANNER_MAPS_FIELD_DESC);
49633
        {
49631
        {
49634
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.bannerMaps.size()));
49632
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.bannerMaps.size()));
49635
          for (BannerMap _iter141 : this.bannerMaps)
49633
          for (BannerMap _iter146 : this.bannerMaps)
49636
          {
49634
          {
49637
            _iter141.write(oprot);
49635
            _iter146.write(oprot);
49638
          }
49636
          }
49639
          oprot.writeListEnd();
49637
          oprot.writeListEnd();
49640
        }
49638
        }
49641
        oprot.writeFieldEnd();
49639
        oprot.writeFieldEnd();
49642
      }
49640
      }
Line 51792... Line 51790...
51792
        }
51790
        }
51793
        switch (field.id) {
51791
        switch (field.id) {
51794
          case 0: // SUCCESS
51792
          case 0: // SUCCESS
51795
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
51793
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
51796
              {
51794
              {
51797
                org.apache.thrift.protocol.TList _list142 = iprot.readListBegin();
51795
                org.apache.thrift.protocol.TList _list147 = iprot.readListBegin();
51798
                this.success = new ArrayList<BannerMap>(_list142.size);
51796
                this.success = new ArrayList<BannerMap>(_list147.size);
51799
                for (int _i143 = 0; _i143 < _list142.size; ++_i143)
51797
                for (int _i148 = 0; _i148 < _list147.size; ++_i148)
51800
                {
51798
                {
51801
                  BannerMap _elem144; // required
51799
                  BannerMap _elem149; // required
51802
                  _elem144 = new BannerMap();
51800
                  _elem149 = new BannerMap();
51803
                  _elem144.read(iprot);
51801
                  _elem149.read(iprot);
51804
                  this.success.add(_elem144);
51802
                  this.success.add(_elem149);
51805
                }
51803
                }
51806
                iprot.readListEnd();
51804
                iprot.readListEnd();
51807
              }
51805
              }
51808
            } else { 
51806
            } else { 
51809
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
51807
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 51823... Line 51821...
51823
 
51821
 
51824
      if (this.isSetSuccess()) {
51822
      if (this.isSetSuccess()) {
51825
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
51823
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
51826
        {
51824
        {
51827
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
51825
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
51828
          for (BannerMap _iter145 : this.success)
51826
          for (BannerMap _iter150 : this.success)
51829
          {
51827
          {
51830
            _iter145.write(oprot);
51828
            _iter150.write(oprot);
51831
          }
51829
          }
51832
          oprot.writeListEnd();
51830
          oprot.writeListEnd();
51833
        }
51831
        }
51834
        oprot.writeFieldEnd();
51832
        oprot.writeFieldEnd();
51835
      }
51833
      }
Line 52123... Line 52121...
52123
        }
52121
        }
52124
        switch (field.id) {
52122
        switch (field.id) {
52125
          case 1: // BANNER_URI_MAPPINGS
52123
          case 1: // BANNER_URI_MAPPINGS
52126
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
52124
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
52127
              {
52125
              {
52128
                org.apache.thrift.protocol.TList _list146 = iprot.readListBegin();
52126
                org.apache.thrift.protocol.TList _list151 = iprot.readListBegin();
52129
                this.bannerUriMappings = new ArrayList<BannerUriMapping>(_list146.size);
52127
                this.bannerUriMappings = new ArrayList<BannerUriMapping>(_list151.size);
52130
                for (int _i147 = 0; _i147 < _list146.size; ++_i147)
52128
                for (int _i152 = 0; _i152 < _list151.size; ++_i152)
52131
                {
52129
                {
52132
                  BannerUriMapping _elem148; // required
52130
                  BannerUriMapping _elem153; // required
52133
                  _elem148 = new BannerUriMapping();
52131
                  _elem153 = new BannerUriMapping();
52134
                  _elem148.read(iprot);
52132
                  _elem153.read(iprot);
52135
                  this.bannerUriMappings.add(_elem148);
52133
                  this.bannerUriMappings.add(_elem153);
52136
                }
52134
                }
52137
                iprot.readListEnd();
52135
                iprot.readListEnd();
52138
              }
52136
              }
52139
            } else { 
52137
            } else { 
52140
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
52138
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 52155... Line 52153...
52155
      oprot.writeStructBegin(STRUCT_DESC);
52153
      oprot.writeStructBegin(STRUCT_DESC);
52156
      if (this.bannerUriMappings != null) {
52154
      if (this.bannerUriMappings != null) {
52157
        oprot.writeFieldBegin(BANNER_URI_MAPPINGS_FIELD_DESC);
52155
        oprot.writeFieldBegin(BANNER_URI_MAPPINGS_FIELD_DESC);
52158
        {
52156
        {
52159
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.bannerUriMappings.size()));
52157
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.bannerUriMappings.size()));
52160
          for (BannerUriMapping _iter149 : this.bannerUriMappings)
52158
          for (BannerUriMapping _iter154 : this.bannerUriMappings)
52161
          {
52159
          {
52162
            _iter149.write(oprot);
52160
            _iter154.write(oprot);
52163
          }
52161
          }
52164
          oprot.writeListEnd();
52162
          oprot.writeListEnd();
52165
        }
52163
        }
52166
        oprot.writeFieldEnd();
52164
        oprot.writeFieldEnd();
52167
      }
52165
      }
Line 53048... Line 53046...
53048
        }
53046
        }
53049
        switch (field.id) {
53047
        switch (field.id) {
53050
          case 0: // SUCCESS
53048
          case 0: // SUCCESS
53051
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
53049
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
53052
              {
53050
              {
53053
                org.apache.thrift.protocol.TList _list150 = iprot.readListBegin();
53051
                org.apache.thrift.protocol.TList _list155 = iprot.readListBegin();
53054
                this.success = new ArrayList<BannerUriMapping>(_list150.size);
53052
                this.success = new ArrayList<BannerUriMapping>(_list155.size);
53055
                for (int _i151 = 0; _i151 < _list150.size; ++_i151)
53053
                for (int _i156 = 0; _i156 < _list155.size; ++_i156)
53056
                {
53054
                {
53057
                  BannerUriMapping _elem152; // required
53055
                  BannerUriMapping _elem157; // required
53058
                  _elem152 = new BannerUriMapping();
53056
                  _elem157 = new BannerUriMapping();
53059
                  _elem152.read(iprot);
53057
                  _elem157.read(iprot);
53060
                  this.success.add(_elem152);
53058
                  this.success.add(_elem157);
53061
                }
53059
                }
53062
                iprot.readListEnd();
53060
                iprot.readListEnd();
53063
              }
53061
              }
53064
            } else { 
53062
            } else { 
53065
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
53063
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 53079... Line 53077...
53079
 
53077
 
53080
      if (this.isSetSuccess()) {
53078
      if (this.isSetSuccess()) {
53081
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
53079
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
53082
        {
53080
        {
53083
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
53081
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
53084
          for (BannerUriMapping _iter153 : this.success)
53082
          for (BannerUriMapping _iter158 : this.success)
53085
          {
53083
          {
53086
            _iter153.write(oprot);
53084
            _iter158.write(oprot);
53087
          }
53085
          }
53088
          oprot.writeListEnd();
53086
          oprot.writeListEnd();
53089
        }
53087
        }
53090
        oprot.writeFieldEnd();
53088
        oprot.writeFieldEnd();
53091
      }
53089
      }
Line 54167... Line 54165...
54167
        }
54165
        }
54168
        switch (field.id) {
54166
        switch (field.id) {
54169
          case 0: // SUCCESS
54167
          case 0: // SUCCESS
54170
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
54168
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
54171
              {
54169
              {
54172
                org.apache.thrift.protocol.TList _list154 = iprot.readListBegin();
54170
                org.apache.thrift.protocol.TList _list159 = iprot.readListBegin();
54173
                this.success = new ArrayList<Campaign>(_list154.size);
54171
                this.success = new ArrayList<Campaign>(_list159.size);
54174
                for (int _i155 = 0; _i155 < _list154.size; ++_i155)
54172
                for (int _i160 = 0; _i160 < _list159.size; ++_i160)
54175
                {
54173
                {
54176
                  Campaign _elem156; // required
54174
                  Campaign _elem161; // required
54177
                  _elem156 = new Campaign();
54175
                  _elem161 = new Campaign();
54178
                  _elem156.read(iprot);
54176
                  _elem161.read(iprot);
54179
                  this.success.add(_elem156);
54177
                  this.success.add(_elem161);
54180
                }
54178
                }
54181
                iprot.readListEnd();
54179
                iprot.readListEnd();
54182
              }
54180
              }
54183
            } else { 
54181
            } else { 
54184
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
54182
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 54198... Line 54196...
54198
 
54196
 
54199
      if (this.isSetSuccess()) {
54197
      if (this.isSetSuccess()) {
54200
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
54198
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
54201
        {
54199
        {
54202
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
54200
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
54203
          for (Campaign _iter157 : this.success)
54201
          for (Campaign _iter162 : this.success)
54204
          {
54202
          {
54205
            _iter157.write(oprot);
54203
            _iter162.write(oprot);
54206
          }
54204
          }
54207
          oprot.writeListEnd();
54205
          oprot.writeListEnd();
54208
        }
54206
        }
54209
        oprot.writeFieldEnd();
54207
        oprot.writeFieldEnd();
54210
      }
54208
      }
Line 55191... Line 55189...
55191
        }
55189
        }
55192
        switch (field.id) {
55190
        switch (field.id) {
55193
          case 0: // SUCCESS
55191
          case 0: // SUCCESS
55194
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
55192
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
55195
              {
55193
              {
55196
                org.apache.thrift.protocol.TList _list158 = iprot.readListBegin();
55194
                org.apache.thrift.protocol.TList _list163 = iprot.readListBegin();
55197
                this.success = new ArrayList<String>(_list158.size);
55195
                this.success = new ArrayList<String>(_list163.size);
55198
                for (int _i159 = 0; _i159 < _list158.size; ++_i159)
55196
                for (int _i164 = 0; _i164 < _list163.size; ++_i164)
55199
                {
55197
                {
55200
                  String _elem160; // required
55198
                  String _elem165; // required
55201
                  _elem160 = iprot.readString();
55199
                  _elem165 = iprot.readString();
55202
                  this.success.add(_elem160);
55200
                  this.success.add(_elem165);
55203
                }
55201
                }
55204
                iprot.readListEnd();
55202
                iprot.readListEnd();
55205
              }
55203
              }
55206
            } else { 
55204
            } else { 
55207
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
55205
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 55221... Line 55219...
55221
 
55219
 
55222
      if (this.isSetSuccess()) {
55220
      if (this.isSetSuccess()) {
55223
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
55221
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
55224
        {
55222
        {
55225
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
55223
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
55226
          for (String _iter161 : this.success)
55224
          for (String _iter166 : this.success)
55227
          {
55225
          {
55228
            oprot.writeString(_iter161);
55226
            oprot.writeString(_iter166);
55229
          }
55227
          }
55230
          oprot.writeListEnd();
55228
          oprot.writeListEnd();
55231
        }
55229
        }
55232
        oprot.writeFieldEnd();
55230
        oprot.writeFieldEnd();
55233
      }
55231
      }
Line 55730... Line 55728...
55730
        }
55728
        }
55731
        switch (field.id) {
55729
        switch (field.id) {
55732
          case 0: // SUCCESS
55730
          case 0: // SUCCESS
55733
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
55731
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
55734
              {
55732
              {
55735
                org.apache.thrift.protocol.TMap _map162 = iprot.readMapBegin();
55733
                org.apache.thrift.protocol.TMap _map167 = iprot.readMapBegin();
55736
                this.success = new HashMap<String,List<Banner>>(2*_map162.size);
55734
                this.success = new HashMap<String,List<Banner>>(2*_map167.size);
55737
                for (int _i163 = 0; _i163 < _map162.size; ++_i163)
55735
                for (int _i168 = 0; _i168 < _map167.size; ++_i168)
55738
                {
55736
                {
55739
                  String _key164; // required
55737
                  String _key169; // required
55740
                  List<Banner> _val165; // required
55738
                  List<Banner> _val170; // required
55741
                  _key164 = iprot.readString();
55739
                  _key169 = iprot.readString();
55742
                  {
55740
                  {
55743
                    org.apache.thrift.protocol.TList _list166 = iprot.readListBegin();
55741
                    org.apache.thrift.protocol.TList _list171 = iprot.readListBegin();
55744
                    _val165 = new ArrayList<Banner>(_list166.size);
55742
                    _val170 = new ArrayList<Banner>(_list171.size);
55745
                    for (int _i167 = 0; _i167 < _list166.size; ++_i167)
55743
                    for (int _i172 = 0; _i172 < _list171.size; ++_i172)
55746
                    {
55744
                    {
55747
                      Banner _elem168; // required
55745
                      Banner _elem173; // required
55748
                      _elem168 = new Banner();
55746
                      _elem173 = new Banner();
55749
                      _elem168.read(iprot);
55747
                      _elem173.read(iprot);
55750
                      _val165.add(_elem168);
55748
                      _val170.add(_elem173);
55751
                    }
55749
                    }
55752
                    iprot.readListEnd();
55750
                    iprot.readListEnd();
55753
                  }
55751
                  }
55754
                  this.success.put(_key164, _val165);
55752
                  this.success.put(_key169, _val170);
55755
                }
55753
                }
55756
                iprot.readMapEnd();
55754
                iprot.readMapEnd();
55757
              }
55755
              }
55758
            } else { 
55756
            } else { 
55759
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
55757
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 55773... Line 55771...
55773
 
55771
 
55774
      if (this.isSetSuccess()) {
55772
      if (this.isSetSuccess()) {
55775
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
55773
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
55776
        {
55774
        {
55777
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.LIST, this.success.size()));
55775
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.LIST, this.success.size()));
55778
          for (Map.Entry<String, List<Banner>> _iter169 : this.success.entrySet())
55776
          for (Map.Entry<String, List<Banner>> _iter174 : this.success.entrySet())
55779
          {
55777
          {
55780
            oprot.writeString(_iter169.getKey());
55778
            oprot.writeString(_iter174.getKey());
55781
            {
55779
            {
55782
              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter169.getValue().size()));
55780
              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter174.getValue().size()));
55783
              for (Banner _iter170 : _iter169.getValue())
55781
              for (Banner _iter175 : _iter174.getValue())
55784
              {
55782
              {
55785
                _iter170.write(oprot);
55783
                _iter175.write(oprot);
55786
              }
55784
              }
55787
              oprot.writeListEnd();
55785
              oprot.writeListEnd();
55788
            }
55786
            }
55789
          }
55787
          }
55790
          oprot.writeMapEnd();
55788
          oprot.writeMapEnd();
Line 58957... Line 58955...
58957
        }
58955
        }
58958
        switch (field.id) {
58956
        switch (field.id) {
58959
          case 0: // SUCCESS
58957
          case 0: // SUCCESS
58960
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
58958
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
58961
              {
58959
              {
58962
                org.apache.thrift.protocol.TList _list171 = iprot.readListBegin();
58960
                org.apache.thrift.protocol.TList _list176 = iprot.readListBegin();
58963
                this.success = new ArrayList<Item>(_list171.size);
58961
                this.success = new ArrayList<Item>(_list176.size);
58964
                for (int _i172 = 0; _i172 < _list171.size; ++_i172)
58962
                for (int _i177 = 0; _i177 < _list176.size; ++_i177)
58965
                {
58963
                {
58966
                  Item _elem173; // required
58964
                  Item _elem178; // required
58967
                  _elem173 = new Item();
58965
                  _elem178 = new Item();
58968
                  _elem173.read(iprot);
58966
                  _elem178.read(iprot);
58969
                  this.success.add(_elem173);
58967
                  this.success.add(_elem178);
58970
                }
58968
                }
58971
                iprot.readListEnd();
58969
                iprot.readListEnd();
58972
              }
58970
              }
58973
            } else { 
58971
            } else { 
58974
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
58972
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 58988... Line 58986...
58988
 
58986
 
58989
      if (this.isSetSuccess()) {
58987
      if (this.isSetSuccess()) {
58990
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
58988
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
58991
        {
58989
        {
58992
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
58990
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
58993
          for (Item _iter174 : this.success)
58991
          for (Item _iter179 : this.success)
58994
          {
58992
          {
58995
            _iter174.write(oprot);
58993
            _iter179.write(oprot);
58996
          }
58994
          }
58997
          oprot.writeListEnd();
58995
          oprot.writeListEnd();
58998
        }
58996
        }
58999
        oprot.writeFieldEnd();
58997
        oprot.writeFieldEnd();
59000
      }
58998
      }
Line 59670... Line 59668...
59670
        }
59668
        }
59671
        switch (field.id) {
59669
        switch (field.id) {
59672
          case 0: // SUCCESS
59670
          case 0: // SUCCESS
59673
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
59671
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
59674
              {
59672
              {
59675
                org.apache.thrift.protocol.TList _list175 = iprot.readListBegin();
59673
                org.apache.thrift.protocol.TList _list180 = iprot.readListBegin();
59676
                this.success = new ArrayList<Item>(_list175.size);
59674
                this.success = new ArrayList<Item>(_list180.size);
59677
                for (int _i176 = 0; _i176 < _list175.size; ++_i176)
59675
                for (int _i181 = 0; _i181 < _list180.size; ++_i181)
59678
                {
59676
                {
59679
                  Item _elem177; // required
59677
                  Item _elem182; // required
59680
                  _elem177 = new Item();
59678
                  _elem182 = new Item();
59681
                  _elem177.read(iprot);
59679
                  _elem182.read(iprot);
59682
                  this.success.add(_elem177);
59680
                  this.success.add(_elem182);
59683
                }
59681
                }
59684
                iprot.readListEnd();
59682
                iprot.readListEnd();
59685
              }
59683
              }
59686
            } else { 
59684
            } else { 
59687
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
59685
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 59701... Line 59699...
59701
 
59699
 
59702
      if (this.isSetSuccess()) {
59700
      if (this.isSetSuccess()) {
59703
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
59701
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
59704
        {
59702
        {
59705
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
59703
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
59706
          for (Item _iter178 : this.success)
59704
          for (Item _iter183 : this.success)
59707
          {
59705
          {
59708
            _iter178.write(oprot);
59706
            _iter183.write(oprot);
59709
          }
59707
          }
59710
          oprot.writeListEnd();
59708
          oprot.writeListEnd();
59711
        }
59709
        }
59712
        oprot.writeFieldEnd();
59710
        oprot.writeFieldEnd();
59713
      }
59711
      }
Line 60459... Line 60457...
60459
        }
60457
        }
60460
        switch (field.id) {
60458
        switch (field.id) {
60461
          case 0: // SUCCESS
60459
          case 0: // SUCCESS
60462
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
60460
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
60463
              {
60461
              {
60464
                org.apache.thrift.protocol.TList _list179 = iprot.readListBegin();
60462
                org.apache.thrift.protocol.TList _list184 = iprot.readListBegin();
60465
                this.success = new ArrayList<Long>(_list179.size);
60463
                this.success = new ArrayList<Long>(_list184.size);
60466
                for (int _i180 = 0; _i180 < _list179.size; ++_i180)
60464
                for (int _i185 = 0; _i185 < _list184.size; ++_i185)
60467
                {
60465
                {
60468
                  long _elem181; // required
60466
                  long _elem186; // required
60469
                  _elem181 = iprot.readI64();
60467
                  _elem186 = iprot.readI64();
60470
                  this.success.add(_elem181);
60468
                  this.success.add(_elem186);
60471
                }
60469
                }
60472
                iprot.readListEnd();
60470
                iprot.readListEnd();
60473
              }
60471
              }
60474
            } else { 
60472
            } else { 
60475
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
60473
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 60489... Line 60487...
60489
 
60487
 
60490
      if (this.isSetSuccess()) {
60488
      if (this.isSetSuccess()) {
60491
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
60489
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
60492
        {
60490
        {
60493
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
60491
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
60494
          for (long _iter182 : this.success)
60492
          for (long _iter187 : this.success)
60495
          {
60493
          {
60496
            oprot.writeI64(_iter182);
60494
            oprot.writeI64(_iter187);
60497
          }
60495
          }
60498
          oprot.writeListEnd();
60496
          oprot.writeListEnd();
60499
        }
60497
        }
60500
        oprot.writeFieldEnd();
60498
        oprot.writeFieldEnd();
60501
      }
60499
      }
Line 62251... Line 62249...
62251
        }
62249
        }
62252
        switch (field.id) {
62250
        switch (field.id) {
62253
          case 0: // SUCCESS
62251
          case 0: // SUCCESS
62254
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
62252
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
62255
              {
62253
              {
62256
                org.apache.thrift.protocol.TList _list183 = iprot.readListBegin();
62254
                org.apache.thrift.protocol.TList _list188 = iprot.readListBegin();
62257
                this.success = new ArrayList<String>(_list183.size);
62255
                this.success = new ArrayList<String>(_list188.size);
62258
                for (int _i184 = 0; _i184 < _list183.size; ++_i184)
62256
                for (int _i189 = 0; _i189 < _list188.size; ++_i189)
62259
                {
62257
                {
62260
                  String _elem185; // required
62258
                  String _elem190; // required
62261
                  _elem185 = iprot.readString();
62259
                  _elem190 = iprot.readString();
62262
                  this.success.add(_elem185);
62260
                  this.success.add(_elem190);
62263
                }
62261
                }
62264
                iprot.readListEnd();
62262
                iprot.readListEnd();
62265
              }
62263
              }
62266
            } else { 
62264
            } else { 
62267
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
62265
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 62281... Line 62279...
62281
 
62279
 
62282
      if (this.isSetSuccess()) {
62280
      if (this.isSetSuccess()) {
62283
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
62281
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
62284
        {
62282
        {
62285
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
62283
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
62286
          for (String _iter186 : this.success)
62284
          for (String _iter191 : this.success)
62287
          {
62285
          {
62288
            oprot.writeString(_iter186);
62286
            oprot.writeString(_iter191);
62289
          }
62287
          }
62290
          oprot.writeListEnd();
62288
          oprot.writeListEnd();
62291
        }
62289
        }
62292
        oprot.writeFieldEnd();
62290
        oprot.writeFieldEnd();
62293
      }
62291
      }
Line 62781... Line 62779...
62781
        }
62779
        }
62782
        switch (field.id) {
62780
        switch (field.id) {
62783
          case 0: // SUCCESS
62781
          case 0: // SUCCESS
62784
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
62782
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
62785
              {
62783
              {
62786
                org.apache.thrift.protocol.TList _list187 = iprot.readListBegin();
62784
                org.apache.thrift.protocol.TList _list192 = iprot.readListBegin();
62787
                this.success = new ArrayList<String>(_list187.size);
62785
                this.success = new ArrayList<String>(_list192.size);
62788
                for (int _i188 = 0; _i188 < _list187.size; ++_i188)
62786
                for (int _i193 = 0; _i193 < _list192.size; ++_i193)
62789
                {
62787
                {
62790
                  String _elem189; // required
62788
                  String _elem194; // required
62791
                  _elem189 = iprot.readString();
62789
                  _elem194 = iprot.readString();
62792
                  this.success.add(_elem189);
62790
                  this.success.add(_elem194);
62793
                }
62791
                }
62794
                iprot.readListEnd();
62792
                iprot.readListEnd();
62795
              }
62793
              }
62796
            } else { 
62794
            } else { 
62797
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
62795
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 62811... Line 62809...
62811
 
62809
 
62812
      if (this.isSetSuccess()) {
62810
      if (this.isSetSuccess()) {
62813
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
62811
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
62814
        {
62812
        {
62815
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
62813
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
62816
          for (String _iter190 : this.success)
62814
          for (String _iter195 : this.success)
62817
          {
62815
          {
62818
            oprot.writeString(_iter190);
62816
            oprot.writeString(_iter195);
62819
          }
62817
          }
62820
          oprot.writeListEnd();
62818
          oprot.writeListEnd();
62821
        }
62819
        }
62822
        oprot.writeFieldEnd();
62820
        oprot.writeFieldEnd();
62823
      }
62821
      }
Line 63311... Line 63309...
63311
        }
63309
        }
63312
        switch (field.id) {
63310
        switch (field.id) {
63313
          case 0: // SUCCESS
63311
          case 0: // SUCCESS
63314
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
63312
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
63315
              {
63313
              {
63316
                org.apache.thrift.protocol.TList _list191 = iprot.readListBegin();
63314
                org.apache.thrift.protocol.TList _list196 = iprot.readListBegin();
63317
                this.success = new ArrayList<Source>(_list191.size);
63315
                this.success = new ArrayList<Source>(_list196.size);
63318
                for (int _i192 = 0; _i192 < _list191.size; ++_i192)
63316
                for (int _i197 = 0; _i197 < _list196.size; ++_i197)
63319
                {
63317
                {
63320
                  Source _elem193; // required
63318
                  Source _elem198; // required
63321
                  _elem193 = new Source();
63319
                  _elem198 = new Source();
63322
                  _elem193.read(iprot);
63320
                  _elem198.read(iprot);
63323
                  this.success.add(_elem193);
63321
                  this.success.add(_elem198);
63324
                }
63322
                }
63325
                iprot.readListEnd();
63323
                iprot.readListEnd();
63326
              }
63324
              }
63327
            } else { 
63325
            } else { 
63328
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
63326
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 63342... Line 63340...
63342
 
63340
 
63343
      if (this.isSetSuccess()) {
63341
      if (this.isSetSuccess()) {
63344
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
63342
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
63345
        {
63343
        {
63346
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
63344
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
63347
          for (Source _iter194 : this.success)
63345
          for (Source _iter199 : this.success)
63348
          {
63346
          {
63349
            _iter194.write(oprot);
63347
            _iter199.write(oprot);
63350
          }
63348
          }
63351
          oprot.writeListEnd();
63349
          oprot.writeListEnd();
63352
        }
63350
        }
63353
        oprot.writeFieldEnd();
63351
        oprot.writeFieldEnd();
63354
      }
63352
      }
Line 65348... Line 65346...
65348
        }
65346
        }
65349
        switch (field.id) {
65347
        switch (field.id) {
65350
          case 0: // SUCCESS
65348
          case 0: // SUCCESS
65351
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
65349
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
65352
              {
65350
              {
65353
                org.apache.thrift.protocol.TList _list195 = iprot.readListBegin();
65351
                org.apache.thrift.protocol.TList _list200 = iprot.readListBegin();
65354
                this.success = new ArrayList<SourceItemPricing>(_list195.size);
65352
                this.success = new ArrayList<SourceItemPricing>(_list200.size);
65355
                for (int _i196 = 0; _i196 < _list195.size; ++_i196)
65353
                for (int _i201 = 0; _i201 < _list200.size; ++_i201)
65356
                {
65354
                {
65357
                  SourceItemPricing _elem197; // required
65355
                  SourceItemPricing _elem202; // required
65358
                  _elem197 = new SourceItemPricing();
65356
                  _elem202 = new SourceItemPricing();
65359
                  _elem197.read(iprot);
65357
                  _elem202.read(iprot);
65360
                  this.success.add(_elem197);
65358
                  this.success.add(_elem202);
65361
                }
65359
                }
65362
                iprot.readListEnd();
65360
                iprot.readListEnd();
65363
              }
65361
              }
65364
            } else { 
65362
            } else { 
65365
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
65363
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 65387... Line 65385...
65387
 
65385
 
65388
      if (this.isSetSuccess()) {
65386
      if (this.isSetSuccess()) {
65389
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
65387
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
65390
        {
65388
        {
65391
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
65389
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
65392
          for (SourceItemPricing _iter198 : this.success)
65390
          for (SourceItemPricing _iter203 : this.success)
65393
          {
65391
          {
65394
            _iter198.write(oprot);
65392
            _iter203.write(oprot);
65395
          }
65393
          }
65396
          oprot.writeListEnd();
65394
          oprot.writeListEnd();
65397
        }
65395
        }
65398
        oprot.writeFieldEnd();
65396
        oprot.writeFieldEnd();
65399
      } else if (this.isSetCex()) {
65397
      } else if (this.isSetCex()) {
Line 66595... Line 66593...
66595
        }
66593
        }
66596
        switch (field.id) {
66594
        switch (field.id) {
66597
          case 1: // SEARCH_TERMS
66595
          case 1: // SEARCH_TERMS
66598
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
66596
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
66599
              {
66597
              {
66600
                org.apache.thrift.protocol.TList _list199 = iprot.readListBegin();
66598
                org.apache.thrift.protocol.TList _list204 = iprot.readListBegin();
66601
                this.searchTerms = new ArrayList<String>(_list199.size);
66599
                this.searchTerms = new ArrayList<String>(_list204.size);
66602
                for (int _i200 = 0; _i200 < _list199.size; ++_i200)
66600
                for (int _i205 = 0; _i205 < _list204.size; ++_i205)
66603
                {
66601
                {
66604
                  String _elem201; // required
66602
                  String _elem206; // required
66605
                  _elem201 = iprot.readString();
66603
                  _elem206 = iprot.readString();
66606
                  this.searchTerms.add(_elem201);
66604
                  this.searchTerms.add(_elem206);
66607
                }
66605
                }
66608
                iprot.readListEnd();
66606
                iprot.readListEnd();
66609
              }
66607
              }
66610
            } else { 
66608
            } else { 
66611
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
66609
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 66642... Line 66640...
66642
      oprot.writeStructBegin(STRUCT_DESC);
66640
      oprot.writeStructBegin(STRUCT_DESC);
66643
      if (this.searchTerms != null) {
66641
      if (this.searchTerms != null) {
66644
        oprot.writeFieldBegin(SEARCH_TERMS_FIELD_DESC);
66642
        oprot.writeFieldBegin(SEARCH_TERMS_FIELD_DESC);
66645
        {
66643
        {
66646
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerms.size()));
66644
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerms.size()));
66647
          for (String _iter202 : this.searchTerms)
66645
          for (String _iter207 : this.searchTerms)
66648
          {
66646
          {
66649
            oprot.writeString(_iter202);
66647
            oprot.writeString(_iter207);
66650
          }
66648
          }
66651
          oprot.writeListEnd();
66649
          oprot.writeListEnd();
66652
        }
66650
        }
66653
        oprot.writeFieldEnd();
66651
        oprot.writeFieldEnd();
66654
      }
66652
      }
Line 66956... Line 66954...
66956
        }
66954
        }
66957
        switch (field.id) {
66955
        switch (field.id) {
66958
          case 0: // SUCCESS
66956
          case 0: // SUCCESS
66959
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
66957
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
66960
              {
66958
              {
66961
                org.apache.thrift.protocol.TList _list203 = iprot.readListBegin();
66959
                org.apache.thrift.protocol.TList _list208 = iprot.readListBegin();
66962
                this.success = new ArrayList<Item>(_list203.size);
66960
                this.success = new ArrayList<Item>(_list208.size);
66963
                for (int _i204 = 0; _i204 < _list203.size; ++_i204)
66961
                for (int _i209 = 0; _i209 < _list208.size; ++_i209)
66964
                {
66962
                {
66965
                  Item _elem205; // required
66963
                  Item _elem210; // required
66966
                  _elem205 = new Item();
66964
                  _elem210 = new Item();
66967
                  _elem205.read(iprot);
66965
                  _elem210.read(iprot);
66968
                  this.success.add(_elem205);
66966
                  this.success.add(_elem210);
66969
                }
66967
                }
66970
                iprot.readListEnd();
66968
                iprot.readListEnd();
66971
              }
66969
              }
66972
            } else { 
66970
            } else { 
66973
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
66971
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 66987... Line 66985...
66987
 
66985
 
66988
      if (this.isSetSuccess()) {
66986
      if (this.isSetSuccess()) {
66989
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
66987
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
66990
        {
66988
        {
66991
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
66989
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
66992
          for (Item _iter206 : this.success)
66990
          for (Item _iter211 : this.success)
66993
          {
66991
          {
66994
            _iter206.write(oprot);
66992
            _iter211.write(oprot);
66995
          }
66993
          }
66996
          oprot.writeListEnd();
66994
          oprot.writeListEnd();
66997
        }
66995
        }
66998
        oprot.writeFieldEnd();
66996
        oprot.writeFieldEnd();
66999
      }
66997
      }
Line 67287... Line 67285...
67287
        }
67285
        }
67288
        switch (field.id) {
67286
        switch (field.id) {
67289
          case 1: // SEARCH_TERMS
67287
          case 1: // SEARCH_TERMS
67290
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
67288
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
67291
              {
67289
              {
67292
                org.apache.thrift.protocol.TList _list207 = iprot.readListBegin();
67290
                org.apache.thrift.protocol.TList _list212 = iprot.readListBegin();
67293
                this.searchTerms = new ArrayList<String>(_list207.size);
67291
                this.searchTerms = new ArrayList<String>(_list212.size);
67294
                for (int _i208 = 0; _i208 < _list207.size; ++_i208)
67292
                for (int _i213 = 0; _i213 < _list212.size; ++_i213)
67295
                {
67293
                {
67296
                  String _elem209; // required
67294
                  String _elem214; // required
67297
                  _elem209 = iprot.readString();
67295
                  _elem214 = iprot.readString();
67298
                  this.searchTerms.add(_elem209);
67296
                  this.searchTerms.add(_elem214);
67299
                }
67297
                }
67300
                iprot.readListEnd();
67298
                iprot.readListEnd();
67301
              }
67299
              }
67302
            } else { 
67300
            } else { 
67303
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
67301
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 67318... Line 67316...
67318
      oprot.writeStructBegin(STRUCT_DESC);
67316
      oprot.writeStructBegin(STRUCT_DESC);
67319
      if (this.searchTerms != null) {
67317
      if (this.searchTerms != null) {
67320
        oprot.writeFieldBegin(SEARCH_TERMS_FIELD_DESC);
67318
        oprot.writeFieldBegin(SEARCH_TERMS_FIELD_DESC);
67321
        {
67319
        {
67322
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerms.size()));
67320
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerms.size()));
67323
          for (String _iter210 : this.searchTerms)
67321
          for (String _iter215 : this.searchTerms)
67324
          {
67322
          {
67325
            oprot.writeString(_iter210);
67323
            oprot.writeString(_iter215);
67326
          }
67324
          }
67327
          oprot.writeListEnd();
67325
          oprot.writeListEnd();
67328
        }
67326
        }
67329
        oprot.writeFieldEnd();
67327
        oprot.writeFieldEnd();
67330
      }
67328
      }
Line 68205... Line 68203...
68205
        }
68203
        }
68206
        switch (field.id) {
68204
        switch (field.id) {
68207
          case 0: // SUCCESS
68205
          case 0: // SUCCESS
68208
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
68206
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
68209
              {
68207
              {
68210
                org.apache.thrift.protocol.TList _list211 = iprot.readListBegin();
68208
                org.apache.thrift.protocol.TList _list216 = iprot.readListBegin();
68211
                this.success = new ArrayList<ProductNotificationRequest>(_list211.size);
68209
                this.success = new ArrayList<ProductNotificationRequest>(_list216.size);
68212
                for (int _i212 = 0; _i212 < _list211.size; ++_i212)
68210
                for (int _i217 = 0; _i217 < _list216.size; ++_i217)
68213
                {
68211
                {
68214
                  ProductNotificationRequest _elem213; // required
68212
                  ProductNotificationRequest _elem218; // required
68215
                  _elem213 = new ProductNotificationRequest();
68213
                  _elem218 = new ProductNotificationRequest();
68216
                  _elem213.read(iprot);
68214
                  _elem218.read(iprot);
68217
                  this.success.add(_elem213);
68215
                  this.success.add(_elem218);
68218
                }
68216
                }
68219
                iprot.readListEnd();
68217
                iprot.readListEnd();
68220
              }
68218
              }
68221
            } else { 
68219
            } else { 
68222
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
68220
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 68236... Line 68234...
68236
 
68234
 
68237
      if (this.isSetSuccess()) {
68235
      if (this.isSetSuccess()) {
68238
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
68236
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
68239
        {
68237
        {
68240
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
68238
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
68241
          for (ProductNotificationRequest _iter214 : this.success)
68239
          for (ProductNotificationRequest _iter219 : this.success)
68242
          {
68240
          {
68243
            _iter214.write(oprot);
68241
            _iter219.write(oprot);
68244
          }
68242
          }
68245
          oprot.writeListEnd();
68243
          oprot.writeListEnd();
68246
        }
68244
        }
68247
        oprot.writeFieldEnd();
68245
        oprot.writeFieldEnd();
68248
      }
68246
      }
Line 68913... Line 68911...
68913
        }
68911
        }
68914
        switch (field.id) {
68912
        switch (field.id) {
68915
          case 0: // SUCCESS
68913
          case 0: // SUCCESS
68916
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
68914
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
68917
              {
68915
              {
68918
                org.apache.thrift.protocol.TList _list215 = iprot.readListBegin();
68916
                org.apache.thrift.protocol.TList _list220 = iprot.readListBegin();
68919
                this.success = new ArrayList<ProductNotificationRequestCount>(_list215.size);
68917
                this.success = new ArrayList<ProductNotificationRequestCount>(_list220.size);
68920
                for (int _i216 = 0; _i216 < _list215.size; ++_i216)
68918
                for (int _i221 = 0; _i221 < _list220.size; ++_i221)
68921
                {
68919
                {
68922
                  ProductNotificationRequestCount _elem217; // required
68920
                  ProductNotificationRequestCount _elem222; // required
68923
                  _elem217 = new ProductNotificationRequestCount();
68921
                  _elem222 = new ProductNotificationRequestCount();
68924
                  _elem217.read(iprot);
68922
                  _elem222.read(iprot);
68925
                  this.success.add(_elem217);
68923
                  this.success.add(_elem222);
68926
                }
68924
                }
68927
                iprot.readListEnd();
68925
                iprot.readListEnd();
68928
              }
68926
              }
68929
            } else { 
68927
            } else { 
68930
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
68928
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 68944... Line 68942...
68944
 
68942
 
68945
      if (this.isSetSuccess()) {
68943
      if (this.isSetSuccess()) {
68946
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
68944
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
68947
        {
68945
        {
68948
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
68946
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
68949
          for (ProductNotificationRequestCount _iter218 : this.success)
68947
          for (ProductNotificationRequestCount _iter223 : this.success)
68950
          {
68948
          {
68951
            _iter218.write(oprot);
68949
            _iter223.write(oprot);
68952
          }
68950
          }
68953
          oprot.writeListEnd();
68951
          oprot.writeListEnd();
68954
        }
68952
        }
68955
        oprot.writeFieldEnd();
68953
        oprot.writeFieldEnd();
68956
      }
68954
      }
Line 72656... Line 72654...
72656
        }
72654
        }
72657
        switch (field.id) {
72655
        switch (field.id) {
72658
          case 0: // SUCCESS
72656
          case 0: // SUCCESS
72659
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
72657
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
72660
              {
72658
              {
72661
                org.apache.thrift.protocol.TList _list219 = iprot.readListBegin();
72659
                org.apache.thrift.protocol.TList _list224 = iprot.readListBegin();
72662
                this.success = new ArrayList<VoucherItemMapping>(_list219.size);
72660
                this.success = new ArrayList<VoucherItemMapping>(_list224.size);
72663
                for (int _i220 = 0; _i220 < _list219.size; ++_i220)
72661
                for (int _i225 = 0; _i225 < _list224.size; ++_i225)
72664
                {
72662
                {
72665
                  VoucherItemMapping _elem221; // required
72663
                  VoucherItemMapping _elem226; // required
72666
                  _elem221 = new VoucherItemMapping();
72664
                  _elem226 = new VoucherItemMapping();
72667
                  _elem221.read(iprot);
72665
                  _elem226.read(iprot);
72668
                  this.success.add(_elem221);
72666
                  this.success.add(_elem226);
72669
                }
72667
                }
72670
                iprot.readListEnd();
72668
                iprot.readListEnd();
72671
              }
72669
              }
72672
            } else { 
72670
            } else { 
72673
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
72671
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 72687... Line 72685...
72687
 
72685
 
72688
      if (this.isSetSuccess()) {
72686
      if (this.isSetSuccess()) {
72689
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
72687
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
72690
        {
72688
        {
72691
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
72689
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
72692
          for (VoucherItemMapping _iter222 : this.success)
72690
          for (VoucherItemMapping _iter227 : this.success)
72693
          {
72691
          {
72694
            _iter222.write(oprot);
72692
            _iter227.write(oprot);
72695
          }
72693
          }
72696
          oprot.writeListEnd();
72694
          oprot.writeListEnd();
72697
        }
72695
        }
72698
        oprot.writeFieldEnd();
72696
        oprot.writeFieldEnd();
72699
      }
72697
      }
Line 75462... Line 75460...
75462
        }
75460
        }
75463
        switch (field.id) {
75461
        switch (field.id) {
75464
          case 0: // SUCCESS
75462
          case 0: // SUCCESS
75465
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
75463
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
75466
              {
75464
              {
75467
                org.apache.thrift.protocol.TList _list223 = iprot.readListBegin();
75465
                org.apache.thrift.protocol.TList _list228 = iprot.readListBegin();
75468
                this.success = new ArrayList<Item>(_list223.size);
75466
                this.success = new ArrayList<Item>(_list228.size);
75469
                for (int _i224 = 0; _i224 < _list223.size; ++_i224)
75467
                for (int _i229 = 0; _i229 < _list228.size; ++_i229)
75470
                {
75468
                {
75471
                  Item _elem225; // required
75469
                  Item _elem230; // required
75472
                  _elem225 = new Item();
75470
                  _elem230 = new Item();
75473
                  _elem225.read(iprot);
75471
                  _elem230.read(iprot);
75474
                  this.success.add(_elem225);
75472
                  this.success.add(_elem230);
75475
                }
75473
                }
75476
                iprot.readListEnd();
75474
                iprot.readListEnd();
75477
              }
75475
              }
75478
            } else { 
75476
            } else { 
75479
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
75477
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 75493... Line 75491...
75493
 
75491
 
75494
      if (this.isSetSuccess()) {
75492
      if (this.isSetSuccess()) {
75495
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
75493
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
75496
        {
75494
        {
75497
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
75495
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
75498
          for (Item _iter226 : this.success)
75496
          for (Item _iter231 : this.success)
75499
          {
75497
          {
75500
            _iter226.write(oprot);
75498
            _iter231.write(oprot);
75501
          }
75499
          }
75502
          oprot.writeListEnd();
75500
          oprot.writeListEnd();
75503
        }
75501
        }
75504
        oprot.writeFieldEnd();
75502
        oprot.writeFieldEnd();
75505
      }
75503
      }
Line 75993... Line 75991...
75993
        }
75991
        }
75994
        switch (field.id) {
75992
        switch (field.id) {
75995
          case 0: // SUCCESS
75993
          case 0: // SUCCESS
75996
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
75994
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
75997
              {
75995
              {
75998
                org.apache.thrift.protocol.TList _list227 = iprot.readListBegin();
75996
                org.apache.thrift.protocol.TList _list232 = iprot.readListBegin();
75999
                this.success = new ArrayList<Item>(_list227.size);
75997
                this.success = new ArrayList<Item>(_list232.size);
76000
                for (int _i228 = 0; _i228 < _list227.size; ++_i228)
75998
                for (int _i233 = 0; _i233 < _list232.size; ++_i233)
76001
                {
75999
                {
76002
                  Item _elem229; // required
76000
                  Item _elem234; // required
76003
                  _elem229 = new Item();
76001
                  _elem234 = new Item();
76004
                  _elem229.read(iprot);
76002
                  _elem234.read(iprot);
76005
                  this.success.add(_elem229);
76003
                  this.success.add(_elem234);
76006
                }
76004
                }
76007
                iprot.readListEnd();
76005
                iprot.readListEnd();
76008
              }
76006
              }
76009
            } else { 
76007
            } else { 
76010
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
76008
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 76024... Line 76022...
76024
 
76022
 
76025
      if (this.isSetSuccess()) {
76023
      if (this.isSetSuccess()) {
76026
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
76024
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
76027
        {
76025
        {
76028
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
76026
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
76029
          for (Item _iter230 : this.success)
76027
          for (Item _iter235 : this.success)
76030
          {
76028
          {
76031
            _iter230.write(oprot);
76029
            _iter235.write(oprot);
76032
          }
76030
          }
76033
          oprot.writeListEnd();
76031
          oprot.writeListEnd();
76034
        }
76032
        }
76035
        oprot.writeFieldEnd();
76033
        oprot.writeFieldEnd();
76036
      }
76034
      }
Line 77946... Line 77944...
77946
        }
77944
        }
77947
        switch (field.id) {
77945
        switch (field.id) {
77948
          case 0: // SUCCESS
77946
          case 0: // SUCCESS
77949
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
77947
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
77950
              {
77948
              {
77951
                org.apache.thrift.protocol.TList _list231 = iprot.readListBegin();
77949
                org.apache.thrift.protocol.TList _list236 = iprot.readListBegin();
77952
                this.success = new ArrayList<Insurer>(_list231.size);
77950
                this.success = new ArrayList<Insurer>(_list236.size);
77953
                for (int _i232 = 0; _i232 < _list231.size; ++_i232)
77951
                for (int _i237 = 0; _i237 < _list236.size; ++_i237)
77954
                {
77952
                {
77955
                  Insurer _elem233; // required
77953
                  Insurer _elem238; // required
77956
                  _elem233 = new Insurer();
77954
                  _elem238 = new Insurer();
77957
                  _elem233.read(iprot);
77955
                  _elem238.read(iprot);
77958
                  this.success.add(_elem233);
77956
                  this.success.add(_elem238);
77959
                }
77957
                }
77960
                iprot.readListEnd();
77958
                iprot.readListEnd();
77961
              }
77959
              }
77962
            } else { 
77960
            } else { 
77963
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
77961
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 77977... Line 77975...
77977
 
77975
 
77978
      if (this.isSetSuccess()) {
77976
      if (this.isSetSuccess()) {
77979
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
77977
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
77980
        {
77978
        {
77981
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
77979
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
77982
          for (Insurer _iter234 : this.success)
77980
          for (Insurer _iter239 : this.success)
77983
          {
77981
          {
77984
            _iter234.write(oprot);
77982
            _iter239.write(oprot);
77985
          }
77983
          }
77986
          oprot.writeListEnd();
77984
          oprot.writeListEnd();
77987
        }
77985
        }
77988
        oprot.writeFieldEnd();
77986
        oprot.writeFieldEnd();
77989
      }
77987
      }
Line 80633... Line 80631...
80633
        }
80631
        }
80634
        switch (field.id) {
80632
        switch (field.id) {
80635
          case 0: // SUCCESS
80633
          case 0: // SUCCESS
80636
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
80634
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
80637
              {
80635
              {
80638
                org.apache.thrift.protocol.TMap _map235 = iprot.readMapBegin();
80636
                org.apache.thrift.protocol.TMap _map240 = iprot.readMapBegin();
80639
                this.success = new HashMap<String,BrandInfo>(2*_map235.size);
80637
                this.success = new HashMap<String,BrandInfo>(2*_map240.size);
80640
                for (int _i236 = 0; _i236 < _map235.size; ++_i236)
80638
                for (int _i241 = 0; _i241 < _map240.size; ++_i241)
80641
                {
80639
                {
80642
                  String _key237; // required
80640
                  String _key242; // required
80643
                  BrandInfo _val238; // required
80641
                  BrandInfo _val243; // required
80644
                  _key237 = iprot.readString();
80642
                  _key242 = iprot.readString();
80645
                  _val238 = new BrandInfo();
80643
                  _val243 = new BrandInfo();
80646
                  _val238.read(iprot);
80644
                  _val243.read(iprot);
80647
                  this.success.put(_key237, _val238);
80645
                  this.success.put(_key242, _val243);
80648
                }
80646
                }
80649
                iprot.readMapEnd();
80647
                iprot.readMapEnd();
80650
              }
80648
              }
80651
            } else { 
80649
            } else { 
80652
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
80650
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 80666... Line 80664...
80666
 
80664
 
80667
      if (this.isSetSuccess()) {
80665
      if (this.isSetSuccess()) {
80668
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
80666
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
80669
        {
80667
        {
80670
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
80668
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
80671
          for (Map.Entry<String, BrandInfo> _iter239 : this.success.entrySet())
80669
          for (Map.Entry<String, BrandInfo> _iter244 : this.success.entrySet())
80672
          {
80670
          {
80673
            oprot.writeString(_iter239.getKey());
80671
            oprot.writeString(_iter244.getKey());
80674
            _iter239.getValue().write(oprot);
80672
            _iter244.getValue().write(oprot);
80675
          }
80673
          }
80676
          oprot.writeMapEnd();
80674
          oprot.writeMapEnd();
80677
        }
80675
        }
80678
        oprot.writeFieldEnd();
80676
        oprot.writeFieldEnd();
80679
      }
80677
      }
Line 81555... Line 81553...
81555
        }
81553
        }
81556
        switch (field.id) {
81554
        switch (field.id) {
81557
          case 1: // ITEM_IDS
81555
          case 1: // ITEM_IDS
81558
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
81556
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
81559
              {
81557
              {
81560
                org.apache.thrift.protocol.TList _list240 = iprot.readListBegin();
81558
                org.apache.thrift.protocol.TList _list245 = iprot.readListBegin();
81561
                this.itemIds = new ArrayList<Long>(_list240.size);
81559
                this.itemIds = new ArrayList<Long>(_list245.size);
81562
                for (int _i241 = 0; _i241 < _list240.size; ++_i241)
81560
                for (int _i246 = 0; _i246 < _list245.size; ++_i246)
81563
                {
81561
                {
81564
                  long _elem242; // required
81562
                  long _elem247; // required
81565
                  _elem242 = iprot.readI64();
81563
                  _elem247 = iprot.readI64();
81566
                  this.itemIds.add(_elem242);
81564
                  this.itemIds.add(_elem247);
81567
                }
81565
                }
81568
                iprot.readListEnd();
81566
                iprot.readListEnd();
81569
              }
81567
              }
81570
            } else { 
81568
            } else { 
81571
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
81569
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 81586... Line 81584...
81586
      oprot.writeStructBegin(STRUCT_DESC);
81584
      oprot.writeStructBegin(STRUCT_DESC);
81587
      if (this.itemIds != null) {
81585
      if (this.itemIds != null) {
81588
        oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
81586
        oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
81589
        {
81587
        {
81590
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.itemIds.size()));
81588
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.itemIds.size()));
81591
          for (long _iter243 : this.itemIds)
81589
          for (long _iter248 : this.itemIds)
81592
          {
81590
          {
81593
            oprot.writeI64(_iter243);
81591
            oprot.writeI64(_iter248);
81594
          }
81592
          }
81595
          oprot.writeListEnd();
81593
          oprot.writeListEnd();
81596
        }
81594
        }
81597
        oprot.writeFieldEnd();
81595
        oprot.writeFieldEnd();
81598
      }
81596
      }
Line 81886... Line 81884...
81886
        }
81884
        }
81887
        switch (field.id) {
81885
        switch (field.id) {
81888
          case 0: // SUCCESS
81886
          case 0: // SUCCESS
81889
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
81887
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
81890
              {
81888
              {
81891
                org.apache.thrift.protocol.TList _list244 = iprot.readListBegin();
81889
                org.apache.thrift.protocol.TList _list249 = iprot.readListBegin();
81892
                this.success = new ArrayList<StorePricing>(_list244.size);
81890
                this.success = new ArrayList<StorePricing>(_list249.size);
81893
                for (int _i245 = 0; _i245 < _list244.size; ++_i245)
81891
                for (int _i250 = 0; _i250 < _list249.size; ++_i250)
81894
                {
81892
                {
81895
                  StorePricing _elem246; // required
81893
                  StorePricing _elem251; // required
81896
                  _elem246 = new StorePricing();
81894
                  _elem251 = new StorePricing();
81897
                  _elem246.read(iprot);
81895
                  _elem251.read(iprot);
81898
                  this.success.add(_elem246);
81896
                  this.success.add(_elem251);
81899
                }
81897
                }
81900
                iprot.readListEnd();
81898
                iprot.readListEnd();
81901
              }
81899
              }
81902
            } else { 
81900
            } else { 
81903
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
81901
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 81917... Line 81915...
81917
 
81915
 
81918
      if (this.isSetSuccess()) {
81916
      if (this.isSetSuccess()) {
81919
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
81917
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
81920
        {
81918
        {
81921
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
81919
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
81922
          for (StorePricing _iter247 : this.success)
81920
          for (StorePricing _iter252 : this.success)
81923
          {
81921
          {
81924
            _iter247.write(oprot);
81922
            _iter252.write(oprot);
81925
          }
81923
          }
81926
          oprot.writeListEnd();
81924
          oprot.writeListEnd();
81927
        }
81925
        }
81928
        oprot.writeFieldEnd();
81926
        oprot.writeFieldEnd();
81929
      }
81927
      }
Line 82999... Line 82997...
82999
        }
82997
        }
83000
        switch (field.id) {
82998
        switch (field.id) {
83001
          case 0: // SUCCESS
82999
          case 0: // SUCCESS
83002
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
83000
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
83003
              {
83001
              {
83004
                org.apache.thrift.protocol.TList _list248 = iprot.readListBegin();
83002
                org.apache.thrift.protocol.TList _list253 = iprot.readListBegin();
83005
                this.success = new ArrayList<Amazonlisted>(_list248.size);
83003
                this.success = new ArrayList<Amazonlisted>(_list253.size);
83006
                for (int _i249 = 0; _i249 < _list248.size; ++_i249)
83004
                for (int _i254 = 0; _i254 < _list253.size; ++_i254)
83007
                {
83005
                {
83008
                  Amazonlisted _elem250; // required
83006
                  Amazonlisted _elem255; // required
83009
                  _elem250 = new Amazonlisted();
83007
                  _elem255 = new Amazonlisted();
83010
                  _elem250.read(iprot);
83008
                  _elem255.read(iprot);
83011
                  this.success.add(_elem250);
83009
                  this.success.add(_elem255);
83012
                }
83010
                }
83013
                iprot.readListEnd();
83011
                iprot.readListEnd();
83014
              }
83012
              }
83015
            } else { 
83013
            } else { 
83016
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
83014
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 83030... Line 83028...
83030
 
83028
 
83031
      if (this.isSetSuccess()) {
83029
      if (this.isSetSuccess()) {
83032
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
83030
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
83033
        {
83031
        {
83034
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
83032
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
83035
          for (Amazonlisted _iter251 : this.success)
83033
          for (Amazonlisted _iter256 : this.success)
83036
          {
83034
          {
83037
            _iter251.write(oprot);
83035
            _iter256.write(oprot);
83038
          }
83036
          }
83039
          oprot.writeListEnd();
83037
          oprot.writeListEnd();
83040
        }
83038
        }
83041
        oprot.writeFieldEnd();
83039
        oprot.writeFieldEnd();
83042
      }
83040
      }
Line 83469... Line 83467...
83469
        }
83467
        }
83470
        switch (field.id) {
83468
        switch (field.id) {
83471
          case 1: // SEARCH_TERM
83469
          case 1: // SEARCH_TERM
83472
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
83470
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
83473
              {
83471
              {
83474
                org.apache.thrift.protocol.TList _list252 = iprot.readListBegin();
83472
                org.apache.thrift.protocol.TList _list257 = iprot.readListBegin();
83475
                this.searchTerm = new ArrayList<String>(_list252.size);
83473
                this.searchTerm = new ArrayList<String>(_list257.size);
83476
                for (int _i253 = 0; _i253 < _list252.size; ++_i253)
83474
                for (int _i258 = 0; _i258 < _list257.size; ++_i258)
83477
                {
83475
                {
83478
                  String _elem254; // required
83476
                  String _elem259; // required
83479
                  _elem254 = iprot.readString();
83477
                  _elem259 = iprot.readString();
83480
                  this.searchTerm.add(_elem254);
83478
                  this.searchTerm.add(_elem259);
83481
                }
83479
                }
83482
                iprot.readListEnd();
83480
                iprot.readListEnd();
83483
              }
83481
              }
83484
            } else { 
83482
            } else { 
83485
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
83483
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 83516... Line 83514...
83516
      oprot.writeStructBegin(STRUCT_DESC);
83514
      oprot.writeStructBegin(STRUCT_DESC);
83517
      if (this.searchTerm != null) {
83515
      if (this.searchTerm != null) {
83518
        oprot.writeFieldBegin(SEARCH_TERM_FIELD_DESC);
83516
        oprot.writeFieldBegin(SEARCH_TERM_FIELD_DESC);
83519
        {
83517
        {
83520
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerm.size()));
83518
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerm.size()));
83521
          for (String _iter255 : this.searchTerm)
83519
          for (String _iter260 : this.searchTerm)
83522
          {
83520
          {
83523
            oprot.writeString(_iter255);
83521
            oprot.writeString(_iter260);
83524
          }
83522
          }
83525
          oprot.writeListEnd();
83523
          oprot.writeListEnd();
83526
        }
83524
        }
83527
        oprot.writeFieldEnd();
83525
        oprot.writeFieldEnd();
83528
      }
83526
      }
Line 83832... Line 83830...
83832
        }
83830
        }
83833
        switch (field.id) {
83831
        switch (field.id) {
83834
          case 0: // SUCCESS
83832
          case 0: // SUCCESS
83835
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
83833
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
83836
              {
83834
              {
83837
                org.apache.thrift.protocol.TList _list256 = iprot.readListBegin();
83835
                org.apache.thrift.protocol.TList _list261 = iprot.readListBegin();
83838
                this.success = new ArrayList<Amazonlisted>(_list256.size);
83836
                this.success = new ArrayList<Amazonlisted>(_list261.size);
83839
                for (int _i257 = 0; _i257 < _list256.size; ++_i257)
83837
                for (int _i262 = 0; _i262 < _list261.size; ++_i262)
83840
                {
83838
                {
83841
                  Amazonlisted _elem258; // required
83839
                  Amazonlisted _elem263; // required
83842
                  _elem258 = new Amazonlisted();
83840
                  _elem263 = new Amazonlisted();
83843
                  _elem258.read(iprot);
83841
                  _elem263.read(iprot);
83844
                  this.success.add(_elem258);
83842
                  this.success.add(_elem263);
83845
                }
83843
                }
83846
                iprot.readListEnd();
83844
                iprot.readListEnd();
83847
              }
83845
              }
83848
            } else { 
83846
            } else { 
83849
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
83847
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 83863... Line 83861...
83863
 
83861
 
83864
      if (this.isSetSuccess()) {
83862
      if (this.isSetSuccess()) {
83865
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
83863
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
83866
        {
83864
        {
83867
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
83865
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
83868
          for (Amazonlisted _iter259 : this.success)
83866
          for (Amazonlisted _iter264 : this.success)
83869
          {
83867
          {
83870
            _iter259.write(oprot);
83868
            _iter264.write(oprot);
83871
          }
83869
          }
83872
          oprot.writeListEnd();
83870
          oprot.writeListEnd();
83873
        }
83871
        }
83874
        oprot.writeFieldEnd();
83872
        oprot.writeFieldEnd();
83875
      }
83873
      }
Line 84163... Line 84161...
84163
        }
84161
        }
84164
        switch (field.id) {
84162
        switch (field.id) {
84165
          case 1: // SEARCH_TERM
84163
          case 1: // SEARCH_TERM
84166
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
84164
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
84167
              {
84165
              {
84168
                org.apache.thrift.protocol.TList _list260 = iprot.readListBegin();
84166
                org.apache.thrift.protocol.TList _list265 = iprot.readListBegin();
84169
                this.searchTerm = new ArrayList<String>(_list260.size);
84167
                this.searchTerm = new ArrayList<String>(_list265.size);
84170
                for (int _i261 = 0; _i261 < _list260.size; ++_i261)
84168
                for (int _i266 = 0; _i266 < _list265.size; ++_i266)
84171
                {
84169
                {
84172
                  String _elem262; // required
84170
                  String _elem267; // required
84173
                  _elem262 = iprot.readString();
84171
                  _elem267 = iprot.readString();
84174
                  this.searchTerm.add(_elem262);
84172
                  this.searchTerm.add(_elem267);
84175
                }
84173
                }
84176
                iprot.readListEnd();
84174
                iprot.readListEnd();
84177
              }
84175
              }
84178
            } else { 
84176
            } else { 
84179
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
84177
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 84194... Line 84192...
84194
      oprot.writeStructBegin(STRUCT_DESC);
84192
      oprot.writeStructBegin(STRUCT_DESC);
84195
      if (this.searchTerm != null) {
84193
      if (this.searchTerm != null) {
84196
        oprot.writeFieldBegin(SEARCH_TERM_FIELD_DESC);
84194
        oprot.writeFieldBegin(SEARCH_TERM_FIELD_DESC);
84197
        {
84195
        {
84198
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerm.size()));
84196
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerm.size()));
84199
          for (String _iter263 : this.searchTerm)
84197
          for (String _iter268 : this.searchTerm)
84200
          {
84198
          {
84201
            oprot.writeString(_iter263);
84199
            oprot.writeString(_iter268);
84202
          }
84200
          }
84203
          oprot.writeListEnd();
84201
          oprot.writeListEnd();
84204
        }
84202
        }
84205
        oprot.writeFieldEnd();
84203
        oprot.writeFieldEnd();
84206
      }
84204
      }
Line 87056... Line 87054...
87056
        }
87054
        }
87057
        switch (field.id) {
87055
        switch (field.id) {
87058
          case 0: // SUCCESS
87056
          case 0: // SUCCESS
87059
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
87057
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
87060
              {
87058
              {
87061
                org.apache.thrift.protocol.TList _list264 = iprot.readListBegin();
87059
                org.apache.thrift.protocol.TList _list269 = iprot.readListBegin();
87062
                this.success = new ArrayList<Item>(_list264.size);
87060
                this.success = new ArrayList<Item>(_list269.size);
87063
                for (int _i265 = 0; _i265 < _list264.size; ++_i265)
87061
                for (int _i270 = 0; _i270 < _list269.size; ++_i270)
87064
                {
87062
                {
87065
                  Item _elem266; // required
87063
                  Item _elem271; // required
87066
                  _elem266 = new Item();
87064
                  _elem271 = new Item();
87067
                  _elem266.read(iprot);
87065
                  _elem271.read(iprot);
87068
                  this.success.add(_elem266);
87066
                  this.success.add(_elem271);
87069
                }
87067
                }
87070
                iprot.readListEnd();
87068
                iprot.readListEnd();
87071
              }
87069
              }
87072
            } else { 
87070
            } else { 
87073
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
87071
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 87087... Line 87085...
87087
 
87085
 
87088
      if (this.isSetSuccess()) {
87086
      if (this.isSetSuccess()) {
87089
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
87087
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
87090
        {
87088
        {
87091
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
87089
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
87092
          for (Item _iter267 : this.success)
87090
          for (Item _iter272 : this.success)
87093
          {
87091
          {
87094
            _iter267.write(oprot);
87092
            _iter272.write(oprot);
87095
          }
87093
          }
87096
          oprot.writeListEnd();
87094
          oprot.writeListEnd();
87097
        }
87095
        }
87098
        oprot.writeFieldEnd();
87096
        oprot.writeFieldEnd();
87099
      }
87097
      }
Line 87587... Line 87585...
87587
        }
87585
        }
87588
        switch (field.id) {
87586
        switch (field.id) {
87589
          case 0: // SUCCESS
87587
          case 0: // SUCCESS
87590
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
87588
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
87591
              {
87589
              {
87592
                org.apache.thrift.protocol.TList _list268 = iprot.readListBegin();
87590
                org.apache.thrift.protocol.TList _list273 = iprot.readListBegin();
87593
                this.success = new ArrayList<Amazonlisted>(_list268.size);
87591
                this.success = new ArrayList<Amazonlisted>(_list273.size);
87594
                for (int _i269 = 0; _i269 < _list268.size; ++_i269)
87592
                for (int _i274 = 0; _i274 < _list273.size; ++_i274)
87595
                {
87593
                {
87596
                  Amazonlisted _elem270; // required
87594
                  Amazonlisted _elem275; // required
87597
                  _elem270 = new Amazonlisted();
87595
                  _elem275 = new Amazonlisted();
87598
                  _elem270.read(iprot);
87596
                  _elem275.read(iprot);
87599
                  this.success.add(_elem270);
87597
                  this.success.add(_elem275);
87600
                }
87598
                }
87601
                iprot.readListEnd();
87599
                iprot.readListEnd();
87602
              }
87600
              }
87603
            } else { 
87601
            } else { 
87604
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
87602
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 87618... Line 87616...
87618
 
87616
 
87619
      if (this.isSetSuccess()) {
87617
      if (this.isSetSuccess()) {
87620
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
87618
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
87621
        {
87619
        {
87622
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
87620
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
87623
          for (Amazonlisted _iter271 : this.success)
87621
          for (Amazonlisted _iter276 : this.success)
87624
          {
87622
          {
87625
            _iter271.write(oprot);
87623
            _iter276.write(oprot);
87626
          }
87624
          }
87627
          oprot.writeListEnd();
87625
          oprot.writeListEnd();
87628
        }
87626
        }
87629
        oprot.writeFieldEnd();
87627
        oprot.writeFieldEnd();
87630
      }
87628
      }
Line 88118... Line 88116...
88118
        }
88116
        }
88119
        switch (field.id) {
88117
        switch (field.id) {
88120
          case 0: // SUCCESS
88118
          case 0: // SUCCESS
88121
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
88119
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
88122
              {
88120
              {
88123
                org.apache.thrift.protocol.TList _list272 = iprot.readListBegin();
88121
                org.apache.thrift.protocol.TList _list277 = iprot.readListBegin();
88124
                this.success = new ArrayList<Amazonlisted>(_list272.size);
88122
                this.success = new ArrayList<Amazonlisted>(_list277.size);
88125
                for (int _i273 = 0; _i273 < _list272.size; ++_i273)
88123
                for (int _i278 = 0; _i278 < _list277.size; ++_i278)
88126
                {
88124
                {
88127
                  Amazonlisted _elem274; // required
88125
                  Amazonlisted _elem279; // required
88128
                  _elem274 = new Amazonlisted();
88126
                  _elem279 = new Amazonlisted();
88129
                  _elem274.read(iprot);
88127
                  _elem279.read(iprot);
88130
                  this.success.add(_elem274);
88128
                  this.success.add(_elem279);
88131
                }
88129
                }
88132
                iprot.readListEnd();
88130
                iprot.readListEnd();
88133
              }
88131
              }
88134
            } else { 
88132
            } else { 
88135
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
88133
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 88149... Line 88147...
88149
 
88147
 
88150
      if (this.isSetSuccess()) {
88148
      if (this.isSetSuccess()) {
88151
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
88149
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
88152
        {
88150
        {
88153
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
88151
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
88154
          for (Amazonlisted _iter275 : this.success)
88152
          for (Amazonlisted _iter280 : this.success)
88155
          {
88153
          {
88156
            _iter275.write(oprot);
88154
            _iter280.write(oprot);
88157
          }
88155
          }
88158
          oprot.writeListEnd();
88156
          oprot.writeListEnd();
88159
        }
88157
        }
88160
        oprot.writeFieldEnd();
88158
        oprot.writeFieldEnd();
88161
      }
88159
      }
Line 89348... Line 89346...
89348
            }
89346
            }
89349
            break;
89347
            break;
89350
          case 2: // SKU
89348
          case 2: // SKU
89351
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
89349
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
89352
              {
89350
              {
89353
                org.apache.thrift.protocol.TList _list276 = iprot.readListBegin();
89351
                org.apache.thrift.protocol.TList _list281 = iprot.readListBegin();
89354
                this.sku = new ArrayList<Long>(_list276.size);
89352
                this.sku = new ArrayList<Long>(_list281.size);
89355
                for (int _i277 = 0; _i277 < _list276.size; ++_i277)
89353
                for (int _i282 = 0; _i282 < _list281.size; ++_i282)
89356
                {
89354
                {
89357
                  long _elem278; // required
89355
                  long _elem283; // required
89358
                  _elem278 = iprot.readI64();
89356
                  _elem283 = iprot.readI64();
89359
                  this.sku.add(_elem278);
89357
                  this.sku.add(_elem283);
89360
                }
89358
                }
89361
                iprot.readListEnd();
89359
                iprot.readListEnd();
89362
              }
89360
              }
89363
            } else { 
89361
            } else { 
89364
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
89362
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 89392... Line 89390...
89392
      }
89390
      }
89393
      if (this.sku != null) {
89391
      if (this.sku != null) {
89394
        oprot.writeFieldBegin(SKU_FIELD_DESC);
89392
        oprot.writeFieldBegin(SKU_FIELD_DESC);
89395
        {
89393
        {
89396
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.sku.size()));
89394
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.sku.size()));
89397
          for (long _iter279 : this.sku)
89395
          for (long _iter284 : this.sku)
89398
          {
89396
          {
89399
            oprot.writeI64(_iter279);
89397
            oprot.writeI64(_iter284);
89400
          }
89398
          }
89401
          oprot.writeListEnd();
89399
          oprot.writeListEnd();
89402
        }
89400
        }
89403
        oprot.writeFieldEnd();
89401
        oprot.writeFieldEnd();
89404
      }
89402
      }
Line 90202... Line 90200...
90202
        }
90200
        }
90203
        switch (field.id) {
90201
        switch (field.id) {
90204
          case 0: // SUCCESS
90202
          case 0: // SUCCESS
90205
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
90203
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
90206
              {
90204
              {
90207
                org.apache.thrift.protocol.TList _list280 = iprot.readListBegin();
90205
                org.apache.thrift.protocol.TList _list285 = iprot.readListBegin();
90208
                this.success = new ArrayList<Category>(_list280.size);
90206
                this.success = new ArrayList<Category>(_list285.size);
90209
                for (int _i281 = 0; _i281 < _list280.size; ++_i281)
90207
                for (int _i286 = 0; _i286 < _list285.size; ++_i286)
90210
                {
90208
                {
90211
                  Category _elem282; // required
90209
                  Category _elem287; // required
90212
                  _elem282 = new Category();
90210
                  _elem287 = new Category();
90213
                  _elem282.read(iprot);
90211
                  _elem287.read(iprot);
90214
                  this.success.add(_elem282);
90212
                  this.success.add(_elem287);
90215
                }
90213
                }
90216
                iprot.readListEnd();
90214
                iprot.readListEnd();
90217
              }
90215
              }
90218
            } else { 
90216
            } else { 
90219
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
90217
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 90233... Line 90231...
90233
 
90231
 
90234
      if (this.isSetSuccess()) {
90232
      if (this.isSetSuccess()) {
90235
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
90233
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
90236
        {
90234
        {
90237
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
90235
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
90238
          for (Category _iter283 : this.success)
90236
          for (Category _iter288 : this.success)
90239
          {
90237
          {
90240
            _iter283.write(oprot);
90238
            _iter288.write(oprot);
90241
          }
90239
          }
90242
          oprot.writeListEnd();
90240
          oprot.writeListEnd();
90243
        }
90241
        }
90244
        oprot.writeFieldEnd();
90242
        oprot.writeFieldEnd();
90245
      }
90243
      }
Line 93474... Line 93472...
93474
        }
93472
        }
93475
        switch (field.id) {
93473
        switch (field.id) {
93476
          case 0: // SUCCESS
93474
          case 0: // SUCCESS
93477
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
93475
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
93478
              {
93476
              {
93479
                org.apache.thrift.protocol.TList _list284 = iprot.readListBegin();
93477
                org.apache.thrift.protocol.TList _list289 = iprot.readListBegin();
93480
                this.success = new ArrayList<Amazonlisted>(_list284.size);
93478
                this.success = new ArrayList<Amazonlisted>(_list289.size);
93481
                for (int _i285 = 0; _i285 < _list284.size; ++_i285)
93479
                for (int _i290 = 0; _i290 < _list289.size; ++_i290)
93482
                {
93480
                {
93483
                  Amazonlisted _elem286; // required
93481
                  Amazonlisted _elem291; // required
93484
                  _elem286 = new Amazonlisted();
93482
                  _elem291 = new Amazonlisted();
93485
                  _elem286.read(iprot);
93483
                  _elem291.read(iprot);
93486
                  this.success.add(_elem286);
93484
                  this.success.add(_elem291);
93487
                }
93485
                }
93488
                iprot.readListEnd();
93486
                iprot.readListEnd();
93489
              }
93487
              }
93490
            } else { 
93488
            } else { 
93491
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
93489
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 93505... Line 93503...
93505
 
93503
 
93506
      if (this.isSetSuccess()) {
93504
      if (this.isSetSuccess()) {
93507
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
93505
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
93508
        {
93506
        {
93509
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
93507
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
93510
          for (Amazonlisted _iter287 : this.success)
93508
          for (Amazonlisted _iter292 : this.success)
93511
          {
93509
          {
93512
            _iter287.write(oprot);
93510
            _iter292.write(oprot);
93513
          }
93511
          }
93514
          oprot.writeListEnd();
93512
          oprot.writeListEnd();
93515
        }
93513
        }
93516
        oprot.writeFieldEnd();
93514
        oprot.writeFieldEnd();
93517
      }
93515
      }
Line 93810... Line 93808...
93810
        }
93808
        }
93811
        switch (field.id) {
93809
        switch (field.id) {
93812
          case 1: // AMAZONLISTED
93810
          case 1: // AMAZONLISTED
93813
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
93811
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
93814
              {
93812
              {
93815
                org.apache.thrift.protocol.TMap _map288 = iprot.readMapBegin();
93813
                org.apache.thrift.protocol.TMap _map293 = iprot.readMapBegin();
93816
                this.amazonlisted = new HashMap<Long,Amazonlisted>(2*_map288.size);
93814
                this.amazonlisted = new HashMap<Long,Amazonlisted>(2*_map293.size);
93817
                for (int _i289 = 0; _i289 < _map288.size; ++_i289)
93815
                for (int _i294 = 0; _i294 < _map293.size; ++_i294)
93818
                {
93816
                {
93819
                  long _key290; // required
93817
                  long _key295; // required
93820
                  Amazonlisted _val291; // required
93818
                  Amazonlisted _val296; // required
93821
                  _key290 = iprot.readI64();
93819
                  _key295 = iprot.readI64();
93822
                  _val291 = new Amazonlisted();
93820
                  _val296 = new Amazonlisted();
93823
                  _val291.read(iprot);
93821
                  _val296.read(iprot);
93824
                  this.amazonlisted.put(_key290, _val291);
93822
                  this.amazonlisted.put(_key295, _val296);
93825
                }
93823
                }
93826
                iprot.readMapEnd();
93824
                iprot.readMapEnd();
93827
              }
93825
              }
93828
            } else { 
93826
            } else { 
93829
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
93827
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 93844... Line 93842...
93844
      oprot.writeStructBegin(STRUCT_DESC);
93842
      oprot.writeStructBegin(STRUCT_DESC);
93845
      if (this.amazonlisted != null) {
93843
      if (this.amazonlisted != null) {
93846
        oprot.writeFieldBegin(AMAZONLISTED_FIELD_DESC);
93844
        oprot.writeFieldBegin(AMAZONLISTED_FIELD_DESC);
93847
        {
93845
        {
93848
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRUCT, this.amazonlisted.size()));
93846
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRUCT, this.amazonlisted.size()));
93849
          for (Map.Entry<Long, Amazonlisted> _iter292 : this.amazonlisted.entrySet())
93847
          for (Map.Entry<Long, Amazonlisted> _iter297 : this.amazonlisted.entrySet())
93850
          {
93848
          {
93851
            oprot.writeI64(_iter292.getKey());
93849
            oprot.writeI64(_iter297.getKey());
93852
            _iter292.getValue().write(oprot);
93850
            _iter297.getValue().write(oprot);
93853
          }
93851
          }
93854
          oprot.writeMapEnd();
93852
          oprot.writeMapEnd();
93855
        }
93853
        }
93856
        oprot.writeFieldEnd();
93854
        oprot.writeFieldEnd();
93857
      }
93855
      }
Line 94638... Line 94636...
94638
        }
94636
        }
94639
        switch (field.id) {
94637
        switch (field.id) {
94640
          case 0: // SUCCESS
94638
          case 0: // SUCCESS
94641
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
94639
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
94642
              {
94640
              {
94643
                org.apache.thrift.protocol.TList _list293 = iprot.readListBegin();
94641
                org.apache.thrift.protocol.TList _list298 = iprot.readListBegin();
94644
                this.success = new ArrayList<Amazonlisted>(_list293.size);
94642
                this.success = new ArrayList<Amazonlisted>(_list298.size);
94645
                for (int _i294 = 0; _i294 < _list293.size; ++_i294)
94643
                for (int _i299 = 0; _i299 < _list298.size; ++_i299)
94646
                {
94644
                {
94647
                  Amazonlisted _elem295; // required
94645
                  Amazonlisted _elem300; // required
94648
                  _elem295 = new Amazonlisted();
94646
                  _elem300 = new Amazonlisted();
94649
                  _elem295.read(iprot);
94647
                  _elem300.read(iprot);
94650
                  this.success.add(_elem295);
94648
                  this.success.add(_elem300);
94651
                }
94649
                }
94652
                iprot.readListEnd();
94650
                iprot.readListEnd();
94653
              }
94651
              }
94654
            } else { 
94652
            } else { 
94655
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
94653
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 94669... Line 94667...
94669
 
94667
 
94670
      if (this.isSetSuccess()) {
94668
      if (this.isSetSuccess()) {
94671
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
94669
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
94672
        {
94670
        {
94673
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
94671
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
94674
          for (Amazonlisted _iter296 : this.success)
94672
          for (Amazonlisted _iter301 : this.success)
94675
          {
94673
          {
94676
            _iter296.write(oprot);
94674
            _iter301.write(oprot);
94677
          }
94675
          }
94678
          oprot.writeListEnd();
94676
          oprot.writeListEnd();
94679
        }
94677
        }
94680
        oprot.writeFieldEnd();
94678
        oprot.writeFieldEnd();
94681
      }
94679
      }
Line 95169... Line 95167...
95169
        }
95167
        }
95170
        switch (field.id) {
95168
        switch (field.id) {
95171
          case 0: // SUCCESS
95169
          case 0: // SUCCESS
95172
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
95170
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
95173
              {
95171
              {
95174
                org.apache.thrift.protocol.TList _list297 = iprot.readListBegin();
95172
                org.apache.thrift.protocol.TList _list302 = iprot.readListBegin();
95175
                this.success = new ArrayList<Amazonlisted>(_list297.size);
95173
                this.success = new ArrayList<Amazonlisted>(_list302.size);
95176
                for (int _i298 = 0; _i298 < _list297.size; ++_i298)
95174
                for (int _i303 = 0; _i303 < _list302.size; ++_i303)
95177
                {
95175
                {
95178
                  Amazonlisted _elem299; // required
95176
                  Amazonlisted _elem304; // required
95179
                  _elem299 = new Amazonlisted();
95177
                  _elem304 = new Amazonlisted();
95180
                  _elem299.read(iprot);
95178
                  _elem304.read(iprot);
95181
                  this.success.add(_elem299);
95179
                  this.success.add(_elem304);
95182
                }
95180
                }
95183
                iprot.readListEnd();
95181
                iprot.readListEnd();
95184
              }
95182
              }
95185
            } else { 
95183
            } else { 
95186
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
95184
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 95200... Line 95198...
95200
 
95198
 
95201
      if (this.isSetSuccess()) {
95199
      if (this.isSetSuccess()) {
95202
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
95200
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
95203
        {
95201
        {
95204
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
95202
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
95205
          for (Amazonlisted _iter300 : this.success)
95203
          for (Amazonlisted _iter305 : this.success)
95206
          {
95204
          {
95207
            _iter300.write(oprot);
95205
            _iter305.write(oprot);
95208
          }
95206
          }
95209
          oprot.writeListEnd();
95207
          oprot.writeListEnd();
95210
        }
95208
        }
95211
        oprot.writeFieldEnd();
95209
        oprot.writeFieldEnd();
95212
      }
95210
      }
Line 95505... Line 95503...
95505
        }
95503
        }
95506
        switch (field.id) {
95504
        switch (field.id) {
95507
          case 1: // ITEM
95505
          case 1: // ITEM
95508
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
95506
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
95509
              {
95507
              {
95510
                org.apache.thrift.protocol.TMap _map301 = iprot.readMapBegin();
95508
                org.apache.thrift.protocol.TMap _map306 = iprot.readMapBegin();
95511
                this.item = new HashMap<Long,Item>(2*_map301.size);
95509
                this.item = new HashMap<Long,Item>(2*_map306.size);
95512
                for (int _i302 = 0; _i302 < _map301.size; ++_i302)
95510
                for (int _i307 = 0; _i307 < _map306.size; ++_i307)
95513
                {
95511
                {
95514
                  long _key303; // required
95512
                  long _key308; // required
95515
                  Item _val304; // required
95513
                  Item _val309; // required
95516
                  _key303 = iprot.readI64();
95514
                  _key308 = iprot.readI64();
95517
                  _val304 = new Item();
95515
                  _val309 = new Item();
95518
                  _val304.read(iprot);
95516
                  _val309.read(iprot);
95519
                  this.item.put(_key303, _val304);
95517
                  this.item.put(_key308, _val309);
95520
                }
95518
                }
95521
                iprot.readMapEnd();
95519
                iprot.readMapEnd();
95522
              }
95520
              }
95523
            } else { 
95521
            } else { 
95524
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
95522
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 95539... Line 95537...
95539
      oprot.writeStructBegin(STRUCT_DESC);
95537
      oprot.writeStructBegin(STRUCT_DESC);
95540
      if (this.item != null) {
95538
      if (this.item != null) {
95541
        oprot.writeFieldBegin(ITEM_FIELD_DESC);
95539
        oprot.writeFieldBegin(ITEM_FIELD_DESC);
95542
        {
95540
        {
95543
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRUCT, this.item.size()));
95541
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRUCT, this.item.size()));
95544
          for (Map.Entry<Long, Item> _iter305 : this.item.entrySet())
95542
          for (Map.Entry<Long, Item> _iter310 : this.item.entrySet())
95545
          {
95543
          {
95546
            oprot.writeI64(_iter305.getKey());
95544
            oprot.writeI64(_iter310.getKey());
95547
            _iter305.getValue().write(oprot);
95545
            _iter310.getValue().write(oprot);
95548
          }
95546
          }
95549
          oprot.writeMapEnd();
95547
          oprot.writeMapEnd();
95550
        }
95548
        }
95551
        oprot.writeFieldEnd();
95549
        oprot.writeFieldEnd();
95552
      }
95550
      }
Line 98003... Line 98001...
98003
        }
98001
        }
98004
        switch (field.id) {
98002
        switch (field.id) {
98005
          case 0: // SUCCESS
98003
          case 0: // SUCCESS
98006
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
98004
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
98007
              {
98005
              {
98008
                org.apache.thrift.protocol.TList _list306 = iprot.readListBegin();
98006
                org.apache.thrift.protocol.TList _list311 = iprot.readListBegin();
98009
                this.success = new ArrayList<SnapdealItemDetails>(_list306.size);
98007
                this.success = new ArrayList<SnapdealItemDetails>(_list311.size);
98010
                for (int _i307 = 0; _i307 < _list306.size; ++_i307)
98008
                for (int _i312 = 0; _i312 < _list311.size; ++_i312)
98011
                {
98009
                {
98012
                  SnapdealItemDetails _elem308; // required
98010
                  SnapdealItemDetails _elem313; // required
98013
                  _elem308 = new SnapdealItemDetails();
98011
                  _elem313 = new SnapdealItemDetails();
98014
                  _elem308.read(iprot);
98012
                  _elem313.read(iprot);
98015
                  this.success.add(_elem308);
98013
                  this.success.add(_elem313);
98016
                }
98014
                }
98017
                iprot.readListEnd();
98015
                iprot.readListEnd();
98018
              }
98016
              }
98019
            } else { 
98017
            } else { 
98020
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
98018
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 98034... Line 98032...
98034
 
98032
 
98035
      if (this.isSetSuccess()) {
98033
      if (this.isSetSuccess()) {
98036
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
98034
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
98037
        {
98035
        {
98038
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
98036
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
98039
          for (SnapdealItemDetails _iter309 : this.success)
98037
          for (SnapdealItemDetails _iter314 : this.success)
98040
          {
98038
          {
98041
            _iter309.write(oprot);
98039
            _iter314.write(oprot);
98042
          }
98040
          }
98043
          oprot.writeListEnd();
98041
          oprot.writeListEnd();
98044
        }
98042
        }
98045
        oprot.writeFieldEnd();
98043
        oprot.writeFieldEnd();
98046
      }
98044
      }
Line 98711... Line 98709...
98711
        }
98709
        }
98712
        switch (field.id) {
98710
        switch (field.id) {
98713
          case 0: // SUCCESS
98711
          case 0: // SUCCESS
98714
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
98712
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
98715
              {
98713
              {
98716
                org.apache.thrift.protocol.TList _list310 = iprot.readListBegin();
98714
                org.apache.thrift.protocol.TList _list315 = iprot.readListBegin();
98717
                this.success = new ArrayList<SnapdealItemDetails>(_list310.size);
98715
                this.success = new ArrayList<SnapdealItemDetails>(_list315.size);
98718
                for (int _i311 = 0; _i311 < _list310.size; ++_i311)
98716
                for (int _i316 = 0; _i316 < _list315.size; ++_i316)
98719
                {
98717
                {
98720
                  SnapdealItemDetails _elem312; // required
98718
                  SnapdealItemDetails _elem317; // required
98721
                  _elem312 = new SnapdealItemDetails();
98719
                  _elem317 = new SnapdealItemDetails();
98722
                  _elem312.read(iprot);
98720
                  _elem317.read(iprot);
98723
                  this.success.add(_elem312);
98721
                  this.success.add(_elem317);
98724
                }
98722
                }
98725
                iprot.readListEnd();
98723
                iprot.readListEnd();
98726
              }
98724
              }
98727
            } else { 
98725
            } else { 
98728
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
98726
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 98742... Line 98740...
98742
 
98740
 
98743
      if (this.isSetSuccess()) {
98741
      if (this.isSetSuccess()) {
98744
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
98742
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
98745
        {
98743
        {
98746
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
98744
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
98747
          for (SnapdealItemDetails _iter313 : this.success)
98745
          for (SnapdealItemDetails _iter318 : this.success)
98748
          {
98746
          {
98749
            _iter313.write(oprot);
98747
            _iter318.write(oprot);
98750
          }
98748
          }
98751
          oprot.writeListEnd();
98749
          oprot.writeListEnd();
98752
        }
98750
        }
98753
        oprot.writeFieldEnd();
98751
        oprot.writeFieldEnd();
98754
      }
98752
      }
Line 99181... Line 99179...
99181
        }
99179
        }
99182
        switch (field.id) {
99180
        switch (field.id) {
99183
          case 1: // SEARCH_TERM
99181
          case 1: // SEARCH_TERM
99184
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
99182
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
99185
              {
99183
              {
99186
                org.apache.thrift.protocol.TList _list314 = iprot.readListBegin();
99184
                org.apache.thrift.protocol.TList _list319 = iprot.readListBegin();
99187
                this.searchTerm = new ArrayList<String>(_list314.size);
99185
                this.searchTerm = new ArrayList<String>(_list319.size);
99188
                for (int _i315 = 0; _i315 < _list314.size; ++_i315)
99186
                for (int _i320 = 0; _i320 < _list319.size; ++_i320)
99189
                {
99187
                {
99190
                  String _elem316; // required
99188
                  String _elem321; // required
99191
                  _elem316 = iprot.readString();
99189
                  _elem321 = iprot.readString();
99192
                  this.searchTerm.add(_elem316);
99190
                  this.searchTerm.add(_elem321);
99193
                }
99191
                }
99194
                iprot.readListEnd();
99192
                iprot.readListEnd();
99195
              }
99193
              }
99196
            } else { 
99194
            } else { 
99197
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
99195
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 99228... Line 99226...
99228
      oprot.writeStructBegin(STRUCT_DESC);
99226
      oprot.writeStructBegin(STRUCT_DESC);
99229
      if (this.searchTerm != null) {
99227
      if (this.searchTerm != null) {
99230
        oprot.writeFieldBegin(SEARCH_TERM_FIELD_DESC);
99228
        oprot.writeFieldBegin(SEARCH_TERM_FIELD_DESC);
99231
        {
99229
        {
99232
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerm.size()));
99230
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerm.size()));
99233
          for (String _iter317 : this.searchTerm)
99231
          for (String _iter322 : this.searchTerm)
99234
          {
99232
          {
99235
            oprot.writeString(_iter317);
99233
            oprot.writeString(_iter322);
99236
          }
99234
          }
99237
          oprot.writeListEnd();
99235
          oprot.writeListEnd();
99238
        }
99236
        }
99239
        oprot.writeFieldEnd();
99237
        oprot.writeFieldEnd();
99240
      }
99238
      }
Line 99542... Line 99540...
99542
        }
99540
        }
99543
        switch (field.id) {
99541
        switch (field.id) {
99544
          case 0: // SUCCESS
99542
          case 0: // SUCCESS
99545
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
99543
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
99546
              {
99544
              {
99547
                org.apache.thrift.protocol.TList _list318 = iprot.readListBegin();
99545
                org.apache.thrift.protocol.TList _list323 = iprot.readListBegin();
99548
                this.success = new ArrayList<SnapdealItemDetails>(_list318.size);
99546
                this.success = new ArrayList<SnapdealItemDetails>(_list323.size);
99549
                for (int _i319 = 0; _i319 < _list318.size; ++_i319)
99547
                for (int _i324 = 0; _i324 < _list323.size; ++_i324)
99550
                {
99548
                {
99551
                  SnapdealItemDetails _elem320; // required
99549
                  SnapdealItemDetails _elem325; // required
99552
                  _elem320 = new SnapdealItemDetails();
99550
                  _elem325 = new SnapdealItemDetails();
99553
                  _elem320.read(iprot);
99551
                  _elem325.read(iprot);
99554
                  this.success.add(_elem320);
99552
                  this.success.add(_elem325);
99555
                }
99553
                }
99556
                iprot.readListEnd();
99554
                iprot.readListEnd();
99557
              }
99555
              }
99558
            } else { 
99556
            } else { 
99559
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
99557
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 99573... Line 99571...
99573
 
99571
 
99574
      if (this.isSetSuccess()) {
99572
      if (this.isSetSuccess()) {
99575
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
99573
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
99576
        {
99574
        {
99577
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
99575
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
99578
          for (SnapdealItemDetails _iter321 : this.success)
99576
          for (SnapdealItemDetails _iter326 : this.success)
99579
          {
99577
          {
99580
            _iter321.write(oprot);
99578
            _iter326.write(oprot);
99581
          }
99579
          }
99582
          oprot.writeListEnd();
99580
          oprot.writeListEnd();
99583
        }
99581
        }
99584
        oprot.writeFieldEnd();
99582
        oprot.writeFieldEnd();
99585
      }
99583
      }
Line 100366... Line 100364...
100366
        }
100364
        }
100367
        switch (field.id) {
100365
        switch (field.id) {
100368
          case 1: // SEARCH_TERM
100366
          case 1: // SEARCH_TERM
100369
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
100367
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
100370
              {
100368
              {
100371
                org.apache.thrift.protocol.TList _list322 = iprot.readListBegin();
100369
                org.apache.thrift.protocol.TList _list327 = iprot.readListBegin();
100372
                this.searchTerm = new ArrayList<String>(_list322.size);
100370
                this.searchTerm = new ArrayList<String>(_list327.size);
100373
                for (int _i323 = 0; _i323 < _list322.size; ++_i323)
100371
                for (int _i328 = 0; _i328 < _list327.size; ++_i328)
100374
                {
100372
                {
100375
                  String _elem324; // required
100373
                  String _elem329; // required
100376
                  _elem324 = iprot.readString();
100374
                  _elem329 = iprot.readString();
100377
                  this.searchTerm.add(_elem324);
100375
                  this.searchTerm.add(_elem329);
100378
                }
100376
                }
100379
                iprot.readListEnd();
100377
                iprot.readListEnd();
100380
              }
100378
              }
100381
            } else { 
100379
            } else { 
100382
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
100380
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 100397... Line 100395...
100397
      oprot.writeStructBegin(STRUCT_DESC);
100395
      oprot.writeStructBegin(STRUCT_DESC);
100398
      if (this.searchTerm != null) {
100396
      if (this.searchTerm != null) {
100399
        oprot.writeFieldBegin(SEARCH_TERM_FIELD_DESC);
100397
        oprot.writeFieldBegin(SEARCH_TERM_FIELD_DESC);
100400
        {
100398
        {
100401
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerm.size()));
100399
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerm.size()));
100402
          for (String _iter325 : this.searchTerm)
100400
          for (String _iter330 : this.searchTerm)
100403
          {
100401
          {
100404
            oprot.writeString(_iter325);
100402
            oprot.writeString(_iter330);
100405
          }
100403
          }
100406
          oprot.writeListEnd();
100404
          oprot.writeListEnd();
100407
        }
100405
        }
100408
        oprot.writeFieldEnd();
100406
        oprot.writeFieldEnd();
100409
      }
100407
      }
Line 105236... Line 105234...
105236
        }
105234
        }
105237
        switch (field.id) {
105235
        switch (field.id) {
105238
          case 0: // SUCCESS
105236
          case 0: // SUCCESS
105239
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
105237
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
105240
              {
105238
              {
105241
                org.apache.thrift.protocol.TList _list326 = iprot.readListBegin();
105239
                org.apache.thrift.protocol.TList _list331 = iprot.readListBegin();
105242
                this.success = new ArrayList<ProductFeedSubmit>(_list326.size);
105240
                this.success = new ArrayList<ProductFeedSubmit>(_list331.size);
105243
                for (int _i327 = 0; _i327 < _list326.size; ++_i327)
105241
                for (int _i332 = 0; _i332 < _list331.size; ++_i332)
105244
                {
105242
                {
105245
                  ProductFeedSubmit _elem328; // required
105243
                  ProductFeedSubmit _elem333; // required
105246
                  _elem328 = new ProductFeedSubmit();
105244
                  _elem333 = new ProductFeedSubmit();
105247
                  _elem328.read(iprot);
105245
                  _elem333.read(iprot);
105248
                  this.success.add(_elem328);
105246
                  this.success.add(_elem333);
105249
                }
105247
                }
105250
                iprot.readListEnd();
105248
                iprot.readListEnd();
105251
              }
105249
              }
105252
            } else { 
105250
            } else { 
105253
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
105251
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 105275... Line 105273...
105275
 
105273
 
105276
      if (this.isSetSuccess()) {
105274
      if (this.isSetSuccess()) {
105277
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
105275
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
105278
        {
105276
        {
105279
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
105277
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
105280
          for (ProductFeedSubmit _iter329 : this.success)
105278
          for (ProductFeedSubmit _iter334 : this.success)
105281
          {
105279
          {
105282
            _iter329.write(oprot);
105280
            _iter334.write(oprot);
105283
          }
105281
          }
105284
          oprot.writeListEnd();
105282
          oprot.writeListEnd();
105285
        }
105283
        }
105286
        oprot.writeFieldEnd();
105284
        oprot.writeFieldEnd();
105287
      } else if (this.isSetCex()) {
105285
      } else if (this.isSetCex()) {
Line 107811... Line 107809...
107811
        }
107809
        }
107812
        switch (field.id) {
107810
        switch (field.id) {
107813
          case 0: // SUCCESS
107811
          case 0: // SUCCESS
107814
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
107812
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
107815
              {
107813
              {
107816
                org.apache.thrift.protocol.TList _list330 = iprot.readListBegin();
107814
                org.apache.thrift.protocol.TList _list335 = iprot.readListBegin();
107817
                this.success = new ArrayList<MarketPlaceItemPrice>(_list330.size);
107815
                this.success = new ArrayList<MarketPlaceItemPrice>(_list335.size);
107818
                for (int _i331 = 0; _i331 < _list330.size; ++_i331)
107816
                for (int _i336 = 0; _i336 < _list335.size; ++_i336)
107819
                {
107817
                {
107820
                  MarketPlaceItemPrice _elem332; // required
107818
                  MarketPlaceItemPrice _elem337; // required
107821
                  _elem332 = new MarketPlaceItemPrice();
107819
                  _elem337 = new MarketPlaceItemPrice();
107822
                  _elem332.read(iprot);
107820
                  _elem337.read(iprot);
107823
                  this.success.add(_elem332);
107821
                  this.success.add(_elem337);
107824
                }
107822
                }
107825
                iprot.readListEnd();
107823
                iprot.readListEnd();
107826
              }
107824
              }
107827
            } else { 
107825
            } else { 
107828
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
107826
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 107842... Line 107840...
107842
 
107840
 
107843
      if (this.isSetSuccess()) {
107841
      if (this.isSetSuccess()) {
107844
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
107842
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
107845
        {
107843
        {
107846
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
107844
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
107847
          for (MarketPlaceItemPrice _iter333 : this.success)
107845
          for (MarketPlaceItemPrice _iter338 : this.success)
107848
          {
107846
          {
107849
            _iter333.write(oprot);
107847
            _iter338.write(oprot);
107850
          }
107848
          }
107851
          oprot.writeListEnd();
107849
          oprot.writeListEnd();
107852
        }
107850
        }
107853
        oprot.writeFieldEnd();
107851
        oprot.writeFieldEnd();
107854
      }
107852
      }
Line 108281... Line 108279...
108281
        }
108279
        }
108282
        switch (field.id) {
108280
        switch (field.id) {
108283
          case 1: // SKULIST
108281
          case 1: // SKULIST
108284
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
108282
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
108285
              {
108283
              {
108286
                org.apache.thrift.protocol.TList _list334 = iprot.readListBegin();
108284
                org.apache.thrift.protocol.TList _list339 = iprot.readListBegin();
108287
                this.skulist = new ArrayList<Long>(_list334.size);
108285
                this.skulist = new ArrayList<Long>(_list339.size);
108288
                for (int _i335 = 0; _i335 < _list334.size; ++_i335)
108286
                for (int _i340 = 0; _i340 < _list339.size; ++_i340)
108289
                {
108287
                {
108290
                  long _elem336; // required
108288
                  long _elem341; // required
108291
                  _elem336 = iprot.readI64();
108289
                  _elem341 = iprot.readI64();
108292
                  this.skulist.add(_elem336);
108290
                  this.skulist.add(_elem341);
108293
                }
108291
                }
108294
                iprot.readListEnd();
108292
                iprot.readListEnd();
108295
              }
108293
              }
108296
            } else { 
108294
            } else { 
108297
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
108295
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 108328... Line 108326...
108328
      oprot.writeStructBegin(STRUCT_DESC);
108326
      oprot.writeStructBegin(STRUCT_DESC);
108329
      if (this.skulist != null) {
108327
      if (this.skulist != null) {
108330
        oprot.writeFieldBegin(SKULIST_FIELD_DESC);
108328
        oprot.writeFieldBegin(SKULIST_FIELD_DESC);
108331
        {
108329
        {
108332
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.skulist.size()));
108330
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.skulist.size()));
108333
          for (long _iter337 : this.skulist)
108331
          for (long _iter342 : this.skulist)
108334
          {
108332
          {
108335
            oprot.writeI64(_iter337);
108333
            oprot.writeI64(_iter342);
108336
          }
108334
          }
108337
          oprot.writeListEnd();
108335
          oprot.writeListEnd();
108338
        }
108336
        }
108339
        oprot.writeFieldEnd();
108337
        oprot.writeFieldEnd();
108340
      }
108338
      }
Line 108848... Line 108846...
108848
        }
108846
        }
108849
        switch (field.id) {
108847
        switch (field.id) {
108850
          case 1: // ITEM_HOLD_MAP
108848
          case 1: // ITEM_HOLD_MAP
108851
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
108849
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
108852
              {
108850
              {
108853
                org.apache.thrift.protocol.TMap _map338 = iprot.readMapBegin();
108851
                org.apache.thrift.protocol.TMap _map343 = iprot.readMapBegin();
108854
                this.itemHoldMap = new HashMap<Long,Long>(2*_map338.size);
108852
                this.itemHoldMap = new HashMap<Long,Long>(2*_map343.size);
108855
                for (int _i339 = 0; _i339 < _map338.size; ++_i339)
108853
                for (int _i344 = 0; _i344 < _map343.size; ++_i344)
108856
                {
108854
                {
108857
                  long _key340; // required
108855
                  long _key345; // required
108858
                  long _val341; // required
108856
                  long _val346; // required
108859
                  _key340 = iprot.readI64();
108857
                  _key345 = iprot.readI64();
108860
                  _val341 = iprot.readI64();
108858
                  _val346 = iprot.readI64();
108861
                  this.itemHoldMap.put(_key340, _val341);
108859
                  this.itemHoldMap.put(_key345, _val346);
108862
                }
108860
                }
108863
                iprot.readMapEnd();
108861
                iprot.readMapEnd();
108864
              }
108862
              }
108865
            } else { 
108863
            } else { 
108866
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
108864
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 108881... Line 108879...
108881
      oprot.writeStructBegin(STRUCT_DESC);
108879
      oprot.writeStructBegin(STRUCT_DESC);
108882
      if (this.itemHoldMap != null) {
108880
      if (this.itemHoldMap != null) {
108883
        oprot.writeFieldBegin(ITEM_HOLD_MAP_FIELD_DESC);
108881
        oprot.writeFieldBegin(ITEM_HOLD_MAP_FIELD_DESC);
108884
        {
108882
        {
108885
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.I64, this.itemHoldMap.size()));
108883
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.I64, this.itemHoldMap.size()));
108886
          for (Map.Entry<Long, Long> _iter342 : this.itemHoldMap.entrySet())
108884
          for (Map.Entry<Long, Long> _iter347 : this.itemHoldMap.entrySet())
108887
          {
108885
          {
108888
            oprot.writeI64(_iter342.getKey());
108886
            oprot.writeI64(_iter347.getKey());
108889
            oprot.writeI64(_iter342.getValue());
108887
            oprot.writeI64(_iter347.getValue());
108890
          }
108888
          }
108891
          oprot.writeMapEnd();
108889
          oprot.writeMapEnd();
108892
        }
108890
        }
108893
        oprot.writeFieldEnd();
108891
        oprot.writeFieldEnd();
108894
      }
108892
      }
Line 110240... Line 110238...
110240
        }
110238
        }
110241
        switch (field.id) {
110239
        switch (field.id) {
110242
          case 0: // SUCCESS
110240
          case 0: // SUCCESS
110243
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
110241
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
110244
              {
110242
              {
110245
                org.apache.thrift.protocol.TList _list343 = iprot.readListBegin();
110243
                org.apache.thrift.protocol.TList _list348 = iprot.readListBegin();
110246
                this.success = new ArrayList<FlipkartItem>(_list343.size);
110244
                this.success = new ArrayList<FlipkartItem>(_list348.size);
110247
                for (int _i344 = 0; _i344 < _list343.size; ++_i344)
110245
                for (int _i349 = 0; _i349 < _list348.size; ++_i349)
110248
                {
110246
                {
110249
                  FlipkartItem _elem345; // required
110247
                  FlipkartItem _elem350; // required
110250
                  _elem345 = new FlipkartItem();
110248
                  _elem350 = new FlipkartItem();
110251
                  _elem345.read(iprot);
110249
                  _elem350.read(iprot);
110252
                  this.success.add(_elem345);
110250
                  this.success.add(_elem350);
110253
                }
110251
                }
110254
                iprot.readListEnd();
110252
                iprot.readListEnd();
110255
              }
110253
              }
110256
            } else { 
110254
            } else { 
110257
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
110255
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 110271... Line 110269...
110271
 
110269
 
110272
      if (this.isSetSuccess()) {
110270
      if (this.isSetSuccess()) {
110273
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
110271
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
110274
        {
110272
        {
110275
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
110273
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
110276
          for (FlipkartItem _iter346 : this.success)
110274
          for (FlipkartItem _iter351 : this.success)
110277
          {
110275
          {
110278
            _iter346.write(oprot);
110276
            _iter351.write(oprot);
110279
          }
110277
          }
110280
          oprot.writeListEnd();
110278
          oprot.writeListEnd();
110281
        }
110279
        }
110282
        oprot.writeFieldEnd();
110280
        oprot.writeFieldEnd();
110283
      }
110281
      }
Line 112712... Line 112710...
112712
        }
112710
        }
112713
        switch (field.id) {
112711
        switch (field.id) {
112714
          case 0: // SUCCESS
112712
          case 0: // SUCCESS
112715
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
112713
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
112716
              {
112714
              {
112717
                org.apache.thrift.protocol.TList _list347 = iprot.readListBegin();
112715
                org.apache.thrift.protocol.TList _list352 = iprot.readListBegin();
112718
                this.success = new ArrayList<FlipkartItemDetails>(_list347.size);
112716
                this.success = new ArrayList<FlipkartItemDetails>(_list352.size);
112719
                for (int _i348 = 0; _i348 < _list347.size; ++_i348)
112717
                for (int _i353 = 0; _i353 < _list352.size; ++_i353)
112720
                {
112718
                {
112721
                  FlipkartItemDetails _elem349; // required
112719
                  FlipkartItemDetails _elem354; // required
112722
                  _elem349 = new FlipkartItemDetails();
112720
                  _elem354 = new FlipkartItemDetails();
112723
                  _elem349.read(iprot);
112721
                  _elem354.read(iprot);
112724
                  this.success.add(_elem349);
112722
                  this.success.add(_elem354);
112725
                }
112723
                }
112726
                iprot.readListEnd();
112724
                iprot.readListEnd();
112727
              }
112725
              }
112728
            } else { 
112726
            } else { 
112729
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
112727
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 112743... Line 112741...
112743
 
112741
 
112744
      if (this.isSetSuccess()) {
112742
      if (this.isSetSuccess()) {
112745
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
112743
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
112746
        {
112744
        {
112747
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
112745
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
112748
          for (FlipkartItemDetails _iter350 : this.success)
112746
          for (FlipkartItemDetails _iter355 : this.success)
112749
          {
112747
          {
112750
            _iter350.write(oprot);
112748
            _iter355.write(oprot);
112751
          }
112749
          }
112752
          oprot.writeListEnd();
112750
          oprot.writeListEnd();
112753
        }
112751
        }
112754
        oprot.writeFieldEnd();
112752
        oprot.writeFieldEnd();
112755
      }
112753
      }
Line 113182... Line 113180...
113182
        }
113180
        }
113183
        switch (field.id) {
113181
        switch (field.id) {
113184
          case 1: // SEARCH_TERM
113182
          case 1: // SEARCH_TERM
113185
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
113183
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
113186
              {
113184
              {
113187
                org.apache.thrift.protocol.TList _list351 = iprot.readListBegin();
113185
                org.apache.thrift.protocol.TList _list356 = iprot.readListBegin();
113188
                this.searchTerm = new ArrayList<String>(_list351.size);
113186
                this.searchTerm = new ArrayList<String>(_list356.size);
113189
                for (int _i352 = 0; _i352 < _list351.size; ++_i352)
113187
                for (int _i357 = 0; _i357 < _list356.size; ++_i357)
113190
                {
113188
                {
113191
                  String _elem353; // required
113189
                  String _elem358; // required
113192
                  _elem353 = iprot.readString();
113190
                  _elem358 = iprot.readString();
113193
                  this.searchTerm.add(_elem353);
113191
                  this.searchTerm.add(_elem358);
113194
                }
113192
                }
113195
                iprot.readListEnd();
113193
                iprot.readListEnd();
113196
              }
113194
              }
113197
            } else { 
113195
            } else { 
113198
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
113196
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 113229... Line 113227...
113229
      oprot.writeStructBegin(STRUCT_DESC);
113227
      oprot.writeStructBegin(STRUCT_DESC);
113230
      if (this.searchTerm != null) {
113228
      if (this.searchTerm != null) {
113231
        oprot.writeFieldBegin(SEARCH_TERM_FIELD_DESC);
113229
        oprot.writeFieldBegin(SEARCH_TERM_FIELD_DESC);
113232
        {
113230
        {
113233
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerm.size()));
113231
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerm.size()));
113234
          for (String _iter354 : this.searchTerm)
113232
          for (String _iter359 : this.searchTerm)
113235
          {
113233
          {
113236
            oprot.writeString(_iter354);
113234
            oprot.writeString(_iter359);
113237
          }
113235
          }
113238
          oprot.writeListEnd();
113236
          oprot.writeListEnd();
113239
        }
113237
        }
113240
        oprot.writeFieldEnd();
113238
        oprot.writeFieldEnd();
113241
      }
113239
      }
Line 113545... Line 113543...
113545
        }
113543
        }
113546
        switch (field.id) {
113544
        switch (field.id) {
113547
          case 0: // SUCCESS
113545
          case 0: // SUCCESS
113548
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
113546
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
113549
              {
113547
              {
113550
                org.apache.thrift.protocol.TList _list355 = iprot.readListBegin();
113548
                org.apache.thrift.protocol.TList _list360 = iprot.readListBegin();
113551
                this.success = new ArrayList<FlipkartItemDetails>(_list355.size);
113549
                this.success = new ArrayList<FlipkartItemDetails>(_list360.size);
113552
                for (int _i356 = 0; _i356 < _list355.size; ++_i356)
113550
                for (int _i361 = 0; _i361 < _list360.size; ++_i361)
113553
                {
113551
                {
113554
                  FlipkartItemDetails _elem357; // required
113552
                  FlipkartItemDetails _elem362; // required
113555
                  _elem357 = new FlipkartItemDetails();
113553
                  _elem362 = new FlipkartItemDetails();
113556
                  _elem357.read(iprot);
113554
                  _elem362.read(iprot);
113557
                  this.success.add(_elem357);
113555
                  this.success.add(_elem362);
113558
                }
113556
                }
113559
                iprot.readListEnd();
113557
                iprot.readListEnd();
113560
              }
113558
              }
113561
            } else { 
113559
            } else { 
113562
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
113560
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 113576... Line 113574...
113576
 
113574
 
113577
      if (this.isSetSuccess()) {
113575
      if (this.isSetSuccess()) {
113578
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
113576
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
113579
        {
113577
        {
113580
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
113578
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
113581
          for (FlipkartItemDetails _iter358 : this.success)
113579
          for (FlipkartItemDetails _iter363 : this.success)
113582
          {
113580
          {
113583
            _iter358.write(oprot);
113581
            _iter363.write(oprot);
113584
          }
113582
          }
113585
          oprot.writeListEnd();
113583
          oprot.writeListEnd();
113586
        }
113584
        }
113587
        oprot.writeFieldEnd();
113585
        oprot.writeFieldEnd();
113588
      }
113586
      }
Line 114369... Line 114367...
114369
        }
114367
        }
114370
        switch (field.id) {
114368
        switch (field.id) {
114371
          case 1: // SEARCH_TERM
114369
          case 1: // SEARCH_TERM
114372
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
114370
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
114373
              {
114371
              {
114374
                org.apache.thrift.protocol.TList _list359 = iprot.readListBegin();
114372
                org.apache.thrift.protocol.TList _list364 = iprot.readListBegin();
114375
                this.searchTerm = new ArrayList<String>(_list359.size);
114373
                this.searchTerm = new ArrayList<String>(_list364.size);
114376
                for (int _i360 = 0; _i360 < _list359.size; ++_i360)
114374
                for (int _i365 = 0; _i365 < _list364.size; ++_i365)
114377
                {
114375
                {
114378
                  String _elem361; // required
114376
                  String _elem366; // required
114379
                  _elem361 = iprot.readString();
114377
                  _elem366 = iprot.readString();
114380
                  this.searchTerm.add(_elem361);
114378
                  this.searchTerm.add(_elem366);
114381
                }
114379
                }
114382
                iprot.readListEnd();
114380
                iprot.readListEnd();
114383
              }
114381
              }
114384
            } else { 
114382
            } else { 
114385
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
114383
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 114400... Line 114398...
114400
      oprot.writeStructBegin(STRUCT_DESC);
114398
      oprot.writeStructBegin(STRUCT_DESC);
114401
      if (this.searchTerm != null) {
114399
      if (this.searchTerm != null) {
114402
        oprot.writeFieldBegin(SEARCH_TERM_FIELD_DESC);
114400
        oprot.writeFieldBegin(SEARCH_TERM_FIELD_DESC);
114403
        {
114401
        {
114404
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerm.size()));
114402
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerm.size()));
114405
          for (String _iter362 : this.searchTerm)
114403
          for (String _iter367 : this.searchTerm)
114406
          {
114404
          {
114407
            oprot.writeString(_iter362);
114405
            oprot.writeString(_iter367);
114408
          }
114406
          }
114409
          oprot.writeListEnd();
114407
          oprot.writeListEnd();
114410
        }
114408
        }
114411
        oprot.writeFieldEnd();
114409
        oprot.writeFieldEnd();
114412
      }
114410
      }
Line 115193... Line 115191...
115193
        }
115191
        }
115194
        switch (field.id) {
115192
        switch (field.id) {
115195
          case 0: // SUCCESS
115193
          case 0: // SUCCESS
115196
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
115194
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
115197
              {
115195
              {
115198
                org.apache.thrift.protocol.TList _list363 = iprot.readListBegin();
115196
                org.apache.thrift.protocol.TList _list368 = iprot.readListBegin();
115199
                this.success = new ArrayList<FlipkartItemDetails>(_list363.size);
115197
                this.success = new ArrayList<FlipkartItemDetails>(_list368.size);
115200
                for (int _i364 = 0; _i364 < _list363.size; ++_i364)
115198
                for (int _i369 = 0; _i369 < _list368.size; ++_i369)
115201
                {
115199
                {
115202
                  FlipkartItemDetails _elem365; // required
115200
                  FlipkartItemDetails _elem370; // required
115203
                  _elem365 = new FlipkartItemDetails();
115201
                  _elem370 = new FlipkartItemDetails();
115204
                  _elem365.read(iprot);
115202
                  _elem370.read(iprot);
115205
                  this.success.add(_elem365);
115203
                  this.success.add(_elem370);
115206
                }
115204
                }
115207
                iprot.readListEnd();
115205
                iprot.readListEnd();
115208
              }
115206
              }
115209
            } else { 
115207
            } else { 
115210
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
115208
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 115224... Line 115222...
115224
 
115222
 
115225
      if (this.isSetSuccess()) {
115223
      if (this.isSetSuccess()) {
115226
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
115224
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
115227
        {
115225
        {
115228
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
115226
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
115229
          for (FlipkartItemDetails _iter366 : this.success)
115227
          for (FlipkartItemDetails _iter371 : this.success)
115230
          {
115228
          {
115231
            _iter366.write(oprot);
115229
            _iter371.write(oprot);
115232
          }
115230
          }
115233
          oprot.writeListEnd();
115231
          oprot.writeListEnd();
115234
        }
115232
        }
115235
        oprot.writeFieldEnd();
115233
        oprot.writeFieldEnd();
115236
      }
115234
      }
Line 116572... Line 116570...
116572
        }
116570
        }
116573
        switch (field.id) {
116571
        switch (field.id) {
116574
          case 0: // SUCCESS
116572
          case 0: // SUCCESS
116575
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
116573
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
116576
              {
116574
              {
116577
                org.apache.thrift.protocol.TList _list367 = iprot.readListBegin();
116575
                org.apache.thrift.protocol.TList _list372 = iprot.readListBegin();
116578
                this.success = new ArrayList<MarketplaceHistory>(_list367.size);
116576
                this.success = new ArrayList<MarketplaceHistory>(_list372.size);
116579
                for (int _i368 = 0; _i368 < _list367.size; ++_i368)
116577
                for (int _i373 = 0; _i373 < _list372.size; ++_i373)
116580
                {
116578
                {
116581
                  MarketplaceHistory _elem369; // required
116579
                  MarketplaceHistory _elem374; // required
116582
                  _elem369 = new MarketplaceHistory();
116580
                  _elem374 = new MarketplaceHistory();
116583
                  _elem369.read(iprot);
116581
                  _elem374.read(iprot);
116584
                  this.success.add(_elem369);
116582
                  this.success.add(_elem374);
116585
                }
116583
                }
116586
                iprot.readListEnd();
116584
                iprot.readListEnd();
116587
              }
116585
              }
116588
            } else { 
116586
            } else { 
116589
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
116587
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 116603... Line 116601...
116603
 
116601
 
116604
      if (this.isSetSuccess()) {
116602
      if (this.isSetSuccess()) {
116605
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
116603
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
116606
        {
116604
        {
116607
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
116605
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
116608
          for (MarketplaceHistory _iter370 : this.success)
116606
          for (MarketplaceHistory _iter375 : this.success)
116609
          {
116607
          {
116610
            _iter370.write(oprot);
116608
            _iter375.write(oprot);
116611
          }
116609
          }
116612
          oprot.writeListEnd();
116610
          oprot.writeListEnd();
116613
        }
116611
        }
116614
        oprot.writeFieldEnd();
116612
        oprot.writeFieldEnd();
116615
      }
116613
      }
Line 117103... Line 117101...
117103
        }
117101
        }
117104
        switch (field.id) {
117102
        switch (field.id) {
117105
          case 0: // SUCCESS
117103
          case 0: // SUCCESS
117106
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
117104
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
117107
              {
117105
              {
117108
                org.apache.thrift.protocol.TList _list371 = iprot.readListBegin();
117106
                org.apache.thrift.protocol.TList _list376 = iprot.readListBegin();
117109
                this.success = new ArrayList<Amazonlisted>(_list371.size);
117107
                this.success = new ArrayList<Amazonlisted>(_list376.size);
117110
                for (int _i372 = 0; _i372 < _list371.size; ++_i372)
117108
                for (int _i377 = 0; _i377 < _list376.size; ++_i377)
117111
                {
117109
                {
117112
                  Amazonlisted _elem373; // required
117110
                  Amazonlisted _elem378; // required
117113
                  _elem373 = new Amazonlisted();
117111
                  _elem378 = new Amazonlisted();
117114
                  _elem373.read(iprot);
117112
                  _elem378.read(iprot);
117115
                  this.success.add(_elem373);
117113
                  this.success.add(_elem378);
117116
                }
117114
                }
117117
                iprot.readListEnd();
117115
                iprot.readListEnd();
117118
              }
117116
              }
117119
            } else { 
117117
            } else { 
117120
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
117118
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 117134... Line 117132...
117134
 
117132
 
117135
      if (this.isSetSuccess()) {
117133
      if (this.isSetSuccess()) {
117136
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
117134
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
117137
        {
117135
        {
117138
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
117136
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
117139
          for (Amazonlisted _iter374 : this.success)
117137
          for (Amazonlisted _iter379 : this.success)
117140
          {
117138
          {
117141
            _iter374.write(oprot);
117139
            _iter379.write(oprot);
117142
          }
117140
          }
117143
          oprot.writeListEnd();
117141
          oprot.writeListEnd();
117144
        }
117142
        }
117145
        oprot.writeFieldEnd();
117143
        oprot.writeFieldEnd();
117146
      }
117144
      }
Line 117634... Line 117632...
117634
        }
117632
        }
117635
        switch (field.id) {
117633
        switch (field.id) {
117636
          case 0: // SUCCESS
117634
          case 0: // SUCCESS
117637
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
117635
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
117638
              {
117636
              {
117639
                org.apache.thrift.protocol.TList _list375 = iprot.readListBegin();
117637
                org.apache.thrift.protocol.TList _list380 = iprot.readListBegin();
117640
                this.success = new ArrayList<Amazonlisted>(_list375.size);
117638
                this.success = new ArrayList<Amazonlisted>(_list380.size);
117641
                for (int _i376 = 0; _i376 < _list375.size; ++_i376)
117639
                for (int _i381 = 0; _i381 < _list380.size; ++_i381)
117642
                {
117640
                {
117643
                  Amazonlisted _elem377; // required
117641
                  Amazonlisted _elem382; // required
117644
                  _elem377 = new Amazonlisted();
117642
                  _elem382 = new Amazonlisted();
117645
                  _elem377.read(iprot);
117643
                  _elem382.read(iprot);
117646
                  this.success.add(_elem377);
117644
                  this.success.add(_elem382);
117647
                }
117645
                }
117648
                iprot.readListEnd();
117646
                iprot.readListEnd();
117649
              }
117647
              }
117650
            } else { 
117648
            } else { 
117651
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
117649
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 117665... Line 117663...
117665
 
117663
 
117666
      if (this.isSetSuccess()) {
117664
      if (this.isSetSuccess()) {
117667
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
117665
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
117668
        {
117666
        {
117669
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
117667
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
117670
          for (Amazonlisted _iter378 : this.success)
117668
          for (Amazonlisted _iter383 : this.success)
117671
          {
117669
          {
117672
            _iter378.write(oprot);
117670
            _iter383.write(oprot);
117673
          }
117671
          }
117674
          oprot.writeListEnd();
117672
          oprot.writeListEnd();
117675
        }
117673
        }
117676
        oprot.writeFieldEnd();
117674
        oprot.writeFieldEnd();
117677
      }
117675
      }
Line 119344... Line 119342...
119344
        }
119342
        }
119345
        switch (field.id) {
119343
        switch (field.id) {
119346
          case 0: // SUCCESS
119344
          case 0: // SUCCESS
119347
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
119345
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
119348
              {
119346
              {
119349
                org.apache.thrift.protocol.TList _list379 = iprot.readListBegin();
119347
                org.apache.thrift.protocol.TList _list384 = iprot.readListBegin();
119350
                this.success = new ArrayList<MarketplaceHistory>(_list379.size);
119348
                this.success = new ArrayList<MarketplaceHistory>(_list384.size);
119351
                for (int _i380 = 0; _i380 < _list379.size; ++_i380)
119349
                for (int _i385 = 0; _i385 < _list384.size; ++_i385)
119352
                {
119350
                {
119353
                  MarketplaceHistory _elem381; // required
119351
                  MarketplaceHistory _elem386; // required
119354
                  _elem381 = new MarketplaceHistory();
119352
                  _elem386 = new MarketplaceHistory();
119355
                  _elem381.read(iprot);
119353
                  _elem386.read(iprot);
119356
                  this.success.add(_elem381);
119354
                  this.success.add(_elem386);
119357
                }
119355
                }
119358
                iprot.readListEnd();
119356
                iprot.readListEnd();
119359
              }
119357
              }
119360
            } else { 
119358
            } else { 
119361
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
119359
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 119375... Line 119373...
119375
 
119373
 
119376
      if (this.isSetSuccess()) {
119374
      if (this.isSetSuccess()) {
119377
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
119375
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
119378
        {
119376
        {
119379
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
119377
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
119380
          for (MarketplaceHistory _iter382 : this.success)
119378
          for (MarketplaceHistory _iter387 : this.success)
119381
          {
119379
          {
119382
            _iter382.write(oprot);
119380
            _iter387.write(oprot);
119383
          }
119381
          }
119384
          oprot.writeListEnd();
119382
          oprot.writeListEnd();
119385
        }
119383
        }
119386
        oprot.writeFieldEnd();
119384
        oprot.writeFieldEnd();
119387
      }
119385
      }
Line 120640... Line 120638...
120640
        }
120638
        }
120641
        switch (field.id) {
120639
        switch (field.id) {
120642
          case 0: // SUCCESS
120640
          case 0: // SUCCESS
120643
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
120641
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
120644
              {
120642
              {
120645
                org.apache.thrift.protocol.TList _list383 = iprot.readListBegin();
120643
                org.apache.thrift.protocol.TList _list388 = iprot.readListBegin();
120646
                this.success = new ArrayList<Item>(_list383.size);
120644
                this.success = new ArrayList<Item>(_list388.size);
120647
                for (int _i384 = 0; _i384 < _list383.size; ++_i384)
120645
                for (int _i389 = 0; _i389 < _list388.size; ++_i389)
120648
                {
120646
                {
120649
                  Item _elem385; // required
120647
                  Item _elem390; // required
120650
                  _elem385 = new Item();
120648
                  _elem390 = new Item();
120651
                  _elem385.read(iprot);
120649
                  _elem390.read(iprot);
120652
                  this.success.add(_elem385);
120650
                  this.success.add(_elem390);
120653
                }
120651
                }
120654
                iprot.readListEnd();
120652
                iprot.readListEnd();
120655
              }
120653
              }
120656
            } else { 
120654
            } else { 
120657
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
120655
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 120671... Line 120669...
120671
 
120669
 
120672
      if (this.isSetSuccess()) {
120670
      if (this.isSetSuccess()) {
120673
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
120671
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
120674
        {
120672
        {
120675
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
120673
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
120676
          for (Item _iter386 : this.success)
120674
          for (Item _iter391 : this.success)
120677
          {
120675
          {
120678
            _iter386.write(oprot);
120676
            _iter391.write(oprot);
120679
          }
120677
          }
120680
          oprot.writeListEnd();
120678
          oprot.writeListEnd();
120681
        }
120679
        }
120682
        oprot.writeFieldEnd();
120680
        oprot.writeFieldEnd();
120683
      }
120681
      }
Line 121042... Line 121040...
121042
        }
121040
        }
121043
        switch (field.id) {
121041
        switch (field.id) {
121044
          case 1: // ITEM_IDS
121042
          case 1: // ITEM_IDS
121045
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
121043
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
121046
              {
121044
              {
121047
                org.apache.thrift.protocol.TList _list387 = iprot.readListBegin();
121045
                org.apache.thrift.protocol.TList _list392 = iprot.readListBegin();
121048
                this.itemIds = new ArrayList<Long>(_list387.size);
121046
                this.itemIds = new ArrayList<Long>(_list392.size);
121049
                for (int _i388 = 0; _i388 < _list387.size; ++_i388)
121047
                for (int _i393 = 0; _i393 < _list392.size; ++_i393)
121050
                {
121048
                {
121051
                  long _elem389; // required
121049
                  long _elem394; // required
121052
                  _elem389 = iprot.readI64();
121050
                  _elem394 = iprot.readI64();
121053
                  this.itemIds.add(_elem389);
121051
                  this.itemIds.add(_elem394);
121054
                }
121052
                }
121055
                iprot.readListEnd();
121053
                iprot.readListEnd();
121056
              }
121054
              }
121057
            } else { 
121055
            } else { 
121058
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
121056
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 121081... Line 121079...
121081
      oprot.writeStructBegin(STRUCT_DESC);
121079
      oprot.writeStructBegin(STRUCT_DESC);
121082
      if (this.itemIds != null) {
121080
      if (this.itemIds != null) {
121083
        oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
121081
        oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
121084
        {
121082
        {
121085
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.itemIds.size()));
121083
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.itemIds.size()));
121086
          for (long _iter390 : this.itemIds)
121084
          for (long _iter395 : this.itemIds)
121087
          {
121085
          {
121088
            oprot.writeI64(_iter390);
121086
            oprot.writeI64(_iter395);
121089
          }
121087
          }
121090
          oprot.writeListEnd();
121088
          oprot.writeListEnd();
121091
        }
121089
        }
121092
        oprot.writeFieldEnd();
121090
        oprot.writeFieldEnd();
121093
      }
121091
      }
Line 121395... Line 121393...
121395
        }
121393
        }
121396
        switch (field.id) {
121394
        switch (field.id) {
121397
          case 0: // SUCCESS
121395
          case 0: // SUCCESS
121398
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
121396
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
121399
              {
121397
              {
121400
                org.apache.thrift.protocol.TMap _map391 = iprot.readMapBegin();
121398
                org.apache.thrift.protocol.TMap _map396 = iprot.readMapBegin();
121401
                this.success = new HashMap<Long,PrivateDeal>(2*_map391.size);
121399
                this.success = new HashMap<Long,PrivateDeal>(2*_map396.size);
121402
                for (int _i392 = 0; _i392 < _map391.size; ++_i392)
121400
                for (int _i397 = 0; _i397 < _map396.size; ++_i397)
121403
                {
121401
                {
121404
                  long _key393; // required
121402
                  long _key398; // required
121405
                  PrivateDeal _val394; // required
121403
                  PrivateDeal _val399; // required
121406
                  _key393 = iprot.readI64();
121404
                  _key398 = iprot.readI64();
121407
                  _val394 = new PrivateDeal();
121405
                  _val399 = new PrivateDeal();
121408
                  _val394.read(iprot);
121406
                  _val399.read(iprot);
121409
                  this.success.put(_key393, _val394);
121407
                  this.success.put(_key398, _val399);
121410
                }
121408
                }
121411
                iprot.readMapEnd();
121409
                iprot.readMapEnd();
121412
              }
121410
              }
121413
            } else { 
121411
            } else { 
121414
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
121412
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 121428... Line 121426...
121428
 
121426
 
121429
      if (this.isSetSuccess()) {
121427
      if (this.isSetSuccess()) {
121430
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
121428
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
121431
        {
121429
        {
121432
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
121430
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
121433
          for (Map.Entry<Long, PrivateDeal> _iter395 : this.success.entrySet())
121431
          for (Map.Entry<Long, PrivateDeal> _iter400 : this.success.entrySet())
121434
          {
121432
          {
121435
            oprot.writeI64(_iter395.getKey());
121433
            oprot.writeI64(_iter400.getKey());
121436
            _iter395.getValue().write(oprot);
121434
            _iter400.getValue().write(oprot);
121437
          }
121435
          }
121438
          oprot.writeMapEnd();
121436
          oprot.writeMapEnd();
121439
        }
121437
        }
121440
        oprot.writeFieldEnd();
121438
        oprot.writeFieldEnd();
121441
      }
121439
      }
Line 122762... Line 122760...
122762
        }
122760
        }
122763
        switch (field.id) {
122761
        switch (field.id) {
122764
          case 0: // SUCCESS
122762
          case 0: // SUCCESS
122765
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
122763
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
122766
              {
122764
              {
122767
                org.apache.thrift.protocol.TList _list396 = iprot.readListBegin();
122765
                org.apache.thrift.protocol.TList _list401 = iprot.readListBegin();
122768
                this.success = new ArrayList<Long>(_list396.size);
122766
                this.success = new ArrayList<Long>(_list401.size);
122769
                for (int _i397 = 0; _i397 < _list396.size; ++_i397)
122767
                for (int _i402 = 0; _i402 < _list401.size; ++_i402)
122770
                {
122768
                {
122771
                  long _elem398; // required
122769
                  long _elem403; // required
122772
                  _elem398 = iprot.readI64();
122770
                  _elem403 = iprot.readI64();
122773
                  this.success.add(_elem398);
122771
                  this.success.add(_elem403);
122774
                }
122772
                }
122775
                iprot.readListEnd();
122773
                iprot.readListEnd();
122776
              }
122774
              }
122777
            } else { 
122775
            } else { 
122778
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
122776
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 122800... Line 122798...
122800
 
122798
 
122801
      if (this.isSetSuccess()) {
122799
      if (this.isSetSuccess()) {
122802
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
122800
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
122803
        {
122801
        {
122804
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
122802
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
122805
          for (long _iter399 : this.success)
122803
          for (long _iter404 : this.success)
122806
          {
122804
          {
122807
            oprot.writeI64(_iter399);
122805
            oprot.writeI64(_iter404);
122808
          }
122806
          }
122809
          oprot.writeListEnd();
122807
          oprot.writeListEnd();
122810
        }
122808
        }
122811
        oprot.writeFieldEnd();
122809
        oprot.writeFieldEnd();
122812
      } else if (this.isSetCex()) {
122810
      } else if (this.isSetCex()) {
Line 124393... Line 124391...
124393
        }
124391
        }
124394
        switch (field.id) {
124392
        switch (field.id) {
124395
          case 0: // SUCCESS
124393
          case 0: // SUCCESS
124396
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
124394
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
124397
              {
124395
              {
124398
                org.apache.thrift.protocol.TList _list400 = iprot.readListBegin();
124396
                org.apache.thrift.protocol.TList _list405 = iprot.readListBegin();
124399
                this.success = new ArrayList<PdPriceComp>(_list400.size);
124397
                this.success = new ArrayList<PdPriceComp>(_list405.size);
124400
                for (int _i401 = 0; _i401 < _list400.size; ++_i401)
124398
                for (int _i406 = 0; _i406 < _list405.size; ++_i406)
124401
                {
124399
                {
124402
                  PdPriceComp _elem402; // required
124400
                  PdPriceComp _elem407; // required
124403
                  _elem402 = new PdPriceComp();
124401
                  _elem407 = new PdPriceComp();
124404
                  _elem402.read(iprot);
124402
                  _elem407.read(iprot);
124405
                  this.success.add(_elem402);
124403
                  this.success.add(_elem407);
124406
                }
124404
                }
124407
                iprot.readListEnd();
124405
                iprot.readListEnd();
124408
              }
124406
              }
124409
            } else { 
124407
            } else { 
124410
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
124408
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 124424... Line 124422...
124424
 
124422
 
124425
      if (this.isSetSuccess()) {
124423
      if (this.isSetSuccess()) {
124426
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
124424
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
124427
        {
124425
        {
124428
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
124426
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
124429
          for (PdPriceComp _iter403 : this.success)
124427
          for (PdPriceComp _iter408 : this.success)
124430
          {
124428
          {
124431
            _iter403.write(oprot);
124429
            _iter408.write(oprot);
124432
          }
124430
          }
124433
          oprot.writeListEnd();
124431
          oprot.writeListEnd();
124434
        }
124432
        }
124435
        oprot.writeFieldEnd();
124433
        oprot.writeFieldEnd();
124436
      }
124434
      }
Line 124924... Line 124922...
124924
        }
124922
        }
124925
        switch (field.id) {
124923
        switch (field.id) {
124926
          case 0: // SUCCESS
124924
          case 0: // SUCCESS
124927
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
124925
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
124928
              {
124926
              {
124929
                org.apache.thrift.protocol.TList _list404 = iprot.readListBegin();
124927
                org.apache.thrift.protocol.TList _list409 = iprot.readListBegin();
124930
                this.success = new ArrayList<SnapdealItem>(_list404.size);
124928
                this.success = new ArrayList<SnapdealItem>(_list409.size);
124931
                for (int _i405 = 0; _i405 < _list404.size; ++_i405)
124929
                for (int _i410 = 0; _i410 < _list409.size; ++_i410)
124932
                {
124930
                {
124933
                  SnapdealItem _elem406; // required
124931
                  SnapdealItem _elem411; // required
124934
                  _elem406 = new SnapdealItem();
124932
                  _elem411 = new SnapdealItem();
124935
                  _elem406.read(iprot);
124933
                  _elem411.read(iprot);
124936
                  this.success.add(_elem406);
124934
                  this.success.add(_elem411);
124937
                }
124935
                }
124938
                iprot.readListEnd();
124936
                iprot.readListEnd();
124939
              }
124937
              }
124940
            } else { 
124938
            } else { 
124941
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
124939
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 124955... Line 124953...
124955
 
124953
 
124956
      if (this.isSetSuccess()) {
124954
      if (this.isSetSuccess()) {
124957
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
124955
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
124958
        {
124956
        {
124959
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
124957
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
124960
          for (SnapdealItem _iter407 : this.success)
124958
          for (SnapdealItem _iter412 : this.success)
124961
          {
124959
          {
124962
            _iter407.write(oprot);
124960
            _iter412.write(oprot);
124963
          }
124961
          }
124964
          oprot.writeListEnd();
124962
          oprot.writeListEnd();
124965
        }
124963
        }
124966
        oprot.writeFieldEnd();
124964
        oprot.writeFieldEnd();
124967
      }
124965
      }
Line 125455... Line 125453...
125455
        }
125453
        }
125456
        switch (field.id) {
125454
        switch (field.id) {
125457
          case 0: // SUCCESS
125455
          case 0: // SUCCESS
125458
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
125456
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
125459
              {
125457
              {
125460
                org.apache.thrift.protocol.TList _list408 = iprot.readListBegin();
125458
                org.apache.thrift.protocol.TList _list413 = iprot.readListBegin();
125461
                this.success = new ArrayList<FlipkartItem>(_list408.size);
125459
                this.success = new ArrayList<FlipkartItem>(_list413.size);
125462
                for (int _i409 = 0; _i409 < _list408.size; ++_i409)
125460
                for (int _i414 = 0; _i414 < _list413.size; ++_i414)
125463
                {
125461
                {
125464
                  FlipkartItem _elem410; // required
125462
                  FlipkartItem _elem415; // required
125465
                  _elem410 = new FlipkartItem();
125463
                  _elem415 = new FlipkartItem();
125466
                  _elem410.read(iprot);
125464
                  _elem415.read(iprot);
125467
                  this.success.add(_elem410);
125465
                  this.success.add(_elem415);
125468
                }
125466
                }
125469
                iprot.readListEnd();
125467
                iprot.readListEnd();
125470
              }
125468
              }
125471
            } else { 
125469
            } else { 
125472
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
125470
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 125486... Line 125484...
125486
 
125484
 
125487
      if (this.isSetSuccess()) {
125485
      if (this.isSetSuccess()) {
125488
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
125486
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
125489
        {
125487
        {
125490
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
125488
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
125491
          for (FlipkartItem _iter411 : this.success)
125489
          for (FlipkartItem _iter416 : this.success)
125492
          {
125490
          {
125493
            _iter411.write(oprot);
125491
            _iter416.write(oprot);
125494
          }
125492
          }
125495
          oprot.writeListEnd();
125493
          oprot.writeListEnd();
125496
        }
125494
        }
125497
        oprot.writeFieldEnd();
125495
        oprot.writeFieldEnd();
125498
      }
125496
      }
Line 125791... Line 125789...
125791
        }
125789
        }
125792
        switch (field.id) {
125790
        switch (field.id) {
125793
          case 1: // COMPETITOR_PRICING_MAP
125791
          case 1: // COMPETITOR_PRICING_MAP
125794
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
125792
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
125795
              {
125793
              {
125796
                org.apache.thrift.protocol.TMap _map412 = iprot.readMapBegin();
125794
                org.apache.thrift.protocol.TMap _map417 = iprot.readMapBegin();
125797
                this.competitorPricingMap = new HashMap<Long,CompetitorPricing>(2*_map412.size);
125795
                this.competitorPricingMap = new HashMap<Long,CompetitorPricing>(2*_map417.size);
125798
                for (int _i413 = 0; _i413 < _map412.size; ++_i413)
125796
                for (int _i418 = 0; _i418 < _map417.size; ++_i418)
125799
                {
125797
                {
125800
                  long _key414; // required
125798
                  long _key419; // required
125801
                  CompetitorPricing _val415; // required
125799
                  CompetitorPricing _val420; // required
125802
                  _key414 = iprot.readI64();
125800
                  _key419 = iprot.readI64();
125803
                  _val415 = new CompetitorPricing();
125801
                  _val420 = new CompetitorPricing();
125804
                  _val415.read(iprot);
125802
                  _val420.read(iprot);
125805
                  this.competitorPricingMap.put(_key414, _val415);
125803
                  this.competitorPricingMap.put(_key419, _val420);
125806
                }
125804
                }
125807
                iprot.readMapEnd();
125805
                iprot.readMapEnd();
125808
              }
125806
              }
125809
            } else { 
125807
            } else { 
125810
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
125808
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 125825... Line 125823...
125825
      oprot.writeStructBegin(STRUCT_DESC);
125823
      oprot.writeStructBegin(STRUCT_DESC);
125826
      if (this.competitorPricingMap != null) {
125824
      if (this.competitorPricingMap != null) {
125827
        oprot.writeFieldBegin(COMPETITOR_PRICING_MAP_FIELD_DESC);
125825
        oprot.writeFieldBegin(COMPETITOR_PRICING_MAP_FIELD_DESC);
125828
        {
125826
        {
125829
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRUCT, this.competitorPricingMap.size()));
125827
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRUCT, this.competitorPricingMap.size()));
125830
          for (Map.Entry<Long, CompetitorPricing> _iter416 : this.competitorPricingMap.entrySet())
125828
          for (Map.Entry<Long, CompetitorPricing> _iter421 : this.competitorPricingMap.entrySet())
125831
          {
125829
          {
125832
            oprot.writeI64(_iter416.getKey());
125830
            oprot.writeI64(_iter421.getKey());
125833
            _iter416.getValue().write(oprot);
125831
            _iter421.getValue().write(oprot);
125834
          }
125832
          }
125835
          oprot.writeMapEnd();
125833
          oprot.writeMapEnd();
125836
        }
125834
        }
125837
        oprot.writeFieldEnd();
125835
        oprot.writeFieldEnd();
125838
      }
125836
      }
Line 126619... Line 126617...
126619
        }
126617
        }
126620
        switch (field.id) {
126618
        switch (field.id) {
126621
          case 0: // SUCCESS
126619
          case 0: // SUCCESS
126622
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
126620
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
126623
              {
126621
              {
126624
                org.apache.thrift.protocol.TList _list417 = iprot.readListBegin();
126622
                org.apache.thrift.protocol.TList _list422 = iprot.readListBegin();
126625
                this.success = new ArrayList<CompetitorPricing>(_list417.size);
126623
                this.success = new ArrayList<CompetitorPricing>(_list422.size);
126626
                for (int _i418 = 0; _i418 < _list417.size; ++_i418)
126624
                for (int _i423 = 0; _i423 < _list422.size; ++_i423)
126627
                {
126625
                {
126628
                  CompetitorPricing _elem419; // required
126626
                  CompetitorPricing _elem424; // required
126629
                  _elem419 = new CompetitorPricing();
126627
                  _elem424 = new CompetitorPricing();
126630
                  _elem419.read(iprot);
126628
                  _elem424.read(iprot);
126631
                  this.success.add(_elem419);
126629
                  this.success.add(_elem424);
126632
                }
126630
                }
126633
                iprot.readListEnd();
126631
                iprot.readListEnd();
126634
              }
126632
              }
126635
            } else { 
126633
            } else { 
126636
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
126634
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 126650... Line 126648...
126650
 
126648
 
126651
      if (this.isSetSuccess()) {
126649
      if (this.isSetSuccess()) {
126652
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
126650
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
126653
        {
126651
        {
126654
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
126652
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
126655
          for (CompetitorPricing _iter420 : this.success)
126653
          for (CompetitorPricing _iter425 : this.success)
126656
          {
126654
          {
126657
            _iter420.write(oprot);
126655
            _iter425.write(oprot);
126658
          }
126656
          }
126659
          oprot.writeListEnd();
126657
          oprot.writeListEnd();
126660
        }
126658
        }
126661
        oprot.writeFieldEnd();
126659
        oprot.writeFieldEnd();
126662
      }
126660
      }
Line 127244... Line 127242...
127244
        }
127242
        }
127245
        switch (field.id) {
127243
        switch (field.id) {
127246
          case 0: // SUCCESS
127244
          case 0: // SUCCESS
127247
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
127245
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
127248
              {
127246
              {
127249
                org.apache.thrift.protocol.TList _list421 = iprot.readListBegin();
127247
                org.apache.thrift.protocol.TList _list426 = iprot.readListBegin();
127250
                this.success = new ArrayList<CompetitorPricing>(_list421.size);
127248
                this.success = new ArrayList<CompetitorPricing>(_list426.size);
127251
                for (int _i422 = 0; _i422 < _list421.size; ++_i422)
127249
                for (int _i427 = 0; _i427 < _list426.size; ++_i427)
127252
                {
127250
                {
127253
                  CompetitorPricing _elem423; // required
127251
                  CompetitorPricing _elem428; // required
127254
                  _elem423 = new CompetitorPricing();
127252
                  _elem428 = new CompetitorPricing();
127255
                  _elem423.read(iprot);
127253
                  _elem428.read(iprot);
127256
                  this.success.add(_elem423);
127254
                  this.success.add(_elem428);
127257
                }
127255
                }
127258
                iprot.readListEnd();
127256
                iprot.readListEnd();
127259
              }
127257
              }
127260
            } else { 
127258
            } else { 
127261
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
127259
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 127275... Line 127273...
127275
 
127273
 
127276
      if (this.isSetSuccess()) {
127274
      if (this.isSetSuccess()) {
127277
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
127275
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
127278
        {
127276
        {
127279
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
127277
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
127280
          for (CompetitorPricing _iter424 : this.success)
127278
          for (CompetitorPricing _iter429 : this.success)
127281
          {
127279
          {
127282
            _iter424.write(oprot);
127280
            _iter429.write(oprot);
127283
          }
127281
          }
127284
          oprot.writeListEnd();
127282
          oprot.writeListEnd();
127285
        }
127283
        }
127286
        oprot.writeFieldEnd();
127284
        oprot.writeFieldEnd();
127287
      }
127285
      }
Line 127580... Line 127578...
127580
        }
127578
        }
127581
        switch (field.id) {
127579
        switch (field.id) {
127582
          case 1: // AMAZON_PROMOTIONS
127580
          case 1: // AMAZON_PROMOTIONS
127583
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
127581
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
127584
              {
127582
              {
127585
                org.apache.thrift.protocol.TMap _map425 = iprot.readMapBegin();
127583
                org.apache.thrift.protocol.TMap _map430 = iprot.readMapBegin();
127586
                this.amazonPromotions = new HashMap<String,AmazonPromotion>(2*_map425.size);
127584
                this.amazonPromotions = new HashMap<String,AmazonPromotion>(2*_map430.size);
127587
                for (int _i426 = 0; _i426 < _map425.size; ++_i426)
127585
                for (int _i431 = 0; _i431 < _map430.size; ++_i431)
127588
                {
127586
                {
127589
                  String _key427; // required
127587
                  String _key432; // required
127590
                  AmazonPromotion _val428; // required
127588
                  AmazonPromotion _val433; // required
127591
                  _key427 = iprot.readString();
127589
                  _key432 = iprot.readString();
127592
                  _val428 = new AmazonPromotion();
127590
                  _val433 = new AmazonPromotion();
127593
                  _val428.read(iprot);
127591
                  _val433.read(iprot);
127594
                  this.amazonPromotions.put(_key427, _val428);
127592
                  this.amazonPromotions.put(_key432, _val433);
127595
                }
127593
                }
127596
                iprot.readMapEnd();
127594
                iprot.readMapEnd();
127597
              }
127595
              }
127598
            } else { 
127596
            } else { 
127599
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
127597
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 127614... Line 127612...
127614
      oprot.writeStructBegin(STRUCT_DESC);
127612
      oprot.writeStructBegin(STRUCT_DESC);
127615
      if (this.amazonPromotions != null) {
127613
      if (this.amazonPromotions != null) {
127616
        oprot.writeFieldBegin(AMAZON_PROMOTIONS_FIELD_DESC);
127614
        oprot.writeFieldBegin(AMAZON_PROMOTIONS_FIELD_DESC);
127617
        {
127615
        {
127618
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, this.amazonPromotions.size()));
127616
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, this.amazonPromotions.size()));
127619
          for (Map.Entry<String, AmazonPromotion> _iter429 : this.amazonPromotions.entrySet())
127617
          for (Map.Entry<String, AmazonPromotion> _iter434 : this.amazonPromotions.entrySet())
127620
          {
127618
          {
127621
            oprot.writeString(_iter429.getKey());
127619
            oprot.writeString(_iter434.getKey());
127622
            _iter429.getValue().write(oprot);
127620
            _iter434.getValue().write(oprot);
127623
          }
127621
          }
127624
          oprot.writeMapEnd();
127622
          oprot.writeMapEnd();
127625
        }
127623
        }
127626
        oprot.writeFieldEnd();
127624
        oprot.writeFieldEnd();
127627
      }
127625
      }
Line 127983... Line 127981...
127983
        }
127981
        }
127984
        switch (field.id) {
127982
        switch (field.id) {
127985
          case 0: // SUCCESS
127983
          case 0: // SUCCESS
127986
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
127984
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
127987
              {
127985
              {
127988
                org.apache.thrift.protocol.TList _list430 = iprot.readListBegin();
127986
                org.apache.thrift.protocol.TList _list435 = iprot.readListBegin();
127989
                this.success = new ArrayList<String>(_list430.size);
127987
                this.success = new ArrayList<String>(_list435.size);
127990
                for (int _i431 = 0; _i431 < _list430.size; ++_i431)
127988
                for (int _i436 = 0; _i436 < _list435.size; ++_i436)
127991
                {
127989
                {
127992
                  String _elem432; // required
127990
                  String _elem437; // required
127993
                  _elem432 = iprot.readString();
127991
                  _elem437 = iprot.readString();
127994
                  this.success.add(_elem432);
127992
                  this.success.add(_elem437);
127995
                }
127993
                }
127996
                iprot.readListEnd();
127994
                iprot.readListEnd();
127997
              }
127995
              }
127998
            } else { 
127996
            } else { 
127999
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
127997
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 128021... Line 128019...
128021
 
128019
 
128022
      if (this.isSetSuccess()) {
128020
      if (this.isSetSuccess()) {
128023
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
128021
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
128024
        {
128022
        {
128025
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
128023
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
128026
          for (String _iter433 : this.success)
128024
          for (String _iter438 : this.success)
128027
          {
128025
          {
128028
            oprot.writeString(_iter433);
128026
            oprot.writeString(_iter438);
128029
          }
128027
          }
128030
          oprot.writeListEnd();
128028
          oprot.writeListEnd();
128031
        }
128029
        }
128032
        oprot.writeFieldEnd();
128030
        oprot.writeFieldEnd();
128033
      } else if (this.isSetCex()) {
128031
      } else if (this.isSetCex()) {
Line 128710... Line 128708...
128710
        }
128708
        }
128711
        switch (field.id) {
128709
        switch (field.id) {
128712
          case 0: // SUCCESS
128710
          case 0: // SUCCESS
128713
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
128711
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
128714
              {
128712
              {
128715
                org.apache.thrift.protocol.TList _list434 = iprot.readListBegin();
128713
                org.apache.thrift.protocol.TList _list439 = iprot.readListBegin();
128716
                this.success = new ArrayList<AmazonPromotion>(_list434.size);
128714
                this.success = new ArrayList<AmazonPromotion>(_list439.size);
128717
                for (int _i435 = 0; _i435 < _list434.size; ++_i435)
128715
                for (int _i440 = 0; _i440 < _list439.size; ++_i440)
128718
                {
128716
                {
128719
                  AmazonPromotion _elem436; // required
128717
                  AmazonPromotion _elem441; // required
128720
                  _elem436 = new AmazonPromotion();
128718
                  _elem441 = new AmazonPromotion();
128721
                  _elem436.read(iprot);
128719
                  _elem441.read(iprot);
128722
                  this.success.add(_elem436);
128720
                  this.success.add(_elem441);
128723
                }
128721
                }
128724
                iprot.readListEnd();
128722
                iprot.readListEnd();
128725
              }
128723
              }
128726
            } else { 
128724
            } else { 
128727
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
128725
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 128741... Line 128739...
128741
 
128739
 
128742
      if (this.isSetSuccess()) {
128740
      if (this.isSetSuccess()) {
128743
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
128741
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
128744
        {
128742
        {
128745
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
128743
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
128746
          for (AmazonPromotion _iter437 : this.success)
128744
          for (AmazonPromotion _iter442 : this.success)
128747
          {
128745
          {
128748
            _iter437.write(oprot);
128746
            _iter442.write(oprot);
128749
          }
128747
          }
128750
          oprot.writeListEnd();
128748
          oprot.writeListEnd();
128751
        }
128749
        }
128752
        oprot.writeFieldEnd();
128750
        oprot.writeFieldEnd();
128753
      }
128751
      }
Line 129041... Line 129039...
129041
        }
129039
        }
129042
        switch (field.id) {
129040
        switch (field.id) {
129043
          case 1: // AMAZON_PROMOTIONS
129041
          case 1: // AMAZON_PROMOTIONS
129044
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
129042
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
129045
              {
129043
              {
129046
                org.apache.thrift.protocol.TList _list438 = iprot.readListBegin();
129044
                org.apache.thrift.protocol.TList _list443 = iprot.readListBegin();
129047
                this.amazonPromotions = new ArrayList<AmazonPromotion>(_list438.size);
129045
                this.amazonPromotions = new ArrayList<AmazonPromotion>(_list443.size);
129048
                for (int _i439 = 0; _i439 < _list438.size; ++_i439)
129046
                for (int _i444 = 0; _i444 < _list443.size; ++_i444)
129049
                {
129047
                {
129050
                  AmazonPromotion _elem440; // required
129048
                  AmazonPromotion _elem445; // required
129051
                  _elem440 = new AmazonPromotion();
129049
                  _elem445 = new AmazonPromotion();
129052
                  _elem440.read(iprot);
129050
                  _elem445.read(iprot);
129053
                  this.amazonPromotions.add(_elem440);
129051
                  this.amazonPromotions.add(_elem445);
129054
                }
129052
                }
129055
                iprot.readListEnd();
129053
                iprot.readListEnd();
129056
              }
129054
              }
129057
            } else { 
129055
            } else { 
129058
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
129056
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 129073... Line 129071...
129073
      oprot.writeStructBegin(STRUCT_DESC);
129071
      oprot.writeStructBegin(STRUCT_DESC);
129074
      if (this.amazonPromotions != null) {
129072
      if (this.amazonPromotions != null) {
129075
        oprot.writeFieldBegin(AMAZON_PROMOTIONS_FIELD_DESC);
129073
        oprot.writeFieldBegin(AMAZON_PROMOTIONS_FIELD_DESC);
129076
        {
129074
        {
129077
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.amazonPromotions.size()));
129075
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.amazonPromotions.size()));
129078
          for (AmazonPromotion _iter441 : this.amazonPromotions)
129076
          for (AmazonPromotion _iter446 : this.amazonPromotions)
129079
          {
129077
          {
129080
            _iter441.write(oprot);
129078
            _iter446.write(oprot);
129081
          }
129079
          }
129082
          oprot.writeListEnd();
129080
          oprot.writeListEnd();
129083
        }
129081
        }
129084
        oprot.writeFieldEnd();
129082
        oprot.writeFieldEnd();
129085
      }
129083
      }
Line 130420... Line 130418...
130420
            }
130418
            }
130421
            break;
130419
            break;
130422
          case 2: // STATEVAT
130420
          case 2: // STATEVAT
130423
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
130421
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
130424
              {
130422
              {
130425
                org.apache.thrift.protocol.TMap _map442 = iprot.readMapBegin();
130423
                org.apache.thrift.protocol.TMap _map447 = iprot.readMapBegin();
130426
                this.statevat = new HashMap<Long,Double>(2*_map442.size);
130424
                this.statevat = new HashMap<Long,Double>(2*_map447.size);
130427
                for (int _i443 = 0; _i443 < _map442.size; ++_i443)
130425
                for (int _i448 = 0; _i448 < _map447.size; ++_i448)
130428
                {
130426
                {
130429
                  long _key444; // required
130427
                  long _key449; // required
130430
                  double _val445; // required
130428
                  double _val450; // required
130431
                  _key444 = iprot.readI64();
130429
                  _key449 = iprot.readI64();
130432
                  _val445 = iprot.readDouble();
130430
                  _val450 = iprot.readDouble();
130433
                  this.statevat.put(_key444, _val445);
130431
                  this.statevat.put(_key449, _val450);
130434
                }
130432
                }
130435
                iprot.readMapEnd();
130433
                iprot.readMapEnd();
130436
              }
130434
              }
130437
            } else { 
130435
            } else { 
130438
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
130436
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 130456... Line 130454...
130456
      oprot.writeFieldEnd();
130454
      oprot.writeFieldEnd();
130457
      if (this.statevat != null) {
130455
      if (this.statevat != null) {
130458
        oprot.writeFieldBegin(STATEVAT_FIELD_DESC);
130456
        oprot.writeFieldBegin(STATEVAT_FIELD_DESC);
130459
        {
130457
        {
130460
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.DOUBLE, this.statevat.size()));
130458
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.DOUBLE, this.statevat.size()));
130461
          for (Map.Entry<Long, Double> _iter446 : this.statevat.entrySet())
130459
          for (Map.Entry<Long, Double> _iter451 : this.statevat.entrySet())
130462
          {
130460
          {
130463
            oprot.writeI64(_iter446.getKey());
130461
            oprot.writeI64(_iter451.getKey());
130464
            oprot.writeDouble(_iter446.getValue());
130462
            oprot.writeDouble(_iter451.getValue());
130465
          }
130463
          }
130466
          oprot.writeMapEnd();
130464
          oprot.writeMapEnd();
130467
        }
130465
        }
130468
        oprot.writeFieldEnd();
130466
        oprot.writeFieldEnd();
130469
      }
130467
      }
Line 131261... Line 131259...
131261
        }
131259
        }
131262
        switch (field.id) {
131260
        switch (field.id) {
131263
          case 0: // SUCCESS
131261
          case 0: // SUCCESS
131264
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
131262
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
131265
              {
131263
              {
131266
                org.apache.thrift.protocol.TMap _map447 = iprot.readMapBegin();
131264
                org.apache.thrift.protocol.TMap _map452 = iprot.readMapBegin();
131267
                this.success = new HashMap<Long,ExclusiveAffiliateItemInfo>(2*_map447.size);
131265
                this.success = new HashMap<Long,ExclusiveAffiliateItemInfo>(2*_map452.size);
131268
                for (int _i448 = 0; _i448 < _map447.size; ++_i448)
131266
                for (int _i453 = 0; _i453 < _map452.size; ++_i453)
131269
                {
131267
                {
131270
                  long _key449; // required
131268
                  long _key454; // required
131271
                  ExclusiveAffiliateItemInfo _val450; // required
131269
                  ExclusiveAffiliateItemInfo _val455; // required
131272
                  _key449 = iprot.readI64();
131270
                  _key454 = iprot.readI64();
131273
                  _val450 = new ExclusiveAffiliateItemInfo();
131271
                  _val455 = new ExclusiveAffiliateItemInfo();
131274
                  _val450.read(iprot);
131272
                  _val455.read(iprot);
131275
                  this.success.put(_key449, _val450);
131273
                  this.success.put(_key454, _val455);
131276
                }
131274
                }
131277
                iprot.readMapEnd();
131275
                iprot.readMapEnd();
131278
              }
131276
              }
131279
            } else { 
131277
            } else { 
131280
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
131278
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 131294... Line 131292...
131294
 
131292
 
131295
      if (this.isSetSuccess()) {
131293
      if (this.isSetSuccess()) {
131296
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
131294
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
131297
        {
131295
        {
131298
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
131296
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
131299
          for (Map.Entry<Long, ExclusiveAffiliateItemInfo> _iter451 : this.success.entrySet())
131297
          for (Map.Entry<Long, ExclusiveAffiliateItemInfo> _iter456 : this.success.entrySet())
131300
          {
131298
          {
131301
            oprot.writeI64(_iter451.getKey());
131299
            oprot.writeI64(_iter456.getKey());
131302
            _iter451.getValue().write(oprot);
131300
            _iter456.getValue().write(oprot);
131303
          }
131301
          }
131304
          oprot.writeMapEnd();
131302
          oprot.writeMapEnd();
131305
        }
131303
        }
131306
        oprot.writeFieldEnd();
131304
        oprot.writeFieldEnd();
131307
      }
131305
      }
Line 131795... Line 131793...
131795
        }
131793
        }
131796
        switch (field.id) {
131794
        switch (field.id) {
131797
          case 0: // SUCCESS
131795
          case 0: // SUCCESS
131798
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
131796
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
131799
              {
131797
              {
131800
                org.apache.thrift.protocol.TList _list452 = iprot.readListBegin();
131798
                org.apache.thrift.protocol.TList _list457 = iprot.readListBegin();
131801
                this.success = new ArrayList<Amazonlisted>(_list452.size);
131799
                this.success = new ArrayList<Amazonlisted>(_list457.size);
131802
                for (int _i453 = 0; _i453 < _list452.size; ++_i453)
131800
                for (int _i458 = 0; _i458 < _list457.size; ++_i458)
131803
                {
131801
                {
131804
                  Amazonlisted _elem454; // required
131802
                  Amazonlisted _elem459; // required
131805
                  _elem454 = new Amazonlisted();
131803
                  _elem459 = new Amazonlisted();
131806
                  _elem454.read(iprot);
131804
                  _elem459.read(iprot);
131807
                  this.success.add(_elem454);
131805
                  this.success.add(_elem459);
131808
                }
131806
                }
131809
                iprot.readListEnd();
131807
                iprot.readListEnd();
131810
              }
131808
              }
131811
            } else { 
131809
            } else { 
131812
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
131810
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 131826... Line 131824...
131826
 
131824
 
131827
      if (this.isSetSuccess()) {
131825
      if (this.isSetSuccess()) {
131828
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
131826
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
131829
        {
131827
        {
131830
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
131828
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
131831
          for (Amazonlisted _iter455 : this.success)
131829
          for (Amazonlisted _iter460 : this.success)
131832
          {
131830
          {
131833
            _iter455.write(oprot);
131831
            _iter460.write(oprot);
131834
          }
131832
          }
131835
          oprot.writeListEnd();
131833
          oprot.writeListEnd();
131836
        }
131834
        }
131837
        oprot.writeFieldEnd();
131835
        oprot.writeFieldEnd();
131838
      }
131836
      }
Line 132326... Line 132324...
132326
        }
132324
        }
132327
        switch (field.id) {
132325
        switch (field.id) {
132328
          case 0: // SUCCESS
132326
          case 0: // SUCCESS
132329
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
132327
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
132330
              {
132328
              {
132331
                org.apache.thrift.protocol.TList _list456 = iprot.readListBegin();
132329
                org.apache.thrift.protocol.TList _list461 = iprot.readListBegin();
132332
                this.success = new ArrayList<Amazonlisted>(_list456.size);
132330
                this.success = new ArrayList<Amazonlisted>(_list461.size);
132333
                for (int _i457 = 0; _i457 < _list456.size; ++_i457)
132331
                for (int _i462 = 0; _i462 < _list461.size; ++_i462)
132334
                {
132332
                {
132335
                  Amazonlisted _elem458; // required
132333
                  Amazonlisted _elem463; // required
132336
                  _elem458 = new Amazonlisted();
132334
                  _elem463 = new Amazonlisted();
132337
                  _elem458.read(iprot);
132335
                  _elem463.read(iprot);
132338
                  this.success.add(_elem458);
132336
                  this.success.add(_elem463);
132339
                }
132337
                }
132340
                iprot.readListEnd();
132338
                iprot.readListEnd();
132341
              }
132339
              }
132342
            } else { 
132340
            } else { 
132343
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
132341
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 132357... Line 132355...
132357
 
132355
 
132358
      if (this.isSetSuccess()) {
132356
      if (this.isSetSuccess()) {
132359
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
132357
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
132360
        {
132358
        {
132361
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
132359
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
132362
          for (Amazonlisted _iter459 : this.success)
132360
          for (Amazonlisted _iter464 : this.success)
132363
          {
132361
          {
132364
            _iter459.write(oprot);
132362
            _iter464.write(oprot);
132365
          }
132363
          }
132366
          oprot.writeListEnd();
132364
          oprot.writeListEnd();
132367
        }
132365
        }
132368
        oprot.writeFieldEnd();
132366
        oprot.writeFieldEnd();
132369
      }
132367
      }
Line 132675... Line 132673...
132675
        }
132673
        }
132676
        switch (field.id) {
132674
        switch (field.id) {
132677
          case 1: // LINES
132675
          case 1: // LINES
132678
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
132676
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
132679
              {
132677
              {
132680
                org.apache.thrift.protocol.TMap _map460 = iprot.readMapBegin();
132678
                org.apache.thrift.protocol.TMap _map465 = iprot.readMapBegin();
132681
                this.lines = new HashMap<Long,Map<String,Long>>(2*_map460.size);
132679
                this.lines = new HashMap<Long,Map<String,Long>>(2*_map465.size);
132682
                for (int _i461 = 0; _i461 < _map460.size; ++_i461)
132680
                for (int _i466 = 0; _i466 < _map465.size; ++_i466)
132683
                {
132681
                {
132684
                  long _key462; // required
132682
                  long _key467; // required
132685
                  Map<String,Long> _val463; // required
132683
                  Map<String,Long> _val468; // required
132686
                  _key462 = iprot.readI64();
132684
                  _key467 = iprot.readI64();
132687
                  {
132685
                  {
132688
                    org.apache.thrift.protocol.TMap _map464 = iprot.readMapBegin();
132686
                    org.apache.thrift.protocol.TMap _map469 = iprot.readMapBegin();
132689
                    _val463 = new HashMap<String,Long>(2*_map464.size);
132687
                    _val468 = new HashMap<String,Long>(2*_map469.size);
132690
                    for (int _i465 = 0; _i465 < _map464.size; ++_i465)
132688
                    for (int _i470 = 0; _i470 < _map469.size; ++_i470)
132691
                    {
132689
                    {
132692
                      String _key466; // required
132690
                      String _key471; // required
132693
                      long _val467; // required
132691
                      long _val472; // required
132694
                      _key466 = iprot.readString();
132692
                      _key471 = iprot.readString();
132695
                      _val467 = iprot.readI64();
132693
                      _val472 = iprot.readI64();
132696
                      _val463.put(_key466, _val467);
132694
                      _val468.put(_key471, _val472);
132697
                    }
132695
                    }
132698
                    iprot.readMapEnd();
132696
                    iprot.readMapEnd();
132699
                  }
132697
                  }
132700
                  this.lines.put(_key462, _val463);
132698
                  this.lines.put(_key467, _val468);
132701
                }
132699
                }
132702
                iprot.readMapEnd();
132700
                iprot.readMapEnd();
132703
              }
132701
              }
132704
            } else { 
132702
            } else { 
132705
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
132703
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 132720... Line 132718...
132720
      oprot.writeStructBegin(STRUCT_DESC);
132718
      oprot.writeStructBegin(STRUCT_DESC);
132721
      if (this.lines != null) {
132719
      if (this.lines != null) {
132722
        oprot.writeFieldBegin(LINES_FIELD_DESC);
132720
        oprot.writeFieldBegin(LINES_FIELD_DESC);
132723
        {
132721
        {
132724
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.MAP, this.lines.size()));
132722
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.MAP, this.lines.size()));
132725
          for (Map.Entry<Long, Map<String,Long>> _iter468 : this.lines.entrySet())
132723
          for (Map.Entry<Long, Map<String,Long>> _iter473 : this.lines.entrySet())
132726
          {
132724
          {
132727
            oprot.writeI64(_iter468.getKey());
132725
            oprot.writeI64(_iter473.getKey());
132728
            {
132726
            {
132729
              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I64, _iter468.getValue().size()));
132727
              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I64, _iter473.getValue().size()));
132730
              for (Map.Entry<String, Long> _iter469 : _iter468.getValue().entrySet())
132728
              for (Map.Entry<String, Long> _iter474 : _iter473.getValue().entrySet())
132731
              {
132729
              {
132732
                oprot.writeString(_iter469.getKey());
132730
                oprot.writeString(_iter474.getKey());
132733
                oprot.writeI64(_iter469.getValue());
132731
                oprot.writeI64(_iter474.getValue());
132734
              }
132732
              }
132735
              oprot.writeMapEnd();
132733
              oprot.writeMapEnd();
132736
            }
132734
            }
132737
          }
132735
          }
132738
          oprot.writeMapEnd();
132736
          oprot.writeMapEnd();
Line 133115... Line 133113...
133115
        }
133113
        }
133116
        switch (field.id) {
133114
        switch (field.id) {
133117
          case 0: // SUCCESS
133115
          case 0: // SUCCESS
133118
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
133116
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
133119
              {
133117
              {
133120
                org.apache.thrift.protocol.TMap _map470 = iprot.readMapBegin();
133118
                org.apache.thrift.protocol.TMap _map475 = iprot.readMapBegin();
133121
                this.success = new HashMap<Long,Map<String,Long>>(2*_map470.size);
133119
                this.success = new HashMap<Long,Map<String,Long>>(2*_map475.size);
133122
                for (int _i471 = 0; _i471 < _map470.size; ++_i471)
133120
                for (int _i476 = 0; _i476 < _map475.size; ++_i476)
133123
                {
133121
                {
133124
                  long _key472; // required
133122
                  long _key477; // required
133125
                  Map<String,Long> _val473; // required
133123
                  Map<String,Long> _val478; // required
133126
                  _key472 = iprot.readI64();
133124
                  _key477 = iprot.readI64();
133127
                  {
133125
                  {
133128
                    org.apache.thrift.protocol.TMap _map474 = iprot.readMapBegin();
133126
                    org.apache.thrift.protocol.TMap _map479 = iprot.readMapBegin();
133129
                    _val473 = new HashMap<String,Long>(2*_map474.size);
133127
                    _val478 = new HashMap<String,Long>(2*_map479.size);
133130
                    for (int _i475 = 0; _i475 < _map474.size; ++_i475)
133128
                    for (int _i480 = 0; _i480 < _map479.size; ++_i480)
133131
                    {
133129
                    {
133132
                      String _key476; // required
133130
                      String _key481; // required
133133
                      long _val477; // required
133131
                      long _val482; // required
133134
                      _key476 = iprot.readString();
133132
                      _key481 = iprot.readString();
133135
                      _val477 = iprot.readI64();
133133
                      _val482 = iprot.readI64();
133136
                      _val473.put(_key476, _val477);
133134
                      _val478.put(_key481, _val482);
133137
                    }
133135
                    }
133138
                    iprot.readMapEnd();
133136
                    iprot.readMapEnd();
133139
                  }
133137
                  }
133140
                  this.success.put(_key472, _val473);
133138
                  this.success.put(_key477, _val478);
133141
                }
133139
                }
133142
                iprot.readMapEnd();
133140
                iprot.readMapEnd();
133143
              }
133141
              }
133144
            } else { 
133142
            } else { 
133145
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
133143
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 133167... Line 133165...
133167
 
133165
 
133168
      if (this.isSetSuccess()) {
133166
      if (this.isSetSuccess()) {
133169
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
133167
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
133170
        {
133168
        {
133171
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.MAP, this.success.size()));
133169
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.MAP, this.success.size()));
133172
          for (Map.Entry<Long, Map<String,Long>> _iter478 : this.success.entrySet())
133170
          for (Map.Entry<Long, Map<String,Long>> _iter483 : this.success.entrySet())
133173
          {
133171
          {
133174
            oprot.writeI64(_iter478.getKey());
133172
            oprot.writeI64(_iter483.getKey());
133175
            {
133173
            {
133176
              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I64, _iter478.getValue().size()));
133174
              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I64, _iter483.getValue().size()));
133177
              for (Map.Entry<String, Long> _iter479 : _iter478.getValue().entrySet())
133175
              for (Map.Entry<String, Long> _iter484 : _iter483.getValue().entrySet())
133178
              {
133176
              {
133179
                oprot.writeString(_iter479.getKey());
133177
                oprot.writeString(_iter484.getKey());
133180
                oprot.writeI64(_iter479.getValue());
133178
                oprot.writeI64(_iter484.getValue());
133181
              }
133179
              }
133182
              oprot.writeMapEnd();
133180
              oprot.writeMapEnd();
133183
            }
133181
            }
133184
          }
133182
          }
133185
          oprot.writeMapEnd();
133183
          oprot.writeMapEnd();
Line 133488... Line 133486...
133488
        }
133486
        }
133489
        switch (field.id) {
133487
        switch (field.id) {
133490
          case 1: // HS_ITEMS
133488
          case 1: // HS_ITEMS
133491
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
133489
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
133492
              {
133490
              {
133493
                org.apache.thrift.protocol.TList _list480 = iprot.readListBegin();
133491
                org.apache.thrift.protocol.TList _list485 = iprot.readListBegin();
133494
                this.hsItems = new ArrayList<HsItem>(_list480.size);
133492
                this.hsItems = new ArrayList<HsItem>(_list485.size);
133495
                for (int _i481 = 0; _i481 < _list480.size; ++_i481)
133493
                for (int _i486 = 0; _i486 < _list485.size; ++_i486)
133496
                {
133494
                {
133497
                  HsItem _elem482; // required
133495
                  HsItem _elem487; // required
133498
                  _elem482 = new HsItem();
133496
                  _elem487 = new HsItem();
133499
                  _elem482.read(iprot);
133497
                  _elem487.read(iprot);
133500
                  this.hsItems.add(_elem482);
133498
                  this.hsItems.add(_elem487);
133501
                }
133499
                }
133502
                iprot.readListEnd();
133500
                iprot.readListEnd();
133503
              }
133501
              }
133504
            } else { 
133502
            } else { 
133505
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
133503
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 133520... Line 133518...
133520
      oprot.writeStructBegin(STRUCT_DESC);
133518
      oprot.writeStructBegin(STRUCT_DESC);
133521
      if (this.hsItems != null) {
133519
      if (this.hsItems != null) {
133522
        oprot.writeFieldBegin(HS_ITEMS_FIELD_DESC);
133520
        oprot.writeFieldBegin(HS_ITEMS_FIELD_DESC);
133523
        {
133521
        {
133524
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.hsItems.size()));
133522
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.hsItems.size()));
133525
          for (HsItem _iter483 : this.hsItems)
133523
          for (HsItem _iter488 : this.hsItems)
133526
          {
133524
          {
133527
            _iter483.write(oprot);
133525
            _iter488.write(oprot);
133528
          }
133526
          }
133529
          oprot.writeListEnd();
133527
          oprot.writeListEnd();
133530
        }
133528
        }
133531
        oprot.writeFieldEnd();
133529
        oprot.writeFieldEnd();
133532
      }
133530
      }
Line 135150... Line 135148...
135150
  public static class getPricingForDtr_result implements org.apache.thrift.TBase<getPricingForDtr_result, getPricingForDtr_result._Fields>, java.io.Serializable, Cloneable   {
135148
  public static class getPricingForDtr_result implements org.apache.thrift.TBase<getPricingForDtr_result, getPricingForDtr_result._Fields>, java.io.Serializable, Cloneable   {
135151
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getPricingForDtr_result");
135149
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getPricingForDtr_result");
135152
 
135150
 
135153
    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
135151
    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
135154
 
135152
 
135155
    private Item success; // required
135153
    private DtrPricing success; // required
135156
 
135154
 
135157
    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
135155
    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
135158
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
135156
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
135159
      SUCCESS((short)0, "success");
135157
      SUCCESS((short)0, "success");
135160
 
135158
 
Line 135216... Line 135214...
135216
 
135214
 
135217
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
135215
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
135218
    static {
135216
    static {
135219
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
135217
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
135220
      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
135218
      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
135221
          new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Item.class)));
135219
          new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, DtrPricing.class)));
135222
      metaDataMap = Collections.unmodifiableMap(tmpMap);
135220
      metaDataMap = Collections.unmodifiableMap(tmpMap);
135223
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getPricingForDtr_result.class, metaDataMap);
135221
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getPricingForDtr_result.class, metaDataMap);
135224
    }
135222
    }
135225
 
135223
 
135226
    public getPricingForDtr_result() {
135224
    public getPricingForDtr_result() {
135227
    }
135225
    }
135228
 
135226
 
135229
    public getPricingForDtr_result(
135227
    public getPricingForDtr_result(
135230
      Item success)
135228
      DtrPricing success)
135231
    {
135229
    {
135232
      this();
135230
      this();
135233
      this.success = success;
135231
      this.success = success;
135234
    }
135232
    }
135235
 
135233
 
135236
    /**
135234
    /**
135237
     * Performs a deep copy on <i>other</i>.
135235
     * Performs a deep copy on <i>other</i>.
135238
     */
135236
     */
135239
    public getPricingForDtr_result(getPricingForDtr_result other) {
135237
    public getPricingForDtr_result(getPricingForDtr_result other) {
135240
      if (other.isSetSuccess()) {
135238
      if (other.isSetSuccess()) {
135241
        this.success = new Item(other.success);
135239
        this.success = new DtrPricing(other.success);
135242
      }
135240
      }
135243
    }
135241
    }
135244
 
135242
 
135245
    public getPricingForDtr_result deepCopy() {
135243
    public getPricingForDtr_result deepCopy() {
135246
      return new getPricingForDtr_result(this);
135244
      return new getPricingForDtr_result(this);
Line 135249... Line 135247...
135249
    @Override
135247
    @Override
135250
    public void clear() {
135248
    public void clear() {
135251
      this.success = null;
135249
      this.success = null;
135252
    }
135250
    }
135253
 
135251
 
135254
    public Item getSuccess() {
135252
    public DtrPricing getSuccess() {
135255
      return this.success;
135253
      return this.success;
135256
    }
135254
    }
135257
 
135255
 
135258
    public void setSuccess(Item success) {
135256
    public void setSuccess(DtrPricing success) {
135259
      this.success = success;
135257
      this.success = success;
135260
    }
135258
    }
135261
 
135259
 
135262
    public void unsetSuccess() {
135260
    public void unsetSuccess() {
135263
      this.success = null;
135261
      this.success = null;
Line 135278... Line 135276...
135278
      switch (field) {
135276
      switch (field) {
135279
      case SUCCESS:
135277
      case SUCCESS:
135280
        if (value == null) {
135278
        if (value == null) {
135281
          unsetSuccess();
135279
          unsetSuccess();
135282
        } else {
135280
        } else {
135283
          setSuccess((Item)value);
135281
          setSuccess((DtrPricing)value);
135284
        }
135282
        }
135285
        break;
135283
        break;
135286
 
135284
 
135287
      }
135285
      }
135288
    }
135286
    }
Line 135374... Line 135372...
135374
          break;
135372
          break;
135375
        }
135373
        }
135376
        switch (field.id) {
135374
        switch (field.id) {
135377
          case 0: // SUCCESS
135375
          case 0: // SUCCESS
135378
            if (field.type == org.apache.thrift.protocol.TType.STRUCT) {
135376
            if (field.type == org.apache.thrift.protocol.TType.STRUCT) {
135379
              this.success = new Item();
135377
              this.success = new DtrPricing();
135380
              this.success.read(iprot);
135378
              this.success.read(iprot);
135381
            } else { 
135379
            } else { 
135382
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
135380
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
135383
            }
135381
            }
135384
            break;
135382
            break;
Line 135889... Line 135887...
135889
        }
135887
        }
135890
        switch (field.id) {
135888
        switch (field.id) {
135891
          case 0: // SUCCESS
135889
          case 0: // SUCCESS
135892
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
135890
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
135893
              {
135891
              {
135894
                org.apache.thrift.protocol.TList _list484 = iprot.readListBegin();
135892
                org.apache.thrift.protocol.TList _list489 = iprot.readListBegin();
135895
                this.success = new ArrayList<Amazonlisted>(_list484.size);
135893
                this.success = new ArrayList<Amazonlisted>(_list489.size);
135896
                for (int _i485 = 0; _i485 < _list484.size; ++_i485)
135894
                for (int _i490 = 0; _i490 < _list489.size; ++_i490)
135897
                {
135895
                {
135898
                  Amazonlisted _elem486; // required
135896
                  Amazonlisted _elem491; // required
135899
                  _elem486 = new Amazonlisted();
135897
                  _elem491 = new Amazonlisted();
135900
                  _elem486.read(iprot);
135898
                  _elem491.read(iprot);
135901
                  this.success.add(_elem486);
135899
                  this.success.add(_elem491);
135902
                }
135900
                }
135903
                iprot.readListEnd();
135901
                iprot.readListEnd();
135904
              }
135902
              }
135905
            } else { 
135903
            } else { 
135906
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
135904
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 135920... Line 135918...
135920
 
135918
 
135921
      if (this.isSetSuccess()) {
135919
      if (this.isSetSuccess()) {
135922
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
135920
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
135923
        {
135921
        {
135924
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
135922
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
135925
          for (Amazonlisted _iter487 : this.success)
135923
          for (Amazonlisted _iter492 : this.success)
135926
          {
135924
          {
135927
            _iter487.write(oprot);
135925
            _iter492.write(oprot);
135928
          }
135926
          }
135929
          oprot.writeListEnd();
135927
          oprot.writeListEnd();
135930
        }
135928
        }
135931
        oprot.writeFieldEnd();
135929
        oprot.writeFieldEnd();
135932
      }
135930
      }
Line 136420... Line 136418...
136420
        }
136418
        }
136421
        switch (field.id) {
136419
        switch (field.id) {
136422
          case 0: // SUCCESS
136420
          case 0: // SUCCESS
136423
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
136421
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
136424
              {
136422
              {
136425
                org.apache.thrift.protocol.TList _list488 = iprot.readListBegin();
136423
                org.apache.thrift.protocol.TList _list493 = iprot.readListBegin();
136426
                this.success = new ArrayList<Amazonlisted>(_list488.size);
136424
                this.success = new ArrayList<Amazonlisted>(_list493.size);
136427
                for (int _i489 = 0; _i489 < _list488.size; ++_i489)
136425
                for (int _i494 = 0; _i494 < _list493.size; ++_i494)
136428
                {
136426
                {
136429
                  Amazonlisted _elem490; // required
136427
                  Amazonlisted _elem495; // required
136430
                  _elem490 = new Amazonlisted();
136428
                  _elem495 = new Amazonlisted();
136431
                  _elem490.read(iprot);
136429
                  _elem495.read(iprot);
136432
                  this.success.add(_elem490);
136430
                  this.success.add(_elem495);
136433
                }
136431
                }
136434
                iprot.readListEnd();
136432
                iprot.readListEnd();
136435
              }
136433
              }
136436
            } else { 
136434
            } else { 
136437
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
136435
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 136451... Line 136449...
136451
 
136449
 
136452
      if (this.isSetSuccess()) {
136450
      if (this.isSetSuccess()) {
136453
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
136451
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
136454
        {
136452
        {
136455
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
136453
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
136456
          for (Amazonlisted _iter491 : this.success)
136454
          for (Amazonlisted _iter496 : this.success)
136457
          {
136455
          {
136458
            _iter491.write(oprot);
136456
            _iter496.write(oprot);
136459
          }
136457
          }
136460
          oprot.writeListEnd();
136458
          oprot.writeListEnd();
136461
        }
136459
        }
136462
        oprot.writeFieldEnd();
136460
        oprot.writeFieldEnd();
136463
      }
136461
      }
Line 136751... Line 136749...
136751
        }
136749
        }
136752
        switch (field.id) {
136750
        switch (field.id) {
136753
          case 1: // ITEM_IDS
136751
          case 1: // ITEM_IDS
136754
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
136752
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
136755
              {
136753
              {
136756
                org.apache.thrift.protocol.TList _list492 = iprot.readListBegin();
136754
                org.apache.thrift.protocol.TList _list497 = iprot.readListBegin();
136757
                this.itemIds = new ArrayList<Long>(_list492.size);
136755
                this.itemIds = new ArrayList<Long>(_list497.size);
136758
                for (int _i493 = 0; _i493 < _list492.size; ++_i493)
136756
                for (int _i498 = 0; _i498 < _list497.size; ++_i498)
136759
                {
136757
                {
136760
                  long _elem494; // required
136758
                  long _elem499; // required
136761
                  _elem494 = iprot.readI64();
136759
                  _elem499 = iprot.readI64();
136762
                  this.itemIds.add(_elem494);
136760
                  this.itemIds.add(_elem499);
136763
                }
136761
                }
136764
                iprot.readListEnd();
136762
                iprot.readListEnd();
136765
              }
136763
              }
136766
            } else { 
136764
            } else { 
136767
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
136765
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 136782... Line 136780...
136782
      oprot.writeStructBegin(STRUCT_DESC);
136780
      oprot.writeStructBegin(STRUCT_DESC);
136783
      if (this.itemIds != null) {
136781
      if (this.itemIds != null) {
136784
        oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
136782
        oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
136785
        {
136783
        {
136786
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.itemIds.size()));
136784
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.itemIds.size()));
136787
          for (long _iter495 : this.itemIds)
136785
          for (long _iter500 : this.itemIds)
136788
          {
136786
          {
136789
            oprot.writeI64(_iter495);
136787
            oprot.writeI64(_iter500);
136790
          }
136788
          }
136791
          oprot.writeListEnd();
136789
          oprot.writeListEnd();
136792
        }
136790
        }
136793
        oprot.writeFieldEnd();
136791
        oprot.writeFieldEnd();
136794
      }
136792
      }
Line 137091... Line 137089...
137091
        }
137089
        }
137092
        switch (field.id) {
137090
        switch (field.id) {
137093
          case 0: // SUCCESS
137091
          case 0: // SUCCESS
137094
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
137092
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
137095
              {
137093
              {
137096
                org.apache.thrift.protocol.TMap _map496 = iprot.readMapBegin();
137094
                org.apache.thrift.protocol.TMap _map501 = iprot.readMapBegin();
137097
                this.success = new HashMap<Long,List<BulkItemPricing>>(2*_map496.size);
137095
                this.success = new HashMap<Long,List<BulkItemPricing>>(2*_map501.size);
137098
                for (int _i497 = 0; _i497 < _map496.size; ++_i497)
137096
                for (int _i502 = 0; _i502 < _map501.size; ++_i502)
137099
                {
137097
                {
137100
                  long _key498; // required
137098
                  long _key503; // required
137101
                  List<BulkItemPricing> _val499; // required
137099
                  List<BulkItemPricing> _val504; // required
137102
                  _key498 = iprot.readI64();
137100
                  _key503 = iprot.readI64();
137103
                  {
137101
                  {
137104
                    org.apache.thrift.protocol.TList _list500 = iprot.readListBegin();
137102
                    org.apache.thrift.protocol.TList _list505 = iprot.readListBegin();
137105
                    _val499 = new ArrayList<BulkItemPricing>(_list500.size);
137103
                    _val504 = new ArrayList<BulkItemPricing>(_list505.size);
137106
                    for (int _i501 = 0; _i501 < _list500.size; ++_i501)
137104
                    for (int _i506 = 0; _i506 < _list505.size; ++_i506)
137107
                    {
137105
                    {
137108
                      BulkItemPricing _elem502; // required
137106
                      BulkItemPricing _elem507; // required
137109
                      _elem502 = new BulkItemPricing();
137107
                      _elem507 = new BulkItemPricing();
137110
                      _elem502.read(iprot);
137108
                      _elem507.read(iprot);
137111
                      _val499.add(_elem502);
137109
                      _val504.add(_elem507);
137112
                    }
137110
                    }
137113
                    iprot.readListEnd();
137111
                    iprot.readListEnd();
137114
                  }
137112
                  }
137115
                  this.success.put(_key498, _val499);
137113
                  this.success.put(_key503, _val504);
137116
                }
137114
                }
137117
                iprot.readMapEnd();
137115
                iprot.readMapEnd();
137118
              }
137116
              }
137119
            } else { 
137117
            } else { 
137120
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
137118
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 137134... Line 137132...
137134
 
137132
 
137135
      if (this.isSetSuccess()) {
137133
      if (this.isSetSuccess()) {
137136
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
137134
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
137137
        {
137135
        {
137138
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.LIST, this.success.size()));
137136
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.LIST, this.success.size()));
137139
          for (Map.Entry<Long, List<BulkItemPricing>> _iter503 : this.success.entrySet())
137137
          for (Map.Entry<Long, List<BulkItemPricing>> _iter508 : this.success.entrySet())
137140
          {
137138
          {
137141
            oprot.writeI64(_iter503.getKey());
137139
            oprot.writeI64(_iter508.getKey());
137142
            {
137140
            {
137143
              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter503.getValue().size()));
137141
              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter508.getValue().size()));
137144
              for (BulkItemPricing _iter504 : _iter503.getValue())
137142
              for (BulkItemPricing _iter509 : _iter508.getValue())
137145
              {
137143
              {
137146
                _iter504.write(oprot);
137144
                _iter509.write(oprot);
137147
              }
137145
              }
137148
              oprot.writeListEnd();
137146
              oprot.writeListEnd();
137149
            }
137147
            }
137150
          }
137148
          }
137151
          oprot.writeMapEnd();
137149
          oprot.writeMapEnd();
Line 139499... Line 139497...
139499
        }
139497
        }
139500
        switch (field.id) {
139498
        switch (field.id) {
139501
          case 0: // SUCCESS
139499
          case 0: // SUCCESS
139502
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
139500
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
139503
              {
139501
              {
139504
                org.apache.thrift.protocol.TList _list505 = iprot.readListBegin();
139502
                org.apache.thrift.protocol.TList _list510 = iprot.readListBegin();
139505
                this.success = new ArrayList<BulkItemPricing>(_list505.size);
139503
                this.success = new ArrayList<BulkItemPricing>(_list510.size);
139506
                for (int _i506 = 0; _i506 < _list505.size; ++_i506)
139504
                for (int _i511 = 0; _i511 < _list510.size; ++_i511)
139507
                {
139505
                {
139508
                  BulkItemPricing _elem507; // required
139506
                  BulkItemPricing _elem512; // required
139509
                  _elem507 = new BulkItemPricing();
139507
                  _elem512 = new BulkItemPricing();
139510
                  _elem507.read(iprot);
139508
                  _elem512.read(iprot);
139511
                  this.success.add(_elem507);
139509
                  this.success.add(_elem512);
139512
                }
139510
                }
139513
                iprot.readListEnd();
139511
                iprot.readListEnd();
139514
              }
139512
              }
139515
            } else { 
139513
            } else { 
139516
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
139514
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 139530... Line 139528...
139530
 
139528
 
139531
      if (this.isSetSuccess()) {
139529
      if (this.isSetSuccess()) {
139532
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
139530
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
139533
        {
139531
        {
139534
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
139532
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
139535
          for (BulkItemPricing _iter508 : this.success)
139533
          for (BulkItemPricing _iter513 : this.success)
139536
          {
139534
          {
139537
            _iter508.write(oprot);
139535
            _iter513.write(oprot);
139538
          }
139536
          }
139539
          oprot.writeListEnd();
139537
          oprot.writeListEnd();
139540
        }
139538
        }
139541
        oprot.writeFieldEnd();
139539
        oprot.writeFieldEnd();
139542
      }
139540
      }
Line 139909... Line 139907...
139909
            }
139907
            }
139910
            break;
139908
            break;
139911
          case 2: // BULK_ITEM_PRICING_LIST
139909
          case 2: // BULK_ITEM_PRICING_LIST
139912
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
139910
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
139913
              {
139911
              {
139914
                org.apache.thrift.protocol.TList _list509 = iprot.readListBegin();
139912
                org.apache.thrift.protocol.TList _list514 = iprot.readListBegin();
139915
                this.bulkItemPricingList = new ArrayList<BulkItemPricing>(_list509.size);
139913
                this.bulkItemPricingList = new ArrayList<BulkItemPricing>(_list514.size);
139916
                for (int _i510 = 0; _i510 < _list509.size; ++_i510)
139914
                for (int _i515 = 0; _i515 < _list514.size; ++_i515)
139917
                {
139915
                {
139918
                  BulkItemPricing _elem511; // required
139916
                  BulkItemPricing _elem516; // required
139919
                  _elem511 = new BulkItemPricing();
139917
                  _elem516 = new BulkItemPricing();
139920
                  _elem511.read(iprot);
139918
                  _elem516.read(iprot);
139921
                  this.bulkItemPricingList.add(_elem511);
139919
                  this.bulkItemPricingList.add(_elem516);
139922
                }
139920
                }
139923
                iprot.readListEnd();
139921
                iprot.readListEnd();
139924
              }
139922
              }
139925
            } else { 
139923
            } else { 
139926
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
139924
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 139944... Line 139942...
139944
      oprot.writeFieldEnd();
139942
      oprot.writeFieldEnd();
139945
      if (this.bulkItemPricingList != null) {
139943
      if (this.bulkItemPricingList != null) {
139946
        oprot.writeFieldBegin(BULK_ITEM_PRICING_LIST_FIELD_DESC);
139944
        oprot.writeFieldBegin(BULK_ITEM_PRICING_LIST_FIELD_DESC);
139947
        {
139945
        {
139948
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.bulkItemPricingList.size()));
139946
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.bulkItemPricingList.size()));
139949
          for (BulkItemPricing _iter512 : this.bulkItemPricingList)
139947
          for (BulkItemPricing _iter517 : this.bulkItemPricingList)
139950
          {
139948
          {
139951
            _iter512.write(oprot);
139949
            _iter517.write(oprot);
139952
          }
139950
          }
139953
          oprot.writeListEnd();
139951
          oprot.writeListEnd();
139954
        }
139952
        }
139955
        oprot.writeFieldEnd();
139953
        oprot.writeFieldEnd();
139956
      }
139954
      }