Example #1
0
  /**
   * Gets the field value.
   *
   * @return the value of the field
   */
  public Object value() {
    if (!convert1st) {
      FieldAccess field = field();
      if (field != null) {
        switch (field.typeEnum()) {
          case NUMBER:
            this.value = (VALUE) Conversions.coerce(field.type(), this.value);
            return new MyNumber(this.value);

          case ARRAY:
          case ARRAY_INT:
          case ARRAY_BYTE:
          case ARRAY_SHORT:
          case ARRAY_FLOAT:
          case ARRAY_DOUBLE:
          case ARRAY_LONG:
          case ARRAY_STRING:
          case ARRAY_OBJECT:
          case COLLECTION:
          case SET:
          case LIST:
            this.value = (VALUE) Conversions.coerce(field.getComponentClass(), this.value);
            break;
          default:
            this.value = (VALUE) Conversions.coerce(field.type(), this.value);
        }
      }
      convert1st = true;
    }
    return value;
  }
Example #2
0
  public static double variance(Collection<?> inputList, String propertyPath) {
    double mean = mean(inputList, propertyPath);
    double temp = 0;

    double a;

    if (propertyPath.contains(".") || propertyPath.contains("[")) {

      String[] properties = StringScanner.splitByDelimiters(propertyPath, ".[]");

      for (Object o : inputList) {
        a = BeanUtils.getPropertyInt(o, properties);
        temp += (mean - a) * (mean - a);
      }

    } else {

      Map<String, FieldAccess> fields = BeanUtils.getFieldsFromObject(inputList.iterator().next());
      FieldAccess fieldAccess = fields.get(propertyPath);
      for (Object o : inputList) {
        a = fieldAccess.getInt(o);
        temp += (mean - a) * (mean - a);
      }
    }

    return Math.round(temp / inputList.size());
  }
Example #3
0
  /**
   * Calculate a sum of a property from a list.
   *
   * @param inputList
   * @param propertyPath to item we want to sum
   * @return sum
   */
  public static long sum(Collection<?> inputList, String propertyPath) {
    if (inputList.size() == 0) {
      return 0;
    }

    long sum = 0l;

    if (propertyPath.contains(".") || propertyPath.contains("[")) {

      String[] properties = StringScanner.splitByDelimiters(propertyPath, ".[]");

      for (Object o : inputList) {
        sum += BeanUtils.getPropertyInt(o, properties);
      }

    } else {

      Map<String, FieldAccess> fields = BeanUtils.getFieldsFromObject(inputList.iterator().next());
      FieldAccess fieldAccess = fields.get(propertyPath);
      for (Object o : inputList) {
        sum += fieldAccess.getInt(o);
      }
    }

    return sum;
  }
Example #4
0
 /**
  * Gets the field value.
  *
  * @return the value of the field
  */
 public Object value2() {
   if (!convert2nd) {
     FieldAccess field = this.field();
     this.value2 = (VALUE) Conversions.coerce(field.type(), this.value2);
     convert2nd = true;
   }
   return value2;
 }
Example #5
0
 public char fieldChar() {
   if (!path) {
     FieldAccess field1 = this.field();
     return field1.getChar(objectUnderTest);
   } else {
     return BeanUtils.idxChar(objectUnderTest, name.toString());
   }
 }
Example #6
0
 public long fieldLong() {
   if (!path) {
     FieldAccess field1 = this.field();
     return field1.getLong(objectUnderTest);
   } else {
     return BeanUtils.idxLong(objectUnderTest, name.toString());
   }
 }
Example #7
0
 public int fieldInt() {
   if (!path) {
     FieldAccess field1 = this.field();
     return field1.getInt(objectUnderTest);
   } else {
     return BeanUtils.idxInt(objectUnderTest, name.toString());
   }
 }
Example #8
0
  public byte fieldByte() {

    if (!path) {
      FieldAccess field1 = this.field();
      return field1.getByte(objectUnderTest);
    } else {
      return BeanUtils.idxByte(objectUnderTest, name.toString());
    }
  }
Example #9
0
  /**
   * Gets the field value.
   *
   * @return the value of the field
   */
  public Object fieldValue() {

    if (!path) {
      FieldAccess field1 = this.field();
      return field1.getValue(objectUnderTest);
    } else {
      return BeanUtils.atIndex(objectUnderTest, name.toString());
    }
  }
Example #10
0
 /**
  * Gets the field value.
  *
  * @return the value of the field
  */
 public Object value() {
   if (!convert1st) {
     FieldAccess field = field();
     if (field != null) {
       switch (field.typeEnum()) {
         case ARRAY:
         case COLLECTION:
         case SET:
         case LIST:
           this.value = (VALUE) Conversions.coerce(field.getComponentClass(), this.value);
           break;
         default:
           this.value = (VALUE) Conversions.coerce(field.type(), this.value);
       }
     }
     convert1st = true;
   }
   return value;
 }
Example #11
0
  public Set<Object> valueSet() {

    if (!convert1st) {

      HashSet<Object> set = new HashSet<>(values.length);
      FieldAccess field = this.field();
      Class<?> classType = field.type();

      for (Object v : values) {
        v = Conversions.coerce(classType, this.value);
        set.add(v);
      }

      value = (VALUE) set;

      convert1st = true;
    }
    return (Set<Object>) value;
  }
Example #12
0
  private void initIfNeeded() {

    if (initialized) return;
    initialized = true;

    String name = this.name.toString();

    FieldAccess field = field();
    if (field == null) {
      return;
    }

    Class type = field.type();

    if (!type.isPrimitive() && type != Typ.date) {
      return;
    }

    if (type == Typ.date) {

      if (!(value instanceof Date)) {
        initForDate();
      }
      return;
    }

    useDelegate = true;

    if (type == Typ.intgr) {
      int v = Conversions.toInt(value);
      initForInt(v);
    } else if (type == Typ.bt) {

      byte v = Conversions.toByte(value);

      initForByte(v);

    } else if (type == Typ.shrt) {

      short v = Conversions.toShort(value);

      initForShortValue(v);

    } else if (type == Typ.lng) {

      long v = Conversions.toLong(value);

      initForLong(v);

    } else if (type == Typ.flt) {

      float v = Conversions.toFloat(value);

      initForFloat(v);

    } else if (type == Typ.dbl) {

      double v = Conversions.toDouble(value);

      initForDouble(v);

    } else if (type == Typ.bln) {

      switch (operator) {
        case EQUAL:
          nativeDelegate = ObjectFilter.eqBoolean(name, Conversions.toBoolean(value));
          break;

        case NOT_EQUAL:
          nativeDelegate = ObjectFilter.notEqBoolean(name, Conversions.toBoolean(value));
          break;

        default:
          useDelegate = false;
      }

    } else if (type == Typ.chr) {

      char v = Conversions.toChar(value);
      initForChar(v);
    }
  }