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

     public void addOrUpdateAmazonInventoryForItem(AmazonInventorySnapshot amazonInventorySnapshot) throws org.apache.thrift.TException;
     public String getLastNdaySaleForItem(long itemId, long numberOfDays) throws org.apache.thrift.TException;
+    public void addUpdateHoldInventory(long itemId, long warehouseId, long holdQuantity, long source) throws org.apache.thrift.TException;
+  }
   public interface AsyncIface extends in.shop2020.generic.GenericService .AsyncIface {
     public void addWarehouse(Warehouse warehouse, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.addWarehouse_call> resultHandler) throws org.apache.thrift.TException;
     public void addOrUpdateAmazonInventoryForItem(AmazonInventorySnapshot amazonInventorySnapshot, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.addOrUpdateAmazonInventoryForItem_call> resultHandler) throws org.apache.thrift.TException;
     public void getLastNdaySaleForItem(long itemId, long numberOfDays, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getLastNdaySaleForItem_call> resultHandler) throws org.apache.thrift.TException;
+    public void addUpdateHoldInventory(long itemId, long warehouseId, long holdQuantity, long source, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.addUpdateHoldInventory_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() {}
         return result.success;
+      }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getLastNdaySaleForItem failed: unknown result");
+    }
+    public void addUpdateHoldInventory(long itemId, long warehouseId, long holdQuantity, long source) throws org.apache.thrift.TException
+    {
+      send_addUpdateHoldInventory(itemId, warehouseId, holdQuantity, source);
+      recv_addUpdateHoldInventory();
+    }
+    public void send_addUpdateHoldInventory(long itemId, long warehouseId, long holdQuantity, long source) throws org.apache.thrift.TException
+    {
+      addUpdateHoldInventory_args args = new addUpdateHoldInventory_args();
+      args.setItemId(itemId);
+      args.setWarehouseId(warehouseId);
+      args.setHoldQuantity(holdQuantity);
+      args.setSource(source);
+      sendBase("addUpdateHoldInventory", args);
+    }
+    public void recv_addUpdateHoldInventory() throws org.apache.thrift.TException
+    {
+      addUpdateHoldInventory_result result = new addUpdateHoldInventory_result();
+      receiveBase(result, "addUpdateHoldInventory");
+      return;
+    }
+  }
   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_getLastNdaySaleForItem();
+      }
+    }
+    public void addUpdateHoldInventory(long itemId, long warehouseId, long holdQuantity, long source, org.apache.thrift.async.AsyncMethodCallback<addUpdateHoldInventory_call> resultHandler) throws org.apache.thrift.TException {
+      checkReady();
+      addUpdateHoldInventory_call method_call = new addUpdateHoldInventory_call(itemId, warehouseId, holdQuantity, source, resultHandler, this, ___protocolFactory, ___transport);
+      this.___currentMethod = method_call;
+      ___manager.call(method_call);
+    }
+    public static class addUpdateHoldInventory_call extends org.apache.thrift.async.TAsyncMethodCall {
+      private long itemId;
+      private long warehouseId;
+      private long holdQuantity;
+      private long source;
+      public addUpdateHoldInventory_call(long itemId, long warehouseId, long holdQuantity, long source, org.apache.thrift.async.AsyncMethodCallback<addUpdateHoldInventory_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.warehouseId = warehouseId;
+        this.holdQuantity = holdQuantity;
+        this.source = source;
+      }
+      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("addUpdateHoldInventory", org.apache.thrift.protocol.TMessageType.CALL, 0));
+        addUpdateHoldInventory_args args = new addUpdateHoldInventory_args();
+        args.setItemId(itemId);
+        args.setWarehouseId(warehouseId);
+        args.setHoldQuantity(holdQuantity);
+        args.setSource(source);
+        args.write(prot);
+        prot.writeMessageEnd();
+      }
+      public void 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);
+        (new Client(prot)).recv_addUpdateHoldInventory();
+      }
+    }
+  }
   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("getWarehouseName", new getWarehouseName());
       processMap.put("getAmazonInventoryForItem", new getAmazonInventoryForItem());
       processMap.put("getAllAmazonInventory", new getAllAmazonInventory());
       processMap.put("addOrUpdateAmazonInventoryForItem", new addOrUpdateAmazonInventoryForItem());
       processMap.put("getLastNdaySaleForItem", new getLastNdaySaleForItem());
+      processMap.put("addUpdateHoldInventory", new addUpdateHoldInventory());
       return processMap;
+    }
     private static class addWarehouse<I extends Iface> extends org.apache.thrift.ProcessFunction<I, addWarehouse_args> {
       public addWarehouse() {
         result.success = iface.getLastNdaySaleForItem(args.itemId, args.numberOfDays);
         return result;
+      }
+    }
+    private static class addUpdateHoldInventory<I extends Iface> extends org.apache.thrift.ProcessFunction<I, addUpdateHoldInventory_args> {
+      public addUpdateHoldInventory() {
+        super("addUpdateHoldInventory");
+      }
+      protected addUpdateHoldInventory_args getEmptyArgsInstance() {
+        return new addUpdateHoldInventory_args();
+      }
+      protected addUpdateHoldInventory_result getResult(I iface, addUpdateHoldInventory_args args) throws org.apache.thrift.TException {
+        addUpdateHoldInventory_result result = new addUpdateHoldInventory_result();
+        iface.addUpdateHoldInventory(args.itemId, args.warehouseId, args.holdQuantity, args.source);
+        return result;
+      }
+    }
+  }
   public static class addWarehouse_args implements org.apache.thrift.TBase<addWarehouse_args, addWarehouse_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("addWarehouse_args");
+            }
             break;
           case 3: // AVAILABILITY
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map10 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map15 = iprot.readMapBegin();
-                this.availability = new HashMap<String,Long>(2*_map10.size);
+                this.availability = new HashMap<String,Long>(2*_map15.size);
-                for (int _i11 = 0; _i11 < _map10.size; ++_i11)
+                for (int _i16 = 0; _i16 < _map15.size; ++_i16)
+                {
-                  String _key12; // required
+                  String _key17; // required
-                  long _val13; // required
+                  long _val18; // required
-                  _key12 = iprot.readString();
+                  _key17 = iprot.readString();
-                  _val13 = iprot.readI64();
+                  _val18 = iprot.readI64();
-                  this.availability.put(_key12, _val13);
+                  this.availability.put(_key17, _val18);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+      }
       if (this.availability != null) {
         oprot.writeFieldBegin(AVAILABILITY_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I64, this.availability.size()));
-          for (Map.Entry<String, Long> _iter14 : this.availability.entrySet())
+          for (Map.Entry<String, Long> _iter19 : this.availability.entrySet())
+          {
-            oprot.writeString(_iter14.getKey());
+            oprot.writeString(_iter19.getKey());
-            oprot.writeI64(_iter14.getValue());
+            oprot.writeI64(_iter19.getValue());
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }
+            }
             break;
           case 3: // AVAILABILITY
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map15 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map20 = iprot.readMapBegin();
-                this.availability = new HashMap<String,Long>(2*_map15.size);
+                this.availability = new HashMap<String,Long>(2*_map20.size);
-                for (int _i16 = 0; _i16 < _map15.size; ++_i16)
+                for (int _i21 = 0; _i21 < _map20.size; ++_i21)
+                {
-                  String _key17; // required
+                  String _key22; // required
-                  long _val18; // required
+                  long _val23; // required
-                  _key17 = iprot.readString();
+                  _key22 = iprot.readString();
-                  _val18 = iprot.readI64();
+                  _val23 = iprot.readI64();
-                  this.availability.put(_key17, _val18);
+                  this.availability.put(_key22, _val23);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+      }
       if (this.availability != null) {
         oprot.writeFieldBegin(AVAILABILITY_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I64, this.availability.size()));
-          for (Map.Entry<String, Long> _iter19 : this.availability.entrySet())
+          for (Map.Entry<String, Long> _iter24 : this.availability.entrySet())
+          {
-            oprot.writeString(_iter19.getKey());
+            oprot.writeString(_iter24.getKey());
-            oprot.writeI64(_iter19.getValue());
+            oprot.writeI64(_iter24.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 _list20 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list25 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list20.size);
+                this.success = new ArrayList<Long>(_list25.size);
-                for (int _i21 = 0; _i21 < _list20.size; ++_i21)
+                for (int _i26 = 0; _i26 < _list25.size; ++_i26)
+                {
-                  long _elem22; // required
+                  long _elem27; // required
-                  _elem22 = iprot.readI64();
+                  _elem27 = iprot.readI64();
-                  this.success.add(_elem22);
+                  this.success.add(_elem27);
+                }
                 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 _iter23 : this.success)
+          for (long _iter28 : this.success)
+          {
-            oprot.writeI64(_iter23);
+            oprot.writeI64(_iter28);
+          }
           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 _list24 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list29 = iprot.readListBegin();
-                this.success = new ArrayList<Warehouse>(_list24.size);
+                this.success = new ArrayList<Warehouse>(_list29.size);
-                for (int _i25 = 0; _i25 < _list24.size; ++_i25)
+                for (int _i30 = 0; _i30 < _list29.size; ++_i30)
+                {
-                  Warehouse _elem26; // required
+                  Warehouse _elem31; // required
-                  _elem26 = new Warehouse();
+                  _elem31 = new Warehouse();
-                  _elem26.read(iprot);
+                  _elem31.read(iprot);
-                  this.success.add(_elem26);
+                  this.success.add(_elem31);
+                }
                 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 (Warehouse _iter27 : this.success)
+          for (Warehouse _iter32 : this.success)
+          {
-            _iter27.write(oprot);
+            _iter32.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 _list28 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list33 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list28.size);
+                this.success = new ArrayList<Long>(_list33.size);
-                for (int _i29 = 0; _i29 < _list28.size; ++_i29)
+                for (int _i34 = 0; _i34 < _list33.size; ++_i34)
+                {
-                  long _elem30; // required
+                  long _elem35; // required
-                  _elem30 = iprot.readI64();
+                  _elem35 = iprot.readI64();
-                  this.success.add(_elem30);
+                  this.success.add(_elem35);
+                }
                 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 _iter31 : this.success)
+          for (long _iter36 : this.success)
+          {
-            oprot.writeI64(_iter31);
+            oprot.writeI64(_iter36);
+          }
           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 _list32 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list37 = iprot.readListBegin();
-                this.success = new ArrayList<VendorItemPricing>(_list32.size);
+                this.success = new ArrayList<VendorItemPricing>(_list37.size);
-                for (int _i33 = 0; _i33 < _list32.size; ++_i33)
+                for (int _i38 = 0; _i38 < _list37.size; ++_i38)
+                {
-                  VendorItemPricing _elem34; // required
+                  VendorItemPricing _elem39; // required
-                  _elem34 = new VendorItemPricing();
+                  _elem39 = new VendorItemPricing();
-                  _elem34.read(iprot);
+                  _elem39.read(iprot);
-                  this.success.add(_elem34);
+                  this.success.add(_elem39);
+                }
                 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 (VendorItemPricing _iter35 : this.success)
+          for (VendorItemPricing _iter40 : this.success)
+          {
-            _iter35.write(oprot);
+            _iter40.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 _list36 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list41 = iprot.readListBegin();
-                this.success = new ArrayList<Vendor>(_list36.size);
+                this.success = new ArrayList<Vendor>(_list41.size);
-                for (int _i37 = 0; _i37 < _list36.size; ++_i37)
+                for (int _i42 = 0; _i42 < _list41.size; ++_i42)
+                {
-                  Vendor _elem38; // required
+                  Vendor _elem43; // required
-                  _elem38 = new Vendor();
+                  _elem43 = new Vendor();
-                  _elem38.read(iprot);
+                  _elem43.read(iprot);
-                  this.success.add(_elem38);
+                  this.success.add(_elem43);
+                }
                 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 (Vendor _iter39 : this.success)
+          for (Vendor _iter44 : this.success)
+          {
-            _iter39.write(oprot);
+            _iter44.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 _list40 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list45 = iprot.readListBegin();
-                this.success = new ArrayList<VendorItemMapping>(_list40.size);
+                this.success = new ArrayList<VendorItemMapping>(_list45.size);
-                for (int _i41 = 0; _i41 < _list40.size; ++_i41)
+                for (int _i46 = 0; _i46 < _list45.size; ++_i46)
+                {
-                  VendorItemMapping _elem42; // required
+                  VendorItemMapping _elem47; // required
-                  _elem42 = new VendorItemMapping();
+                  _elem47 = new VendorItemMapping();
-                  _elem42.read(iprot);
+                  _elem47.read(iprot);
-                  this.success.add(_elem42);
+                  this.success.add(_elem47);
+                }
                 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 (VendorItemMapping _iter43 : this.success)
+          for (VendorItemMapping _iter48 : this.success)
+          {
-            _iter43.write(oprot);
+            _iter48.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 _list44 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list49 = iprot.readListBegin();
-                this.success = new ArrayList<AvailableAndReservedStock>(_list44.size);
+                this.success = new ArrayList<AvailableAndReservedStock>(_list49.size);
-                for (int _i45 = 0; _i45 < _list44.size; ++_i45)
+                for (int _i50 = 0; _i50 < _list49.size; ++_i50)
+                {
-                  AvailableAndReservedStock _elem46; // required
+                  AvailableAndReservedStock _elem51; // required
-                  _elem46 = new AvailableAndReservedStock();
+                  _elem51 = new AvailableAndReservedStock();
-                  _elem46.read(iprot);
+                  _elem51.read(iprot);
-                  this.success.add(_elem46);
+                  this.success.add(_elem51);
+                }
                 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 (AvailableAndReservedStock _iter47 : this.success)
+          for (AvailableAndReservedStock _iter52 : this.success)
+          {
-            _iter47.write(oprot);
+            _iter52.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 _list48 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list53 = iprot.readListBegin();
-                this.success = new ArrayList<Warehouse>(_list48.size);
+                this.success = new ArrayList<Warehouse>(_list53.size);
-                for (int _i49 = 0; _i49 < _list48.size; ++_i49)
+                for (int _i54 = 0; _i54 < _list53.size; ++_i54)
+                {
-                  Warehouse _elem50; // required
+                  Warehouse _elem55; // required
-                  _elem50 = new Warehouse();
+                  _elem55 = new Warehouse();
-                  _elem50.read(iprot);
+                  _elem55.read(iprot);
-                  this.success.add(_elem50);
+                  this.success.add(_elem55);
+                }
                 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 (Warehouse _iter51 : this.success)
+          for (Warehouse _iter56 : this.success)
+          {
-            _iter51.write(oprot);
+            _iter56.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 _list52 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list57 = iprot.readListBegin();
-                this.success = new ArrayList<String>(_list52.size);
+                this.success = new ArrayList<String>(_list57.size);
-                for (int _i53 = 0; _i53 < _list52.size; ++_i53)
+                for (int _i58 = 0; _i58 < _list57.size; ++_i58)
+                {
-                  String _elem54; // required
+                  String _elem59; // required
-                  _elem54 = iprot.readString();
+                  _elem59 = iprot.readString();
-                  this.success.add(_elem54);
+                  this.success.add(_elem59);
+                }
                 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 _iter55 : this.success)
+          for (String _iter60 : this.success)
+          {
-            oprot.writeString(_iter55);
+            oprot.writeString(_iter60);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map56 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map61 = iprot.readMapBegin();
-                this.success = new HashMap<String,Map<Long,Long>>(2*_map56.size);
+                this.success = new HashMap<String,Map<Long,Long>>(2*_map61.size);
-                for (int _i57 = 0; _i57 < _map56.size; ++_i57)
+                for (int _i62 = 0; _i62 < _map61.size; ++_i62)
+                {
-                  String _key58; // required
+                  String _key63; // required
-                  Map<Long,Long> _val59; // required
+                  Map<Long,Long> _val64; // required
-                  _key58 = iprot.readString();
+                  _key63 = iprot.readString();
+                  {
-                    org.apache.thrift.protocol.TMap _map60 = iprot.readMapBegin();
+                    org.apache.thrift.protocol.TMap _map65 = iprot.readMapBegin();
-                    _val59 = new HashMap<Long,Long>(2*_map60.size);
+                    _val64 = new HashMap<Long,Long>(2*_map65.size);
-                    for (int _i61 = 0; _i61 < _map60.size; ++_i61)
+                    for (int _i66 = 0; _i66 < _map65.size; ++_i66)
+                    {
-                      long _key62; // required
+                      long _key67; // required
-                      long _val63; // required
+                      long _val68; // required
-                      _key62 = iprot.readI64();
+                      _key67 = iprot.readI64();
-                      _val63 = iprot.readI64();
+                      _val68 = iprot.readI64();
-                      _val59.put(_key62, _val63);
+                      _val64.put(_key67, _val68);
+                    }
                     iprot.readMapEnd();
+                  }
-                  this.success.put(_key58, _val59);
+                  this.success.put(_key63, _val64);
+                }
                 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.MAP, this.success.size()));
-          for (Map.Entry<String, Map<Long,Long>> _iter64 : this.success.entrySet())
+          for (Map.Entry<String, Map<Long,Long>> _iter69 : this.success.entrySet())
+          {
-            oprot.writeString(_iter64.getKey());
+            oprot.writeString(_iter69.getKey());
+            {
-              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.I64, _iter64.getValue().size()));
+              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.I64, _iter69.getValue().size()));
-              for (Map.Entry<Long, Long> _iter65 : _iter64.getValue().entrySet())
+              for (Map.Entry<Long, Long> _iter70 : _iter69.getValue().entrySet())
+              {
-                oprot.writeI64(_iter65.getKey());
+                oprot.writeI64(_iter70.getKey());
-                oprot.writeI64(_iter65.getValue());
+                oprot.writeI64(_iter70.getValue());
+              }
               oprot.writeMapEnd();
+            }
+          }
           oprot.writeMapEnd();
+        }
         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<Warehouse>(_list66.size);
+                this.success = new ArrayList<Warehouse>(_list71.size);
-                for (int _i67 = 0; _i67 < _list66.size; ++_i67)
+                for (int _i72 = 0; _i72 < _list71.size; ++_i72)
+                {
-                  Warehouse _elem68; // required
+                  Warehouse _elem73; // required
-                  _elem68 = new Warehouse();
+                  _elem73 = new Warehouse();
-                  _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 (Warehouse _iter69 : this.success)
+          for (Warehouse _iter74 : this.success)
+          {
-            _iter69.write(oprot);
+            _iter74.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 _list70 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list75 = iprot.readListBegin();
-                this.success = new ArrayList<VendorItemMapping>(_list70.size);
+                this.success = new ArrayList<VendorItemMapping>(_list75.size);
-                for (int _i71 = 0; _i71 < _list70.size; ++_i71)
+                for (int _i76 = 0; _i76 < _list75.size; ++_i76)
+                {
-                  VendorItemMapping _elem72; // required
+                  VendorItemMapping _elem77; // required
-                  _elem72 = new VendorItemMapping();
+                  _elem77 = new VendorItemMapping();
-                  _elem72.read(iprot);
+                  _elem77.read(iprot);
-                  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.STRUCT, this.success.size()));
-          for (VendorItemMapping _iter73 : this.success)
+          for (VendorItemMapping _iter78 : this.success)
+          {
-            _iter73.write(oprot);
+            _iter78.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 _map74 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map79 = iprot.readMapBegin();
-                this.success = new HashMap<Long,ItemInventory>(2*_map74.size);
+                this.success = new HashMap<Long,ItemInventory>(2*_map79.size);
-                for (int _i75 = 0; _i75 < _map74.size; ++_i75)
+                for (int _i80 = 0; _i80 < _map79.size; ++_i80)
+                {
-                  long _key76; // required
+                  long _key81; // required
-                  ItemInventory _val77; // required
+                  ItemInventory _val82; // required
-                  _key76 = iprot.readI64();
+                  _key81 = iprot.readI64();
-                  _val77 = new ItemInventory();
+                  _val82 = new ItemInventory();
-                  _val77.read(iprot);
+                  _val82.read(iprot);
-                  this.success.put(_key76, _val77);
+                  this.success.put(_key81, _val82);
+                }
                 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, ItemInventory> _iter78 : this.success.entrySet())
+          for (Map.Entry<Long, ItemInventory> _iter83 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter78.getKey());
+            oprot.writeI64(_iter83.getKey());
-            _iter78.getValue().write(oprot);
+            _iter83.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 _list79 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list84 = iprot.readListBegin();
-                this.item_ids = new ArrayList<Long>(_list79.size);
+                this.item_ids = new ArrayList<Long>(_list84.size);
-                for (int _i80 = 0; _i80 < _list79.size; ++_i80)
+                for (int _i85 = 0; _i85 < _list84.size; ++_i85)
+                {
-                  long _elem81; // required
+                  long _elem86; // required
-                  _elem81 = iprot.readI64();
+                  _elem86 = iprot.readI64();
-                  this.item_ids.add(_elem81);
+                  this.item_ids.add(_elem86);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.item_ids != null) {
         oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.item_ids.size()));
-          for (long _iter82 : this.item_ids)
+          for (long _iter87 : this.item_ids)
+          {
-            oprot.writeI64(_iter82);
+            oprot.writeI64(_iter87);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map83 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map88 = iprot.readMapBegin();
-                this.success = new HashMap<Long,Long>(2*_map83.size);
+                this.success = new HashMap<Long,Long>(2*_map88.size);
-                for (int _i84 = 0; _i84 < _map83.size; ++_i84)
+                for (int _i89 = 0; _i89 < _map88.size; ++_i89)
+                {
-                  long _key85; // required
+                  long _key90; // required
-                  long _val86; // required
+                  long _val91; // required
-                  _key85 = iprot.readI64();
+                  _key90 = iprot.readI64();
-                  _val86 = iprot.readI64();
+                  _val91 = iprot.readI64();
-                  this.success.put(_key85, _val86);
+                  this.success.put(_key90, _val91);
+                }
                 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.I64, this.success.size()));
-          for (Map.Entry<Long, Long> _iter87 : this.success.entrySet())
+          for (Map.Entry<Long, Long> _iter92 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter87.getKey());
+            oprot.writeI64(_iter92.getKey());
-            oprot.writeI64(_iter87.getValue());
+            oprot.writeI64(_iter92.getValue());
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // VENDOR_IDS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list88 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list93 = iprot.readListBegin();
-                this.vendorIds = new ArrayList<Long>(_list88.size);
+                this.vendorIds = new ArrayList<Long>(_list93.size);
-                for (int _i89 = 0; _i89 < _list88.size; ++_i89)
+                for (int _i94 = 0; _i94 < _list93.size; ++_i94)
+                {
-                  long _elem90; // required
+                  long _elem95; // required
-                  _elem90 = iprot.readI64();
+                  _elem95 = iprot.readI64();
-                  this.vendorIds.add(_elem90);
+                  this.vendorIds.add(_elem95);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.vendorIds != null) {
         oprot.writeFieldBegin(VENDOR_IDS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.vendorIds.size()));
-          for (long _iter91 : this.vendorIds)
+          for (long _iter96 : this.vendorIds)
+          {
-            oprot.writeI64(_iter91);
+            oprot.writeI64(_iter96);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list92 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list97 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list92.size);
+                this.success = new ArrayList<Long>(_list97.size);
-                for (int _i93 = 0; _i93 < _list92.size; ++_i93)
+                for (int _i98 = 0; _i98 < _list97.size; ++_i98)
+                {
-                  long _elem94; // required
+                  long _elem99; // required
-                  _elem94 = iprot.readI64();
+                  _elem99 = iprot.readI64();
-                  this.success.add(_elem94);
+                  this.success.add(_elem99);
+                }
                 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 _iter95 : this.success)
+          for (long _iter100 : this.success)
+          {
-            oprot.writeI64(_iter95);
+            oprot.writeI64(_iter100);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list96 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list101 = iprot.readListBegin();
-                this.success = new ArrayList<IgnoredInventoryUpdateItems>(_list96.size);
+                this.success = new ArrayList<IgnoredInventoryUpdateItems>(_list101.size);
-                for (int _i97 = 0; _i97 < _list96.size; ++_i97)
+                for (int _i102 = 0; _i102 < _list101.size; ++_i102)
+                {
-                  IgnoredInventoryUpdateItems _elem98; // required
+                  IgnoredInventoryUpdateItems _elem103; // required
-                  _elem98 = new IgnoredInventoryUpdateItems();
+                  _elem103 = new IgnoredInventoryUpdateItems();
-                  _elem98.read(iprot);
+                  _elem103.read(iprot);
-                  this.success.add(_elem98);
+                  this.success.add(_elem103);
+                }
                 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 (IgnoredInventoryUpdateItems _iter99 : this.success)
+          for (IgnoredInventoryUpdateItems _iter104 : this.success)
+          {
-            _iter99.write(oprot);
+            _iter104.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 _list100 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list105 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list100.size);
+                this.success = new ArrayList<Long>(_list105.size);
-                for (int _i101 = 0; _i101 < _list100.size; ++_i101)
+                for (int _i106 = 0; _i106 < _list105.size; ++_i106)
+                {
-                  long _elem102; // required
+                  long _elem107; // required
-                  _elem102 = iprot.readI64();
+                  _elem107 = iprot.readI64();
-                  this.success.add(_elem102);
+                  this.success.add(_elem107);
+                }
                 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 _iter103 : this.success)
+          for (long _iter108 : this.success)
+          {
-            oprot.writeI64(_iter103);
+            oprot.writeI64(_iter108);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // OOS_STATUS_MAP
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map104 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map109 = iprot.readMapBegin();
-                this.oosStatusMap = new HashMap<Long,Boolean>(2*_map104.size);
+                this.oosStatusMap = new HashMap<Long,Boolean>(2*_map109.size);
-                for (int _i105 = 0; _i105 < _map104.size; ++_i105)
+                for (int _i110 = 0; _i110 < _map109.size; ++_i110)
+                {
-                  long _key106; // required
+                  long _key111; // required
-                  boolean _val107; // required
+                  boolean _val112; // required
-                  _key106 = iprot.readI64();
+                  _key111 = iprot.readI64();
-                  _val107 = iprot.readBool();
+                  _val112 = iprot.readBool();
-                  this.oosStatusMap.put(_key106, _val107);
+                  this.oosStatusMap.put(_key111, _val112);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.oosStatusMap != null) {
         oprot.writeFieldBegin(OOS_STATUS_MAP_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.BOOL, this.oosStatusMap.size()));
-          for (Map.Entry<Long, Boolean> _iter108 : this.oosStatusMap.entrySet())
+          for (Map.Entry<Long, Boolean> _iter113 : this.oosStatusMap.entrySet())
+          {
-            oprot.writeI64(_iter108.getKey());
+            oprot.writeI64(_iter113.getKey());
-            oprot.writeBool(_iter108.getValue());
+            oprot.writeBool(_iter113.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 _list109 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list114 = iprot.readListBegin();
-                this.success = new ArrayList<OOSStatus>(_list109.size);
+                this.success = new ArrayList<OOSStatus>(_list114.size);
-                for (int _i110 = 0; _i110 < _list109.size; ++_i110)
+                for (int _i115 = 0; _i115 < _list114.size; ++_i115)
+                {
-                  OOSStatus _elem111; // required
+                  OOSStatus _elem116; // required
-                  _elem111 = new OOSStatus();
+                  _elem116 = new OOSStatus();
-                  _elem111.read(iprot);
+                  _elem116.read(iprot);
-                  this.success.add(_elem111);
+                  this.success.add(_elem116);
+                }
                 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 (OOSStatus _iter112 : this.success)
+          for (OOSStatus _iter117 : this.success)
+          {
-            _iter112.write(oprot);
+            _iter117.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 _list113 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list118 = iprot.readListBegin();
-                this.success = new ArrayList<ItemStockPurchaseParams>(_list113.size);
+                this.success = new ArrayList<ItemStockPurchaseParams>(_list118.size);
-                for (int _i114 = 0; _i114 < _list113.size; ++_i114)
+                for (int _i119 = 0; _i119 < _list118.size; ++_i119)
+                {
-                  ItemStockPurchaseParams _elem115; // required
+                  ItemStockPurchaseParams _elem120; // required
-                  _elem115 = new ItemStockPurchaseParams();
+                  _elem120 = new ItemStockPurchaseParams();
-                  _elem115.read(iprot);
+                  _elem120.read(iprot);
-                  this.success.add(_elem115);
+                  this.success.add(_elem120);
+                }
                 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 (ItemStockPurchaseParams _iter116 : this.success)
+          for (ItemStockPurchaseParams _iter121 : this.success)
+          {
-            _iter116.write(oprot);
+            _iter121.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 _list117 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list122 = iprot.readListBegin();
-                this.success = new ArrayList<AvailableAndReservedStock>(_list117.size);
+                this.success = new ArrayList<AvailableAndReservedStock>(_list122.size);
-                for (int _i118 = 0; _i118 < _list117.size; ++_i118)
+                for (int _i123 = 0; _i123 < _list122.size; ++_i123)
+                {
-                  AvailableAndReservedStock _elem119; // required
+                  AvailableAndReservedStock _elem124; // required
-                  _elem119 = new AvailableAndReservedStock();
+                  _elem124 = new AvailableAndReservedStock();
-                  _elem119.read(iprot);
+                  _elem124.read(iprot);
-                  this.success.add(_elem119);
+                  this.success.add(_elem124);
+                }
                 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 (AvailableAndReservedStock _iter120 : this.success)
+          for (AvailableAndReservedStock _iter125 : this.success)
+          {
-            _iter120.write(oprot);
+            _iter125.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 _list121 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list126 = iprot.readListBegin();
-                this.success = new ArrayList<AmazonInventorySnapshot>(_list121.size);
+                this.success = new ArrayList<AmazonInventorySnapshot>(_list126.size);
-                for (int _i122 = 0; _i122 < _list121.size; ++_i122)
+                for (int _i127 = 0; _i127 < _list126.size; ++_i127)
+                {
-                  AmazonInventorySnapshot _elem123; // required
+                  AmazonInventorySnapshot _elem128; // required
-                  _elem123 = new AmazonInventorySnapshot();
+                  _elem128 = new AmazonInventorySnapshot();
-                  _elem123.read(iprot);
+                  _elem128.read(iprot);
-                  this.success.add(_elem123);
+                  this.success.add(_elem128);
+                }
                 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 (AmazonInventorySnapshot _iter124 : this.success)
+          for (AmazonInventorySnapshot _iter129 : this.success)
+          {
-            _iter124.write(oprot);
+            _iter129.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
       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 addUpdateHoldInventory_args implements org.apache.thrift.TBase<addUpdateHoldInventory_args, addUpdateHoldInventory_args._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("addUpdateHoldInventory_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 WAREHOUSE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("warehouseId", org.apache.thrift.protocol.TType.I64, (short)2);
+    private static final org.apache.thrift.protocol.TField HOLD_QUANTITY_FIELD_DESC = new org.apache.thrift.protocol.TField("holdQuantity", org.apache.thrift.protocol.TType.I64, (short)3);
+    private static final org.apache.thrift.protocol.TField SOURCE_FIELD_DESC = new org.apache.thrift.protocol.TField("source", org.apache.thrift.protocol.TType.I64, (short)4);
+    private long itemId; // required
+    private long warehouseId; // required
+    private long holdQuantity; // required
+    private long source; // 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"),
+      WAREHOUSE_ID((short)2, "warehouseId"),
+      HOLD_QUANTITY((short)3, "holdQuantity"),
+      SOURCE((short)4, "source");
+      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: // WAREHOUSE_ID
+            return WAREHOUSE_ID;
+          case 3: // HOLD_QUANTITY
+            return HOLD_QUANTITY;
+          case 4: // SOURCE
+            return SOURCE;
+          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 __WAREHOUSEID_ISSET_ID = 1;
+    private static final int __HOLDQUANTITY_ISSET_ID = 2;
+    private static final int __SOURCE_ISSET_ID = 3;
+    private BitSet __isset_bit_vector = new BitSet(4);
+    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.WAREHOUSE_ID, new org.apache.thrift.meta_data.FieldMetaData("warehouseId", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      tmpMap.put(_Fields.HOLD_QUANTITY, new org.apache.thrift.meta_data.FieldMetaData("holdQuantity", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      tmpMap.put(_Fields.SOURCE, new org.apache.thrift.meta_data.FieldMetaData("source", 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(addUpdateHoldInventory_args.class, metaDataMap);
+    }
+    public addUpdateHoldInventory_args() {
+    }
+    public addUpdateHoldInventory_args(
+      long itemId,
+      long warehouseId,
+      long holdQuantity,
+      long source)
+    {
+      this();
+      this.itemId = itemId;
+      setItemIdIsSet(true);
+      this.warehouseId = warehouseId;
+      setWarehouseIdIsSet(true);
+      this.holdQuantity = holdQuantity;
+      setHoldQuantityIsSet(true);
+      this.source = source;
+      setSourceIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public addUpdateHoldInventory_args(addUpdateHoldInventory_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.itemId = other.itemId;
+      this.warehouseId = other.warehouseId;
+      this.holdQuantity = other.holdQuantity;
+      this.source = other.source;
+    }
+    public addUpdateHoldInventory_args deepCopy() {
+      return new addUpdateHoldInventory_args(this);
+    }
+    @Override
+    public void clear() {
+      setItemIdIsSet(false);
+      this.itemId = 0;
+      setWarehouseIdIsSet(false);
+      this.warehouseId = 0;
+      setHoldQuantityIsSet(false);
+      this.holdQuantity = 0;
+      setSourceIsSet(false);
+      this.source = 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 getWarehouseId() {
+      return this.warehouseId;
+    }
+    public void setWarehouseId(long warehouseId) {
+      this.warehouseId = warehouseId;
+      setWarehouseIdIsSet(true);
+    }
+    public void unsetWarehouseId() {
+      __isset_bit_vector.clear(__WAREHOUSEID_ISSET_ID);
+    }
+    /** Returns true if field warehouseId is set (has been assigned a value) and false otherwise */
+    public boolean isSetWarehouseId() {
+      return __isset_bit_vector.get(__WAREHOUSEID_ISSET_ID);
+    }
+    public void setWarehouseIdIsSet(boolean value) {
+      __isset_bit_vector.set(__WAREHOUSEID_ISSET_ID, value);
+    }
+    public long getHoldQuantity() {
+      return this.holdQuantity;
+    }
+    public void setHoldQuantity(long holdQuantity) {
+      this.holdQuantity = holdQuantity;
+      setHoldQuantityIsSet(true);
+    }
+    public void unsetHoldQuantity() {
+      __isset_bit_vector.clear(__HOLDQUANTITY_ISSET_ID);
+    }
+    /** Returns true if field holdQuantity is set (has been assigned a value) and false otherwise */
+    public boolean isSetHoldQuantity() {
+      return __isset_bit_vector.get(__HOLDQUANTITY_ISSET_ID);
+    }
+    public void setHoldQuantityIsSet(boolean value) {
+      __isset_bit_vector.set(__HOLDQUANTITY_ISSET_ID, value);
+    }
+    public long getSource() {
+      return this.source;
+    }
+    public void setSource(long source) {
+      this.source = source;
+      setSourceIsSet(true);
+    }
+    public void unsetSource() {
+      __isset_bit_vector.clear(__SOURCE_ISSET_ID);
+    }
+    /** Returns true if field source is set (has been assigned a value) and false otherwise */
+    public boolean isSetSource() {
+      return __isset_bit_vector.get(__SOURCE_ISSET_ID);
+    }
+    public void setSourceIsSet(boolean value) {
+      __isset_bit_vector.set(__SOURCE_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 WAREHOUSE_ID:
+        if (value == null) {
+          unsetWarehouseId();
+        } else {
+          setWarehouseId((Long)value);
+        }
+        break;
+      case HOLD_QUANTITY:
+        if (value == null) {
+          unsetHoldQuantity();
+        } else {
+          setHoldQuantity((Long)value);
+        }
+        break;
+      case SOURCE:
+        if (value == null) {
+          unsetSource();
+        } else {
+          setSource((Long)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case ITEM_ID:
+        return Long.valueOf(getItemId());
+      case WAREHOUSE_ID:
+        return Long.valueOf(getWarehouseId());
+      case HOLD_QUANTITY:
+        return Long.valueOf(getHoldQuantity());
+      case SOURCE:
+        return Long.valueOf(getSource());
+      }
+      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 WAREHOUSE_ID:
+        return isSetWarehouseId();
+      case HOLD_QUANTITY:
+        return isSetHoldQuantity();
+      case SOURCE:
+        return isSetSource();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof addUpdateHoldInventory_args)
+        return this.equals((addUpdateHoldInventory_args)that);
+      return false;
+    }
+    public boolean equals(addUpdateHoldInventory_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_warehouseId = true;
+      boolean that_present_warehouseId = true;
+      if (this_present_warehouseId || that_present_warehouseId) {
+        if (!(this_present_warehouseId && that_present_warehouseId))
+          return false;
+        if (this.warehouseId != that.warehouseId)
+          return false;
+      }
+      boolean this_present_holdQuantity = true;
+      boolean that_present_holdQuantity = true;
+      if (this_present_holdQuantity || that_present_holdQuantity) {
+        if (!(this_present_holdQuantity && that_present_holdQuantity))
+          return false;
+        if (this.holdQuantity != that.holdQuantity)
+          return false;
+      }
+      boolean this_present_source = true;
+      boolean that_present_source = true;
+      if (this_present_source || that_present_source) {
+        if (!(this_present_source && that_present_source))
+          return false;
+        if (this.source != that.source)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(addUpdateHoldInventory_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      addUpdateHoldInventory_args typedOther = (addUpdateHoldInventory_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(isSetWarehouseId()).compareTo(typedOther.isSetWarehouseId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetWarehouseId()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.warehouseId, typedOther.warehouseId);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetHoldQuantity()).compareTo(typedOther.isSetHoldQuantity());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetHoldQuantity()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.holdQuantity, typedOther.holdQuantity);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetSource()).compareTo(typedOther.isSetSource());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetSource()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.source, typedOther.source);
+        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: // WAREHOUSE_ID
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.warehouseId = iprot.readI64();
+              setWarehouseIdIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 3: // HOLD_QUANTITY
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.holdQuantity = iprot.readI64();
+              setHoldQuantityIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 4: // SOURCE
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.source = iprot.readI64();
+              setSourceIsSet(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(WAREHOUSE_ID_FIELD_DESC);
+      oprot.writeI64(this.warehouseId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(HOLD_QUANTITY_FIELD_DESC);
+      oprot.writeI64(this.holdQuantity);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(SOURCE_FIELD_DESC);
+      oprot.writeI64(this.source);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("addUpdateHoldInventory_args(");
+      boolean first = true;
+      sb.append("itemId:");
+      sb.append(this.itemId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("warehouseId:");
+      sb.append(this.warehouseId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("holdQuantity:");
+      sb.append(this.holdQuantity);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("source:");
+      sb.append(this.source);
+      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 addUpdateHoldInventory_result implements org.apache.thrift.TBase<addUpdateHoldInventory_result, addUpdateHoldInventory_result._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("addUpdateHoldInventory_result");
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+;
+      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) {
+          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;
+      }
+    }
+    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);
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(addUpdateHoldInventory_result.class, metaDataMap);
+    }
+    public addUpdateHoldInventory_result() {
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public addUpdateHoldInventory_result(addUpdateHoldInventory_result other) {
+    }
+    public addUpdateHoldInventory_result deepCopy() {
+      return new addUpdateHoldInventory_result(this);
+    }
+    @Override
+    public void clear() {
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      }
+      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) {
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof addUpdateHoldInventory_result)
+        return this.equals((addUpdateHoldInventory_result)that);
+      return false;
+    }
+    public boolean equals(addUpdateHoldInventory_result that) {
+      if (that == null)
+        return false;
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(addUpdateHoldInventory_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      addUpdateHoldInventory_result typedOther = (addUpdateHoldInventory_result)other;
+      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) {
+          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);
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("addUpdateHoldInventory_result(");
+      boolean first = true;
+      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 {

Subversion Repositories SmartDukaan

(root)/trunk/ThriftConfig/src/main/java/in/shop2020/model/v1/inventory/InventoryService.java – Rev 7972 → 8182