@Override
public void accept(Visitor visitor) {
super.accept(visitor);
if (filter != null) {
visitor.visit(filter);
}
}
/**
* 列表过滤
*
* @param <T>
* @param objs
* @param filter
* @return
*/
public static <T> List<T> filter(List<T> objs, ObjectFilter<T> filter) {
List<T> new_objs = new ArrayList<T>();
for (T obj : objs) {
if (filter.filter(obj)) new_objs.add(obj);
}
return new_objs;
}
@Override
public int hashCode() {
int result = fullPath != null ? fullPath.hashCode() : 0;
result = 31 * result + (definition != null ? definition.hashCode() : 0);
result = 31 * result + (filter != null ? filter.hashCode() : 0);
return result;
}
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;
}
}
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;
}
}
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;
}
}
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;
}
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof ExistsFilter)) return false;
ExistsFilter that = (ExistsFilter) o;
if (fullPath != null ? !fullPath.equals(that.fullPath) : that.fullPath != null) return false;
if (definition != null ? !definition.equals(that.definition) : that.definition != null)
return false;
return !(filter != null ? !filter.equals(that.filter) : that.filter != null);
}
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;
}
}
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;
}
}
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;
}
}
@Override
public void checkConsistence() {
if (fullPath == null || fullPath.isEmpty()) {
throw new IllegalArgumentException("Null or empty path in " + this);
}
if (definition == null) {
throw new IllegalArgumentException("Null definition in " + this);
}
// null subfilter is legal. It means "ALL".
if (filter != null) {
filter.checkConsistence();
}
}
@Override
public String debugDump(int indent) {
StringBuilder sb = new StringBuilder();
DebugUtil.indentDebugDump(sb, indent);
sb.append("EXISTS: ");
sb.append(fullPath);
sb.append('\n');
DebugUtil.indentDebugDump(sb, indent + 1);
sb.append("DEF: ");
if (getDefinition() != null) {
sb.append(getDefinition().toString());
} else {
sb.append("null");
}
if (filter != null) {
sb.append(filter.debugDump(indent + 1));
}
return sb.toString();
}
@Override
public PageList<AlertDefinition> findAlertDefinitionsByCriteria(AlertDefinitionCriteria criteria)
throws RuntimeException {
try {
PageList<AlertDefinition> results =
this.alertDefManager.findAlertDefinitionsByCriteria(getSessionSubject(), criteria);
if (!results.isEmpty()) {
List<Resource> resources = new ArrayList<Resource>(results.size());
for (AlertDefinition alertDefinition : results) {
Resource res = alertDefinition.getResource();
if (null != res) {
resources.add(res);
}
}
ObjectFilter.filterFieldsInCollection(resources, ResourceGWTServiceImpl.importantFieldsSet);
}
return SerialUtility.prepare(results, "findAlertDefinitionsByCriteria");
} catch (Throwable t) {
throw getExceptionToThrowToClient(t);
}
}
@Override
public ObjectFilter clone() {
ObjectFilter f = filter != null ? filter.clone() : null;
return new ExistsFilter(fullPath, definition, f);
}
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);
}
}
