Subversion Repositories SmartDukaan

Rev

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

Rev 7972 Rev 8182
Line 331... Line 331...
331
 
331
 
332
    public void addOrUpdateAmazonInventoryForItem(AmazonInventorySnapshot amazonInventorySnapshot) throws org.apache.thrift.TException;
332
    public void addOrUpdateAmazonInventoryForItem(AmazonInventorySnapshot amazonInventorySnapshot) throws org.apache.thrift.TException;
333
 
333
 
334
    public String getLastNdaySaleForItem(long itemId, long numberOfDays) throws org.apache.thrift.TException;
334
    public String getLastNdaySaleForItem(long itemId, long numberOfDays) throws org.apache.thrift.TException;
335
 
335
 
-
 
336
    public void addUpdateHoldInventory(long itemId, long warehouseId, long holdQuantity, long source) throws org.apache.thrift.TException;
-
 
337
 
336
  }
338
  }
337
 
339
 
338
  public interface AsyncIface extends in.shop2020.generic.GenericService .AsyncIface {
340
  public interface AsyncIface extends in.shop2020.generic.GenericService .AsyncIface {
339
 
341
 
340
    public void addWarehouse(Warehouse warehouse, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.addWarehouse_call> resultHandler) throws org.apache.thrift.TException;
342
    public void addWarehouse(Warehouse warehouse, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.addWarehouse_call> resultHandler) throws org.apache.thrift.TException;
Line 447... Line 449...
447
 
449
 
448
    public void addOrUpdateAmazonInventoryForItem(AmazonInventorySnapshot amazonInventorySnapshot, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.addOrUpdateAmazonInventoryForItem_call> resultHandler) throws org.apache.thrift.TException;
450
    public void addOrUpdateAmazonInventoryForItem(AmazonInventorySnapshot amazonInventorySnapshot, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.addOrUpdateAmazonInventoryForItem_call> resultHandler) throws org.apache.thrift.TException;
449
 
451
 
450
    public void getLastNdaySaleForItem(long itemId, long numberOfDays, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getLastNdaySaleForItem_call> resultHandler) throws org.apache.thrift.TException;
452
    public void getLastNdaySaleForItem(long itemId, long numberOfDays, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getLastNdaySaleForItem_call> resultHandler) throws org.apache.thrift.TException;
451
 
453
 
-
 
454
    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;
-
 
455
 
452
  }
456
  }
453
 
457
 
454
  public static class Client extends in.shop2020.generic.GenericService.Client implements Iface {
458
  public static class Client extends in.shop2020.generic.GenericService.Client implements Iface {
455
    public static class Factory implements org.apache.thrift.TServiceClientFactory<Client> {
459
    public static class Factory implements org.apache.thrift.TServiceClientFactory<Client> {
456
      public Factory() {}
460
      public Factory() {}
Line 1817... Line 1821...
1817
        return result.success;
1821
        return result.success;
1818
      }
1822
      }
1819
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getLastNdaySaleForItem failed: unknown result");
1823
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getLastNdaySaleForItem failed: unknown result");
1820
    }
1824
    }
1821
 
1825
 
-
 
1826
    public void addUpdateHoldInventory(long itemId, long warehouseId, long holdQuantity, long source) throws org.apache.thrift.TException
-
 
1827
    {
-
 
1828
      send_addUpdateHoldInventory(itemId, warehouseId, holdQuantity, source);
-
 
1829
      recv_addUpdateHoldInventory();
-
 
1830
    }
-
 
1831
 
-
 
1832
    public void send_addUpdateHoldInventory(long itemId, long warehouseId, long holdQuantity, long source) throws org.apache.thrift.TException
-
 
1833
    {
-
 
1834
      addUpdateHoldInventory_args args = new addUpdateHoldInventory_args();
-
 
1835
      args.setItemId(itemId);
-
 
1836
      args.setWarehouseId(warehouseId);
-
 
1837
      args.setHoldQuantity(holdQuantity);
-
 
1838
      args.setSource(source);
-
 
1839
      sendBase("addUpdateHoldInventory", args);
-
 
1840
    }
-
 
1841
 
-
 
1842
    public void recv_addUpdateHoldInventory() throws org.apache.thrift.TException
-
 
1843
    {
-
 
1844
      addUpdateHoldInventory_result result = new addUpdateHoldInventory_result();
-
 
1845
      receiveBase(result, "addUpdateHoldInventory");
-
 
1846
      return;
-
 
1847
    }
-
 
1848
 
1822
  }
1849
  }
1823
  public static class AsyncClient extends in.shop2020.generic.GenericService.AsyncClient implements AsyncIface {
1850
  public static class AsyncClient extends in.shop2020.generic.GenericService.AsyncClient implements AsyncIface {
1824
    public static class Factory implements org.apache.thrift.async.TAsyncClientFactory<AsyncClient> {
1851
    public static class Factory implements org.apache.thrift.async.TAsyncClientFactory<AsyncClient> {
1825
      private org.apache.thrift.async.TAsyncClientManager clientManager;
1852
      private org.apache.thrift.async.TAsyncClientManager clientManager;
1826
      private org.apache.thrift.protocol.TProtocolFactory protocolFactory;
1853
      private org.apache.thrift.protocol.TProtocolFactory protocolFactory;
Line 3744... Line 3771...
3744
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
3771
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
3745
        return (new Client(prot)).recv_getLastNdaySaleForItem();
3772
        return (new Client(prot)).recv_getLastNdaySaleForItem();
3746
      }
3773
      }
3747
    }
3774
    }
3748
 
3775
 
-
 
3776
    public void addUpdateHoldInventory(long itemId, long warehouseId, long holdQuantity, long source, org.apache.thrift.async.AsyncMethodCallback<addUpdateHoldInventory_call> resultHandler) throws org.apache.thrift.TException {
-
 
3777
      checkReady();
-
 
3778
      addUpdateHoldInventory_call method_call = new addUpdateHoldInventory_call(itemId, warehouseId, holdQuantity, source, resultHandler, this, ___protocolFactory, ___transport);
-
 
3779
      this.___currentMethod = method_call;
-
 
3780
      ___manager.call(method_call);
-
 
3781
    }
-
 
3782
 
-
 
3783
    public static class addUpdateHoldInventory_call extends org.apache.thrift.async.TAsyncMethodCall {
-
 
3784
      private long itemId;
-
 
3785
      private long warehouseId;
-
 
3786
      private long holdQuantity;
-
 
3787
      private long source;
-
 
3788
      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 {
-
 
3789
        super(client, protocolFactory, transport, resultHandler, false);
-
 
3790
        this.itemId = itemId;
-
 
3791
        this.warehouseId = warehouseId;
-
 
3792
        this.holdQuantity = holdQuantity;
-
 
3793
        this.source = source;
-
 
3794
      }
-
 
3795
 
-
 
3796
      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
-
 
3797
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("addUpdateHoldInventory", org.apache.thrift.protocol.TMessageType.CALL, 0));
-
 
3798
        addUpdateHoldInventory_args args = new addUpdateHoldInventory_args();
-
 
3799
        args.setItemId(itemId);
-
 
3800
        args.setWarehouseId(warehouseId);
-
 
3801
        args.setHoldQuantity(holdQuantity);
-
 
3802
        args.setSource(source);
-
 
3803
        args.write(prot);
-
 
3804
        prot.writeMessageEnd();
-
 
3805
      }
-
 
3806
 
-
 
3807
      public void getResult() throws org.apache.thrift.TException {
-
 
3808
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
-
 
3809
          throw new IllegalStateException("Method call not finished!");
-
 
3810
        }
-
 
3811
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
-
 
3812
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
-
 
3813
        (new Client(prot)).recv_addUpdateHoldInventory();
-
 
3814
      }
-
 
3815
    }
-
 
3816
 
3749
  }
3817
  }
3750
 
3818
 
3751
  public static class Processor<I extends Iface> extends in.shop2020.generic.GenericService.Processor implements org.apache.thrift.TProcessor {
3819
  public static class Processor<I extends Iface> extends in.shop2020.generic.GenericService.Processor implements org.apache.thrift.TProcessor {
3752
    private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
3820
    private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
3753
    public Processor(I iface) {
3821
    public Processor(I iface) {
Line 3813... Line 3881...
3813
      processMap.put("getWarehouseName", new getWarehouseName());
3881
      processMap.put("getWarehouseName", new getWarehouseName());
3814
      processMap.put("getAmazonInventoryForItem", new getAmazonInventoryForItem());
3882
      processMap.put("getAmazonInventoryForItem", new getAmazonInventoryForItem());
3815
      processMap.put("getAllAmazonInventory", new getAllAmazonInventory());
3883
      processMap.put("getAllAmazonInventory", new getAllAmazonInventory());
3816
      processMap.put("addOrUpdateAmazonInventoryForItem", new addOrUpdateAmazonInventoryForItem());
3884
      processMap.put("addOrUpdateAmazonInventoryForItem", new addOrUpdateAmazonInventoryForItem());
3817
      processMap.put("getLastNdaySaleForItem", new getLastNdaySaleForItem());
3885
      processMap.put("getLastNdaySaleForItem", new getLastNdaySaleForItem());
-
 
3886
      processMap.put("addUpdateHoldInventory", new addUpdateHoldInventory());
3818
      return processMap;
3887
      return processMap;
3819
    }
3888
    }
3820
 
3889
 
3821
    private static class addWarehouse<I extends Iface> extends org.apache.thrift.ProcessFunction<I, addWarehouse_args> {
3890
    private static class addWarehouse<I extends Iface> extends org.apache.thrift.ProcessFunction<I, addWarehouse_args> {
3822
      public addWarehouse() {
3891
      public addWarehouse() {
Line 4815... Line 4884...
4815
        result.success = iface.getLastNdaySaleForItem(args.itemId, args.numberOfDays);
4884
        result.success = iface.getLastNdaySaleForItem(args.itemId, args.numberOfDays);
4816
        return result;
4885
        return result;
4817
      }
4886
      }
4818
    }
4887
    }
4819
 
4888
 
-
 
4889
    private static class addUpdateHoldInventory<I extends Iface> extends org.apache.thrift.ProcessFunction<I, addUpdateHoldInventory_args> {
-
 
4890
      public addUpdateHoldInventory() {
-
 
4891
        super("addUpdateHoldInventory");
-
 
4892
      }
-
 
4893
 
-
 
4894
      protected addUpdateHoldInventory_args getEmptyArgsInstance() {
-
 
4895
        return new addUpdateHoldInventory_args();
-
 
4896
      }
-
 
4897
 
-
 
4898
      protected addUpdateHoldInventory_result getResult(I iface, addUpdateHoldInventory_args args) throws org.apache.thrift.TException {
-
 
4899
        addUpdateHoldInventory_result result = new addUpdateHoldInventory_result();
-
 
4900
        iface.addUpdateHoldInventory(args.itemId, args.warehouseId, args.holdQuantity, args.source);
-
 
4901
        return result;
-
 
4902
      }
-
 
4903
    }
-
 
4904
 
4820
  }
4905
  }
4821
 
4906
 
4822
  public static class addWarehouse_args implements org.apache.thrift.TBase<addWarehouse_args, addWarehouse_args._Fields>, java.io.Serializable, Cloneable   {
4907
  public static class addWarehouse_args implements org.apache.thrift.TBase<addWarehouse_args, addWarehouse_args._Fields>, java.io.Serializable, Cloneable   {
4823
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("addWarehouse_args");
4908
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("addWarehouse_args");
4824
 
4909
 
Line 6578... Line 6663...
6578
            }
6663
            }
6579
            break;
6664
            break;
6580
          case 3: // AVAILABILITY
6665
          case 3: // AVAILABILITY
6581
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
6666
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
6582
              {
6667
              {
6583
                org.apache.thrift.protocol.TMap _map10 = iprot.readMapBegin();
6668
                org.apache.thrift.protocol.TMap _map15 = iprot.readMapBegin();
6584
                this.availability = new HashMap<String,Long>(2*_map10.size);
6669
                this.availability = new HashMap<String,Long>(2*_map15.size);
6585
                for (int _i11 = 0; _i11 < _map10.size; ++_i11)
6670
                for (int _i16 = 0; _i16 < _map15.size; ++_i16)
6586
                {
6671
                {
6587
                  String _key12; // required
6672
                  String _key17; // required
6588
                  long _val13; // required
6673
                  long _val18; // required
6589
                  _key12 = iprot.readString();
6674
                  _key17 = iprot.readString();
6590
                  _val13 = iprot.readI64();
6675
                  _val18 = iprot.readI64();
6591
                  this.availability.put(_key12, _val13);
6676
                  this.availability.put(_key17, _val18);
6592
                }
6677
                }
6593
                iprot.readMapEnd();
6678
                iprot.readMapEnd();
6594
              }
6679
              }
6595
            } else { 
6680
            } else { 
6596
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
6681
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 6619... Line 6704...
6619
      }
6704
      }
6620
      if (this.availability != null) {
6705
      if (this.availability != null) {
6621
        oprot.writeFieldBegin(AVAILABILITY_FIELD_DESC);
6706
        oprot.writeFieldBegin(AVAILABILITY_FIELD_DESC);
6622
        {
6707
        {
6623
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I64, this.availability.size()));
6708
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I64, this.availability.size()));
6624
          for (Map.Entry<String, Long> _iter14 : this.availability.entrySet())
6709
          for (Map.Entry<String, Long> _iter19 : this.availability.entrySet())
6625
          {
6710
          {
6626
            oprot.writeString(_iter14.getKey());
6711
            oprot.writeString(_iter19.getKey());
6627
            oprot.writeI64(_iter14.getValue());
6712
            oprot.writeI64(_iter19.getValue());
6628
          }
6713
          }
6629
          oprot.writeMapEnd();
6714
          oprot.writeMapEnd();
6630
        }
6715
        }
6631
        oprot.writeFieldEnd();
6716
        oprot.writeFieldEnd();
6632
      }
6717
      }
Line 7385... Line 7470...
7385
            }
7470
            }
7386
            break;
7471
            break;
7387
          case 3: // AVAILABILITY
7472
          case 3: // AVAILABILITY
7388
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
7473
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
7389
              {
7474
              {
7390
                org.apache.thrift.protocol.TMap _map15 = iprot.readMapBegin();
7475
                org.apache.thrift.protocol.TMap _map20 = iprot.readMapBegin();
7391
                this.availability = new HashMap<String,Long>(2*_map15.size);
7476
                this.availability = new HashMap<String,Long>(2*_map20.size);
7392
                for (int _i16 = 0; _i16 < _map15.size; ++_i16)
7477
                for (int _i21 = 0; _i21 < _map20.size; ++_i21)
7393
                {
7478
                {
7394
                  String _key17; // required
7479
                  String _key22; // required
7395
                  long _val18; // required
7480
                  long _val23; // required
7396
                  _key17 = iprot.readString();
7481
                  _key22 = iprot.readString();
7397
                  _val18 = iprot.readI64();
7482
                  _val23 = iprot.readI64();
7398
                  this.availability.put(_key17, _val18);
7483
                  this.availability.put(_key22, _val23);
7399
                }
7484
                }
7400
                iprot.readMapEnd();
7485
                iprot.readMapEnd();
7401
              }
7486
              }
7402
            } else { 
7487
            } else { 
7403
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
7488
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 7426... Line 7511...
7426
      }
7511
      }
7427
      if (this.availability != null) {
7512
      if (this.availability != null) {
7428
        oprot.writeFieldBegin(AVAILABILITY_FIELD_DESC);
7513
        oprot.writeFieldBegin(AVAILABILITY_FIELD_DESC);
7429
        {
7514
        {
7430
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I64, this.availability.size()));
7515
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I64, this.availability.size()));
7431
          for (Map.Entry<String, Long> _iter19 : this.availability.entrySet())
7516
          for (Map.Entry<String, Long> _iter24 : this.availability.entrySet())
7432
          {
7517
          {
7433
            oprot.writeString(_iter19.getKey());
7518
            oprot.writeString(_iter24.getKey());
7434
            oprot.writeI64(_iter19.getValue());
7519
            oprot.writeI64(_iter24.getValue());
7435
          }
7520
          }
7436
          oprot.writeMapEnd();
7521
          oprot.writeMapEnd();
7437
        }
7522
        }
7438
        oprot.writeFieldEnd();
7523
        oprot.writeFieldEnd();
7439
      }
7524
      }
Line 11254... Line 11339...
11254
        }
11339
        }
11255
        switch (field.id) {
11340
        switch (field.id) {
11256
          case 0: // SUCCESS
11341
          case 0: // SUCCESS
11257
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
11342
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
11258
              {
11343
              {
11259
                org.apache.thrift.protocol.TList _list20 = iprot.readListBegin();
11344
                org.apache.thrift.protocol.TList _list25 = iprot.readListBegin();
11260
                this.success = new ArrayList<Long>(_list20.size);
11345
                this.success = new ArrayList<Long>(_list25.size);
11261
                for (int _i21 = 0; _i21 < _list20.size; ++_i21)
11346
                for (int _i26 = 0; _i26 < _list25.size; ++_i26)
11262
                {
11347
                {
11263
                  long _elem22; // required
11348
                  long _elem27; // required
11264
                  _elem22 = iprot.readI64();
11349
                  _elem27 = iprot.readI64();
11265
                  this.success.add(_elem22);
11350
                  this.success.add(_elem27);
11266
                }
11351
                }
11267
                iprot.readListEnd();
11352
                iprot.readListEnd();
11268
              }
11353
              }
11269
            } else { 
11354
            } else { 
11270
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
11355
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 11292... Line 11377...
11292
 
11377
 
11293
      if (this.isSetSuccess()) {
11378
      if (this.isSetSuccess()) {
11294
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
11379
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
11295
        {
11380
        {
11296
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
11381
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
11297
          for (long _iter23 : this.success)
11382
          for (long _iter28 : this.success)
11298
          {
11383
          {
11299
            oprot.writeI64(_iter23);
11384
            oprot.writeI64(_iter28);
11300
          }
11385
          }
11301
          oprot.writeListEnd();
11386
          oprot.writeListEnd();
11302
        }
11387
        }
11303
        oprot.writeFieldEnd();
11388
        oprot.writeFieldEnd();
11304
      } else if (this.isSetIsex()) {
11389
      } else if (this.isSetIsex()) {
Line 11966... Line 12051...
11966
        }
12051
        }
11967
        switch (field.id) {
12052
        switch (field.id) {
11968
          case 0: // SUCCESS
12053
          case 0: // SUCCESS
11969
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
12054
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
11970
              {
12055
              {
11971
                org.apache.thrift.protocol.TList _list24 = iprot.readListBegin();
12056
                org.apache.thrift.protocol.TList _list29 = iprot.readListBegin();
11972
                this.success = new ArrayList<Warehouse>(_list24.size);
12057
                this.success = new ArrayList<Warehouse>(_list29.size);
11973
                for (int _i25 = 0; _i25 < _list24.size; ++_i25)
12058
                for (int _i30 = 0; _i30 < _list29.size; ++_i30)
11974
                {
12059
                {
11975
                  Warehouse _elem26; // required
12060
                  Warehouse _elem31; // required
11976
                  _elem26 = new Warehouse();
12061
                  _elem31 = new Warehouse();
11977
                  _elem26.read(iprot);
12062
                  _elem31.read(iprot);
11978
                  this.success.add(_elem26);
12063
                  this.success.add(_elem31);
11979
                }
12064
                }
11980
                iprot.readListEnd();
12065
                iprot.readListEnd();
11981
              }
12066
              }
11982
            } else { 
12067
            } else { 
11983
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
12068
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 12005... Line 12090...
12005
 
12090
 
12006
      if (this.isSetSuccess()) {
12091
      if (this.isSetSuccess()) {
12007
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
12092
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
12008
        {
12093
        {
12009
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
12094
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
12010
          for (Warehouse _iter27 : this.success)
12095
          for (Warehouse _iter32 : this.success)
12011
          {
12096
          {
12012
            _iter27.write(oprot);
12097
            _iter32.write(oprot);
12013
          }
12098
          }
12014
          oprot.writeListEnd();
12099
          oprot.writeListEnd();
12015
        }
12100
        }
12016
        oprot.writeFieldEnd();
12101
        oprot.writeFieldEnd();
12017
      } else if (this.isSetCex()) {
12102
      } else if (this.isSetCex()) {
Line 13355... Line 13440...
13355
        }
13440
        }
13356
        switch (field.id) {
13441
        switch (field.id) {
13357
          case 0: // SUCCESS
13442
          case 0: // SUCCESS
13358
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
13443
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
13359
              {
13444
              {
13360
                org.apache.thrift.protocol.TList _list28 = iprot.readListBegin();
13445
                org.apache.thrift.protocol.TList _list33 = iprot.readListBegin();
13361
                this.success = new ArrayList<Long>(_list28.size);
13446
                this.success = new ArrayList<Long>(_list33.size);
13362
                for (int _i29 = 0; _i29 < _list28.size; ++_i29)
13447
                for (int _i34 = 0; _i34 < _list33.size; ++_i34)
13363
                {
13448
                {
13364
                  long _elem30; // required
13449
                  long _elem35; // required
13365
                  _elem30 = iprot.readI64();
13450
                  _elem35 = iprot.readI64();
13366
                  this.success.add(_elem30);
13451
                  this.success.add(_elem35);
13367
                }
13452
                }
13368
                iprot.readListEnd();
13453
                iprot.readListEnd();
13369
              }
13454
              }
13370
            } else { 
13455
            } else { 
13371
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
13456
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 13393... Line 13478...
13393
 
13478
 
13394
      if (this.isSetSuccess()) {
13479
      if (this.isSetSuccess()) {
13395
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
13480
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
13396
        {
13481
        {
13397
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
13482
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
13398
          for (long _iter31 : this.success)
13483
          for (long _iter36 : this.success)
13399
          {
13484
          {
13400
            oprot.writeI64(_iter31);
13485
            oprot.writeI64(_iter36);
13401
          }
13486
          }
13402
          oprot.writeListEnd();
13487
          oprot.writeListEnd();
13403
        }
13488
        }
13404
        oprot.writeFieldEnd();
13489
        oprot.writeFieldEnd();
13405
      } else if (this.isSetCex()) {
13490
      } else if (this.isSetCex()) {
Line 19005... Line 19090...
19005
        }
19090
        }
19006
        switch (field.id) {
19091
        switch (field.id) {
19007
          case 0: // SUCCESS
19092
          case 0: // SUCCESS
19008
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
19093
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
19009
              {
19094
              {
19010
                org.apache.thrift.protocol.TList _list32 = iprot.readListBegin();
19095
                org.apache.thrift.protocol.TList _list37 = iprot.readListBegin();
19011
                this.success = new ArrayList<VendorItemPricing>(_list32.size);
19096
                this.success = new ArrayList<VendorItemPricing>(_list37.size);
19012
                for (int _i33 = 0; _i33 < _list32.size; ++_i33)
19097
                for (int _i38 = 0; _i38 < _list37.size; ++_i38)
19013
                {
19098
                {
19014
                  VendorItemPricing _elem34; // required
19099
                  VendorItemPricing _elem39; // required
19015
                  _elem34 = new VendorItemPricing();
19100
                  _elem39 = new VendorItemPricing();
19016
                  _elem34.read(iprot);
19101
                  _elem39.read(iprot);
19017
                  this.success.add(_elem34);
19102
                  this.success.add(_elem39);
19018
                }
19103
                }
19019
                iprot.readListEnd();
19104
                iprot.readListEnd();
19020
              }
19105
              }
19021
            } else { 
19106
            } else { 
19022
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
19107
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 19044... Line 19129...
19044
 
19129
 
19045
      if (this.isSetSuccess()) {
19130
      if (this.isSetSuccess()) {
19046
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
19131
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
19047
        {
19132
        {
19048
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
19133
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
19049
          for (VendorItemPricing _iter35 : this.success)
19134
          for (VendorItemPricing _iter40 : this.success)
19050
          {
19135
          {
19051
            _iter35.write(oprot);
19136
            _iter40.write(oprot);
19052
          }
19137
          }
19053
          oprot.writeListEnd();
19138
          oprot.writeListEnd();
19054
        }
19139
        }
19055
        oprot.writeFieldEnd();
19140
        oprot.writeFieldEnd();
19056
      } else if (this.isSetCex()) {
19141
      } else if (this.isSetCex()) {
Line 20733... Line 20818...
20733
        }
20818
        }
20734
        switch (field.id) {
20819
        switch (field.id) {
20735
          case 0: // SUCCESS
20820
          case 0: // SUCCESS
20736
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
20821
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
20737
              {
20822
              {
20738
                org.apache.thrift.protocol.TList _list36 = iprot.readListBegin();
20823
                org.apache.thrift.protocol.TList _list41 = iprot.readListBegin();
20739
                this.success = new ArrayList<Vendor>(_list36.size);
20824
                this.success = new ArrayList<Vendor>(_list41.size);
20740
                for (int _i37 = 0; _i37 < _list36.size; ++_i37)
20825
                for (int _i42 = 0; _i42 < _list41.size; ++_i42)
20741
                {
20826
                {
20742
                  Vendor _elem38; // required
20827
                  Vendor _elem43; // required
20743
                  _elem38 = new Vendor();
20828
                  _elem43 = new Vendor();
20744
                  _elem38.read(iprot);
20829
                  _elem43.read(iprot);
20745
                  this.success.add(_elem38);
20830
                  this.success.add(_elem43);
20746
                }
20831
                }
20747
                iprot.readListEnd();
20832
                iprot.readListEnd();
20748
              }
20833
              }
20749
            } else { 
20834
            } else { 
20750
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
20835
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 20764... Line 20849...
20764
 
20849
 
20765
      if (this.isSetSuccess()) {
20850
      if (this.isSetSuccess()) {
20766
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
20851
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
20767
        {
20852
        {
20768
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
20853
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
20769
          for (Vendor _iter39 : this.success)
20854
          for (Vendor _iter44 : this.success)
20770
          {
20855
          {
20771
            _iter39.write(oprot);
20856
            _iter44.write(oprot);
20772
          }
20857
          }
20773
          oprot.writeListEnd();
20858
          oprot.writeListEnd();
20774
        }
20859
        }
20775
        oprot.writeFieldEnd();
20860
        oprot.writeFieldEnd();
20776
      }
20861
      }
Line 22101... Line 22186...
22101
        }
22186
        }
22102
        switch (field.id) {
22187
        switch (field.id) {
22103
          case 0: // SUCCESS
22188
          case 0: // SUCCESS
22104
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
22189
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
22105
              {
22190
              {
22106
                org.apache.thrift.protocol.TList _list40 = iprot.readListBegin();
22191
                org.apache.thrift.protocol.TList _list45 = iprot.readListBegin();
22107
                this.success = new ArrayList<VendorItemMapping>(_list40.size);
22192
                this.success = new ArrayList<VendorItemMapping>(_list45.size);
22108
                for (int _i41 = 0; _i41 < _list40.size; ++_i41)
22193
                for (int _i46 = 0; _i46 < _list45.size; ++_i46)
22109
                {
22194
                {
22110
                  VendorItemMapping _elem42; // required
22195
                  VendorItemMapping _elem47; // required
22111
                  _elem42 = new VendorItemMapping();
22196
                  _elem47 = new VendorItemMapping();
22112
                  _elem42.read(iprot);
22197
                  _elem47.read(iprot);
22113
                  this.success.add(_elem42);
22198
                  this.success.add(_elem47);
22114
                }
22199
                }
22115
                iprot.readListEnd();
22200
                iprot.readListEnd();
22116
              }
22201
              }
22117
            } else { 
22202
            } else { 
22118
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
22203
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 22140... Line 22225...
22140
 
22225
 
22141
      if (this.isSetSuccess()) {
22226
      if (this.isSetSuccess()) {
22142
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
22227
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
22143
        {
22228
        {
22144
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
22229
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
22145
          for (VendorItemMapping _iter43 : this.success)
22230
          for (VendorItemMapping _iter48 : this.success)
22146
          {
22231
          {
22147
            _iter43.write(oprot);
22232
            _iter48.write(oprot);
22148
          }
22233
          }
22149
          oprot.writeListEnd();
22234
          oprot.writeListEnd();
22150
        }
22235
        }
22151
        oprot.writeFieldEnd();
22236
        oprot.writeFieldEnd();
22152
      } else if (this.isSetCex()) {
22237
      } else if (this.isSetCex()) {
Line 22746... Line 22831...
22746
        }
22831
        }
22747
        switch (field.id) {
22832
        switch (field.id) {
22748
          case 0: // SUCCESS
22833
          case 0: // SUCCESS
22749
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
22834
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
22750
              {
22835
              {
22751
                org.apache.thrift.protocol.TList _list44 = iprot.readListBegin();
22836
                org.apache.thrift.protocol.TList _list49 = iprot.readListBegin();
22752
                this.success = new ArrayList<AvailableAndReservedStock>(_list44.size);
22837
                this.success = new ArrayList<AvailableAndReservedStock>(_list49.size);
22753
                for (int _i45 = 0; _i45 < _list44.size; ++_i45)
22838
                for (int _i50 = 0; _i50 < _list49.size; ++_i50)
22754
                {
22839
                {
22755
                  AvailableAndReservedStock _elem46; // required
22840
                  AvailableAndReservedStock _elem51; // required
22756
                  _elem46 = new AvailableAndReservedStock();
22841
                  _elem51 = new AvailableAndReservedStock();
22757
                  _elem46.read(iprot);
22842
                  _elem51.read(iprot);
22758
                  this.success.add(_elem46);
22843
                  this.success.add(_elem51);
22759
                }
22844
                }
22760
                iprot.readListEnd();
22845
                iprot.readListEnd();
22761
              }
22846
              }
22762
            } else { 
22847
            } else { 
22763
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
22848
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 22777... Line 22862...
22777
 
22862
 
22778
      if (this.isSetSuccess()) {
22863
      if (this.isSetSuccess()) {
22779
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
22864
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
22780
        {
22865
        {
22781
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
22866
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
22782
          for (AvailableAndReservedStock _iter47 : this.success)
22867
          for (AvailableAndReservedStock _iter52 : this.success)
22783
          {
22868
          {
22784
            _iter47.write(oprot);
22869
            _iter52.write(oprot);
22785
          }
22870
          }
22786
          oprot.writeListEnd();
22871
          oprot.writeListEnd();
22787
        }
22872
        }
22788
        oprot.writeFieldEnd();
22873
        oprot.writeFieldEnd();
22789
      }
22874
      }
Line 23735... Line 23820...
23735
        }
23820
        }
23736
        switch (field.id) {
23821
        switch (field.id) {
23737
          case 0: // SUCCESS
23822
          case 0: // SUCCESS
23738
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
23823
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
23739
              {
23824
              {
23740
                org.apache.thrift.protocol.TList _list48 = iprot.readListBegin();
23825
                org.apache.thrift.protocol.TList _list53 = iprot.readListBegin();
23741
                this.success = new ArrayList<Warehouse>(_list48.size);
23826
                this.success = new ArrayList<Warehouse>(_list53.size);
23742
                for (int _i49 = 0; _i49 < _list48.size; ++_i49)
23827
                for (int _i54 = 0; _i54 < _list53.size; ++_i54)
23743
                {
23828
                {
23744
                  Warehouse _elem50; // required
23829
                  Warehouse _elem55; // required
23745
                  _elem50 = new Warehouse();
23830
                  _elem55 = new Warehouse();
23746
                  _elem50.read(iprot);
23831
                  _elem55.read(iprot);
23747
                  this.success.add(_elem50);
23832
                  this.success.add(_elem55);
23748
                }
23833
                }
23749
                iprot.readListEnd();
23834
                iprot.readListEnd();
23750
              }
23835
              }
23751
            } else { 
23836
            } else { 
23752
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
23837
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 23766... Line 23851...
23766
 
23851
 
23767
      if (this.isSetSuccess()) {
23852
      if (this.isSetSuccess()) {
23768
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
23853
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
23769
        {
23854
        {
23770
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
23855
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
23771
          for (Warehouse _iter51 : this.success)
23856
          for (Warehouse _iter56 : this.success)
23772
          {
23857
          {
23773
            _iter51.write(oprot);
23858
            _iter56.write(oprot);
23774
          }
23859
          }
23775
          oprot.writeListEnd();
23860
          oprot.writeListEnd();
23776
        }
23861
        }
23777
        oprot.writeFieldEnd();
23862
        oprot.writeFieldEnd();
23778
      }
23863
      }
Line 25788... Line 25873...
25788
        }
25873
        }
25789
        switch (field.id) {
25874
        switch (field.id) {
25790
          case 0: // SUCCESS
25875
          case 0: // SUCCESS
25791
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
25876
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
25792
              {
25877
              {
25793
                org.apache.thrift.protocol.TList _list52 = iprot.readListBegin();
25878
                org.apache.thrift.protocol.TList _list57 = iprot.readListBegin();
25794
                this.success = new ArrayList<String>(_list52.size);
25879
                this.success = new ArrayList<String>(_list57.size);
25795
                for (int _i53 = 0; _i53 < _list52.size; ++_i53)
25880
                for (int _i58 = 0; _i58 < _list57.size; ++_i58)
25796
                {
25881
                {
25797
                  String _elem54; // required
25882
                  String _elem59; // required
25798
                  _elem54 = iprot.readString();
25883
                  _elem59 = iprot.readString();
25799
                  this.success.add(_elem54);
25884
                  this.success.add(_elem59);
25800
                }
25885
                }
25801
                iprot.readListEnd();
25886
                iprot.readListEnd();
25802
              }
25887
              }
25803
            } else { 
25888
            } else { 
25804
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
25889
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 25818... Line 25903...
25818
 
25903
 
25819
      if (this.isSetSuccess()) {
25904
      if (this.isSetSuccess()) {
25820
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
25905
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
25821
        {
25906
        {
25822
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
25907
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size()));
25823
          for (String _iter55 : this.success)
25908
          for (String _iter60 : this.success)
25824
          {
25909
          {
25825
            oprot.writeString(_iter55);
25910
            oprot.writeString(_iter60);
25826
          }
25911
          }
25827
          oprot.writeListEnd();
25912
          oprot.writeListEnd();
25828
        }
25913
        }
25829
        oprot.writeFieldEnd();
25914
        oprot.writeFieldEnd();
25830
      }
25915
      }
Line 26915... Line 27000...
26915
        }
27000
        }
26916
        switch (field.id) {
27001
        switch (field.id) {
26917
          case 0: // SUCCESS
27002
          case 0: // SUCCESS
26918
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
27003
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
26919
              {
27004
              {
26920
                org.apache.thrift.protocol.TMap _map56 = iprot.readMapBegin();
27005
                org.apache.thrift.protocol.TMap _map61 = iprot.readMapBegin();
26921
                this.success = new HashMap<String,Map<Long,Long>>(2*_map56.size);
27006
                this.success = new HashMap<String,Map<Long,Long>>(2*_map61.size);
26922
                for (int _i57 = 0; _i57 < _map56.size; ++_i57)
27007
                for (int _i62 = 0; _i62 < _map61.size; ++_i62)
26923
                {
27008
                {
26924
                  String _key58; // required
27009
                  String _key63; // required
26925
                  Map<Long,Long> _val59; // required
27010
                  Map<Long,Long> _val64; // required
26926
                  _key58 = iprot.readString();
27011
                  _key63 = iprot.readString();
26927
                  {
27012
                  {
26928
                    org.apache.thrift.protocol.TMap _map60 = iprot.readMapBegin();
27013
                    org.apache.thrift.protocol.TMap _map65 = iprot.readMapBegin();
26929
                    _val59 = new HashMap<Long,Long>(2*_map60.size);
27014
                    _val64 = new HashMap<Long,Long>(2*_map65.size);
26930
                    for (int _i61 = 0; _i61 < _map60.size; ++_i61)
27015
                    for (int _i66 = 0; _i66 < _map65.size; ++_i66)
26931
                    {
27016
                    {
26932
                      long _key62; // required
27017
                      long _key67; // required
26933
                      long _val63; // required
27018
                      long _val68; // required
26934
                      _key62 = iprot.readI64();
27019
                      _key67 = iprot.readI64();
26935
                      _val63 = iprot.readI64();
27020
                      _val68 = iprot.readI64();
26936
                      _val59.put(_key62, _val63);
27021
                      _val64.put(_key67, _val68);
26937
                    }
27022
                    }
26938
                    iprot.readMapEnd();
27023
                    iprot.readMapEnd();
26939
                  }
27024
                  }
26940
                  this.success.put(_key58, _val59);
27025
                  this.success.put(_key63, _val64);
26941
                }
27026
                }
26942
                iprot.readMapEnd();
27027
                iprot.readMapEnd();
26943
              }
27028
              }
26944
            } else { 
27029
            } else { 
26945
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
27030
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 26959... Line 27044...
26959
 
27044
 
26960
      if (this.isSetSuccess()) {
27045
      if (this.isSetSuccess()) {
26961
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
27046
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
26962
        {
27047
        {
26963
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.MAP, this.success.size()));
27048
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.MAP, this.success.size()));
26964
          for (Map.Entry<String, Map<Long,Long>> _iter64 : this.success.entrySet())
27049
          for (Map.Entry<String, Map<Long,Long>> _iter69 : this.success.entrySet())
26965
          {
27050
          {
26966
            oprot.writeString(_iter64.getKey());
27051
            oprot.writeString(_iter69.getKey());
26967
            {
27052
            {
26968
              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.I64, _iter64.getValue().size()));
27053
              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.I64, _iter69.getValue().size()));
26969
              for (Map.Entry<Long, Long> _iter65 : _iter64.getValue().entrySet())
27054
              for (Map.Entry<Long, Long> _iter70 : _iter69.getValue().entrySet())
26970
              {
27055
              {
26971
                oprot.writeI64(_iter65.getKey());
27056
                oprot.writeI64(_iter70.getKey());
26972
                oprot.writeI64(_iter65.getValue());
27057
                oprot.writeI64(_iter70.getValue());
26973
              }
27058
              }
26974
              oprot.writeMapEnd();
27059
              oprot.writeMapEnd();
26975
            }
27060
            }
26976
          }
27061
          }
26977
          oprot.writeMapEnd();
27062
          oprot.writeMapEnd();
Line 28220... Line 28305...
28220
        }
28305
        }
28221
        switch (field.id) {
28306
        switch (field.id) {
28222
          case 0: // SUCCESS
28307
          case 0: // SUCCESS
28223
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
28308
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
28224
              {
28309
              {
28225
                org.apache.thrift.protocol.TList _list66 = iprot.readListBegin();
28310
                org.apache.thrift.protocol.TList _list71 = iprot.readListBegin();
28226
                this.success = new ArrayList<Warehouse>(_list66.size);
28311
                this.success = new ArrayList<Warehouse>(_list71.size);
28227
                for (int _i67 = 0; _i67 < _list66.size; ++_i67)
28312
                for (int _i72 = 0; _i72 < _list71.size; ++_i72)
28228
                {
28313
                {
28229
                  Warehouse _elem68; // required
28314
                  Warehouse _elem73; // required
28230
                  _elem68 = new Warehouse();
28315
                  _elem73 = new Warehouse();
28231
                  _elem68.read(iprot);
28316
                  _elem73.read(iprot);
28232
                  this.success.add(_elem68);
28317
                  this.success.add(_elem73);
28233
                }
28318
                }
28234
                iprot.readListEnd();
28319
                iprot.readListEnd();
28235
              }
28320
              }
28236
            } else { 
28321
            } else { 
28237
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
28322
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 28251... Line 28336...
28251
 
28336
 
28252
      if (this.isSetSuccess()) {
28337
      if (this.isSetSuccess()) {
28253
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
28338
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
28254
        {
28339
        {
28255
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
28340
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
28256
          for (Warehouse _iter69 : this.success)
28341
          for (Warehouse _iter74 : this.success)
28257
          {
28342
          {
28258
            _iter69.write(oprot);
28343
            _iter74.write(oprot);
28259
          }
28344
          }
28260
          oprot.writeListEnd();
28345
          oprot.writeListEnd();
28261
        }
28346
        }
28262
        oprot.writeFieldEnd();
28347
        oprot.writeFieldEnd();
28263
      }
28348
      }
Line 28751... Line 28836...
28751
        }
28836
        }
28752
        switch (field.id) {
28837
        switch (field.id) {
28753
          case 0: // SUCCESS
28838
          case 0: // SUCCESS
28754
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
28839
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
28755
              {
28840
              {
28756
                org.apache.thrift.protocol.TList _list70 = iprot.readListBegin();
28841
                org.apache.thrift.protocol.TList _list75 = iprot.readListBegin();
28757
                this.success = new ArrayList<VendorItemMapping>(_list70.size);
28842
                this.success = new ArrayList<VendorItemMapping>(_list75.size);
28758
                for (int _i71 = 0; _i71 < _list70.size; ++_i71)
28843
                for (int _i76 = 0; _i76 < _list75.size; ++_i76)
28759
                {
28844
                {
28760
                  VendorItemMapping _elem72; // required
28845
                  VendorItemMapping _elem77; // required
28761
                  _elem72 = new VendorItemMapping();
28846
                  _elem77 = new VendorItemMapping();
28762
                  _elem72.read(iprot);
28847
                  _elem77.read(iprot);
28763
                  this.success.add(_elem72);
28848
                  this.success.add(_elem77);
28764
                }
28849
                }
28765
                iprot.readListEnd();
28850
                iprot.readListEnd();
28766
              }
28851
              }
28767
            } else { 
28852
            } else { 
28768
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
28853
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 28782... Line 28867...
28782
 
28867
 
28783
      if (this.isSetSuccess()) {
28868
      if (this.isSetSuccess()) {
28784
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
28869
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
28785
        {
28870
        {
28786
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
28871
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
28787
          for (VendorItemMapping _iter73 : this.success)
28872
          for (VendorItemMapping _iter78 : this.success)
28788
          {
28873
          {
28789
            _iter73.write(oprot);
28874
            _iter78.write(oprot);
28790
          }
28875
          }
28791
          oprot.writeListEnd();
28876
          oprot.writeListEnd();
28792
        }
28877
        }
28793
        oprot.writeFieldEnd();
28878
        oprot.writeFieldEnd();
28794
      }
28879
      }
Line 29379... Line 29464...
29379
        }
29464
        }
29380
        switch (field.id) {
29465
        switch (field.id) {
29381
          case 0: // SUCCESS
29466
          case 0: // SUCCESS
29382
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
29467
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
29383
              {
29468
              {
29384
                org.apache.thrift.protocol.TMap _map74 = iprot.readMapBegin();
29469
                org.apache.thrift.protocol.TMap _map79 = iprot.readMapBegin();
29385
                this.success = new HashMap<Long,ItemInventory>(2*_map74.size);
29470
                this.success = new HashMap<Long,ItemInventory>(2*_map79.size);
29386
                for (int _i75 = 0; _i75 < _map74.size; ++_i75)
29471
                for (int _i80 = 0; _i80 < _map79.size; ++_i80)
29387
                {
29472
                {
29388
                  long _key76; // required
29473
                  long _key81; // required
29389
                  ItemInventory _val77; // required
29474
                  ItemInventory _val82; // required
29390
                  _key76 = iprot.readI64();
29475
                  _key81 = iprot.readI64();
29391
                  _val77 = new ItemInventory();
29476
                  _val82 = new ItemInventory();
29392
                  _val77.read(iprot);
29477
                  _val82.read(iprot);
29393
                  this.success.put(_key76, _val77);
29478
                  this.success.put(_key81, _val82);
29394
                }
29479
                }
29395
                iprot.readMapEnd();
29480
                iprot.readMapEnd();
29396
              }
29481
              }
29397
            } else { 
29482
            } else { 
29398
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
29483
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 29412... Line 29497...
29412
 
29497
 
29413
      if (this.isSetSuccess()) {
29498
      if (this.isSetSuccess()) {
29414
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
29499
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
29415
        {
29500
        {
29416
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
29501
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
29417
          for (Map.Entry<Long, ItemInventory> _iter78 : this.success.entrySet())
29502
          for (Map.Entry<Long, ItemInventory> _iter83 : this.success.entrySet())
29418
          {
29503
          {
29419
            oprot.writeI64(_iter78.getKey());
29504
            oprot.writeI64(_iter83.getKey());
29420
            _iter78.getValue().write(oprot);
29505
            _iter83.getValue().write(oprot);
29421
          }
29506
          }
29422
          oprot.writeMapEnd();
29507
          oprot.writeMapEnd();
29423
        }
29508
        }
29424
        oprot.writeFieldEnd();
29509
        oprot.writeFieldEnd();
29425
      }
29510
      }
Line 31856... Line 31941...
31856
        }
31941
        }
31857
        switch (field.id) {
31942
        switch (field.id) {
31858
          case 1: // ITEM_IDS
31943
          case 1: // ITEM_IDS
31859
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
31944
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
31860
              {
31945
              {
31861
                org.apache.thrift.protocol.TList _list79 = iprot.readListBegin();
31946
                org.apache.thrift.protocol.TList _list84 = iprot.readListBegin();
31862
                this.item_ids = new ArrayList<Long>(_list79.size);
31947
                this.item_ids = new ArrayList<Long>(_list84.size);
31863
                for (int _i80 = 0; _i80 < _list79.size; ++_i80)
31948
                for (int _i85 = 0; _i85 < _list84.size; ++_i85)
31864
                {
31949
                {
31865
                  long _elem81; // required
31950
                  long _elem86; // required
31866
                  _elem81 = iprot.readI64();
31951
                  _elem86 = iprot.readI64();
31867
                  this.item_ids.add(_elem81);
31952
                  this.item_ids.add(_elem86);
31868
                }
31953
                }
31869
                iprot.readListEnd();
31954
                iprot.readListEnd();
31870
              }
31955
              }
31871
            } else { 
31956
            } else { 
31872
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
31957
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 31887... Line 31972...
31887
      oprot.writeStructBegin(STRUCT_DESC);
31972
      oprot.writeStructBegin(STRUCT_DESC);
31888
      if (this.item_ids != null) {
31973
      if (this.item_ids != null) {
31889
        oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
31974
        oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
31890
        {
31975
        {
31891
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.item_ids.size()));
31976
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.item_ids.size()));
31892
          for (long _iter82 : this.item_ids)
31977
          for (long _iter87 : this.item_ids)
31893
          {
31978
          {
31894
            oprot.writeI64(_iter82);
31979
            oprot.writeI64(_iter87);
31895
          }
31980
          }
31896
          oprot.writeListEnd();
31981
          oprot.writeListEnd();
31897
        }
31982
        }
31898
        oprot.writeFieldEnd();
31983
        oprot.writeFieldEnd();
31899
      }
31984
      }
Line 32192... Line 32277...
32192
        }
32277
        }
32193
        switch (field.id) {
32278
        switch (field.id) {
32194
          case 0: // SUCCESS
32279
          case 0: // SUCCESS
32195
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
32280
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
32196
              {
32281
              {
32197
                org.apache.thrift.protocol.TMap _map83 = iprot.readMapBegin();
32282
                org.apache.thrift.protocol.TMap _map88 = iprot.readMapBegin();
32198
                this.success = new HashMap<Long,Long>(2*_map83.size);
32283
                this.success = new HashMap<Long,Long>(2*_map88.size);
32199
                for (int _i84 = 0; _i84 < _map83.size; ++_i84)
32284
                for (int _i89 = 0; _i89 < _map88.size; ++_i89)
32200
                {
32285
                {
32201
                  long _key85; // required
32286
                  long _key90; // required
32202
                  long _val86; // required
32287
                  long _val91; // required
32203
                  _key85 = iprot.readI64();
32288
                  _key90 = iprot.readI64();
32204
                  _val86 = iprot.readI64();
32289
                  _val91 = iprot.readI64();
32205
                  this.success.put(_key85, _val86);
32290
                  this.success.put(_key90, _val91);
32206
                }
32291
                }
32207
                iprot.readMapEnd();
32292
                iprot.readMapEnd();
32208
              }
32293
              }
32209
            } else { 
32294
            } else { 
32210
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
32295
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 32224... Line 32309...
32224
 
32309
 
32225
      if (this.isSetSuccess()) {
32310
      if (this.isSetSuccess()) {
32226
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
32311
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
32227
        {
32312
        {
32228
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.I64, this.success.size()));
32313
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.I64, this.success.size()));
32229
          for (Map.Entry<Long, Long> _iter87 : this.success.entrySet())
32314
          for (Map.Entry<Long, Long> _iter92 : this.success.entrySet())
32230
          {
32315
          {
32231
            oprot.writeI64(_iter87.getKey());
32316
            oprot.writeI64(_iter92.getKey());
32232
            oprot.writeI64(_iter87.getValue());
32317
            oprot.writeI64(_iter92.getValue());
32233
          }
32318
          }
32234
          oprot.writeMapEnd();
32319
          oprot.writeMapEnd();
32235
        }
32320
        }
32236
        oprot.writeFieldEnd();
32321
        oprot.writeFieldEnd();
32237
      }
32322
      }
Line 32525... Line 32610...
32525
        }
32610
        }
32526
        switch (field.id) {
32611
        switch (field.id) {
32527
          case 1: // VENDOR_IDS
32612
          case 1: // VENDOR_IDS
32528
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
32613
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
32529
              {
32614
              {
32530
                org.apache.thrift.protocol.TList _list88 = iprot.readListBegin();
32615
                org.apache.thrift.protocol.TList _list93 = iprot.readListBegin();
32531
                this.vendorIds = new ArrayList<Long>(_list88.size);
32616
                this.vendorIds = new ArrayList<Long>(_list93.size);
32532
                for (int _i89 = 0; _i89 < _list88.size; ++_i89)
32617
                for (int _i94 = 0; _i94 < _list93.size; ++_i94)
32533
                {
32618
                {
32534
                  long _elem90; // required
32619
                  long _elem95; // required
32535
                  _elem90 = iprot.readI64();
32620
                  _elem95 = iprot.readI64();
32536
                  this.vendorIds.add(_elem90);
32621
                  this.vendorIds.add(_elem95);
32537
                }
32622
                }
32538
                iprot.readListEnd();
32623
                iprot.readListEnd();
32539
              }
32624
              }
32540
            } else { 
32625
            } else { 
32541
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
32626
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 32556... Line 32641...
32556
      oprot.writeStructBegin(STRUCT_DESC);
32641
      oprot.writeStructBegin(STRUCT_DESC);
32557
      if (this.vendorIds != null) {
32642
      if (this.vendorIds != null) {
32558
        oprot.writeFieldBegin(VENDOR_IDS_FIELD_DESC);
32643
        oprot.writeFieldBegin(VENDOR_IDS_FIELD_DESC);
32559
        {
32644
        {
32560
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.vendorIds.size()));
32645
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.vendorIds.size()));
32561
          for (long _iter91 : this.vendorIds)
32646
          for (long _iter96 : this.vendorIds)
32562
          {
32647
          {
32563
            oprot.writeI64(_iter91);
32648
            oprot.writeI64(_iter96);
32564
          }
32649
          }
32565
          oprot.writeListEnd();
32650
          oprot.writeListEnd();
32566
        }
32651
        }
32567
        oprot.writeFieldEnd();
32652
        oprot.writeFieldEnd();
32568
      }
32653
      }
Line 32856... Line 32941...
32856
        }
32941
        }
32857
        switch (field.id) {
32942
        switch (field.id) {
32858
          case 0: // SUCCESS
32943
          case 0: // SUCCESS
32859
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
32944
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
32860
              {
32945
              {
32861
                org.apache.thrift.protocol.TList _list92 = iprot.readListBegin();
32946
                org.apache.thrift.protocol.TList _list97 = iprot.readListBegin();
32862
                this.success = new ArrayList<Long>(_list92.size);
32947
                this.success = new ArrayList<Long>(_list97.size);
32863
                for (int _i93 = 0; _i93 < _list92.size; ++_i93)
32948
                for (int _i98 = 0; _i98 < _list97.size; ++_i98)
32864
                {
32949
                {
32865
                  long _elem94; // required
32950
                  long _elem99; // required
32866
                  _elem94 = iprot.readI64();
32951
                  _elem99 = iprot.readI64();
32867
                  this.success.add(_elem94);
32952
                  this.success.add(_elem99);
32868
                }
32953
                }
32869
                iprot.readListEnd();
32954
                iprot.readListEnd();
32870
              }
32955
              }
32871
            } else { 
32956
            } else { 
32872
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
32957
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 32886... Line 32971...
32886
 
32971
 
32887
      if (this.isSetSuccess()) {
32972
      if (this.isSetSuccess()) {
32888
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
32973
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
32889
        {
32974
        {
32890
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
32975
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
32891
          for (long _iter95 : this.success)
32976
          for (long _iter100 : this.success)
32892
          {
32977
          {
32893
            oprot.writeI64(_iter95);
32978
            oprot.writeI64(_iter100);
32894
          }
32979
          }
32895
          oprot.writeListEnd();
32980
          oprot.writeListEnd();
32896
        }
32981
        }
32897
        oprot.writeFieldEnd();
32982
        oprot.writeFieldEnd();
32898
      }
32983
      }
Line 33386... Line 33471...
33386
        }
33471
        }
33387
        switch (field.id) {
33472
        switch (field.id) {
33388
          case 0: // SUCCESS
33473
          case 0: // SUCCESS
33389
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
33474
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
33390
              {
33475
              {
33391
                org.apache.thrift.protocol.TList _list96 = iprot.readListBegin();
33476
                org.apache.thrift.protocol.TList _list101 = iprot.readListBegin();
33392
                this.success = new ArrayList<IgnoredInventoryUpdateItems>(_list96.size);
33477
                this.success = new ArrayList<IgnoredInventoryUpdateItems>(_list101.size);
33393
                for (int _i97 = 0; _i97 < _list96.size; ++_i97)
33478
                for (int _i102 = 0; _i102 < _list101.size; ++_i102)
33394
                {
33479
                {
33395
                  IgnoredInventoryUpdateItems _elem98; // required
33480
                  IgnoredInventoryUpdateItems _elem103; // required
33396
                  _elem98 = new IgnoredInventoryUpdateItems();
33481
                  _elem103 = new IgnoredInventoryUpdateItems();
33397
                  _elem98.read(iprot);
33482
                  _elem103.read(iprot);
33398
                  this.success.add(_elem98);
33483
                  this.success.add(_elem103);
33399
                }
33484
                }
33400
                iprot.readListEnd();
33485
                iprot.readListEnd();
33401
              }
33486
              }
33402
            } else { 
33487
            } else { 
33403
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
33488
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 33417... Line 33502...
33417
 
33502
 
33418
      if (this.isSetSuccess()) {
33503
      if (this.isSetSuccess()) {
33419
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
33504
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
33420
        {
33505
        {
33421
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
33506
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
33422
          for (IgnoredInventoryUpdateItems _iter99 : this.success)
33507
          for (IgnoredInventoryUpdateItems _iter104 : this.success)
33423
          {
33508
          {
33424
            _iter99.write(oprot);
33509
            _iter104.write(oprot);
33425
          }
33510
          }
33426
          oprot.writeListEnd();
33511
          oprot.writeListEnd();
33427
        }
33512
        }
33428
        oprot.writeFieldEnd();
33513
        oprot.writeFieldEnd();
33429
      }
33514
      }
Line 35927... Line 36012...
35927
        }
36012
        }
35928
        switch (field.id) {
36013
        switch (field.id) {
35929
          case 0: // SUCCESS
36014
          case 0: // SUCCESS
35930
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
36015
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
35931
              {
36016
              {
35932
                org.apache.thrift.protocol.TList _list100 = iprot.readListBegin();
36017
                org.apache.thrift.protocol.TList _list105 = iprot.readListBegin();
35933
                this.success = new ArrayList<Long>(_list100.size);
36018
                this.success = new ArrayList<Long>(_list105.size);
35934
                for (int _i101 = 0; _i101 < _list100.size; ++_i101)
36019
                for (int _i106 = 0; _i106 < _list105.size; ++_i106)
35935
                {
36020
                {
35936
                  long _elem102; // required
36021
                  long _elem107; // required
35937
                  _elem102 = iprot.readI64();
36022
                  _elem107 = iprot.readI64();
35938
                  this.success.add(_elem102);
36023
                  this.success.add(_elem107);
35939
                }
36024
                }
35940
                iprot.readListEnd();
36025
                iprot.readListEnd();
35941
              }
36026
              }
35942
            } else { 
36027
            } else { 
35943
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
36028
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 35957... Line 36042...
35957
 
36042
 
35958
      if (this.isSetSuccess()) {
36043
      if (this.isSetSuccess()) {
35959
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
36044
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
35960
        {
36045
        {
35961
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
36046
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
35962
          for (long _iter103 : this.success)
36047
          for (long _iter108 : this.success)
35963
          {
36048
          {
35964
            oprot.writeI64(_iter103);
36049
            oprot.writeI64(_iter108);
35965
          }
36050
          }
35966
          oprot.writeListEnd();
36051
          oprot.writeListEnd();
35967
        }
36052
        }
35968
        oprot.writeFieldEnd();
36053
        oprot.writeFieldEnd();
35969
      }
36054
      }
Line 37580... Line 37665...
37580
        }
37665
        }
37581
        switch (field.id) {
37666
        switch (field.id) {
37582
          case 1: // OOS_STATUS_MAP
37667
          case 1: // OOS_STATUS_MAP
37583
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
37668
            if (field.type == org.apache.thrift.protocol.TType.MAP) {
37584
              {
37669
              {
37585
                org.apache.thrift.protocol.TMap _map104 = iprot.readMapBegin();
37670
                org.apache.thrift.protocol.TMap _map109 = iprot.readMapBegin();
37586
                this.oosStatusMap = new HashMap<Long,Boolean>(2*_map104.size);
37671
                this.oosStatusMap = new HashMap<Long,Boolean>(2*_map109.size);
37587
                for (int _i105 = 0; _i105 < _map104.size; ++_i105)
37672
                for (int _i110 = 0; _i110 < _map109.size; ++_i110)
37588
                {
37673
                {
37589
                  long _key106; // required
37674
                  long _key111; // required
37590
                  boolean _val107; // required
37675
                  boolean _val112; // required
37591
                  _key106 = iprot.readI64();
37676
                  _key111 = iprot.readI64();
37592
                  _val107 = iprot.readBool();
37677
                  _val112 = iprot.readBool();
37593
                  this.oosStatusMap.put(_key106, _val107);
37678
                  this.oosStatusMap.put(_key111, _val112);
37594
                }
37679
                }
37595
                iprot.readMapEnd();
37680
                iprot.readMapEnd();
37596
              }
37681
              }
37597
            } else { 
37682
            } else { 
37598
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
37683
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 37621... Line 37706...
37621
      oprot.writeStructBegin(STRUCT_DESC);
37706
      oprot.writeStructBegin(STRUCT_DESC);
37622
      if (this.oosStatusMap != null) {
37707
      if (this.oosStatusMap != null) {
37623
        oprot.writeFieldBegin(OOS_STATUS_MAP_FIELD_DESC);
37708
        oprot.writeFieldBegin(OOS_STATUS_MAP_FIELD_DESC);
37624
        {
37709
        {
37625
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.BOOL, this.oosStatusMap.size()));
37710
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.BOOL, this.oosStatusMap.size()));
37626
          for (Map.Entry<Long, Boolean> _iter108 : this.oosStatusMap.entrySet())
37711
          for (Map.Entry<Long, Boolean> _iter113 : this.oosStatusMap.entrySet())
37627
          {
37712
          {
37628
            oprot.writeI64(_iter108.getKey());
37713
            oprot.writeI64(_iter113.getKey());
37629
            oprot.writeBool(_iter108.getValue());
37714
            oprot.writeBool(_iter113.getValue());
37630
          }
37715
          }
37631
          oprot.writeMapEnd();
37716
          oprot.writeMapEnd();
37632
        }
37717
        }
37633
        oprot.writeFieldEnd();
37718
        oprot.writeFieldEnd();
37634
      }
37719
      }
Line 38507... Line 38592...
38507
        }
38592
        }
38508
        switch (field.id) {
38593
        switch (field.id) {
38509
          case 0: // SUCCESS
38594
          case 0: // SUCCESS
38510
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
38595
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
38511
              {
38596
              {
38512
                org.apache.thrift.protocol.TList _list109 = iprot.readListBegin();
38597
                org.apache.thrift.protocol.TList _list114 = iprot.readListBegin();
38513
                this.success = new ArrayList<OOSStatus>(_list109.size);
38598
                this.success = new ArrayList<OOSStatus>(_list114.size);
38514
                for (int _i110 = 0; _i110 < _list109.size; ++_i110)
38599
                for (int _i115 = 0; _i115 < _list114.size; ++_i115)
38515
                {
38600
                {
38516
                  OOSStatus _elem111; // required
38601
                  OOSStatus _elem116; // required
38517
                  _elem111 = new OOSStatus();
38602
                  _elem116 = new OOSStatus();
38518
                  _elem111.read(iprot);
38603
                  _elem116.read(iprot);
38519
                  this.success.add(_elem111);
38604
                  this.success.add(_elem116);
38520
                }
38605
                }
38521
                iprot.readListEnd();
38606
                iprot.readListEnd();
38522
              }
38607
              }
38523
            } else { 
38608
            } else { 
38524
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
38609
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 38538... Line 38623...
38538
 
38623
 
38539
      if (this.isSetSuccess()) {
38624
      if (this.isSetSuccess()) {
38540
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
38625
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
38541
        {
38626
        {
38542
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
38627
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
38543
          for (OOSStatus _iter112 : this.success)
38628
          for (OOSStatus _iter117 : this.success)
38544
          {
38629
          {
38545
            _iter112.write(oprot);
38630
            _iter117.write(oprot);
38546
          }
38631
          }
38547
          oprot.writeListEnd();
38632
          oprot.writeListEnd();
38548
        }
38633
        }
38549
        oprot.writeFieldEnd();
38634
        oprot.writeFieldEnd();
38550
      }
38635
      }
Line 39038... Line 39123...
39038
        }
39123
        }
39039
        switch (field.id) {
39124
        switch (field.id) {
39040
          case 0: // SUCCESS
39125
          case 0: // SUCCESS
39041
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
39126
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
39042
              {
39127
              {
39043
                org.apache.thrift.protocol.TList _list113 = iprot.readListBegin();
39128
                org.apache.thrift.protocol.TList _list118 = iprot.readListBegin();
39044
                this.success = new ArrayList<ItemStockPurchaseParams>(_list113.size);
39129
                this.success = new ArrayList<ItemStockPurchaseParams>(_list118.size);
39045
                for (int _i114 = 0; _i114 < _list113.size; ++_i114)
39130
                for (int _i119 = 0; _i119 < _list118.size; ++_i119)
39046
                {
39131
                {
39047
                  ItemStockPurchaseParams _elem115; // required
39132
                  ItemStockPurchaseParams _elem120; // required
39048
                  _elem115 = new ItemStockPurchaseParams();
39133
                  _elem120 = new ItemStockPurchaseParams();
39049
                  _elem115.read(iprot);
39134
                  _elem120.read(iprot);
39050
                  this.success.add(_elem115);
39135
                  this.success.add(_elem120);
39051
                }
39136
                }
39052
                iprot.readListEnd();
39137
                iprot.readListEnd();
39053
              }
39138
              }
39054
            } else { 
39139
            } else { 
39055
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
39140
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 39069... Line 39154...
39069
 
39154
 
39070
      if (this.isSetSuccess()) {
39155
      if (this.isSetSuccess()) {
39071
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
39156
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
39072
        {
39157
        {
39073
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
39158
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
39074
          for (ItemStockPurchaseParams _iter116 : this.success)
39159
          for (ItemStockPurchaseParams _iter121 : this.success)
39075
          {
39160
          {
39076
            _iter116.write(oprot);
39161
            _iter121.write(oprot);
39077
          }
39162
          }
39078
          oprot.writeListEnd();
39163
          oprot.writeListEnd();
39079
        }
39164
        }
39080
        oprot.writeFieldEnd();
39165
        oprot.writeFieldEnd();
39081
      }
39166
      }
Line 39569... Line 39654...
39569
        }
39654
        }
39570
        switch (field.id) {
39655
        switch (field.id) {
39571
          case 0: // SUCCESS
39656
          case 0: // SUCCESS
39572
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
39657
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
39573
              {
39658
              {
39574
                org.apache.thrift.protocol.TList _list117 = iprot.readListBegin();
39659
                org.apache.thrift.protocol.TList _list122 = iprot.readListBegin();
39575
                this.success = new ArrayList<AvailableAndReservedStock>(_list117.size);
39660
                this.success = new ArrayList<AvailableAndReservedStock>(_list122.size);
39576
                for (int _i118 = 0; _i118 < _list117.size; ++_i118)
39661
                for (int _i123 = 0; _i123 < _list122.size; ++_i123)
39577
                {
39662
                {
39578
                  AvailableAndReservedStock _elem119; // required
39663
                  AvailableAndReservedStock _elem124; // required
39579
                  _elem119 = new AvailableAndReservedStock();
39664
                  _elem124 = new AvailableAndReservedStock();
39580
                  _elem119.read(iprot);
39665
                  _elem124.read(iprot);
39581
                  this.success.add(_elem119);
39666
                  this.success.add(_elem124);
39582
                }
39667
                }
39583
                iprot.readListEnd();
39668
                iprot.readListEnd();
39584
              }
39669
              }
39585
            } else { 
39670
            } else { 
39586
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
39671
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 39600... Line 39685...
39600
 
39685
 
39601
      if (this.isSetSuccess()) {
39686
      if (this.isSetSuccess()) {
39602
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
39687
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
39603
        {
39688
        {
39604
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
39689
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
39605
          for (AvailableAndReservedStock _iter120 : this.success)
39690
          for (AvailableAndReservedStock _iter125 : this.success)
39606
          {
39691
          {
39607
            _iter120.write(oprot);
39692
            _iter125.write(oprot);
39608
          }
39693
          }
39609
          oprot.writeListEnd();
39694
          oprot.writeListEnd();
39610
        }
39695
        }
39611
        oprot.writeFieldEnd();
39696
        oprot.writeFieldEnd();
39612
      }
39697
      }
Line 41275... Line 41360...
41275
        }
41360
        }
41276
        switch (field.id) {
41361
        switch (field.id) {
41277
          case 0: // SUCCESS
41362
          case 0: // SUCCESS
41278
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
41363
            if (field.type == org.apache.thrift.protocol.TType.LIST) {
41279
              {
41364
              {
41280
                org.apache.thrift.protocol.TList _list121 = iprot.readListBegin();
41365
                org.apache.thrift.protocol.TList _list126 = iprot.readListBegin();
41281
                this.success = new ArrayList<AmazonInventorySnapshot>(_list121.size);
41366
                this.success = new ArrayList<AmazonInventorySnapshot>(_list126.size);
41282
                for (int _i122 = 0; _i122 < _list121.size; ++_i122)
41367
                for (int _i127 = 0; _i127 < _list126.size; ++_i127)
41283
                {
41368
                {
41284
                  AmazonInventorySnapshot _elem123; // required
41369
                  AmazonInventorySnapshot _elem128; // required
41285
                  _elem123 = new AmazonInventorySnapshot();
41370
                  _elem128 = new AmazonInventorySnapshot();
41286
                  _elem123.read(iprot);
41371
                  _elem128.read(iprot);
41287
                  this.success.add(_elem123);
41372
                  this.success.add(_elem128);
41288
                }
41373
                }
41289
                iprot.readListEnd();
41374
                iprot.readListEnd();
41290
              }
41375
              }
41291
            } else { 
41376
            } else { 
41292
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
41377
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
Line 41306... Line 41391...
41306
 
41391
 
41307
      if (this.isSetSuccess()) {
41392
      if (this.isSetSuccess()) {
41308
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
41393
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
41309
        {
41394
        {
41310
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
41395
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
41311
          for (AmazonInventorySnapshot _iter124 : this.success)
41396
          for (AmazonInventorySnapshot _iter129 : this.success)
41312
          {
41397
          {
41313
            _iter124.write(oprot);
41398
            _iter129.write(oprot);
41314
          }
41399
          }
41315
          oprot.writeListEnd();
41400
          oprot.writeListEnd();
41316
        }
41401
        }
41317
        oprot.writeFieldEnd();
41402
        oprot.writeFieldEnd();
41318
      }
41403
      }
Line 42499... Line 42584...
42499
      sb.append(")");
42584
      sb.append(")");
42500
      return sb.toString();
42585
      return sb.toString();
42501
    }
42586
    }
42502
 
42587
 
42503
    public void validate() throws org.apache.thrift.TException {
42588
    public void validate() throws org.apache.thrift.TException {
-
 
42589
      // check for required fields
-
 
42590
    }
-
 
42591
 
-
 
42592
    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
-
 
42593
      try {
-
 
42594
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
-
 
42595
      } catch (org.apache.thrift.TException te) {
-
 
42596
        throw new java.io.IOException(te);
-
 
42597
      }
-
 
42598
    }
-
 
42599
 
-
 
42600
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
-
 
42601
      try {
-
 
42602
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
-
 
42603
      } catch (org.apache.thrift.TException te) {
-
 
42604
        throw new java.io.IOException(te);
-
 
42605
      }
-
 
42606
    }
-
 
42607
 
-
 
42608
  }
-
 
42609
 
-
 
42610
  public static class addUpdateHoldInventory_args implements org.apache.thrift.TBase<addUpdateHoldInventory_args, addUpdateHoldInventory_args._Fields>, java.io.Serializable, Cloneable   {
-
 
42611
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("addUpdateHoldInventory_args");
-
 
42612
 
-
 
42613
    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);
-
 
42614
    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);
-
 
42615
    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);
-
 
42616
    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);
-
 
42617
 
-
 
42618
    private long itemId; // required
-
 
42619
    private long warehouseId; // required
-
 
42620
    private long holdQuantity; // required
-
 
42621
    private long source; // required
-
 
42622
 
-
 
42623
    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
-
 
42624
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
-
 
42625
      ITEM_ID((short)1, "itemId"),
-
 
42626
      WAREHOUSE_ID((short)2, "warehouseId"),
-
 
42627
      HOLD_QUANTITY((short)3, "holdQuantity"),
-
 
42628
      SOURCE((short)4, "source");
-
 
42629
 
-
 
42630
      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
-
 
42631
 
-
 
42632
      static {
-
 
42633
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
-
 
42634
          byName.put(field.getFieldName(), field);
-
 
42635
        }
-
 
42636
      }
-
 
42637
 
-
 
42638
      /**
-
 
42639
       * Find the _Fields constant that matches fieldId, or null if its not found.
-
 
42640
       */
-
 
42641
      public static _Fields findByThriftId(int fieldId) {
-
 
42642
        switch(fieldId) {
-
 
42643
          case 1: // ITEM_ID
-
 
42644
            return ITEM_ID;
-
 
42645
          case 2: // WAREHOUSE_ID
-
 
42646
            return WAREHOUSE_ID;
-
 
42647
          case 3: // HOLD_QUANTITY
-
 
42648
            return HOLD_QUANTITY;
-
 
42649
          case 4: // SOURCE
-
 
42650
            return SOURCE;
-
 
42651
          default:
-
 
42652
            return null;
-
 
42653
        }
-
 
42654
      }
-
 
42655
 
-
 
42656
      /**
-
 
42657
       * Find the _Fields constant that matches fieldId, throwing an exception
-
 
42658
       * if it is not found.
-
 
42659
       */
-
 
42660
      public static _Fields findByThriftIdOrThrow(int fieldId) {
-
 
42661
        _Fields fields = findByThriftId(fieldId);
-
 
42662
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
-
 
42663
        return fields;
-
 
42664
      }
-
 
42665
 
-
 
42666
      /**
-
 
42667
       * Find the _Fields constant that matches name, or null if its not found.
-
 
42668
       */
-
 
42669
      public static _Fields findByName(String name) {
-
 
42670
        return byName.get(name);
-
 
42671
      }
-
 
42672
 
-
 
42673
      private final short _thriftId;
-
 
42674
      private final String _fieldName;
-
 
42675
 
-
 
42676
      _Fields(short thriftId, String fieldName) {
-
 
42677
        _thriftId = thriftId;
-
 
42678
        _fieldName = fieldName;
-
 
42679
      }
-
 
42680
 
-
 
42681
      public short getThriftFieldId() {
-
 
42682
        return _thriftId;
-
 
42683
      }
-
 
42684
 
-
 
42685
      public String getFieldName() {
-
 
42686
        return _fieldName;
-
 
42687
      }
-
 
42688
    }
-
 
42689
 
-
 
42690
    // isset id assignments
-
 
42691
    private static final int __ITEMID_ISSET_ID = 0;
-
 
42692
    private static final int __WAREHOUSEID_ISSET_ID = 1;
-
 
42693
    private static final int __HOLDQUANTITY_ISSET_ID = 2;
-
 
42694
    private static final int __SOURCE_ISSET_ID = 3;
-
 
42695
    private BitSet __isset_bit_vector = new BitSet(4);
-
 
42696
 
-
 
42697
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
-
 
42698
    static {
-
 
42699
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
-
 
42700
      tmpMap.put(_Fields.ITEM_ID, new org.apache.thrift.meta_data.FieldMetaData("itemId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
-
 
42701
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
-
 
42702
      tmpMap.put(_Fields.WAREHOUSE_ID, new org.apache.thrift.meta_data.FieldMetaData("warehouseId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
-
 
42703
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
-
 
42704
      tmpMap.put(_Fields.HOLD_QUANTITY, new org.apache.thrift.meta_data.FieldMetaData("holdQuantity", org.apache.thrift.TFieldRequirementType.DEFAULT, 
-
 
42705
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
-
 
42706
      tmpMap.put(_Fields.SOURCE, new org.apache.thrift.meta_data.FieldMetaData("source", org.apache.thrift.TFieldRequirementType.DEFAULT, 
-
 
42707
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
-
 
42708
      metaDataMap = Collections.unmodifiableMap(tmpMap);
-
 
42709
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(addUpdateHoldInventory_args.class, metaDataMap);
-
 
42710
    }
-
 
42711
 
-
 
42712
    public addUpdateHoldInventory_args() {
-
 
42713
    }
-
 
42714
 
-
 
42715
    public addUpdateHoldInventory_args(
-
 
42716
      long itemId,
-
 
42717
      long warehouseId,
-
 
42718
      long holdQuantity,
-
 
42719
      long source)
-
 
42720
    {
-
 
42721
      this();
-
 
42722
      this.itemId = itemId;
-
 
42723
      setItemIdIsSet(true);
-
 
42724
      this.warehouseId = warehouseId;
-
 
42725
      setWarehouseIdIsSet(true);
-
 
42726
      this.holdQuantity = holdQuantity;
-
 
42727
      setHoldQuantityIsSet(true);
-
 
42728
      this.source = source;
-
 
42729
      setSourceIsSet(true);
-
 
42730
    }
-
 
42731
 
-
 
42732
    /**
-
 
42733
     * Performs a deep copy on <i>other</i>.
-
 
42734
     */
-
 
42735
    public addUpdateHoldInventory_args(addUpdateHoldInventory_args other) {
-
 
42736
      __isset_bit_vector.clear();
-
 
42737
      __isset_bit_vector.or(other.__isset_bit_vector);
-
 
42738
      this.itemId = other.itemId;
-
 
42739
      this.warehouseId = other.warehouseId;
-
 
42740
      this.holdQuantity = other.holdQuantity;
-
 
42741
      this.source = other.source;
-
 
42742
    }
-
 
42743
 
-
 
42744
    public addUpdateHoldInventory_args deepCopy() {
-
 
42745
      return new addUpdateHoldInventory_args(this);
-
 
42746
    }
-
 
42747
 
-
 
42748
    @Override
-
 
42749
    public void clear() {
-
 
42750
      setItemIdIsSet(false);
-
 
42751
      this.itemId = 0;
-
 
42752
      setWarehouseIdIsSet(false);
-
 
42753
      this.warehouseId = 0;
-
 
42754
      setHoldQuantityIsSet(false);
-
 
42755
      this.holdQuantity = 0;
-
 
42756
      setSourceIsSet(false);
-
 
42757
      this.source = 0;
-
 
42758
    }
-
 
42759
 
-
 
42760
    public long getItemId() {
-
 
42761
      return this.itemId;
-
 
42762
    }
-
 
42763
 
-
 
42764
    public void setItemId(long itemId) {
-
 
42765
      this.itemId = itemId;
-
 
42766
      setItemIdIsSet(true);
-
 
42767
    }
-
 
42768
 
-
 
42769
    public void unsetItemId() {
-
 
42770
      __isset_bit_vector.clear(__ITEMID_ISSET_ID);
-
 
42771
    }
-
 
42772
 
-
 
42773
    /** Returns true if field itemId is set (has been assigned a value) and false otherwise */
-
 
42774
    public boolean isSetItemId() {
-
 
42775
      return __isset_bit_vector.get(__ITEMID_ISSET_ID);
-
 
42776
    }
-
 
42777
 
-
 
42778
    public void setItemIdIsSet(boolean value) {
-
 
42779
      __isset_bit_vector.set(__ITEMID_ISSET_ID, value);
-
 
42780
    }
-
 
42781
 
-
 
42782
    public long getWarehouseId() {
-
 
42783
      return this.warehouseId;
-
 
42784
    }
-
 
42785
 
-
 
42786
    public void setWarehouseId(long warehouseId) {
-
 
42787
      this.warehouseId = warehouseId;
-
 
42788
      setWarehouseIdIsSet(true);
-
 
42789
    }
-
 
42790
 
-
 
42791
    public void unsetWarehouseId() {
-
 
42792
      __isset_bit_vector.clear(__WAREHOUSEID_ISSET_ID);
-
 
42793
    }
-
 
42794
 
-
 
42795
    /** Returns true if field warehouseId is set (has been assigned a value) and false otherwise */
-
 
42796
    public boolean isSetWarehouseId() {
-
 
42797
      return __isset_bit_vector.get(__WAREHOUSEID_ISSET_ID);
-
 
42798
    }
-
 
42799
 
-
 
42800
    public void setWarehouseIdIsSet(boolean value) {
-
 
42801
      __isset_bit_vector.set(__WAREHOUSEID_ISSET_ID, value);
-
 
42802
    }
-
 
42803
 
-
 
42804
    public long getHoldQuantity() {
-
 
42805
      return this.holdQuantity;
-
 
42806
    }
-
 
42807
 
-
 
42808
    public void setHoldQuantity(long holdQuantity) {
-
 
42809
      this.holdQuantity = holdQuantity;
-
 
42810
      setHoldQuantityIsSet(true);
-
 
42811
    }
-
 
42812
 
-
 
42813
    public void unsetHoldQuantity() {
-
 
42814
      __isset_bit_vector.clear(__HOLDQUANTITY_ISSET_ID);
-
 
42815
    }
-
 
42816
 
-
 
42817
    /** Returns true if field holdQuantity is set (has been assigned a value) and false otherwise */
-
 
42818
    public boolean isSetHoldQuantity() {
-
 
42819
      return __isset_bit_vector.get(__HOLDQUANTITY_ISSET_ID);
-
 
42820
    }
-
 
42821
 
-
 
42822
    public void setHoldQuantityIsSet(boolean value) {
-
 
42823
      __isset_bit_vector.set(__HOLDQUANTITY_ISSET_ID, value);
-
 
42824
    }
-
 
42825
 
-
 
42826
    public long getSource() {
-
 
42827
      return this.source;
-
 
42828
    }
-
 
42829
 
-
 
42830
    public void setSource(long source) {
-
 
42831
      this.source = source;
-
 
42832
      setSourceIsSet(true);
-
 
42833
    }
-
 
42834
 
-
 
42835
    public void unsetSource() {
-
 
42836
      __isset_bit_vector.clear(__SOURCE_ISSET_ID);
-
 
42837
    }
-
 
42838
 
-
 
42839
    /** Returns true if field source is set (has been assigned a value) and false otherwise */
-
 
42840
    public boolean isSetSource() {
-
 
42841
      return __isset_bit_vector.get(__SOURCE_ISSET_ID);
-
 
42842
    }
-
 
42843
 
-
 
42844
    public void setSourceIsSet(boolean value) {
-
 
42845
      __isset_bit_vector.set(__SOURCE_ISSET_ID, value);
-
 
42846
    }
-
 
42847
 
-
 
42848
    public void setFieldValue(_Fields field, Object value) {
-
 
42849
      switch (field) {
-
 
42850
      case ITEM_ID:
-
 
42851
        if (value == null) {
-
 
42852
          unsetItemId();
-
 
42853
        } else {
-
 
42854
          setItemId((Long)value);
-
 
42855
        }
-
 
42856
        break;
-
 
42857
 
-
 
42858
      case WAREHOUSE_ID:
-
 
42859
        if (value == null) {
-
 
42860
          unsetWarehouseId();
-
 
42861
        } else {
-
 
42862
          setWarehouseId((Long)value);
-
 
42863
        }
-
 
42864
        break;
-
 
42865
 
-
 
42866
      case HOLD_QUANTITY:
-
 
42867
        if (value == null) {
-
 
42868
          unsetHoldQuantity();
-
 
42869
        } else {
-
 
42870
          setHoldQuantity((Long)value);
-
 
42871
        }
-
 
42872
        break;
-
 
42873
 
-
 
42874
      case SOURCE:
-
 
42875
        if (value == null) {
-
 
42876
          unsetSource();
-
 
42877
        } else {
-
 
42878
          setSource((Long)value);
-
 
42879
        }
-
 
42880
        break;
-
 
42881
 
-
 
42882
      }
-
 
42883
    }
-
 
42884
 
-
 
42885
    public Object getFieldValue(_Fields field) {
-
 
42886
      switch (field) {
-
 
42887
      case ITEM_ID:
-
 
42888
        return Long.valueOf(getItemId());
-
 
42889
 
-
 
42890
      case WAREHOUSE_ID:
-
 
42891
        return Long.valueOf(getWarehouseId());
-
 
42892
 
-
 
42893
      case HOLD_QUANTITY:
-
 
42894
        return Long.valueOf(getHoldQuantity());
-
 
42895
 
-
 
42896
      case SOURCE:
-
 
42897
        return Long.valueOf(getSource());
-
 
42898
 
-
 
42899
      }
-
 
42900
      throw new IllegalStateException();
-
 
42901
    }
-
 
42902
 
-
 
42903
    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
-
 
42904
    public boolean isSet(_Fields field) {
-
 
42905
      if (field == null) {
-
 
42906
        throw new IllegalArgumentException();
-
 
42907
      }
-
 
42908
 
-
 
42909
      switch (field) {
-
 
42910
      case ITEM_ID:
-
 
42911
        return isSetItemId();
-
 
42912
      case WAREHOUSE_ID:
-
 
42913
        return isSetWarehouseId();
-
 
42914
      case HOLD_QUANTITY:
-
 
42915
        return isSetHoldQuantity();
-
 
42916
      case SOURCE:
-
 
42917
        return isSetSource();
-
 
42918
      }
-
 
42919
      throw new IllegalStateException();
-
 
42920
    }
-
 
42921
 
-
 
42922
    @Override
-
 
42923
    public boolean equals(Object that) {
-
 
42924
      if (that == null)
-
 
42925
        return false;
-
 
42926
      if (that instanceof addUpdateHoldInventory_args)
-
 
42927
        return this.equals((addUpdateHoldInventory_args)that);
-
 
42928
      return false;
-
 
42929
    }
-
 
42930
 
-
 
42931
    public boolean equals(addUpdateHoldInventory_args that) {
-
 
42932
      if (that == null)
-
 
42933
        return false;
-
 
42934
 
-
 
42935
      boolean this_present_itemId = true;
-
 
42936
      boolean that_present_itemId = true;
-
 
42937
      if (this_present_itemId || that_present_itemId) {
-
 
42938
        if (!(this_present_itemId && that_present_itemId))
-
 
42939
          return false;
-
 
42940
        if (this.itemId != that.itemId)
-
 
42941
          return false;
-
 
42942
      }
-
 
42943
 
-
 
42944
      boolean this_present_warehouseId = true;
-
 
42945
      boolean that_present_warehouseId = true;
-
 
42946
      if (this_present_warehouseId || that_present_warehouseId) {
-
 
42947
        if (!(this_present_warehouseId && that_present_warehouseId))
-
 
42948
          return false;
-
 
42949
        if (this.warehouseId != that.warehouseId)
-
 
42950
          return false;
-
 
42951
      }
-
 
42952
 
-
 
42953
      boolean this_present_holdQuantity = true;
-
 
42954
      boolean that_present_holdQuantity = true;
-
 
42955
      if (this_present_holdQuantity || that_present_holdQuantity) {
-
 
42956
        if (!(this_present_holdQuantity && that_present_holdQuantity))
-
 
42957
          return false;
-
 
42958
        if (this.holdQuantity != that.holdQuantity)
-
 
42959
          return false;
-
 
42960
      }
-
 
42961
 
-
 
42962
      boolean this_present_source = true;
-
 
42963
      boolean that_present_source = true;
-
 
42964
      if (this_present_source || that_present_source) {
-
 
42965
        if (!(this_present_source && that_present_source))
-
 
42966
          return false;
-
 
42967
        if (this.source != that.source)
-
 
42968
          return false;
-
 
42969
      }
-
 
42970
 
-
 
42971
      return true;
-
 
42972
    }
-
 
42973
 
-
 
42974
    @Override
-
 
42975
    public int hashCode() {
-
 
42976
      return 0;
-
 
42977
    }
-
 
42978
 
-
 
42979
    public int compareTo(addUpdateHoldInventory_args other) {
-
 
42980
      if (!getClass().equals(other.getClass())) {
-
 
42981
        return getClass().getName().compareTo(other.getClass().getName());
-
 
42982
      }
-
 
42983
 
-
 
42984
      int lastComparison = 0;
-
 
42985
      addUpdateHoldInventory_args typedOther = (addUpdateHoldInventory_args)other;
-
 
42986
 
-
 
42987
      lastComparison = Boolean.valueOf(isSetItemId()).compareTo(typedOther.isSetItemId());
-
 
42988
      if (lastComparison != 0) {
-
 
42989
        return lastComparison;
-
 
42990
      }
-
 
42991
      if (isSetItemId()) {
-
 
42992
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.itemId, typedOther.itemId);
-
 
42993
        if (lastComparison != 0) {
-
 
42994
          return lastComparison;
-
 
42995
        }
-
 
42996
      }
-
 
42997
      lastComparison = Boolean.valueOf(isSetWarehouseId()).compareTo(typedOther.isSetWarehouseId());
-
 
42998
      if (lastComparison != 0) {
-
 
42999
        return lastComparison;
-
 
43000
      }
-
 
43001
      if (isSetWarehouseId()) {
-
 
43002
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.warehouseId, typedOther.warehouseId);
-
 
43003
        if (lastComparison != 0) {
-
 
43004
          return lastComparison;
-
 
43005
        }
-
 
43006
      }
-
 
43007
      lastComparison = Boolean.valueOf(isSetHoldQuantity()).compareTo(typedOther.isSetHoldQuantity());
-
 
43008
      if (lastComparison != 0) {
-
 
43009
        return lastComparison;
-
 
43010
      }
-
 
43011
      if (isSetHoldQuantity()) {
-
 
43012
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.holdQuantity, typedOther.holdQuantity);
-
 
43013
        if (lastComparison != 0) {
-
 
43014
          return lastComparison;
-
 
43015
        }
-
 
43016
      }
-
 
43017
      lastComparison = Boolean.valueOf(isSetSource()).compareTo(typedOther.isSetSource());
-
 
43018
      if (lastComparison != 0) {
-
 
43019
        return lastComparison;
-
 
43020
      }
-
 
43021
      if (isSetSource()) {
-
 
43022
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.source, typedOther.source);
-
 
43023
        if (lastComparison != 0) {
-
 
43024
          return lastComparison;
-
 
43025
        }
-
 
43026
      }
-
 
43027
      return 0;
-
 
43028
    }
-
 
43029
 
-
 
43030
    public _Fields fieldForId(int fieldId) {
-
 
43031
      return _Fields.findByThriftId(fieldId);
-
 
43032
    }
-
 
43033
 
-
 
43034
    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
-
 
43035
      org.apache.thrift.protocol.TField field;
-
 
43036
      iprot.readStructBegin();
-
 
43037
      while (true)
-
 
43038
      {
-
 
43039
        field = iprot.readFieldBegin();
-
 
43040
        if (field.type == org.apache.thrift.protocol.TType.STOP) { 
-
 
43041
          break;
-
 
43042
        }
-
 
43043
        switch (field.id) {
-
 
43044
          case 1: // ITEM_ID
-
 
43045
            if (field.type == org.apache.thrift.protocol.TType.I64) {
-
 
43046
              this.itemId = iprot.readI64();
-
 
43047
              setItemIdIsSet(true);
-
 
43048
            } else { 
-
 
43049
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
-
 
43050
            }
-
 
43051
            break;
-
 
43052
          case 2: // WAREHOUSE_ID
-
 
43053
            if (field.type == org.apache.thrift.protocol.TType.I64) {
-
 
43054
              this.warehouseId = iprot.readI64();
-
 
43055
              setWarehouseIdIsSet(true);
-
 
43056
            } else { 
-
 
43057
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
-
 
43058
            }
-
 
43059
            break;
-
 
43060
          case 3: // HOLD_QUANTITY
-
 
43061
            if (field.type == org.apache.thrift.protocol.TType.I64) {
-
 
43062
              this.holdQuantity = iprot.readI64();
-
 
43063
              setHoldQuantityIsSet(true);
-
 
43064
            } else { 
-
 
43065
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
-
 
43066
            }
-
 
43067
            break;
-
 
43068
          case 4: // SOURCE
-
 
43069
            if (field.type == org.apache.thrift.protocol.TType.I64) {
-
 
43070
              this.source = iprot.readI64();
-
 
43071
              setSourceIsSet(true);
-
 
43072
            } else { 
-
 
43073
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
-
 
43074
            }
-
 
43075
            break;
-
 
43076
          default:
-
 
43077
            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
-
 
43078
        }
-
 
43079
        iprot.readFieldEnd();
-
 
43080
      }
-
 
43081
      iprot.readStructEnd();
-
 
43082
      validate();
-
 
43083
    }
-
 
43084
 
-
 
43085
    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
-
 
43086
      validate();
-
 
43087
 
-
 
43088
      oprot.writeStructBegin(STRUCT_DESC);
-
 
43089
      oprot.writeFieldBegin(ITEM_ID_FIELD_DESC);
-
 
43090
      oprot.writeI64(this.itemId);
-
 
43091
      oprot.writeFieldEnd();
-
 
43092
      oprot.writeFieldBegin(WAREHOUSE_ID_FIELD_DESC);
-
 
43093
      oprot.writeI64(this.warehouseId);
-
 
43094
      oprot.writeFieldEnd();
-
 
43095
      oprot.writeFieldBegin(HOLD_QUANTITY_FIELD_DESC);
-
 
43096
      oprot.writeI64(this.holdQuantity);
-
 
43097
      oprot.writeFieldEnd();
-
 
43098
      oprot.writeFieldBegin(SOURCE_FIELD_DESC);
-
 
43099
      oprot.writeI64(this.source);
-
 
43100
      oprot.writeFieldEnd();
-
 
43101
      oprot.writeFieldStop();
-
 
43102
      oprot.writeStructEnd();
-
 
43103
    }
-
 
43104
 
-
 
43105
    @Override
-
 
43106
    public String toString() {
-
 
43107
      StringBuilder sb = new StringBuilder("addUpdateHoldInventory_args(");
-
 
43108
      boolean first = true;
-
 
43109
 
-
 
43110
      sb.append("itemId:");
-
 
43111
      sb.append(this.itemId);
-
 
43112
      first = false;
-
 
43113
      if (!first) sb.append(", ");
-
 
43114
      sb.append("warehouseId:");
-
 
43115
      sb.append(this.warehouseId);
-
 
43116
      first = false;
-
 
43117
      if (!first) sb.append(", ");
-
 
43118
      sb.append("holdQuantity:");
-
 
43119
      sb.append(this.holdQuantity);
-
 
43120
      first = false;
-
 
43121
      if (!first) sb.append(", ");
-
 
43122
      sb.append("source:");
-
 
43123
      sb.append(this.source);
-
 
43124
      first = false;
-
 
43125
      sb.append(")");
-
 
43126
      return sb.toString();
-
 
43127
    }
-
 
43128
 
-
 
43129
    public void validate() throws org.apache.thrift.TException {
-
 
43130
      // check for required fields
-
 
43131
    }
-
 
43132
 
-
 
43133
    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
-
 
43134
      try {
-
 
43135
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
-
 
43136
      } catch (org.apache.thrift.TException te) {
-
 
43137
        throw new java.io.IOException(te);
-
 
43138
      }
-
 
43139
    }
-
 
43140
 
-
 
43141
    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
-
 
43142
      try {
-
 
43143
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
-
 
43144
        __isset_bit_vector = new BitSet(1);
-
 
43145
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
-
 
43146
      } catch (org.apache.thrift.TException te) {
-
 
43147
        throw new java.io.IOException(te);
-
 
43148
      }
-
 
43149
    }
-
 
43150
 
-
 
43151
  }
-
 
43152
 
-
 
43153
  public static class addUpdateHoldInventory_result implements org.apache.thrift.TBase<addUpdateHoldInventory_result, addUpdateHoldInventory_result._Fields>, java.io.Serializable, Cloneable   {
-
 
43154
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("addUpdateHoldInventory_result");
-
 
43155
 
-
 
43156
 
-
 
43157
 
-
 
43158
    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
-
 
43159
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
-
 
43160
;
-
 
43161
 
-
 
43162
      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
-
 
43163
 
-
 
43164
      static {
-
 
43165
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
-
 
43166
          byName.put(field.getFieldName(), field);
-
 
43167
        }
-
 
43168
      }
-
 
43169
 
-
 
43170
      /**
-
 
43171
       * Find the _Fields constant that matches fieldId, or null if its not found.
-
 
43172
       */
-
 
43173
      public static _Fields findByThriftId(int fieldId) {
-
 
43174
        switch(fieldId) {
-
 
43175
          default:
-
 
43176
            return null;
-
 
43177
        }
-
 
43178
      }
-
 
43179
 
-
 
43180
      /**
-
 
43181
       * Find the _Fields constant that matches fieldId, throwing an exception
-
 
43182
       * if it is not found.
-
 
43183
       */
-
 
43184
      public static _Fields findByThriftIdOrThrow(int fieldId) {
-
 
43185
        _Fields fields = findByThriftId(fieldId);
-
 
43186
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
-
 
43187
        return fields;
-
 
43188
      }
-
 
43189
 
-
 
43190
      /**
-
 
43191
       * Find the _Fields constant that matches name, or null if its not found.
-
 
43192
       */
-
 
43193
      public static _Fields findByName(String name) {
-
 
43194
        return byName.get(name);
-
 
43195
      }
-
 
43196
 
-
 
43197
      private final short _thriftId;
-
 
43198
      private final String _fieldName;
-
 
43199
 
-
 
43200
      _Fields(short thriftId, String fieldName) {
-
 
43201
        _thriftId = thriftId;
-
 
43202
        _fieldName = fieldName;
-
 
43203
      }
-
 
43204
 
-
 
43205
      public short getThriftFieldId() {
-
 
43206
        return _thriftId;
-
 
43207
      }
-
 
43208
 
-
 
43209
      public String getFieldName() {
-
 
43210
        return _fieldName;
-
 
43211
      }
-
 
43212
    }
-
 
43213
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
-
 
43214
    static {
-
 
43215
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
-
 
43216
      metaDataMap = Collections.unmodifiableMap(tmpMap);
-
 
43217
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(addUpdateHoldInventory_result.class, metaDataMap);
-
 
43218
    }
-
 
43219
 
-
 
43220
    public addUpdateHoldInventory_result() {
-
 
43221
    }
-
 
43222
 
-
 
43223
    /**
-
 
43224
     * Performs a deep copy on <i>other</i>.
-
 
43225
     */
-
 
43226
    public addUpdateHoldInventory_result(addUpdateHoldInventory_result other) {
-
 
43227
    }
-
 
43228
 
-
 
43229
    public addUpdateHoldInventory_result deepCopy() {
-
 
43230
      return new addUpdateHoldInventory_result(this);
-
 
43231
    }
-
 
43232
 
-
 
43233
    @Override
-
 
43234
    public void clear() {
-
 
43235
    }
-
 
43236
 
-
 
43237
    public void setFieldValue(_Fields field, Object value) {
-
 
43238
      switch (field) {
-
 
43239
      }
-
 
43240
    }
-
 
43241
 
-
 
43242
    public Object getFieldValue(_Fields field) {
-
 
43243
      switch (field) {
-
 
43244
      }
-
 
43245
      throw new IllegalStateException();
-
 
43246
    }
-
 
43247
 
-
 
43248
    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
-
 
43249
    public boolean isSet(_Fields field) {
-
 
43250
      if (field == null) {
-
 
43251
        throw new IllegalArgumentException();
-
 
43252
      }
-
 
43253
 
-
 
43254
      switch (field) {
-
 
43255
      }
-
 
43256
      throw new IllegalStateException();
-
 
43257
    }
-
 
43258
 
-
 
43259
    @Override
-
 
43260
    public boolean equals(Object that) {
-
 
43261
      if (that == null)
-
 
43262
        return false;
-
 
43263
      if (that instanceof addUpdateHoldInventory_result)
-
 
43264
        return this.equals((addUpdateHoldInventory_result)that);
-
 
43265
      return false;
-
 
43266
    }
-
 
43267
 
-
 
43268
    public boolean equals(addUpdateHoldInventory_result that) {
-
 
43269
      if (that == null)
-
 
43270
        return false;
-
 
43271
 
-
 
43272
      return true;
-
 
43273
    }
-
 
43274
 
-
 
43275
    @Override
-
 
43276
    public int hashCode() {
-
 
43277
      return 0;
-
 
43278
    }
-
 
43279
 
-
 
43280
    public int compareTo(addUpdateHoldInventory_result other) {
-
 
43281
      if (!getClass().equals(other.getClass())) {
-
 
43282
        return getClass().getName().compareTo(other.getClass().getName());
-
 
43283
      }
-
 
43284
 
-
 
43285
      int lastComparison = 0;
-
 
43286
      addUpdateHoldInventory_result typedOther = (addUpdateHoldInventory_result)other;
-
 
43287
 
-
 
43288
      return 0;
-
 
43289
    }
-
 
43290
 
-
 
43291
    public _Fields fieldForId(int fieldId) {
-
 
43292
      return _Fields.findByThriftId(fieldId);
-
 
43293
    }
-
 
43294
 
-
 
43295
    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
-
 
43296
      org.apache.thrift.protocol.TField field;
-
 
43297
      iprot.readStructBegin();
-
 
43298
      while (true)
-
 
43299
      {
-
 
43300
        field = iprot.readFieldBegin();
-
 
43301
        if (field.type == org.apache.thrift.protocol.TType.STOP) { 
-
 
43302
          break;
-
 
43303
        }
-
 
43304
        switch (field.id) {
-
 
43305
          default:
-
 
43306
            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
-
 
43307
        }
-
 
43308
        iprot.readFieldEnd();
-
 
43309
      }
-
 
43310
      iprot.readStructEnd();
-
 
43311
      validate();
-
 
43312
    }
-
 
43313
 
-
 
43314
    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
-
 
43315
      oprot.writeStructBegin(STRUCT_DESC);
-
 
43316
 
-
 
43317
      oprot.writeFieldStop();
-
 
43318
      oprot.writeStructEnd();
-
 
43319
    }
-
 
43320
 
-
 
43321
    @Override
-
 
43322
    public String toString() {
-
 
43323
      StringBuilder sb = new StringBuilder("addUpdateHoldInventory_result(");
-
 
43324
      boolean first = true;
-
 
43325
 
-
 
43326
      sb.append(")");
-
 
43327
      return sb.toString();
-
 
43328
    }
-
 
43329
 
-
 
43330
    public void validate() throws org.apache.thrift.TException {
42504
      // check for required fields
43331
      // check for required fields
42505
    }
43332
    }
42506
 
43333
 
42507
    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
43334
    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
42508
      try {
43335
      try {