WebSVN – SmartDukaan – Diff – /trunk/ThriftConfig/src/main/java/in/shop2020/logistics/Provider.java

   private static final org.apache.thrift.protocol.TField ID_FIELD_DESC = new org.apache.thrift.protocol.TField("id", org.apache.thrift.protocol.TType.I64, (short)1);
   private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short)2);
   private static final org.apache.thrift.protocol.TField DETAILS_FIELD_DESC = new org.apache.thrift.protocol.TField("details", org.apache.thrift.protocol.TType.LIST, (short)3);
   private static final org.apache.thrift.protocol.TField PICKUP_FIELD_DESC = new org.apache.thrift.protocol.TField("pickup", org.apache.thrift.protocol.TType.I32, (short)4);
+  private static final org.apache.thrift.protocol.TField BUNDLE_WEIGHT_LIMIT_FIELD_DESC = new org.apache.thrift.protocol.TField("bundleWeightLimit", org.apache.thrift.protocol.TType.DOUBLE, (short)5);
+  private static final org.apache.thrift.protocol.TField GROUP_SHIPMENT_ALLOWED_FIELD_DESC = new org.apache.thrift.protocol.TField("groupShipmentAllowed", org.apache.thrift.protocol.TType.BOOL, (short)6);
+  private static final org.apache.thrift.protocol.TField MAX_COD_LIMIT_FIELD_DESC = new org.apache.thrift.protocol.TField("maxCodLimit", org.apache.thrift.protocol.TType.DOUBLE, (short)7);
   private long id; // required
   private String name; // required
   private List<ProviderDetails> details; // required
   private PickUpType pickup; // required
+  private double bundleWeightLimit; // required
+  private boolean groupShipmentAllowed; // required
+  private double maxCodLimit; // 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 {
     ID((short)1, "id"),
     NAME((short)2, "name"),
     DETAILS((short)3, "details"),
     /**
+     *
      * @see PickUpType
      */
-    PICKUP((short)4, "pickup");
+    PICKUP((short)4, "pickup"),
+    BUNDLE_WEIGHT_LIMIT((short)5, "bundleWeightLimit"),
+    GROUP_SHIPMENT_ALLOWED((short)6, "groupShipmentAllowed"),
+    MAX_COD_LIMIT((short)7, "maxCodLimit");
     private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
     static {
       for (_Fields field : EnumSet.allOf(_Fields.class)) {
           return NAME;
         case 3: // DETAILS
           return DETAILS;
         case 4: // PICKUP
           return PICKUP;
+        case 5: // BUNDLE_WEIGHT_LIMIT
+          return BUNDLE_WEIGHT_LIMIT;
+        case 6: // GROUP_SHIPMENT_ALLOWED
+          return GROUP_SHIPMENT_ALLOWED;
+        case 7: // MAX_COD_LIMIT
+          return MAX_COD_LIMIT;
         default:
           return null;
+      }
+    }
+    }
+  }
   // isset id assignments
   private static final int __ID_ISSET_ID = 0;
+  private static final int __BUNDLEWEIGHTLIMIT_ISSET_ID = 1;
+  private static final int __GROUPSHIPMENTALLOWED_ISSET_ID = 2;
+  private static final int __MAXCODLIMIT_ISSET_ID = 3;
-  private BitSet __isset_bit_vector = new BitSet(1);
+  private BitSet __isset_bit_vector = new BitSet(4);
   public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
   static {
     Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
     tmpMap.put(_Fields.ID, new org.apache.thrift.meta_data.FieldMetaData("id", org.apache.thrift.TFieldRequirementType.DEFAULT,
     tmpMap.put(_Fields.DETAILS, new org.apache.thrift.meta_data.FieldMetaData("details", org.apache.thrift.TFieldRequirementType.DEFAULT,
         new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
             new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ProviderDetails.class))));
     tmpMap.put(_Fields.PICKUP, new org.apache.thrift.meta_data.FieldMetaData("pickup", org.apache.thrift.TFieldRequirementType.DEFAULT,
         new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, PickUpType.class)));
+    tmpMap.put(_Fields.BUNDLE_WEIGHT_LIMIT, new org.apache.thrift.meta_data.FieldMetaData("bundleWeightLimit", org.apache.thrift.TFieldRequirementType.DEFAULT,
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
+    tmpMap.put(_Fields.GROUP_SHIPMENT_ALLOWED, new org.apache.thrift.meta_data.FieldMetaData("groupShipmentAllowed", org.apache.thrift.TFieldRequirementType.DEFAULT,
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+    tmpMap.put(_Fields.MAX_COD_LIMIT, new org.apache.thrift.meta_data.FieldMetaData("maxCodLimit", org.apache.thrift.TFieldRequirementType.DEFAULT,
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
     metaDataMap = Collections.unmodifiableMap(tmpMap);
     org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(Provider.class, metaDataMap);
+  }
   public Provider() {
   public Provider(
     long id,
     String name,
     List<ProviderDetails> details,
-    PickUpType pickup)
+    PickUpType pickup,
+    double bundleWeightLimit,
+    boolean groupShipmentAllowed,
+    double maxCodLimit)
+  {
     this();
     this.id = id;
     setIdIsSet(true);
     this.name = name;
     this.details = details;
     this.pickup = pickup;
+    this.bundleWeightLimit = bundleWeightLimit;
+    setBundleWeightLimitIsSet(true);
+    this.groupShipmentAllowed = groupShipmentAllowed;
+    setGroupShipmentAllowedIsSet(true);
+    this.maxCodLimit = maxCodLimit;
+    setMaxCodLimitIsSet(true);
+  }
   /**
    * Performs a deep copy on <i>other</i>.
    */
       this.details = __this__details;
+    }
     if (other.isSetPickup()) {
       this.pickup = other.pickup;
+    }
+    this.bundleWeightLimit = other.bundleWeightLimit;
+    this.groupShipmentAllowed = other.groupShipmentAllowed;
+    this.maxCodLimit = other.maxCodLimit;
+  }
   public Provider deepCopy() {
     return new Provider(this);
+  }
     setIdIsSet(false);
     this.id = 0;
     this.name = null;
     this.details = null;
     this.pickup = null;
+    setBundleWeightLimitIsSet(false);
+    this.bundleWeightLimit = 0.0;
+    setGroupShipmentAllowedIsSet(false);
+    this.groupShipmentAllowed = false;
+    setMaxCodLimitIsSet(false);
+    this.maxCodLimit = 0.0;
+  }
   public long getId() {
     return this.id;
+  }
     if (!value) {
       this.pickup = null;
+    }
+  }
+  public double getBundleWeightLimit() {
+    return this.bundleWeightLimit;
+  }
+  public void setBundleWeightLimit(double bundleWeightLimit) {
+    this.bundleWeightLimit = bundleWeightLimit;
+    setBundleWeightLimitIsSet(true);
+  }
+  public void unsetBundleWeightLimit() {
+    __isset_bit_vector.clear(__BUNDLEWEIGHTLIMIT_ISSET_ID);
+  }
+  /** Returns true if field bundleWeightLimit is set (has been assigned a value) and false otherwise */
+  public boolean isSetBundleWeightLimit() {
+    return __isset_bit_vector.get(__BUNDLEWEIGHTLIMIT_ISSET_ID);
+  }
+  public void setBundleWeightLimitIsSet(boolean value) {
+    __isset_bit_vector.set(__BUNDLEWEIGHTLIMIT_ISSET_ID, value);
+  }
+  public boolean isGroupShipmentAllowed() {
+    return this.groupShipmentAllowed;
+  }
+  public void setGroupShipmentAllowed(boolean groupShipmentAllowed) {
+    this.groupShipmentAllowed = groupShipmentAllowed;
+    setGroupShipmentAllowedIsSet(true);
+  }
+  public void unsetGroupShipmentAllowed() {
+    __isset_bit_vector.clear(__GROUPSHIPMENTALLOWED_ISSET_ID);
+  }
+  /** Returns true if field groupShipmentAllowed is set (has been assigned a value) and false otherwise */
+  public boolean isSetGroupShipmentAllowed() {
+    return __isset_bit_vector.get(__GROUPSHIPMENTALLOWED_ISSET_ID);
+  }
+  public void setGroupShipmentAllowedIsSet(boolean value) {
+    __isset_bit_vector.set(__GROUPSHIPMENTALLOWED_ISSET_ID, value);
+  }
+  public double getMaxCodLimit() {
+    return this.maxCodLimit;
+  }
+  public void setMaxCodLimit(double maxCodLimit) {
+    this.maxCodLimit = maxCodLimit;
+    setMaxCodLimitIsSet(true);
+  }
+  public void unsetMaxCodLimit() {
+    __isset_bit_vector.clear(__MAXCODLIMIT_ISSET_ID);
+  }
+  /** Returns true if field maxCodLimit is set (has been assigned a value) and false otherwise */
+  public boolean isSetMaxCodLimit() {
+    return __isset_bit_vector.get(__MAXCODLIMIT_ISSET_ID);
+  }
+  public void setMaxCodLimitIsSet(boolean value) {
+    __isset_bit_vector.set(__MAXCODLIMIT_ISSET_ID, value);
+  }
   public void setFieldValue(_Fields field, Object value) {
     switch (field) {
     case ID:
       if (value == null) {
         unsetId();
       } else {
         setPickup((PickUpType)value);
+      }
       break;
+    case BUNDLE_WEIGHT_LIMIT:
+      if (value == null) {
+        unsetBundleWeightLimit();
+      } else {
+        setBundleWeightLimit((Double)value);
+      }
+      break;
+    case GROUP_SHIPMENT_ALLOWED:
+      if (value == null) {
+        unsetGroupShipmentAllowed();
+      } else {
+        setGroupShipmentAllowed((Boolean)value);
+      }
+      break;
+    case MAX_COD_LIMIT:
+      if (value == null) {
+        unsetMaxCodLimit();
+      } else {
+        setMaxCodLimit((Double)value);
+      }
+      break;
+    }
+  }
   public Object getFieldValue(_Fields field) {
     switch (field) {
       return getDetails();
     case PICKUP:
       return getPickup();
+    case BUNDLE_WEIGHT_LIMIT:
+      return Double.valueOf(getBundleWeightLimit());
+    case GROUP_SHIPMENT_ALLOWED:
+      return Boolean.valueOf(isGroupShipmentAllowed());
+    case MAX_COD_LIMIT:
+      return Double.valueOf(getMaxCodLimit());
+    }
     throw new IllegalStateException();
+  }
   /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
       return isSetName();
     case DETAILS:
       return isSetDetails();
     case PICKUP:
       return isSetPickup();
+    case BUNDLE_WEIGHT_LIMIT:
+      return isSetBundleWeightLimit();
+    case GROUP_SHIPMENT_ALLOWED:
+      return isSetGroupShipmentAllowed();
+    case MAX_COD_LIMIT:
+      return isSetMaxCodLimit();
+    }
     throw new IllegalStateException();
+  }
   @Override
         return false;
       if (!this.pickup.equals(that.pickup))
         return false;
+    }
+    boolean this_present_bundleWeightLimit = true;
+    boolean that_present_bundleWeightLimit = true;
+    if (this_present_bundleWeightLimit || that_present_bundleWeightLimit) {
+      if (!(this_present_bundleWeightLimit && that_present_bundleWeightLimit))
+        return false;
+      if (this.bundleWeightLimit != that.bundleWeightLimit)
+        return false;
+    }
+    boolean this_present_groupShipmentAllowed = true;
+    boolean that_present_groupShipmentAllowed = true;
+    if (this_present_groupShipmentAllowed || that_present_groupShipmentAllowed) {
+      if (!(this_present_groupShipmentAllowed && that_present_groupShipmentAllowed))
+        return false;
+      if (this.groupShipmentAllowed != that.groupShipmentAllowed)
+        return false;
+    }
+    boolean this_present_maxCodLimit = true;
+    boolean that_present_maxCodLimit = true;
+    if (this_present_maxCodLimit || that_present_maxCodLimit) {
+      if (!(this_present_maxCodLimit && that_present_maxCodLimit))
+        return false;
+      if (this.maxCodLimit != that.maxCodLimit)
+        return false;
+    }
     return true;
+  }
   @Override
   public int hashCode() {
       lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pickup, typedOther.pickup);
       if (lastComparison != 0) {
         return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetBundleWeightLimit()).compareTo(typedOther.isSetBundleWeightLimit());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetBundleWeightLimit()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.bundleWeightLimit, typedOther.bundleWeightLimit);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetGroupShipmentAllowed()).compareTo(typedOther.isSetGroupShipmentAllowed());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetGroupShipmentAllowed()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.groupShipmentAllowed, typedOther.groupShipmentAllowed);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetMaxCodLimit()).compareTo(typedOther.isSetMaxCodLimit());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetMaxCodLimit()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.maxCodLimit, typedOther.maxCodLimit);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
     return 0;
+  }
   public _Fields fieldForId(int fieldId) {
     return _Fields.findByThriftId(fieldId);
             this.pickup = PickUpType.findByValue(iprot.readI32());
           } else {
             org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+          }
           break;
+        case 5: // BUNDLE_WEIGHT_LIMIT
+          if (field.type == org.apache.thrift.protocol.TType.DOUBLE) {
+            this.bundleWeightLimit = iprot.readDouble();
+            setBundleWeightLimitIsSet(true);
+          } else {
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        case 6: // GROUP_SHIPMENT_ALLOWED
+          if (field.type == org.apache.thrift.protocol.TType.BOOL) {
+            this.groupShipmentAllowed = iprot.readBool();
+            setGroupShipmentAllowedIsSet(true);
+          } else {
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        case 7: // MAX_COD_LIMIT
+          if (field.type == org.apache.thrift.protocol.TType.DOUBLE) {
+            this.maxCodLimit = iprot.readDouble();
+            setMaxCodLimitIsSet(true);
+          } else {
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
         default:
           org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+      }
       iprot.readFieldEnd();
+    }
     if (this.pickup != null) {
       oprot.writeFieldBegin(PICKUP_FIELD_DESC);
       oprot.writeI32(this.pickup.getValue());
       oprot.writeFieldEnd();
+    }
+    oprot.writeFieldBegin(BUNDLE_WEIGHT_LIMIT_FIELD_DESC);
+    oprot.writeDouble(this.bundleWeightLimit);
+    oprot.writeFieldEnd();
+    oprot.writeFieldBegin(GROUP_SHIPMENT_ALLOWED_FIELD_DESC);
+    oprot.writeBool(this.groupShipmentAllowed);
+    oprot.writeFieldEnd();
+    oprot.writeFieldBegin(MAX_COD_LIMIT_FIELD_DESC);
+    oprot.writeDouble(this.maxCodLimit);
+    oprot.writeFieldEnd();
     oprot.writeFieldStop();
     oprot.writeStructEnd();
+  }
   @Override
       sb.append("null");
     } else {
       sb.append(this.pickup);
+    }
     first = false;
+    if (!first) sb.append(", ");
+    sb.append("bundleWeightLimit:");
+    sb.append(this.bundleWeightLimit);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("groupShipmentAllowed:");
+    sb.append(this.groupShipmentAllowed);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("maxCodLimit:");
+    sb.append(this.maxCodLimit);
+    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/logistics/Provider.java – Rev 7792 → 13146