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

      * @param warehouseId
      */
     public VendorItemPricing getItemPricing(long itemId, long warehouseId) throws InventoryServiceException, TException;
     /**
-     * Store category object and retrieve it
+     * All category related functions
+     *
-     * @param object
+     * @param category
      */
-    public boolean putCategoryObject(byte[] object) throws TException;
+    public boolean addCategory(Category category) throws TException;
-    public byte[] getCategoryObject() throws TException;
+    public Category getCategory(long id) throws TException;
+    public List<Category> getAllCategories() throws TException;
+  }
   public static class Client implements Iface {
     public Client(TProtocol prot)
         throw result.cex;
+      }
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricing failed: unknown result");
+    }
-    public boolean putCategoryObject(byte[] object) throws TException
+    public boolean addCategory(Category category) throws TException
+    {
+      send_addCategory(category);
+      return recv_addCategory();
+    }
+    public void send_addCategory(Category category) throws TException
+    {
+      oprot_.writeMessageBegin(new TMessage("addCategory", TMessageType.CALL, seqid_));
+      addCategory_args args = new addCategory_args();
+      args.category = category;
+      args.write(oprot_);
+      oprot_.writeMessageEnd();
+      oprot_.getTransport().flush();
+    }
+    public boolean recv_addCategory() throws TException
+    {
+      TMessage msg = iprot_.readMessageBegin();
+      if (msg.type == TMessageType.EXCEPTION) {
+        TApplicationException x = TApplicationException.read(iprot_);
+        iprot_.readMessageEnd();
+        throw x;
+      }
+      addCategory_result result = new addCategory_result();
+      result.read(iprot_);
+      iprot_.readMessageEnd();
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      throw new TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
+    }
+    public Category getCategory(long id) throws TException
+    {
-      send_putCategoryObject(object);
+      send_getCategory(id);
-      return recv_putCategoryObject();
+      return recv_getCategory();
+    }
-    public void send_putCategoryObject(byte[] object) throws TException
+    public void send_getCategory(long id) throws TException
+    {
-      oprot_.writeMessageBegin(new TMessage("putCategoryObject", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("getCategory", TMessageType.CALL, seqid_));
-      putCategoryObject_args args = new putCategoryObject_args();
+      getCategory_args args = new getCategory_args();
-      args.object = object;
+      args.id = id;
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
+    }
-    public boolean recv_putCategoryObject() throws TException
+    public Category recv_getCategory() throws TException
+    {
       TMessage msg = iprot_.readMessageBegin();
       if (msg.type == TMessageType.EXCEPTION) {
         TApplicationException x = TApplicationException.read(iprot_);
         iprot_.readMessageEnd();
         throw x;
+      }
-      putCategoryObject_result result = new putCategoryObject_result();
+      getCategory_result result = new getCategory_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
       if (result.isSetSuccess()) {
         return result.success;
+      }
-      throw new TApplicationException(TApplicationException.MISSING_RESULT, "putCategoryObject failed: unknown result");
+      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
+    }
-    public byte[] getCategoryObject() throws TException
+    public List<Category> getAllCategories() throws TException
+    {
-      send_getCategoryObject();
+      send_getAllCategories();
-      return recv_getCategoryObject();
+      return recv_getAllCategories();
+    }
-    public void send_getCategoryObject() throws TException
+    public void send_getAllCategories() throws TException
+    {
-      oprot_.writeMessageBegin(new TMessage("getCategoryObject", TMessageType.CALL, seqid_));
+      oprot_.writeMessageBegin(new TMessage("getAllCategories", TMessageType.CALL, seqid_));
-      getCategoryObject_args args = new getCategoryObject_args();
+      getAllCategories_args args = new getAllCategories_args();
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
+    }
-    public byte[] recv_getCategoryObject() throws TException
+    public List<Category> recv_getAllCategories() throws TException
+    {
       TMessage msg = iprot_.readMessageBegin();
       if (msg.type == TMessageType.EXCEPTION) {
         TApplicationException x = TApplicationException.read(iprot_);
         iprot_.readMessageEnd();
         throw x;
+      }
-      getCategoryObject_result result = new getCategoryObject_result();
+      getAllCategories_result result = new getAllCategories_result();
       result.read(iprot_);
       iprot_.readMessageEnd();
       if (result.isSetSuccess()) {
         return result.success;
+      }
-      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getCategoryObject failed: unknown result");
+      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
+    }
+  }
   public static class Processor implements TProcessor {
     private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
       processMap_.put("getLatestArrivals", new getLatestArrivals());
       processMap_.put("getLatestArrivalsCatalogIds", new getLatestArrivalsCatalogIds());
       processMap_.put("getLatestArrivalsCount", new getLatestArrivalsCount());
       processMap_.put("generateNewEntityID", new generateNewEntityID());
       processMap_.put("getItemPricing", new getItemPricing());
-      processMap_.put("putCategoryObject", new putCategoryObject());
+      processMap_.put("addCategory", new addCategory());
-      processMap_.put("getCategoryObject", new getCategoryObject());
+      processMap_.put("getCategory", new getCategory());
+      processMap_.put("getAllCategories", new getAllCategories());
+    }
     protected static interface ProcessFunction {
       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException;
+    }
         oprot.getTransport().flush();
+      }
+    }
-    private class putCategoryObject implements ProcessFunction {
+    private class addCategory implements ProcessFunction {
       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
-        putCategoryObject_args args = new putCategoryObject_args();
+        addCategory_args args = new addCategory_args();
         args.read(iprot);
         iprot.readMessageEnd();
-        putCategoryObject_result result = new putCategoryObject_result();
+        addCategory_result result = new addCategory_result();
-        result.success = iface_.putCategoryObject(args.object);
+        result.success = iface_.addCategory(args.category);
         result.setSuccessIsSet(true);
+        oprot.writeMessageBegin(new TMessage("addCategory", TMessageType.REPLY, seqid));
+        result.write(oprot);
+        oprot.writeMessageEnd();
+        oprot.getTransport().flush();
+      }
+    }
+    private class getCategory implements ProcessFunction {
+      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
+        getCategory_args args = new getCategory_args();
+        args.read(iprot);
+        iprot.readMessageEnd();
+        getCategory_result result = new getCategory_result();
+        result.success = iface_.getCategory(args.id);
-        oprot.writeMessageBegin(new TMessage("putCategoryObject", TMessageType.REPLY, seqid));
+        oprot.writeMessageBegin(new TMessage("getCategory", TMessageType.REPLY, seqid));
         result.write(oprot);
         oprot.writeMessageEnd();
         oprot.getTransport().flush();
+      }
+    }
-    private class getCategoryObject implements ProcessFunction {
+    private class getAllCategories implements ProcessFunction {
       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
-        getCategoryObject_args args = new getCategoryObject_args();
+        getAllCategories_args args = new getAllCategories_args();
         args.read(iprot);
         iprot.readMessageEnd();
-        getCategoryObject_result result = new getCategoryObject_result();
+        getAllCategories_result result = new getAllCategories_result();
-        result.success = iface_.getCategoryObject();
+        result.success = iface_.getAllCategories();
-        oprot.writeMessageBegin(new TMessage("getCategoryObject", TMessageType.REPLY, seqid));
+        oprot.writeMessageBegin(new TMessage("getAllCategories", TMessageType.REPLY, seqid));
         result.write(oprot);
         oprot.writeMessageEnd();
         oprot.getTransport().flush();
+      }
+              }
               break;
             case AVAILABILITY:
               if (field.type == TType.MAP) {
+                {
-                  TMap _map10 = iprot.readMapBegin();
+                  TMap _map14 = iprot.readMapBegin();
-                  this.availability = new HashMap<String,Long>(2*_map10.size);
+                  this.availability = new HashMap<String,Long>(2*_map14.size);
-                  for (int _i11 = 0; _i11 < _map10.size; ++_i11)
+                  for (int _i15 = 0; _i15 < _map14.size; ++_i15)
+                  {
-                    String _key12;
+                    String _key16;
-                    long _val13;
+                    long _val17;
-                    _key12 = iprot.readString();
+                    _key16 = iprot.readString();
-                    _val13 = iprot.readI64();
+                    _val17 = iprot.readI64();
-                    this.availability.put(_key12, _val13);
+                    this.availability.put(_key16, _val17);
+                  }
                   iprot.readMapEnd();
+                }
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+      }
       if (this.availability != null) {
         oprot.writeFieldBegin(AVAILABILITY_FIELD_DESC);
+        {
           oprot.writeMapBegin(new TMap(TType.STRING, TType.I64, this.availability.size()));
-          for (Map.Entry<String, Long> _iter14 : this.availability.entrySet())
+          for (Map.Entry<String, Long> _iter18 : this.availability.entrySet())
+          {
-            oprot.writeString(_iter14.getKey());
+            oprot.writeString(_iter18.getKey());
-            oprot.writeI64(_iter14.getValue());
+            oprot.writeI64(_iter18.getValue());
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }
         } else {
           switch (fieldId) {
             case SUCCESS:
               if (field.type == TType.LIST) {
+                {
-                  TList _list15 = iprot.readListBegin();
+                  TList _list19 = iprot.readListBegin();
-                  this.success = new ArrayList<Item>(_list15.size);
+                  this.success = new ArrayList<Item>(_list19.size);
-                  for (int _i16 = 0; _i16 < _list15.size; ++_i16)
+                  for (int _i20 = 0; _i20 < _list19.size; ++_i20)
+                  {
-                    Item _elem17;
+                    Item _elem21;
-                    _elem17 = new Item();
+                    _elem21 = new Item();
-                    _elem17.read(iprot);
+                    _elem21.read(iprot);
-                    this.success.add(_elem17);
+                    this.success.add(_elem21);
+                  }
                   iprot.readListEnd();
+                }
               } else {
                 TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (Item _iter18 : this.success)
+          for (Item _iter22 : this.success)
+          {
-            _iter18.write(oprot);
+            _iter22.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetCex()) {
         } else {
           switch (fieldId) {
             case SUCCESS:
               if (field.type == TType.LIST) {
+                {
-                  TList _list19 = iprot.readListBegin();
+                  TList _list23 = iprot.readListBegin();
-                  this.success = new ArrayList<Item>(_list19.size);
+                  this.success = new ArrayList<Item>(_list23.size);
-                  for (int _i20 = 0; _i20 < _list19.size; ++_i20)
+                  for (int _i24 = 0; _i24 < _list23.size; ++_i24)
+                  {
-                    Item _elem21;
+                    Item _elem25;
-                    _elem21 = new Item();
+                    _elem25 = new Item();
-                    _elem21.read(iprot);
+                    _elem25.read(iprot);
-                    this.success.add(_elem21);
+                    this.success.add(_elem25);
+                  }
                   iprot.readListEnd();
+                }
               } else {
                 TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (Item _iter22 : this.success)
+          for (Item _iter26 : this.success)
+          {
-            _iter22.write(oprot);
+            _iter26.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetCex()) {
         } else {
           switch (fieldId) {
             case SUCCESS:
               if (field.type == TType.LIST) {
+                {
-                  TList _list23 = iprot.readListBegin();
+                  TList _list27 = iprot.readListBegin();
-                  this.success = new ArrayList<Item>(_list23.size);
+                  this.success = new ArrayList<Item>(_list27.size);
-                  for (int _i24 = 0; _i24 < _list23.size; ++_i24)
+                  for (int _i28 = 0; _i28 < _list27.size; ++_i28)
+                  {
-                    Item _elem25;
+                    Item _elem29;
-                    _elem25 = new Item();
+                    _elem29 = new Item();
-                    _elem25.read(iprot);
+                    _elem29.read(iprot);
-                    this.success.add(_elem25);
+                    this.success.add(_elem29);
+                  }
                   iprot.readListEnd();
+                }
               } else {
                 TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (Item _iter26 : this.success)
+          for (Item _iter30 : this.success)
+          {
-            _iter26.write(oprot);
+            _iter30.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetCex()) {
         } else {
           switch (fieldId) {
             case SUCCESS:
               if (field.type == TType.LIST) {
+                {
-                  TList _list27 = iprot.readListBegin();
+                  TList _list31 = iprot.readListBegin();
-                  this.success = new ArrayList<Long>(_list27.size);
+                  this.success = new ArrayList<Long>(_list31.size);
-                  for (int _i28 = 0; _i28 < _list27.size; ++_i28)
+                  for (int _i32 = 0; _i32 < _list31.size; ++_i32)
+                  {
-                    long _elem29;
+                    long _elem33;
-                    _elem29 = iprot.readI64();
+                    _elem33 = iprot.readI64();
-                    this.success.add(_elem29);
+                    this.success.add(_elem33);
+                  }
                   iprot.readListEnd();
+                }
               } else {
                 TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new TList(TType.I64, this.success.size()));
-          for (long _iter30 : this.success)
+          for (long _iter34 : this.success)
+          {
-            oprot.writeI64(_iter30);
+            oprot.writeI64(_iter34);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetIsex()) {
         } else {
           switch (fieldId) {
             case SUCCESS:
               if (field.type == TType.LIST) {
+                {
-                  TList _list31 = iprot.readListBegin();
+                  TList _list35 = iprot.readListBegin();
-                  this.success = new ArrayList<Warehouse>(_list31.size);
+                  this.success = new ArrayList<Warehouse>(_list35.size);
-                  for (int _i32 = 0; _i32 < _list31.size; ++_i32)
+                  for (int _i36 = 0; _i36 < _list35.size; ++_i36)
+                  {
-                    Warehouse _elem33;
+                    Warehouse _elem37;
-                    _elem33 = new Warehouse();
+                    _elem37 = new Warehouse();
-                    _elem33.read(iprot);
+                    _elem37.read(iprot);
-                    this.success.add(_elem33);
+                    this.success.add(_elem37);
+                  }
                   iprot.readListEnd();
+                }
               } else {
                 TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (Warehouse _iter34 : this.success)
+          for (Warehouse _iter38 : this.success)
+          {
-            _iter34.write(oprot);
+            _iter38.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetCex()) {
         } else {
           switch (fieldId) {
             case SUCCESS:
               if (field.type == TType.LIST) {
+                {
-                  TList _list35 = iprot.readListBegin();
+                  TList _list39 = iprot.readListBegin();
-                  this.success = new ArrayList<Warehouse>(_list35.size);
+                  this.success = new ArrayList<Warehouse>(_list39.size);
-                  for (int _i36 = 0; _i36 < _list35.size; ++_i36)
+                  for (int _i40 = 0; _i40 < _list39.size; ++_i40)
+                  {
-                    Warehouse _elem37;
+                    Warehouse _elem41;
-                    _elem37 = new Warehouse();
+                    _elem41 = new Warehouse();
-                    _elem37.read(iprot);
+                    _elem41.read(iprot);
-                    this.success.add(_elem37);
+                    this.success.add(_elem41);
+                  }
                   iprot.readListEnd();
+                }
               } else {
                 TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (Warehouse _iter38 : this.success)
+          for (Warehouse _iter42 : this.success)
+          {
-            _iter38.write(oprot);
+            _iter42.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetCex()) {
         } else {
           switch (fieldId) {
             case SUCCESS:
               if (field.type == TType.LIST) {
+                {
-                  TList _list39 = iprot.readListBegin();
+                  TList _list43 = iprot.readListBegin();
-                  this.success = new ArrayList<Item>(_list39.size);
+                  this.success = new ArrayList<Item>(_list43.size);
-                  for (int _i40 = 0; _i40 < _list39.size; ++_i40)
+                  for (int _i44 = 0; _i44 < _list43.size; ++_i44)
+                  {
-                    Item _elem41;
+                    Item _elem45;
-                    _elem41 = new Item();
+                    _elem45 = new Item();
-                    _elem41.read(iprot);
+                    _elem45.read(iprot);
-                    this.success.add(_elem41);
+                    this.success.add(_elem45);
+                  }
                   iprot.readListEnd();
+                }
               } else {
                 TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (Item _iter42 : this.success)
+          for (Item _iter46 : this.success)
+          {
-            _iter42.write(oprot);
+            _iter46.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetCex()) {
         } else {
           switch (fieldId) {
             case SUCCESS:
               if (field.type == TType.LIST) {
+                {
-                  TList _list43 = iprot.readListBegin();
+                  TList _list47 = iprot.readListBegin();
-                  this.success = new ArrayList<Item>(_list43.size);
+                  this.success = new ArrayList<Item>(_list47.size);
-                  for (int _i44 = 0; _i44 < _list43.size; ++_i44)
+                  for (int _i48 = 0; _i48 < _list47.size; ++_i48)
+                  {
-                    Item _elem45;
+                    Item _elem49;
-                    _elem45 = new Item();
+                    _elem49 = new Item();
-                    _elem45.read(iprot);
+                    _elem49.read(iprot);
-                    this.success.add(_elem45);
+                    this.success.add(_elem49);
+                  }
                   iprot.readListEnd();
+                }
               } else {
                 TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (Item _iter46 : this.success)
+          for (Item _iter50 : this.success)
+          {
-            _iter46.write(oprot);
+            _iter50.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetIsex()) {
         } else {
           switch (fieldId) {
             case SUCCESS:
               if (field.type == TType.LIST) {
+                {
-                  TList _list47 = iprot.readListBegin();
+                  TList _list51 = iprot.readListBegin();
-                  this.success = new ArrayList<Long>(_list47.size);
+                  this.success = new ArrayList<Long>(_list51.size);
-                  for (int _i48 = 0; _i48 < _list47.size; ++_i48)
+                  for (int _i52 = 0; _i52 < _list51.size; ++_i52)
+                  {
-                    long _elem49;
+                    long _elem53;
-                    _elem49 = iprot.readI64();
+                    _elem53 = iprot.readI64();
-                    this.success.add(_elem49);
+                    this.success.add(_elem53);
+                  }
                   iprot.readListEnd();
+                }
               } else {
                 TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new TList(TType.I64, this.success.size()));
-          for (long _iter50 : this.success)
+          for (long _iter54 : this.success)
+          {
-            oprot.writeI64(_iter50);
+            oprot.writeI64(_iter54);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetCex()) {
         } else {
           switch (fieldId) {
             case SUCCESS:
               if (field.type == TType.LIST) {
+                {
-                  TList _list51 = iprot.readListBegin();
+                  TList _list55 = iprot.readListBegin();
-                  this.success = new ArrayList<Item>(_list51.size);
+                  this.success = new ArrayList<Item>(_list55.size);
-                  for (int _i52 = 0; _i52 < _list51.size; ++_i52)
+                  for (int _i56 = 0; _i56 < _list55.size; ++_i56)
+                  {
-                    Item _elem53;
+                    Item _elem57;
-                    _elem53 = new Item();
+                    _elem57 = new Item();
-                    _elem53.read(iprot);
+                    _elem57.read(iprot);
-                    this.success.add(_elem53);
+                    this.success.add(_elem57);
+                  }
                   iprot.readListEnd();
+                }
               } else {
                 TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (Item _iter54 : this.success)
+          for (Item _iter58 : this.success)
+          {
-            _iter54.write(oprot);
+            _iter58.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetIsex()) {
         } else {
           switch (fieldId) {
             case SUCCESS:
               if (field.type == TType.LIST) {
+                {
-                  TList _list55 = iprot.readListBegin();
+                  TList _list59 = iprot.readListBegin();
-                  this.success = new ArrayList<Long>(_list55.size);
+                  this.success = new ArrayList<Long>(_list59.size);
-                  for (int _i56 = 0; _i56 < _list55.size; ++_i56)
+                  for (int _i60 = 0; _i60 < _list59.size; ++_i60)
+                  {
-                    long _elem57;
+                    long _elem61;
-                    _elem57 = iprot.readI64();
+                    _elem61 = iprot.readI64();
-                    this.success.add(_elem57);
+                    this.success.add(_elem61);
+                  }
                   iprot.readListEnd();
+                }
               } else {
                 TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new TList(TType.I64, this.success.size()));
-          for (long _iter58 : this.success)
+          for (long _iter62 : this.success)
+          {
-            oprot.writeI64(_iter58);
+            oprot.writeI64(_iter62);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetCex()) {
         } else {
           switch (fieldId) {
             case SUCCESS:
               if (field.type == TType.LIST) {
+                {
-                  TList _list59 = iprot.readListBegin();
+                  TList _list63 = iprot.readListBegin();
-                  this.success = new ArrayList<Item>(_list59.size);
+                  this.success = new ArrayList<Item>(_list63.size);
-                  for (int _i60 = 0; _i60 < _list59.size; ++_i60)
+                  for (int _i64 = 0; _i64 < _list63.size; ++_i64)
+                  {
-                    Item _elem61;
+                    Item _elem65;
-                    _elem61 = new Item();
+                    _elem65 = new Item();
-                    _elem61.read(iprot);
+                    _elem65.read(iprot);
-                    this.success.add(_elem61);
+                    this.success.add(_elem65);
+                  }
                   iprot.readListEnd();
+                }
               } else {
                 TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (Item _iter62 : this.success)
+          for (Item _iter66 : this.success)
+          {
-            _iter62.write(oprot);
+            _iter66.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetIsex()) {
         } else {
           switch (fieldId) {
             case SUCCESS:
               if (field.type == TType.LIST) {
+                {
-                  TList _list63 = iprot.readListBegin();
+                  TList _list67 = iprot.readListBegin();
-                  this.success = new ArrayList<Long>(_list63.size);
+                  this.success = new ArrayList<Long>(_list67.size);
-                  for (int _i64 = 0; _i64 < _list63.size; ++_i64)
+                  for (int _i68 = 0; _i68 < _list67.size; ++_i68)
+                  {
-                    long _elem65;
+                    long _elem69;
-                    _elem65 = iprot.readI64();
+                    _elem69 = iprot.readI64();
-                    this.success.add(_elem65);
+                    this.success.add(_elem69);
+                  }
                   iprot.readListEnd();
+                }
               } else {
                 TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new TList(TType.I64, this.success.size()));
-          for (long _iter66 : this.success)
+          for (long _iter70 : this.success)
+          {
-            oprot.writeI64(_iter66);
+            oprot.writeI64(_iter70);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetCex()) {
       // check for required fields
+    }
+  }
-  public static class putCategoryObject_args implements TBase<putCategoryObject_args._Fields>, java.io.Serializable, Cloneable, Comparable<putCategoryObject_args>   {
+  public static class addCategory_args implements TBase<addCategory_args._Fields>, java.io.Serializable, Cloneable, Comparable<addCategory_args>   {
-    private static final TStruct STRUCT_DESC = new TStruct("putCategoryObject_args");
+    private static final TStruct STRUCT_DESC = new TStruct("addCategory_args");
-    private static final TField OBJECT_FIELD_DESC = new TField("object", TType.STRING, (short)1);
+    private static final TField CATEGORY_FIELD_DESC = new TField("category", TType.STRUCT, (short)1);
-    private byte[] object;
+    private Category category;
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     public enum _Fields implements TFieldIdEnum {
-      OBJECT((short)1, "object");
+      CATEGORY((short)1, "category");
       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
       static {
+    }
     // isset id assignments
     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
-      put(_Fields.OBJECT, new FieldMetaData("object", TFieldRequirementType.DEFAULT,
+      put(_Fields.CATEGORY, new FieldMetaData("category", TFieldRequirementType.DEFAULT,
-          new FieldValueMetaData(TType.STRING)));
+          new StructMetaData(TType.STRUCT, Category.class)));
     }});
     static {
-      FieldMetaData.addStructMetaDataMap(putCategoryObject_args.class, metaDataMap);
+      FieldMetaData.addStructMetaDataMap(addCategory_args.class, metaDataMap);
+    }
-    public putCategoryObject_args() {
+    public addCategory_args() {
+    }
-    public putCategoryObject_args(
+    public addCategory_args(
-      byte[] object)
+      Category category)
+    {
       this();
-      this.object = object;
+      this.category = category;
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public putCategoryObject_args(putCategoryObject_args other) {
+    public addCategory_args(addCategory_args other) {
-      if (other.isSetObject()) {
+      if (other.isSetCategory()) {
-        this.object = new byte[other.object.length];
+        this.category = new Category(other.category);
-        System.arraycopy(other.object, 0, object, 0, other.object.length);
+      }
+    }
-    public putCategoryObject_args deepCopy() {
+    public addCategory_args deepCopy() {
-      return new putCategoryObject_args(this);
+      return new addCategory_args(this);
+    }
     @Deprecated
-    public putCategoryObject_args clone() {
+    public addCategory_args clone() {
-      return new putCategoryObject_args(this);
+      return new addCategory_args(this);
+    }
-    public byte[] getObject() {
+    public Category getCategory() {
-      return this.object;
+      return this.category;
+    }
-    public putCategoryObject_args setObject(byte[] object) {
+    public addCategory_args setCategory(Category category) {
-      this.object = object;
+      this.category = category;
       return this;
+    }
-    public void unsetObject() {
+    public void unsetCategory() {
-      this.object = null;
+      this.category = null;
+    }
-    /** Returns true if field object is set (has been asigned a value) and false otherwise */
+    /** Returns true if field category is set (has been asigned a value) and false otherwise */
-    public boolean isSetObject() {
+    public boolean isSetCategory() {
-      return this.object != null;
+      return this.category != null;
+    }
-    public void setObjectIsSet(boolean value) {
+    public void setCategoryIsSet(boolean value) {
       if (!value) {
-        this.object = null;
+        this.category = null;
+      }
+    }
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
-      case OBJECT:
+      case CATEGORY:
         if (value == null) {
-          unsetObject();
+          unsetCategory();
         } else {
-          setObject((byte[])value);
+          setCategory((Category)value);
+        }
         break;
+      }
+    }
       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
     public Object getFieldValue(_Fields field) {
       switch (field) {
-      case OBJECT:
+      case CATEGORY:
-        return getObject();
+        return getCategory();
+      }
       throw new IllegalStateException();
+    }
+    }
     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
     public boolean isSet(_Fields field) {
       switch (field) {
-      case OBJECT:
+      case CATEGORY:
-        return isSetObject();
+        return isSetCategory();
+      }
       throw new IllegalStateException();
+    }
     public boolean isSet(int fieldID) {
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof putCategoryObject_args)
+      if (that instanceof addCategory_args)
-        return this.equals((putCategoryObject_args)that);
+        return this.equals((addCategory_args)that);
       return false;
+    }
-    public boolean equals(putCategoryObject_args that) {
+    public boolean equals(addCategory_args that) {
       if (that == null)
         return false;
-      boolean this_present_object = true && this.isSetObject();
+      boolean this_present_category = true && this.isSetCategory();
-      boolean that_present_object = true && that.isSetObject();
+      boolean that_present_category = true && that.isSetCategory();
-      if (this_present_object || that_present_object) {
+      if (this_present_category || that_present_category) {
-        if (!(this_present_object && that_present_object))
+        if (!(this_present_category && that_present_category))
           return false;
-        if (!java.util.Arrays.equals(this.object, that.object))
+        if (!this.category.equals(that.category))
           return false;
+      }
       return true;
+    }
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(putCategoryObject_args other) {
+    public int compareTo(addCategory_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
+      }
       int lastComparison = 0;
-      putCategoryObject_args typedOther = (putCategoryObject_args)other;
+      addCategory_args typedOther = (addCategory_args)other;
-      lastComparison = Boolean.valueOf(isSetObject()).compareTo(isSetObject());
+      lastComparison = Boolean.valueOf(isSetCategory()).compareTo(isSetCategory());
       if (lastComparison != 0) {
         return lastComparison;
+      }
-      lastComparison = TBaseHelper.compareTo(object, typedOther.object);
+      lastComparison = TBaseHelper.compareTo(category, typedOther.category);
       if (lastComparison != 0) {
         return lastComparison;
+      }
       return 0;
+    }
         _Fields fieldId = _Fields.findByThriftId(field.id);
         if (fieldId == null) {
           TProtocolUtil.skip(iprot, field.type);
         } else {
           switch (fieldId) {
-            case OBJECT:
+            case CATEGORY:
-              if (field.type == TType.STRING) {
+              if (field.type == TType.STRUCT) {
+                this.category = new Category();
-                this.object = iprot.readBinary();
+                this.category.read(iprot);
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
+          }
     public void write(TProtocol oprot) throws TException {
       validate();
       oprot.writeStructBegin(STRUCT_DESC);
-      if (this.object != null) {
+      if (this.category != null) {
-        oprot.writeFieldBegin(OBJECT_FIELD_DESC);
+        oprot.writeFieldBegin(CATEGORY_FIELD_DESC);
-        oprot.writeBinary(this.object);
+        this.category.write(oprot);
         oprot.writeFieldEnd();
+      }
       oprot.writeFieldStop();
       oprot.writeStructEnd();
+    }
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder("putCategoryObject_args(");
+      StringBuilder sb = new StringBuilder("addCategory_args(");
       boolean first = true;
-      sb.append("object:");
+      sb.append("category:");
-      if (this.object == null) {
+      if (this.category == null) {
         sb.append("null");
       } else {
-          int __object_size = Math.min(this.object.length, 128);
-          for (int i = 0; i < __object_size; i++) {
-            if (i != 0) sb.append(" ");
+        sb.append(this.category);
-            sb.append(Integer.toHexString(this.object[i]).length() > 1 ? Integer.toHexString(this.object[i]).substring(Integer.toHexString(this.object[i]).length() - 2).toUpperCase() : "0" + Integer.toHexString(this.object[i]).toUpperCase());
-          }
-          if (this.object.length > 128) sb.append(" ...");
+      }
       first = false;
       sb.append(")");
       return sb.toString();
+    }
       // check for required fields
+    }
+  }
-  public static class putCategoryObject_result implements TBase<putCategoryObject_result._Fields>, java.io.Serializable, Cloneable, Comparable<putCategoryObject_result>   {
+  public static class addCategory_result implements TBase<addCategory_result._Fields>, java.io.Serializable, Cloneable, Comparable<addCategory_result>   {
-    private static final TStruct STRUCT_DESC = new TStruct("putCategoryObject_result");
+    private static final TStruct STRUCT_DESC = new TStruct("addCategory_result");
     private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.BOOL, (short)0);
     private boolean success;
       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
           new FieldValueMetaData(TType.BOOL)));
     }});
     static {
-      FieldMetaData.addStructMetaDataMap(putCategoryObject_result.class, metaDataMap);
+      FieldMetaData.addStructMetaDataMap(addCategory_result.class, metaDataMap);
+    }
-    public putCategoryObject_result() {
+    public addCategory_result() {
+    }
-    public putCategoryObject_result(
+    public addCategory_result(
       boolean success)
+    {
       this();
       this.success = success;
       setSuccessIsSet(true);
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public putCategoryObject_result(putCategoryObject_result other) {
+    public addCategory_result(addCategory_result other) {
       __isset_bit_vector.clear();
       __isset_bit_vector.or(other.__isset_bit_vector);
       this.success = other.success;
+    }
-    public putCategoryObject_result deepCopy() {
+    public addCategory_result deepCopy() {
-      return new putCategoryObject_result(this);
+      return new addCategory_result(this);
+    }
     @Deprecated
-    public putCategoryObject_result clone() {
+    public addCategory_result clone() {
-      return new putCategoryObject_result(this);
+      return new addCategory_result(this);
+    }
     public boolean isSuccess() {
       return this.success;
+    }
-    public putCategoryObject_result setSuccess(boolean success) {
+    public addCategory_result setSuccess(boolean success) {
       this.success = success;
       setSuccessIsSet(true);
       return this;
+    }
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof putCategoryObject_result)
+      if (that instanceof addCategory_result)
-        return this.equals((putCategoryObject_result)that);
+        return this.equals((addCategory_result)that);
       return false;
+    }
-    public boolean equals(putCategoryObject_result that) {
+    public boolean equals(addCategory_result that) {
       if (that == null)
         return false;
       boolean this_present_success = true;
       boolean that_present_success = true;
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(putCategoryObject_result other) {
+    public int compareTo(addCategory_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
+      }
       int lastComparison = 0;
-      putCategoryObject_result typedOther = (putCategoryObject_result)other;
+      addCategory_result typedOther = (addCategory_result)other;
       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
       if (lastComparison != 0) {
         return lastComparison;
+      }
       oprot.writeStructEnd();
+    }
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder("putCategoryObject_result(");
+      StringBuilder sb = new StringBuilder("addCategory_result(");
       boolean first = true;
       sb.append("success:");
       sb.append(this.success);
       first = false;
       // check for required fields
+    }
+  }
-  public static class getCategoryObject_args implements TBase<getCategoryObject_args._Fields>, java.io.Serializable, Cloneable, Comparable<getCategoryObject_args>   {
+  public static class getCategory_args implements TBase<getCategory_args._Fields>, java.io.Serializable, Cloneable, Comparable<getCategory_args>   {
-    private static final TStruct STRUCT_DESC = new TStruct("getCategoryObject_args");
+    private static final TStruct STRUCT_DESC = new TStruct("getCategory_args");
+    private static final TField ID_FIELD_DESC = new TField("id", TType.I64, (short)1);
+    private long id;
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     public enum _Fields implements TFieldIdEnum {
-;
+      ID((short)1, "id");
       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
       static {
       public String getFieldName() {
         return _fieldName;
+      }
+    }
+    // isset id assignments
+    private static final int __ID_ISSET_ID = 0;
+    private BitSet __isset_bit_vector = new BitSet(1);
     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
+      put(_Fields.ID, new FieldMetaData("id", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.I64)));
     }});
     static {
-      FieldMetaData.addStructMetaDataMap(getCategoryObject_args.class, metaDataMap);
+      FieldMetaData.addStructMetaDataMap(getCategory_args.class, metaDataMap);
+    }
-    public getCategoryObject_args() {
+    public getCategory_args() {
+    }
+    public getCategory_args(
+      long id)
+    {
+      this();
+      this.id = id;
+      setIdIsSet(true);
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public getCategoryObject_args(getCategoryObject_args other) {
+    public getCategory_args(getCategory_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.id = other.id;
+    }
-    public getCategoryObject_args deepCopy() {
+    public getCategory_args deepCopy() {
-      return new getCategoryObject_args(this);
+      return new getCategory_args(this);
+    }
     @Deprecated
-    public getCategoryObject_args clone() {
+    public getCategory_args clone() {
-      return new getCategoryObject_args(this);
+      return new getCategory_args(this);
+    }
+    public long getId() {
+      return this.id;
+    }
+    public getCategory_args setId(long id) {
+      this.id = id;
+      setIdIsSet(true);
+      return this;
+    }
+    public void unsetId() {
+      __isset_bit_vector.clear(__ID_ISSET_ID);
+    }
+    /** Returns true if field id is set (has been asigned a value) and false otherwise */
+    public boolean isSetId() {
+      return __isset_bit_vector.get(__ID_ISSET_ID);
+    }
+    public void setIdIsSet(boolean value) {
+      __isset_bit_vector.set(__ID_ISSET_ID, value);
+    }
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
+      case ID:
+        if (value == null) {
+          unsetId();
+        } else {
+          setId((Long)value);
+        }
+        break;
+      }
+    }
     public void setFieldValue(int fieldID, Object value) {
       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
     public Object getFieldValue(_Fields field) {
       switch (field) {
+      case ID:
+        return new Long(getId());
+      }
       throw new IllegalStateException();
+    }
     public Object getFieldValue(int fieldId) {
+    }
     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
     public boolean isSet(_Fields field) {
       switch (field) {
+      case ID:
+        return isSetId();
+      }
       throw new IllegalStateException();
+    }
     public boolean isSet(int fieldID) {
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof getCategoryObject_args)
+      if (that instanceof getCategory_args)
-        return this.equals((getCategoryObject_args)that);
+        return this.equals((getCategory_args)that);
       return false;
+    }
-    public boolean equals(getCategoryObject_args that) {
+    public boolean equals(getCategory_args that) {
       if (that == null)
         return false;
+      boolean this_present_id = true;
+      boolean that_present_id = true;
+      if (this_present_id || that_present_id) {
+        if (!(this_present_id && that_present_id))
+          return false;
+        if (this.id != that.id)
+          return false;
+      }
       return true;
+    }
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(getCategoryObject_args other) {
+    public int compareTo(getCategory_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
+      }
       int lastComparison = 0;
-      getCategoryObject_args typedOther = (getCategoryObject_args)other;
+      getCategory_args typedOther = (getCategory_args)other;
+      lastComparison = Boolean.valueOf(isSetId()).compareTo(isSetId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(id, typedOther.id);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
       return 0;
+    }
     public void read(TProtocol iprot) throws TException {
       TField field;
         _Fields fieldId = _Fields.findByThriftId(field.id);
         if (fieldId == null) {
           TProtocolUtil.skip(iprot, field.type);
         } else {
           switch (fieldId) {
+            case ID:
+              if (field.type == TType.I64) {
+                this.id = iprot.readI64();
+                setIdIsSet(true);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+          }
           iprot.readFieldEnd();
+        }
+      }
       iprot.readStructEnd();
     public void write(TProtocol oprot) throws TException {
       validate();
       oprot.writeStructBegin(STRUCT_DESC);
+      oprot.writeFieldBegin(ID_FIELD_DESC);
+      oprot.writeI64(this.id);
+      oprot.writeFieldEnd();
       oprot.writeFieldStop();
       oprot.writeStructEnd();
+    }
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder("getCategoryObject_args(");
+      StringBuilder sb = new StringBuilder("getCategory_args(");
       boolean first = true;
+      sb.append("id:");
+      sb.append(this.id);
+      first = false;
       sb.append(")");
       return sb.toString();
+    }
     public void validate() throws TException {
       // check for required fields
+    }
+  }
-  public static class getCategoryObject_result implements TBase<getCategoryObject_result._Fields>, java.io.Serializable, Cloneable, Comparable<getCategoryObject_result>   {
+  public static class getCategory_result implements TBase<getCategory_result._Fields>, java.io.Serializable, Cloneable, Comparable<getCategory_result>   {
-    private static final TStruct STRUCT_DESC = new TStruct("getCategoryObject_result");
+    private static final TStruct STRUCT_DESC = new TStruct("getCategory_result");
-    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRING, (short)0);
+    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRUCT, (short)0);
-    private byte[] success;
+    private Category success;
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     public enum _Fields implements TFieldIdEnum {
       SUCCESS((short)0, "success");
     // isset id assignments
     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
       put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
-          new FieldValueMetaData(TType.STRING)));
+          new StructMetaData(TType.STRUCT, Category.class)));
     }});
     static {
-      FieldMetaData.addStructMetaDataMap(getCategoryObject_result.class, metaDataMap);
+      FieldMetaData.addStructMetaDataMap(getCategory_result.class, metaDataMap);
+    }
-    public getCategoryObject_result() {
+    public getCategory_result() {
+    }
-    public getCategoryObject_result(
+    public getCategory_result(
-      byte[] success)
+      Category success)
+    {
       this();
       this.success = success;
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public getCategoryObject_result(getCategoryObject_result other) {
+    public getCategory_result(getCategory_result other) {
       if (other.isSetSuccess()) {
-        this.success = new byte[other.success.length];
+        this.success = new Category(other.success);
-        System.arraycopy(other.success, 0, success, 0, other.success.length);
+      }
+    }
-    public getCategoryObject_result deepCopy() {
+    public getCategory_result deepCopy() {
-      return new getCategoryObject_result(this);
+      return new getCategory_result(this);
+    }
     @Deprecated
-    public getCategoryObject_result clone() {
+    public getCategory_result clone() {
-      return new getCategoryObject_result(this);
+      return new getCategory_result(this);
+    }
-    public byte[] getSuccess() {
+    public Category getSuccess() {
       return this.success;
+    }
-    public getCategoryObject_result setSuccess(byte[] success) {
+    public getCategory_result setSuccess(Category success) {
       this.success = success;
       return this;
+    }
     public void unsetSuccess() {
       switch (field) {
       case SUCCESS:
         if (value == null) {
           unsetSuccess();
         } else {
-          setSuccess((byte[])value);
+          setSuccess((Category)value);
+        }
         break;
+      }
+    }
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof getCategoryObject_result)
+      if (that instanceof getCategory_result)
-        return this.equals((getCategoryObject_result)that);
+        return this.equals((getCategory_result)that);
       return false;
+    }
-    public boolean equals(getCategoryObject_result that) {
+    public boolean equals(getCategory_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 (!java.util.Arrays.equals(this.success, that.success))
+        if (!this.success.equals(that.success))
           return false;
+      }
       return true;
+    }
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(getCategoryObject_result other) {
+    public int compareTo(getCategory_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
+      }
       int lastComparison = 0;
-      getCategoryObject_result typedOther = (getCategoryObject_result)other;
+      getCategory_result typedOther = (getCategory_result)other;
       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
       if (lastComparison != 0) {
         return lastComparison;
+      }
         if (fieldId == null) {
           TProtocolUtil.skip(iprot, field.type);
         } else {
           switch (fieldId) {
             case SUCCESS:
-              if (field.type == TType.STRING) {
+              if (field.type == TType.STRUCT) {
-                this.success = iprot.readBinary();
+                this.success = new Category();
+                this.success.read(iprot);
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
+          }
     public void write(TProtocol oprot) throws TException {
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
-        oprot.writeBinary(this.success);
+        this.success.write(oprot);
         oprot.writeFieldEnd();
+      }
       oprot.writeFieldStop();
       oprot.writeStructEnd();
+    }
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder("getCategoryObject_result(");
+      StringBuilder sb = new StringBuilder("getCategory_result(");
       boolean first = true;
       sb.append("success:");
       if (this.success == null) {
         sb.append("null");
       } else {
+        sb.append(this.success);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getAllCategories_args implements TBase<getAllCategories_args._Fields>, java.io.Serializable, Cloneable, Comparable<getAllCategories_args>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getAllCategories_args");
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements TFieldIdEnum {
+;
+      private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
+      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+      static {
+        for (_Fields field : EnumSet.allOf(_Fields.class)) {
+          byId.put((int)field._thriftId, field);
+          byName.put(field.getFieldName(), field);
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, or null if its not found.
+       */
+      public static _Fields findByThriftId(int fieldId) {
+        return byId.get(fieldId);
+      }
+      /**
+       * 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;
+      }
+    }
+    public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getAllCategories_args.class, metaDataMap);
+    }
+    public getAllCategories_args() {
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getAllCategories_args(getAllCategories_args other) {
+    }
+    public getAllCategories_args deepCopy() {
+      return new getAllCategories_args(this);
+    }
+    @Deprecated
+    public getAllCategories_args clone() {
+      return new getAllCategories_args(this);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      }
+      throw new IllegalStateException();
+    }
+    public Object getFieldValue(int fieldId) {
+      return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
+    }
+    /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
+    public boolean isSet(_Fields field) {
+      switch (field) {
+      }
+      throw new IllegalStateException();
+    }
+    public boolean isSet(int fieldID) {
+      return isSet(_Fields.findByThriftIdOrThrow(fieldID));
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof getAllCategories_args)
+        return this.equals((getAllCategories_args)that);
+      return false;
+    }
+    public boolean equals(getAllCategories_args that) {
+      if (that == null)
+        return false;
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getAllCategories_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getAllCategories_args typedOther = (getAllCategories_args)other;
+      return 0;
+    }
+    public void read(TProtocol iprot) throws TException {
+      TField field;
+      iprot.readStructBegin();
+      while (true)
+      {
+        field = iprot.readFieldBegin();
+        if (field.type == TType.STOP) {
+          break;
+        }
+        _Fields fieldId = _Fields.findByThriftId(field.id);
+        if (fieldId == null) {
+          TProtocolUtil.skip(iprot, field.type);
+        } else {
+          switch (fieldId) {
+          }
+          iprot.readFieldEnd();
+        }
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(TProtocol oprot) throws TException {
+      validate();
+      oprot.writeStructBegin(STRUCT_DESC);
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getAllCategories_args(");
+      boolean first = true;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws TException {
+      // check for required fields
+    }
+  }
+  public static class getAllCategories_result implements TBase<getAllCategories_result._Fields>, java.io.Serializable, Cloneable, Comparable<getAllCategories_result>   {
+    private static final TStruct STRUCT_DESC = new TStruct("getAllCategories_result");
+    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.LIST, (short)0);
+    private List<Category> success;
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements TFieldIdEnum {
+      SUCCESS((short)0, "success");
+      private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
+      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+      static {
+        for (_Fields field : EnumSet.allOf(_Fields.class)) {
+          byId.put((int)field._thriftId, field);
+          byName.put(field.getFieldName(), field);
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, or null if its not found.
+       */
+      public static _Fields findByThriftId(int fieldId) {
+        return byId.get(fieldId);
+      }
+      /**
+       * 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, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
+      put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT,
+          new ListMetaData(TType.LIST,
+              new StructMetaData(TType.STRUCT, Category.class))));
+    }});
+    static {
+      FieldMetaData.addStructMetaDataMap(getAllCategories_result.class, metaDataMap);
+    }
+    public getAllCategories_result() {
+    }
+    public getAllCategories_result(
+      List<Category> success)
+    {
+      this();
+      this.success = success;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getAllCategories_result(getAllCategories_result other) {
+      if (other.isSetSuccess()) {
+        List<Category> __this__success = new ArrayList<Category>();
+        for (Category other_element : other.success) {
+          __this__success.add(new Category(other_element));
+        }
+        this.success = __this__success;
+      }
+    }
+    public getAllCategories_result deepCopy() {
+      return new getAllCategories_result(this);
+    }
+    @Deprecated
+    public getAllCategories_result clone() {
+      return new getAllCategories_result(this);
+    }
+    public int getSuccessSize() {
+      return (this.success == null) ? 0 : this.success.size();
+    }
+    public java.util.Iterator<Category> getSuccessIterator() {
-          int __success_size = Math.min(this.success.length, 128);
+      return (this.success == null) ? null : this.success.iterator();
+    }
+    public void addToSuccess(Category elem) {
+      if (this.success == null) {
+        this.success = new ArrayList<Category>();
+      }
+      this.success.add(elem);
+    }
+    public List<Category> getSuccess() {
+      return this.success;
+    }
+    public getAllCategories_result setSuccess(List<Category> success) {
+      this.success = success;
+      return this;
+    }
+    public void unsetSuccess() {
+      this.success = null;
+    }
+    /** Returns true if field success is set (has been asigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return this.success != null;
+    }
+    public void setSuccessIsSet(boolean value) {
+      if (!value) {
+        this.success = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((List<Category>)value);
+        }
+        break;
+      }
+    }
+    public void setFieldValue(int fieldID, Object value) {
+      setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case SUCCESS:
+        return getSuccess();
+      }
+      throw new IllegalStateException();
+    }
+    public Object getFieldValue(int fieldId) {
+      return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
+    }
+    /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
+    public boolean isSet(_Fields field) {
+      switch (field) {
+      case SUCCESS:
+        return isSetSuccess();
+      }
+      throw new IllegalStateException();
+    }
+    public boolean isSet(int fieldID) {
+      return isSet(_Fields.findByThriftIdOrThrow(fieldID));
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof getAllCategories_result)
+        return this.equals((getAllCategories_result)that);
+      return false;
+    }
+    public boolean equals(getAllCategories_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;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getAllCategories_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getAllCategories_result typedOther = (getAllCategories_result)other;
+      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(isSetSuccess());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(success, typedOther.success);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      return 0;
+    }
+    public void read(TProtocol iprot) throws TException {
+      TField field;
+      iprot.readStructBegin();
+      while (true)
+      {
+        field = iprot.readFieldBegin();
+        if (field.type == TType.STOP) {
+          break;
+        }
+        _Fields fieldId = _Fields.findByThriftId(field.id);
+        if (fieldId == null) {
+          TProtocolUtil.skip(iprot, field.type);
+        } else {
+          switch (fieldId) {
+            case SUCCESS:
+              if (field.type == TType.LIST) {
+                {
+                  TList _list71 = iprot.readListBegin();
+                  this.success = new ArrayList<Category>(_list71.size);
-          for (int i = 0; i < __success_size; i++) {
+                  for (int _i72 = 0; _i72 < _list71.size; ++_i72)
+                  {
+                    Category _elem73;
+                    _elem73 = new Category();
-            if (i != 0) sb.append(" ");
+                    _elem73.read(iprot);
+                    this.success.add(_elem73);
+                  }
+                  iprot.readListEnd();
+                }
+              } else {
-            sb.append(Integer.toHexString(this.success[i]).length() > 1 ? Integer.toHexString(this.success[i]).substring(Integer.toHexString(this.success[i]).length() - 2).toUpperCase() : "0" + Integer.toHexString(this.success[i]).toUpperCase());
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+          }
+          iprot.readFieldEnd();
+        }
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(TProtocol oprot) throws TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
+          oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
+          for (Category _iter74 : this.success)
+          {
+            _iter74.write(oprot);
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getAllCategories_result(");
+      boolean first = true;
+      sb.append("success:");
-          if (this.success.length > 128) sb.append(" ...");
+      if (this.success == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.success);
+      }
       first = false;
       sb.append(")");
       return sb.toString();
+    }

Subversion Repositories SmartDukaan

(root)/trunk/ThriftConfig/src/main/java/in/shop2020/model/v1/catalog/InventoryService.java @ 1969 – Rev 1925 → 1968