Subversion Repositories SmartDukaan

Rev

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

Rev 8579 Rev 8590
Line 176... Line 176...
176
    public Map<Long,List<String>> getAllEntityTags() throws org.apache.thrift.TException;
176
    public Map<Long,List<String>> getAllEntityTags() throws org.apache.thrift.TException;
177
 
177
 
178
    /**
178
    /**
179
     * Banner Related
179
     * Banner Related
180
     * 
180
     * 
181
     * @param banner
181
     * @param bannerCongregate
182
     */
182
     */
183
    public boolean addBanner(Banner banner) throws org.apache.thrift.TException;
183
    public void addBanner(BannerCongregate bannerCongregate) throws org.apache.thrift.TException;
184
 
184
 
185
    public boolean updateBanner(Banner banner) throws org.apache.thrift.TException;
185
    public boolean updateBanner(Banner banner) throws org.apache.thrift.TException;
186
 
186
 
187
    public List<Banner> getAllBanners() throws org.apache.thrift.TException;
187
    public List<Banner> getAllBanners() throws org.apache.thrift.TException;
188
 
188
 
Line 540... Line 540...
540
 
540
 
541
    public void getAllEntitiesByTagName(String displayName, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getAllEntitiesByTagName_call> resultHandler) throws org.apache.thrift.TException;
541
    public void getAllEntitiesByTagName(String displayName, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getAllEntitiesByTagName_call> resultHandler) throws org.apache.thrift.TException;
542
 
542
 
543
    public void getAllEntityTags(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getAllEntityTags_call> resultHandler) throws org.apache.thrift.TException;
543
    public void getAllEntityTags(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getAllEntityTags_call> resultHandler) throws org.apache.thrift.TException;
544
 
544
 
545
    public void addBanner(Banner banner, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.addBanner_call> resultHandler) throws org.apache.thrift.TException;
545
    public void addBanner(BannerCongregate bannerCongregate, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.addBanner_call> resultHandler) throws org.apache.thrift.TException;
546
 
546
 
547
    public void updateBanner(Banner banner, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.updateBanner_call> resultHandler) throws org.apache.thrift.TException;
547
    public void updateBanner(Banner banner, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.updateBanner_call> resultHandler) throws org.apache.thrift.TException;
548
 
548
 
549
    public void getAllBanners(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getAllBanners_call> resultHandler) throws org.apache.thrift.TException;
549
    public void getAllBanners(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getAllBanners_call> resultHandler) throws org.apache.thrift.TException;
550
 
550
 
Line 1750... Line 1750...
1750
        return result.success;
1750
        return result.success;
1751
      }
1751
      }
1752
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
1752
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
1753
    }
1753
    }
1754
 
1754
 
1755
    public boolean addBanner(Banner banner) throws org.apache.thrift.TException
1755
    public void addBanner(BannerCongregate bannerCongregate) throws org.apache.thrift.TException
1756
    {
1756
    {
1757
      send_addBanner(banner);
1757
      send_addBanner(bannerCongregate);
1758
      return recv_addBanner();
1758
      recv_addBanner();
1759
    }
1759
    }
1760
 
1760
 
1761
    public void send_addBanner(Banner banner) throws org.apache.thrift.TException
1761
    public void send_addBanner(BannerCongregate bannerCongregate) throws org.apache.thrift.TException
1762
    {
1762
    {
1763
      addBanner_args args = new addBanner_args();
1763
      addBanner_args args = new addBanner_args();
1764
      args.setBanner(banner);
1764
      args.setBannerCongregate(bannerCongregate);
1765
      sendBase("addBanner", args);
1765
      sendBase("addBanner", args);
1766
    }
1766
    }
1767
 
1767
 
1768
    public boolean recv_addBanner() throws org.apache.thrift.TException
1768
    public void recv_addBanner() throws org.apache.thrift.TException
1769
    {
1769
    {
1770
      addBanner_result result = new addBanner_result();
1770
      addBanner_result result = new addBanner_result();
1771
      receiveBase(result, "addBanner");
1771
      receiveBase(result, "addBanner");
1772
      if (result.isSetSuccess()) {
-
 
1773
        return result.success;
-
 
1774
      }
1772
      return;
1775
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
-
 
1776
    }
1773
    }
1777
 
1774
 
1778
    public boolean updateBanner(Banner banner) throws org.apache.thrift.TException
1775
    public boolean updateBanner(Banner banner) throws org.apache.thrift.TException
1779
    {
1776
    {
1780
      send_updateBanner(banner);
1777
      send_updateBanner(banner);
Line 4869... Line 4866...
4869
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
4866
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
4870
        return (new Client(prot)).recv_getAllEntityTags();
4867
        return (new Client(prot)).recv_getAllEntityTags();
4871
      }
4868
      }
4872
    }
4869
    }
4873
 
4870
 
4874
    public void addBanner(Banner banner, org.apache.thrift.async.AsyncMethodCallback<addBanner_call> resultHandler) throws org.apache.thrift.TException {
4871
    public void addBanner(BannerCongregate bannerCongregate, org.apache.thrift.async.AsyncMethodCallback<addBanner_call> resultHandler) throws org.apache.thrift.TException {
4875
      checkReady();
4872
      checkReady();
4876
      addBanner_call method_call = new addBanner_call(banner, resultHandler, this, ___protocolFactory, ___transport);
4873
      addBanner_call method_call = new addBanner_call(bannerCongregate, resultHandler, this, ___protocolFactory, ___transport);
4877
      this.___currentMethod = method_call;
4874
      this.___currentMethod = method_call;
4878
      ___manager.call(method_call);
4875
      ___manager.call(method_call);
4879
    }
4876
    }
4880
 
4877
 
4881
    public static class addBanner_call extends org.apache.thrift.async.TAsyncMethodCall {
4878
    public static class addBanner_call extends org.apache.thrift.async.TAsyncMethodCall {
4882
      private Banner banner;
4879
      private BannerCongregate bannerCongregate;
4883
      public addBanner_call(Banner banner, org.apache.thrift.async.AsyncMethodCallback<addBanner_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
4880
      public addBanner_call(BannerCongregate bannerCongregate, org.apache.thrift.async.AsyncMethodCallback<addBanner_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
4884
        super(client, protocolFactory, transport, resultHandler, false);
4881
        super(client, protocolFactory, transport, resultHandler, false);
4885
        this.banner = banner;
4882
        this.bannerCongregate = bannerCongregate;
4886
      }
4883
      }
4887
 
4884
 
4888
      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
4885
      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
4889
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("addBanner", org.apache.thrift.protocol.TMessageType.CALL, 0));
4886
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("addBanner", org.apache.thrift.protocol.TMessageType.CALL, 0));
4890
        addBanner_args args = new addBanner_args();
4887
        addBanner_args args = new addBanner_args();
4891
        args.setBanner(banner);
4888
        args.setBannerCongregate(bannerCongregate);
4892
        args.write(prot);
4889
        args.write(prot);
4893
        prot.writeMessageEnd();
4890
        prot.writeMessageEnd();
4894
      }
4891
      }
4895
 
4892
 
4896
      public boolean getResult() throws org.apache.thrift.TException {
4893
      public void getResult() throws org.apache.thrift.TException {
4897
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
4894
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
4898
          throw new IllegalStateException("Method call not finished!");
4895
          throw new IllegalStateException("Method call not finished!");
4899
        }
4896
        }
4900
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
4897
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
4901
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
4898
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
4902
        return (new Client(prot)).recv_addBanner();
4899
        (new Client(prot)).recv_addBanner();
4903
      }
4900
      }
4904
    }
4901
    }
4905
 
4902
 
4906
    public void updateBanner(Banner banner, org.apache.thrift.async.AsyncMethodCallback<updateBanner_call> resultHandler) throws org.apache.thrift.TException {
4903
    public void updateBanner(Banner banner, org.apache.thrift.async.AsyncMethodCallback<updateBanner_call> resultHandler) throws org.apache.thrift.TException {
4907
      checkReady();
4904
      checkReady();
Line 8281... Line 8278...
8281
        return new addBanner_args();
8278
        return new addBanner_args();
8282
      }
8279
      }
8283
 
8280
 
8284
      protected addBanner_result getResult(I iface, addBanner_args args) throws org.apache.thrift.TException {
8281
      protected addBanner_result getResult(I iface, addBanner_args args) throws org.apache.thrift.TException {
8285
        addBanner_result result = new addBanner_result();
8282
        addBanner_result result = new addBanner_result();
8286
        result.success = iface.addBanner(args.banner);
8283
        iface.addBanner(args.bannerCongregate);
8287
        result.setSuccessIsSet(true);
-
 
8288
        return result;
8284
        return result;
8289
      }
8285
      }
8290
    }
8286
    }
8291
 
8287
 
8292
    private static class updateBanner<I extends Iface> extends org.apache.thrift.ProcessFunction<I, updateBanner_args> {
8288
    private static class updateBanner<I extends Iface> extends org.apache.thrift.ProcessFunction<I, updateBanner_args> {
Line 11823... Line 11819...
11823
        }
11819
        }
11824
        switch (field.id) {
11820
        switch (field.id) {
11825
          case 1: // ITEM_IDS
11821
          case 1: // ITEM_IDS
11826
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
11822
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
11827
              {
11823
              {
11828
                org.apache.thrift.protocol.TList _list9 = iprot.readListBegin();
11824
                org.apache.thrift.protocol.TList _list17 = iprot.readListBegin();
11829
                this.itemIds = new ArrayList<Long>(_list9.size);
11825
                this.itemIds = new ArrayList<Long>(_list17.size);
11830
                for (int _i10 = 0; _i10 < _list9.size; ++_i10)
11826
                for (int _i18 = 0; _i18 < _list17.size; ++_i18)
11831
                {
11827
                {
11832
                  long _elem11; // required
11828
                  long _elem19; // required
11833
                  _elem11 = iprot.readI64();
11829
                  _elem19 = iprot.readI64();
11834
                  this.itemIds.add(_elem11);
11830
                  this.itemIds.add(_elem19);
11835
                }
11831
                }
11836
                iprot.readListEnd();
11832
                iprot.readListEnd();
11837
              }
11833
              }
11838
            } else { 
11834
            } else { 
11839
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
11835
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 11854... Line 11850...
11854
      oprot.writeStructBegin(STRUCT_DESC);
11850
      oprot.writeStructBegin(STRUCT_DESC);
11855
      if (this.itemIds != null) {
11851
      if (this.itemIds != null) {
11856
        oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
11852
        oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
11857
        {
11853
        {
11858
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.itemIds.size()));
11854
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.itemIds.size()));
11859
          for (long _iter12 : this.itemIds)
11855
          for (long _iter20 : this.itemIds)
11860
          {
11856
          {
11861
            oprot.writeI64(_iter12);
11857
            oprot.writeI64(_iter20);
11862
          }
11858
          }
11863
          oprot.writeListEnd();
11859
          oprot.writeListEnd();
11864
        }
11860
        }
11865
        oprot.writeFieldEnd();
11861
        oprot.writeFieldEnd();
11866
      }
11862
      }
Line 12227... Line 12223...
12227
        }
12223
        }
12228
        switch (field.id) {
12224
        switch (field.id) {
12229
          case 0: // SUCCESS
12225
          case 0: // SUCCESS
12230
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
12226
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
12231
              {
12227
              {
12232
                org.apache.thrift.protocol.TMap _map13 = iprot.readMapBegin();
12228
                org.apache.thrift.protocol.TMap _map21 = iprot.readMapBegin();
12233
                this.success = new HashMap<Long,Boolean>(2*_map13.size);
12229
                this.success = new HashMap<Long,Boolean>(2*_map21.size);
12234
                for (int _i14 = 0; _i14 < _map13.size; ++_i14)
12230
                for (int _i22 = 0; _i22 < _map21.size; ++_i22)
12235
                {
12231
                {
12236
                  long _key15; // required
12232
                  long _key23; // required
12237
                  boolean _val16; // required
12233
                  boolean _val24; // required
12238
                  _key15 = iprot.readI64();
12234
                  _key23 = iprot.readI64();
12239
                  _val16 = iprot.readBool();
12235
                  _val24 = iprot.readBool();
12240
                  this.success.put(_key15, _val16);
12236
                  this.success.put(_key23, _val24);
12241
                }
12237
                }
12242
                iprot.readMapEnd();
12238
                iprot.readMapEnd();
12243
              }
12239
              }
12244
            } else { 
12240
            } else { 
12245
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
12241
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 12267... Line 12263...
12267
 
12263
 
12268
      if (this.isSetSuccess()) {
12264
      if (this.isSetSuccess()) {
12269
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
12265
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
12270
        {
12266
        {
12271
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.BOOL, this.success.size()));
12267
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.BOOL, this.success.size()));
12272
          for (Map.Entry<Long, Boolean> _iter17 : this.success.entrySet())
12268
          for (Map.Entry<Long, Boolean> _iter25 : this.success.entrySet())
12273
          {
12269
          {
12274
            oprot.writeI64(_iter17.getKey());
12270
            oprot.writeI64(_iter25.getKey());
12275
            oprot.writeBool(_iter17.getValue());
12271
            oprot.writeBool(_iter25.getValue());
12276
          }
12272
          }
12277
          oprot.writeMapEnd();
12273
          oprot.writeMapEnd();
12278
        }
12274
        }
12279
        oprot.writeFieldEnd();
12275
        oprot.writeFieldEnd();
12280
      } else if (this.isSetIsex()) {
12276
      } else if (this.isSetIsex()) {
Line 16406... Line 16402...
16406
        }
16402
        }
16407
        switch (field.id) {
16403
        switch (field.id) {
16408
          case 0: // SUCCESS
16404
          case 0: // SUCCESS
16409
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
16405
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
16410
              {
16406
              {
16411
                org.apache.thrift.protocol.TList _list18 = iprot.readListBegin();
16407
                org.apache.thrift.protocol.TList _list26 = iprot.readListBegin();
16412
                this.success = new ArrayList<Item>(_list18.size);
16408
                this.success = new ArrayList<Item>(_list26.size);
16413
                for (int _i19 = 0; _i19 < _list18.size; ++_i19)
16409
                for (int _i27 = 0; _i27 < _list26.size; ++_i27)
16414
                {
16410
                {
16415
                  Item _elem20; // required
16411
                  Item _elem28; // required
16416
                  _elem20 = new Item();
16412
                  _elem28 = new Item();
16417
                  _elem20.read(iprot);
16413
                  _elem28.read(iprot);
16418
                  this.success.add(_elem20);
16414
                  this.success.add(_elem28);
16419
                }
16415
                }
16420
                iprot.readListEnd();
16416
                iprot.readListEnd();
16421
              }
16417
              }
16422
            } else { 
16418
            } else { 
16423
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
16419
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 16445... Line 16441...
16445
 
16441
 
16446
      if (this.isSetSuccess()) {
16442
      if (this.isSetSuccess()) {
16447
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
16443
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
16448
        {
16444
        {
16449
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
16445
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
16450
          for (Item _iter21 : this.success)
16446
          for (Item _iter29 : this.success)
16451
          {
16447
          {
16452
            _iter21.write(oprot);
16448
            _iter29.write(oprot);
16453
          }
16449
          }
16454
          oprot.writeListEnd();
16450
          oprot.writeListEnd();
16455
        }
16451
        }
16456
        oprot.writeFieldEnd();
16452
        oprot.writeFieldEnd();
16457
      } else if (this.isSetCex()) {
16453
      } else if (this.isSetCex()) {
Line 17119... Line 17115...
17119
        }
17115
        }
17120
        switch (field.id) {
17116
        switch (field.id) {
17121
          case 0: // SUCCESS
17117
          case 0: // SUCCESS
17122
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
17118
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
17123
              {
17119
              {
17124
                org.apache.thrift.protocol.TList _list22 = iprot.readListBegin();
17120
                org.apache.thrift.protocol.TList _list30 = iprot.readListBegin();
17125
                this.success = new ArrayList<Item>(_list22.size);
17121
                this.success = new ArrayList<Item>(_list30.size);
17126
                for (int _i23 = 0; _i23 < _list22.size; ++_i23)
17122
                for (int _i31 = 0; _i31 < _list30.size; ++_i31)
17127
                {
17123
                {
17128
                  Item _elem24; // required
17124
                  Item _elem32; // required
17129
                  _elem24 = new Item();
17125
                  _elem32 = new Item();
17130
                  _elem24.read(iprot);
17126
                  _elem32.read(iprot);
17131
                  this.success.add(_elem24);
17127
                  this.success.add(_elem32);
17132
                }
17128
                }
17133
                iprot.readListEnd();
17129
                iprot.readListEnd();
17134
              }
17130
              }
17135
            } else { 
17131
            } else { 
17136
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
17132
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 17158... Line 17154...
17158
 
17154
 
17159
      if (this.isSetSuccess()) {
17155
      if (this.isSetSuccess()) {
17160
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
17156
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
17161
        {
17157
        {
17162
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
17158
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
17163
          for (Item _iter25 : this.success)
17159
          for (Item _iter33 : this.success)
17164
          {
17160
          {
17165
            _iter25.write(oprot);
17161
            _iter33.write(oprot);
17166
          }
17162
          }
17167
          oprot.writeListEnd();
17163
          oprot.writeListEnd();
17168
        }
17164
        }
17169
        oprot.writeFieldEnd();
17165
        oprot.writeFieldEnd();
17170
      } else if (this.isSetCex()) {
17166
      } else if (this.isSetCex()) {
Line 17832... Line 17828...
17832
        }
17828
        }
17833
        switch (field.id) {
17829
        switch (field.id) {
17834
          case 0: // SUCCESS
17830
          case 0: // SUCCESS
17835
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
17831
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
17836
              {
17832
              {
17837
                org.apache.thrift.protocol.TList _list26 = iprot.readListBegin();
17833
                org.apache.thrift.protocol.TList _list34 = iprot.readListBegin();
17838
                this.success = new ArrayList<Item>(_list26.size);
17834
                this.success = new ArrayList<Item>(_list34.size);
17839
                for (int _i27 = 0; _i27 < _list26.size; ++_i27)
17835
                for (int _i35 = 0; _i35 < _list34.size; ++_i35)
17840
                {
17836
                {
17841
                  Item _elem28; // required
17837
                  Item _elem36; // required
17842
                  _elem28 = new Item();
17838
                  _elem36 = new Item();
17843
                  _elem28.read(iprot);
17839
                  _elem36.read(iprot);
17844
                  this.success.add(_elem28);
17840
                  this.success.add(_elem36);
17845
                }
17841
                }
17846
                iprot.readListEnd();
17842
                iprot.readListEnd();
17847
              }
17843
              }
17848
            } else { 
17844
            } else { 
17849
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
17845
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 17871... Line 17867...
17871
 
17867
 
17872
      if (this.isSetSuccess()) {
17868
      if (this.isSetSuccess()) {
17873
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
17869
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
17874
        {
17870
        {
17875
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
17871
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
17876
          for (Item _iter29 : this.success)
17872
          for (Item _iter37 : this.success)
17877
          {
17873
          {
17878
            _iter29.write(oprot);
17874
            _iter37.write(oprot);
17879
          }
17875
          }
17880
          oprot.writeListEnd();
17876
          oprot.writeListEnd();
17881
        }
17877
        }
17882
        oprot.writeFieldEnd();
17878
        oprot.writeFieldEnd();
17883
      } else if (this.isSetCex()) {
17879
      } else if (this.isSetCex()) {
Line 18557... Line 18553...
18557
        }
18553
        }
18558
        switch (field.id) {
18554
        switch (field.id) {
18559
          case 0: // SUCCESS
18555
          case 0: // SUCCESS
18560
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
18556
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
18561
              {
18557
              {
18562
                org.apache.thrift.protocol.TList _list30 = iprot.readListBegin();
18558
                org.apache.thrift.protocol.TList _list38 = iprot.readListBegin();
18563
                this.success = new ArrayList<Item>(_list30.size);
18559
                this.success = new ArrayList<Item>(_list38.size);
18564
                for (int _i31 = 0; _i31 < _list30.size; ++_i31)
18560
                for (int _i39 = 0; _i39 < _list38.size; ++_i39)
18565
                {
18561
                {
18566
                  Item _elem32; // required
18562
                  Item _elem40; // required
18567
                  _elem32 = new Item();
18563
                  _elem40 = new Item();
18568
                  _elem32.read(iprot);
18564
                  _elem40.read(iprot);
18569
                  this.success.add(_elem32);
18565
                  this.success.add(_elem40);
18570
                }
18566
                }
18571
                iprot.readListEnd();
18567
                iprot.readListEnd();
18572
              }
18568
              }
18573
            } else { 
18569
            } else { 
18574
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
18570
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 18596... Line 18592...
18596
 
18592
 
18597
      if (this.isSetSuccess()) {
18593
      if (this.isSetSuccess()) {
18598
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
18594
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
18599
        {
18595
        {
18600
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
18596
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
18601
          for (Item _iter33 : this.success)
18597
          for (Item _iter41 : this.success)
18602
          {
18598
          {
18603
            _iter33.write(oprot);
18599
            _iter41.write(oprot);
18604
          }
18600
          }
18605
          oprot.writeListEnd();
18601
          oprot.writeListEnd();
18606
        }
18602
        }
18607
        oprot.writeFieldEnd();
18603
        oprot.writeFieldEnd();
18608
      } else if (this.isSetCex()) {
18604
      } else if (this.isSetCex()) {
Line 20373... Line 20369...
20373
        }
20369
        }
20374
        switch (field.id) {
20370
        switch (field.id) {
20375
          case 0: // SUCCESS
20371
          case 0: // SUCCESS
20376
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
20372
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
20377
              {
20373
              {
20378
                org.apache.thrift.protocol.TList _list34 = iprot.readListBegin();
20374
                org.apache.thrift.protocol.TList _list42 = iprot.readListBegin();
20379
                this.success = new ArrayList<Item>(_list34.size);
20375
                this.success = new ArrayList<Item>(_list42.size);
20380
                for (int _i35 = 0; _i35 < _list34.size; ++_i35)
20376
                for (int _i43 = 0; _i43 < _list42.size; ++_i43)
20381
                {
20377
                {
20382
                  Item _elem36; // required
20378
                  Item _elem44; // required
20383
                  _elem36 = new Item();
20379
                  _elem44 = new Item();
20384
                  _elem36.read(iprot);
20380
                  _elem44.read(iprot);
20385
                  this.success.add(_elem36);
20381
                  this.success.add(_elem44);
20386
                }
20382
                }
20387
                iprot.readListEnd();
20383
                iprot.readListEnd();
20388
              }
20384
              }
20389
            } else { 
20385
            } else { 
20390
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
20386
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 20412... Line 20408...
20412
 
20408
 
20413
      if (this.isSetSuccess()) {
20409
      if (this.isSetSuccess()) {
20414
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
20410
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
20415
        {
20411
        {
20416
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
20412
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
20417
          for (Item _iter37 : this.success)
20413
          for (Item _iter45 : this.success)
20418
          {
20414
          {
20419
            _iter37.write(oprot);
20415
            _iter45.write(oprot);
20420
          }
20416
          }
20421
          oprot.writeListEnd();
20417
          oprot.writeListEnd();
20422
        }
20418
        }
20423
        oprot.writeFieldEnd();
20419
        oprot.writeFieldEnd();
20424
      } else if (this.isSetCex()) {
20420
      } else if (this.isSetCex()) {
Line 21267... Line 21263...
21267
        }
21263
        }
21268
        switch (field.id) {
21264
        switch (field.id) {
21269
          case 0: // SUCCESS
21265
          case 0: // SUCCESS
21270
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
21266
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
21271
              {
21267
              {
21272
                org.apache.thrift.protocol.TList _list38 = iprot.readListBegin();
21268
                org.apache.thrift.protocol.TList _list46 = iprot.readListBegin();
21273
                this.success = new ArrayList<Item>(_list38.size);
21269
                this.success = new ArrayList<Item>(_list46.size);
21274
                for (int _i39 = 0; _i39 < _list38.size; ++_i39)
21270
                for (int _i47 = 0; _i47 < _list46.size; ++_i47)
21275
                {
21271
                {
21276
                  Item _elem40; // required
21272
                  Item _elem48; // required
21277
                  _elem40 = new Item();
21273
                  _elem48 = new Item();
21278
                  _elem40.read(iprot);
21274
                  _elem48.read(iprot);
21279
                  this.success.add(_elem40);
21275
                  this.success.add(_elem48);
21280
                }
21276
                }
21281
                iprot.readListEnd();
21277
                iprot.readListEnd();
21282
              }
21278
              }
21283
            } else { 
21279
            } else { 
21284
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
21280
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 21306... Line 21302...
21306
 
21302
 
21307
      if (this.isSetSuccess()) {
21303
      if (this.isSetSuccess()) {
21308
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
21304
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
21309
        {
21305
        {
21310
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
21306
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
21311
          for (Item _iter41 : this.success)
21307
          for (Item _iter49 : this.success)
21312
          {
21308
          {
21313
            _iter41.write(oprot);
21309
            _iter49.write(oprot);
21314
          }
21310
          }
21315
          oprot.writeListEnd();
21311
          oprot.writeListEnd();
21316
        }
21312
        }
21317
        oprot.writeFieldEnd();
21313
        oprot.writeFieldEnd();
21318
      } else if (this.isSetCex()) {
21314
      } else if (this.isSetCex()) {
Line 22573... Line 22569...
22573
        }
22569
        }
22574
        switch (field.id) {
22570
        switch (field.id) {
22575
          case 0: // SUCCESS
22571
          case 0: // SUCCESS
22576
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
22572
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
22577
              {
22573
              {
22578
                org.apache.thrift.protocol.TList _list42 = iprot.readListBegin();
22574
                org.apache.thrift.protocol.TList _list50 = iprot.readListBegin();
22579
                this.success = new ArrayList<Item>(_list42.size);
22575
                this.success = new ArrayList<Item>(_list50.size);
22580
                for (int _i43 = 0; _i43 < _list42.size; ++_i43)
22576
                for (int _i51 = 0; _i51 < _list50.size; ++_i51)
22581
                {
22577
                {
22582
                  Item _elem44; // required
22578
                  Item _elem52; // required
22583
                  _elem44 = new Item();
22579
                  _elem52 = new Item();
22584
                  _elem44.read(iprot);
22580
                  _elem52.read(iprot);
22585
                  this.success.add(_elem44);
22581
                  this.success.add(_elem52);
22586
                }
22582
                }
22587
                iprot.readListEnd();
22583
                iprot.readListEnd();
22588
              }
22584
              }
22589
            } else { 
22585
            } else { 
22590
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
22586
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 22612... Line 22608...
22612
 
22608
 
22613
      if (this.isSetSuccess()) {
22609
      if (this.isSetSuccess()) {
22614
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
22610
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
22615
        {
22611
        {
22616
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
22612
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
22617
          for (Item _iter45 : this.success)
22613
          for (Item _iter53 : this.success)
22618
          {
22614
          {
22619
            _iter45.write(oprot);
22615
            _iter53.write(oprot);
22620
          }
22616
          }
22621
          oprot.writeListEnd();
22617
          oprot.writeListEnd();
22622
        }
22618
        }
22623
        oprot.writeFieldEnd();
22619
        oprot.writeFieldEnd();
22624
      } else if (this.isSetIsex()) {
22620
      } else if (this.isSetIsex()) {
Line 23540... Line 23536...
23540
        }
23536
        }
23541
        switch (field.id) {
23537
        switch (field.id) {
23542
          case 0: // SUCCESS
23538
          case 0: // SUCCESS
23543
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
23539
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
23544
              {
23540
              {
23545
                org.apache.thrift.protocol.TList _list46 = iprot.readListBegin();
23541
                org.apache.thrift.protocol.TList _list54 = iprot.readListBegin();
23546
                this.success = new ArrayList<Long>(_list46.size);
23542
                this.success = new ArrayList<Long>(_list54.size);
23547
                for (int _i47 = 0; _i47 < _list46.size; ++_i47)
23543
                for (int _i55 = 0; _i55 < _list54.size; ++_i55)
23548
                {
23544
                {
23549
                  long _elem48; // required
23545
                  long _elem56; // required
23550
                  _elem48 = iprot.readI64();
23546
                  _elem56 = iprot.readI64();
23551
                  this.success.add(_elem48);
23547
                  this.success.add(_elem56);
23552
                }
23548
                }
23553
                iprot.readListEnd();
23549
                iprot.readListEnd();
23554
              }
23550
              }
23555
            } else { 
23551
            } else { 
23556
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
23552
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 23578... Line 23574...
23578
 
23574
 
23579
      if (this.isSetSuccess()) {
23575
      if (this.isSetSuccess()) {
23580
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
23576
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
23581
        {
23577
        {
23582
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
23578
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
23583
          for (long _iter49 : this.success)
23579
          for (long _iter57 : this.success)
23584
          {
23580
          {
23585
            oprot.writeI64(_iter49);
23581
            oprot.writeI64(_iter57);
23586
          }
23582
          }
23587
          oprot.writeListEnd();
23583
          oprot.writeListEnd();
23588
        }
23584
        }
23589
        oprot.writeFieldEnd();
23585
        oprot.writeFieldEnd();
23590
      } else if (this.isSetCex()) {
23586
      } else if (this.isSetCex()) {
Line 24739... Line 24735...
24739
        }
24735
        }
24740
        switch (field.id) {
24736
        switch (field.id) {
24741
          case 0: // SUCCESS
24737
          case 0: // SUCCESS
24742
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
24738
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
24743
              {
24739
              {
24744
                org.apache.thrift.protocol.TList _list50 = iprot.readListBegin();
24740
                org.apache.thrift.protocol.TList _list58 = iprot.readListBegin();
24745
                this.success = new ArrayList<Item>(_list50.size);
24741
                this.success = new ArrayList<Item>(_list58.size);
24746
                for (int _i51 = 0; _i51 < _list50.size; ++_i51)
24742
                for (int _i59 = 0; _i59 < _list58.size; ++_i59)
24747
                {
24743
                {
24748
                  Item _elem52; // required
24744
                  Item _elem60; // required
24749
                  _elem52 = new Item();
24745
                  _elem60 = new Item();
24750
                  _elem52.read(iprot);
24746
                  _elem60.read(iprot);
24751
                  this.success.add(_elem52);
24747
                  this.success.add(_elem60);
24752
                }
24748
                }
24753
                iprot.readListEnd();
24749
                iprot.readListEnd();
24754
              }
24750
              }
24755
            } else { 
24751
            } else { 
24756
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
24752
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 24778... Line 24774...
24778
 
24774
 
24779
      if (this.isSetSuccess()) {
24775
      if (this.isSetSuccess()) {
24780
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
24776
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
24781
        {
24777
        {
24782
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
24778
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
24783
          for (Item _iter53 : this.success)
24779
          for (Item _iter61 : this.success)
24784
          {
24780
          {
24785
            _iter53.write(oprot);
24781
            _iter61.write(oprot);
24786
          }
24782
          }
24787
          oprot.writeListEnd();
24783
          oprot.writeListEnd();
24788
        }
24784
        }
24789
        oprot.writeFieldEnd();
24785
        oprot.writeFieldEnd();
24790
      } else if (this.isSetIsex()) {
24786
      } else if (this.isSetIsex()) {
Line 25706... Line 25702...
25706
        }
25702
        }
25707
        switch (field.id) {
25703
        switch (field.id) {
25708
          case 0: // SUCCESS
25704
          case 0: // SUCCESS
25709
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
25705
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
25710
              {
25706
              {
25711
                org.apache.thrift.protocol.TList _list54 = iprot.readListBegin();
25707
                org.apache.thrift.protocol.TList _list62 = iprot.readListBegin();
25712
                this.success = new ArrayList<Long>(_list54.size);
25708
                this.success = new ArrayList<Long>(_list62.size);
25713
                for (int _i55 = 0; _i55 < _list54.size; ++_i55)
25709
                for (int _i63 = 0; _i63 < _list62.size; ++_i63)
25714
                {
25710
                {
25715
                  long _elem56; // required
25711
                  long _elem64; // required
25716
                  _elem56 = iprot.readI64();
25712
                  _elem64 = iprot.readI64();
25717
                  this.success.add(_elem56);
25713
                  this.success.add(_elem64);
25718
                }
25714
                }
25719
                iprot.readListEnd();
25715
                iprot.readListEnd();
25720
              }
25716
              }
25721
            } else { 
25717
            } else { 
25722
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
25718
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 25744... Line 25740...
25744
 
25740
 
25745
      if (this.isSetSuccess()) {
25741
      if (this.isSetSuccess()) {
25746
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
25742
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
25747
        {
25743
        {
25748
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
25744
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
25749
          for (long _iter57 : this.success)
25745
          for (long _iter65 : this.success)
25750
          {
25746
          {
25751
            oprot.writeI64(_iter57);
25747
            oprot.writeI64(_iter65);
25752
          }
25748
          }
25753
          oprot.writeListEnd();
25749
          oprot.writeListEnd();
25754
        }
25750
        }
25755
        oprot.writeFieldEnd();
25751
        oprot.writeFieldEnd();
25756
      } else if (this.isSetCex()) {
25752
      } else if (this.isSetCex()) {
Line 26905... Line 26901...
26905
        }
26901
        }
26906
        switch (field.id) {
26902
        switch (field.id) {
26907
          case 0: // SUCCESS
26903
          case 0: // SUCCESS
26908
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
26904
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
26909
              {
26905
              {
26910
                org.apache.thrift.protocol.TList _list58 = iprot.readListBegin();
26906
                org.apache.thrift.protocol.TList _list66 = iprot.readListBegin();
26911
                this.success = new ArrayList<Item>(_list58.size);
26907
                this.success = new ArrayList<Item>(_list66.size);
26912
                for (int _i59 = 0; _i59 < _list58.size; ++_i59)
26908
                for (int _i67 = 0; _i67 < _list66.size; ++_i67)
26913
                {
26909
                {
26914
                  Item _elem60; // required
26910
                  Item _elem68; // required
26915
                  _elem60 = new Item();
26911
                  _elem68 = new Item();
26916
                  _elem60.read(iprot);
26912
                  _elem68.read(iprot);
26917
                  this.success.add(_elem60);
26913
                  this.success.add(_elem68);
26918
                }
26914
                }
26919
                iprot.readListEnd();
26915
                iprot.readListEnd();
26920
              }
26916
              }
26921
            } else { 
26917
            } else { 
26922
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
26918
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 26944... Line 26940...
26944
 
26940
 
26945
      if (this.isSetSuccess()) {
26941
      if (this.isSetSuccess()) {
26946
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
26942
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
26947
        {
26943
        {
26948
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
26944
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
26949
          for (Item _iter61 : this.success)
26945
          for (Item _iter69 : this.success)
26950
          {
26946
          {
26951
            _iter61.write(oprot);
26947
            _iter69.write(oprot);
26952
          }
26948
          }
26953
          oprot.writeListEnd();
26949
          oprot.writeListEnd();
26954
        }
26950
        }
26955
        oprot.writeFieldEnd();
26951
        oprot.writeFieldEnd();
26956
      } else if (this.isSetIsex()) {
26952
      } else if (this.isSetIsex()) {
Line 27872... Line 27868...
27872
        }
27868
        }
27873
        switch (field.id) {
27869
        switch (field.id) {
27874
          case 0: // SUCCESS
27870
          case 0: // SUCCESS
27875
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
27871
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
27876
              {
27872
              {
27877
                org.apache.thrift.protocol.TList _list62 = iprot.readListBegin();
27873
                org.apache.thrift.protocol.TList _list70 = iprot.readListBegin();
27878
                this.success = new ArrayList<Long>(_list62.size);
27874
                this.success = new ArrayList<Long>(_list70.size);
27879
                for (int _i63 = 0; _i63 < _list62.size; ++_i63)
27875
                for (int _i71 = 0; _i71 < _list70.size; ++_i71)
27880
                {
27876
                {
27881
                  long _elem64; // required
27877
                  long _elem72; // required
27882
                  _elem64 = iprot.readI64();
27878
                  _elem72 = iprot.readI64();
27883
                  this.success.add(_elem64);
27879
                  this.success.add(_elem72);
27884
                }
27880
                }
27885
                iprot.readListEnd();
27881
                iprot.readListEnd();
27886
              }
27882
              }
27887
            } else { 
27883
            } else { 
27888
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
27884
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 27910... Line 27906...
27910
 
27906
 
27911
      if (this.isSetSuccess()) {
27907
      if (this.isSetSuccess()) {
27912
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
27908
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
27913
        {
27909
        {
27914
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
27910
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
27915
          for (long _iter65 : this.success)
27911
          for (long _iter73 : this.success)
27916
          {
27912
          {
27917
            oprot.writeI64(_iter65);
27913
            oprot.writeI64(_iter73);
27918
          }
27914
          }
27919
          oprot.writeListEnd();
27915
          oprot.writeListEnd();
27920
        }
27916
        }
27921
        oprot.writeFieldEnd();
27917
        oprot.writeFieldEnd();
27922
      } else if (this.isSetCex()) {
27918
      } else if (this.isSetCex()) {
Line 29071... Line 29067...
29071
        }
29067
        }
29072
        switch (field.id) {
29068
        switch (field.id) {
29073
          case 0: // SUCCESS
29069
          case 0: // SUCCESS
29074
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
29070
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
29075
              {
29071
              {
29076
                org.apache.thrift.protocol.TList _list66 = iprot.readListBegin();
29072
                org.apache.thrift.protocol.TList _list74 = iprot.readListBegin();
29077
                this.success = new ArrayList<Item>(_list66.size);
29073
                this.success = new ArrayList<Item>(_list74.size);
29078
                for (int _i67 = 0; _i67 < _list66.size; ++_i67)
29074
                for (int _i75 = 0; _i75 < _list74.size; ++_i75)
29079
                {
29075
                {
29080
                  Item _elem68; // required
29076
                  Item _elem76; // required
29081
                  _elem68 = new Item();
29077
                  _elem76 = new Item();
29082
                  _elem68.read(iprot);
29078
                  _elem76.read(iprot);
29083
                  this.success.add(_elem68);
29079
                  this.success.add(_elem76);
29084
                }
29080
                }
29085
                iprot.readListEnd();
29081
                iprot.readListEnd();
29086
              }
29082
              }
29087
            } else { 
29083
            } else { 
29088
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
29084
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 29110... Line 29106...
29110
 
29106
 
29111
      if (this.isSetSuccess()) {
29107
      if (this.isSetSuccess()) {
29112
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
29108
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
29113
        {
29109
        {
29114
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
29110
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
29115
          for (Item _iter69 : this.success)
29111
          for (Item _iter77 : this.success)
29116
          {
29112
          {
29117
            _iter69.write(oprot);
29113
            _iter77.write(oprot);
29118
          }
29114
          }
29119
          oprot.writeListEnd();
29115
          oprot.writeListEnd();
29120
        }
29116
        }
29121
        oprot.writeFieldEnd();
29117
        oprot.writeFieldEnd();
29122
      } else if (this.isSetIsex()) {
29118
      } else if (this.isSetIsex()) {
Line 29652... Line 29648...
29652
            }
29648
            }
29653
            break;
29649
            break;
29654
          case 4: // CATEGORIES
29650
          case 4: // CATEGORIES
29655
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
29651
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
29656
              {
29652
              {
29657
                org.apache.thrift.protocol.TList _list70 = iprot.readListBegin();
29653
                org.apache.thrift.protocol.TList _list78 = iprot.readListBegin();
29658
                this.categories = new ArrayList<Long>(_list70.size);
29654
                this.categories = new ArrayList<Long>(_list78.size);
29659
                for (int _i71 = 0; _i71 < _list70.size; ++_i71)
29655
                for (int _i79 = 0; _i79 < _list78.size; ++_i79)
29660
                {
29656
                {
29661
                  long _elem72; // required
29657
                  long _elem80; // required
29662
                  _elem72 = iprot.readI64();
29658
                  _elem80 = iprot.readI64();
29663
                  this.categories.add(_elem72);
29659
                  this.categories.add(_elem80);
29664
                }
29660
                }
29665
                iprot.readListEnd();
29661
                iprot.readListEnd();
29666
              }
29662
              }
29667
            } else { 
29663
            } else { 
29668
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
29664
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 29694... Line 29690...
29694
      }
29690
      }
29695
      if (this.categories != null) {
29691
      if (this.categories != null) {
29696
        oprot.writeFieldBegin(CATEGORIES_FIELD_DESC);
29692
        oprot.writeFieldBegin(CATEGORIES_FIELD_DESC);
29697
        {
29693
        {
29698
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.categories.size()));
29694
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.categories.size()));
29699
          for (long _iter73 : this.categories)
29695
          for (long _iter81 : this.categories)
29700
          {
29696
          {
29701
            oprot.writeI64(_iter73);
29697
            oprot.writeI64(_iter81);
29702
          }
29698
          }
29703
          oprot.writeListEnd();
29699
          oprot.writeListEnd();
29704
        }
29700
        }
29705
        oprot.writeFieldEnd();
29701
        oprot.writeFieldEnd();
29706
      }
29702
      }
Line 30078... Line 30074...
30078
        }
30074
        }
30079
        switch (field.id) {
30075
        switch (field.id) {
30080
          case 0: // SUCCESS
30076
          case 0: // SUCCESS
30081
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
30077
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
30082
              {
30078
              {
30083
                org.apache.thrift.protocol.TList _list74 = iprot.readListBegin();
30079
                org.apache.thrift.protocol.TList _list82 = iprot.readListBegin();
30084
                this.success = new ArrayList<Long>(_list74.size);
30080
                this.success = new ArrayList<Long>(_list82.size);
30085
                for (int _i75 = 0; _i75 < _list74.size; ++_i75)
30081
                for (int _i83 = 0; _i83 < _list82.size; ++_i83)
30086
                {
30082
                {
30087
                  long _elem76; // required
30083
                  long _elem84; // required
30088
                  _elem76 = iprot.readI64();
30084
                  _elem84 = iprot.readI64();
30089
                  this.success.add(_elem76);
30085
                  this.success.add(_elem84);
30090
                }
30086
                }
30091
                iprot.readListEnd();
30087
                iprot.readListEnd();
30092
              }
30088
              }
30093
            } else { 
30089
            } else { 
30094
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
30090
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 30116... Line 30112...
30116
 
30112
 
30117
      if (this.isSetSuccess()) {
30113
      if (this.isSetSuccess()) {
30118
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
30114
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
30119
        {
30115
        {
30120
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
30116
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
30121
          for (long _iter77 : this.success)
30117
          for (long _iter85 : this.success)
30122
          {
30118
          {
30123
            oprot.writeI64(_iter77);
30119
            oprot.writeI64(_iter85);
30124
          }
30120
          }
30125
          oprot.writeListEnd();
30121
          oprot.writeListEnd();
30126
        }
30122
        }
30127
        oprot.writeFieldEnd();
30123
        oprot.writeFieldEnd();
30128
      } else if (this.isSetCex()) {
30124
      } else if (this.isSetCex()) {
Line 32878... Line 32874...
32878
        }
32874
        }
32879
        switch (field.id) {
32875
        switch (field.id) {
32880
          case 0: // SUCCESS
32876
          case 0: // SUCCESS
32881
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
32877
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
32882
              {
32878
              {
32883
                org.apache.thrift.protocol.TList _list78 = iprot.readListBegin();
32879
                org.apache.thrift.protocol.TList _list86 = iprot.readListBegin();
32884
                this.success = new ArrayList<Category>(_list78.size);
32880
                this.success = new ArrayList<Category>(_list86.size);
32885
                for (int _i79 = 0; _i79 < _list78.size; ++_i79)
32881
                for (int _i87 = 0; _i87 < _list86.size; ++_i87)
32886
                {
32882
                {
32887
                  Category _elem80; // required
32883
                  Category _elem88; // required
32888
                  _elem80 = new Category();
32884
                  _elem88 = new Category();
32889
                  _elem80.read(iprot);
32885
                  _elem88.read(iprot);
32890
                  this.success.add(_elem80);
32886
                  this.success.add(_elem88);
32891
                }
32887
                }
32892
                iprot.readListEnd();
32888
                iprot.readListEnd();
32893
              }
32889
              }
32894
            } else { 
32890
            } else { 
32895
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
32891
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 32909... Line 32905...
32909
 
32905
 
32910
      if (this.isSetSuccess()) {
32906
      if (this.isSetSuccess()) {
32911
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
32907
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
32912
        {
32908
        {
32913
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
32909
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
32914
          for (Category _iter81 : this.success)
32910
          for (Category _iter89 : this.success)
32915
          {
32911
          {
32916
            _iter81.write(oprot);
32912
            _iter89.write(oprot);
32917
          }
32913
          }
32918
          oprot.writeListEnd();
32914
          oprot.writeListEnd();
32919
        }
32915
        }
32920
        oprot.writeFieldEnd();
32916
        oprot.writeFieldEnd();
32921
      }
32917
      }
Line 33503... Line 33499...
33503
        }
33499
        }
33504
        switch (field.id) {
33500
        switch (field.id) {
33505
          case 0: // SUCCESS
33501
          case 0: // SUCCESS
33506
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
33502
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
33507
              {
33503
              {
33508
                org.apache.thrift.protocol.TList _list82 = iprot.readListBegin();
33504
                org.apache.thrift.protocol.TList _list90 = iprot.readListBegin();
33509
                this.success = new ArrayList<Item>(_list82.size);
33505
                this.success = new ArrayList<Item>(_list90.size);
33510
                for (int _i83 = 0; _i83 < _list82.size; ++_i83)
33506
                for (int _i91 = 0; _i91 < _list90.size; ++_i91)
33511
                {
33507
                {
33512
                  Item _elem84; // required
33508
                  Item _elem92; // required
33513
                  _elem84 = new Item();
33509
                  _elem92 = new Item();
33514
                  _elem84.read(iprot);
33510
                  _elem92.read(iprot);
33515
                  this.success.add(_elem84);
33511
                  this.success.add(_elem92);
33516
                }
33512
                }
33517
                iprot.readListEnd();
33513
                iprot.readListEnd();
33518
              }
33514
              }
33519
            } else { 
33515
            } else { 
33520
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
33516
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 33534... Line 33530...
33534
 
33530
 
33535
      if (this.isSetSuccess()) {
33531
      if (this.isSetSuccess()) {
33536
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
33532
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
33537
        {
33533
        {
33538
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
33534
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
33539
          for (Item _iter85 : this.success)
33535
          for (Item _iter93 : this.success)
33540
          {
33536
          {
33541
            _iter85.write(oprot);
33537
            _iter93.write(oprot);
33542
          }
33538
          }
33543
          oprot.writeListEnd();
33539
          oprot.writeListEnd();
33544
        }
33540
        }
33545
        oprot.writeFieldEnd();
33541
        oprot.writeFieldEnd();
33546
      }
33542
      }
Line 36730... Line 36726...
36730
        }
36726
        }
36731
        switch (field.id) {
36727
        switch (field.id) {
36732
          case 0: // SUCCESS
36728
          case 0: // SUCCESS
36733
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
36729
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
36734
              {
36730
              {
36735
                org.apache.thrift.protocol.TList _list86 = iprot.readListBegin();
36731
                org.apache.thrift.protocol.TList _list94 = iprot.readListBegin();
36736
                this.success = new ArrayList<String>(_list86.size);
36732
                this.success = new ArrayList<String>(_list94.size);
36737
                for (int _i87 = 0; _i87 < _list86.size; ++_i87)
36733
                for (int _i95 = 0; _i95 < _list94.size; ++_i95)
36738
                {
36734
                {
36739
                  String _elem88; // required
36735
                  String _elem96; // required
36740
                  _elem88 = iprot.readString();
36736
                  _elem96 = iprot.readString();
36741
                  this.success.add(_elem88);
36737
                  this.success.add(_elem96);
36742
                }
36738
                }
36743
                iprot.readListEnd();
36739
                iprot.readListEnd();
36744
              }
36740
              }
36745
            } else { 
36741
            } else { 
36746
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
36742
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 36760... Line 36756...
36760
 
36756
 
36761
      if (this.isSetSuccess()) {
36757
      if (this.isSetSuccess()) {
36762
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
36758
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
36763
        {
36759
        {
36764
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
36760
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
36765
          for (String _iter89 : this.success)
36761
          for (String _iter97 : this.success)
36766
          {
36762
          {
36767
            oprot.writeString(_iter89);
36763
            oprot.writeString(_iter97);
36768
          }
36764
          }
36769
          oprot.writeListEnd();
36765
          oprot.writeListEnd();
36770
        }
36766
        }
36771
        oprot.writeFieldEnd();
36767
        oprot.writeFieldEnd();
36772
      }
36768
      }
Line 37354... Line 37350...
37354
        }
37350
        }
37355
        switch (field.id) {
37351
        switch (field.id) {
37356
          case 0: // SUCCESS
37352
          case 0: // SUCCESS
37357
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
37353
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
37358
              {
37354
              {
37359
                org.apache.thrift.protocol.TList _list90 = iprot.readListBegin();
37355
                org.apache.thrift.protocol.TList _list98 = iprot.readListBegin();
37360
                this.success = new ArrayList<Long>(_list90.size);
37356
                this.success = new ArrayList<Long>(_list98.size);
37361
                for (int _i91 = 0; _i91 < _list90.size; ++_i91)
37357
                for (int _i99 = 0; _i99 < _list98.size; ++_i99)
37362
                {
37358
                {
37363
                  long _elem92; // required
37359
                  long _elem100; // required
37364
                  _elem92 = iprot.readI64();
37360
                  _elem100 = iprot.readI64();
37365
                  this.success.add(_elem92);
37361
                  this.success.add(_elem100);
37366
                }
37362
                }
37367
                iprot.readListEnd();
37363
                iprot.readListEnd();
37368
              }
37364
              }
37369
            } else { 
37365
            } else { 
37370
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
37366
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 37384... Line 37380...
37384
 
37380
 
37385
      if (this.isSetSuccess()) {
37381
      if (this.isSetSuccess()) {
37386
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
37382
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
37387
        {
37383
        {
37388
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
37384
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
37389
          for (long _iter93 : this.success)
37385
          for (long _iter101 : this.success)
37390
          {
37386
          {
37391
            oprot.writeI64(_iter93);
37387
            oprot.writeI64(_iter101);
37392
          }
37388
          }
37393
          oprot.writeListEnd();
37389
          oprot.writeListEnd();
37394
        }
37390
        }
37395
        oprot.writeFieldEnd();
37391
        oprot.writeFieldEnd();
37396
      }
37392
      }
Line 37893... Line 37889...
37893
        }
37889
        }
37894
        switch (field.id) {
37890
        switch (field.id) {
37895
          case 0: // SUCCESS
37891
          case 0: // SUCCESS
37896
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
37892
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
37897
              {
37893
              {
37898
                org.apache.thrift.protocol.TMap _map94 = iprot.readMapBegin();
37894
                org.apache.thrift.protocol.TMap _map102 = iprot.readMapBegin();
37899
                this.success = new HashMap<Long,List<String>>(2*_map94.size);
37895
                this.success = new HashMap<Long,List<String>>(2*_map102.size);
37900
                for (int _i95 = 0; _i95 < _map94.size; ++_i95)
37896
                for (int _i103 = 0; _i103 < _map102.size; ++_i103)
37901
                {
37897
                {
37902
                  long _key96; // required
37898
                  long _key104; // required
37903
                  List<String> _val97; // required
37899
                  List<String> _val105; // required
37904
                  _key96 = iprot.readI64();
37900
                  _key104 = iprot.readI64();
37905
                  {
37901
                  {
37906
                    org.apache.thrift.protocol.TList _list98 = iprot.readListBegin();
37902
                    org.apache.thrift.protocol.TList _list106 = iprot.readListBegin();
37907
                    _val97 = new ArrayList<String>(_list98.size);
37903
                    _val105 = new ArrayList<String>(_list106.size);
37908
                    for (int _i99 = 0; _i99 < _list98.size; ++_i99)
37904
                    for (int _i107 = 0; _i107 < _list106.size; ++_i107)
37909
                    {
37905
                    {
37910
                      String _elem100; // required
37906
                      String _elem108; // required
37911
                      _elem100 = iprot.readString();
37907
                      _elem108 = iprot.readString();
37912
                      _val97.add(_elem100);
37908
                      _val105.add(_elem108);
37913
                    }
37909
                    }
37914
                    iprot.readListEnd();
37910
                    iprot.readListEnd();
37915
                  }
37911
                  }
37916
                  this.success.put(_key96, _val97);
37912
                  this.success.put(_key104, _val105);
37917
                }
37913
                }
37918
                iprot.readMapEnd();
37914
                iprot.readMapEnd();
37919
              }
37915
              }
37920
            } else { 
37916
            } else { 
37921
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
37917
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 37935... Line 37931...
37935
 
37931
 
37936
      if (this.isSetSuccess()) {
37932
      if (this.isSetSuccess()) {
37937
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
37933
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
37938
        {
37934
        {
37939
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.LIST, this.success.size()));
37935
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.LIST, this.success.size()));
37940
          for (Map.Entry<Long, List<String>> _iter101 : this.success.entrySet())
37936
          for (Map.Entry<Long, List<String>> _iter109 : this.success.entrySet())
37941
          {
37937
          {
37942
            oprot.writeI64(_iter101.getKey());
37938
            oprot.writeI64(_iter109.getKey());
37943
            {
37939
            {
37944
              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter101.getValue().size()));
37940
              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter109.getValue().size()));
37945
              for (String _iter102 : _iter101.getValue())
37941
              for (String _iter110 : _iter109.getValue())
37946
              {
37942
              {
37947
                oprot.writeString(_iter102);
37943
                oprot.writeString(_iter110);
37948
              }
37944
              }
37949
              oprot.writeListEnd();
37945
              oprot.writeListEnd();
37950
            }
37946
            }
37951
          }
37947
          }
37952
          oprot.writeMapEnd();
37948
          oprot.writeMapEnd();
Line 37996... Line 37992...
37996
  }
37992
  }
37997
 
37993
 
37998
  public static class addBanner_args implements org.apache.thrift.TBase<addBanner_args, addBanner_args._Fields>, java.io.Serializable, Cloneable   {
37994
  public static class addBanner_args implements org.apache.thrift.TBase<addBanner_args, addBanner_args._Fields>, java.io.Serializable, Cloneable   {
37999
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("addBanner_args");
37995
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("addBanner_args");
38000
 
37996
 
38001
    private static final org.apache.thrift.protocol.TField BANNER_FIELD_DESC = new org.apache.thrift.protocol.TField("banner", org.apache.thrift.protocol.TType.STRUCT, (short)1);
37997
    private static final org.apache.thrift.protocol.TField BANNER_CONGREGATE_FIELD_DESC = new org.apache.thrift.protocol.TField("bannerCongregate", org.apache.thrift.protocol.TType.STRUCT, (short)1);
38002
 
37998
 
38003
    private Banner banner; // required
37999
    private BannerCongregate bannerCongregate; // required
38004
 
38000
 
38005
    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
38001
    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
38006
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
38002
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
38007
      BANNER((short)1, "banner");
38003
      BANNER_CONGREGATE((short)1, "bannerCongregate");
38008
 
38004
 
38009
      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
38005
      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
38010
 
38006
 
38011
      static {
38007
      static {
38012
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
38008
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
Line 38017... Line 38013...
38017
      /**
38013
      /**
38018
       * Find the _Fields constant that matches fieldId, or null if its not found.
38014
       * Find the _Fields constant that matches fieldId, or null if its not found.
38019
       */
38015
       */
38020
      public static _Fields findByThriftId(int fieldId) {
38016
      public static _Fields findByThriftId(int fieldId) {
38021
        switch(fieldId) {
38017
        switch(fieldId) {
38022
          case 1: // BANNER
38018
          case 1: // BANNER_CONGREGATE
38023
            return BANNER;
38019
            return BANNER_CONGREGATE;
38024
          default:
38020
          default:
38025
            return null;
38021
            return null;
38026
        }
38022
        }
38027
      }
38023
      }
38028
 
38024
 
Line 38063... Line 38059...
38063
    // isset id assignments
38059
    // isset id assignments
38064
 
38060
 
38065
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
38061
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
38066
    static {
38062
    static {
38067
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
38063
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
38068
      tmpMap.put(_Fields.BANNER, new org.apache.thrift.meta_data.FieldMetaData("banner", org.apache.thrift.TFieldRequirementType.DEFAULT, 
38064
      tmpMap.put(_Fields.BANNER_CONGREGATE, new org.apache.thrift.meta_data.FieldMetaData("bannerCongregate", org.apache.thrift.TFieldRequirementType.DEFAULT, 
38069
          new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Banner.class)));
38065
          new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, BannerCongregate.class)));
38070
      metaDataMap = Collections.unmodifiableMap(tmpMap);
38066
      metaDataMap = Collections.unmodifiableMap(tmpMap);
38071
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(addBanner_args.class, metaDataMap);
38067
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(addBanner_args.class, metaDataMap);
38072
    }
38068
    }
38073
 
38069
 
38074
    public addBanner_args() {
38070
    public addBanner_args() {
38075
    }
38071
    }
38076
 
38072
 
38077
    public addBanner_args(
38073
    public addBanner_args(
38078
      Banner banner)
38074
      BannerCongregate bannerCongregate)
38079
    {
38075
    {
38080
      this();
38076
      this();
38081
      this.banner = banner;
38077
      this.bannerCongregate = bannerCongregate;
38082
    }
38078
    }
38083
 
38079
 
38084
    /**
38080
    /**
38085
     * Performs a deep copy on <i>other</i>.
38081
     * Performs a deep copy on <i>other</i>.
38086
     */
38082
     */
38087
    public addBanner_args(addBanner_args other) {
38083
    public addBanner_args(addBanner_args other) {
38088
      if (other.isSetBanner()) {
38084
      if (other.isSetBannerCongregate()) {
38089
        this.banner = new Banner(other.banner);
38085
        this.bannerCongregate = new BannerCongregate(other.bannerCongregate);
38090
      }
38086
      }
38091
    }
38087
    }
38092
 
38088
 
38093
    public addBanner_args deepCopy() {
38089
    public addBanner_args deepCopy() {
38094
      return new addBanner_args(this);
38090
      return new addBanner_args(this);
38095
    }
38091
    }
38096
 
38092
 
38097
    @Override
38093
    @Override
38098
    public void clear() {
38094
    public void clear() {
38099
      this.banner = null;
38095
      this.bannerCongregate = null;
38100
    }
38096
    }
38101
 
38097
 
38102
    public Banner getBanner() {
38098
    public BannerCongregate getBannerCongregate() {
38103
      return this.banner;
38099
      return this.bannerCongregate;
38104
    }
38100
    }
38105
 
38101
 
38106
    public void setBanner(Banner banner) {
38102
    public void setBannerCongregate(BannerCongregate bannerCongregate) {
38107
      this.banner = banner;
38103
      this.bannerCongregate = bannerCongregate;
38108
    }
38104
    }
38109
 
38105
 
38110
    public void unsetBanner() {
38106
    public void unsetBannerCongregate() {
38111
      this.banner = null;
38107
      this.bannerCongregate = null;
38112
    }
38108
    }
38113
 
38109
 
38114
    /** Returns true if field banner is set (has been assigned a value) and false otherwise */
38110
    /** Returns true if field bannerCongregate is set (has been assigned a value) and false otherwise */
38115
    public boolean isSetBanner() {
38111
    public boolean isSetBannerCongregate() {
38116
      return this.banner != null;
38112
      return this.bannerCongregate != null;
38117
    }
38113
    }
38118
 
38114
 
38119
    public void setBannerIsSet(boolean value) {
38115
    public void setBannerCongregateIsSet(boolean value) {
38120
      if (!value) {
38116
      if (!value) {
38121
        this.banner = null;
38117
        this.bannerCongregate = null;
38122
      }
38118
      }
38123
    }
38119
    }
38124
 
38120
 
38125
    public void setFieldValue(_Fields field, Object value) {
38121
    public void setFieldValue(_Fields field, Object value) {
38126
      switch (field) {
38122
      switch (field) {
38127
      case BANNER:
38123
      case BANNER_CONGREGATE:
38128
        if (value == null) {
38124
        if (value == null) {
38129
          unsetBanner();
38125
          unsetBannerCongregate();
38130
        } else {
38126
        } else {
38131
          setBanner((Banner)value);
38127
          setBannerCongregate((BannerCongregate)value);
38132
        }
38128
        }
38133
        break;
38129
        break;
38134
 
38130
 
38135
      }
38131
      }
38136
    }
38132
    }
38137
 
38133
 
38138
    public Object getFieldValue(_Fields field) {
38134
    public Object getFieldValue(_Fields field) {
38139
      switch (field) {
38135
      switch (field) {
38140
      case BANNER:
38136
      case BANNER_CONGREGATE:
38141
        return getBanner();
38137
        return getBannerCongregate();
38142
 
38138
 
38143
      }
38139
      }
38144
      throw new IllegalStateException();
38140
      throw new IllegalStateException();
38145
    }
38141
    }
38146
 
38142
 
Line 38149... Line 38145...
38149
      if (field == null) {
38145
      if (field == null) {
38150
        throw new IllegalArgumentException();
38146
        throw new IllegalArgumentException();
38151
      }
38147
      }
38152
 
38148
 
38153
      switch (field) {
38149
      switch (field) {
38154
      case BANNER:
38150
      case BANNER_CONGREGATE:
38155
        return isSetBanner();
38151
        return isSetBannerCongregate();
38156
      }
38152
      }
38157
      throw new IllegalStateException();
38153
      throw new IllegalStateException();
38158
    }
38154
    }
38159
 
38155
 
38160
    @Override
38156
    @Override
Line 38168... Line 38164...
38168
 
38164
 
38169
    public boolean equals(addBanner_args that) {
38165
    public boolean equals(addBanner_args that) {
38170
      if (that == null)
38166
      if (that == null)
38171
        return false;
38167
        return false;
38172
 
38168
 
38173
      boolean this_present_banner = true && this.isSetBanner();
38169
      boolean this_present_bannerCongregate = true && this.isSetBannerCongregate();
38174
      boolean that_present_banner = true && that.isSetBanner();
38170
      boolean that_present_bannerCongregate = true && that.isSetBannerCongregate();
38175
      if (this_present_banner || that_present_banner) {
38171
      if (this_present_bannerCongregate || that_present_bannerCongregate) {
38176
        if (!(this_present_banner && that_present_banner))
38172
        if (!(this_present_bannerCongregate && that_present_bannerCongregate))
38177
          return false;
38173
          return false;
38178
        if (!this.banner.equals(that.banner))
38174
        if (!this.bannerCongregate.equals(that.bannerCongregate))
38179
          return false;
38175
          return false;
38180
      }
38176
      }
38181
 
38177
 
38182
      return true;
38178
      return true;
38183
    }
38179
    }
Line 38193... Line 38189...
38193
      }
38189
      }
38194
 
38190
 
38195
      int lastComparison = 0;
38191
      int lastComparison = 0;
38196
      addBanner_args typedOther = (addBanner_args)other;
38192
      addBanner_args typedOther = (addBanner_args)other;
38197
 
38193
 
38198
      lastComparison = Boolean.valueOf(isSetBanner()).compareTo(typedOther.isSetBanner());
38194
      lastComparison = Boolean.valueOf(isSetBannerCongregate()).compareTo(typedOther.isSetBannerCongregate());
38199
      if (lastComparison != 0) {
38195
      if (lastComparison != 0) {
38200
        return lastComparison;
38196
        return lastComparison;
38201
      }
38197
      }
38202
      if (isSetBanner()) {
38198
      if (isSetBannerCongregate()) {
38203
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.banner, typedOther.banner);
38199
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.bannerCongregate, typedOther.bannerCongregate);
38204
        if (lastComparison != 0) {
38200
        if (lastComparison != 0) {
38205
          return lastComparison;
38201
          return lastComparison;
38206
        }
38202
        }
38207
      }
38203
      }
38208
      return 0;
38204
      return 0;
Line 38220... Line 38216...
38220
        field = iprot.readFieldBegin();
38216
        field = iprot.readFieldBegin();
38221
        if (field.type == org.apache.thrift.protocol.TType.STOP) { 
38217
        if (field.type == org.apache.thrift.protocol.TType.STOP) { 
38222
          break;
38218
          break;
38223
        }
38219
        }
38224
        switch (field.id) {
38220
        switch (field.id) {
38225
          case 1: // BANNER
38221
          case 1: // BANNER_CONGREGATE
38226
            if (field.type == org.apache.thrift.protocol.TType.STRUCT) {
38222
            if (field.type == org.apache.thrift.protocol.TType.STRUCT) {
38227
              this.banner = new Banner();
38223
              this.bannerCongregate = new BannerCongregate();
38228
              this.banner.read(iprot);
38224
              this.bannerCongregate.read(iprot);
38229
            } else { 
38225
            } else { 
38230
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
38226
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
38231
            }
38227
            }
38232
            break;
38228
            break;
38233
          default:
38229
          default:
Line 38241... Line 38237...
38241
 
38237
 
38242
    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
38238
    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
38243
      validate();
38239
      validate();
38244
 
38240
 
38245
      oprot.writeStructBegin(STRUCT_DESC);
38241
      oprot.writeStructBegin(STRUCT_DESC);
38246
      if (this.banner != null) {
38242
      if (this.bannerCongregate != null) {
38247
        oprot.writeFieldBegin(BANNER_FIELD_DESC);
38243
        oprot.writeFieldBegin(BANNER_CONGREGATE_FIELD_DESC);
38248
        this.banner.write(oprot);
38244
        this.bannerCongregate.write(oprot);
38249
        oprot.writeFieldEnd();
38245
        oprot.writeFieldEnd();
38250
      }
38246
      }
38251
      oprot.writeFieldStop();
38247
      oprot.writeFieldStop();
38252
      oprot.writeStructEnd();
38248
      oprot.writeStructEnd();
38253
    }
38249
    }
Line 38255... Line 38251...
38255
    @Override
38251
    @Override
38256
    public String toString() {
38252
    public String toString() {
38257
      StringBuilder sb = new StringBuilder("addBanner_args(");
38253
      StringBuilder sb = new StringBuilder("addBanner_args(");
38258
      boolean first = true;
38254
      boolean first = true;
38259
 
38255
 
38260
      sb.append("banner:");
38256
      sb.append("bannerCongregate:");
38261
      if (this.banner == null) {
38257
      if (this.bannerCongregate == null) {
38262
        sb.append("null");
38258
        sb.append("null");
38263
      } else {
38259
      } else {
38264
        sb.append(this.banner);
38260
        sb.append(this.bannerCongregate);
38265
      }
38261
      }
38266
      first = false;
38262
      first = false;
38267
      sb.append(")");
38263
      sb.append(")");
38268
      return sb.toString();
38264
      return sb.toString();
38269
    }
38265
    }
Line 38291... Line 38287...
38291
  }
38287
  }
38292
 
38288
 
38293
  public static class addBanner_result implements org.apache.thrift.TBase<addBanner_result, addBanner_result._Fields>, java.io.Serializable, Cloneable   {
38289
  public static class addBanner_result implements org.apache.thrift.TBase<addBanner_result, addBanner_result._Fields>, java.io.Serializable, Cloneable   {
38294
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("addBanner_result");
38290
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("addBanner_result");
38295
 
38291
 
38296
    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.BOOL, (short)0);
-
 
38297
 
38292
 
38298
    private boolean success; // required
-
 
38299
 
38293
 
38300
    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
38294
    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
38301
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
38295
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
38302
      SUCCESS((short)0, "success");
-
 
-
 
38296
;
38303
 
38297
 
38304
      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
38298
      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
38305
 
38299
 
38306
      static {
38300
      static {
38307
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
38301
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
Line 38312... Line 38306...
38312
      /**
38306
      /**
38313
       * Find the _Fields constant that matches fieldId, or null if its not found.
38307
       * Find the _Fields constant that matches fieldId, or null if its not found.
38314
       */
38308
       */
38315
      public static _Fields findByThriftId(int fieldId) {
38309
      public static _Fields findByThriftId(int fieldId) {
38316
        switch(fieldId) {
38310
        switch(fieldId) {
38317
          case 0: // SUCCESS
-
 
38318
            return SUCCESS;
-
 
38319
          default:
38311
          default:
38320
            return null;
38312
            return null;
38321
        }
38313
        }
38322
      }
38314
      }
38323
 
38315
 
Line 38352... Line 38344...
38352
 
38344
 
38353
      public String getFieldName() {
38345
      public String getFieldName() {
38354
        return _fieldName;
38346
        return _fieldName;
38355
      }
38347
      }
38356
    }
38348
    }
38357
 
-
 
38358
    // isset id assignments
-
 
38359
    private static final int __SUCCESS_ISSET_ID = 0;
-
 
38360
    private BitSet __isset_bit_vector = new BitSet(1);
-
 
38361
 
-
 
38362
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
38349
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
38363
    static {
38350
    static {
38364
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
38351
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
38365
      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
-
 
38366
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
-
 
38367
      metaDataMap = Collections.unmodifiableMap(tmpMap);
38352
      metaDataMap = Collections.unmodifiableMap(tmpMap);
38368
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(addBanner_result.class, metaDataMap);
38353
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(addBanner_result.class, metaDataMap);
38369
    }
38354
    }
38370
 
38355
 
38371
    public addBanner_result() {
38356
    public addBanner_result() {
38372
    }
38357
    }
38373
 
38358
 
38374
    public addBanner_result(
-
 
38375
      boolean success)
-
 
38376
    {
-
 
38377
      this();
-
 
38378
      this.success = success;
-
 
38379
      setSuccessIsSet(true);
-
 
38380
    }
-
 
38381
 
-
 
38382
    /**
38359
    /**
38383
     * Performs a deep copy on <i>other</i>.
38360
     * Performs a deep copy on <i>other</i>.
38384
     */
38361
     */
38385
    public addBanner_result(addBanner_result other) {
38362
    public addBanner_result(addBanner_result other) {
38386
      __isset_bit_vector.clear();
-
 
38387
      __isset_bit_vector.or(other.__isset_bit_vector);
-
 
38388
      this.success = other.success;
-
 
38389
    }
38363
    }
38390
 
38364
 
38391
    public addBanner_result deepCopy() {
38365
    public addBanner_result deepCopy() {
38392
      return new addBanner_result(this);
38366
      return new addBanner_result(this);
38393
    }
38367
    }
38394
 
38368
 
38395
    @Override
38369
    @Override
38396
    public void clear() {
38370
    public void clear() {
38397
      setSuccessIsSet(false);
-
 
38398
      this.success = false;
-
 
38399
    }
-
 
38400
 
-
 
38401
    public boolean isSuccess() {
-
 
38402
      return this.success;
-
 
38403
    }
-
 
38404
 
-
 
38405
    public void setSuccess(boolean success) {
-
 
38406
      this.success = success;
-
 
38407
      setSuccessIsSet(true);
-
 
38408
    }
-
 
38409
 
-
 
38410
    public void unsetSuccess() {
-
 
38411
      __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
-
 
38412
    }
-
 
38413
 
-
 
38414
    /** Returns true if field success is set (has been assigned a value) and false otherwise */
-
 
38415
    public boolean isSetSuccess() {
-
 
38416
      return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
-
 
38417
    }
-
 
38418
 
-
 
38419
    public void setSuccessIsSet(boolean value) {
-
 
38420
      __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
-
 
38421
    }
38371
    }
38422
 
38372
 
38423
    public void setFieldValue(_Fields field, Object value) {
38373
    public void setFieldValue(_Fields field, Object value) {
38424
      switch (field) {
38374
      switch (field) {
38425
      case SUCCESS:
-
 
38426
        if (value == null) {
-
 
38427
          unsetSuccess();
-
 
38428
        } else {
-
 
38429
          setSuccess((Boolean)value);
-
 
38430
        }
-
 
38431
        break;
-
 
38432
 
-
 
38433
      }
38375
      }
38434
    }
38376
    }
38435
 
38377
 
38436
    public Object getFieldValue(_Fields field) {
38378
    public Object getFieldValue(_Fields field) {
38437
      switch (field) {
38379
      switch (field) {
38438
      case SUCCESS:
-
 
38439
        return Boolean.valueOf(isSuccess());
-
 
38440
 
-
 
38441
      }
38380
      }
38442
      throw new IllegalStateException();
38381
      throw new IllegalStateException();
38443
    }
38382
    }
38444
 
38383
 
38445
    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
38384
    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
Line 38447... Line 38386...
38447
      if (field == null) {
38386
      if (field == null) {
38448
        throw new IllegalArgumentException();
38387
        throw new IllegalArgumentException();
38449
      }
38388
      }
38450
 
38389
 
38451
      switch (field) {
38390
      switch (field) {
38452
      case SUCCESS:
-
 
38453
        return isSetSuccess();
-
 
38454
      }
38391
      }
38455
      throw new IllegalStateException();
38392
      throw new IllegalStateException();
38456
    }
38393
    }
38457
 
38394
 
38458
    @Override
38395
    @Override
Line 38466... Line 38403...
38466
 
38403
 
38467
    public boolean equals(addBanner_result that) {
38404
    public boolean equals(addBanner_result that) {
38468
      if (that == null)
38405
      if (that == null)
38469
        return false;
38406
        return false;
38470
 
38407
 
38471
      boolean this_present_success = true;
-
 
38472
      boolean that_present_success = true;
-
 
38473
      if (this_present_success || that_present_success) {
-
 
38474
        if (!(this_present_success && that_present_success))
-
 
38475
          return false;
-
 
38476
        if (this.success != that.success)
-
 
38477
          return false;
-
 
38478
      }
-
 
38479
 
-
 
38480
      return true;
38408
      return true;
38481
    }
38409
    }
38482
 
38410
 
38483
    @Override
38411
    @Override
38484
    public int hashCode() {
38412
    public int hashCode() {
Line 38491... Line 38419...
38491
      }
38419
      }
38492
 
38420
 
38493
      int lastComparison = 0;
38421
      int lastComparison = 0;
38494
      addBanner_result typedOther = (addBanner_result)other;
38422
      addBanner_result typedOther = (addBanner_result)other;
38495
 
38423
 
38496
      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
-
 
38497
      if (lastComparison != 0) {
-
 
38498
        return lastComparison;
-
 
38499
      }
-
 
38500
      if (isSetSuccess()) {
-
 
38501
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
-
 
38502
        if (lastComparison != 0) {
-
 
38503
          return lastComparison;
-
 
38504
        }
-
 
38505
      }
-
 
38506
      return 0;
38424
      return 0;
38507
    }
38425
    }
38508
 
38426
 
38509
    public _Fields fieldForId(int fieldId) {
38427
    public _Fields fieldForId(int fieldId) {
38510
      return _Fields.findByThriftId(fieldId);
38428
      return _Fields.findByThriftId(fieldId);
Line 38518... Line 38436...
38518
        field = iprot.readFieldBegin();
38436
        field = iprot.readFieldBegin();
38519
        if (field.type == org.apache.thrift.protocol.TType.STOP) { 
38437
        if (field.type == org.apache.thrift.protocol.TType.STOP) { 
38520
          break;
38438
          break;
38521
        }
38439
        }
38522
        switch (field.id) {
38440
        switch (field.id) {
38523
          case 0: // SUCCESS
-
 
38524
            if (field.type == org.apache.thrift.protocol.TType.BOOL) {
-
 
38525
              this.success = iprot.readBool();
-
 
38526
              setSuccessIsSet(true);
-
 
38527
            } else { 
-
 
38528
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
-
 
38529
            }
-
 
38530
            break;
-
 
38531
          default:
38441
          default:
38532
            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
38442
            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
38533
        }
38443
        }
38534
        iprot.readFieldEnd();
38444
        iprot.readFieldEnd();
38535
      }
38445
      }
Line 38538... Line 38448...
38538
    }
38448
    }
38539
 
38449
 
38540
    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
38450
    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
38541
      oprot.writeStructBegin(STRUCT_DESC);
38451
      oprot.writeStructBegin(STRUCT_DESC);
38542
 
38452
 
38543
      if (this.isSetSuccess()) {
-
 
38544
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
-
 
38545
        oprot.writeBool(this.success);
-
 
38546
        oprot.writeFieldEnd();
-
 
38547
      }
-
 
38548
      oprot.writeFieldStop();
38453
      oprot.writeFieldStop();
38549
      oprot.writeStructEnd();
38454
      oprot.writeStructEnd();
38550
    }
38455
    }
38551
 
38456
 
38552
    @Override
38457
    @Override
38553
    public String toString() {
38458
    public String toString() {
38554
      StringBuilder sb = new StringBuilder("addBanner_result(");
38459
      StringBuilder sb = new StringBuilder("addBanner_result(");
38555
      boolean first = true;
38460
      boolean first = true;
38556
 
38461
 
38557
      sb.append("success:");
-
 
38558
      sb.append(this.success);
-
 
38559
      first = false;
-
 
38560
      sb.append(")");
38462
      sb.append(")");
38561
      return sb.toString();
38463
      return sb.toString();
38562
    }
38464
    }
38563
 
38465
 
38564
    public void validate() throws org.apache.thrift.TException {
38466
    public void validate() throws org.apache.thrift.TException {
Line 39619... Line 39521...
39619
        }
39521
        }
39620
        switch (field.id) {
39522
        switch (field.id) {
39621
          case 0: // SUCCESS
39523
          case 0: // SUCCESS
39622
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
39524
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
39623
              {
39525
              {
39624
                org.apache.thrift.protocol.TList _list103 = iprot.readListBegin();
39526
                org.apache.thrift.protocol.TList _list111 = iprot.readListBegin();
39625
                this.success = new ArrayList<Banner>(_list103.size);
39527
                this.success = new ArrayList<Banner>(_list111.size);
39626
                for (int _i104 = 0; _i104 < _list103.size; ++_i104)
39528
                for (int _i112 = 0; _i112 < _list111.size; ++_i112)
39627
                {
39529
                {
39628
                  Banner _elem105; // required
39530
                  Banner _elem113; // required
39629
                  _elem105 = new Banner();
39531
                  _elem113 = new Banner();
39630
                  _elem105.read(iprot);
39532
                  _elem113.read(iprot);
39631
                  this.success.add(_elem105);
39533
                  this.success.add(_elem113);
39632
                }
39534
                }
39633
                iprot.readListEnd();
39535
                iprot.readListEnd();
39634
              }
39536
              }
39635
            } else { 
39537
            } else { 
39636
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
39538
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 39650... Line 39552...
39650
 
39552
 
39651
      if (this.isSetSuccess()) {
39553
      if (this.isSetSuccess()) {
39652
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
39554
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
39653
        {
39555
        {
39654
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
39556
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
39655
          for (Banner _iter106 : this.success)
39557
          for (Banner _iter114 : this.success)
39656
          {
39558
          {
39657
            _iter106.write(oprot);
39559
            _iter114.write(oprot);
39658
          }
39560
          }
39659
          oprot.writeListEnd();
39561
          oprot.writeListEnd();
39660
        }
39562
        }
39661
        oprot.writeFieldEnd();
39563
        oprot.writeFieldEnd();
39662
      }
39564
      }
Line 41334... Line 41236...
41334
        }
41236
        }
41335
        switch (field.id) {
41237
        switch (field.id) {
41336
          case 0: // SUCCESS
41238
          case 0: // SUCCESS
41337
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
41239
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
41338
              {
41240
              {
41339
                org.apache.thrift.protocol.TMap _map107 = iprot.readMapBegin();
41241
                org.apache.thrift.protocol.TMap _map115 = iprot.readMapBegin();
41340
                this.success = new HashMap<String,List<Banner>>(2*_map107.size);
41242
                this.success = new HashMap<String,List<Banner>>(2*_map115.size);
41341
                for (int _i108 = 0; _i108 < _map107.size; ++_i108)
41243
                for (int _i116 = 0; _i116 < _map115.size; ++_i116)
41342
                {
41244
                {
41343
                  String _key109; // required
41245
                  String _key117; // required
41344
                  List<Banner> _val110; // required
41246
                  List<Banner> _val118; // required
41345
                  _key109 = iprot.readString();
41247
                  _key117 = iprot.readString();
41346
                  {
41248
                  {
41347
                    org.apache.thrift.protocol.TList _list111 = iprot.readListBegin();
41249
                    org.apache.thrift.protocol.TList _list119 = iprot.readListBegin();
41348
                    _val110 = new ArrayList<Banner>(_list111.size);
41250
                    _val118 = new ArrayList<Banner>(_list119.size);
41349
                    for (int _i112 = 0; _i112 < _list111.size; ++_i112)
41251
                    for (int _i120 = 0; _i120 < _list119.size; ++_i120)
41350
                    {
41252
                    {
41351
                      Banner _elem113; // required
41253
                      Banner _elem121; // required
41352
                      _elem113 = new Banner();
41254
                      _elem121 = new Banner();
41353
                      _elem113.read(iprot);
41255
                      _elem121.read(iprot);
41354
                      _val110.add(_elem113);
41256
                      _val118.add(_elem121);
41355
                    }
41257
                    }
41356
                    iprot.readListEnd();
41258
                    iprot.readListEnd();
41357
                  }
41259
                  }
41358
                  this.success.put(_key109, _val110);
41260
                  this.success.put(_key117, _val118);
41359
                }
41261
                }
41360
                iprot.readMapEnd();
41262
                iprot.readMapEnd();
41361
              }
41263
              }
41362
            } else { 
41264
            } else { 
41363
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
41265
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 41377... Line 41279...
41377
 
41279
 
41378
      if (this.isSetSuccess()) {
41280
      if (this.isSetSuccess()) {
41379
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
41281
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
41380
        {
41282
        {
41381
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.LIST, this.success.size()));
41283
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.LIST, this.success.size()));
41382
          for (Map.Entry<String, List<Banner>> _iter114 : this.success.entrySet())
41284
          for (Map.Entry<String, List<Banner>> _iter122 : this.success.entrySet())
41383
          {
41285
          {
41384
            oprot.writeString(_iter114.getKey());
41286
            oprot.writeString(_iter122.getKey());
41385
            {
41287
            {
41386
              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter114.getValue().size()));
41288
              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter122.getValue().size()));
41387
              for (Banner _iter115 : _iter114.getValue())
41289
              for (Banner _iter123 : _iter122.getValue())
41388
              {
41290
              {
41389
                _iter115.write(oprot);
41291
                _iter123.write(oprot);
41390
              }
41292
              }
41391
              oprot.writeListEnd();
41293
              oprot.writeListEnd();
41392
            }
41294
            }
41393
          }
41295
          }
41394
          oprot.writeMapEnd();
41296
          oprot.writeMapEnd();
Line 41685... Line 41587...
41685
        }
41587
        }
41686
        switch (field.id) {
41588
        switch (field.id) {
41687
          case 1: // BANNER_MAPS
41589
          case 1: // BANNER_MAPS
41688
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
41590
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
41689
              {
41591
              {
41690
                org.apache.thrift.protocol.TList _list116 = iprot.readListBegin();
41592
                org.apache.thrift.protocol.TList _list124 = iprot.readListBegin();
41691
                this.bannerMaps = new ArrayList<BannerMap>(_list116.size);
41593
                this.bannerMaps = new ArrayList<BannerMap>(_list124.size);
41692
                for (int _i117 = 0; _i117 < _list116.size; ++_i117)
41594
                for (int _i125 = 0; _i125 < _list124.size; ++_i125)
41693
                {
41595
                {
41694
                  BannerMap _elem118; // required
41596
                  BannerMap _elem126; // required
41695
                  _elem118 = new BannerMap();
41597
                  _elem126 = new BannerMap();
41696
                  _elem118.read(iprot);
41598
                  _elem126.read(iprot);
41697
                  this.bannerMaps.add(_elem118);
41599
                  this.bannerMaps.add(_elem126);
41698
                }
41600
                }
41699
                iprot.readListEnd();
41601
                iprot.readListEnd();
41700
              }
41602
              }
41701
            } else { 
41603
            } else { 
41702
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
41604
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 41717... Line 41619...
41717
      oprot.writeStructBegin(STRUCT_DESC);
41619
      oprot.writeStructBegin(STRUCT_DESC);
41718
      if (this.bannerMaps != null) {
41620
      if (this.bannerMaps != null) {
41719
        oprot.writeFieldBegin(BANNER_MAPS_FIELD_DESC);
41621
        oprot.writeFieldBegin(BANNER_MAPS_FIELD_DESC);
41720
        {
41622
        {
41721
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.bannerMaps.size()));
41623
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.bannerMaps.size()));
41722
          for (BannerMap _iter119 : this.bannerMaps)
41624
          for (BannerMap _iter127 : this.bannerMaps)
41723
          {
41625
          {
41724
            _iter119.write(oprot);
41626
            _iter127.write(oprot);
41725
          }
41627
          }
41726
          oprot.writeListEnd();
41628
          oprot.writeListEnd();
41727
        }
41629
        }
41728
        oprot.writeFieldEnd();
41630
        oprot.writeFieldEnd();
41729
      }
41631
      }
Line 43779... Line 43681...
43779
        }
43681
        }
43780
        switch (field.id) {
43682
        switch (field.id) {
43781
          case 0: // SUCCESS
43683
          case 0: // SUCCESS
43782
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
43684
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
43783
              {
43685
              {
43784
                org.apache.thrift.protocol.TList _list120 = iprot.readListBegin();
43686
                org.apache.thrift.protocol.TList _list128 = iprot.readListBegin();
43785
                this.success = new ArrayList<BannerMap>(_list120.size);
43687
                this.success = new ArrayList<BannerMap>(_list128.size);
43786
                for (int _i121 = 0; _i121 < _list120.size; ++_i121)
43688
                for (int _i129 = 0; _i129 < _list128.size; ++_i129)
43787
                {
43689
                {
43788
                  BannerMap _elem122; // required
43690
                  BannerMap _elem130; // required
43789
                  _elem122 = new BannerMap();
43691
                  _elem130 = new BannerMap();
43790
                  _elem122.read(iprot);
43692
                  _elem130.read(iprot);
43791
                  this.success.add(_elem122);
43693
                  this.success.add(_elem130);
43792
                }
43694
                }
43793
                iprot.readListEnd();
43695
                iprot.readListEnd();
43794
              }
43696
              }
43795
            } else { 
43697
            } else { 
43796
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
43698
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 43810... Line 43712...
43810
 
43712
 
43811
      if (this.isSetSuccess()) {
43713
      if (this.isSetSuccess()) {
43812
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
43714
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
43813
        {
43715
        {
43814
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
43716
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
43815
          for (BannerMap _iter123 : this.success)
43717
          for (BannerMap _iter131 : this.success)
43816
          {
43718
          {
43817
            _iter123.write(oprot);
43719
            _iter131.write(oprot);
43818
          }
43720
          }
43819
          oprot.writeListEnd();
43721
          oprot.writeListEnd();
43820
        }
43722
        }
43821
        oprot.writeFieldEnd();
43723
        oprot.writeFieldEnd();
43822
      }
43724
      }
Line 44110... Line 44012...
44110
        }
44012
        }
44111
        switch (field.id) {
44013
        switch (field.id) {
44112
          case 1: // BANNER_URI_MAPPINGS
44014
          case 1: // BANNER_URI_MAPPINGS
44113
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
44015
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
44114
              {
44016
              {
44115
                org.apache.thrift.protocol.TList _list124 = iprot.readListBegin();
44017
                org.apache.thrift.protocol.TList _list132 = iprot.readListBegin();
44116
                this.bannerUriMappings = new ArrayList<BannerUriMapping>(_list124.size);
44018
                this.bannerUriMappings = new ArrayList<BannerUriMapping>(_list132.size);
44117
                for (int _i125 = 0; _i125 < _list124.size; ++_i125)
44019
                for (int _i133 = 0; _i133 < _list132.size; ++_i133)
44118
                {
44020
                {
44119
                  BannerUriMapping _elem126; // required
44021
                  BannerUriMapping _elem134; // required
44120
                  _elem126 = new BannerUriMapping();
44022
                  _elem134 = new BannerUriMapping();
44121
                  _elem126.read(iprot);
44023
                  _elem134.read(iprot);
44122
                  this.bannerUriMappings.add(_elem126);
44024
                  this.bannerUriMappings.add(_elem134);
44123
                }
44025
                }
44124
                iprot.readListEnd();
44026
                iprot.readListEnd();
44125
              }
44027
              }
44126
            } else { 
44028
            } else { 
44127
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
44029
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 44142... Line 44044...
44142
      oprot.writeStructBegin(STRUCT_DESC);
44044
      oprot.writeStructBegin(STRUCT_DESC);
44143
      if (this.bannerUriMappings != null) {
44045
      if (this.bannerUriMappings != null) {
44144
        oprot.writeFieldBegin(BANNER_URI_MAPPINGS_FIELD_DESC);
44046
        oprot.writeFieldBegin(BANNER_URI_MAPPINGS_FIELD_DESC);
44145
        {
44047
        {
44146
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.bannerUriMappings.size()));
44048
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.bannerUriMappings.size()));
44147
          for (BannerUriMapping _iter127 : this.bannerUriMappings)
44049
          for (BannerUriMapping _iter135 : this.bannerUriMappings)
44148
          {
44050
          {
44149
            _iter127.write(oprot);
44051
            _iter135.write(oprot);
44150
          }
44052
          }
44151
          oprot.writeListEnd();
44053
          oprot.writeListEnd();
44152
        }
44054
        }
44153
        oprot.writeFieldEnd();
44055
        oprot.writeFieldEnd();
44154
      }
44056
      }
Line 44935... Line 44837...
44935
        }
44837
        }
44936
        switch (field.id) {
44838
        switch (field.id) {
44937
          case 0: // SUCCESS
44839
          case 0: // SUCCESS
44938
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
44840
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
44939
              {
44841
              {
44940
                org.apache.thrift.protocol.TList _list128 = iprot.readListBegin();
44842
                org.apache.thrift.protocol.TList _list136 = iprot.readListBegin();
44941
                this.success = new ArrayList<BannerUriMapping>(_list128.size);
44843
                this.success = new ArrayList<BannerUriMapping>(_list136.size);
44942
                for (int _i129 = 0; _i129 < _list128.size; ++_i129)
44844
                for (int _i137 = 0; _i137 < _list136.size; ++_i137)
44943
                {
44845
                {
44944
                  BannerUriMapping _elem130; // required
44846
                  BannerUriMapping _elem138; // required
44945
                  _elem130 = new BannerUriMapping();
44847
                  _elem138 = new BannerUriMapping();
44946
                  _elem130.read(iprot);
44848
                  _elem138.read(iprot);
44947
                  this.success.add(_elem130);
44849
                  this.success.add(_elem138);
44948
                }
44850
                }
44949
                iprot.readListEnd();
44851
                iprot.readListEnd();
44950
              }
44852
              }
44951
            } else { 
44853
            } else { 
44952
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
44854
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 44966... Line 44868...
44966
 
44868
 
44967
      if (this.isSetSuccess()) {
44869
      if (this.isSetSuccess()) {
44968
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
44870
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
44969
        {
44871
        {
44970
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
44872
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
44971
          for (BannerUriMapping _iter131 : this.success)
44873
          for (BannerUriMapping _iter139 : this.success)
44972
          {
44874
          {
44973
            _iter131.write(oprot);
44875
            _iter139.write(oprot);
44974
          }
44876
          }
44975
          oprot.writeListEnd();
44877
          oprot.writeListEnd();
44976
        }
44878
        }
44977
        oprot.writeFieldEnd();
44879
        oprot.writeFieldEnd();
44978
      }
44880
      }
Line 46054... Line 45956...
46054
        }
45956
        }
46055
        switch (field.id) {
45957
        switch (field.id) {
46056
          case 0: // SUCCESS
45958
          case 0: // SUCCESS
46057
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
45959
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
46058
              {
45960
              {
46059
                org.apache.thrift.protocol.TList _list132 = iprot.readListBegin();
45961
                org.apache.thrift.protocol.TList _list140 = iprot.readListBegin();
46060
                this.success = new ArrayList<Campaign>(_list132.size);
45962
                this.success = new ArrayList<Campaign>(_list140.size);
46061
                for (int _i133 = 0; _i133 < _list132.size; ++_i133)
45963
                for (int _i141 = 0; _i141 < _list140.size; ++_i141)
46062
                {
45964
                {
46063
                  Campaign _elem134; // required
45965
                  Campaign _elem142; // required
46064
                  _elem134 = new Campaign();
45966
                  _elem142 = new Campaign();
46065
                  _elem134.read(iprot);
45967
                  _elem142.read(iprot);
46066
                  this.success.add(_elem134);
45968
                  this.success.add(_elem142);
46067
                }
45969
                }
46068
                iprot.readListEnd();
45970
                iprot.readListEnd();
46069
              }
45971
              }
46070
            } else { 
45972
            } else { 
46071
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
45973
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 46085... Line 45987...
46085
 
45987
 
46086
      if (this.isSetSuccess()) {
45988
      if (this.isSetSuccess()) {
46087
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
45989
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
46088
        {
45990
        {
46089
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
45991
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
46090
          for (Campaign _iter135 : this.success)
45992
          for (Campaign _iter143 : this.success)
46091
          {
45993
          {
46092
            _iter135.write(oprot);
45994
            _iter143.write(oprot);
46093
          }
45995
          }
46094
          oprot.writeListEnd();
45996
          oprot.writeListEnd();
46095
        }
45997
        }
46096
        oprot.writeFieldEnd();
45998
        oprot.writeFieldEnd();
46097
      }
45999
      }
Line 47078... Line 46980...
47078
        }
46980
        }
47079
        switch (field.id) {
46981
        switch (field.id) {
47080
          case 0: // SUCCESS
46982
          case 0: // SUCCESS
47081
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
46983
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
47082
              {
46984
              {
47083
                org.apache.thrift.protocol.TList _list136 = iprot.readListBegin();
46985
                org.apache.thrift.protocol.TList _list144 = iprot.readListBegin();
47084
                this.success = new ArrayList<String>(_list136.size);
46986
                this.success = new ArrayList<String>(_list144.size);
47085
                for (int _i137 = 0; _i137 < _list136.size; ++_i137)
46987
                for (int _i145 = 0; _i145 < _list144.size; ++_i145)
47086
                {
46988
                {
47087
                  String _elem138; // required
46989
                  String _elem146; // required
47088
                  _elem138 = iprot.readString();
46990
                  _elem146 = iprot.readString();
47089
                  this.success.add(_elem138);
46991
                  this.success.add(_elem146);
47090
                }
46992
                }
47091
                iprot.readListEnd();
46993
                iprot.readListEnd();
47092
              }
46994
              }
47093
            } else { 
46995
            } else { 
47094
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
46996
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 47108... Line 47010...
47108
 
47010
 
47109
      if (this.isSetSuccess()) {
47011
      if (this.isSetSuccess()) {
47110
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
47012
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
47111
        {
47013
        {
47112
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
47014
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
47113
          for (String _iter139 : this.success)
47015
          for (String _iter147 : this.success)
47114
          {
47016
          {
47115
            oprot.writeString(_iter139);
47017
            oprot.writeString(_iter147);
47116
          }
47018
          }
47117
          oprot.writeListEnd();
47019
          oprot.writeListEnd();
47118
        }
47020
        }
47119
        oprot.writeFieldEnd();
47021
        oprot.writeFieldEnd();
47120
      }
47022
      }
Line 50284... Line 50186...
50284
        }
50186
        }
50285
        switch (field.id) {
50187
        switch (field.id) {
50286
          case 0: // SUCCESS
50188
          case 0: // SUCCESS
50287
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
50189
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
50288
              {
50190
              {
50289
                org.apache.thrift.protocol.TList _list140 = iprot.readListBegin();
50191
                org.apache.thrift.protocol.TList _list148 = iprot.readListBegin();
50290
                this.success = new ArrayList<Item>(_list140.size);
50192
                this.success = new ArrayList<Item>(_list148.size);
50291
                for (int _i141 = 0; _i141 < _list140.size; ++_i141)
50193
                for (int _i149 = 0; _i149 < _list148.size; ++_i149)
50292
                {
50194
                {
50293
                  Item _elem142; // required
50195
                  Item _elem150; // required
50294
                  _elem142 = new Item();
50196
                  _elem150 = new Item();
50295
                  _elem142.read(iprot);
50197
                  _elem150.read(iprot);
50296
                  this.success.add(_elem142);
50198
                  this.success.add(_elem150);
50297
                }
50199
                }
50298
                iprot.readListEnd();
50200
                iprot.readListEnd();
50299
              }
50201
              }
50300
            } else { 
50202
            } else { 
50301
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
50203
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 50315... Line 50217...
50315
 
50217
 
50316
      if (this.isSetSuccess()) {
50218
      if (this.isSetSuccess()) {
50317
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
50219
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
50318
        {
50220
        {
50319
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
50221
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
50320
          for (Item _iter143 : this.success)
50222
          for (Item _iter151 : this.success)
50321
          {
50223
          {
50322
            _iter143.write(oprot);
50224
            _iter151.write(oprot);
50323
          }
50225
          }
50324
          oprot.writeListEnd();
50226
          oprot.writeListEnd();
50325
        }
50227
        }
50326
        oprot.writeFieldEnd();
50228
        oprot.writeFieldEnd();
50327
      }
50229
      }
Line 50997... Line 50899...
50997
        }
50899
        }
50998
        switch (field.id) {
50900
        switch (field.id) {
50999
          case 0: // SUCCESS
50901
          case 0: // SUCCESS
51000
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
50902
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
51001
              {
50903
              {
51002
                org.apache.thrift.protocol.TList _list144 = iprot.readListBegin();
50904
                org.apache.thrift.protocol.TList _list152 = iprot.readListBegin();
51003
                this.success = new ArrayList<Item>(_list144.size);
50905
                this.success = new ArrayList<Item>(_list152.size);
51004
                for (int _i145 = 0; _i145 < _list144.size; ++_i145)
50906
                for (int _i153 = 0; _i153 < _list152.size; ++_i153)
51005
                {
50907
                {
51006
                  Item _elem146; // required
50908
                  Item _elem154; // required
51007
                  _elem146 = new Item();
50909
                  _elem154 = new Item();
51008
                  _elem146.read(iprot);
50910
                  _elem154.read(iprot);
51009
                  this.success.add(_elem146);
50911
                  this.success.add(_elem154);
51010
                }
50912
                }
51011
                iprot.readListEnd();
50913
                iprot.readListEnd();
51012
              }
50914
              }
51013
            } else { 
50915
            } else { 
51014
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
50916
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 51028... Line 50930...
51028
 
50930
 
51029
      if (this.isSetSuccess()) {
50931
      if (this.isSetSuccess()) {
51030
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
50932
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
51031
        {
50933
        {
51032
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
50934
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
51033
          for (Item _iter147 : this.success)
50935
          for (Item _iter155 : this.success)
51034
          {
50936
          {
51035
            _iter147.write(oprot);
50937
            _iter155.write(oprot);
51036
          }
50938
          }
51037
          oprot.writeListEnd();
50939
          oprot.writeListEnd();
51038
        }
50940
        }
51039
        oprot.writeFieldEnd();
50941
        oprot.writeFieldEnd();
51040
      }
50942
      }
Line 51786... Line 51688...
51786
        }
51688
        }
51787
        switch (field.id) {
51689
        switch (field.id) {
51788
          case 0: // SUCCESS
51690
          case 0: // SUCCESS
51789
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
51691
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
51790
              {
51692
              {
51791
                org.apache.thrift.protocol.TList _list148 = iprot.readListBegin();
51693
                org.apache.thrift.protocol.TList _list156 = iprot.readListBegin();
51792
                this.success = new ArrayList<Long>(_list148.size);
51694
                this.success = new ArrayList<Long>(_list156.size);
51793
                for (int _i149 = 0; _i149 < _list148.size; ++_i149)
51695
                for (int _i157 = 0; _i157 < _list156.size; ++_i157)
51794
                {
51696
                {
51795
                  long _elem150; // required
51697
                  long _elem158; // required
51796
                  _elem150 = iprot.readI64();
51698
                  _elem158 = iprot.readI64();
51797
                  this.success.add(_elem150);
51699
                  this.success.add(_elem158);
51798
                }
51700
                }
51799
                iprot.readListEnd();
51701
                iprot.readListEnd();
51800
              }
51702
              }
51801
            } else { 
51703
            } else { 
51802
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
51704
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 51816... Line 51718...
51816
 
51718
 
51817
      if (this.isSetSuccess()) {
51719
      if (this.isSetSuccess()) {
51818
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
51720
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
51819
        {
51721
        {
51820
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
51722
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
51821
          for (long _iter151 : this.success)
51723
          for (long _iter159 : this.success)
51822
          {
51724
          {
51823
            oprot.writeI64(_iter151);
51725
            oprot.writeI64(_iter159);
51824
          }
51726
          }
51825
          oprot.writeListEnd();
51727
          oprot.writeListEnd();
51826
        }
51728
        }
51827
        oprot.writeFieldEnd();
51729
        oprot.writeFieldEnd();
51828
      }
51730
      }
Line 53578... Line 53480...
53578
        }
53480
        }
53579
        switch (field.id) {
53481
        switch (field.id) {
53580
          case 0: // SUCCESS
53482
          case 0: // SUCCESS
53581
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
53483
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
53582
              {
53484
              {
53583
                org.apache.thrift.protocol.TList _list152 = iprot.readListBegin();
53485
                org.apache.thrift.protocol.TList _list160 = iprot.readListBegin();
53584
                this.success = new ArrayList<String>(_list152.size);
53486
                this.success = new ArrayList<String>(_list160.size);
53585
                for (int _i153 = 0; _i153 < _list152.size; ++_i153)
53487
                for (int _i161 = 0; _i161 < _list160.size; ++_i161)
53586
                {
53488
                {
53587
                  String _elem154; // required
53489
                  String _elem162; // required
53588
                  _elem154 = iprot.readString();
53490
                  _elem162 = iprot.readString();
53589
                  this.success.add(_elem154);
53491
                  this.success.add(_elem162);
53590
                }
53492
                }
53591
                iprot.readListEnd();
53493
                iprot.readListEnd();
53592
              }
53494
              }
53593
            } else { 
53495
            } else { 
53594
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
53496
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 53608... Line 53510...
53608
 
53510
 
53609
      if (this.isSetSuccess()) {
53511
      if (this.isSetSuccess()) {
53610
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
53512
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
53611
        {
53513
        {
53612
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
53514
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
53613
          for (String _iter155 : this.success)
53515
          for (String _iter163 : this.success)
53614
          {
53516
          {
53615
            oprot.writeString(_iter155);
53517
            oprot.writeString(_iter163);
53616
          }
53518
          }
53617
          oprot.writeListEnd();
53519
          oprot.writeListEnd();
53618
        }
53520
        }
53619
        oprot.writeFieldEnd();
53521
        oprot.writeFieldEnd();
53620
      }
53522
      }
Line 54108... Line 54010...
54108
        }
54010
        }
54109
        switch (field.id) {
54011
        switch (field.id) {
54110
          case 0: // SUCCESS
54012
          case 0: // SUCCESS
54111
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
54013
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
54112
              {
54014
              {
54113
                org.apache.thrift.protocol.TList _list156 = iprot.readListBegin();
54015
                org.apache.thrift.protocol.TList _list164 = iprot.readListBegin();
54114
                this.success = new ArrayList<String>(_list156.size);
54016
                this.success = new ArrayList<String>(_list164.size);
54115
                for (int _i157 = 0; _i157 < _list156.size; ++_i157)
54017
                for (int _i165 = 0; _i165 < _list164.size; ++_i165)
54116
                {
54018
                {
54117
                  String _elem158; // required
54019
                  String _elem166; // required
54118
                  _elem158 = iprot.readString();
54020
                  _elem166 = iprot.readString();
54119
                  this.success.add(_elem158);
54021
                  this.success.add(_elem166);
54120
                }
54022
                }
54121
                iprot.readListEnd();
54023
                iprot.readListEnd();
54122
              }
54024
              }
54123
            } else { 
54025
            } else { 
54124
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
54026
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 54138... Line 54040...
54138
 
54040
 
54139
      if (this.isSetSuccess()) {
54041
      if (this.isSetSuccess()) {
54140
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
54042
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
54141
        {
54043
        {
54142
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
54044
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
54143
          for (String _iter159 : this.success)
54045
          for (String _iter167 : this.success)
54144
          {
54046
          {
54145
            oprot.writeString(_iter159);
54047
            oprot.writeString(_iter167);
54146
          }
54048
          }
54147
          oprot.writeListEnd();
54049
          oprot.writeListEnd();
54148
        }
54050
        }
54149
        oprot.writeFieldEnd();
54051
        oprot.writeFieldEnd();
54150
      }
54052
      }
Line 54638... Line 54540...
54638
        }
54540
        }
54639
        switch (field.id) {
54541
        switch (field.id) {
54640
          case 0: // SUCCESS
54542
          case 0: // SUCCESS
54641
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
54543
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
54642
              {
54544
              {
54643
                org.apache.thrift.protocol.TList _list160 = iprot.readListBegin();
54545
                org.apache.thrift.protocol.TList _list168 = iprot.readListBegin();
54644
                this.success = new ArrayList<Source>(_list160.size);
54546
                this.success = new ArrayList<Source>(_list168.size);
54645
                for (int _i161 = 0; _i161 < _list160.size; ++_i161)
54547
                for (int _i169 = 0; _i169 < _list168.size; ++_i169)
54646
                {
54548
                {
54647
                  Source _elem162; // required
54549
                  Source _elem170; // required
54648
                  _elem162 = new Source();
54550
                  _elem170 = new Source();
54649
                  _elem162.read(iprot);
54551
                  _elem170.read(iprot);
54650
                  this.success.add(_elem162);
54552
                  this.success.add(_elem170);
54651
                }
54553
                }
54652
                iprot.readListEnd();
54554
                iprot.readListEnd();
54653
              }
54555
              }
54654
            } else { 
54556
            } else { 
54655
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
54557
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 54669... Line 54571...
54669
 
54571
 
54670
      if (this.isSetSuccess()) {
54572
      if (this.isSetSuccess()) {
54671
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
54573
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
54672
        {
54574
        {
54673
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
54575
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
54674
          for (Source _iter163 : this.success)
54576
          for (Source _iter171 : this.success)
54675
          {
54577
          {
54676
            _iter163.write(oprot);
54578
            _iter171.write(oprot);
54677
          }
54579
          }
54678
          oprot.writeListEnd();
54580
          oprot.writeListEnd();
54679
        }
54581
        }
54680
        oprot.writeFieldEnd();
54582
        oprot.writeFieldEnd();
54681
      }
54583
      }
Line 56675... Line 56577...
56675
        }
56577
        }
56676
        switch (field.id) {
56578
        switch (field.id) {
56677
          case 0: // SUCCESS
56579
          case 0: // SUCCESS
56678
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
56580
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
56679
              {
56581
              {
56680
                org.apache.thrift.protocol.TList _list164 = iprot.readListBegin();
56582
                org.apache.thrift.protocol.TList _list172 = iprot.readListBegin();
56681
                this.success = new ArrayList<SourceItemPricing>(_list164.size);
56583
                this.success = new ArrayList<SourceItemPricing>(_list172.size);
56682
                for (int _i165 = 0; _i165 < _list164.size; ++_i165)
56584
                for (int _i173 = 0; _i173 < _list172.size; ++_i173)
56683
                {
56585
                {
56684
                  SourceItemPricing _elem166; // required
56586
                  SourceItemPricing _elem174; // required
56685
                  _elem166 = new SourceItemPricing();
56587
                  _elem174 = new SourceItemPricing();
56686
                  _elem166.read(iprot);
56588
                  _elem174.read(iprot);
56687
                  this.success.add(_elem166);
56589
                  this.success.add(_elem174);
56688
                }
56590
                }
56689
                iprot.readListEnd();
56591
                iprot.readListEnd();
56690
              }
56592
              }
56691
            } else { 
56593
            } else { 
56692
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
56594
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 56714... Line 56616...
56714
 
56616
 
56715
      if (this.isSetSuccess()) {
56617
      if (this.isSetSuccess()) {
56716
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
56618
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
56717
        {
56619
        {
56718
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
56620
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
56719
          for (SourceItemPricing _iter167 : this.success)
56621
          for (SourceItemPricing _iter175 : this.success)
56720
          {
56622
          {
56721
            _iter167.write(oprot);
56623
            _iter175.write(oprot);
56722
          }
56624
          }
56723
          oprot.writeListEnd();
56625
          oprot.writeListEnd();
56724
        }
56626
        }
56725
        oprot.writeFieldEnd();
56627
        oprot.writeFieldEnd();
56726
      } else if (this.isSetCex()) {
56628
      } else if (this.isSetCex()) {
Line 57922... Line 57824...
57922
        }
57824
        }
57923
        switch (field.id) {
57825
        switch (field.id) {
57924
          case 1: // SEARCH_TERMS
57826
          case 1: // SEARCH_TERMS
57925
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
57827
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
57926
              {
57828
              {
57927
                org.apache.thrift.protocol.TList _list168 = iprot.readListBegin();
57829
                org.apache.thrift.protocol.TList _list176 = iprot.readListBegin();
57928
                this.searchTerms = new ArrayList<String>(_list168.size);
57830
                this.searchTerms = new ArrayList<String>(_list176.size);
57929
                for (int _i169 = 0; _i169 < _list168.size; ++_i169)
57831
                for (int _i177 = 0; _i177 < _list176.size; ++_i177)
57930
                {
57832
                {
57931
                  String _elem170; // required
57833
                  String _elem178; // required
57932
                  _elem170 = iprot.readString();
57834
                  _elem178 = iprot.readString();
57933
                  this.searchTerms.add(_elem170);
57835
                  this.searchTerms.add(_elem178);
57934
                }
57836
                }
57935
                iprot.readListEnd();
57837
                iprot.readListEnd();
57936
              }
57838
              }
57937
            } else { 
57839
            } else { 
57938
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
57840
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 57969... Line 57871...
57969
      oprot.writeStructBegin(STRUCT_DESC);
57871
      oprot.writeStructBegin(STRUCT_DESC);
57970
      if (this.searchTerms != null) {
57872
      if (this.searchTerms != null) {
57971
        oprot.writeFieldBegin(SEARCH_TERMS_FIELD_DESC);
57873
        oprot.writeFieldBegin(SEARCH_TERMS_FIELD_DESC);
57972
        {
57874
        {
57973
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerms.size()));
57875
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerms.size()));
57974
          for (String _iter171 : this.searchTerms)
57876
          for (String _iter179 : this.searchTerms)
57975
          {
57877
          {
57976
            oprot.writeString(_iter171);
57878
            oprot.writeString(_iter179);
57977
          }
57879
          }
57978
          oprot.writeListEnd();
57880
          oprot.writeListEnd();
57979
        }
57881
        }
57980
        oprot.writeFieldEnd();
57882
        oprot.writeFieldEnd();
57981
      }
57883
      }
Line 58283... Line 58185...
58283
        }
58185
        }
58284
        switch (field.id) {
58186
        switch (field.id) {
58285
          case 0: // SUCCESS
58187
          case 0: // SUCCESS
58286
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
58188
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
58287
              {
58189
              {
58288
                org.apache.thrift.protocol.TList _list172 = iprot.readListBegin();
58190
                org.apache.thrift.protocol.TList _list180 = iprot.readListBegin();
58289
                this.success = new ArrayList<Item>(_list172.size);
58191
                this.success = new ArrayList<Item>(_list180.size);
58290
                for (int _i173 = 0; _i173 < _list172.size; ++_i173)
58192
                for (int _i181 = 0; _i181 < _list180.size; ++_i181)
58291
                {
58193
                {
58292
                  Item _elem174; // required
58194
                  Item _elem182; // required
58293
                  _elem174 = new Item();
58195
                  _elem182 = new Item();
58294
                  _elem174.read(iprot);
58196
                  _elem182.read(iprot);
58295
                  this.success.add(_elem174);
58197
                  this.success.add(_elem182);
58296
                }
58198
                }
58297
                iprot.readListEnd();
58199
                iprot.readListEnd();
58298
              }
58200
              }
58299
            } else { 
58201
            } else { 
58300
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
58202
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 58314... Line 58216...
58314
 
58216
 
58315
      if (this.isSetSuccess()) {
58217
      if (this.isSetSuccess()) {
58316
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
58218
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
58317
        {
58219
        {
58318
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
58220
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
58319
          for (Item _iter175 : this.success)
58221
          for (Item _iter183 : this.success)
58320
          {
58222
          {
58321
            _iter175.write(oprot);
58223
            _iter183.write(oprot);
58322
          }
58224
          }
58323
          oprot.writeListEnd();
58225
          oprot.writeListEnd();
58324
        }
58226
        }
58325
        oprot.writeFieldEnd();
58227
        oprot.writeFieldEnd();
58326
      }
58228
      }
Line 58614... Line 58516...
58614
        }
58516
        }
58615
        switch (field.id) {
58517
        switch (field.id) {
58616
          case 1: // SEARCH_TERMS
58518
          case 1: // SEARCH_TERMS
58617
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
58519
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
58618
              {
58520
              {
58619
                org.apache.thrift.protocol.TList _list176 = iprot.readListBegin();
58521
                org.apache.thrift.protocol.TList _list184 = iprot.readListBegin();
58620
                this.searchTerms = new ArrayList<String>(_list176.size);
58522
                this.searchTerms = new ArrayList<String>(_list184.size);
58621
                for (int _i177 = 0; _i177 < _list176.size; ++_i177)
58523
                for (int _i185 = 0; _i185 < _list184.size; ++_i185)
58622
                {
58524
                {
58623
                  String _elem178; // required
58525
                  String _elem186; // required
58624
                  _elem178 = iprot.readString();
58526
                  _elem186 = iprot.readString();
58625
                  this.searchTerms.add(_elem178);
58527
                  this.searchTerms.add(_elem186);
58626
                }
58528
                }
58627
                iprot.readListEnd();
58529
                iprot.readListEnd();
58628
              }
58530
              }
58629
            } else { 
58531
            } else { 
58630
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
58532
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 58645... Line 58547...
58645
      oprot.writeStructBegin(STRUCT_DESC);
58547
      oprot.writeStructBegin(STRUCT_DESC);
58646
      if (this.searchTerms != null) {
58548
      if (this.searchTerms != null) {
58647
        oprot.writeFieldBegin(SEARCH_TERMS_FIELD_DESC);
58549
        oprot.writeFieldBegin(SEARCH_TERMS_FIELD_DESC);
58648
        {
58550
        {
58649
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerms.size()));
58551
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerms.size()));
58650
          for (String _iter179 : this.searchTerms)
58552
          for (String _iter187 : this.searchTerms)
58651
          {
58553
          {
58652
            oprot.writeString(_iter179);
58554
            oprot.writeString(_iter187);
58653
          }
58555
          }
58654
          oprot.writeListEnd();
58556
          oprot.writeListEnd();
58655
        }
58557
        }
58656
        oprot.writeFieldEnd();
58558
        oprot.writeFieldEnd();
58657
      }
58559
      }
Line 59532... Line 59434...
59532
        }
59434
        }
59533
        switch (field.id) {
59435
        switch (field.id) {
59534
          case 0: // SUCCESS
59436
          case 0: // SUCCESS
59535
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
59437
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
59536
              {
59438
              {
59537
                org.apache.thrift.protocol.TList _list180 = iprot.readListBegin();
59439
                org.apache.thrift.protocol.TList _list188 = iprot.readListBegin();
59538
                this.success = new ArrayList<ProductNotificationRequest>(_list180.size);
59440
                this.success = new ArrayList<ProductNotificationRequest>(_list188.size);
59539
                for (int _i181 = 0; _i181 < _list180.size; ++_i181)
59441
                for (int _i189 = 0; _i189 < _list188.size; ++_i189)
59540
                {
59442
                {
59541
                  ProductNotificationRequest _elem182; // required
59443
                  ProductNotificationRequest _elem190; // required
59542
                  _elem182 = new ProductNotificationRequest();
59444
                  _elem190 = new ProductNotificationRequest();
59543
                  _elem182.read(iprot);
59445
                  _elem190.read(iprot);
59544
                  this.success.add(_elem182);
59446
                  this.success.add(_elem190);
59545
                }
59447
                }
59546
                iprot.readListEnd();
59448
                iprot.readListEnd();
59547
              }
59449
              }
59548
            } else { 
59450
            } else { 
59549
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
59451
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 59563... Line 59465...
59563
 
59465
 
59564
      if (this.isSetSuccess()) {
59466
      if (this.isSetSuccess()) {
59565
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
59467
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
59566
        {
59468
        {
59567
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
59469
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
59568
          for (ProductNotificationRequest _iter183 : this.success)
59470
          for (ProductNotificationRequest _iter191 : this.success)
59569
          {
59471
          {
59570
            _iter183.write(oprot);
59472
            _iter191.write(oprot);
59571
          }
59473
          }
59572
          oprot.writeListEnd();
59474
          oprot.writeListEnd();
59573
        }
59475
        }
59574
        oprot.writeFieldEnd();
59476
        oprot.writeFieldEnd();
59575
      }
59477
      }
Line 60240... Line 60142...
60240
        }
60142
        }
60241
        switch (field.id) {
60143
        switch (field.id) {
60242
          case 0: // SUCCESS
60144
          case 0: // SUCCESS
60243
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
60145
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
60244
              {
60146
              {
60245
                org.apache.thrift.protocol.TList _list184 = iprot.readListBegin();
60147
                org.apache.thrift.protocol.TList _list192 = iprot.readListBegin();
60246
                this.success = new ArrayList<ProductNotificationRequestCount>(_list184.size);
60148
                this.success = new ArrayList<ProductNotificationRequestCount>(_list192.size);
60247
                for (int _i185 = 0; _i185 < _list184.size; ++_i185)
60149
                for (int _i193 = 0; _i193 < _list192.size; ++_i193)
60248
                {
60150
                {
60249
                  ProductNotificationRequestCount _elem186; // required
60151
                  ProductNotificationRequestCount _elem194; // required
60250
                  _elem186 = new ProductNotificationRequestCount();
60152
                  _elem194 = new ProductNotificationRequestCount();
60251
                  _elem186.read(iprot);
60153
                  _elem194.read(iprot);
60252
                  this.success.add(_elem186);
60154
                  this.success.add(_elem194);
60253
                }
60155
                }
60254
                iprot.readListEnd();
60156
                iprot.readListEnd();
60255
              }
60157
              }
60256
            } else { 
60158
            } else { 
60257
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
60159
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 60271... Line 60173...
60271
 
60173
 
60272
      if (this.isSetSuccess()) {
60174
      if (this.isSetSuccess()) {
60273
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
60175
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
60274
        {
60176
        {
60275
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
60177
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
60276
          for (ProductNotificationRequestCount _iter187 : this.success)
60178
          for (ProductNotificationRequestCount _iter195 : this.success)
60277
          {
60179
          {
60278
            _iter187.write(oprot);
60180
            _iter195.write(oprot);
60279
          }
60181
          }
60280
          oprot.writeListEnd();
60182
          oprot.writeListEnd();
60281
        }
60183
        }
60282
        oprot.writeFieldEnd();
60184
        oprot.writeFieldEnd();
60283
      }
60185
      }
Line 63983... Line 63885...
63983
        }
63885
        }
63984
        switch (field.id) {
63886
        switch (field.id) {
63985
          case 0: // SUCCESS
63887
          case 0: // SUCCESS
63986
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
63888
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
63987
              {
63889
              {
63988
                org.apache.thrift.protocol.TList _list188 = iprot.readListBegin();
63890
                org.apache.thrift.protocol.TList _list196 = iprot.readListBegin();
63989
                this.success = new ArrayList<VoucherItemMapping>(_list188.size);
63891
                this.success = new ArrayList<VoucherItemMapping>(_list196.size);
63990
                for (int _i189 = 0; _i189 < _list188.size; ++_i189)
63892
                for (int _i197 = 0; _i197 < _list196.size; ++_i197)
63991
                {
63893
                {
63992
                  VoucherItemMapping _elem190; // required
63894
                  VoucherItemMapping _elem198; // required
63993
                  _elem190 = new VoucherItemMapping();
63895
                  _elem198 = new VoucherItemMapping();
63994
                  _elem190.read(iprot);
63896
                  _elem198.read(iprot);
63995
                  this.success.add(_elem190);
63897
                  this.success.add(_elem198);
63996
                }
63898
                }
63997
                iprot.readListEnd();
63899
                iprot.readListEnd();
63998
              }
63900
              }
63999
            } else { 
63901
            } else { 
64000
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
63902
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 64014... Line 63916...
64014
 
63916
 
64015
      if (this.isSetSuccess()) {
63917
      if (this.isSetSuccess()) {
64016
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
63918
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
64017
        {
63919
        {
64018
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
63920
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
64019
          for (VoucherItemMapping _iter191 : this.success)
63921
          for (VoucherItemMapping _iter199 : this.success)
64020
          {
63922
          {
64021
            _iter191.write(oprot);
63923
            _iter199.write(oprot);
64022
          }
63924
          }
64023
          oprot.writeListEnd();
63925
          oprot.writeListEnd();
64024
        }
63926
        }
64025
        oprot.writeFieldEnd();
63927
        oprot.writeFieldEnd();
64026
      }
63928
      }
Line 66789... Line 66691...
66789
        }
66691
        }
66790
        switch (field.id) {
66692
        switch (field.id) {
66791
          case 0: // SUCCESS
66693
          case 0: // SUCCESS
66792
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
66694
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
66793
              {
66695
              {
66794
                org.apache.thrift.protocol.TList _list192 = iprot.readListBegin();
66696
                org.apache.thrift.protocol.TList _list200 = iprot.readListBegin();
66795
                this.success = new ArrayList<Item>(_list192.size);
66697
                this.success = new ArrayList<Item>(_list200.size);
66796
                for (int _i193 = 0; _i193 < _list192.size; ++_i193)
66698
                for (int _i201 = 0; _i201 < _list200.size; ++_i201)
66797
                {
66699
                {
66798
                  Item _elem194; // required
66700
                  Item _elem202; // required
66799
                  _elem194 = new Item();
66701
                  _elem202 = new Item();
66800
                  _elem194.read(iprot);
66702
                  _elem202.read(iprot);
66801
                  this.success.add(_elem194);
66703
                  this.success.add(_elem202);
66802
                }
66704
                }
66803
                iprot.readListEnd();
66705
                iprot.readListEnd();
66804
              }
66706
              }
66805
            } else { 
66707
            } else { 
66806
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
66708
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 66820... Line 66722...
66820
 
66722
 
66821
      if (this.isSetSuccess()) {
66723
      if (this.isSetSuccess()) {
66822
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
66724
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
66823
        {
66725
        {
66824
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
66726
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
66825
          for (Item _iter195 : this.success)
66727
          for (Item _iter203 : this.success)
66826
          {
66728
          {
66827
            _iter195.write(oprot);
66729
            _iter203.write(oprot);
66828
          }
66730
          }
66829
          oprot.writeListEnd();
66731
          oprot.writeListEnd();
66830
        }
66732
        }
66831
        oprot.writeFieldEnd();
66733
        oprot.writeFieldEnd();
66832
      }
66734
      }
Line 67320... Line 67222...
67320
        }
67222
        }
67321
        switch (field.id) {
67223
        switch (field.id) {
67322
          case 0: // SUCCESS
67224
          case 0: // SUCCESS
67323
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
67225
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
67324
              {
67226
              {
67325
                org.apache.thrift.protocol.TList _list196 = iprot.readListBegin();
67227
                org.apache.thrift.protocol.TList _list204 = iprot.readListBegin();
67326
                this.success = new ArrayList<Item>(_list196.size);
67228
                this.success = new ArrayList<Item>(_list204.size);
67327
                for (int _i197 = 0; _i197 < _list196.size; ++_i197)
67229
                for (int _i205 = 0; _i205 < _list204.size; ++_i205)
67328
                {
67230
                {
67329
                  Item _elem198; // required
67231
                  Item _elem206; // required
67330
                  _elem198 = new Item();
67232
                  _elem206 = new Item();
67331
                  _elem198.read(iprot);
67233
                  _elem206.read(iprot);
67332
                  this.success.add(_elem198);
67234
                  this.success.add(_elem206);
67333
                }
67235
                }
67334
                iprot.readListEnd();
67236
                iprot.readListEnd();
67335
              }
67237
              }
67336
            } else { 
67238
            } else { 
67337
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
67239
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 67351... Line 67253...
67351
 
67253
 
67352
      if (this.isSetSuccess()) {
67254
      if (this.isSetSuccess()) {
67353
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
67255
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
67354
        {
67256
        {
67355
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
67257
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
67356
          for (Item _iter199 : this.success)
67258
          for (Item _iter207 : this.success)
67357
          {
67259
          {
67358
            _iter199.write(oprot);
67260
            _iter207.write(oprot);
67359
          }
67261
          }
67360
          oprot.writeListEnd();
67262
          oprot.writeListEnd();
67361
        }
67263
        }
67362
        oprot.writeFieldEnd();
67264
        oprot.writeFieldEnd();
67363
      }
67265
      }
Line 69273... Line 69175...
69273
        }
69175
        }
69274
        switch (field.id) {
69176
        switch (field.id) {
69275
          case 0: // SUCCESS
69177
          case 0: // SUCCESS
69276
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
69178
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
69277
              {
69179
              {
69278
                org.apache.thrift.protocol.TList _list200 = iprot.readListBegin();
69180
                org.apache.thrift.protocol.TList _list208 = iprot.readListBegin();
69279
                this.success = new ArrayList<Insurer>(_list200.size);
69181
                this.success = new ArrayList<Insurer>(_list208.size);
69280
                for (int _i201 = 0; _i201 < _list200.size; ++_i201)
69182
                for (int _i209 = 0; _i209 < _list208.size; ++_i209)
69281
                {
69183
                {
69282
                  Insurer _elem202; // required
69184
                  Insurer _elem210; // required
69283
                  _elem202 = new Insurer();
69185
                  _elem210 = new Insurer();
69284
                  _elem202.read(iprot);
69186
                  _elem210.read(iprot);
69285
                  this.success.add(_elem202);
69187
                  this.success.add(_elem210);
69286
                }
69188
                }
69287
                iprot.readListEnd();
69189
                iprot.readListEnd();
69288
              }
69190
              }
69289
            } else { 
69191
            } else { 
69290
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
69192
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 69304... Line 69206...
69304
 
69206
 
69305
      if (this.isSetSuccess()) {
69207
      if (this.isSetSuccess()) {
69306
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
69208
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
69307
        {
69209
        {
69308
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
69210
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
69309
          for (Insurer _iter203 : this.success)
69211
          for (Insurer _iter211 : this.success)
69310
          {
69212
          {
69311
            _iter203.write(oprot);
69213
            _iter211.write(oprot);
69312
          }
69214
          }
69313
          oprot.writeListEnd();
69215
          oprot.writeListEnd();
69314
        }
69216
        }
69315
        oprot.writeFieldEnd();
69217
        oprot.writeFieldEnd();
69316
      }
69218
      }
Line 71960... Line 71862...
71960
        }
71862
        }
71961
        switch (field.id) {
71863
        switch (field.id) {
71962
          case 0: // SUCCESS
71864
          case 0: // SUCCESS
71963
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
71865
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
71964
              {
71866
              {
71965
                org.apache.thrift.protocol.TMap _map204 = iprot.readMapBegin();
71867
                org.apache.thrift.protocol.TMap _map212 = iprot.readMapBegin();
71966
                this.success = new HashMap<String,BrandInfo>(2*_map204.size);
71868
                this.success = new HashMap<String,BrandInfo>(2*_map212.size);
71967
                for (int _i205 = 0; _i205 < _map204.size; ++_i205)
71869
                for (int _i213 = 0; _i213 < _map212.size; ++_i213)
71968
                {
71870
                {
71969
                  String _key206; // required
71871
                  String _key214; // required
71970
                  BrandInfo _val207; // required
71872
                  BrandInfo _val215; // required
71971
                  _key206 = iprot.readString();
71873
                  _key214 = iprot.readString();
71972
                  _val207 = new BrandInfo();
71874
                  _val215 = new BrandInfo();
71973
                  _val207.read(iprot);
71875
                  _val215.read(iprot);
71974
                  this.success.put(_key206, _val207);
71876
                  this.success.put(_key214, _val215);
71975
                }
71877
                }
71976
                iprot.readMapEnd();
71878
                iprot.readMapEnd();
71977
              }
71879
              }
71978
            } else { 
71880
            } else { 
71979
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
71881
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 71993... Line 71895...
71993
 
71895
 
71994
      if (this.isSetSuccess()) {
71896
      if (this.isSetSuccess()) {
71995
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
71897
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
71996
        {
71898
        {
71997
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
71899
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
71998
          for (Map.Entry<String, BrandInfo> _iter208 : this.success.entrySet())
71900
          for (Map.Entry<String, BrandInfo> _iter216 : this.success.entrySet())
71999
          {
71901
          {
72000
            oprot.writeString(_iter208.getKey());
71902
            oprot.writeString(_iter216.getKey());
72001
            _iter208.getValue().write(oprot);
71903
            _iter216.getValue().write(oprot);
72002
          }
71904
          }
72003
          oprot.writeMapEnd();
71905
          oprot.writeMapEnd();
72004
        }
71906
        }
72005
        oprot.writeFieldEnd();
71907
        oprot.writeFieldEnd();
72006
      }
71908
      }
Line 72882... Line 72784...
72882
        }
72784
        }
72883
        switch (field.id) {
72785
        switch (field.id) {
72884
          case 1: // ITEM_IDS
72786
          case 1: // ITEM_IDS
72885
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
72787
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
72886
              {
72788
              {
72887
                org.apache.thrift.protocol.TList _list209 = iprot.readListBegin();
72789
                org.apache.thrift.protocol.TList _list217 = iprot.readListBegin();
72888
                this.itemIds = new ArrayList<Long>(_list209.size);
72790
                this.itemIds = new ArrayList<Long>(_list217.size);
72889
                for (int _i210 = 0; _i210 < _list209.size; ++_i210)
72791
                for (int _i218 = 0; _i218 < _list217.size; ++_i218)
72890
                {
72792
                {
72891
                  long _elem211; // required
72793
                  long _elem219; // required
72892
                  _elem211 = iprot.readI64();
72794
                  _elem219 = iprot.readI64();
72893
                  this.itemIds.add(_elem211);
72795
                  this.itemIds.add(_elem219);
72894
                }
72796
                }
72895
                iprot.readListEnd();
72797
                iprot.readListEnd();
72896
              }
72798
              }
72897
            } else { 
72799
            } else { 
72898
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
72800
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 72913... Line 72815...
72913
      oprot.writeStructBegin(STRUCT_DESC);
72815
      oprot.writeStructBegin(STRUCT_DESC);
72914
      if (this.itemIds != null) {
72816
      if (this.itemIds != null) {
72915
        oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
72817
        oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
72916
        {
72818
        {
72917
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.itemIds.size()));
72819
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.itemIds.size()));
72918
          for (long _iter212 : this.itemIds)
72820
          for (long _iter220 : this.itemIds)
72919
          {
72821
          {
72920
            oprot.writeI64(_iter212);
72822
            oprot.writeI64(_iter220);
72921
          }
72823
          }
72922
          oprot.writeListEnd();
72824
          oprot.writeListEnd();
72923
        }
72825
        }
72924
        oprot.writeFieldEnd();
72826
        oprot.writeFieldEnd();
72925
      }
72827
      }
Line 73213... Line 73115...
73213
        }
73115
        }
73214
        switch (field.id) {
73116
        switch (field.id) {
73215
          case 0: // SUCCESS
73117
          case 0: // SUCCESS
73216
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
73118
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
73217
              {
73119
              {
73218
                org.apache.thrift.protocol.TList _list213 = iprot.readListBegin();
73120
                org.apache.thrift.protocol.TList _list221 = iprot.readListBegin();
73219
                this.success = new ArrayList<StorePricing>(_list213.size);
73121
                this.success = new ArrayList<StorePricing>(_list221.size);
73220
                for (int _i214 = 0; _i214 < _list213.size; ++_i214)
73122
                for (int _i222 = 0; _i222 < _list221.size; ++_i222)
73221
                {
73123
                {
73222
                  StorePricing _elem215; // required
73124
                  StorePricing _elem223; // required
73223
                  _elem215 = new StorePricing();
73125
                  _elem223 = new StorePricing();
73224
                  _elem215.read(iprot);
73126
                  _elem223.read(iprot);
73225
                  this.success.add(_elem215);
73127
                  this.success.add(_elem223);
73226
                }
73128
                }
73227
                iprot.readListEnd();
73129
                iprot.readListEnd();
73228
              }
73130
              }
73229
            } else { 
73131
            } else { 
73230
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
73132
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 73244... Line 73146...
73244
 
73146
 
73245
      if (this.isSetSuccess()) {
73147
      if (this.isSetSuccess()) {
73246
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
73148
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
73247
        {
73149
        {
73248
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
73150
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
73249
          for (StorePricing _iter216 : this.success)
73151
          for (StorePricing _iter224 : this.success)
73250
          {
73152
          {
73251
            _iter216.write(oprot);
73153
            _iter224.write(oprot);
73252
          }
73154
          }
73253
          oprot.writeListEnd();
73155
          oprot.writeListEnd();
73254
        }
73156
        }
73255
        oprot.writeFieldEnd();
73157
        oprot.writeFieldEnd();
73256
      }
73158
      }
Line 74326... Line 74228...
74326
        }
74228
        }
74327
        switch (field.id) {
74229
        switch (field.id) {
74328
          case 0: // SUCCESS
74230
          case 0: // SUCCESS
74329
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
74231
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
74330
              {
74232
              {
74331
                org.apache.thrift.protocol.TList _list217 = iprot.readListBegin();
74233
                org.apache.thrift.protocol.TList _list225 = iprot.readListBegin();
74332
                this.success = new ArrayList<Amazonlisted>(_list217.size);
74234
                this.success = new ArrayList<Amazonlisted>(_list225.size);
74333
                for (int _i218 = 0; _i218 < _list217.size; ++_i218)
74235
                for (int _i226 = 0; _i226 < _list225.size; ++_i226)
74334
                {
74236
                {
74335
                  Amazonlisted _elem219; // required
74237
                  Amazonlisted _elem227; // required
74336
                  _elem219 = new Amazonlisted();
74238
                  _elem227 = new Amazonlisted();
74337
                  _elem219.read(iprot);
74239
                  _elem227.read(iprot);
74338
                  this.success.add(_elem219);
74240
                  this.success.add(_elem227);
74339
                }
74241
                }
74340
                iprot.readListEnd();
74242
                iprot.readListEnd();
74341
              }
74243
              }
74342
            } else { 
74244
            } else { 
74343
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
74245
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 74357... Line 74259...
74357
 
74259
 
74358
      if (this.isSetSuccess()) {
74260
      if (this.isSetSuccess()) {
74359
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
74261
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
74360
        {
74262
        {
74361
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
74263
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
74362
          for (Amazonlisted _iter220 : this.success)
74264
          for (Amazonlisted _iter228 : this.success)
74363
          {
74265
          {
74364
            _iter220.write(oprot);
74266
            _iter228.write(oprot);
74365
          }
74267
          }
74366
          oprot.writeListEnd();
74268
          oprot.writeListEnd();
74367
        }
74269
        }
74368
        oprot.writeFieldEnd();
74270
        oprot.writeFieldEnd();
74369
      }
74271
      }
Line 76433... Line 76335...
76433
        }
76335
        }
76434
        switch (field.id) {
76336
        switch (field.id) {
76435
          case 0: // SUCCESS
76337
          case 0: // SUCCESS
76436
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
76338
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
76437
              {
76339
              {
76438
                org.apache.thrift.protocol.TList _list221 = iprot.readListBegin();
76340
                org.apache.thrift.protocol.TList _list229 = iprot.readListBegin();
76439
                this.success = new ArrayList<Item>(_list221.size);
76341
                this.success = new ArrayList<Item>(_list229.size);
76440
                for (int _i222 = 0; _i222 < _list221.size; ++_i222)
76342
                for (int _i230 = 0; _i230 < _list229.size; ++_i230)
76441
                {
76343
                {
76442
                  Item _elem223; // required
76344
                  Item _elem231; // required
76443
                  _elem223 = new Item();
76345
                  _elem231 = new Item();
76444
                  _elem223.read(iprot);
76346
                  _elem231.read(iprot);
76445
                  this.success.add(_elem223);
76347
                  this.success.add(_elem231);
76446
                }
76348
                }
76447
                iprot.readListEnd();
76349
                iprot.readListEnd();
76448
              }
76350
              }
76449
            } else { 
76351
            } else { 
76450
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
76352
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 76464... Line 76366...
76464
 
76366
 
76465
      if (this.isSetSuccess()) {
76367
      if (this.isSetSuccess()) {
76466
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
76368
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
76467
        {
76369
        {
76468
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
76370
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
76469
          for (Item _iter224 : this.success)
76371
          for (Item _iter232 : this.success)
76470
          {
76372
          {
76471
            _iter224.write(oprot);
76373
            _iter232.write(oprot);
76472
          }
76374
          }
76473
          oprot.writeListEnd();
76375
          oprot.writeListEnd();
76474
        }
76376
        }
76475
        oprot.writeFieldEnd();
76377
        oprot.writeFieldEnd();
76476
      }
76378
      }
Line 76964... Line 76866...
76964
        }
76866
        }
76965
        switch (field.id) {
76867
        switch (field.id) {
76966
          case 0: // SUCCESS
76868
          case 0: // SUCCESS
76967
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
76869
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
76968
              {
76870
              {
76969
                org.apache.thrift.protocol.TList _list225 = iprot.readListBegin();
76871
                org.apache.thrift.protocol.TList _list233 = iprot.readListBegin();
76970
                this.success = new ArrayList<Amazonlisted>(_list225.size);
76872
                this.success = new ArrayList<Amazonlisted>(_list233.size);
76971
                for (int _i226 = 0; _i226 < _list225.size; ++_i226)
76873
                for (int _i234 = 0; _i234 < _list233.size; ++_i234)
76972
                {
76874
                {
76973
                  Amazonlisted _elem227; // required
76875
                  Amazonlisted _elem235; // required
76974
                  _elem227 = new Amazonlisted();
76876
                  _elem235 = new Amazonlisted();
76975
                  _elem227.read(iprot);
76877
                  _elem235.read(iprot);
76976
                  this.success.add(_elem227);
76878
                  this.success.add(_elem235);
76977
                }
76879
                }
76978
                iprot.readListEnd();
76880
                iprot.readListEnd();
76979
              }
76881
              }
76980
            } else { 
76882
            } else { 
76981
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
76883
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 76995... Line 76897...
76995
 
76897
 
76996
      if (this.isSetSuccess()) {
76898
      if (this.isSetSuccess()) {
76997
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
76899
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
76998
        {
76900
        {
76999
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
76901
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
77000
          for (Amazonlisted _iter228 : this.success)
76902
          for (Amazonlisted _iter236 : this.success)
77001
          {
76903
          {
77002
            _iter228.write(oprot);
76904
            _iter236.write(oprot);
77003
          }
76905
          }
77004
          oprot.writeListEnd();
76906
          oprot.writeListEnd();
77005
        }
76907
        }
77006
        oprot.writeFieldEnd();
76908
        oprot.writeFieldEnd();
77007
      }
76909
      }
Line 77495... Line 77397...
77495
        }
77397
        }
77496
        switch (field.id) {
77398
        switch (field.id) {
77497
          case 0: // SUCCESS
77399
          case 0: // SUCCESS
77498
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
77400
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
77499
              {
77401
              {
77500
                org.apache.thrift.protocol.TList _list229 = iprot.readListBegin();
77402
                org.apache.thrift.protocol.TList _list237 = iprot.readListBegin();
77501
                this.success = new ArrayList<Amazonlisted>(_list229.size);
77403
                this.success = new ArrayList<Amazonlisted>(_list237.size);
77502
                for (int _i230 = 0; _i230 < _list229.size; ++_i230)
77404
                for (int _i238 = 0; _i238 < _list237.size; ++_i238)
77503
                {
77405
                {
77504
                  Amazonlisted _elem231; // required
77406
                  Amazonlisted _elem239; // required
77505
                  _elem231 = new Amazonlisted();
77407
                  _elem239 = new Amazonlisted();
77506
                  _elem231.read(iprot);
77408
                  _elem239.read(iprot);
77507
                  this.success.add(_elem231);
77409
                  this.success.add(_elem239);
77508
                }
77410
                }
77509
                iprot.readListEnd();
77411
                iprot.readListEnd();
77510
              }
77412
              }
77511
            } else { 
77413
            } else { 
77512
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
77414
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 77526... Line 77428...
77526
 
77428
 
77527
      if (this.isSetSuccess()) {
77429
      if (this.isSetSuccess()) {
77528
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
77430
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
77529
        {
77431
        {
77530
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
77432
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
77531
          for (Amazonlisted _iter232 : this.success)
77433
          for (Amazonlisted _iter240 : this.success)
77532
          {
77434
          {
77533
            _iter232.write(oprot);
77435
            _iter240.write(oprot);
77534
          }
77436
          }
77535
          oprot.writeListEnd();
77437
          oprot.writeListEnd();
77536
        }
77438
        }
77537
        oprot.writeFieldEnd();
77439
        oprot.writeFieldEnd();
77538
      }
77440
      }
Line 78725... Line 78627...
78725
            }
78627
            }
78726
            break;
78628
            break;
78727
          case 2: // SKU
78629
          case 2: // SKU
78728
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
78630
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
78729
              {
78631
              {
78730
                org.apache.thrift.protocol.TList _list233 = iprot.readListBegin();
78632
                org.apache.thrift.protocol.TList _list241 = iprot.readListBegin();
78731
                this.sku = new ArrayList<Long>(_list233.size);
78633
                this.sku = new ArrayList<Long>(_list241.size);
78732
                for (int _i234 = 0; _i234 < _list233.size; ++_i234)
78634
                for (int _i242 = 0; _i242 < _list241.size; ++_i242)
78733
                {
78635
                {
78734
                  long _elem235; // required
78636
                  long _elem243; // required
78735
                  _elem235 = iprot.readI64();
78637
                  _elem243 = iprot.readI64();
78736
                  this.sku.add(_elem235);
78638
                  this.sku.add(_elem243);
78737
                }
78639
                }
78738
                iprot.readListEnd();
78640
                iprot.readListEnd();
78739
              }
78641
              }
78740
            } else { 
78642
            } else { 
78741
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
78643
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 78769... Line 78671...
78769
      }
78671
      }
78770
      if (this.sku != null) {
78672
      if (this.sku != null) {
78771
        oprot.writeFieldBegin(SKU_FIELD_DESC);
78673
        oprot.writeFieldBegin(SKU_FIELD_DESC);
78772
        {
78674
        {
78773
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.sku.size()));
78675
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.sku.size()));
78774
          for (long _iter236 : this.sku)
78676
          for (long _iter244 : this.sku)
78775
          {
78677
          {
78776
            oprot.writeI64(_iter236);
78678
            oprot.writeI64(_iter244);
78777
          }
78679
          }
78778
          oprot.writeListEnd();
78680
          oprot.writeListEnd();
78779
        }
78681
        }
78780
        oprot.writeFieldEnd();
78682
        oprot.writeFieldEnd();
78781
      }
78683
      }
Line 79579... Line 79481...
79579
        }
79481
        }
79580
        switch (field.id) {
79482
        switch (field.id) {
79581
          case 0: // SUCCESS
79483
          case 0: // SUCCESS
79582
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
79484
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
79583
              {
79485
              {
79584
                org.apache.thrift.protocol.TList _list237 = iprot.readListBegin();
79486
                org.apache.thrift.protocol.TList _list245 = iprot.readListBegin();
79585
                this.success = new ArrayList<Category>(_list237.size);
79487
                this.success = new ArrayList<Category>(_list245.size);
79586
                for (int _i238 = 0; _i238 < _list237.size; ++_i238)
79488
                for (int _i246 = 0; _i246 < _list245.size; ++_i246)
79587
                {
79489
                {
79588
                  Category _elem239; // required
79490
                  Category _elem247; // required
79589
                  _elem239 = new Category();
79491
                  _elem247 = new Category();
79590
                  _elem239.read(iprot);
79492
                  _elem247.read(iprot);
79591
                  this.success.add(_elem239);
79493
                  this.success.add(_elem247);
79592
                }
79494
                }
79593
                iprot.readListEnd();
79495
                iprot.readListEnd();
79594
              }
79496
              }
79595
            } else { 
79497
            } else { 
79596
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
79498
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 79610... Line 79512...
79610
 
79512
 
79611
      if (this.isSetSuccess()) {
79513
      if (this.isSetSuccess()) {
79612
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
79514
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
79613
        {
79515
        {
79614
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
79516
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
79615
          for (Category _iter240 : this.success)
79517
          for (Category _iter248 : this.success)
79616
          {
79518
          {
79617
            _iter240.write(oprot);
79519
            _iter248.write(oprot);
79618
          }
79520
          }
79619
          oprot.writeListEnd();
79521
          oprot.writeListEnd();
79620
        }
79522
        }
79621
        oprot.writeFieldEnd();
79523
        oprot.writeFieldEnd();
79622
      }
79524
      }
Line 82851... Line 82753...
82851
        }
82753
        }
82852
        switch (field.id) {
82754
        switch (field.id) {
82853
          case 0: // SUCCESS
82755
          case 0: // SUCCESS
82854
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
82756
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
82855
              {
82757
              {
82856
                org.apache.thrift.protocol.TList _list241 = iprot.readListBegin();
82758
                org.apache.thrift.protocol.TList _list249 = iprot.readListBegin();
82857
                this.success = new ArrayList<Amazonlisted>(_list241.size);
82759
                this.success = new ArrayList<Amazonlisted>(_list249.size);
82858
                for (int _i242 = 0; _i242 < _list241.size; ++_i242)
82760
                for (int _i250 = 0; _i250 < _list249.size; ++_i250)
82859
                {
82761
                {
82860
                  Amazonlisted _elem243; // required
82762
                  Amazonlisted _elem251; // required
82861
                  _elem243 = new Amazonlisted();
82763
                  _elem251 = new Amazonlisted();
82862
                  _elem243.read(iprot);
82764
                  _elem251.read(iprot);
82863
                  this.success.add(_elem243);
82765
                  this.success.add(_elem251);
82864
                }
82766
                }
82865
                iprot.readListEnd();
82767
                iprot.readListEnd();
82866
              }
82768
              }
82867
            } else { 
82769
            } else { 
82868
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
82770
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 82882... Line 82784...
82882
 
82784
 
82883
      if (this.isSetSuccess()) {
82785
      if (this.isSetSuccess()) {
82884
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
82786
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
82885
        {
82787
        {
82886
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
82788
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
82887
          for (Amazonlisted _iter244 : this.success)
82789
          for (Amazonlisted _iter252 : this.success)
82888
          {
82790
          {
82889
            _iter244.write(oprot);
82791
            _iter252.write(oprot);
82890
          }
82792
          }
82891
          oprot.writeListEnd();
82793
          oprot.writeListEnd();
82892
        }
82794
        }
82893
        oprot.writeFieldEnd();
82795
        oprot.writeFieldEnd();
82894
      }
82796
      }
Line 83187... Line 83089...
83187
        }
83089
        }
83188
        switch (field.id) {
83090
        switch (field.id) {
83189
          case 1: // AMAZONLISTED
83091
          case 1: // AMAZONLISTED
83190
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
83092
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
83191
              {
83093
              {
83192
                org.apache.thrift.protocol.TMap _map245 = iprot.readMapBegin();
83094
                org.apache.thrift.protocol.TMap _map253 = iprot.readMapBegin();
83193
                this.amazonlisted = new HashMap<Long,Amazonlisted>(2*_map245.size);
83095
                this.amazonlisted = new HashMap<Long,Amazonlisted>(2*_map253.size);
83194
                for (int _i246 = 0; _i246 < _map245.size; ++_i246)
83096
                for (int _i254 = 0; _i254 < _map253.size; ++_i254)
83195
                {
83097
                {
83196
                  long _key247; // required
83098
                  long _key255; // required
83197
                  Amazonlisted _val248; // required
83099
                  Amazonlisted _val256; // required
83198
                  _key247 = iprot.readI64();
83100
                  _key255 = iprot.readI64();
83199
                  _val248 = new Amazonlisted();
83101
                  _val256 = new Amazonlisted();
83200
                  _val248.read(iprot);
83102
                  _val256.read(iprot);
83201
                  this.amazonlisted.put(_key247, _val248);
83103
                  this.amazonlisted.put(_key255, _val256);
83202
                }
83104
                }
83203
                iprot.readMapEnd();
83105
                iprot.readMapEnd();
83204
              }
83106
              }
83205
            } else { 
83107
            } else { 
83206
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
83108
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 83221... Line 83123...
83221
      oprot.writeStructBegin(STRUCT_DESC);
83123
      oprot.writeStructBegin(STRUCT_DESC);
83222
      if (this.amazonlisted != null) {
83124
      if (this.amazonlisted != null) {
83223
        oprot.writeFieldBegin(AMAZONLISTED_FIELD_DESC);
83125
        oprot.writeFieldBegin(AMAZONLISTED_FIELD_DESC);
83224
        {
83126
        {
83225
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRUCT, this.amazonlisted.size()));
83127
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRUCT, this.amazonlisted.size()));
83226
          for (Map.Entry<Long, Amazonlisted> _iter249 : this.amazonlisted.entrySet())
83128
          for (Map.Entry<Long, Amazonlisted> _iter257 : this.amazonlisted.entrySet())
83227
          {
83129
          {
83228
            oprot.writeI64(_iter249.getKey());
83130
            oprot.writeI64(_iter257.getKey());
83229
            _iter249.getValue().write(oprot);
83131
            _iter257.getValue().write(oprot);
83230
          }
83132
          }
83231
          oprot.writeMapEnd();
83133
          oprot.writeMapEnd();
83232
        }
83134
        }
83233
        oprot.writeFieldEnd();
83135
        oprot.writeFieldEnd();
83234
      }
83136
      }
Line 84015... Line 83917...
84015
        }
83917
        }
84016
        switch (field.id) {
83918
        switch (field.id) {
84017
          case 0: // SUCCESS
83919
          case 0: // SUCCESS
84018
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
83920
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
84019
              {
83921
              {
84020
                org.apache.thrift.protocol.TList _list250 = iprot.readListBegin();
83922
                org.apache.thrift.protocol.TList _list258 = iprot.readListBegin();
84021
                this.success = new ArrayList<Amazonlisted>(_list250.size);
83923
                this.success = new ArrayList<Amazonlisted>(_list258.size);
84022
                for (int _i251 = 0; _i251 < _list250.size; ++_i251)
83924
                for (int _i259 = 0; _i259 < _list258.size; ++_i259)
84023
                {
83925
                {
84024
                  Amazonlisted _elem252; // required
83926
                  Amazonlisted _elem260; // required
84025
                  _elem252 = new Amazonlisted();
83927
                  _elem260 = new Amazonlisted();
84026
                  _elem252.read(iprot);
83928
                  _elem260.read(iprot);
84027
                  this.success.add(_elem252);
83929
                  this.success.add(_elem260);
84028
                }
83930
                }
84029
                iprot.readListEnd();
83931
                iprot.readListEnd();
84030
              }
83932
              }
84031
            } else { 
83933
            } else { 
84032
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
83934
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 84046... Line 83948...
84046
 
83948
 
84047
      if (this.isSetSuccess()) {
83949
      if (this.isSetSuccess()) {
84048
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
83950
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
84049
        {
83951
        {
84050
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
83952
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
84051
          for (Amazonlisted _iter253 : this.success)
83953
          for (Amazonlisted _iter261 : this.success)
84052
          {
83954
          {
84053
            _iter253.write(oprot);
83955
            _iter261.write(oprot);
84054
          }
83956
          }
84055
          oprot.writeListEnd();
83957
          oprot.writeListEnd();
84056
        }
83958
        }
84057
        oprot.writeFieldEnd();
83959
        oprot.writeFieldEnd();
84058
      }
83960
      }
Line 84546... Line 84448...
84546
        }
84448
        }
84547
        switch (field.id) {
84449
        switch (field.id) {
84548
          case 0: // SUCCESS
84450
          case 0: // SUCCESS
84549
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
84451
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
84550
              {
84452
              {
84551
                org.apache.thrift.protocol.TList _list254 = iprot.readListBegin();
84453
                org.apache.thrift.protocol.TList _list262 = iprot.readListBegin();
84552
                this.success = new ArrayList<Amazonlisted>(_list254.size);
84454
                this.success = new ArrayList<Amazonlisted>(_list262.size);
84553
                for (int _i255 = 0; _i255 < _list254.size; ++_i255)
84455
                for (int _i263 = 0; _i263 < _list262.size; ++_i263)
84554
                {
84456
                {
84555
                  Amazonlisted _elem256; // required
84457
                  Amazonlisted _elem264; // required
84556
                  _elem256 = new Amazonlisted();
84458
                  _elem264 = new Amazonlisted();
84557
                  _elem256.read(iprot);
84459
                  _elem264.read(iprot);
84558
                  this.success.add(_elem256);
84460
                  this.success.add(_elem264);
84559
                }
84461
                }
84560
                iprot.readListEnd();
84462
                iprot.readListEnd();
84561
              }
84463
              }
84562
            } else { 
84464
            } else { 
84563
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
84465
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 84577... Line 84479...
84577
 
84479
 
84578
      if (this.isSetSuccess()) {
84480
      if (this.isSetSuccess()) {
84579
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
84481
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
84580
        {
84482
        {
84581
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
84483
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
84582
          for (Amazonlisted _iter257 : this.success)
84484
          for (Amazonlisted _iter265 : this.success)
84583
          {
84485
          {
84584
            _iter257.write(oprot);
84486
            _iter265.write(oprot);
84585
          }
84487
          }
84586
          oprot.writeListEnd();
84488
          oprot.writeListEnd();
84587
        }
84489
        }
84588
        oprot.writeFieldEnd();
84490
        oprot.writeFieldEnd();
84589
      }
84491
      }