Example #1
0
  private void initForLong(long value) {

    this.value = (VALUE) (Long) value;

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

      case NOT_EQUAL:
        nativeDelegate = ObjectFilter.notEqLong(name, (value));
        break;

      case LESS_THAN:
        nativeDelegate = ObjectFilter.ltLong(name, (value));
        break;

      case LESS_THAN_EQUAL:
        nativeDelegate = ObjectFilter.lteLong(name, (value));
        break;

      case GREATER_THAN:
        nativeDelegate = ObjectFilter.gtLong(name, (value));
        break;

      case GREATER_THAN_EQUAL:
        nativeDelegate = ObjectFilter.gteLong(name, (value));
        break;

      case IN:
        nativeDelegate = ObjectFilter.inLongs(name, Conversions.larray(values));
        break;

      case BETWEEN:
        nativeDelegate = ObjectFilter.betweenLong(name, (value), Conversions.toLong(values[1]));
        break;

      case NOT_IN:
        nativeDelegate = ObjectFilter.notInLongs(name, Conversions.larray(values));

        break;

      default:
        useDelegate = false;
    }
  }
Example #2
0
  private void initForByte(byte value) {

    this.value = (VALUE) (Byte) value;

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

      case NOT_EQUAL:
        nativeDelegate = ObjectFilter.notEqByte(name, (value));
        break;

      case LESS_THAN:
        nativeDelegate = ObjectFilter.ltByte(name, (value));
        break;

      case LESS_THAN_EQUAL:
        nativeDelegate = ObjectFilter.lteByte(name, (value));
        break;

      case GREATER_THAN:
        nativeDelegate = ObjectFilter.gtByte(name, (value));
        break;

      case GREATER_THAN_EQUAL:
        nativeDelegate = ObjectFilter.gteByte(name, (value));
        break;

      case IN:
        nativeDelegate = ObjectFilter.inBytes(name, Conversions.barray(values));
        break;

      case NOT_IN:
        nativeDelegate = ObjectFilter.notInBytes(name, Conversions.barray(values));

        break;

      case BETWEEN:
        nativeDelegate = ObjectFilter.betweenByte(name, (value), Conversions.toByte(values[1]));
        break;

      default:
        useDelegate = false;
    }
  }
Example #3
0
  private void initForFloat(float value) {

    this.value = (VALUE) (Float) value;

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

      case NOT_EQUAL:
        nativeDelegate = ObjectFilter.notEqFloat(name, (value));
        break;

      case LESS_THAN:
        nativeDelegate = ObjectFilter.ltFloat(name, (value));
        break;

      case LESS_THAN_EQUAL:
        nativeDelegate = ObjectFilter.lteFloat(name, (value));
        break;

      case GREATER_THAN:
        nativeDelegate = ObjectFilter.gtFloat(name, (value));
        break;

      case GREATER_THAN_EQUAL:
        nativeDelegate = ObjectFilter.gteFloat(name, (value));
        break;

      case BETWEEN:
        nativeDelegate = ObjectFilter.betweenFloat(name, (value), Conversions.toFloat(values[1]));
        break;

      case IN:
        nativeDelegate = ObjectFilter.inFloats(name, Conversions.farray(values));
        break;

      case NOT_IN:
        nativeDelegate = ObjectFilter.notInFloats(name, Conversions.farray(values));

        break;

      default:
        useDelegate = false;
    }
  }
Example #4
0
  private void initForShortValue(short v) {

    this.value = (VALUE) (Short) v;

    switch (operator) {
      case EQUAL:
        nativeDelegate = ObjectFilter.eqShort(name, v);
        break;

      case NOT_EQUAL:
        nativeDelegate = ObjectFilter.notEqShort(name, v);
        break;

      case LESS_THAN:
        nativeDelegate = ObjectFilter.ltShort(name, v);
        break;

      case LESS_THAN_EQUAL:
        nativeDelegate = ObjectFilter.lteShort(name, v);
        break;

      case GREATER_THAN:
        nativeDelegate = ObjectFilter.gtShort(name, v);
        break;

      case GREATER_THAN_EQUAL:
        nativeDelegate = ObjectFilter.gteShort(name, v);
        break;

      case IN:
        nativeDelegate = ObjectFilter.inShorts(name, Conversions.sarray(values));
        break;

      case BETWEEN:
        nativeDelegate = ObjectFilter.betweenShort(name, (v), Conversions.toShort(values[1]));
        break;

      case NOT_IN:
        nativeDelegate = ObjectFilter.notInShorts(name, Conversions.sarray(values));

        break;

      default:
        useDelegate = false;
    }
  }
Example #5
0
  private void initForInt(int v) {
    this.value = (VALUE) (Integer) v;

    switch (operator) {
      case EQUAL:
        nativeDelegate = ObjectFilter.eqInt(name, v);
        break;

      case NOT_EQUAL:
        nativeDelegate = ObjectFilter.notEqInt(name, v);
        break;

      case LESS_THAN:
        nativeDelegate = ObjectFilter.ltInt(name, v);
        break;

      case LESS_THAN_EQUAL:
        nativeDelegate = ObjectFilter.lteInt(name, v);
        break;

      case GREATER_THAN:
        nativeDelegate = ObjectFilter.gtInt(name, v);
        break;

      case GREATER_THAN_EQUAL:
        nativeDelegate = ObjectFilter.gteInt(name, v);
        break;

      case BETWEEN:
        nativeDelegate = ObjectFilter.betweenInt(name, v, Conversions.toInt(values[1]));
        break;

      case IN:
        nativeDelegate = ObjectFilter.inInts(name, Conversions.iarray(values));
        break;

      case NOT_IN:
        nativeDelegate = ObjectFilter.notInInts(name, Conversions.iarray(values));

        break;

      default:
        useDelegate = false;
    }
  }
Example #6
0
  private void initForDouble(double value) {

    this.value = (VALUE) (Double) value;

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

      case NOT_EQUAL:
        nativeDelegate = ObjectFilter.notEqDouble(name, (value));
        break;

      case LESS_THAN:
        nativeDelegate = ObjectFilter.ltDouble(name, (value));
        break;

      case LESS_THAN_EQUAL:
        nativeDelegate = ObjectFilter.lteDouble(name, (value));
        break;

      case GREATER_THAN:
        nativeDelegate = ObjectFilter.gtDouble(name, (value));
        break;

      case GREATER_THAN_EQUAL:
        nativeDelegate = ObjectFilter.gteDouble(name, (value));
        break;

      case BETWEEN:
        nativeDelegate = ObjectFilter.betweenDouble(name, (value), Conversions.toDouble(values[1]));
        break;

      case IN:
        nativeDelegate = ObjectFilter.inDoubles(name, Conversions.darray(values));
        break;

      case NOT_IN:
        nativeDelegate = ObjectFilter.notInDoubles(name, Conversions.darray(values));
        break;

      default:
        useDelegate = false;
    }
  }
Example #7
0
  private void initForChar(char value) {

    this.value = (VALUE) (Character) value;

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

      case NOT_EQUAL:
        nativeDelegate = ObjectFilter.notEqChar(name, (value));
        break;

      case LESS_THAN:
        nativeDelegate = ObjectFilter.ltChar(name, (value));
        break;

      case LESS_THAN_EQUAL:
        nativeDelegate = ObjectFilter.lteChar(name, (value));
        break;

      case GREATER_THAN:
        nativeDelegate = ObjectFilter.gtChar(name, (value));
        break;

      case GREATER_THAN_EQUAL:
        nativeDelegate = ObjectFilter.gteChar(name, (value));
        break;

      case BETWEEN:
        nativeDelegate = ObjectFilter.betweenChar(name, (value), Conversions.toChar(values[1]));
        break;

      case IN:
        nativeDelegate = ObjectFilter.inChars(name, Conversions.carray(values));
        break;

      case NOT_IN:
        nativeDelegate = ObjectFilter.notInChars(name, Conversions.carray(values));
        break;

      default:
        useDelegate = false;
    }
  }
Example #8
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);
    }
  }