WebSVN – SmartDukaan – Diff – /trunk/ThriftConfig/src/main/java/in/shop2020/purchase/LineItem.java

   private static final org.apache.thrift.protocol.TField UNFULFILLED_QUANTITY_FIELD_DESC = new org.apache.thrift.protocol.TField("unfulfilledQuantity", org.apache.thrift.protocol.TType.DOUBLE, (short)10);
   private static final org.apache.thrift.protocol.TField CREATED_AT_FIELD_DESC = new org.apache.thrift.protocol.TField("createdAt", org.apache.thrift.protocol.TType.I64, (short)11);
   private static final org.apache.thrift.protocol.TField UNIT_PRICE_FIELD_DESC = new org.apache.thrift.protocol.TField("unitPrice", org.apache.thrift.protocol.TType.DOUBLE, (short)12);
   private static final org.apache.thrift.protocol.TField FULFILLED_FIELD_DESC = new org.apache.thrift.protocol.TField("fulfilled", org.apache.thrift.protocol.TType.BOOL, (short)13);
   private static final org.apache.thrift.protocol.TField COD_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("codCount", org.apache.thrift.protocol.TType.I64, (short)14);
+  private static final org.apache.thrift.protocol.TField AVAILABLE_QUANTITY_FIELD_DESC = new org.apache.thrift.protocol.TField("availableQuantity", org.apache.thrift.protocol.TType.I64, (short)15);
+  private static final org.apache.thrift.protocol.TField RESERVED_QUANTITY_FIELD_DESC = new org.apache.thrift.protocol.TField("reservedQuantity", org.apache.thrift.protocol.TType.I64, (short)16);
+  private static final org.apache.thrift.protocol.TField AVG_SALES_FIELD_DESC = new org.apache.thrift.protocol.TField("avgSales", org.apache.thrift.protocol.TType.DOUBLE, (short)17);
+  private static final org.apache.thrift.protocol.TField MIN_STOCK_LEVEL_FIELD_DESC = new org.apache.thrift.protocol.TField("minStockLevel", org.apache.thrift.protocol.TType.I64, (short)18);
+  private static final org.apache.thrift.protocol.TField NUMBER_OF_DAYS_STOCK_FIELD_DESC = new org.apache.thrift.protocol.TField("numberOfDaysStock", org.apache.thrift.protocol.TType.I64, (short)19);
+  private static final org.apache.thrift.protocol.TField SUGGESTED_QUANTITY_FIELD_DESC = new org.apache.thrift.protocol.TField("suggestedQuantity", org.apache.thrift.protocol.TType.I64, (short)20);
+  private static final org.apache.thrift.protocol.TField NUMBER_OF_DAYS_IN_STOCK_FIELD_DESC = new org.apache.thrift.protocol.TField("numberOfDaysInStock", org.apache.thrift.protocol.TType.I64, (short)21);
   private long orderId; // required
   private long itemId; // required
   private String productGroup; // required
   private String brand; // required
   private double unfulfilledQuantity; // required
   private long createdAt; // required
   private double unitPrice; // required
   private boolean fulfilled; // required
   private long codCount; // required
+  private long availableQuantity; // required
+  private long reservedQuantity; // required
+  private double avgSales; // required
+  private long minStockLevel; // required
+  private long numberOfDaysStock; // required
+  private long suggestedQuantity; // required
+  private long numberOfDaysInStock; // required
   /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
   public enum _Fields implements org.apache.thrift.TFieldIdEnum {
     ORDER_ID((short)1, "orderId"),
     ITEM_ID((short)2, "itemId"),
     QUANTITY((short)9, "quantity"),
     UNFULFILLED_QUANTITY((short)10, "unfulfilledQuantity"),
     CREATED_AT((short)11, "createdAt"),
     UNIT_PRICE((short)12, "unitPrice"),
     FULFILLED((short)13, "fulfilled"),
-    COD_COUNT((short)14, "codCount");
+    COD_COUNT((short)14, "codCount"),
+    AVAILABLE_QUANTITY((short)15, "availableQuantity"),
+    RESERVED_QUANTITY((short)16, "reservedQuantity"),
+    AVG_SALES((short)17, "avgSales"),
+    MIN_STOCK_LEVEL((short)18, "minStockLevel"),
+    NUMBER_OF_DAYS_STOCK((short)19, "numberOfDaysStock"),
+    SUGGESTED_QUANTITY((short)20, "suggestedQuantity"),
+    NUMBER_OF_DAYS_IN_STOCK((short)21, "numberOfDaysInStock");
     private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
     static {
       for (_Fields field : EnumSet.allOf(_Fields.class)) {
           return UNIT_PRICE;
         case 13: // FULFILLED
           return FULFILLED;
         case 14: // COD_COUNT
           return COD_COUNT;
+        case 15: // AVAILABLE_QUANTITY
+          return AVAILABLE_QUANTITY;
+        case 16: // RESERVED_QUANTITY
+          return RESERVED_QUANTITY;
+        case 17: // AVG_SALES
+          return AVG_SALES;
+        case 18: // MIN_STOCK_LEVEL
+          return MIN_STOCK_LEVEL;
+        case 19: // NUMBER_OF_DAYS_STOCK
+          return NUMBER_OF_DAYS_STOCK;
+        case 20: // SUGGESTED_QUANTITY
+          return SUGGESTED_QUANTITY;
+        case 21: // NUMBER_OF_DAYS_IN_STOCK
+          return NUMBER_OF_DAYS_IN_STOCK;
         default:
           return null;
+      }
+    }
   private static final int __UNFULFILLEDQUANTITY_ISSET_ID = 3;
   private static final int __CREATEDAT_ISSET_ID = 4;
   private static final int __UNITPRICE_ISSET_ID = 5;
   private static final int __FULFILLED_ISSET_ID = 6;
   private static final int __CODCOUNT_ISSET_ID = 7;
+  private static final int __AVAILABLEQUANTITY_ISSET_ID = 8;
+  private static final int __RESERVEDQUANTITY_ISSET_ID = 9;
+  private static final int __AVGSALES_ISSET_ID = 10;
+  private static final int __MINSTOCKLEVEL_ISSET_ID = 11;
+  private static final int __NUMBEROFDAYSSTOCK_ISSET_ID = 12;
+  private static final int __SUGGESTEDQUANTITY_ISSET_ID = 13;
+  private static final int __NUMBEROFDAYSINSTOCK_ISSET_ID = 14;
-  private BitSet __isset_bit_vector = new BitSet(8);
+  private BitSet __isset_bit_vector = new BitSet(15);
   public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
   static {
     Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
     tmpMap.put(_Fields.ORDER_ID, new org.apache.thrift.meta_data.FieldMetaData("orderId", org.apache.thrift.TFieldRequirementType.DEFAULT,
         new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
     tmpMap.put(_Fields.FULFILLED, new org.apache.thrift.meta_data.FieldMetaData("fulfilled", org.apache.thrift.TFieldRequirementType.DEFAULT,
         new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
     tmpMap.put(_Fields.COD_COUNT, new org.apache.thrift.meta_data.FieldMetaData("codCount", org.apache.thrift.TFieldRequirementType.DEFAULT,
         new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+    tmpMap.put(_Fields.AVAILABLE_QUANTITY, new org.apache.thrift.meta_data.FieldMetaData("availableQuantity", org.apache.thrift.TFieldRequirementType.DEFAULT,
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+    tmpMap.put(_Fields.RESERVED_QUANTITY, new org.apache.thrift.meta_data.FieldMetaData("reservedQuantity", org.apache.thrift.TFieldRequirementType.DEFAULT,
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+    tmpMap.put(_Fields.AVG_SALES, new org.apache.thrift.meta_data.FieldMetaData("avgSales", org.apache.thrift.TFieldRequirementType.DEFAULT,
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
+    tmpMap.put(_Fields.MIN_STOCK_LEVEL, new org.apache.thrift.meta_data.FieldMetaData("minStockLevel", org.apache.thrift.TFieldRequirementType.DEFAULT,
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+    tmpMap.put(_Fields.NUMBER_OF_DAYS_STOCK, new org.apache.thrift.meta_data.FieldMetaData("numberOfDaysStock", org.apache.thrift.TFieldRequirementType.DEFAULT,
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+    tmpMap.put(_Fields.SUGGESTED_QUANTITY, new org.apache.thrift.meta_data.FieldMetaData("suggestedQuantity", org.apache.thrift.TFieldRequirementType.DEFAULT,
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+    tmpMap.put(_Fields.NUMBER_OF_DAYS_IN_STOCK, new org.apache.thrift.meta_data.FieldMetaData("numberOfDaysInStock", org.apache.thrift.TFieldRequirementType.DEFAULT,
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
     metaDataMap = Collections.unmodifiableMap(tmpMap);
     org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(LineItem.class, metaDataMap);
+  }
   public LineItem() {
     double quantity,
     double unfulfilledQuantity,
     long createdAt,
     double unitPrice,
     boolean fulfilled,
-    long codCount)
+    long codCount,
+    long availableQuantity,
+    long reservedQuantity,
+    double avgSales,
+    long minStockLevel,
+    long numberOfDaysStock,
+    long suggestedQuantity,
+    long numberOfDaysInStock)
+  {
     this();
     this.orderId = orderId;
     setOrderIdIsSet(true);
     this.itemId = itemId;
     setUnitPriceIsSet(true);
     this.fulfilled = fulfilled;
     setFulfilledIsSet(true);
     this.codCount = codCount;
     setCodCountIsSet(true);
+    this.availableQuantity = availableQuantity;
+    setAvailableQuantityIsSet(true);
+    this.reservedQuantity = reservedQuantity;
+    setReservedQuantityIsSet(true);
+    this.avgSales = avgSales;
+    setAvgSalesIsSet(true);
+    this.minStockLevel = minStockLevel;
+    setMinStockLevelIsSet(true);
+    this.numberOfDaysStock = numberOfDaysStock;
+    setNumberOfDaysStockIsSet(true);
+    this.suggestedQuantity = suggestedQuantity;
+    setSuggestedQuantityIsSet(true);
+    this.numberOfDaysInStock = numberOfDaysInStock;
+    setNumberOfDaysInStockIsSet(true);
+  }
   /**
    * Performs a deep copy on <i>other</i>.
    */
     this.unfulfilledQuantity = other.unfulfilledQuantity;
     this.createdAt = other.createdAt;
     this.unitPrice = other.unitPrice;
     this.fulfilled = other.fulfilled;
     this.codCount = other.codCount;
+    this.availableQuantity = other.availableQuantity;
+    this.reservedQuantity = other.reservedQuantity;
+    this.avgSales = other.avgSales;
+    this.minStockLevel = other.minStockLevel;
+    this.numberOfDaysStock = other.numberOfDaysStock;
+    this.suggestedQuantity = other.suggestedQuantity;
+    this.numberOfDaysInStock = other.numberOfDaysInStock;
+  }
   public LineItem deepCopy() {
     return new LineItem(this);
+  }
     this.unitPrice = 0.0;
     setFulfilledIsSet(false);
     this.fulfilled = false;
     setCodCountIsSet(false);
     this.codCount = 0;
+    setAvailableQuantityIsSet(false);
+    this.availableQuantity = 0;
+    setReservedQuantityIsSet(false);
+    this.reservedQuantity = 0;
+    setAvgSalesIsSet(false);
+    this.avgSales = 0.0;
+    setMinStockLevelIsSet(false);
+    this.minStockLevel = 0;
+    setNumberOfDaysStockIsSet(false);
+    this.numberOfDaysStock = 0;
+    setSuggestedQuantityIsSet(false);
+    this.suggestedQuantity = 0;
+    setNumberOfDaysInStockIsSet(false);
+    this.numberOfDaysInStock = 0;
+  }
   public long getOrderId() {
     return this.orderId;
+  }
   public void setCodCountIsSet(boolean value) {
     __isset_bit_vector.set(__CODCOUNT_ISSET_ID, value);
+  }
+  public long getAvailableQuantity() {
+    return this.availableQuantity;
+  }
+  public void setAvailableQuantity(long availableQuantity) {
+    this.availableQuantity = availableQuantity;
+    setAvailableQuantityIsSet(true);
+  }
+  public void unsetAvailableQuantity() {
+    __isset_bit_vector.clear(__AVAILABLEQUANTITY_ISSET_ID);
+  }
+  /** Returns true if field availableQuantity is set (has been assigned a value) and false otherwise */
+  public boolean isSetAvailableQuantity() {
+    return __isset_bit_vector.get(__AVAILABLEQUANTITY_ISSET_ID);
+  }
+  public void setAvailableQuantityIsSet(boolean value) {
+    __isset_bit_vector.set(__AVAILABLEQUANTITY_ISSET_ID, value);
+  }
+  public long getReservedQuantity() {
+    return this.reservedQuantity;
+  }
+  public void setReservedQuantity(long reservedQuantity) {
+    this.reservedQuantity = reservedQuantity;
+    setReservedQuantityIsSet(true);
+  }
+  public void unsetReservedQuantity() {
+    __isset_bit_vector.clear(__RESERVEDQUANTITY_ISSET_ID);
+  }
+  /** Returns true if field reservedQuantity is set (has been assigned a value) and false otherwise */
+  public boolean isSetReservedQuantity() {
+    return __isset_bit_vector.get(__RESERVEDQUANTITY_ISSET_ID);
+  }
+  public void setReservedQuantityIsSet(boolean value) {
+    __isset_bit_vector.set(__RESERVEDQUANTITY_ISSET_ID, value);
+  }
+  public double getAvgSales() {
+    return this.avgSales;
+  }
+  public void setAvgSales(double avgSales) {
+    this.avgSales = avgSales;
+    setAvgSalesIsSet(true);
+  }
+  public void unsetAvgSales() {
+    __isset_bit_vector.clear(__AVGSALES_ISSET_ID);
+  }
+  /** Returns true if field avgSales is set (has been assigned a value) and false otherwise */
+  public boolean isSetAvgSales() {
+    return __isset_bit_vector.get(__AVGSALES_ISSET_ID);
+  }
+  public void setAvgSalesIsSet(boolean value) {
+    __isset_bit_vector.set(__AVGSALES_ISSET_ID, value);
+  }
+  public long getMinStockLevel() {
+    return this.minStockLevel;
+  }
+  public void setMinStockLevel(long minStockLevel) {
+    this.minStockLevel = minStockLevel;
+    setMinStockLevelIsSet(true);
+  }
+  public void unsetMinStockLevel() {
+    __isset_bit_vector.clear(__MINSTOCKLEVEL_ISSET_ID);
+  }
+  /** Returns true if field minStockLevel is set (has been assigned a value) and false otherwise */
+  public boolean isSetMinStockLevel() {
+    return __isset_bit_vector.get(__MINSTOCKLEVEL_ISSET_ID);
+  }
+  public void setMinStockLevelIsSet(boolean value) {
+    __isset_bit_vector.set(__MINSTOCKLEVEL_ISSET_ID, value);
+  }
+  public long getNumberOfDaysStock() {
+    return this.numberOfDaysStock;
+  }
+  public void setNumberOfDaysStock(long numberOfDaysStock) {
+    this.numberOfDaysStock = numberOfDaysStock;
+    setNumberOfDaysStockIsSet(true);
+  }
+  public void unsetNumberOfDaysStock() {
+    __isset_bit_vector.clear(__NUMBEROFDAYSSTOCK_ISSET_ID);
+  }
+  /** Returns true if field numberOfDaysStock is set (has been assigned a value) and false otherwise */
+  public boolean isSetNumberOfDaysStock() {
+    return __isset_bit_vector.get(__NUMBEROFDAYSSTOCK_ISSET_ID);
+  }
+  public void setNumberOfDaysStockIsSet(boolean value) {
+    __isset_bit_vector.set(__NUMBEROFDAYSSTOCK_ISSET_ID, value);
+  }
+  public long getSuggestedQuantity() {
+    return this.suggestedQuantity;
+  }
+  public void setSuggestedQuantity(long suggestedQuantity) {
+    this.suggestedQuantity = suggestedQuantity;
+    setSuggestedQuantityIsSet(true);
+  }
+  public void unsetSuggestedQuantity() {
+    __isset_bit_vector.clear(__SUGGESTEDQUANTITY_ISSET_ID);
+  }
+  /** Returns true if field suggestedQuantity is set (has been assigned a value) and false otherwise */
+  public boolean isSetSuggestedQuantity() {
+    return __isset_bit_vector.get(__SUGGESTEDQUANTITY_ISSET_ID);
+  }
+  public void setSuggestedQuantityIsSet(boolean value) {
+    __isset_bit_vector.set(__SUGGESTEDQUANTITY_ISSET_ID, value);
+  }
+  public long getNumberOfDaysInStock() {
+    return this.numberOfDaysInStock;
+  }
+  public void setNumberOfDaysInStock(long numberOfDaysInStock) {
+    this.numberOfDaysInStock = numberOfDaysInStock;
+    setNumberOfDaysInStockIsSet(true);
+  }
+  public void unsetNumberOfDaysInStock() {
+    __isset_bit_vector.clear(__NUMBEROFDAYSINSTOCK_ISSET_ID);
+  }
+  /** Returns true if field numberOfDaysInStock is set (has been assigned a value) and false otherwise */
+  public boolean isSetNumberOfDaysInStock() {
+    return __isset_bit_vector.get(__NUMBEROFDAYSINSTOCK_ISSET_ID);
+  }
+  public void setNumberOfDaysInStockIsSet(boolean value) {
+    __isset_bit_vector.set(__NUMBEROFDAYSINSTOCK_ISSET_ID, value);
+  }
   public void setFieldValue(_Fields field, Object value) {
     switch (field) {
     case ORDER_ID:
       if (value == null) {
         unsetOrderId();
       } else {
         setCodCount((Long)value);
+      }
       break;
+    case AVAILABLE_QUANTITY:
+      if (value == null) {
+        unsetAvailableQuantity();
+      } else {
+        setAvailableQuantity((Long)value);
+      }
+      break;
+    case RESERVED_QUANTITY:
+      if (value == null) {
+        unsetReservedQuantity();
+      } else {
+        setReservedQuantity((Long)value);
+      }
+      break;
+    case AVG_SALES:
+      if (value == null) {
+        unsetAvgSales();
+      } else {
+        setAvgSales((Double)value);
+      }
+      break;
+    case MIN_STOCK_LEVEL:
+      if (value == null) {
+        unsetMinStockLevel();
+      } else {
+        setMinStockLevel((Long)value);
+      }
+      break;
+    case NUMBER_OF_DAYS_STOCK:
+      if (value == null) {
+        unsetNumberOfDaysStock();
+      } else {
+        setNumberOfDaysStock((Long)value);
+      }
+      break;
+    case SUGGESTED_QUANTITY:
+      if (value == null) {
+        unsetSuggestedQuantity();
+      } else {
+        setSuggestedQuantity((Long)value);
+      }
+      break;
+    case NUMBER_OF_DAYS_IN_STOCK:
+      if (value == null) {
+        unsetNumberOfDaysInStock();
+      } else {
+        setNumberOfDaysInStock((Long)value);
+      }
+      break;
+    }
+  }
   public Object getFieldValue(_Fields field) {
     switch (field) {
       return Boolean.valueOf(isFulfilled());
     case COD_COUNT:
       return Long.valueOf(getCodCount());
+    case AVAILABLE_QUANTITY:
+      return Long.valueOf(getAvailableQuantity());
+    case RESERVED_QUANTITY:
+      return Long.valueOf(getReservedQuantity());
+    case AVG_SALES:
+      return Double.valueOf(getAvgSales());
+    case MIN_STOCK_LEVEL:
+      return Long.valueOf(getMinStockLevel());
+    case NUMBER_OF_DAYS_STOCK:
+      return Long.valueOf(getNumberOfDaysStock());
+    case SUGGESTED_QUANTITY:
+      return Long.valueOf(getSuggestedQuantity());
+    case NUMBER_OF_DAYS_IN_STOCK:
+      return Long.valueOf(getNumberOfDaysInStock());
+    }
     throw new IllegalStateException();
+  }
   /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
       return isSetUnitPrice();
     case FULFILLED:
       return isSetFulfilled();
     case COD_COUNT:
       return isSetCodCount();
+    case AVAILABLE_QUANTITY:
+      return isSetAvailableQuantity();
+    case RESERVED_QUANTITY:
+      return isSetReservedQuantity();
+    case AVG_SALES:
+      return isSetAvgSales();
+    case MIN_STOCK_LEVEL:
+      return isSetMinStockLevel();
+    case NUMBER_OF_DAYS_STOCK:
+      return isSetNumberOfDaysStock();
+    case SUGGESTED_QUANTITY:
+      return isSetSuggestedQuantity();
+    case NUMBER_OF_DAYS_IN_STOCK:
+      return isSetNumberOfDaysInStock();
+    }
     throw new IllegalStateException();
+  }
   @Override
         return false;
       if (this.codCount != that.codCount)
         return false;
+    }
+    boolean this_present_availableQuantity = true;
+    boolean that_present_availableQuantity = true;
+    if (this_present_availableQuantity || that_present_availableQuantity) {
+      if (!(this_present_availableQuantity && that_present_availableQuantity))
+        return false;
+      if (this.availableQuantity != that.availableQuantity)
+        return false;
+    }
+    boolean this_present_reservedQuantity = true;
+    boolean that_present_reservedQuantity = true;
+    if (this_present_reservedQuantity || that_present_reservedQuantity) {
+      if (!(this_present_reservedQuantity && that_present_reservedQuantity))
+        return false;
+      if (this.reservedQuantity != that.reservedQuantity)
+        return false;
+    }
+    boolean this_present_avgSales = true;
+    boolean that_present_avgSales = true;
+    if (this_present_avgSales || that_present_avgSales) {
+      if (!(this_present_avgSales && that_present_avgSales))
+        return false;
+      if (this.avgSales != that.avgSales)
+        return false;
+    }
+    boolean this_present_minStockLevel = true;
+    boolean that_present_minStockLevel = true;
+    if (this_present_minStockLevel || that_present_minStockLevel) {
+      if (!(this_present_minStockLevel && that_present_minStockLevel))
+        return false;
+      if (this.minStockLevel != that.minStockLevel)
+        return false;
+    }
+    boolean this_present_numberOfDaysStock = true;
+    boolean that_present_numberOfDaysStock = true;
+    if (this_present_numberOfDaysStock || that_present_numberOfDaysStock) {
+      if (!(this_present_numberOfDaysStock && that_present_numberOfDaysStock))
+        return false;
+      if (this.numberOfDaysStock != that.numberOfDaysStock)
+        return false;
+    }
+    boolean this_present_suggestedQuantity = true;
+    boolean that_present_suggestedQuantity = true;
+    if (this_present_suggestedQuantity || that_present_suggestedQuantity) {
+      if (!(this_present_suggestedQuantity && that_present_suggestedQuantity))
+        return false;
+      if (this.suggestedQuantity != that.suggestedQuantity)
+        return false;
+    }
+    boolean this_present_numberOfDaysInStock = true;
+    boolean that_present_numberOfDaysInStock = true;
+    if (this_present_numberOfDaysInStock || that_present_numberOfDaysInStock) {
+      if (!(this_present_numberOfDaysInStock && that_present_numberOfDaysInStock))
+        return false;
+      if (this.numberOfDaysInStock != that.numberOfDaysInStock)
+        return false;
+    }
     return true;
+  }
   @Override
   public int hashCode() {
       lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.codCount, typedOther.codCount);
       if (lastComparison != 0) {
         return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetAvailableQuantity()).compareTo(typedOther.isSetAvailableQuantity());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetAvailableQuantity()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.availableQuantity, typedOther.availableQuantity);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetReservedQuantity()).compareTo(typedOther.isSetReservedQuantity());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetReservedQuantity()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.reservedQuantity, typedOther.reservedQuantity);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetAvgSales()).compareTo(typedOther.isSetAvgSales());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetAvgSales()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.avgSales, typedOther.avgSales);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetMinStockLevel()).compareTo(typedOther.isSetMinStockLevel());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetMinStockLevel()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.minStockLevel, typedOther.minStockLevel);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetNumberOfDaysStock()).compareTo(typedOther.isSetNumberOfDaysStock());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetNumberOfDaysStock()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numberOfDaysStock, typedOther.numberOfDaysStock);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetSuggestedQuantity()).compareTo(typedOther.isSetSuggestedQuantity());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetSuggestedQuantity()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.suggestedQuantity, typedOther.suggestedQuantity);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetNumberOfDaysInStock()).compareTo(typedOther.isSetNumberOfDaysInStock());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetNumberOfDaysInStock()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numberOfDaysInStock, typedOther.numberOfDaysInStock);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
     return 0;
+  }
   public _Fields fieldForId(int fieldId) {
     return _Fields.findByThriftId(fieldId);
             setCodCountIsSet(true);
           } else {
             org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+          }
           break;
+        case 15: // AVAILABLE_QUANTITY
+          if (field.type == org.apache.thrift.protocol.TType.I64) {
+            this.availableQuantity = iprot.readI64();
+            setAvailableQuantityIsSet(true);
+          } else {
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        case 16: // RESERVED_QUANTITY
+          if (field.type == org.apache.thrift.protocol.TType.I64) {
+            this.reservedQuantity = iprot.readI64();
+            setReservedQuantityIsSet(true);
+          } else {
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        case 17: // AVG_SALES
+          if (field.type == org.apache.thrift.protocol.TType.DOUBLE) {
+            this.avgSales = iprot.readDouble();
+            setAvgSalesIsSet(true);
+          } else {
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        case 18: // MIN_STOCK_LEVEL
+          if (field.type == org.apache.thrift.protocol.TType.I64) {
+            this.minStockLevel = iprot.readI64();
+            setMinStockLevelIsSet(true);
+          } else {
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        case 19: // NUMBER_OF_DAYS_STOCK
+          if (field.type == org.apache.thrift.protocol.TType.I64) {
+            this.numberOfDaysStock = iprot.readI64();
+            setNumberOfDaysStockIsSet(true);
+          } else {
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        case 20: // SUGGESTED_QUANTITY
+          if (field.type == org.apache.thrift.protocol.TType.I64) {
+            this.suggestedQuantity = iprot.readI64();
+            setSuggestedQuantityIsSet(true);
+          } else {
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        case 21: // NUMBER_OF_DAYS_IN_STOCK
+          if (field.type == org.apache.thrift.protocol.TType.I64) {
+            this.numberOfDaysInStock = iprot.readI64();
+            setNumberOfDaysInStockIsSet(true);
+          } else {
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
         default:
           org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+      }
       iprot.readFieldEnd();
+    }
     oprot.writeBool(this.fulfilled);
     oprot.writeFieldEnd();
     oprot.writeFieldBegin(COD_COUNT_FIELD_DESC);
     oprot.writeI64(this.codCount);
     oprot.writeFieldEnd();
+    oprot.writeFieldBegin(AVAILABLE_QUANTITY_FIELD_DESC);
+    oprot.writeI64(this.availableQuantity);
+    oprot.writeFieldEnd();
+    oprot.writeFieldBegin(RESERVED_QUANTITY_FIELD_DESC);
+    oprot.writeI64(this.reservedQuantity);
+    oprot.writeFieldEnd();
+    oprot.writeFieldBegin(AVG_SALES_FIELD_DESC);
+    oprot.writeDouble(this.avgSales);
+    oprot.writeFieldEnd();
+    oprot.writeFieldBegin(MIN_STOCK_LEVEL_FIELD_DESC);
+    oprot.writeI64(this.minStockLevel);
+    oprot.writeFieldEnd();
+    oprot.writeFieldBegin(NUMBER_OF_DAYS_STOCK_FIELD_DESC);
+    oprot.writeI64(this.numberOfDaysStock);
+    oprot.writeFieldEnd();
+    oprot.writeFieldBegin(SUGGESTED_QUANTITY_FIELD_DESC);
+    oprot.writeI64(this.suggestedQuantity);
+    oprot.writeFieldEnd();
+    oprot.writeFieldBegin(NUMBER_OF_DAYS_IN_STOCK_FIELD_DESC);
+    oprot.writeI64(this.numberOfDaysInStock);
+    oprot.writeFieldEnd();
     oprot.writeFieldStop();
     oprot.writeStructEnd();
+  }
   @Override
     first = false;
     if (!first) sb.append(", ");
     sb.append("codCount:");
     sb.append(this.codCount);
     first = false;
+    if (!first) sb.append(", ");
+    sb.append("availableQuantity:");
+    sb.append(this.availableQuantity);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("reservedQuantity:");
+    sb.append(this.reservedQuantity);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("avgSales:");
+    sb.append(this.avgSales);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("minStockLevel:");
+    sb.append(this.minStockLevel);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("numberOfDaysStock:");
+    sb.append(this.numberOfDaysStock);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("suggestedQuantity:");
+    sb.append(this.suggestedQuantity);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("numberOfDaysInStock:");
+    sb.append(this.numberOfDaysInStock);
+    first = false;
     sb.append(")");
     return sb.toString();
+  }
   public void validate() throws org.apache.thrift.TException {

Subversion Repositories SmartDukaan

(root)/trunk/ThriftConfig/src/main/java/in/shop2020/purchase/LineItem.java – Rev 4754 → 6821