WebSVN – SmartDukaan – Diff – /trunk/ThriftConfig/src/main/java/in/shop2020/model/v1/catalog/CatalogService.java

     public List<Item> getAllItemsByStatus(status itemStatus) throws CatalogServiceException, org.apache.thrift.TException;
     public boolean markItemAsContentComplete(long entityId, long category, String brand, String modelName, String modelNumber, boolean isAndroid) throws CatalogServiceException, org.apache.thrift.TException;
+    public Map<Long,Double> getVatRates(long itemId, long categoryId) throws CatalogServiceException, org.apache.thrift.TException;
     /**
      * Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
+     *
      * @param offset
      * @param limit
     public List<AmazonPromotion> getAmazonPromotion(long startDate, long endDate) throws org.apache.thrift.TException;
     public boolean updateAmazonPromotion(List<AmazonPromotion> amazonPromotions) throws org.apache.thrift.TException;
+    public boolean markPartiallyActive(long itemId, long categoryId) throws org.apache.thrift.TException;
+    public boolean updateItemStateVat(long itemId, Map<Long,Double> statevat) throws org.apache.thrift.TException;
+  }
   public interface AsyncIface extends in.shop2020.generic.GenericService .AsyncIface {
     public void addItem(Item item, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.addItem_call> resultHandler) throws org.apache.thrift.TException;
     public void getAllItemsByStatus(status itemStatus, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getAllItemsByStatus_call> resultHandler) throws org.apache.thrift.TException;
     public void markItemAsContentComplete(long entityId, long category, String brand, String modelName, String modelNumber, boolean isAndroid, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.markItemAsContentComplete_call> resultHandler) throws org.apache.thrift.TException;
+    public void getVatRates(long itemId, long categoryId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getVatRates_call> resultHandler) throws org.apache.thrift.TException;
     public void getAllItemsInRange(long offset, long limit, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getAllItemsInRange_call> resultHandler) throws org.apache.thrift.TException;
     public void getAllItemsByStatusInRange(status itemStatus, long offset, long limit, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getAllItemsByStatusInRange_call> resultHandler) throws org.apache.thrift.TException;
     public void getItemCountByStatus(boolean useStatus, status itemStatus, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getItemCountByStatus_call> resultHandler) throws org.apache.thrift.TException;
     public void getAmazonPromotion(long startDate, long endDate, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getAmazonPromotion_call> resultHandler) throws org.apache.thrift.TException;
     public void updateAmazonPromotion(List<AmazonPromotion> amazonPromotions, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.updateAmazonPromotion_call> resultHandler) throws org.apache.thrift.TException;
+    public void markPartiallyActive(long itemId, long categoryId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.markPartiallyActive_call> resultHandler) throws org.apache.thrift.TException;
+    public void updateItemStateVat(long itemId, Map<Long,Double> statevat, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.updateItemStateVat_call> resultHandler) throws org.apache.thrift.TException;
+  }
   public static class Client extends in.shop2020.generic.GenericService.Client implements Iface {
     public static class Factory implements org.apache.thrift.TServiceClientFactory<Client> {
       public Factory() {}
         throw result.cex;
+      }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
+    }
+    public Map<Long,Double> getVatRates(long itemId, long categoryId) throws CatalogServiceException, org.apache.thrift.TException
+    {
+      send_getVatRates(itemId, categoryId);
+      return recv_getVatRates();
+    }
+    public void send_getVatRates(long itemId, long categoryId) throws org.apache.thrift.TException
+    {
+      getVatRates_args args = new getVatRates_args();
+      args.setItemId(itemId);
+      args.setCategoryId(categoryId);
+      sendBase("getVatRates", args);
+    }
+    public Map<Long,Double> recv_getVatRates() throws CatalogServiceException, org.apache.thrift.TException
+    {
+      getVatRates_result result = new getVatRates_result();
+      receiveBase(result, "getVatRates");
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      if (result.cex != null) {
+        throw result.cex;
+      }
+      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getVatRates failed: unknown result");
+    }
     public List<Item> getAllItemsInRange(long offset, long limit) throws CatalogServiceException, org.apache.thrift.TException
+    {
       send_getAllItemsInRange(offset, limit);
       return recv_getAllItemsInRange();
+    }
         return result.success;
+      }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "updateAmazonPromotion failed: unknown result");
+    }
+    public boolean markPartiallyActive(long itemId, long categoryId) throws org.apache.thrift.TException
+    {
+      send_markPartiallyActive(itemId, categoryId);
+      return recv_markPartiallyActive();
+    }
+    public void send_markPartiallyActive(long itemId, long categoryId) throws org.apache.thrift.TException
+    {
+      markPartiallyActive_args args = new markPartiallyActive_args();
+      args.setItemId(itemId);
+      args.setCategoryId(categoryId);
+      sendBase("markPartiallyActive", args);
+    }
+    public boolean recv_markPartiallyActive() throws org.apache.thrift.TException
+    {
+      markPartiallyActive_result result = new markPartiallyActive_result();
+      receiveBase(result, "markPartiallyActive");
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "markPartiallyActive failed: unknown result");
+    }
+    public boolean updateItemStateVat(long itemId, Map<Long,Double> statevat) throws org.apache.thrift.TException
+    {
+      send_updateItemStateVat(itemId, statevat);
+      return recv_updateItemStateVat();
+    }
+    public void send_updateItemStateVat(long itemId, Map<Long,Double> statevat) throws org.apache.thrift.TException
+    {
+      updateItemStateVat_args args = new updateItemStateVat_args();
+      args.setItemId(itemId);
+      args.setStatevat(statevat);
+      sendBase("updateItemStateVat", args);
+    }
+    public boolean recv_updateItemStateVat() throws org.apache.thrift.TException
+    {
+      updateItemStateVat_result result = new updateItemStateVat_result();
+      receiveBase(result, "updateItemStateVat");
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "updateItemStateVat failed: unknown result");
+    }
+  }
   public static class AsyncClient extends in.shop2020.generic.GenericService.AsyncClient implements AsyncIface {
     public static class Factory implements org.apache.thrift.async.TAsyncClientFactory<AsyncClient> {
       private org.apache.thrift.async.TAsyncClientManager clientManager;
       private org.apache.thrift.protocol.TProtocolFactory protocolFactory;
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         return (new Client(prot)).recv_markItemAsContentComplete();
+      }
+    }
+    public void getVatRates(long itemId, long categoryId, org.apache.thrift.async.AsyncMethodCallback<getVatRates_call> resultHandler) throws org.apache.thrift.TException {
+      checkReady();
+      getVatRates_call method_call = new getVatRates_call(itemId, categoryId, resultHandler, this, ___protocolFactory, ___transport);
+      this.___currentMethod = method_call;
+      ___manager.call(method_call);
+    }
+    public static class getVatRates_call extends org.apache.thrift.async.TAsyncMethodCall {
+      private long itemId;
+      private long categoryId;
+      public getVatRates_call(long itemId, long categoryId, org.apache.thrift.async.AsyncMethodCallback<getVatRates_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 {
+        super(client, protocolFactory, transport, resultHandler, false);
+        this.itemId = itemId;
+        this.categoryId = categoryId;
+      }
+      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getVatRates", org.apache.thrift.protocol.TMessageType.CALL, 0));
+        getVatRates_args args = new getVatRates_args();
+        args.setItemId(itemId);
+        args.setCategoryId(categoryId);
+        args.write(prot);
+        prot.writeMessageEnd();
+      }
+      public Map<Long,Double> getResult() throws CatalogServiceException, org.apache.thrift.TException {
+        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+          throw new IllegalStateException("Method call not finished!");
+        }
+        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+        return (new Client(prot)).recv_getVatRates();
+      }
+    }
     public void getAllItemsInRange(long offset, long limit, org.apache.thrift.async.AsyncMethodCallback<getAllItemsInRange_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       getAllItemsInRange_call method_call = new getAllItemsInRange_call(offset, limit, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         return (new Client(prot)).recv_updateAmazonPromotion();
+      }
+    }
+    public void markPartiallyActive(long itemId, long categoryId, org.apache.thrift.async.AsyncMethodCallback<markPartiallyActive_call> resultHandler) throws org.apache.thrift.TException {
+      checkReady();
+      markPartiallyActive_call method_call = new markPartiallyActive_call(itemId, categoryId, resultHandler, this, ___protocolFactory, ___transport);
+      this.___currentMethod = method_call;
+      ___manager.call(method_call);
+    }
+    public static class markPartiallyActive_call extends org.apache.thrift.async.TAsyncMethodCall {
+      private long itemId;
+      private long categoryId;
+      public markPartiallyActive_call(long itemId, long categoryId, org.apache.thrift.async.AsyncMethodCallback<markPartiallyActive_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 {
+        super(client, protocolFactory, transport, resultHandler, false);
+        this.itemId = itemId;
+        this.categoryId = categoryId;
+      }
+      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("markPartiallyActive", org.apache.thrift.protocol.TMessageType.CALL, 0));
+        markPartiallyActive_args args = new markPartiallyActive_args();
+        args.setItemId(itemId);
+        args.setCategoryId(categoryId);
+        args.write(prot);
+        prot.writeMessageEnd();
+      }
+      public boolean getResult() throws org.apache.thrift.TException {
+        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+          throw new IllegalStateException("Method call not finished!");
+        }
+        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+        return (new Client(prot)).recv_markPartiallyActive();
+      }
+    }
+    public void updateItemStateVat(long itemId, Map<Long,Double> statevat, org.apache.thrift.async.AsyncMethodCallback<updateItemStateVat_call> resultHandler) throws org.apache.thrift.TException {
+      checkReady();
+      updateItemStateVat_call method_call = new updateItemStateVat_call(itemId, statevat, resultHandler, this, ___protocolFactory, ___transport);
+      this.___currentMethod = method_call;
+      ___manager.call(method_call);
+    }
+    public static class updateItemStateVat_call extends org.apache.thrift.async.TAsyncMethodCall {
+      private long itemId;
+      private Map<Long,Double> statevat;
+      public updateItemStateVat_call(long itemId, Map<Long,Double> statevat, org.apache.thrift.async.AsyncMethodCallback<updateItemStateVat_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 {
+        super(client, protocolFactory, transport, resultHandler, false);
+        this.itemId = itemId;
+        this.statevat = statevat;
+      }
+      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("updateItemStateVat", org.apache.thrift.protocol.TMessageType.CALL, 0));
+        updateItemStateVat_args args = new updateItemStateVat_args();
+        args.setItemId(itemId);
+        args.setStatevat(statevat);
+        args.write(prot);
+        prot.writeMessageEnd();
+      }
+      public boolean getResult() throws org.apache.thrift.TException {
+        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+          throw new IllegalStateException("Method call not finished!");
+        }
+        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+        return (new Client(prot)).recv_updateItemStateVat();
+      }
+    }
+  }
   public static class Processor<I extends Iface> extends in.shop2020.generic.GenericService.Processor implements org.apache.thrift.TProcessor {
     private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
     public Processor(I iface) {
       processMap.put("getItemsByCatalogId", new getItemsByCatalogId());
       processMap.put("getValidItemsByCatalogId", new getValidItemsByCatalogId());
       processMap.put("getAllItems", new getAllItems());
       processMap.put("getAllItemsByStatus", new getAllItemsByStatus());
       processMap.put("markItemAsContentComplete", new markItemAsContentComplete());
+      processMap.put("getVatRates", new getVatRates());
       processMap.put("getAllItemsInRange", new getAllItemsInRange());
       processMap.put("getAllItemsByStatusInRange", new getAllItemsByStatusInRange());
       processMap.put("getItemCountByStatus", new getItemCountByStatus());
       processMap.put("getBestSellers", new getBestSellers());
       processMap.put("getBestSellersCatalogIds", new getBestSellersCatalogIds());
       processMap.put("getPreviousCompetitorScraping", new getPreviousCompetitorScraping());
       processMap.put("getUploadResultById", new getUploadResultById());
       processMap.put("addAmazonPromotion", new addAmazonPromotion());
       processMap.put("getAmazonPromotion", new getAmazonPromotion());
       processMap.put("updateAmazonPromotion", new updateAmazonPromotion());
+      processMap.put("markPartiallyActive", new markPartiallyActive());
+      processMap.put("updateItemStateVat", new updateItemStateVat());
       return processMap;
+    }
     private static class addItem<I extends Iface> extends org.apache.thrift.ProcessFunction<I, addItem_args> {
       public addItem() {
+        }
         return result;
+      }
+    }
+    private static class getVatRates<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getVatRates_args> {
+      public getVatRates() {
+        super("getVatRates");
+      }
+      protected getVatRates_args getEmptyArgsInstance() {
+        return new getVatRates_args();
+      }
+      protected getVatRates_result getResult(I iface, getVatRates_args args) throws org.apache.thrift.TException {
+        getVatRates_result result = new getVatRates_result();
+        try {
+          result.success = iface.getVatRates(args.itemId, args.categoryId);
+        } catch (CatalogServiceException cex) {
+          result.cex = cex;
+        }
+        return result;
+      }
+    }
     private static class getAllItemsInRange<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getAllItemsInRange_args> {
       public getAllItemsInRange() {
         super("getAllItemsInRange");
+      }
         result.setSuccessIsSet(true);
         return result;
+      }
+    }
+    private static class markPartiallyActive<I extends Iface> extends org.apache.thrift.ProcessFunction<I, markPartiallyActive_args> {
+      public markPartiallyActive() {
+        super("markPartiallyActive");
+      }
+      protected markPartiallyActive_args getEmptyArgsInstance() {
+        return new markPartiallyActive_args();
+      }
+      protected markPartiallyActive_result getResult(I iface, markPartiallyActive_args args) throws org.apache.thrift.TException {
+        markPartiallyActive_result result = new markPartiallyActive_result();
+        result.success = iface.markPartiallyActive(args.itemId, args.categoryId);
+        result.setSuccessIsSet(true);
+        return result;
+      }
+    }
+    private static class updateItemStateVat<I extends Iface> extends org.apache.thrift.ProcessFunction<I, updateItemStateVat_args> {
+      public updateItemStateVat() {
+        super("updateItemStateVat");
+      }
+      protected updateItemStateVat_args getEmptyArgsInstance() {
+        return new updateItemStateVat_args();
+      }
+      protected updateItemStateVat_result getResult(I iface, updateItemStateVat_args args) throws org.apache.thrift.TException {
+        updateItemStateVat_result result = new updateItemStateVat_result();
+        result.success = iface.updateItemStateVat(args.itemId, args.statevat);
+        result.setSuccessIsSet(true);
+        return result;
+      }
+    }
+  }
   public static class addItem_args implements org.apache.thrift.TBase<addItem_args, addItem_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("addItem_args");
+      }
+    }
+  }
+  public static class getVatRates_args implements org.apache.thrift.TBase<getVatRates_args, getVatRates_args._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getVatRates_args");
+    private static final org.apache.thrift.protocol.TField ITEM_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("itemId", org.apache.thrift.protocol.TType.I64, (short)1);
+    private static final org.apache.thrift.protocol.TField CATEGORY_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("categoryId", org.apache.thrift.protocol.TType.I64, (short)2);
+    private long itemId; // required
+    private long categoryId; // required
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+      ITEM_ID((short)1, "itemId"),
+      CATEGORY_ID((short)2, "categoryId");
+      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+      static {
+        for (_Fields field : EnumSet.allOf(_Fields.class)) {
+          byName.put(field.getFieldName(), field);
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, or null if its not found.
+       */
+      public static _Fields findByThriftId(int fieldId) {
+        switch(fieldId) {
+          case 1: // ITEM_ID
+            return ITEM_ID;
+          case 2: // CATEGORY_ID
+            return CATEGORY_ID;
+          default:
+            return null;
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, throwing an exception
+       * if it is not found.
+       */
+      public static _Fields findByThriftIdOrThrow(int fieldId) {
+        _Fields fields = findByThriftId(fieldId);
+        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+        return fields;
+      }
+      /**
+       * Find the _Fields constant that matches name, or null if its not found.
+       */
+      public static _Fields findByName(String name) {
+        return byName.get(name);
+      }
+      private final short _thriftId;
+      private final String _fieldName;
+      _Fields(short thriftId, String fieldName) {
+        _thriftId = thriftId;
+        _fieldName = fieldName;
+      }
+      public short getThriftFieldId() {
+        return _thriftId;
+      }
+      public String getFieldName() {
+        return _fieldName;
+      }
+    }
+    // isset id assignments
+    private static final int __ITEMID_ISSET_ID = 0;
+    private static final int __CATEGORYID_ISSET_ID = 1;
+    private BitSet __isset_bit_vector = new BitSet(2);
+    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+    static {
+      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+      tmpMap.put(_Fields.ITEM_ID, new org.apache.thrift.meta_data.FieldMetaData("itemId", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      tmpMap.put(_Fields.CATEGORY_ID, new org.apache.thrift.meta_data.FieldMetaData("categoryId", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getVatRates_args.class, metaDataMap);
+    }
+    public getVatRates_args() {
+    }
+    public getVatRates_args(
+      long itemId,
+      long categoryId)
+    {
+      this();
+      this.itemId = itemId;
+      setItemIdIsSet(true);
+      this.categoryId = categoryId;
+      setCategoryIdIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getVatRates_args(getVatRates_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.itemId = other.itemId;
+      this.categoryId = other.categoryId;
+    }
+    public getVatRates_args deepCopy() {
+      return new getVatRates_args(this);
+    }
+    @Override
+    public void clear() {
+      setItemIdIsSet(false);
+      this.itemId = 0;
+      setCategoryIdIsSet(false);
+      this.categoryId = 0;
+    }
+    public long getItemId() {
+      return this.itemId;
+    }
+    public void setItemId(long itemId) {
+      this.itemId = itemId;
+      setItemIdIsSet(true);
+    }
+    public void unsetItemId() {
+      __isset_bit_vector.clear(__ITEMID_ISSET_ID);
+    }
+    /** Returns true if field itemId is set (has been assigned a value) and false otherwise */
+    public boolean isSetItemId() {
+      return __isset_bit_vector.get(__ITEMID_ISSET_ID);
+    }
+    public void setItemIdIsSet(boolean value) {
+      __isset_bit_vector.set(__ITEMID_ISSET_ID, value);
+    }
+    public long getCategoryId() {
+      return this.categoryId;
+    }
+    public void setCategoryId(long categoryId) {
+      this.categoryId = categoryId;
+      setCategoryIdIsSet(true);
+    }
+    public void unsetCategoryId() {
+      __isset_bit_vector.clear(__CATEGORYID_ISSET_ID);
+    }
+    /** Returns true if field categoryId is set (has been assigned a value) and false otherwise */
+    public boolean isSetCategoryId() {
+      return __isset_bit_vector.get(__CATEGORYID_ISSET_ID);
+    }
+    public void setCategoryIdIsSet(boolean value) {
+      __isset_bit_vector.set(__CATEGORYID_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case ITEM_ID:
+        if (value == null) {
+          unsetItemId();
+        } else {
+          setItemId((Long)value);
+        }
+        break;
+      case CATEGORY_ID:
+        if (value == null) {
+          unsetCategoryId();
+        } else {
+          setCategoryId((Long)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case ITEM_ID:
+        return Long.valueOf(getItemId());
+      case CATEGORY_ID:
+        return Long.valueOf(getCategoryId());
+      }
+      throw new IllegalStateException();
+    }
+    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+    public boolean isSet(_Fields field) {
+      if (field == null) {
+        throw new IllegalArgumentException();
+      }
+      switch (field) {
+      case ITEM_ID:
+        return isSetItemId();
+      case CATEGORY_ID:
+        return isSetCategoryId();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof getVatRates_args)
+        return this.equals((getVatRates_args)that);
+      return false;
+    }
+    public boolean equals(getVatRates_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_itemId = true;
+      boolean that_present_itemId = true;
+      if (this_present_itemId || that_present_itemId) {
+        if (!(this_present_itemId && that_present_itemId))
+          return false;
+        if (this.itemId != that.itemId)
+          return false;
+      }
+      boolean this_present_categoryId = true;
+      boolean that_present_categoryId = true;
+      if (this_present_categoryId || that_present_categoryId) {
+        if (!(this_present_categoryId && that_present_categoryId))
+          return false;
+        if (this.categoryId != that.categoryId)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getVatRates_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getVatRates_args typedOther = (getVatRates_args)other;
+      lastComparison = Boolean.valueOf(isSetItemId()).compareTo(typedOther.isSetItemId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetItemId()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.itemId, typedOther.itemId);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetCategoryId()).compareTo(typedOther.isSetCategoryId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetCategoryId()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.categoryId, typedOther.categoryId);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      return 0;
+    }
+    public _Fields fieldForId(int fieldId) {
+      return _Fields.findByThriftId(fieldId);
+    }
+    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField field;
+      iprot.readStructBegin();
+      while (true)
+      {
+        field = iprot.readFieldBegin();
+        if (field.type == org.apache.thrift.protocol.TType.STOP) {
+          break;
+        }
+        switch (field.id) {
+          case 1: // ITEM_ID
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.itemId = iprot.readI64();
+              setItemIdIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 2: // CATEGORY_ID
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.categoryId = iprot.readI64();
+              setCategoryIdIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+      validate();
+      oprot.writeStructBegin(STRUCT_DESC);
+      oprot.writeFieldBegin(ITEM_ID_FIELD_DESC);
+      oprot.writeI64(this.itemId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(CATEGORY_ID_FIELD_DESC);
+      oprot.writeI64(this.categoryId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getVatRates_args(");
+      boolean first = true;
+      sb.append("itemId:");
+      sb.append(this.itemId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("categoryId:");
+      sb.append(this.categoryId);
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws org.apache.thrift.TException {
+      // check for required fields
+    }
+    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+      try {
+        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+      try {
+        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+        __isset_bit_vector = new BitSet(1);
+        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+  }
+  public static class getVatRates_result implements org.apache.thrift.TBase<getVatRates_result, getVatRates_result._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getVatRates_result");
+    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.MAP, (short)0);
+    private static final org.apache.thrift.protocol.TField CEX_FIELD_DESC = new org.apache.thrift.protocol.TField("cex", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+    private Map<Long,Double> success; // required
+    private CatalogServiceException cex; // required
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+      SUCCESS((short)0, "success"),
+      CEX((short)1, "cex");
+      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+      static {
+        for (_Fields field : EnumSet.allOf(_Fields.class)) {
+          byName.put(field.getFieldName(), field);
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, or null if its not found.
+       */
+      public static _Fields findByThriftId(int fieldId) {
+        switch(fieldId) {
+          case 0: // SUCCESS
+            return SUCCESS;
+          case 1: // CEX
+            return CEX;
+          default:
+            return null;
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, throwing an exception
+       * if it is not found.
+       */
+      public static _Fields findByThriftIdOrThrow(int fieldId) {
+        _Fields fields = findByThriftId(fieldId);
+        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+        return fields;
+      }
+      /**
+       * Find the _Fields constant that matches name, or null if its not found.
+       */
+      public static _Fields findByName(String name) {
+        return byName.get(name);
+      }
+      private final short _thriftId;
+      private final String _fieldName;
+      _Fields(short thriftId, String fieldName) {
+        _thriftId = thriftId;
+        _fieldName = fieldName;
+      }
+      public short getThriftFieldId() {
+        return _thriftId;
+      }
+      public String getFieldName() {
+        return _fieldName;
+      }
+    }
+    // isset id assignments
+    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+    static {
+      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+              new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64),
+              new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE))));
+      tmpMap.put(_Fields.CEX, new org.apache.thrift.meta_data.FieldMetaData("cex", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getVatRates_result.class, metaDataMap);
+    }
+    public getVatRates_result() {
+    }
+    public getVatRates_result(
+      Map<Long,Double> success,
+      CatalogServiceException cex)
+    {
+      this();
+      this.success = success;
+      this.cex = cex;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getVatRates_result(getVatRates_result other) {
+      if (other.isSetSuccess()) {
+        Map<Long,Double> __this__success = new HashMap<Long,Double>();
+        for (Map.Entry<Long, Double> other_element : other.success.entrySet()) {
+          Long other_element_key = other_element.getKey();
+          Double other_element_value = other_element.getValue();
+          Long __this__success_copy_key = other_element_key;
+          Double __this__success_copy_value = other_element_value;
+          __this__success.put(__this__success_copy_key, __this__success_copy_value);
+        }
+        this.success = __this__success;
+      }
+      if (other.isSetCex()) {
+        this.cex = new CatalogServiceException(other.cex);
+      }
+    }
+    public getVatRates_result deepCopy() {
+      return new getVatRates_result(this);
+    }
+    @Override
+    public void clear() {
+      this.success = null;
+      this.cex = null;
+    }
+    public int getSuccessSize() {
+      return (this.success == null) ? 0 : this.success.size();
+    }
+    public void putToSuccess(long key, double val) {
+      if (this.success == null) {
+        this.success = new HashMap<Long,Double>();
+      }
+      this.success.put(key, val);
+    }
+    public Map<Long,Double> getSuccess() {
+      return this.success;
+    }
+    public void setSuccess(Map<Long,Double> success) {
+      this.success = success;
+    }
+    public void unsetSuccess() {
+      this.success = null;
+    }
+    /** Returns true if field success is set (has been assigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return this.success != null;
+    }
+    public void setSuccessIsSet(boolean value) {
+      if (!value) {
+        this.success = null;
+      }
+    }
+    public CatalogServiceException getCex() {
+      return this.cex;
+    }
+    public void setCex(CatalogServiceException cex) {
+      this.cex = cex;
+    }
+    public void unsetCex() {
+      this.cex = null;
+    }
+    /** Returns true if field cex is set (has been assigned a value) and false otherwise */
+    public boolean isSetCex() {
+      return this.cex != null;
+    }
+    public void setCexIsSet(boolean value) {
+      if (!value) {
+        this.cex = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((Map<Long,Double>)value);
+        }
+        break;
+      case CEX:
+        if (value == null) {
+          unsetCex();
+        } else {
+          setCex((CatalogServiceException)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case SUCCESS:
+        return getSuccess();
+      case CEX:
+        return getCex();
+      }
+      throw new IllegalStateException();
+    }
+    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+    public boolean isSet(_Fields field) {
+      if (field == null) {
+        throw new IllegalArgumentException();
+      }
+      switch (field) {
+      case SUCCESS:
+        return isSetSuccess();
+      case CEX:
+        return isSetCex();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof getVatRates_result)
+        return this.equals((getVatRates_result)that);
+      return false;
+    }
+    public boolean equals(getVatRates_result that) {
+      if (that == null)
+        return false;
+      boolean this_present_success = true && this.isSetSuccess();
+      boolean that_present_success = true && that.isSetSuccess();
+      if (this_present_success || that_present_success) {
+        if (!(this_present_success && that_present_success))
+          return false;
+        if (!this.success.equals(that.success))
+          return false;
+      }
+      boolean this_present_cex = true && this.isSetCex();
+      boolean that_present_cex = true && that.isSetCex();
+      if (this_present_cex || that_present_cex) {
+        if (!(this_present_cex && that_present_cex))
+          return false;
+        if (!this.cex.equals(that.cex))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getVatRates_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getVatRates_result typedOther = (getVatRates_result)other;
+      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetSuccess()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetCex()).compareTo(typedOther.isSetCex());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetCex()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.cex, typedOther.cex);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      return 0;
+    }
+    public _Fields fieldForId(int fieldId) {
+      return _Fields.findByThriftId(fieldId);
+    }
+    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField field;
+      iprot.readStructBegin();
+      while (true)
+      {
+        field = iprot.readFieldBegin();
+        if (field.type == org.apache.thrift.protocol.TType.STOP) {
+          break;
+        }
+        switch (field.id) {
+          case 0: // SUCCESS
+            if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
+                org.apache.thrift.protocol.TMap _map42 = iprot.readMapBegin();
+                this.success = new HashMap<Long,Double>(2*_map42.size);
+                for (int _i43 = 0; _i43 < _map42.size; ++_i43)
+                {
+                  long _key44; // required
+                  double _val45; // required
+                  _key44 = iprot.readI64();
+                  _val45 = iprot.readDouble();
+                  this.success.put(_key44, _val45);
+                }
+                iprot.readMapEnd();
+              }
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 1: // CEX
+            if (field.type == org.apache.thrift.protocol.TType.STRUCT) {
+              this.cex = new CatalogServiceException();
+              this.cex.read(iprot);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
+          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.DOUBLE, this.success.size()));
+          for (Map.Entry<Long, Double> _iter46 : this.success.entrySet())
+          {
+            oprot.writeI64(_iter46.getKey());
+            oprot.writeDouble(_iter46.getValue());
+          }
+          oprot.writeMapEnd();
+        }
+        oprot.writeFieldEnd();
+      } else if (this.isSetCex()) {
+        oprot.writeFieldBegin(CEX_FIELD_DESC);
+        this.cex.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getVatRates_result(");
+      boolean first = true;
+      sb.append("success:");
+      if (this.success == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.success);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("cex:");
+      if (this.cex == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.cex);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws org.apache.thrift.TException {
+      // check for required fields
+    }
+    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+      try {
+        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+      try {
+        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+  }
   public static class getAllItemsInRange_args implements org.apache.thrift.TBase<getAllItemsInRange_args, getAllItemsInRange_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getAllItemsInRange_args");
     private static final org.apache.thrift.protocol.TField OFFSET_FIELD_DESC = new org.apache.thrift.protocol.TField("offset", org.apache.thrift.protocol.TType.I64, (short)1);
     private static final org.apache.thrift.protocol.TField LIMIT_FIELD_DESC = new org.apache.thrift.protocol.TField("limit", org.apache.thrift.protocol.TType.I64, (short)2);
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list42 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list47 = iprot.readListBegin();
-                this.success = new ArrayList<Item>(_list42.size);
+                this.success = new ArrayList<Item>(_list47.size);
-                for (int _i43 = 0; _i43 < _list42.size; ++_i43)
+                for (int _i48 = 0; _i48 < _list47.size; ++_i48)
+                {
-                  Item _elem44; // required
+                  Item _elem49; // required
-                  _elem44 = new Item();
+                  _elem49 = new Item();
-                  _elem44.read(iprot);
+                  _elem49.read(iprot);
-                  this.success.add(_elem44);
+                  this.success.add(_elem49);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Item _iter45 : this.success)
+          for (Item _iter50 : this.success)
+          {
-            _iter45.write(oprot);
+            _iter50.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetCex()) {
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list46 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list51 = iprot.readListBegin();
-                this.success = new ArrayList<Item>(_list46.size);
+                this.success = new ArrayList<Item>(_list51.size);
-                for (int _i47 = 0; _i47 < _list46.size; ++_i47)
+                for (int _i52 = 0; _i52 < _list51.size; ++_i52)
+                {
-                  Item _elem48; // required
+                  Item _elem53; // required
-                  _elem48 = new Item();
+                  _elem53 = new Item();
-                  _elem48.read(iprot);
+                  _elem53.read(iprot);
-                  this.success.add(_elem48);
+                  this.success.add(_elem53);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Item _iter49 : this.success)
+          for (Item _iter54 : this.success)
+          {
-            _iter49.write(oprot);
+            _iter54.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetCex()) {
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list50 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list55 = iprot.readListBegin();
-                this.success = new ArrayList<Item>(_list50.size);
+                this.success = new ArrayList<Item>(_list55.size);
-                for (int _i51 = 0; _i51 < _list50.size; ++_i51)
+                for (int _i56 = 0; _i56 < _list55.size; ++_i56)
+                {
-                  Item _elem52; // required
+                  Item _elem57; // required
-                  _elem52 = new Item();
+                  _elem57 = new Item();
-                  _elem52.read(iprot);
+                  _elem57.read(iprot);
-                  this.success.add(_elem52);
+                  this.success.add(_elem57);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Item _iter53 : this.success)
+          for (Item _iter58 : this.success)
+          {
-            _iter53.write(oprot);
+            _iter58.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetIsex()) {
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list54 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list59 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list54.size);
+                this.success = new ArrayList<Long>(_list59.size);
-                for (int _i55 = 0; _i55 < _list54.size; ++_i55)
+                for (int _i60 = 0; _i60 < _list59.size; ++_i60)
+                {
-                  long _elem56; // required
+                  long _elem61; // required
-                  _elem56 = iprot.readI64();
+                  _elem61 = iprot.readI64();
-                  this.success.add(_elem56);
+                  this.success.add(_elem61);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
-          for (long _iter57 : this.success)
+          for (long _iter62 : this.success)
+          {
-            oprot.writeI64(_iter57);
+            oprot.writeI64(_iter62);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetCex()) {
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list58 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list63 = iprot.readListBegin();
-                this.success = new ArrayList<Item>(_list58.size);
+                this.success = new ArrayList<Item>(_list63.size);
-                for (int _i59 = 0; _i59 < _list58.size; ++_i59)
+                for (int _i64 = 0; _i64 < _list63.size; ++_i64)
+                {
-                  Item _elem60; // required
+                  Item _elem65; // required
-                  _elem60 = new Item();
+                  _elem65 = new Item();
-                  _elem60.read(iprot);
+                  _elem65.read(iprot);
-                  this.success.add(_elem60);
+                  this.success.add(_elem65);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Item _iter61 : this.success)
+          for (Item _iter66 : this.success)
+          {
-            _iter61.write(oprot);
+            _iter66.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetIsex()) {
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list62 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list67 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list62.size);
+                this.success = new ArrayList<Long>(_list67.size);
-                for (int _i63 = 0; _i63 < _list62.size; ++_i63)
+                for (int _i68 = 0; _i68 < _list67.size; ++_i68)
+                {
-                  long _elem64; // required
+                  long _elem69; // required
-                  _elem64 = iprot.readI64();
+                  _elem69 = iprot.readI64();
-                  this.success.add(_elem64);
+                  this.success.add(_elem69);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
-          for (long _iter65 : this.success)
+          for (long _iter70 : this.success)
+          {
-            oprot.writeI64(_iter65);
+            oprot.writeI64(_iter70);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetCex()) {
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list66 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list71 = iprot.readListBegin();
-                this.success = new ArrayList<Item>(_list66.size);
+                this.success = new ArrayList<Item>(_list71.size);
-                for (int _i67 = 0; _i67 < _list66.size; ++_i67)
+                for (int _i72 = 0; _i72 < _list71.size; ++_i72)
+                {
-                  Item _elem68; // required
+                  Item _elem73; // required
-                  _elem68 = new Item();
+                  _elem73 = new Item();
-                  _elem68.read(iprot);
+                  _elem73.read(iprot);
-                  this.success.add(_elem68);
+                  this.success.add(_elem73);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Item _iter69 : this.success)
+          for (Item _iter74 : this.success)
+          {
-            _iter69.write(oprot);
+            _iter74.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetIsex()) {
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list70 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list75 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list70.size);
+                this.success = new ArrayList<Long>(_list75.size);
-                for (int _i71 = 0; _i71 < _list70.size; ++_i71)
+                for (int _i76 = 0; _i76 < _list75.size; ++_i76)
+                {
-                  long _elem72; // required
+                  long _elem77; // required
-                  _elem72 = iprot.readI64();
+                  _elem77 = iprot.readI64();
-                  this.success.add(_elem72);
+                  this.success.add(_elem77);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
-          for (long _iter73 : this.success)
+          for (long _iter78 : this.success)
+          {
-            oprot.writeI64(_iter73);
+            oprot.writeI64(_iter78);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetCex()) {
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list74 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list79 = iprot.readListBegin();
-                this.success = new ArrayList<Item>(_list74.size);
+                this.success = new ArrayList<Item>(_list79.size);
-                for (int _i75 = 0; _i75 < _list74.size; ++_i75)
+                for (int _i80 = 0; _i80 < _list79.size; ++_i80)
+                {
-                  Item _elem76; // required
+                  Item _elem81; // required
-                  _elem76 = new Item();
+                  _elem81 = new Item();
-                  _elem76.read(iprot);
+                  _elem81.read(iprot);
-                  this.success.add(_elem76);
+                  this.success.add(_elem81);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Item _iter77 : this.success)
+          for (Item _iter82 : this.success)
+          {
-            _iter77.write(oprot);
+            _iter82.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetIsex()) {
+            }
             break;
           case 4: // CATEGORIES
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list78 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list83 = iprot.readListBegin();
-                this.categories = new ArrayList<Long>(_list78.size);
+                this.categories = new ArrayList<Long>(_list83.size);
-                for (int _i79 = 0; _i79 < _list78.size; ++_i79)
+                for (int _i84 = 0; _i84 < _list83.size; ++_i84)
+                {
-                  long _elem80; // required
+                  long _elem85; // required
-                  _elem80 = iprot.readI64();
+                  _elem85 = iprot.readI64();
-                  this.categories.add(_elem80);
+                  this.categories.add(_elem85);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+      }
       if (this.categories != null) {
         oprot.writeFieldBegin(CATEGORIES_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.categories.size()));
-          for (long _iter81 : this.categories)
+          for (long _iter86 : this.categories)
+          {
-            oprot.writeI64(_iter81);
+            oprot.writeI64(_iter86);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list82 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list87 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list82.size);
+                this.success = new ArrayList<Long>(_list87.size);
-                for (int _i83 = 0; _i83 < _list82.size; ++_i83)
+                for (int _i88 = 0; _i88 < _list87.size; ++_i88)
+                {
-                  long _elem84; // required
+                  long _elem89; // required
-                  _elem84 = iprot.readI64();
+                  _elem89 = iprot.readI64();
-                  this.success.add(_elem84);
+                  this.success.add(_elem89);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
-          for (long _iter85 : this.success)
+          for (long _iter90 : this.success)
+          {
-            oprot.writeI64(_iter85);
+            oprot.writeI64(_iter90);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetCex()) {
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list86 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list91 = iprot.readListBegin();
-                this.success = new ArrayList<Category>(_list86.size);
+                this.success = new ArrayList<Category>(_list91.size);
-                for (int _i87 = 0; _i87 < _list86.size; ++_i87)
+                for (int _i92 = 0; _i92 < _list91.size; ++_i92)
+                {
-                  Category _elem88; // required
+                  Category _elem93; // required
-                  _elem88 = new Category();
+                  _elem93 = new Category();
-                  _elem88.read(iprot);
+                  _elem93.read(iprot);
-                  this.success.add(_elem88);
+                  this.success.add(_elem93);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Category _iter89 : this.success)
+          for (Category _iter94 : this.success)
+          {
-            _iter89.write(oprot);
+            _iter94.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list90 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list95 = iprot.readListBegin();
-                this.success = new ArrayList<Item>(_list90.size);
+                this.success = new ArrayList<Item>(_list95.size);
-                for (int _i91 = 0; _i91 < _list90.size; ++_i91)
+                for (int _i96 = 0; _i96 < _list95.size; ++_i96)
+                {
-                  Item _elem92; // required
+                  Item _elem97; // required
-                  _elem92 = new Item();
+                  _elem97 = new Item();
-                  _elem92.read(iprot);
+                  _elem97.read(iprot);
-                  this.success.add(_elem92);
+                  this.success.add(_elem97);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Item _iter93 : this.success)
+          for (Item _iter98 : this.success)
+          {
-            _iter93.write(oprot);
+            _iter98.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list94 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list99 = iprot.readListBegin();
-                this.success = new ArrayList<String>(_list94.size);
+                this.success = new ArrayList<String>(_list99.size);
-                for (int _i95 = 0; _i95 < _list94.size; ++_i95)
+                for (int _i100 = 0; _i100 < _list99.size; ++_i100)
+                {
-                  String _elem96; // required
+                  String _elem101; // required
-                  _elem96 = iprot.readString();
+                  _elem101 = iprot.readString();
-                  this.success.add(_elem96);
+                  this.success.add(_elem101);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
-          for (String _iter97 : this.success)
+          for (String _iter102 : this.success)
+          {
-            oprot.writeString(_iter97);
+            oprot.writeString(_iter102);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list98 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list103 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list98.size);
+                this.success = new ArrayList<Long>(_list103.size);
-                for (int _i99 = 0; _i99 < _list98.size; ++_i99)
+                for (int _i104 = 0; _i104 < _list103.size; ++_i104)
+                {
-                  long _elem100; // required
+                  long _elem105; // required
-                  _elem100 = iprot.readI64();
+                  _elem105 = iprot.readI64();
-                  this.success.add(_elem100);
+                  this.success.add(_elem105);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
-          for (long _iter101 : this.success)
+          for (long _iter106 : this.success)
+          {
-            oprot.writeI64(_iter101);
+            oprot.writeI64(_iter106);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map102 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map107 = iprot.readMapBegin();
-                this.success = new HashMap<Long,List<String>>(2*_map102.size);
+                this.success = new HashMap<Long,List<String>>(2*_map107.size);
-                for (int _i103 = 0; _i103 < _map102.size; ++_i103)
+                for (int _i108 = 0; _i108 < _map107.size; ++_i108)
+                {
-                  long _key104; // required
+                  long _key109; // required
-                  List<String> _val105; // required
+                  List<String> _val110; // required
-                  _key104 = iprot.readI64();
+                  _key109 = iprot.readI64();
+                  {
-                    org.apache.thrift.protocol.TList _list106 = iprot.readListBegin();
+                    org.apache.thrift.protocol.TList _list111 = iprot.readListBegin();
-                    _val105 = new ArrayList<String>(_list106.size);
+                    _val110 = new ArrayList<String>(_list111.size);
-                    for (int _i107 = 0; _i107 < _list106.size; ++_i107)
+                    for (int _i112 = 0; _i112 < _list111.size; ++_i112)
+                    {
-                      String _elem108; // required
+                      String _elem113; // required
-                      _elem108 = iprot.readString();
+                      _elem113 = iprot.readString();
-                      _val105.add(_elem108);
+                      _val110.add(_elem113);
+                    }
                     iprot.readListEnd();
+                  }
-                  this.success.put(_key104, _val105);
+                  this.success.put(_key109, _val110);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.LIST, this.success.size()));
-          for (Map.Entry<Long, List<String>> _iter109 : this.success.entrySet())
+          for (Map.Entry<Long, List<String>> _iter114 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter109.getKey());
+            oprot.writeI64(_iter114.getKey());
+            {
-              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter109.getValue().size()));
+              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter114.getValue().size()));
-              for (String _iter110 : _iter109.getValue())
+              for (String _iter115 : _iter114.getValue())
+              {
-                oprot.writeString(_iter110);
+                oprot.writeString(_iter115);
+              }
               oprot.writeListEnd();
+            }
+          }
           oprot.writeMapEnd();
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list111 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list116 = iprot.readListBegin();
-                this.success = new ArrayList<Banner>(_list111.size);
+                this.success = new ArrayList<Banner>(_list116.size);
-                for (int _i112 = 0; _i112 < _list111.size; ++_i112)
+                for (int _i117 = 0; _i117 < _list116.size; ++_i117)
+                {
-                  Banner _elem113; // required
+                  Banner _elem118; // required
-                  _elem113 = new Banner();
+                  _elem118 = new Banner();
-                  _elem113.read(iprot);
+                  _elem118.read(iprot);
-                  this.success.add(_elem113);
+                  this.success.add(_elem118);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Banner _iter114 : this.success)
+          for (Banner _iter119 : this.success)
+          {
-            _iter114.write(oprot);
+            _iter119.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map115 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map120 = iprot.readMapBegin();
-                this.success = new HashMap<String,List<Banner>>(2*_map115.size);
+                this.success = new HashMap<String,List<Banner>>(2*_map120.size);
-                for (int _i116 = 0; _i116 < _map115.size; ++_i116)
+                for (int _i121 = 0; _i121 < _map120.size; ++_i121)
+                {
-                  String _key117; // required
+                  String _key122; // required
-                  List<Banner> _val118; // required
+                  List<Banner> _val123; // required
-                  _key117 = iprot.readString();
+                  _key122 = iprot.readString();
+                  {
-                    org.apache.thrift.protocol.TList _list119 = iprot.readListBegin();
+                    org.apache.thrift.protocol.TList _list124 = iprot.readListBegin();
-                    _val118 = new ArrayList<Banner>(_list119.size);
+                    _val123 = new ArrayList<Banner>(_list124.size);
-                    for (int _i120 = 0; _i120 < _list119.size; ++_i120)
+                    for (int _i125 = 0; _i125 < _list124.size; ++_i125)
+                    {
-                      Banner _elem121; // required
+                      Banner _elem126; // required
-                      _elem121 = new Banner();
+                      _elem126 = new Banner();
-                      _elem121.read(iprot);
+                      _elem126.read(iprot);
-                      _val118.add(_elem121);
+                      _val123.add(_elem126);
+                    }
                     iprot.readListEnd();
+                  }
-                  this.success.put(_key117, _val118);
+                  this.success.put(_key122, _val123);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.LIST, this.success.size()));
-          for (Map.Entry<String, List<Banner>> _iter122 : this.success.entrySet())
+          for (Map.Entry<String, List<Banner>> _iter127 : this.success.entrySet())
+          {
-            oprot.writeString(_iter122.getKey());
+            oprot.writeString(_iter127.getKey());
+            {
-              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter122.getValue().size()));
+              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter127.getValue().size()));
-              for (Banner _iter123 : _iter122.getValue())
+              for (Banner _iter128 : _iter127.getValue())
+              {
-                _iter123.write(oprot);
+                _iter128.write(oprot);
+              }
               oprot.writeListEnd();
+            }
+          }
           oprot.writeMapEnd();
+        }
         switch (field.id) {
           case 1: // BANNER_MAPS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list124 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list129 = iprot.readListBegin();
-                this.bannerMaps = new ArrayList<BannerMap>(_list124.size);
+                this.bannerMaps = new ArrayList<BannerMap>(_list129.size);
-                for (int _i125 = 0; _i125 < _list124.size; ++_i125)
+                for (int _i130 = 0; _i130 < _list129.size; ++_i130)
+                {
-                  BannerMap _elem126; // required
+                  BannerMap _elem131; // required
-                  _elem126 = new BannerMap();
+                  _elem131 = new BannerMap();
-                  _elem126.read(iprot);
+                  _elem131.read(iprot);
-                  this.bannerMaps.add(_elem126);
+                  this.bannerMaps.add(_elem131);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.bannerMaps != null) {
         oprot.writeFieldBegin(BANNER_MAPS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.bannerMaps.size()));
-          for (BannerMap _iter127 : this.bannerMaps)
+          for (BannerMap _iter132 : this.bannerMaps)
+          {
-            _iter127.write(oprot);
+            _iter132.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list128 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list133 = iprot.readListBegin();
-                this.success = new ArrayList<BannerMap>(_list128.size);
+                this.success = new ArrayList<BannerMap>(_list133.size);
-                for (int _i129 = 0; _i129 < _list128.size; ++_i129)
+                for (int _i134 = 0; _i134 < _list133.size; ++_i134)
+                {
-                  BannerMap _elem130; // required
+                  BannerMap _elem135; // required
-                  _elem130 = new BannerMap();
+                  _elem135 = new BannerMap();
-                  _elem130.read(iprot);
+                  _elem135.read(iprot);
-                  this.success.add(_elem130);
+                  this.success.add(_elem135);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (BannerMap _iter131 : this.success)
+          for (BannerMap _iter136 : this.success)
+          {
-            _iter131.write(oprot);
+            _iter136.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // BANNER_URI_MAPPINGS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list132 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list137 = iprot.readListBegin();
-                this.bannerUriMappings = new ArrayList<BannerUriMapping>(_list132.size);
+                this.bannerUriMappings = new ArrayList<BannerUriMapping>(_list137.size);
-                for (int _i133 = 0; _i133 < _list132.size; ++_i133)
+                for (int _i138 = 0; _i138 < _list137.size; ++_i138)
+                {
-                  BannerUriMapping _elem134; // required
+                  BannerUriMapping _elem139; // required
-                  _elem134 = new BannerUriMapping();
+                  _elem139 = new BannerUriMapping();
-                  _elem134.read(iprot);
+                  _elem139.read(iprot);
-                  this.bannerUriMappings.add(_elem134);
+                  this.bannerUriMappings.add(_elem139);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.bannerUriMappings != null) {
         oprot.writeFieldBegin(BANNER_URI_MAPPINGS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.bannerUriMappings.size()));
-          for (BannerUriMapping _iter135 : this.bannerUriMappings)
+          for (BannerUriMapping _iter140 : this.bannerUriMappings)
+          {
-            _iter135.write(oprot);
+            _iter140.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list136 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list141 = iprot.readListBegin();
-                this.success = new ArrayList<BannerUriMapping>(_list136.size);
+                this.success = new ArrayList<BannerUriMapping>(_list141.size);
-                for (int _i137 = 0; _i137 < _list136.size; ++_i137)
+                for (int _i142 = 0; _i142 < _list141.size; ++_i142)
+                {
-                  BannerUriMapping _elem138; // required
+                  BannerUriMapping _elem143; // required
-                  _elem138 = new BannerUriMapping();
+                  _elem143 = new BannerUriMapping();
-                  _elem138.read(iprot);
+                  _elem143.read(iprot);
-                  this.success.add(_elem138);
+                  this.success.add(_elem143);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (BannerUriMapping _iter139 : this.success)
+          for (BannerUriMapping _iter144 : this.success)
+          {
-            _iter139.write(oprot);
+            _iter144.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list140 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list145 = iprot.readListBegin();
-                this.success = new ArrayList<Campaign>(_list140.size);
+                this.success = new ArrayList<Campaign>(_list145.size);
-                for (int _i141 = 0; _i141 < _list140.size; ++_i141)
+                for (int _i146 = 0; _i146 < _list145.size; ++_i146)
+                {
-                  Campaign _elem142; // required
+                  Campaign _elem147; // required
-                  _elem142 = new Campaign();
+                  _elem147 = new Campaign();
-                  _elem142.read(iprot);
+                  _elem147.read(iprot);
-                  this.success.add(_elem142);
+                  this.success.add(_elem147);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Campaign _iter143 : this.success)
+          for (Campaign _iter148 : this.success)
+          {
-            _iter143.write(oprot);
+            _iter148.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list144 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list149 = iprot.readListBegin();
-                this.success = new ArrayList<String>(_list144.size);
+                this.success = new ArrayList<String>(_list149.size);
-                for (int _i145 = 0; _i145 < _list144.size; ++_i145)
+                for (int _i150 = 0; _i150 < _list149.size; ++_i150)
+                {
-                  String _elem146; // required
+                  String _elem151; // required
-                  _elem146 = iprot.readString();
+                  _elem151 = iprot.readString();
-                  this.success.add(_elem146);
+                  this.success.add(_elem151);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
-          for (String _iter147 : this.success)
+          for (String _iter152 : this.success)
+          {
-            oprot.writeString(_iter147);
+            oprot.writeString(_iter152);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map148 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map153 = iprot.readMapBegin();
-                this.success = new HashMap<String,List<Banner>>(2*_map148.size);
+                this.success = new HashMap<String,List<Banner>>(2*_map153.size);
-                for (int _i149 = 0; _i149 < _map148.size; ++_i149)
+                for (int _i154 = 0; _i154 < _map153.size; ++_i154)
+                {
-                  String _key150; // required
+                  String _key155; // required
-                  List<Banner> _val151; // required
+                  List<Banner> _val156; // required
-                  _key150 = iprot.readString();
+                  _key155 = iprot.readString();
+                  {
-                    org.apache.thrift.protocol.TList _list152 = iprot.readListBegin();
+                    org.apache.thrift.protocol.TList _list157 = iprot.readListBegin();
-                    _val151 = new ArrayList<Banner>(_list152.size);
+                    _val156 = new ArrayList<Banner>(_list157.size);
-                    for (int _i153 = 0; _i153 < _list152.size; ++_i153)
+                    for (int _i158 = 0; _i158 < _list157.size; ++_i158)
+                    {
-                      Banner _elem154; // required
+                      Banner _elem159; // required
-                      _elem154 = new Banner();
+                      _elem159 = new Banner();
-                      _elem154.read(iprot);
+                      _elem159.read(iprot);
-                      _val151.add(_elem154);
+                      _val156.add(_elem159);
+                    }
                     iprot.readListEnd();
+                  }
-                  this.success.put(_key150, _val151);
+                  this.success.put(_key155, _val156);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.LIST, this.success.size()));
-          for (Map.Entry<String, List<Banner>> _iter155 : this.success.entrySet())
+          for (Map.Entry<String, List<Banner>> _iter160 : this.success.entrySet())
+          {
-            oprot.writeString(_iter155.getKey());
+            oprot.writeString(_iter160.getKey());
+            {
-              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter155.getValue().size()));
+              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter160.getValue().size()));
-              for (Banner _iter156 : _iter155.getValue())
+              for (Banner _iter161 : _iter160.getValue())
+              {
-                _iter156.write(oprot);
+                _iter161.write(oprot);
+              }
               oprot.writeListEnd();
+            }
+          }
           oprot.writeMapEnd();
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list157 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list162 = iprot.readListBegin();
-                this.success = new ArrayList<Item>(_list157.size);
+                this.success = new ArrayList<Item>(_list162.size);
-                for (int _i158 = 0; _i158 < _list157.size; ++_i158)
+                for (int _i163 = 0; _i163 < _list162.size; ++_i163)
+                {
-                  Item _elem159; // required
+                  Item _elem164; // required
-                  _elem159 = new Item();
+                  _elem164 = new Item();
-                  _elem159.read(iprot);
+                  _elem164.read(iprot);
-                  this.success.add(_elem159);
+                  this.success.add(_elem164);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Item _iter160 : this.success)
+          for (Item _iter165 : this.success)
+          {
-            _iter160.write(oprot);
+            _iter165.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list161 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list166 = iprot.readListBegin();
-                this.success = new ArrayList<Item>(_list161.size);
+                this.success = new ArrayList<Item>(_list166.size);
-                for (int _i162 = 0; _i162 < _list161.size; ++_i162)
+                for (int _i167 = 0; _i167 < _list166.size; ++_i167)
+                {
-                  Item _elem163; // required
+                  Item _elem168; // required
-                  _elem163 = new Item();
+                  _elem168 = new Item();
-                  _elem163.read(iprot);
+                  _elem168.read(iprot);
-                  this.success.add(_elem163);
+                  this.success.add(_elem168);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Item _iter164 : this.success)
+          for (Item _iter169 : this.success)
+          {
-            _iter164.write(oprot);
+            _iter169.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list165 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list170 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list165.size);
+                this.success = new ArrayList<Long>(_list170.size);
-                for (int _i166 = 0; _i166 < _list165.size; ++_i166)
+                for (int _i171 = 0; _i171 < _list170.size; ++_i171)
+                {
-                  long _elem167; // required
+                  long _elem172; // required
-                  _elem167 = iprot.readI64();
+                  _elem172 = iprot.readI64();
-                  this.success.add(_elem167);
+                  this.success.add(_elem172);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
-          for (long _iter168 : this.success)
+          for (long _iter173 : this.success)
+          {
-            oprot.writeI64(_iter168);
+            oprot.writeI64(_iter173);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+      }
+    }
     private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
       try {
+        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+        __isset_bit_vector = new BitSet(1);
         read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
       } catch (org.apache.thrift.TException te) {
         throw new java.io.IOException(te);
+      }
+    }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list169 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list174 = iprot.readListBegin();
-                this.success = new ArrayList<String>(_list169.size);
+                this.success = new ArrayList<String>(_list174.size);
-                for (int _i170 = 0; _i170 < _list169.size; ++_i170)
+                for (int _i175 = 0; _i175 < _list174.size; ++_i175)
+                {
-                  String _elem171; // required
+                  String _elem176; // required
-                  _elem171 = iprot.readString();
+                  _elem176 = iprot.readString();
-                  this.success.add(_elem171);
+                  this.success.add(_elem176);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
-          for (String _iter172 : this.success)
+          for (String _iter177 : this.success)
+          {
-            oprot.writeString(_iter172);
+            oprot.writeString(_iter177);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list173 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list178 = iprot.readListBegin();
-                this.success = new ArrayList<String>(_list173.size);
+                this.success = new ArrayList<String>(_list178.size);
-                for (int _i174 = 0; _i174 < _list173.size; ++_i174)
+                for (int _i179 = 0; _i179 < _list178.size; ++_i179)
+                {
-                  String _elem175; // required
+                  String _elem180; // required
-                  _elem175 = iprot.readString();
+                  _elem180 = iprot.readString();
-                  this.success.add(_elem175);
+                  this.success.add(_elem180);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
-          for (String _iter176 : this.success)
+          for (String _iter181 : this.success)
+          {
-            oprot.writeString(_iter176);
+            oprot.writeString(_iter181);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list177 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list182 = iprot.readListBegin();
-                this.success = new ArrayList<Source>(_list177.size);
+                this.success = new ArrayList<Source>(_list182.size);
-                for (int _i178 = 0; _i178 < _list177.size; ++_i178)
+                for (int _i183 = 0; _i183 < _list182.size; ++_i183)
+                {
-                  Source _elem179; // required
+                  Source _elem184; // required
-                  _elem179 = new Source();
+                  _elem184 = new Source();
-                  _elem179.read(iprot);
+                  _elem184.read(iprot);
-                  this.success.add(_elem179);
+                  this.success.add(_elem184);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Source _iter180 : this.success)
+          for (Source _iter185 : this.success)
+          {
-            _iter180.write(oprot);
+            _iter185.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list181 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list186 = iprot.readListBegin();
-                this.success = new ArrayList<SourceItemPricing>(_list181.size);
+                this.success = new ArrayList<SourceItemPricing>(_list186.size);
-                for (int _i182 = 0; _i182 < _list181.size; ++_i182)
+                for (int _i187 = 0; _i187 < _list186.size; ++_i187)
+                {
-                  SourceItemPricing _elem183; // required
+                  SourceItemPricing _elem188; // required
-                  _elem183 = new SourceItemPricing();
+                  _elem188 = new SourceItemPricing();
-                  _elem183.read(iprot);
+                  _elem188.read(iprot);
-                  this.success.add(_elem183);
+                  this.success.add(_elem188);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (SourceItemPricing _iter184 : this.success)
+          for (SourceItemPricing _iter189 : this.success)
+          {
-            _iter184.write(oprot);
+            _iter189.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetCex()) {
+        }
         switch (field.id) {
           case 1: // SEARCH_TERMS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list185 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list190 = iprot.readListBegin();
-                this.searchTerms = new ArrayList<String>(_list185.size);
+                this.searchTerms = new ArrayList<String>(_list190.size);
-                for (int _i186 = 0; _i186 < _list185.size; ++_i186)
+                for (int _i191 = 0; _i191 < _list190.size; ++_i191)
+                {
-                  String _elem187; // required
+                  String _elem192; // required
-                  _elem187 = iprot.readString();
+                  _elem192 = iprot.readString();
-                  this.searchTerms.add(_elem187);
+                  this.searchTerms.add(_elem192);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.searchTerms != null) {
         oprot.writeFieldBegin(SEARCH_TERMS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerms.size()));
-          for (String _iter188 : this.searchTerms)
+          for (String _iter193 : this.searchTerms)
+          {
-            oprot.writeString(_iter188);
+            oprot.writeString(_iter193);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list189 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list194 = iprot.readListBegin();
-                this.success = new ArrayList<Item>(_list189.size);
+                this.success = new ArrayList<Item>(_list194.size);
-                for (int _i190 = 0; _i190 < _list189.size; ++_i190)
+                for (int _i195 = 0; _i195 < _list194.size; ++_i195)
+                {
-                  Item _elem191; // required
+                  Item _elem196; // required
-                  _elem191 = new Item();
+                  _elem196 = new Item();
-                  _elem191.read(iprot);
+                  _elem196.read(iprot);
-                  this.success.add(_elem191);
+                  this.success.add(_elem196);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Item _iter192 : this.success)
+          for (Item _iter197 : this.success)
+          {
-            _iter192.write(oprot);
+            _iter197.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // SEARCH_TERMS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list193 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list198 = iprot.readListBegin();
-                this.searchTerms = new ArrayList<String>(_list193.size);
+                this.searchTerms = new ArrayList<String>(_list198.size);
-                for (int _i194 = 0; _i194 < _list193.size; ++_i194)
+                for (int _i199 = 0; _i199 < _list198.size; ++_i199)
+                {
-                  String _elem195; // required
+                  String _elem200; // required
-                  _elem195 = iprot.readString();
+                  _elem200 = iprot.readString();
-                  this.searchTerms.add(_elem195);
+                  this.searchTerms.add(_elem200);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.searchTerms != null) {
         oprot.writeFieldBegin(SEARCH_TERMS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerms.size()));
-          for (String _iter196 : this.searchTerms)
+          for (String _iter201 : this.searchTerms)
+          {
-            oprot.writeString(_iter196);
+            oprot.writeString(_iter201);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list197 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list202 = iprot.readListBegin();
-                this.success = new ArrayList<ProductNotificationRequest>(_list197.size);
+                this.success = new ArrayList<ProductNotificationRequest>(_list202.size);
-                for (int _i198 = 0; _i198 < _list197.size; ++_i198)
+                for (int _i203 = 0; _i203 < _list202.size; ++_i203)
+                {
-                  ProductNotificationRequest _elem199; // required
+                  ProductNotificationRequest _elem204; // required
-                  _elem199 = new ProductNotificationRequest();
+                  _elem204 = new ProductNotificationRequest();
-                  _elem199.read(iprot);
+                  _elem204.read(iprot);
-                  this.success.add(_elem199);
+                  this.success.add(_elem204);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (ProductNotificationRequest _iter200 : this.success)
+          for (ProductNotificationRequest _iter205 : this.success)
+          {
-            _iter200.write(oprot);
+            _iter205.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list201 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list206 = iprot.readListBegin();
-                this.success = new ArrayList<ProductNotificationRequestCount>(_list201.size);
+                this.success = new ArrayList<ProductNotificationRequestCount>(_list206.size);
-                for (int _i202 = 0; _i202 < _list201.size; ++_i202)
+                for (int _i207 = 0; _i207 < _list206.size; ++_i207)
+                {
-                  ProductNotificationRequestCount _elem203; // required
+                  ProductNotificationRequestCount _elem208; // required
-                  _elem203 = new ProductNotificationRequestCount();
+                  _elem208 = new ProductNotificationRequestCount();
-                  _elem203.read(iprot);
+                  _elem208.read(iprot);
-                  this.success.add(_elem203);
+                  this.success.add(_elem208);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (ProductNotificationRequestCount _iter204 : this.success)
+          for (ProductNotificationRequestCount _iter209 : this.success)
+          {
-            _iter204.write(oprot);
+            _iter209.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list205 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list210 = iprot.readListBegin();
-                this.success = new ArrayList<VoucherItemMapping>(_list205.size);
+                this.success = new ArrayList<VoucherItemMapping>(_list210.size);
-                for (int _i206 = 0; _i206 < _list205.size; ++_i206)
+                for (int _i211 = 0; _i211 < _list210.size; ++_i211)
+                {
-                  VoucherItemMapping _elem207; // required
+                  VoucherItemMapping _elem212; // required
-                  _elem207 = new VoucherItemMapping();
+                  _elem212 = new VoucherItemMapping();
-                  _elem207.read(iprot);
+                  _elem212.read(iprot);
-                  this.success.add(_elem207);
+                  this.success.add(_elem212);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (VoucherItemMapping _iter208 : this.success)
+          for (VoucherItemMapping _iter213 : this.success)
+          {
-            _iter208.write(oprot);
+            _iter213.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list209 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list214 = iprot.readListBegin();
-                this.success = new ArrayList<Item>(_list209.size);
+                this.success = new ArrayList<Item>(_list214.size);
-                for (int _i210 = 0; _i210 < _list209.size; ++_i210)
+                for (int _i215 = 0; _i215 < _list214.size; ++_i215)
+                {
-                  Item _elem211; // required
+                  Item _elem216; // required
-                  _elem211 = new Item();
+                  _elem216 = new Item();
-                  _elem211.read(iprot);
+                  _elem216.read(iprot);
-                  this.success.add(_elem211);
+                  this.success.add(_elem216);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Item _iter212 : this.success)
+          for (Item _iter217 : this.success)
+          {
-            _iter212.write(oprot);
+            _iter217.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list213 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list218 = iprot.readListBegin();
-                this.success = new ArrayList<Item>(_list213.size);
+                this.success = new ArrayList<Item>(_list218.size);
-                for (int _i214 = 0; _i214 < _list213.size; ++_i214)
+                for (int _i219 = 0; _i219 < _list218.size; ++_i219)
+                {
-                  Item _elem215; // required
+                  Item _elem220; // required
-                  _elem215 = new Item();
+                  _elem220 = new Item();
-                  _elem215.read(iprot);
+                  _elem220.read(iprot);
-                  this.success.add(_elem215);
+                  this.success.add(_elem220);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Item _iter216 : this.success)
+          for (Item _iter221 : this.success)
+          {
-            _iter216.write(oprot);
+            _iter221.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list217 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list222 = iprot.readListBegin();
-                this.success = new ArrayList<Insurer>(_list217.size);
+                this.success = new ArrayList<Insurer>(_list222.size);
-                for (int _i218 = 0; _i218 < _list217.size; ++_i218)
+                for (int _i223 = 0; _i223 < _list222.size; ++_i223)
+                {
-                  Insurer _elem219; // required
+                  Insurer _elem224; // required
-                  _elem219 = new Insurer();
+                  _elem224 = new Insurer();
-                  _elem219.read(iprot);
+                  _elem224.read(iprot);
-                  this.success.add(_elem219);
+                  this.success.add(_elem224);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Insurer _iter220 : this.success)
+          for (Insurer _iter225 : this.success)
+          {
-            _iter220.write(oprot);
+            _iter225.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map221 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map226 = iprot.readMapBegin();
-                this.success = new HashMap<String,BrandInfo>(2*_map221.size);
+                this.success = new HashMap<String,BrandInfo>(2*_map226.size);
-                for (int _i222 = 0; _i222 < _map221.size; ++_i222)
+                for (int _i227 = 0; _i227 < _map226.size; ++_i227)
+                {
-                  String _key223; // required
+                  String _key228; // required
-                  BrandInfo _val224; // required
+                  BrandInfo _val229; // required
-                  _key223 = iprot.readString();
+                  _key228 = iprot.readString();
-                  _val224 = new BrandInfo();
+                  _val229 = new BrandInfo();
-                  _val224.read(iprot);
+                  _val229.read(iprot);
-                  this.success.put(_key223, _val224);
+                  this.success.put(_key228, _val229);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Map.Entry<String, BrandInfo> _iter225 : this.success.entrySet())
+          for (Map.Entry<String, BrandInfo> _iter230 : this.success.entrySet())
+          {
-            oprot.writeString(_iter225.getKey());
+            oprot.writeString(_iter230.getKey());
-            _iter225.getValue().write(oprot);
+            _iter230.getValue().write(oprot);
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // ITEM_IDS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list226 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list231 = iprot.readListBegin();
-                this.itemIds = new ArrayList<Long>(_list226.size);
+                this.itemIds = new ArrayList<Long>(_list231.size);
-                for (int _i227 = 0; _i227 < _list226.size; ++_i227)
+                for (int _i232 = 0; _i232 < _list231.size; ++_i232)
+                {
-                  long _elem228; // required
+                  long _elem233; // required
-                  _elem228 = iprot.readI64();
+                  _elem233 = iprot.readI64();
-                  this.itemIds.add(_elem228);
+                  this.itemIds.add(_elem233);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.itemIds != null) {
         oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.itemIds.size()));
-          for (long _iter229 : this.itemIds)
+          for (long _iter234 : this.itemIds)
+          {
-            oprot.writeI64(_iter229);
+            oprot.writeI64(_iter234);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list230 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list235 = iprot.readListBegin();
-                this.success = new ArrayList<StorePricing>(_list230.size);
+                this.success = new ArrayList<StorePricing>(_list235.size);
-                for (int _i231 = 0; _i231 < _list230.size; ++_i231)
+                for (int _i236 = 0; _i236 < _list235.size; ++_i236)
+                {
-                  StorePricing _elem232; // required
+                  StorePricing _elem237; // required
-                  _elem232 = new StorePricing();
+                  _elem237 = new StorePricing();
-                  _elem232.read(iprot);
+                  _elem237.read(iprot);
-                  this.success.add(_elem232);
+                  this.success.add(_elem237);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (StorePricing _iter233 : this.success)
+          for (StorePricing _iter238 : this.success)
+          {
-            _iter233.write(oprot);
+            _iter238.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list234 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list239 = iprot.readListBegin();
-                this.success = new ArrayList<Amazonlisted>(_list234.size);
+                this.success = new ArrayList<Amazonlisted>(_list239.size);
-                for (int _i235 = 0; _i235 < _list234.size; ++_i235)
+                for (int _i240 = 0; _i240 < _list239.size; ++_i240)
+                {
-                  Amazonlisted _elem236; // required
+                  Amazonlisted _elem241; // required
-                  _elem236 = new Amazonlisted();
+                  _elem241 = new Amazonlisted();
-                  _elem236.read(iprot);
+                  _elem241.read(iprot);
-                  this.success.add(_elem236);
+                  this.success.add(_elem241);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Amazonlisted _iter237 : this.success)
+          for (Amazonlisted _iter242 : this.success)
+          {
-            _iter237.write(oprot);
+            _iter242.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // SEARCH_TERM
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list238 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list243 = iprot.readListBegin();
-                this.searchTerm = new ArrayList<String>(_list238.size);
+                this.searchTerm = new ArrayList<String>(_list243.size);
-                for (int _i239 = 0; _i239 < _list238.size; ++_i239)
+                for (int _i244 = 0; _i244 < _list243.size; ++_i244)
+                {
-                  String _elem240; // required
+                  String _elem245; // required
-                  _elem240 = iprot.readString();
+                  _elem245 = iprot.readString();
-                  this.searchTerm.add(_elem240);
+                  this.searchTerm.add(_elem245);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.searchTerm != null) {
         oprot.writeFieldBegin(SEARCH_TERM_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerm.size()));
-          for (String _iter241 : this.searchTerm)
+          for (String _iter246 : this.searchTerm)
+          {
-            oprot.writeString(_iter241);
+            oprot.writeString(_iter246);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list242 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list247 = iprot.readListBegin();
-                this.success = new ArrayList<Amazonlisted>(_list242.size);
+                this.success = new ArrayList<Amazonlisted>(_list247.size);
-                for (int _i243 = 0; _i243 < _list242.size; ++_i243)
+                for (int _i248 = 0; _i248 < _list247.size; ++_i248)
+                {
-                  Amazonlisted _elem244; // required
+                  Amazonlisted _elem249; // required
-                  _elem244 = new Amazonlisted();
+                  _elem249 = new Amazonlisted();
-                  _elem244.read(iprot);
+                  _elem249.read(iprot);
-                  this.success.add(_elem244);
+                  this.success.add(_elem249);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Amazonlisted _iter245 : this.success)
+          for (Amazonlisted _iter250 : this.success)
+          {
-            _iter245.write(oprot);
+            _iter250.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // SEARCH_TERM
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list246 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list251 = iprot.readListBegin();
-                this.searchTerm = new ArrayList<String>(_list246.size);
+                this.searchTerm = new ArrayList<String>(_list251.size);
-                for (int _i247 = 0; _i247 < _list246.size; ++_i247)
+                for (int _i252 = 0; _i252 < _list251.size; ++_i252)
+                {
-                  String _elem248; // required
+                  String _elem253; // required
-                  _elem248 = iprot.readString();
+                  _elem253 = iprot.readString();
-                  this.searchTerm.add(_elem248);
+                  this.searchTerm.add(_elem253);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.searchTerm != null) {
         oprot.writeFieldBegin(SEARCH_TERM_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerm.size()));
-          for (String _iter249 : this.searchTerm)
+          for (String _iter254 : this.searchTerm)
+          {
-            oprot.writeString(_iter249);
+            oprot.writeString(_iter254);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list250 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list255 = iprot.readListBegin();
-                this.success = new ArrayList<Item>(_list250.size);
+                this.success = new ArrayList<Item>(_list255.size);
-                for (int _i251 = 0; _i251 < _list250.size; ++_i251)
+                for (int _i256 = 0; _i256 < _list255.size; ++_i256)
+                {
-                  Item _elem252; // required
+                  Item _elem257; // required
-                  _elem252 = new Item();
+                  _elem257 = new Item();
-                  _elem252.read(iprot);
+                  _elem257.read(iprot);
-                  this.success.add(_elem252);
+                  this.success.add(_elem257);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Item _iter253 : this.success)
+          for (Item _iter258 : this.success)
+          {
-            _iter253.write(oprot);
+            _iter258.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list254 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list259 = iprot.readListBegin();
-                this.success = new ArrayList<Amazonlisted>(_list254.size);
+                this.success = new ArrayList<Amazonlisted>(_list259.size);
-                for (int _i255 = 0; _i255 < _list254.size; ++_i255)
+                for (int _i260 = 0; _i260 < _list259.size; ++_i260)
+                {
-                  Amazonlisted _elem256; // required
+                  Amazonlisted _elem261; // required
-                  _elem256 = new Amazonlisted();
+                  _elem261 = new Amazonlisted();
-                  _elem256.read(iprot);
+                  _elem261.read(iprot);
-                  this.success.add(_elem256);
+                  this.success.add(_elem261);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Amazonlisted _iter257 : this.success)
+          for (Amazonlisted _iter262 : this.success)
+          {
-            _iter257.write(oprot);
+            _iter262.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list258 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list263 = iprot.readListBegin();
-                this.success = new ArrayList<Amazonlisted>(_list258.size);
+                this.success = new ArrayList<Amazonlisted>(_list263.size);
-                for (int _i259 = 0; _i259 < _list258.size; ++_i259)
+                for (int _i264 = 0; _i264 < _list263.size; ++_i264)
+                {
-                  Amazonlisted _elem260; // required
+                  Amazonlisted _elem265; // required
-                  _elem260 = new Amazonlisted();
+                  _elem265 = new Amazonlisted();
-                  _elem260.read(iprot);
+                  _elem265.read(iprot);
-                  this.success.add(_elem260);
+                  this.success.add(_elem265);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Amazonlisted _iter261 : this.success)
+          for (Amazonlisted _iter266 : this.success)
+          {
-            _iter261.write(oprot);
+            _iter266.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+            }
             break;
           case 2: // SKU
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list262 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list267 = iprot.readListBegin();
-                this.sku = new ArrayList<Long>(_list262.size);
+                this.sku = new ArrayList<Long>(_list267.size);
-                for (int _i263 = 0; _i263 < _list262.size; ++_i263)
+                for (int _i268 = 0; _i268 < _list267.size; ++_i268)
+                {
-                  long _elem264; // required
+                  long _elem269; // required
-                  _elem264 = iprot.readI64();
+                  _elem269 = iprot.readI64();
-                  this.sku.add(_elem264);
+                  this.sku.add(_elem269);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+      }
       if (this.sku != null) {
         oprot.writeFieldBegin(SKU_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.sku.size()));
-          for (long _iter265 : this.sku)
+          for (long _iter270 : this.sku)
+          {
-            oprot.writeI64(_iter265);
+            oprot.writeI64(_iter270);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list266 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list271 = iprot.readListBegin();
-                this.success = new ArrayList<Category>(_list266.size);
+                this.success = new ArrayList<Category>(_list271.size);
-                for (int _i267 = 0; _i267 < _list266.size; ++_i267)
+                for (int _i272 = 0; _i272 < _list271.size; ++_i272)
+                {
-                  Category _elem268; // required
+                  Category _elem273; // required
-                  _elem268 = new Category();
+                  _elem273 = new Category();
-                  _elem268.read(iprot);
+                  _elem273.read(iprot);
-                  this.success.add(_elem268);
+                  this.success.add(_elem273);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Category _iter269 : this.success)
+          for (Category _iter274 : this.success)
+          {
-            _iter269.write(oprot);
+            _iter274.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list270 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list275 = iprot.readListBegin();
-                this.success = new ArrayList<Amazonlisted>(_list270.size);
+                this.success = new ArrayList<Amazonlisted>(_list275.size);
-                for (int _i271 = 0; _i271 < _list270.size; ++_i271)
+                for (int _i276 = 0; _i276 < _list275.size; ++_i276)
+                {
-                  Amazonlisted _elem272; // required
+                  Amazonlisted _elem277; // required
-                  _elem272 = new Amazonlisted();
+                  _elem277 = new Amazonlisted();
-                  _elem272.read(iprot);
+                  _elem277.read(iprot);
-                  this.success.add(_elem272);
+                  this.success.add(_elem277);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Amazonlisted _iter273 : this.success)
+          for (Amazonlisted _iter278 : this.success)
+          {
-            _iter273.write(oprot);
+            _iter278.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // AMAZONLISTED
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map274 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map279 = iprot.readMapBegin();
-                this.amazonlisted = new HashMap<Long,Amazonlisted>(2*_map274.size);
+                this.amazonlisted = new HashMap<Long,Amazonlisted>(2*_map279.size);
-                for (int _i275 = 0; _i275 < _map274.size; ++_i275)
+                for (int _i280 = 0; _i280 < _map279.size; ++_i280)
+                {
-                  long _key276; // required
+                  long _key281; // required
-                  Amazonlisted _val277; // required
+                  Amazonlisted _val282; // required
-                  _key276 = iprot.readI64();
+                  _key281 = iprot.readI64();
-                  _val277 = new Amazonlisted();
+                  _val282 = new Amazonlisted();
-                  _val277.read(iprot);
+                  _val282.read(iprot);
-                  this.amazonlisted.put(_key276, _val277);
+                  this.amazonlisted.put(_key281, _val282);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.amazonlisted != null) {
         oprot.writeFieldBegin(AMAZONLISTED_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRUCT, this.amazonlisted.size()));
-          for (Map.Entry<Long, Amazonlisted> _iter278 : this.amazonlisted.entrySet())
+          for (Map.Entry<Long, Amazonlisted> _iter283 : this.amazonlisted.entrySet())
+          {
-            oprot.writeI64(_iter278.getKey());
+            oprot.writeI64(_iter283.getKey());
-            _iter278.getValue().write(oprot);
+            _iter283.getValue().write(oprot);
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list279 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list284 = iprot.readListBegin();
-                this.success = new ArrayList<Amazonlisted>(_list279.size);
+                this.success = new ArrayList<Amazonlisted>(_list284.size);
-                for (int _i280 = 0; _i280 < _list279.size; ++_i280)
+                for (int _i285 = 0; _i285 < _list284.size; ++_i285)
+                {
-                  Amazonlisted _elem281; // required
+                  Amazonlisted _elem286; // required
-                  _elem281 = new Amazonlisted();
+                  _elem286 = new Amazonlisted();
-                  _elem281.read(iprot);
+                  _elem286.read(iprot);
-                  this.success.add(_elem281);
+                  this.success.add(_elem286);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Amazonlisted _iter282 : this.success)
+          for (Amazonlisted _iter287 : this.success)
+          {
-            _iter282.write(oprot);
+            _iter287.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list283 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list288 = iprot.readListBegin();
-                this.success = new ArrayList<Amazonlisted>(_list283.size);
+                this.success = new ArrayList<Amazonlisted>(_list288.size);
-                for (int _i284 = 0; _i284 < _list283.size; ++_i284)
+                for (int _i289 = 0; _i289 < _list288.size; ++_i289)
+                {
-                  Amazonlisted _elem285; // required
+                  Amazonlisted _elem290; // required
-                  _elem285 = new Amazonlisted();
+                  _elem290 = new Amazonlisted();
-                  _elem285.read(iprot);
+                  _elem290.read(iprot);
-                  this.success.add(_elem285);
+                  this.success.add(_elem290);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Amazonlisted _iter286 : this.success)
+          for (Amazonlisted _iter291 : this.success)
+          {
-            _iter286.write(oprot);
+            _iter291.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // ITEM
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map287 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map292 = iprot.readMapBegin();
-                this.item = new HashMap<Long,Item>(2*_map287.size);
+                this.item = new HashMap<Long,Item>(2*_map292.size);
-                for (int _i288 = 0; _i288 < _map287.size; ++_i288)
+                for (int _i293 = 0; _i293 < _map292.size; ++_i293)
+                {
-                  long _key289; // required
+                  long _key294; // required
-                  Item _val290; // required
+                  Item _val295; // required
-                  _key289 = iprot.readI64();
+                  _key294 = iprot.readI64();
-                  _val290 = new Item();
+                  _val295 = new Item();
-                  _val290.read(iprot);
+                  _val295.read(iprot);
-                  this.item.put(_key289, _val290);
+                  this.item.put(_key294, _val295);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.item != null) {
         oprot.writeFieldBegin(ITEM_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRUCT, this.item.size()));
-          for (Map.Entry<Long, Item> _iter291 : this.item.entrySet())
+          for (Map.Entry<Long, Item> _iter296 : this.item.entrySet())
+          {
-            oprot.writeI64(_iter291.getKey());
+            oprot.writeI64(_iter296.getKey());
-            _iter291.getValue().write(oprot);
+            _iter296.getValue().write(oprot);
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list292 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list297 = iprot.readListBegin();
-                this.success = new ArrayList<SnapdealItemDetails>(_list292.size);
+                this.success = new ArrayList<SnapdealItemDetails>(_list297.size);
-                for (int _i293 = 0; _i293 < _list292.size; ++_i293)
+                for (int _i298 = 0; _i298 < _list297.size; ++_i298)
+                {
-                  SnapdealItemDetails _elem294; // required
+                  SnapdealItemDetails _elem299; // required
-                  _elem294 = new SnapdealItemDetails();
+                  _elem299 = new SnapdealItemDetails();
-                  _elem294.read(iprot);
+                  _elem299.read(iprot);
-                  this.success.add(_elem294);
+                  this.success.add(_elem299);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (SnapdealItemDetails _iter295 : this.success)
+          for (SnapdealItemDetails _iter300 : this.success)
+          {
-            _iter295.write(oprot);
+            _iter300.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list296 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list301 = iprot.readListBegin();
-                this.success = new ArrayList<SnapdealItemDetails>(_list296.size);
+                this.success = new ArrayList<SnapdealItemDetails>(_list301.size);
-                for (int _i297 = 0; _i297 < _list296.size; ++_i297)
+                for (int _i302 = 0; _i302 < _list301.size; ++_i302)
+                {
-                  SnapdealItemDetails _elem298; // required
+                  SnapdealItemDetails _elem303; // required
-                  _elem298 = new SnapdealItemDetails();
+                  _elem303 = new SnapdealItemDetails();
-                  _elem298.read(iprot);
+                  _elem303.read(iprot);
-                  this.success.add(_elem298);
+                  this.success.add(_elem303);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (SnapdealItemDetails _iter299 : this.success)
+          for (SnapdealItemDetails _iter304 : this.success)
+          {
-            _iter299.write(oprot);
+            _iter304.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // SEARCH_TERM
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list300 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list305 = iprot.readListBegin();
-                this.searchTerm = new ArrayList<String>(_list300.size);
+                this.searchTerm = new ArrayList<String>(_list305.size);
-                for (int _i301 = 0; _i301 < _list300.size; ++_i301)
+                for (int _i306 = 0; _i306 < _list305.size; ++_i306)
+                {
-                  String _elem302; // required
+                  String _elem307; // required
-                  _elem302 = iprot.readString();
+                  _elem307 = iprot.readString();
-                  this.searchTerm.add(_elem302);
+                  this.searchTerm.add(_elem307);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.searchTerm != null) {
         oprot.writeFieldBegin(SEARCH_TERM_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerm.size()));
-          for (String _iter303 : this.searchTerm)
+          for (String _iter308 : this.searchTerm)
+          {
-            oprot.writeString(_iter303);
+            oprot.writeString(_iter308);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list304 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list309 = iprot.readListBegin();
-                this.success = new ArrayList<SnapdealItemDetails>(_list304.size);
+                this.success = new ArrayList<SnapdealItemDetails>(_list309.size);
-                for (int _i305 = 0; _i305 < _list304.size; ++_i305)
+                for (int _i310 = 0; _i310 < _list309.size; ++_i310)
+                {
-                  SnapdealItemDetails _elem306; // required
+                  SnapdealItemDetails _elem311; // required
-                  _elem306 = new SnapdealItemDetails();
+                  _elem311 = new SnapdealItemDetails();
-                  _elem306.read(iprot);
+                  _elem311.read(iprot);
-                  this.success.add(_elem306);
+                  this.success.add(_elem311);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (SnapdealItemDetails _iter307 : this.success)
+          for (SnapdealItemDetails _iter312 : this.success)
+          {
-            _iter307.write(oprot);
+            _iter312.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // SEARCH_TERM
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list308 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list313 = iprot.readListBegin();
-                this.searchTerm = new ArrayList<String>(_list308.size);
+                this.searchTerm = new ArrayList<String>(_list313.size);
-                for (int _i309 = 0; _i309 < _list308.size; ++_i309)
+                for (int _i314 = 0; _i314 < _list313.size; ++_i314)
+                {
-                  String _elem310; // required
+                  String _elem315; // required
-                  _elem310 = iprot.readString();
+                  _elem315 = iprot.readString();
-                  this.searchTerm.add(_elem310);
+                  this.searchTerm.add(_elem315);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.searchTerm != null) {
         oprot.writeFieldBegin(SEARCH_TERM_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerm.size()));
-          for (String _iter311 : this.searchTerm)
+          for (String _iter316 : this.searchTerm)
+          {
-            oprot.writeString(_iter311);
+            oprot.writeString(_iter316);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list312 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list317 = iprot.readListBegin();
-                this.success = new ArrayList<ProductFeedSubmit>(_list312.size);
+                this.success = new ArrayList<ProductFeedSubmit>(_list317.size);
-                for (int _i313 = 0; _i313 < _list312.size; ++_i313)
+                for (int _i318 = 0; _i318 < _list317.size; ++_i318)
+                {
-                  ProductFeedSubmit _elem314; // required
+                  ProductFeedSubmit _elem319; // required
-                  _elem314 = new ProductFeedSubmit();
+                  _elem319 = new ProductFeedSubmit();
-                  _elem314.read(iprot);
+                  _elem319.read(iprot);
-                  this.success.add(_elem314);
+                  this.success.add(_elem319);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (ProductFeedSubmit _iter315 : this.success)
+          for (ProductFeedSubmit _iter320 : this.success)
+          {
-            _iter315.write(oprot);
+            _iter320.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetCex()) {
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list316 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list321 = iprot.readListBegin();
-                this.success = new ArrayList<MarketPlaceItemPrice>(_list316.size);
+                this.success = new ArrayList<MarketPlaceItemPrice>(_list321.size);
-                for (int _i317 = 0; _i317 < _list316.size; ++_i317)
+                for (int _i322 = 0; _i322 < _list321.size; ++_i322)
+                {
-                  MarketPlaceItemPrice _elem318; // required
+                  MarketPlaceItemPrice _elem323; // required
-                  _elem318 = new MarketPlaceItemPrice();
+                  _elem323 = new MarketPlaceItemPrice();
-                  _elem318.read(iprot);
+                  _elem323.read(iprot);
-                  this.success.add(_elem318);
+                  this.success.add(_elem323);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (MarketPlaceItemPrice _iter319 : this.success)
+          for (MarketPlaceItemPrice _iter324 : this.success)
+          {
-            _iter319.write(oprot);
+            _iter324.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // SKULIST
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list320 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list325 = iprot.readListBegin();
-                this.skulist = new ArrayList<Long>(_list320.size);
+                this.skulist = new ArrayList<Long>(_list325.size);
-                for (int _i321 = 0; _i321 < _list320.size; ++_i321)
+                for (int _i326 = 0; _i326 < _list325.size; ++_i326)
+                {
-                  long _elem322; // required
+                  long _elem327; // required
-                  _elem322 = iprot.readI64();
+                  _elem327 = iprot.readI64();
-                  this.skulist.add(_elem322);
+                  this.skulist.add(_elem327);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.skulist != null) {
         oprot.writeFieldBegin(SKULIST_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.skulist.size()));
-          for (long _iter323 : this.skulist)
+          for (long _iter328 : this.skulist)
+          {
-            oprot.writeI64(_iter323);
+            oprot.writeI64(_iter328);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // ITEM_HOLD_MAP
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map324 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map329 = iprot.readMapBegin();
-                this.itemHoldMap = new HashMap<Long,Long>(2*_map324.size);
+                this.itemHoldMap = new HashMap<Long,Long>(2*_map329.size);
-                for (int _i325 = 0; _i325 < _map324.size; ++_i325)
+                for (int _i330 = 0; _i330 < _map329.size; ++_i330)
+                {
-                  long _key326; // required
+                  long _key331; // required
-                  long _val327; // required
+                  long _val332; // required
-                  _key326 = iprot.readI64();
+                  _key331 = iprot.readI64();
-                  _val327 = iprot.readI64();
+                  _val332 = iprot.readI64();
-                  this.itemHoldMap.put(_key326, _val327);
+                  this.itemHoldMap.put(_key331, _val332);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.itemHoldMap != null) {
         oprot.writeFieldBegin(ITEM_HOLD_MAP_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.I64, this.itemHoldMap.size()));
-          for (Map.Entry<Long, Long> _iter328 : this.itemHoldMap.entrySet())
+          for (Map.Entry<Long, Long> _iter333 : this.itemHoldMap.entrySet())
+          {
-            oprot.writeI64(_iter328.getKey());
+            oprot.writeI64(_iter333.getKey());
-            oprot.writeI64(_iter328.getValue());
+            oprot.writeI64(_iter333.getValue());
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list329 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list334 = iprot.readListBegin();
-                this.success = new ArrayList<FlipkartItem>(_list329.size);
+                this.success = new ArrayList<FlipkartItem>(_list334.size);
-                for (int _i330 = 0; _i330 < _list329.size; ++_i330)
+                for (int _i335 = 0; _i335 < _list334.size; ++_i335)
+                {
-                  FlipkartItem _elem331; // required
+                  FlipkartItem _elem336; // required
-                  _elem331 = new FlipkartItem();
+                  _elem336 = new FlipkartItem();
-                  _elem331.read(iprot);
+                  _elem336.read(iprot);
-                  this.success.add(_elem331);
+                  this.success.add(_elem336);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (FlipkartItem _iter332 : this.success)
+          for (FlipkartItem _iter337 : this.success)
+          {
-            _iter332.write(oprot);
+            _iter337.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list333 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list338 = iprot.readListBegin();
-                this.success = new ArrayList<FlipkartItemDetails>(_list333.size);
+                this.success = new ArrayList<FlipkartItemDetails>(_list338.size);
-                for (int _i334 = 0; _i334 < _list333.size; ++_i334)
+                for (int _i339 = 0; _i339 < _list338.size; ++_i339)
+                {
-                  FlipkartItemDetails _elem335; // required
+                  FlipkartItemDetails _elem340; // required
-                  _elem335 = new FlipkartItemDetails();
+                  _elem340 = new FlipkartItemDetails();
-                  _elem335.read(iprot);
+                  _elem340.read(iprot);
-                  this.success.add(_elem335);
+                  this.success.add(_elem340);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (FlipkartItemDetails _iter336 : this.success)
+          for (FlipkartItemDetails _iter341 : this.success)
+          {
-            _iter336.write(oprot);
+            _iter341.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // SEARCH_TERM
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list337 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list342 = iprot.readListBegin();
-                this.searchTerm = new ArrayList<String>(_list337.size);
+                this.searchTerm = new ArrayList<String>(_list342.size);
-                for (int _i338 = 0; _i338 < _list337.size; ++_i338)
+                for (int _i343 = 0; _i343 < _list342.size; ++_i343)
+                {
-                  String _elem339; // required
+                  String _elem344; // required
-                  _elem339 = iprot.readString();
+                  _elem344 = iprot.readString();
-                  this.searchTerm.add(_elem339);
+                  this.searchTerm.add(_elem344);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.searchTerm != null) {
         oprot.writeFieldBegin(SEARCH_TERM_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerm.size()));
-          for (String _iter340 : this.searchTerm)
+          for (String _iter345 : this.searchTerm)
+          {
-            oprot.writeString(_iter340);
+            oprot.writeString(_iter345);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list341 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list346 = iprot.readListBegin();
-                this.success = new ArrayList<FlipkartItemDetails>(_list341.size);
+                this.success = new ArrayList<FlipkartItemDetails>(_list346.size);
-                for (int _i342 = 0; _i342 < _list341.size; ++_i342)
+                for (int _i347 = 0; _i347 < _list346.size; ++_i347)
+                {
-                  FlipkartItemDetails _elem343; // required
+                  FlipkartItemDetails _elem348; // required
-                  _elem343 = new FlipkartItemDetails();
+                  _elem348 = new FlipkartItemDetails();
-                  _elem343.read(iprot);
+                  _elem348.read(iprot);
-                  this.success.add(_elem343);
+                  this.success.add(_elem348);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (FlipkartItemDetails _iter344 : this.success)
+          for (FlipkartItemDetails _iter349 : this.success)
+          {
-            _iter344.write(oprot);
+            _iter349.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // SEARCH_TERM
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list345 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list350 = iprot.readListBegin();
-                this.searchTerm = new ArrayList<String>(_list345.size);
+                this.searchTerm = new ArrayList<String>(_list350.size);
-                for (int _i346 = 0; _i346 < _list345.size; ++_i346)
+                for (int _i351 = 0; _i351 < _list350.size; ++_i351)
+                {
-                  String _elem347; // required
+                  String _elem352; // required
-                  _elem347 = iprot.readString();
+                  _elem352 = iprot.readString();
-                  this.searchTerm.add(_elem347);
+                  this.searchTerm.add(_elem352);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.searchTerm != null) {
         oprot.writeFieldBegin(SEARCH_TERM_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.searchTerm.size()));
-          for (String _iter348 : this.searchTerm)
+          for (String _iter353 : this.searchTerm)
+          {
-            oprot.writeString(_iter348);
+            oprot.writeString(_iter353);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list349 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list354 = iprot.readListBegin();
-                this.success = new ArrayList<FlipkartItemDetails>(_list349.size);
+                this.success = new ArrayList<FlipkartItemDetails>(_list354.size);
-                for (int _i350 = 0; _i350 < _list349.size; ++_i350)
+                for (int _i355 = 0; _i355 < _list354.size; ++_i355)
+                {
-                  FlipkartItemDetails _elem351; // required
+                  FlipkartItemDetails _elem356; // required
-                  _elem351 = new FlipkartItemDetails();
+                  _elem356 = new FlipkartItemDetails();
-                  _elem351.read(iprot);
+                  _elem356.read(iprot);
-                  this.success.add(_elem351);
+                  this.success.add(_elem356);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (FlipkartItemDetails _iter352 : this.success)
+          for (FlipkartItemDetails _iter357 : this.success)
+          {
-            _iter352.write(oprot);
+            _iter357.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list353 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list358 = iprot.readListBegin();
-                this.success = new ArrayList<MarketplaceHistory>(_list353.size);
+                this.success = new ArrayList<MarketplaceHistory>(_list358.size);
-                for (int _i354 = 0; _i354 < _list353.size; ++_i354)
+                for (int _i359 = 0; _i359 < _list358.size; ++_i359)
+                {
-                  MarketplaceHistory _elem355; // required
+                  MarketplaceHistory _elem360; // required
-                  _elem355 = new MarketplaceHistory();
+                  _elem360 = new MarketplaceHistory();
-                  _elem355.read(iprot);
+                  _elem360.read(iprot);
-                  this.success.add(_elem355);
+                  this.success.add(_elem360);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (MarketplaceHistory _iter356 : this.success)
+          for (MarketplaceHistory _iter361 : this.success)
+          {
-            _iter356.write(oprot);
+            _iter361.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list357 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list362 = iprot.readListBegin();
-                this.success = new ArrayList<Amazonlisted>(_list357.size);
+                this.success = new ArrayList<Amazonlisted>(_list362.size);
-                for (int _i358 = 0; _i358 < _list357.size; ++_i358)
+                for (int _i363 = 0; _i363 < _list362.size; ++_i363)
+                {
-                  Amazonlisted _elem359; // required
+                  Amazonlisted _elem364; // required
-                  _elem359 = new Amazonlisted();
+                  _elem364 = new Amazonlisted();
-                  _elem359.read(iprot);
+                  _elem364.read(iprot);
-                  this.success.add(_elem359);
+                  this.success.add(_elem364);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Amazonlisted _iter360 : this.success)
+          for (Amazonlisted _iter365 : this.success)
+          {
-            _iter360.write(oprot);
+            _iter365.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list361 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list366 = iprot.readListBegin();
-                this.success = new ArrayList<Amazonlisted>(_list361.size);
+                this.success = new ArrayList<Amazonlisted>(_list366.size);
-                for (int _i362 = 0; _i362 < _list361.size; ++_i362)
+                for (int _i367 = 0; _i367 < _list366.size; ++_i367)
+                {
-                  Amazonlisted _elem363; // required
+                  Amazonlisted _elem368; // required
-                  _elem363 = new Amazonlisted();
+                  _elem368 = new Amazonlisted();
-                  _elem363.read(iprot);
+                  _elem368.read(iprot);
-                  this.success.add(_elem363);
+                  this.success.add(_elem368);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Amazonlisted _iter364 : this.success)
+          for (Amazonlisted _iter369 : this.success)
+          {
-            _iter364.write(oprot);
+            _iter369.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list365 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list370 = iprot.readListBegin();
-                this.success = new ArrayList<MarketplaceHistory>(_list365.size);
+                this.success = new ArrayList<MarketplaceHistory>(_list370.size);
-                for (int _i366 = 0; _i366 < _list365.size; ++_i366)
+                for (int _i371 = 0; _i371 < _list370.size; ++_i371)
+                {
-                  MarketplaceHistory _elem367; // required
+                  MarketplaceHistory _elem372; // required
-                  _elem367 = new MarketplaceHistory();
+                  _elem372 = new MarketplaceHistory();
-                  _elem367.read(iprot);
+                  _elem372.read(iprot);
-                  this.success.add(_elem367);
+                  this.success.add(_elem372);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (MarketplaceHistory _iter368 : this.success)
+          for (MarketplaceHistory _iter373 : this.success)
+          {
-            _iter368.write(oprot);
+            _iter373.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list369 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list374 = iprot.readListBegin();
-                this.success = new ArrayList<Item>(_list369.size);
+                this.success = new ArrayList<Item>(_list374.size);
-                for (int _i370 = 0; _i370 < _list369.size; ++_i370)
+                for (int _i375 = 0; _i375 < _list374.size; ++_i375)
+                {
-                  Item _elem371; // required
+                  Item _elem376; // required
-                  _elem371 = new Item();
+                  _elem376 = new Item();
-                  _elem371.read(iprot);
+                  _elem376.read(iprot);
-                  this.success.add(_elem371);
+                  this.success.add(_elem376);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Item _iter372 : this.success)
+          for (Item _iter377 : this.success)
+          {
-            _iter372.write(oprot);
+            _iter377.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // ITEM_IDS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list373 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list378 = iprot.readListBegin();
-                this.itemIds = new ArrayList<Long>(_list373.size);
+                this.itemIds = new ArrayList<Long>(_list378.size);
-                for (int _i374 = 0; _i374 < _list373.size; ++_i374)
+                for (int _i379 = 0; _i379 < _list378.size; ++_i379)
+                {
-                  long _elem375; // required
+                  long _elem380; // required
-                  _elem375 = iprot.readI64();
+                  _elem380 = iprot.readI64();
-                  this.itemIds.add(_elem375);
+                  this.itemIds.add(_elem380);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.itemIds != null) {
         oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.itemIds.size()));
-          for (long _iter376 : this.itemIds)
+          for (long _iter381 : this.itemIds)
+          {
-            oprot.writeI64(_iter376);
+            oprot.writeI64(_iter381);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map377 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map382 = iprot.readMapBegin();
-                this.success = new HashMap<Long,PrivateDeal>(2*_map377.size);
+                this.success = new HashMap<Long,PrivateDeal>(2*_map382.size);
-                for (int _i378 = 0; _i378 < _map377.size; ++_i378)
+                for (int _i383 = 0; _i383 < _map382.size; ++_i383)
+                {
-                  long _key379; // required
+                  long _key384; // required
-                  PrivateDeal _val380; // required
+                  PrivateDeal _val385; // required
-                  _key379 = iprot.readI64();
+                  _key384 = iprot.readI64();
-                  _val380 = new PrivateDeal();
+                  _val385 = new PrivateDeal();
-                  _val380.read(iprot);
+                  _val385.read(iprot);
-                  this.success.put(_key379, _val380);
+                  this.success.put(_key384, _val385);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Map.Entry<Long, PrivateDeal> _iter381 : this.success.entrySet())
+          for (Map.Entry<Long, PrivateDeal> _iter386 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter381.getKey());
+            oprot.writeI64(_iter386.getKey());
-            _iter381.getValue().write(oprot);
+            _iter386.getValue().write(oprot);
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list382 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list387 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list382.size);
+                this.success = new ArrayList<Long>(_list387.size);
-                for (int _i383 = 0; _i383 < _list382.size; ++_i383)
+                for (int _i388 = 0; _i388 < _list387.size; ++_i388)
+                {
-                  long _elem384; // required
+                  long _elem389; // required
-                  _elem384 = iprot.readI64();
+                  _elem389 = iprot.readI64();
-                  this.success.add(_elem384);
+                  this.success.add(_elem389);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
-          for (long _iter385 : this.success)
+          for (long _iter390 : this.success)
+          {
-            oprot.writeI64(_iter385);
+            oprot.writeI64(_iter390);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetCex()) {
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list386 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list391 = iprot.readListBegin();
-                this.success = new ArrayList<PdPriceComp>(_list386.size);
+                this.success = new ArrayList<PdPriceComp>(_list391.size);
-                for (int _i387 = 0; _i387 < _list386.size; ++_i387)
+                for (int _i392 = 0; _i392 < _list391.size; ++_i392)
+                {
-                  PdPriceComp _elem388; // required
+                  PdPriceComp _elem393; // required
-                  _elem388 = new PdPriceComp();
+                  _elem393 = new PdPriceComp();
-                  _elem388.read(iprot);
+                  _elem393.read(iprot);
-                  this.success.add(_elem388);
+                  this.success.add(_elem393);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (PdPriceComp _iter389 : this.success)
+          for (PdPriceComp _iter394 : this.success)
+          {
-            _iter389.write(oprot);
+            _iter394.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list390 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list395 = iprot.readListBegin();
-                this.success = new ArrayList<SnapdealItem>(_list390.size);
+                this.success = new ArrayList<SnapdealItem>(_list395.size);
-                for (int _i391 = 0; _i391 < _list390.size; ++_i391)
+                for (int _i396 = 0; _i396 < _list395.size; ++_i396)
+                {
-                  SnapdealItem _elem392; // required
+                  SnapdealItem _elem397; // required
-                  _elem392 = new SnapdealItem();
+                  _elem397 = new SnapdealItem();
-                  _elem392.read(iprot);
+                  _elem397.read(iprot);
-                  this.success.add(_elem392);
+                  this.success.add(_elem397);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (SnapdealItem _iter393 : this.success)
+          for (SnapdealItem _iter398 : this.success)
+          {
-            _iter393.write(oprot);
+            _iter398.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list394 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list399 = iprot.readListBegin();
-                this.success = new ArrayList<FlipkartItem>(_list394.size);
+                this.success = new ArrayList<FlipkartItem>(_list399.size);
-                for (int _i395 = 0; _i395 < _list394.size; ++_i395)
+                for (int _i400 = 0; _i400 < _list399.size; ++_i400)
+                {
-                  FlipkartItem _elem396; // required
+                  FlipkartItem _elem401; // required
-                  _elem396 = new FlipkartItem();
+                  _elem401 = new FlipkartItem();
-                  _elem396.read(iprot);
+                  _elem401.read(iprot);
-                  this.success.add(_elem396);
+                  this.success.add(_elem401);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (FlipkartItem _iter397 : this.success)
+          for (FlipkartItem _iter402 : this.success)
+          {
-            _iter397.write(oprot);
+            _iter402.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // COMPETITOR_PRICING_MAP
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map398 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map403 = iprot.readMapBegin();
-                this.competitorPricingMap = new HashMap<Long,CompetitorPricing>(2*_map398.size);
+                this.competitorPricingMap = new HashMap<Long,CompetitorPricing>(2*_map403.size);
-                for (int _i399 = 0; _i399 < _map398.size; ++_i399)
+                for (int _i404 = 0; _i404 < _map403.size; ++_i404)
+                {
-                  long _key400; // required
+                  long _key405; // required
-                  CompetitorPricing _val401; // required
+                  CompetitorPricing _val406; // required
-                  _key400 = iprot.readI64();
+                  _key405 = iprot.readI64();
-                  _val401 = new CompetitorPricing();
+                  _val406 = new CompetitorPricing();
-                  _val401.read(iprot);
+                  _val406.read(iprot);
-                  this.competitorPricingMap.put(_key400, _val401);
+                  this.competitorPricingMap.put(_key405, _val406);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.competitorPricingMap != null) {
         oprot.writeFieldBegin(COMPETITOR_PRICING_MAP_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRUCT, this.competitorPricingMap.size()));
-          for (Map.Entry<Long, CompetitorPricing> _iter402 : this.competitorPricingMap.entrySet())
+          for (Map.Entry<Long, CompetitorPricing> _iter407 : this.competitorPricingMap.entrySet())
+          {
-            oprot.writeI64(_iter402.getKey());
+            oprot.writeI64(_iter407.getKey());
-            _iter402.getValue().write(oprot);
+            _iter407.getValue().write(oprot);
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list403 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list408 = iprot.readListBegin();
-                this.success = new ArrayList<CompetitorPricing>(_list403.size);
+                this.success = new ArrayList<CompetitorPricing>(_list408.size);
-                for (int _i404 = 0; _i404 < _list403.size; ++_i404)
+                for (int _i409 = 0; _i409 < _list408.size; ++_i409)
+                {
-                  CompetitorPricing _elem405; // required
+                  CompetitorPricing _elem410; // required
-                  _elem405 = new CompetitorPricing();
+                  _elem410 = new CompetitorPricing();
-                  _elem405.read(iprot);
+                  _elem410.read(iprot);
-                  this.success.add(_elem405);
+                  this.success.add(_elem410);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (CompetitorPricing _iter406 : this.success)
+          for (CompetitorPricing _iter411 : this.success)
+          {
-            _iter406.write(oprot);
+            _iter411.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list407 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list412 = iprot.readListBegin();
-                this.success = new ArrayList<CompetitorPricing>(_list407.size);
+                this.success = new ArrayList<CompetitorPricing>(_list412.size);
-                for (int _i408 = 0; _i408 < _list407.size; ++_i408)
+                for (int _i413 = 0; _i413 < _list412.size; ++_i413)
+                {
-                  CompetitorPricing _elem409; // required
+                  CompetitorPricing _elem414; // required
-                  _elem409 = new CompetitorPricing();
+                  _elem414 = new CompetitorPricing();
-                  _elem409.read(iprot);
+                  _elem414.read(iprot);
-                  this.success.add(_elem409);
+                  this.success.add(_elem414);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (CompetitorPricing _iter410 : this.success)
+          for (CompetitorPricing _iter415 : this.success)
+          {
-            _iter410.write(oprot);
+            _iter415.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // AMAZON_PROMOTIONS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map411 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map416 = iprot.readMapBegin();
-                this.amazonPromotions = new HashMap<String,AmazonPromotion>(2*_map411.size);
+                this.amazonPromotions = new HashMap<String,AmazonPromotion>(2*_map416.size);
-                for (int _i412 = 0; _i412 < _map411.size; ++_i412)
+                for (int _i417 = 0; _i417 < _map416.size; ++_i417)
+                {
-                  String _key413; // required
+                  String _key418; // required
-                  AmazonPromotion _val414; // required
+                  AmazonPromotion _val419; // required
-                  _key413 = iprot.readString();
+                  _key418 = iprot.readString();
-                  _val414 = new AmazonPromotion();
+                  _val419 = new AmazonPromotion();
-                  _val414.read(iprot);
+                  _val419.read(iprot);
-                  this.amazonPromotions.put(_key413, _val414);
+                  this.amazonPromotions.put(_key418, _val419);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.amazonPromotions != null) {
         oprot.writeFieldBegin(AMAZON_PROMOTIONS_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, this.amazonPromotions.size()));
-          for (Map.Entry<String, AmazonPromotion> _iter415 : this.amazonPromotions.entrySet())
+          for (Map.Entry<String, AmazonPromotion> _iter420 : this.amazonPromotions.entrySet())
+          {
-            oprot.writeString(_iter415.getKey());
+            oprot.writeString(_iter420.getKey());
-            _iter415.getValue().write(oprot);
+            _iter420.getValue().write(oprot);
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list416 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list421 = iprot.readListBegin();
-                this.success = new ArrayList<AmazonPromotion>(_list416.size);
+                this.success = new ArrayList<AmazonPromotion>(_list421.size);
-                for (int _i417 = 0; _i417 < _list416.size; ++_i417)
+                for (int _i422 = 0; _i422 < _list421.size; ++_i422)
+                {
-                  AmazonPromotion _elem418; // required
+                  AmazonPromotion _elem423; // required
-                  _elem418 = new AmazonPromotion();
+                  _elem423 = new AmazonPromotion();
-                  _elem418.read(iprot);
+                  _elem423.read(iprot);
-                  this.success.add(_elem418);
+                  this.success.add(_elem423);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (AmazonPromotion _iter419 : this.success)
+          for (AmazonPromotion _iter424 : this.success)
+          {
-            _iter419.write(oprot);
+            _iter424.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // AMAZON_PROMOTIONS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list420 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list425 = iprot.readListBegin();
-                this.amazonPromotions = new ArrayList<AmazonPromotion>(_list420.size);
+                this.amazonPromotions = new ArrayList<AmazonPromotion>(_list425.size);
-                for (int _i421 = 0; _i421 < _list420.size; ++_i421)
+                for (int _i426 = 0; _i426 < _list425.size; ++_i426)
+                {
-                  AmazonPromotion _elem422; // required
+                  AmazonPromotion _elem427; // required
-                  _elem422 = new AmazonPromotion();
+                  _elem427 = new AmazonPromotion();
-                  _elem422.read(iprot);
+                  _elem427.read(iprot);
-                  this.amazonPromotions.add(_elem422);
+                  this.amazonPromotions.add(_elem427);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.amazonPromotions != null) {
         oprot.writeFieldBegin(AMAZON_PROMOTIONS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.amazonPromotions.size()));
-          for (AmazonPromotion _iter423 : this.amazonPromotions)
+          for (AmazonPromotion _iter428 : this.amazonPromotions)
+          {
-            _iter423.write(oprot);
+            _iter428.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
       boolean first = true;
       sb.append("success:");
       sb.append(this.success);
       first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws org.apache.thrift.TException {
+      // check for required fields
+    }
+    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+      try {
+        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+      try {
+        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+  }
+  public static class markPartiallyActive_args implements org.apache.thrift.TBase<markPartiallyActive_args, markPartiallyActive_args._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("markPartiallyActive_args");
+    private static final org.apache.thrift.protocol.TField ITEM_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("itemId", org.apache.thrift.protocol.TType.I64, (short)1);
+    private static final org.apache.thrift.protocol.TField CATEGORY_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("categoryId", org.apache.thrift.protocol.TType.I64, (short)2);
+    private long itemId; // required
+    private long categoryId; // required
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+      ITEM_ID((short)1, "itemId"),
+      CATEGORY_ID((short)2, "categoryId");
+      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+      static {
+        for (_Fields field : EnumSet.allOf(_Fields.class)) {
+          byName.put(field.getFieldName(), field);
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, or null if its not found.
+       */
+      public static _Fields findByThriftId(int fieldId) {
+        switch(fieldId) {
+          case 1: // ITEM_ID
+            return ITEM_ID;
+          case 2: // CATEGORY_ID
+            return CATEGORY_ID;
+          default:
+            return null;
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, throwing an exception
+       * if it is not found.
+       */
+      public static _Fields findByThriftIdOrThrow(int fieldId) {
+        _Fields fields = findByThriftId(fieldId);
+        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+        return fields;
+      }
+      /**
+       * Find the _Fields constant that matches name, or null if its not found.
+       */
+      public static _Fields findByName(String name) {
+        return byName.get(name);
+      }
+      private final short _thriftId;
+      private final String _fieldName;
+      _Fields(short thriftId, String fieldName) {
+        _thriftId = thriftId;
+        _fieldName = fieldName;
+      }
+      public short getThriftFieldId() {
+        return _thriftId;
+      }
+      public String getFieldName() {
+        return _fieldName;
+      }
+    }
+    // isset id assignments
+    private static final int __ITEMID_ISSET_ID = 0;
+    private static final int __CATEGORYID_ISSET_ID = 1;
+    private BitSet __isset_bit_vector = new BitSet(2);
+    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+    static {
+      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+      tmpMap.put(_Fields.ITEM_ID, new org.apache.thrift.meta_data.FieldMetaData("itemId", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      tmpMap.put(_Fields.CATEGORY_ID, new org.apache.thrift.meta_data.FieldMetaData("categoryId", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(markPartiallyActive_args.class, metaDataMap);
+    }
+    public markPartiallyActive_args() {
+    }
+    public markPartiallyActive_args(
+      long itemId,
+      long categoryId)
+    {
+      this();
+      this.itemId = itemId;
+      setItemIdIsSet(true);
+      this.categoryId = categoryId;
+      setCategoryIdIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public markPartiallyActive_args(markPartiallyActive_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.itemId = other.itemId;
+      this.categoryId = other.categoryId;
+    }
+    public markPartiallyActive_args deepCopy() {
+      return new markPartiallyActive_args(this);
+    }
+    @Override
+    public void clear() {
+      setItemIdIsSet(false);
+      this.itemId = 0;
+      setCategoryIdIsSet(false);
+      this.categoryId = 0;
+    }
+    public long getItemId() {
+      return this.itemId;
+    }
+    public void setItemId(long itemId) {
+      this.itemId = itemId;
+      setItemIdIsSet(true);
+    }
+    public void unsetItemId() {
+      __isset_bit_vector.clear(__ITEMID_ISSET_ID);
+    }
+    /** Returns true if field itemId is set (has been assigned a value) and false otherwise */
+    public boolean isSetItemId() {
+      return __isset_bit_vector.get(__ITEMID_ISSET_ID);
+    }
+    public void setItemIdIsSet(boolean value) {
+      __isset_bit_vector.set(__ITEMID_ISSET_ID, value);
+    }
+    public long getCategoryId() {
+      return this.categoryId;
+    }
+    public void setCategoryId(long categoryId) {
+      this.categoryId = categoryId;
+      setCategoryIdIsSet(true);
+    }
+    public void unsetCategoryId() {
+      __isset_bit_vector.clear(__CATEGORYID_ISSET_ID);
+    }
+    /** Returns true if field categoryId is set (has been assigned a value) and false otherwise */
+    public boolean isSetCategoryId() {
+      return __isset_bit_vector.get(__CATEGORYID_ISSET_ID);
+    }
+    public void setCategoryIdIsSet(boolean value) {
+      __isset_bit_vector.set(__CATEGORYID_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case ITEM_ID:
+        if (value == null) {
+          unsetItemId();
+        } else {
+          setItemId((Long)value);
+        }
+        break;
+      case CATEGORY_ID:
+        if (value == null) {
+          unsetCategoryId();
+        } else {
+          setCategoryId((Long)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case ITEM_ID:
+        return Long.valueOf(getItemId());
+      case CATEGORY_ID:
+        return Long.valueOf(getCategoryId());
+      }
+      throw new IllegalStateException();
+    }
+    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+    public boolean isSet(_Fields field) {
+      if (field == null) {
+        throw new IllegalArgumentException();
+      }
+      switch (field) {
+      case ITEM_ID:
+        return isSetItemId();
+      case CATEGORY_ID:
+        return isSetCategoryId();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof markPartiallyActive_args)
+        return this.equals((markPartiallyActive_args)that);
+      return false;
+    }
+    public boolean equals(markPartiallyActive_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_itemId = true;
+      boolean that_present_itemId = true;
+      if (this_present_itemId || that_present_itemId) {
+        if (!(this_present_itemId && that_present_itemId))
+          return false;
+        if (this.itemId != that.itemId)
+          return false;
+      }
+      boolean this_present_categoryId = true;
+      boolean that_present_categoryId = true;
+      if (this_present_categoryId || that_present_categoryId) {
+        if (!(this_present_categoryId && that_present_categoryId))
+          return false;
+        if (this.categoryId != that.categoryId)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(markPartiallyActive_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      markPartiallyActive_args typedOther = (markPartiallyActive_args)other;
+      lastComparison = Boolean.valueOf(isSetItemId()).compareTo(typedOther.isSetItemId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetItemId()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.itemId, typedOther.itemId);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetCategoryId()).compareTo(typedOther.isSetCategoryId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetCategoryId()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.categoryId, typedOther.categoryId);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      return 0;
+    }
+    public _Fields fieldForId(int fieldId) {
+      return _Fields.findByThriftId(fieldId);
+    }
+    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField field;
+      iprot.readStructBegin();
+      while (true)
+      {
+        field = iprot.readFieldBegin();
+        if (field.type == org.apache.thrift.protocol.TType.STOP) {
+          break;
+        }
+        switch (field.id) {
+          case 1: // ITEM_ID
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.itemId = iprot.readI64();
+              setItemIdIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 2: // CATEGORY_ID
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.categoryId = iprot.readI64();
+              setCategoryIdIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+      validate();
+      oprot.writeStructBegin(STRUCT_DESC);
+      oprot.writeFieldBegin(ITEM_ID_FIELD_DESC);
+      oprot.writeI64(this.itemId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(CATEGORY_ID_FIELD_DESC);
+      oprot.writeI64(this.categoryId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("markPartiallyActive_args(");
+      boolean first = true;
+      sb.append("itemId:");
+      sb.append(this.itemId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("categoryId:");
+      sb.append(this.categoryId);
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws org.apache.thrift.TException {
+      // check for required fields
+    }
+    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+      try {
+        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+      try {
+        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+        __isset_bit_vector = new BitSet(1);
+        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+  }
+  public static class markPartiallyActive_result implements org.apache.thrift.TBase<markPartiallyActive_result, markPartiallyActive_result._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("markPartiallyActive_result");
+    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);
+    private boolean success; // required
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+      SUCCESS((short)0, "success");
+      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+      static {
+        for (_Fields field : EnumSet.allOf(_Fields.class)) {
+          byName.put(field.getFieldName(), field);
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, or null if its not found.
+       */
+      public static _Fields findByThriftId(int fieldId) {
+        switch(fieldId) {
+          case 0: // SUCCESS
+            return SUCCESS;
+          default:
+            return null;
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, throwing an exception
+       * if it is not found.
+       */
+      public static _Fields findByThriftIdOrThrow(int fieldId) {
+        _Fields fields = findByThriftId(fieldId);
+        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+        return fields;
+      }
+      /**
+       * Find the _Fields constant that matches name, or null if its not found.
+       */
+      public static _Fields findByName(String name) {
+        return byName.get(name);
+      }
+      private final short _thriftId;
+      private final String _fieldName;
+      _Fields(short thriftId, String fieldName) {
+        _thriftId = thriftId;
+        _fieldName = fieldName;
+      }
+      public short getThriftFieldId() {
+        return _thriftId;
+      }
+      public String getFieldName() {
+        return _fieldName;
+      }
+    }
+    // isset id assignments
+    private static final int __SUCCESS_ISSET_ID = 0;
+    private BitSet __isset_bit_vector = new BitSet(1);
+    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+    static {
+      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(markPartiallyActive_result.class, metaDataMap);
+    }
+    public markPartiallyActive_result() {
+    }
+    public markPartiallyActive_result(
+      boolean success)
+    {
+      this();
+      this.success = success;
+      setSuccessIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public markPartiallyActive_result(markPartiallyActive_result other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.success = other.success;
+    }
+    public markPartiallyActive_result deepCopy() {
+      return new markPartiallyActive_result(this);
+    }
+    @Override
+    public void clear() {
+      setSuccessIsSet(false);
+      this.success = false;
+    }
+    public boolean isSuccess() {
+      return this.success;
+    }
+    public void setSuccess(boolean success) {
+      this.success = success;
+      setSuccessIsSet(true);
+    }
+    public void unsetSuccess() {
+      __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
+    }
+    /** Returns true if field success is set (has been assigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
+    }
+    public void setSuccessIsSet(boolean value) {
+      __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((Boolean)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case SUCCESS:
+        return Boolean.valueOf(isSuccess());
+      }
+      throw new IllegalStateException();
+    }
+    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+    public boolean isSet(_Fields field) {
+      if (field == null) {
+        throw new IllegalArgumentException();
+      }
+      switch (field) {
+      case SUCCESS:
+        return isSetSuccess();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof markPartiallyActive_result)
+        return this.equals((markPartiallyActive_result)that);
+      return false;
+    }
+    public boolean equals(markPartiallyActive_result that) {
+      if (that == null)
+        return false;
+      boolean this_present_success = true;
+      boolean that_present_success = true;
+      if (this_present_success || that_present_success) {
+        if (!(this_present_success && that_present_success))
+          return false;
+        if (this.success != that.success)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(markPartiallyActive_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      markPartiallyActive_result typedOther = (markPartiallyActive_result)other;
+      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetSuccess()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      return 0;
+    }
+    public _Fields fieldForId(int fieldId) {
+      return _Fields.findByThriftId(fieldId);
+    }
+    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField field;
+      iprot.readStructBegin();
+      while (true)
+      {
+        field = iprot.readFieldBegin();
+        if (field.type == org.apache.thrift.protocol.TType.STOP) {
+          break;
+        }
+        switch (field.id) {
+          case 0: // SUCCESS
+            if (field.type == org.apache.thrift.protocol.TType.BOOL) {
+              this.success = iprot.readBool();
+              setSuccessIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        oprot.writeBool(this.success);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("markPartiallyActive_result(");
+      boolean first = true;
+      sb.append("success:");
+      sb.append(this.success);
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws org.apache.thrift.TException {
+      // check for required fields
+    }
+    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+      try {
+        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+      try {
+        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+  }
+  public static class updateItemStateVat_args implements org.apache.thrift.TBase<updateItemStateVat_args, updateItemStateVat_args._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("updateItemStateVat_args");
+    private static final org.apache.thrift.protocol.TField ITEM_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("itemId", org.apache.thrift.protocol.TType.I64, (short)1);
+    private static final org.apache.thrift.protocol.TField STATEVAT_FIELD_DESC = new org.apache.thrift.protocol.TField("statevat", org.apache.thrift.protocol.TType.MAP, (short)2);
+    private long itemId; // required
+    private Map<Long,Double> statevat; // required
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+      ITEM_ID((short)1, "itemId"),
+      STATEVAT((short)2, "statevat");
+      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+      static {
+        for (_Fields field : EnumSet.allOf(_Fields.class)) {
+          byName.put(field.getFieldName(), field);
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, or null if its not found.
+       */
+      public static _Fields findByThriftId(int fieldId) {
+        switch(fieldId) {
+          case 1: // ITEM_ID
+            return ITEM_ID;
+          case 2: // STATEVAT
+            return STATEVAT;
+          default:
+            return null;
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, throwing an exception
+       * if it is not found.
+       */
+      public static _Fields findByThriftIdOrThrow(int fieldId) {
+        _Fields fields = findByThriftId(fieldId);
+        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+        return fields;
+      }
+      /**
+       * Find the _Fields constant that matches name, or null if its not found.
+       */
+      public static _Fields findByName(String name) {
+        return byName.get(name);
+      }
+      private final short _thriftId;
+      private final String _fieldName;
+      _Fields(short thriftId, String fieldName) {
+        _thriftId = thriftId;
+        _fieldName = fieldName;
+      }
+      public short getThriftFieldId() {
+        return _thriftId;
+      }
+      public String getFieldName() {
+        return _fieldName;
+      }
+    }
+    // isset id assignments
+    private static final int __ITEMID_ISSET_ID = 0;
+    private BitSet __isset_bit_vector = new BitSet(1);
+    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+    static {
+      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+      tmpMap.put(_Fields.ITEM_ID, new org.apache.thrift.meta_data.FieldMetaData("itemId", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      tmpMap.put(_Fields.STATEVAT, new org.apache.thrift.meta_data.FieldMetaData("statevat", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+              new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64),
+              new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE))));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(updateItemStateVat_args.class, metaDataMap);
+    }
+    public updateItemStateVat_args() {
+    }
+    public updateItemStateVat_args(
+      long itemId,
+      Map<Long,Double> statevat)
+    {
+      this();
+      this.itemId = itemId;
+      setItemIdIsSet(true);
+      this.statevat = statevat;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public updateItemStateVat_args(updateItemStateVat_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.itemId = other.itemId;
+      if (other.isSetStatevat()) {
+        Map<Long,Double> __this__statevat = new HashMap<Long,Double>();
+        for (Map.Entry<Long, Double> other_element : other.statevat.entrySet()) {
+          Long other_element_key = other_element.getKey();
+          Double other_element_value = other_element.getValue();
+          Long __this__statevat_copy_key = other_element_key;
+          Double __this__statevat_copy_value = other_element_value;
+          __this__statevat.put(__this__statevat_copy_key, __this__statevat_copy_value);
+        }
+        this.statevat = __this__statevat;
+      }
+    }
+    public updateItemStateVat_args deepCopy() {
+      return new updateItemStateVat_args(this);
+    }
+    @Override
+    public void clear() {
+      setItemIdIsSet(false);
+      this.itemId = 0;
+      this.statevat = null;
+    }
+    public long getItemId() {
+      return this.itemId;
+    }
+    public void setItemId(long itemId) {
+      this.itemId = itemId;
+      setItemIdIsSet(true);
+    }
+    public void unsetItemId() {
+      __isset_bit_vector.clear(__ITEMID_ISSET_ID);
+    }
+    /** Returns true if field itemId is set (has been assigned a value) and false otherwise */
+    public boolean isSetItemId() {
+      return __isset_bit_vector.get(__ITEMID_ISSET_ID);
+    }
+    public void setItemIdIsSet(boolean value) {
+      __isset_bit_vector.set(__ITEMID_ISSET_ID, value);
+    }
+    public int getStatevatSize() {
+      return (this.statevat == null) ? 0 : this.statevat.size();
+    }
+    public void putToStatevat(long key, double val) {
+      if (this.statevat == null) {
+        this.statevat = new HashMap<Long,Double>();
+      }
+      this.statevat.put(key, val);
+    }
+    public Map<Long,Double> getStatevat() {
+      return this.statevat;
+    }
+    public void setStatevat(Map<Long,Double> statevat) {
+      this.statevat = statevat;
+    }
+    public void unsetStatevat() {
+      this.statevat = null;
+    }
+    /** Returns true if field statevat is set (has been assigned a value) and false otherwise */
+    public boolean isSetStatevat() {
+      return this.statevat != null;
+    }
+    public void setStatevatIsSet(boolean value) {
+      if (!value) {
+        this.statevat = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case ITEM_ID:
+        if (value == null) {
+          unsetItemId();
+        } else {
+          setItemId((Long)value);
+        }
+        break;
+      case STATEVAT:
+        if (value == null) {
+          unsetStatevat();
+        } else {
+          setStatevat((Map<Long,Double>)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case ITEM_ID:
+        return Long.valueOf(getItemId());
+      case STATEVAT:
+        return getStatevat();
+      }
+      throw new IllegalStateException();
+    }
+    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+    public boolean isSet(_Fields field) {
+      if (field == null) {
+        throw new IllegalArgumentException();
+      }
+      switch (field) {
+      case ITEM_ID:
+        return isSetItemId();
+      case STATEVAT:
+        return isSetStatevat();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof updateItemStateVat_args)
+        return this.equals((updateItemStateVat_args)that);
+      return false;
+    }
+    public boolean equals(updateItemStateVat_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_itemId = true;
+      boolean that_present_itemId = true;
+      if (this_present_itemId || that_present_itemId) {
+        if (!(this_present_itemId && that_present_itemId))
+          return false;
+        if (this.itemId != that.itemId)
+          return false;
+      }
+      boolean this_present_statevat = true && this.isSetStatevat();
+      boolean that_present_statevat = true && that.isSetStatevat();
+      if (this_present_statevat || that_present_statevat) {
+        if (!(this_present_statevat && that_present_statevat))
+          return false;
+        if (!this.statevat.equals(that.statevat))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(updateItemStateVat_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      updateItemStateVat_args typedOther = (updateItemStateVat_args)other;
+      lastComparison = Boolean.valueOf(isSetItemId()).compareTo(typedOther.isSetItemId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetItemId()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.itemId, typedOther.itemId);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetStatevat()).compareTo(typedOther.isSetStatevat());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetStatevat()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.statevat, typedOther.statevat);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      return 0;
+    }
+    public _Fields fieldForId(int fieldId) {
+      return _Fields.findByThriftId(fieldId);
+    }
+    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField field;
+      iprot.readStructBegin();
+      while (true)
+      {
+        field = iprot.readFieldBegin();
+        if (field.type == org.apache.thrift.protocol.TType.STOP) {
+          break;
+        }
+        switch (field.id) {
+          case 1: // ITEM_ID
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.itemId = iprot.readI64();
+              setItemIdIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 2: // STATEVAT
+            if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
+                org.apache.thrift.protocol.TMap _map429 = iprot.readMapBegin();
+                this.statevat = new HashMap<Long,Double>(2*_map429.size);
+                for (int _i430 = 0; _i430 < _map429.size; ++_i430)
+                {
+                  long _key431; // required
+                  double _val432; // required
+                  _key431 = iprot.readI64();
+                  _val432 = iprot.readDouble();
+                  this.statevat.put(_key431, _val432);
+                }
+                iprot.readMapEnd();
+              }
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+      validate();
+      oprot.writeStructBegin(STRUCT_DESC);
+      oprot.writeFieldBegin(ITEM_ID_FIELD_DESC);
+      oprot.writeI64(this.itemId);
+      oprot.writeFieldEnd();
+      if (this.statevat != null) {
+        oprot.writeFieldBegin(STATEVAT_FIELD_DESC);
+        {
+          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.DOUBLE, this.statevat.size()));
+          for (Map.Entry<Long, Double> _iter433 : this.statevat.entrySet())
+          {
+            oprot.writeI64(_iter433.getKey());
+            oprot.writeDouble(_iter433.getValue());
+          }
+          oprot.writeMapEnd();
+        }
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("updateItemStateVat_args(");
+      boolean first = true;
+      sb.append("itemId:");
+      sb.append(this.itemId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("statevat:");
+      if (this.statevat == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.statevat);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws org.apache.thrift.TException {
+      // check for required fields
+    }
+    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+      try {
+        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+      try {
+        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+        __isset_bit_vector = new BitSet(1);
+        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+  }
+  public static class updateItemStateVat_result implements org.apache.thrift.TBase<updateItemStateVat_result, updateItemStateVat_result._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("updateItemStateVat_result");
+    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);
+    private boolean success; // required
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+      SUCCESS((short)0, "success");
+      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+      static {
+        for (_Fields field : EnumSet.allOf(_Fields.class)) {
+          byName.put(field.getFieldName(), field);
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, or null if its not found.
+       */
+      public static _Fields findByThriftId(int fieldId) {
+        switch(fieldId) {
+          case 0: // SUCCESS
+            return SUCCESS;
+          default:
+            return null;
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, throwing an exception
+       * if it is not found.
+       */
+      public static _Fields findByThriftIdOrThrow(int fieldId) {
+        _Fields fields = findByThriftId(fieldId);
+        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+        return fields;
+      }
+      /**
+       * Find the _Fields constant that matches name, or null if its not found.
+       */
+      public static _Fields findByName(String name) {
+        return byName.get(name);
+      }
+      private final short _thriftId;
+      private final String _fieldName;
+      _Fields(short thriftId, String fieldName) {
+        _thriftId = thriftId;
+        _fieldName = fieldName;
+      }
+      public short getThriftFieldId() {
+        return _thriftId;
+      }
+      public String getFieldName() {
+        return _fieldName;
+      }
+    }
+    // isset id assignments
+    private static final int __SUCCESS_ISSET_ID = 0;
+    private BitSet __isset_bit_vector = new BitSet(1);
+    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+    static {
+      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(updateItemStateVat_result.class, metaDataMap);
+    }
+    public updateItemStateVat_result() {
+    }
+    public updateItemStateVat_result(
+      boolean success)
+    {
+      this();
+      this.success = success;
+      setSuccessIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public updateItemStateVat_result(updateItemStateVat_result other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.success = other.success;
+    }
+    public updateItemStateVat_result deepCopy() {
+      return new updateItemStateVat_result(this);
+    }
+    @Override
+    public void clear() {
+      setSuccessIsSet(false);
+      this.success = false;
+    }
+    public boolean isSuccess() {
+      return this.success;
+    }
+    public void setSuccess(boolean success) {
+      this.success = success;
+      setSuccessIsSet(true);
+    }
+    public void unsetSuccess() {
+      __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
+    }
+    /** Returns true if field success is set (has been assigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
+    }
+    public void setSuccessIsSet(boolean value) {
+      __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((Boolean)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case SUCCESS:
+        return Boolean.valueOf(isSuccess());
+      }
+      throw new IllegalStateException();
+    }
+    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+    public boolean isSet(_Fields field) {
+      if (field == null) {
+        throw new IllegalArgumentException();
+      }
+      switch (field) {
+      case SUCCESS:
+        return isSetSuccess();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof updateItemStateVat_result)
+        return this.equals((updateItemStateVat_result)that);
+      return false;
+    }
+    public boolean equals(updateItemStateVat_result that) {
+      if (that == null)
+        return false;
+      boolean this_present_success = true;
+      boolean that_present_success = true;
+      if (this_present_success || that_present_success) {
+        if (!(this_present_success && that_present_success))
+          return false;
+        if (this.success != that.success)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(updateItemStateVat_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      updateItemStateVat_result typedOther = (updateItemStateVat_result)other;
+      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetSuccess()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      return 0;
+    }
+    public _Fields fieldForId(int fieldId) {
+      return _Fields.findByThriftId(fieldId);
+    }
+    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField field;
+      iprot.readStructBegin();
+      while (true)
+      {
+        field = iprot.readFieldBegin();
+        if (field.type == org.apache.thrift.protocol.TType.STOP) {
+          break;
+        }
+        switch (field.id) {
+          case 0: // SUCCESS
+            if (field.type == org.apache.thrift.protocol.TType.BOOL) {
+              this.success = iprot.readBool();
+              setSuccessIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        oprot.writeBool(this.success);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("updateItemStateVat_result(");
+      boolean first = true;
+      sb.append("success:");
+      sb.append(this.success);
+      first = false;
       sb.append(")");
       return sb.toString();
+    }
     public void validate() throws org.apache.thrift.TException {

Subversion Repositories SmartDukaan

(root)/trunk/ThriftConfig/src/main/java/in/shop2020/model/v1/catalog/CatalogService.java – Rev 12363 → 12523