protected CommandEvaluator<Criterion, Object> compileIdentifierToValueCMP(
IdentifierToValueCMP node) {
Identifier id = node.getIdentifier();
if (id instanceof Field) {
String name = id.getName();
Value value = node.getValue();
if (INSTANCE_ID_FIELD.equals(name)) {
value.setValue(Long.valueOf((String) value.getValue()));
} else if (INSTANCE_STARTED_FIELD.equals(name) || INSTANCE_LAST_ACTIVE_FIELD.equals(name)) {
try {
value.setValue(ISO8601DateParser.parse((String) value.getValue()));
} catch (ParseException ex) {
throw new RuntimeException(ex);
}
}
}
if (node instanceof Equality) {
return compileEqual((Equality) node);
} else if (node instanceof Less) {
return compileLess((Less) node);
} else if (node instanceof Greater) {
return compileGreater((Greater) node);
} else if (node instanceof GE) {
return compileGE((GE) node);
} else if (node instanceof LE) {
return compileLE((LE) node);
} else if (node instanceof Like) {
return compileLike((Like) node);
} else {
throw new IllegalArgumentException("Unsupported node " + node.getClass());
}
}
protected Advisory evaluateVital(Vital vital) {
Advisory a = null;
if (vital.isNoValueWarning() && vital.isEmpty()) {
a = new Advisory(State.Warning, vital, null, "no source of");
} else {
for (Value val : vital) {
if (val.isAtOrBelowLow()) {
a =
new Advisory(
val.isAtOrBelowCriticalLow() ? State.Alarm : State.Warning,
vital,
val.getValue(),
"low");
}
if (val.isAtOrAboveHigh()) {
a =
new Advisory(
val.isAtOrAboveCriticalHigh() ? State.Alarm : State.Warning,
vital,
val.getValue(),
"high");
}
if (a != null && a.state == State.Alarm) break;
}
}
return a;
}
/** multiplicative ::= unary MUL unary multiplicative ::= unary DIV unary */
private Value mulpiplicative() {
Value res = unary();
while (token.getType() == TokenType.MUL || token.getType() == TokenType.DIV) {
if (token.getType() == TokenType.MUL) {
res.setValue(res.getValue() * unary().getValue());
} else if (token.getType() == TokenType.DIV) {
res.setValue(res.getValue() / unary().getValue());
}
}
return res;
}
/**
* additive ::= multiplicative ADD multiplicative additive ::= multiplicative SUB multiplicative
*/
private Value additive() {
Value res = mulpiplicative();
while (token.getType() == TokenType.ADD || token.getType() == TokenType.SUB) {
if (token.getType() == TokenType.ADD) {
res.setValue(res.getValue() + mulpiplicative().getValue());
} else if (token.getType() == TokenType.SUB) {
res.setValue(res.getValue() - mulpiplicative().getValue());
}
}
return res;
}
/**
* Create a new node (element or attribute) to be inserted into the target node as a child or
* attribute.
*
* @param doc DOM document
* @param target the target ode
* @param value the value for creating the new node.
*/
public void createNewNode(Document doc, Node target, Value value) {
if (value.getLocation().startsWith("@")) {
Attr newAttribute = doc.createAttribute(value.getLocation().substring(1));
newAttribute.setValue(value.getValue());
target.getAttributes().setNamedItem(newAttribute);
} else {
Element newElement = doc.createElement(value.getLocation());
newElement.setTextContent(value.getValue());
target.appendChild(newElement);
}
}
/** equality ::= relational EQ relational equality ::= relational NEQ relational */
private Value equality() {
Value res = relational();
while (token.getType() == TokenType.EQ || token.getType() == TokenType.NEQ) {
if (token.getType() == TokenType.EQ) {
res.setBooleanValue(res.getValue() == relational().getValue());
} else if (token.getType() == TokenType.NEQ) {
res.setBooleanValue(res.getValue() != relational().getValue());
}
}
return res;
}
public void printValues() {
if (isMagicSquare) {
System.out.println("Printing magic square:");
int totalValues = values.size();
int n = (int) Math.sqrt(totalValues);
int count = 0;
for (Value v : values) {
++count;
System.out.print(v.getValue() + "\t");
if (count >= n) {
count = 0;
System.out.println("");
}
}
} else {
int n = values.size();
int[] heights = new int[n];
String toPrint = "\n";
for (int i = 0; i < n; i++) {
heights[i] = Integer.valueOf(values.get(i).getValue());
}
for (int i = 0; i < n; i++) {
int maxValueIndex = getMax(heights);
for (int j = 0; j < maxValueIndex; j++) {
toPrint += " O ";
}
int xToAdd = n - maxValueIndex - 1;
toPrint += " X ";
for (int j = 0; j < xToAdd; j++) {
toPrint += " O ";
}
toPrint += "\n";
heights[maxValueIndex] = -1;
}
System.out.println(toPrint);
for (Value v : values) {
System.out.print(v.getContent() + ": " + v.getValue() + " ");
}
System.out.println("");
}
}
/**
* Returns the values owned by this {@link PropertyRepresentation}, represented by a string
*
* @return the values owned by this {@link PropertyRepresentation}, represented by a string
*/
public ArrayList<String> getStringValue() {
ArrayList<String> stringValues = new ArrayList<String>();
for (Value val : values) {
stringValues.add(val.getValue());
}
return stringValues;
}
public Value findValue(String stringValue) {
for (Value value : this) {
if (value.getValue().equals(stringValue)) {
return value;
}
}
return null;
}
// Update several Positions for the given SilverObjectId
// only if the value is invariant
// add by SAN
public String buildUpdateByObjectIdStatement(Value value, int nSilverObjectId) {
String sSQLStatement = "UPDATE " + CLASSIFICATION_TABLE;
sSQLStatement += " SET " + AXIS_COLUMN + value.getAxisId() + " = '" + value.getValue() + "' ";
sSQLStatement += " WHERE " + SILVEROBJECT_ID_COLUMN + " = " + nSilverObjectId;
sSQLStatement += " AND " + AXIS_COLUMN + value.getAxisId() + " IS NOT NULL";
return sSQLStatement;
}
public void write(DataOutput out) throws IOException {
out.writeInt(valueSize);
out.writeInt(valueCount);
Value<V> value = firstValue;
while (value != null) {
btree.writeValue(out, value.getValue());
value = value.getNext();
}
}
/**
* relational ::= additive LT additive relational ::= additive GT additive relational ::= additive
* LTE additive relational ::= additive GTE additive
*/
private Value relational() {
Value res = additive();
while (token.getType() == TokenType.LT
|| token.getType() == TokenType.GT
|| token.getType() == TokenType.LTE
|| token.getType() == TokenType.GTE) {
if (token.getType() == TokenType.LT) {
res.setBooleanValue(res.getValue() < additive().getValue());
} else if (token.getType() == TokenType.GT) {
res.setBooleanValue(res.getValue() > additive().getValue());
} else if (token.getType() == TokenType.LTE) {
res.setBooleanValue(res.getValue() <= additive().getValue());
} else if (token.getType() == TokenType.GTE) {
res.setBooleanValue(res.getValue() >= additive().getValue());
}
}
return res;
}
/**
* Transform the DOM tree using the configuration.
*
* @param configuration the transformation configuration.
* @param doc the DOM tree to be updated.
*/
protected void applyTransformation(XmlConfiguration configuration, Document doc) {
List<Parameter> parameters = configuration.getParameters();
for (Parameter parameter : parameters) {
displayMessageln("\t" + parameter.getKey() + " (mode:" + parameter.getMode() + ")");
Node rootXpathNode = getMatchingNode(parameter.getKey(), doc);
if (rootXpathNode != null) {
for (Value value : parameter.getValues()) {
switch (value.getMode()) {
case XmlTreeHandler.MODE_INSERT:
{
createNewNode(doc, rootXpathNode, value);
}
break;
case XmlTreeHandler.MODE_DELETE:
{
Node deletedNode = getMatchingNode(value.getLocation(), rootXpathNode);
rootXpathNode.removeChild(deletedNode);
}
break;
case XmlTreeHandler.MODE_UPDATE:
{
Node oldNode = getMatchingNode(value.getLocation(), rootXpathNode);
if (oldNode == null) {
createNewNode(doc, rootXpathNode, value);
} else {
if (rootXpathNode.equals(oldNode)) {
rootXpathNode = rootXpathNode.getParentNode();
}
Node newNode = oldNode.cloneNode(true);
if (oldNode instanceof Element) {
((Element) newNode).setTextContent(value.getValue());
rootXpathNode.replaceChild(newNode, oldNode);
} else {
((Attr) newNode).setValue(value.getValue());
rootXpathNode.getAttributes().setNamedItem(newNode);
}
}
break;
}
}
}
}
}
}
// Replace the oldValue with the newValue
public String buildReplaceValuesStatement(Value oldValue, Value newValue) {
StringBuilder sSQLStatement = new StringBuilder(1000);
// Build the SQL statement to remove the values
if (newValue.getValue() != null) {
sSQLStatement
.append("UPDATE ")
.append(CLASSIFICATION_TABLE)
.append(" SET ")
.append(AXIS_COLUMN)
.append(newValue.getAxisId())
.append(" = '")
.append(newValue.getValue())
.append("'");
} else {
sSQLStatement
.append("UPDATE ")
.append(CLASSIFICATION_TABLE)
.append(" SET ")
.append(AXIS_COLUMN)
.append(newValue.getAxisId())
.append(" = ")
.append(newValue.getValue());
}
if (oldValue.getValue() != null) {
sSQLStatement
.append(" WHERE (")
.append(AXIS_COLUMN)
.append(oldValue.getAxisId())
.append(" = '")
.append(oldValue.getValue())
.append("')");
} else {
sSQLStatement
.append(" WHERE (")
.append(AXIS_COLUMN)
.append(oldValue.getAxisId())
.append(" IS NULL)");
}
return sSQLStatement.toString();
}
public Value addUnique(String stringValue) {
for (Value value : this) {
if (value.getValue().equals(stringValue)) {
return value;
}
}
Value value = new Value();
value.setValue(stringValue);
add(value);
return value;
}
/**
* @param name Value name
* @return Value for specified name
*/
public String getValue(String name) {
String value = null;
for (Value v : recordValues) {
if (v.getName().equalsIgnoreCase(name)) {
value = v.getValue();
break;
}
}
return value;
}
@Override
public R operate(R target) throws MappingException {
AbstractRecord source = AbstractRecord.this;
try {
// [#1522] [#2989] If possible the complete state of this record should be copied onto the
// other record
if (target instanceof AbstractRecord) {
AbstractRecord t = (AbstractRecord) target;
// Iterate over target fields, to avoid ambiguities when two source fields share the same
// name.
for (int targetIndex = 0; targetIndex < t.size(); targetIndex++) {
Field<?> targetField = t.field(targetIndex);
int sourceIndex = fields.indexOf(targetField);
if (sourceIndex >= 0) {
DataType<?> targetType = targetField.getDataType();
Value<?> sourceValue = values[sourceIndex];
t.values[targetIndex] =
new Value<Object>(
targetType.convert(sourceValue.getValue()),
targetType.convert(sourceValue.getOriginal()),
sourceValue.isChanged());
}
}
} else {
for (Field<?> targetField : target.fields()) {
Field<?> sourceField = field(targetField);
if (sourceField != null) {
Utils.setValue(target, targetField, source, sourceField);
}
}
}
return target;
}
// All reflection exceptions are intercepted
catch (Exception e) {
throw new MappingException("An error ocurred when mapping record to " + target, e);
}
}
// Update a Position with the given one for the given SilverObjectId
public String buildUpdateByPositionIdStatement(Position<Value> newPosition) {
StringBuilder sSQLStatement = new StringBuilder(1000);
sSQLStatement
.append("UPDATE ")
.append(CLASSIFICATION_TABLE)
.append(" SET ")
.append(POSITION_ID_COLUMN)
.append(" = ")
.append(newPosition.getPositionId())
.append(", ");
List<Value> allValues = newPosition.getValues();
int valuesTakenInCharge = 0;
for (int axisId = 0; axisId < axisMaxNumber; axisId++) {
String value = null;
if (valuesTakenInCharge < allValues.size()) {
for (Value aValue : allValues) {
if (aValue.getPhysicalAxisId() == axisId) {
value = aValue.getValue();
valuesTakenInCharge++;
break;
}
}
}
sSQLStatement.append(AXIS_COLUMN).append(axisId);
if (value == null || value.equals("-")) {
sSQLStatement.append(" = ").append(value);
} else {
sSQLStatement.append(" = '").append(value).append("'");
}
if (axisId < axisMaxNumber - 1) {
sSQLStatement.append(", ");
}
}
sSQLStatement
.append(" WHERE ")
.append(POSITION_ID_COLUMN)
.append(" = ")
.append(newPosition.getPositionId());
return sSQLStatement.toString();
}
private void addORColsToFinalList(FilterList filterList) {
for (Entry<Column, List<Value>> entry : colWithOperatorsOfOR.entrySet()) {
List<Value> valueList = entry.getValue();
for (Value value : valueList) {
if (value.getOperator() == CompareOp.EQUAL) {
filterList.addFilter(value.getFilter());
} else {
SingleColumnRangeFilter rangeFltr =
new SingleColumnRangeFilter(
entry.getKey().getFamily(),
entry.getKey().getQualifier(),
entry.getKey().getValuePartition(),
value.getValue(),
value.getOperator(),
null,
null);
filterList.addFilter(rangeFltr);
}
}
}
}
/** @return TBD */
@Override
public String toString() {
StringBuffer buffer = new StringBuffer();
buffer.append(recordName);
for (Value value : recordValues) {
buffer.append(' ');
buffer.append(value.getName());
if (value.isArrayValue()) {
buffer.append("=");
buffer.append(stringArrayAsString(value.getArrayValue()));
} else {
buffer.append("=\"");
buffer.append(value.getValue());
buffer.append("\"");
}
}
return buffer.toString();
}
// Build the SQL statement to get a position
public String buildVerifyStatement(int nSilverObjectId, Position<Value> position) {
StringBuilder sSQLStatement = new StringBuilder(1000);
List<Value> alValues = position.getValues();
// Build the SQL statement to classify the object
sSQLStatement
.append("SELECT ")
.append(POSITION_ID_COLUMN)
.append(" FROM ")
.append(CLASSIFICATION_TABLE);
// Put the values for the concerning axis, put null for the other non-valued axis
sSQLStatement.append(" WHERE (");
for (int axis = 0; axis <= axisMaxNumber; axis++) {
Value foundValue = null;
for (Value aValue : alValues) {
if (aValue.getPhysicalAxisId() == axis) {
foundValue = aValue;
break;
}
}
String axisValue = null;
if (foundValue != null) {
axisValue = "'" + foundValue.getValue() + "'";
}
sSQLStatement.append(AXIS_COLUMN).append(axis).append(" = ").append(axisValue);
if (axis < axisMaxNumber) {
sSQLStatement.append(" AND ");
}
}
sSQLStatement.append(")");
sSQLStatement
.append(" AND ")
.append(SILVEROBJECT_ID_COLUMN)
.append(" = ")
.append(nSilverObjectId);
return sSQLStatement.toString();
}
// construct from types of an argument list
public FuncInfo(final ArrayList args) {
if (args == null) {
// default to noarg, any return
_paramNames = new String[0];
_paramTypes = new TypeSpec[0];
_paramDefaults = new Object[0];
_paramHasDefault = new boolean[0];
_returnType = TypeSpec.typeOf("any");
} else {
final int n = args.size();
_paramNames = new String[n];
_paramTypes = new TypeSpec[n];
_paramDefaults = new Object[n];
_paramHasDefault = new boolean[n];
_returnType = TypeSpec.typeOf("any");
for (int a = 0; a < n; a++) {
_paramNames[a] = null;
_paramTypes[a] = null;
if (args.get(a) instanceof Value) {
// if an arg is null and is an LValue, extract it's declared
// type
final Value v = (Value) args.get(a);
final boolean isNull =
(v.getValue() == null)
|| ((v.getValue() instanceof Any) && (((Any) v.getValue()).value == null));
if (isNull && v.isLValue()) {
_paramTypes[a] = v.getLValue().getSymbol().getType();
}
// if we have an Any value, try to deduce the type from the
// actual value within
else if (v.getValue() instanceof Any) { // if we have an Any
if (v.getValue() != null) {
_paramTypes[a] = TypeSpec.typeOf(((Any) v.getValue()).value);
}
}
}
if (_paramTypes[a] == null) {
_paramTypes[a] = TypeSpec.typeOf(args.get(a));
}
_paramDefaults[a] = null;
_paramHasDefault[a] = false;
}
}
}
/**
* unary ::= NUMBER unary ::= OPEN logicalOr CLOSE unary ::= VARIABLE unary ::= NOT unary unary
* ::= SUB unary unary ::= ADD unary
*/
private Value unary() {
final Value res;
nextToken();
if (token.getType() == TokenType.SUB) {
res = unary();
return res.setValue(-res.getValue());
} else if (token.getType() == TokenType.ADD) {
return unary();
} else if (token.getType() == TokenType.NOT) {
res = unary();
return res.setBooleanValue(!res.getBooleanValue());
} else if (token.getType() == TokenType.OPEN) {
res = logicalOr();
if (token.getType() != TokenType.CLOSE) {
throw expected(TokenType.CLOSE);
}
} else if (token.getType() == TokenType.NUMBER) {
res = token.getValue();
} else if (token.getType() == TokenType.VARIABLE) {
// resolve variable
res = variables.get(token.getStr());
if (res == null) {
throw new IllegalStateException("Unexpected variable name");
}
} else {
throw expected(
TokenType.SUB,
TokenType.ADD,
TokenType.NOT,
TokenType.OPEN,
TokenType.NUMBER,
TokenType.VARIABLE);
}
nextToken();
return res;
}
@Override
public int getValue(
Expression receiver, ArrayList<Expression> actuals, ExpressionEvaluator expressionEvaluator) {
return l.getValue(receiver, actuals, expressionEvaluator)
+ r.getValue(receiver, actuals, expressionEvaluator);
}
private void handleScvfOfOR(SingleColumnValueFilter scvf) {
ValuePartition vp = null;
if (scvf instanceof SingleColumnValuePartitionFilter) {
vp = ((SingleColumnValuePartitionFilter) scvf).getValuePartition();
}
Column key = new Column(scvf.getFamily(), scvf.getQualifier(), vp);
if (colWithOperatorsOfOR.get(key) == null) {
List<Value> valueList = new ArrayList<FilterGroupingWorker.Value>(1);
valueList.add(new Value(scvf.getOperator(), scvf.getComparator().getValue(), scvf));
colWithOperatorsOfOR.put(key, valueList);
} else {
List<Value> valueList = colWithOperatorsOfOR.get(key);
Iterator<Value> valueListItr = valueList.iterator();
CompareOp operator = scvf.getOperator();
byte[] value = scvf.getComparator().getValue();
Value prevValueObj = null;
while (valueListItr.hasNext()) {
prevValueObj = valueListItr.next();
// TODO As Anoop said we may have to check the Value type also..
// We can not compare and validate this way. btw "a" and "K".
// Only in case of Numeric col type we can have this check.
byte[] prevValue = prevValueObj.getValue();
int result = Bytes.compareTo(prevValue, value);
CompareOp prevOperator = prevValueObj.getOperator();
switch (operator) {
case GREATER:
if (prevOperator == CompareOp.GREATER || prevOperator == CompareOp.GREATER_OR_EQUAL) {
if (result > 0) {
valueListItr.remove();
} else {
// Already you found less or equal value than present value means present filter
// will
// return subset of previous filter. No need to add it to list.
return;
}
} else if (prevOperator == CompareOp.LESS || prevOperator == CompareOp.LESS_OR_EQUAL) {
// Need to handle conditions like previous is c1<5 and current c1>2. In these cases we
// can change this condition into three parts c1<2,c1>=2 AND C1=<5 ,c1>5 and add to
// list.
} else if (prevOperator == CompareOp.EQUAL) {
if (result > 0) {
valueListItr.remove();
} else if (result == 0) {
// remove this entry and convert GREATER to GREATER_OR_EQUAL
valueListItr.remove();
SingleColumnValueFilter newScvf = null;
if (vp == null) {
newScvf =
new SingleColumnValueFilter(
scvf.getFamily(),
scvf.getQualifier(),
CompareOp.GREATER_OR_EQUAL,
scvf.getComparator());
} else {
newScvf =
new SingleColumnValuePartitionFilter(
scvf.getFamily(),
scvf.getQualifier(),
CompareOp.GREATER_OR_EQUAL,
scvf.getComparator(),
vp);
}
Value newValue = new Value(CompareOp.GREATER_OR_EQUAL, prevValue, newScvf);
valueList.add(newValue);
return;
}
}
break;
case GREATER_OR_EQUAL:
if (prevOperator == CompareOp.GREATER || prevOperator == CompareOp.GREATER_OR_EQUAL) {
if (result >= 0) {
valueListItr.remove();
} else {
// Already you found less value than present value means present filter will
// return subset of previous filter. No need to add it to list.
return;
}
} else if (prevOperator == CompareOp.LESS || prevOperator == CompareOp.LESS_OR_EQUAL) {
// Need to handle conditions like previous is c1<5 and current c1>2. In these cases we
// can change this condition into three parts c1<2,c1>=2 AND C1=<5 ,c1>5 and add to
// list.
} else if (prevOperator == CompareOp.EQUAL) {
if (result >= 0) {
valueListItr.remove();
}
}
break;
case LESS:
if (prevOperator == CompareOp.LESS || prevOperator == CompareOp.LESS_OR_EQUAL) {
if (result < 0) {
valueListItr.remove();
} else {
// Already you found less or equal value than present value means present filter
// will
// return subset of previous filter. No need to add it to list.
return;
}
} else if (prevOperator == CompareOp.GREATER
|| prevOperator == CompareOp.GREATER_OR_EQUAL) {
// Need to handle conditions like previous is c1<5 and current c1>2. In these cases we
// can change this condition into three parts c1<2,c1>=2 AND C1=<5 ,c1>5 and add to
// list.
} else if (prevOperator == CompareOp.EQUAL) {
if (result < 0) {
valueListItr.remove();
} else if (result == 0) {
// remove this entry and convert LESS to LESS_OR_EQUAL
valueListItr.remove();
SingleColumnValueFilter newScvf = null;
if (vp == null) {
newScvf =
new SingleColumnValueFilter(
scvf.getFamily(),
scvf.getQualifier(),
CompareOp.LESS_OR_EQUAL,
scvf.getComparator());
} else {
newScvf =
new SingleColumnValuePartitionFilter(
scvf.getFamily(),
scvf.getQualifier(),
CompareOp.LESS_OR_EQUAL,
scvf.getComparator(),
vp);
}
Value newValue = new Value(CompareOp.LESS_OR_EQUAL, prevValue, newScvf);
valueList.add(newValue);
return;
}
}
break;
case LESS_OR_EQUAL:
if (prevOperator == CompareOp.LESS || prevOperator == CompareOp.LESS_OR_EQUAL) {
if (result <= 0) {
valueListItr.remove();
} else {
// Already you found less or equal value than present value means present filter
// will
// return subset of previous filter. No need to add it to list.
return;
}
} else if (prevOperator == CompareOp.GREATER
|| prevOperator == CompareOp.GREATER_OR_EQUAL) {
// Need to handle conditions like previous is c1<5 and current c1>2. In these cases we
// can change this condition into three parts c1<2,c1>=2 AND C1=<5 ,c1>5 and add to
// list.
} else if (prevOperator == CompareOp.EQUAL) {
// If we dont want to do conversion we can add into first if condition.
if (result <= 0) {
valueListItr.remove();
} else if (result == 0) {
// remove this entry and convert GREATER to GREATER_OR_EQUAL
}
}
break;
case EQUAL:
if (prevOperator == CompareOp.GREATER) {
if (result < 0) {
return;
} else if (result == 0) {
valueListItr.remove();
SingleColumnValueFilter newScvf = null;
if (vp == null) {
newScvf =
new SingleColumnValueFilter(
scvf.getFamily(),
scvf.getQualifier(),
CompareOp.GREATER_OR_EQUAL,
scvf.getComparator());
} else {
newScvf =
new SingleColumnValuePartitionFilter(
scvf.getFamily(),
scvf.getQualifier(),
CompareOp.GREATER_OR_EQUAL,
scvf.getComparator(),
vp);
}
Value newValue = new Value(CompareOp.GREATER_OR_EQUAL, prevValue, newScvf);
valueList.add(newValue);
return;
}
} else if (prevOperator == CompareOp.GREATER_OR_EQUAL) {
if (result <= 0) {
return;
}
} else if (prevOperator == CompareOp.LESS) {
if (result > 0) {
return;
} else if (result == 0) {
valueListItr.remove();
SingleColumnValueFilter newScvf = null;
if (vp == null) {
newScvf =
new SingleColumnValueFilter(
scvf.getFamily(),
scvf.getQualifier(),
CompareOp.LESS_OR_EQUAL,
scvf.getComparator());
} else {
newScvf =
new SingleColumnValuePartitionFilter(
scvf.getFamily(),
scvf.getQualifier(),
CompareOp.LESS_OR_EQUAL,
scvf.getComparator(),
vp);
}
Value newValue = new Value(CompareOp.LESS_OR_EQUAL, prevValue, newScvf);
valueList.add(newValue);
return;
}
} else if (prevOperator == CompareOp.LESS_OR_EQUAL) {
if (result >= 0) {
return;
}
} else if (prevOperator == CompareOp.EQUAL) {
if (result == 0) {
// Already same filter exists with same condiftion.
return;
}
}
break;
case NOT_EQUAL:
case NO_OP:
// Need to check this
break;
}
}
valueList.add(new Value(scvf.getOperator(), scvf.getComparator().getValue(), scvf));
}
}
/**
* performs basic arithmetic operations on Value objects
*
* @param left
* @param right
* @param op
* @return
*/
public static Value evaluateInfix(Value left, Value right, Token op) {
int precision = 10;
double newValue = evaluateOperands(left.getValue(), right.getValue(), op, precision);
ValueType newType = evaluateUnits(left.getType(), right.getType(), op);
return new Value(newValue, newType);
}
protected INEvaluator<String, Criterion, Object> compileIn(final In in) {
if (in.getIdentifier() instanceof Property) {
propertyInQuery = true;
final Property property = (Property) in.getIdentifier();
return new INEvaluator<String, Criterion, Object>() {
public Criterion evaluate(Object paramValue) {
Disjunction disj = Restrictions.disjunction();
String propertyNS = property.getNamespace();
String propertyName = property.getName();
for (Value value : in.getValues()) {
Conjunction conj = Restrictions.conjunction();
if (!StringUtils.isEmpty(property.getNamespace())) {
conj.add(Restrictions.gt(PROPERTY_NS_DB_FIELD, propertyNS));
}
conj.add(Restrictions.gt(PROPERTY_NAME_DB_FIELD, propertyName));
conj.add(Restrictions.gt(PROPERTY_VALUE_DB_FIELD, value.getValue()));
disj.add(conj);
}
return disj;
};
public String getIdentifier() {
return property.toString();
};
};
} else {
final String fieldName = in.getIdentifier().getName();
if (INSTANCE_STATUS_FIELD.equals(fieldName)) {
short noState = 200; // TODO move to constants
final Disjunction disj = Restrictions.disjunction();
final Collection values = ValuesHelper.extract((Collection<Value>) in.getValues());
if (values.contains(STATUS_ACTIVE)) {
disj.add(Restrictions.eq(INSTANCE_STATUS_DB_FIELD, ProcessState.STATE_NEW));
disj.add(Restrictions.eq(INSTANCE_STATUS_DB_FIELD, ProcessState.STATE_ACTIVE));
disj.add(Restrictions.eq(INSTANCE_STATUS_DB_FIELD, ProcessState.STATE_READY));
}
if (values.contains(STATUS_SUSPENDED)) {
disj.add(Restrictions.eq(INSTANCE_STATUS_DB_FIELD, ProcessState.STATE_SUSPENDED));
}
if (values.contains(STATUS_ERROR)) {
disj.add(
Restrictions.eq(
INSTANCE_STATUS_DB_FIELD, noState)); // Error instance state doesn't exist yet
}
if (values.contains(STATUS_COMPLETED)) {
disj.add(Restrictions.eq(INSTANCE_STATUS_DB_FIELD, ProcessState.STATE_COMPLETED_OK));
}
if (values.contains(STATUS_TERMINATED)) {
disj.add(Restrictions.eq(INSTANCE_STATUS_DB_FIELD, ProcessState.STATE_TERMINATED));
}
if (values.contains(STATUS_FAULTED)) {
disj.add(
Restrictions.eq(INSTANCE_STATUS_DB_FIELD, ProcessState.STATE_COMPLETED_WITH_FAULT));
}
return new INEvaluator<String, Criterion, Object>() {
public Criterion evaluate(Object paramValue) {
return disj;
};
public String getIdentifier() {
return INSTANCE_STATUS_DB_FIELD;
};
};
} else {
final Collection objValues;
final Collection<Value> values = in.getValues();
if (INSTANCE_ID_FIELD.equals(fieldName)) {
objValues = new ArrayList<Long>(values.size());
for (Value value : values) {
objValues.add(Long.valueOf((String) value.getValue()));
}
} else if (INSTANCE_STARTED_FIELD.equals(fieldName)
|| INSTANCE_LAST_ACTIVE_FIELD.equals(fieldName)) {
objValues = new ArrayList<Date>(values.size());
try {
for (Value value : values) {
objValues.add(ISO8601DateParser.parse((String) value.getValue()));
}
} catch (ParseException ex) {
throw new RuntimeException(ex);
}
} else {
objValues = ValuesHelper.extract((Collection<Value>) values);
}
final String dbField = getDBField(fieldName);
return new INEvaluator<String, Criterion, Object>() {
/** @see org.apache.ode.ql.eval.skel.CommandEvaluator#evaluate(java.lang.Object) */
public Criterion evaluate(Object paramValue) {
return Restrictions.in(dbField, objValues);
}
/** @see org.apache.ode.ql.eval.skel.Identified#getIdentifier() */
public String getIdentifier() {
return dbField;
}
};
}
}
}
// convert the args for a call with signature callSig that is compatible
// with this
// to exactly the types this func expects (including filling in defaults if
// possible)
// throws on arg type or number mismatch
public Object[] convertParameters(
final FuncInfo callSig, Object[] args, final boolean externCall) {
if (args == null) {
args = new Object[0];
}
Debug.Assert(callSig != null);
Debug.Assert(callSig.numArgs() == args.length, "supplied arg count must match callSig");
// if (externCall) //!!!
// Debug.WriteLine("Warning: FuncInfo.convertParameters() - externCall being ignored
// (unimplemented)");
if (numRequiredArgs() > callSig.numArgs()) {
ScigolTreeParser.semanticError(
callSig.getDefinitionLocation(),
"not enough arguments for function " + this + " in call with signature " + callSig);
}
if (callSig.numArgs() > numArgs()) {
ScigolTreeParser.semanticError(
callSig.getDefinitionLocation(),
"too many arguments for function " + this + " in call with signature " + callSig);
}
final Object[] convertedArgs = new Object[numArgs()];
// for each formal param
for (int a = 0; a < numArgs(); a++) {
if (a < callSig.numArgs()) { // if param supplied
Object arg =
((args[a] instanceof Value)
? (((Value) args[a]).getValue())
: args[a]); // convert from Value if
// necessary
TypeSpec argType = TypeSpec.typeOf(arg);
if (!argType.isAny()) { // implicit conversion from any always
// exists
// does an implicit conversion from the argType to the
// parameter type exist?
if (!TypeManager.existsImplicitConversion(argType, _paramTypes[a], new Value(arg))) {
ScigolTreeParser.semanticError(
callSig.getDefinitionLocation(),
"argument "
+ a
+ " ("
+ _paramNames[a]
+ ") to func with signature "
+ this
+ " is of type '"
+ argType
+ "' which is incompatible with parameter type '"
+ _paramTypes[a]
+ "'");
}
} else {
arg = TypeSpec.unwrapAny(arg);
argType = TypeSpec.typeOf(arg);
}
// conversion
final Value convertedArg =
TypeManager.performImplicitConversion(argType, _paramTypes[a], new Value(arg));
if (convertedArg == null) {
ScigolTreeParser.semanticError(
callSig.getDefinitionLocation(),
"argument "
+ a
+ " ("
+ _paramNames[a]
+ ") to func with signature "
+ this
+ " is of type '"
+ argType
+ "' which cannot be converted into the required parameter type '"
+ _paramTypes[a]
+ "'");
}
convertedArgs[a] = convertedArg.getValue();
} else { // not supplied
// do we have a default value?
if (!_paramHasDefault[a]) {
ScigolTreeParser.semanticError(
callSig.getDefinitionLocation(),
"in call to function "
+ this
+ ", no argument was supplied for parameter "
+ _paramNames[a]
+ " (which has no default)");
}
// use default
convertedArgs[a] = _paramDefaults[a];
}
} // for each param
return convertedArgs;
}
public String getValue() {
return value.getValue();
}
