private final <T> void setValue(int index, Field<T> field, T value) {
Value<T> val = getValue0(index);
UniqueKey<?> key = getPrimaryKey();
// Normal fields' changed flag is always set to true
if (key == null || !key.getFields().contains(field)) {
val.setValue(value);
}
// The primary key's changed flag might've been set previously
else if (val.isChanged()) {
val.setValue(value);
}
// [#2764] Users may override updatability of primary key values
else if (updatablePrimaryKeys(settings(this))) {
val.setValue(value);
}
// [#2698] If the primary key has not yet been set
else if (val.getOriginal() == null) {
val.setValue(value);
}
// [#979] If the primary key is being changed, all other fields' flags
// need to be set to true for in case this record is stored again, an
// INSERT statement will thus be issued
else {
val.setValue(value, true);
if (val.isChanged()) {
changed(true);
}
}
}
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());
}
}
/**
* 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;
}
/** 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;
}
public static OsgiManifest read(List<String> lines) {
// parse lines
OsgiManifest manifest = new OsgiManifest();
for (int i = 0; i < lines.size(); i++) {
String line = lines.get(i);
for (int j = i + 1; j < lines.size() && lines.get(j).startsWith(" "); j++, i++) {
line = line + lines.get(j);
}
int index = line.indexOf(':');
if (index > 0) {
String attributeName = line.substring(0, index).trim();
List<String> valueTokens = tokenize(line.substring(index + 1), ',');
Attribute values = manifest.getAttribute(attributeName);
for (String valueToken : valueTokens) {
if (valueToken.trim().isEmpty()) continue;
Value value = new Value();
values.add(value);
List<String> annotationTokens = tokenize(valueToken, ';');
value.setValue(annotationTokens.get(0));
for (int k = 1; k < annotationTokens.size(); k++) {
String annotationToken = annotationTokens.get(k);
index = annotationToken.indexOf('=');
if (index > 0) {
value.setAnnotation(
annotationToken.substring(0, index), annotationToken.substring(index + 1));
}
}
}
}
}
return manifest;
}
public void randomizeValues() {
int size = values.size();
Random r = new Random();
for (Value value : values) {
int randomValue = r.nextInt(size);
value.setValue(String.valueOf(randomValue));
}
}
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;
}
public static void parse(
String[] args, HostsPorts input, HostsPorts outputs, Value omega, Value tau)
throws ParseException {
Pattern pattern;
Matcher matcher;
for (int i = 0; i < args.length; i++) {
if (args[i].startsWith("-input")) {
int j = args[i].indexOf('=');
input.addHostPort(null, Integer.parseInt(args[i].substring(j + 1)));
} else if (args[i].startsWith("-outputs")) {
int j = args[i].indexOf('=');
String str = args[i].substring(j + 1);
String[] ipaddrs = str.split(",");
for (int k = 0; k < ipaddrs.length; k++) {
pattern = Pattern.compile("[0-9]+.[0-9]+.[0-9]+.[0-9]+:[0-9]+");
matcher = pattern.matcher(ipaddrs[k]);
if (!matcher.matches()) {
throw new ParseException("illegal IP Address format found for outputs: ", i);
}
int colon = ipaddrs[k].indexOf(':');
outputs.addHostPort(
ipaddrs[k].substring(0, colon), Integer.parseInt(ipaddrs[k].substring(colon + 1)));
}
} else if (args[i].startsWith("-omega")) {
int j = args[i].indexOf('=');
omega.setValue(Integer.parseInt(args[i].substring(j + 1)));
} else if (args[i].startsWith("-tau")) {
int j = args[i].indexOf('=');
tau.setValue(Double.parseDouble(args[i].substring(j + 1)));
} else {
throw new ParseException("illegal option found: ", i);
}
}
}
/**
* @param name Value name
* @param value Value
*/
public void setValue(String name, String value) {
Value recordValue = null;
for (Value v : recordValues) {
if (v.getName().equalsIgnoreCase(name)) {
recordValue = v;
break;
}
}
if (recordValue == null) {
recordValue = new Value();
recordValue.setName(name);
recordValues.add(recordValue);
}
recordValue.setValue(value);
}
/**
* 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;
}
