public void testSumGivesCorrectValue() {
RealmResults<AllTypes> resultList = testRealm.where(AllTypes.class).findAll();
Number sum = resultList.sum(FIELD_LONG);
// Sum of numbers 0 to M-1: (M-1)*M/2
assertEquals((TEST_DATA_SIZE - 1) * TEST_DATA_SIZE / 2, sum.intValue());
}
/**
* Checks whether the provided value is greater than the minimum. In case the value is an instance
* of string: checks whether the length of the string is equal to or smaller than the minLength
* property. In case the value is an instance of number: checks whether the length of the integer
* value is equal to or smaller than the minLength property.
*
* @return boolean true if the length of value is equal to or less than the minLength property,
* false otherwise
* @see
* nl.openedge.baritus.validation.FieldValidator#isValid(org.infohazard.maverick.flow.ControllerContext,
* nl.openedge.baritus.FormBeanContext, java.lang.String, java.lang.Object)
*/
@Override
public boolean isValid(
ControllerContext cctx, FormBeanContext formBeanContext, String fieldName, Object value) {
if (minLength == NO_MINIMUM) return true;
boolean minExceeded = false;
if (value != null) {
if (value instanceof String) {
String toCheck = (String) value;
int length = toCheck.length();
minExceeded = (length < minLength);
} else if (value instanceof Number) {
Number toCheck = (Number) value;
int length = toCheck.toString().length();
minExceeded = (length < minLength);
} else {
// just ignore; wrong type to check on
log.warn(
fieldName + " with value: " + value + " is of the wrong type for checking on length");
}
}
if (minExceeded) {
setErrorMessage(
formBeanContext,
fieldName,
getErrorMessageKey(),
new Object[] {
getFieldName(formBeanContext, fieldName), value, Integer.valueOf(minLength)
});
}
return (!minExceeded);
}
public Matrix createVector(BitVector selector) {
int rows = selector != null ? selector.countOnBits() : frame.size();
Matrix m = new Matrix(rows, 1);
for (int i = 0, j = 0; j < frame.size(); j++) {
if (selector == null || selector.isOn(j)) {
M rowValue = frame.object(j);
try {
Number numValue = (Number) numericField.get(rowValue);
m.set(i, 0, numValue.doubleValue());
} catch (IllegalAccessException e) {
e.printStackTrace();
throw new IllegalStateException(
String.format(
"Couldn't access field %s: %s", numericField.getName(), e.getMessage()));
}
i++;
}
}
return m;
}
@Test
public void testCursorPosition() throws Exception {
selenium.open("../tests/html/test_type_page1.html");
try {
assertEquals(selenium.getCursorPosition("username"), "8");
fail("expected failure");
} catch (Throwable e) {
}
selenium.windowFocus();
verifyEquals(selenium.getValue("username"), "");
selenium.type("username", "TestUser");
selenium.setCursorPosition("username", "0");
Number position = 0;
try {
position = selenium.getCursorPosition("username");
} catch (SeleniumException e) {
if (!isWindowInFocus(e)) {
return;
}
}
verifyEquals(position.toString(), "0");
selenium.setCursorPosition("username", "-1");
verifyEquals(selenium.getCursorPosition("username"), "8");
selenium.refresh();
selenium.waitForPageToLoad("30000");
try {
assertEquals(selenium.getCursorPosition("username"), "8");
fail("expected failure");
} catch (Throwable e) {
}
}
private static JSONObject extractVuserResult(Map<Integer, TreeMap<String, Integer>> graphData) {
JSONObject graphDataSet;
graphDataSet = new JSONObject();
JSONArray labels = new JSONArray();
HashMap<String, ArrayList<Number>> vUserState = new HashMap<String, ArrayList<Number>>(0);
vUserState.put("Passed", new ArrayList<Number>(0));
vUserState.put("Failed", new ArrayList<Number>(0));
vUserState.put("Stopped", new ArrayList<Number>(0));
vUserState.put("Error", new ArrayList<Number>(0));
for (Map.Entry<Integer, TreeMap<String, Integer>> run : graphData.entrySet()) {
Number tempVUserCount = run.getValue().get("Count");
if (tempVUserCount != null && tempVUserCount.intValue() > 0) {
labels.add(run.getKey());
vUserState.get("Passed").add(run.getValue().get("Passed"));
vUserState.get("Failed").add(run.getValue().get("Failed"));
vUserState.get("Stopped").add(run.getValue().get("Stopped"));
vUserState.get("Error").add(run.getValue().get("Error"));
}
}
graphDataSet.put(LABELS, labels);
graphDataSet.put(SERIES, createGraphDatasets(vUserState));
return graphDataSet;
}
public Number compute(Number d1, Number d2) {
float d2Float = d2.floatValue();
if (d2Float == 0) {
return null;
}
return d1.floatValue() / d2Float;
}
public Number compute(Number d1, Number d2) {
int d2Int = d2.intValue();
if (d2Int == 0) {
return null;
}
return d1.intValue() / d2Int;
}
public StringBuffer format(Object obj, StringBuffer toAppendTo, FieldPosition pos) {
// only works for numbers - class exception otherwise
Number millisNumber = (Number) obj;
long millis = millisNumber.longValue();
if (m_formats == null) {
initLocale(null);
}
if (millis < DateUtils.MILLIS_PER_SECOND && !m_showZero) {
return toAppendTo;
}
boolean added = false;
long[] result = calculate(millis);
for (int i = 0; i < result.length; i++) {
long l = result[i];
if (l > 0 || added || i == result.length - 1) {
if (added) {
toAppendTo.append(m_separator);
}
Object params = new Object[] {l};
m_formats[i].format(params, toAppendTo, pos);
added = true;
}
}
return toAppendTo;
}
@Override
public int compare(Pair<V, Number> pairOne, Pair<V, Number> pairTwo) {
Number leftSide = pairOne.getRight();
Number rightSide = pairTwo.getRight();
if (leftSide.getClass() == Double.class) {
Double left = (Double) leftSide;
Double right = (Double) rightSide;
if (left > right) {
return 1;
} else if (right > left) {
return -1;
}
} else if (leftSide.getClass() == Integer.class) {
Integer left = (Integer) leftSide;
Integer right = (Integer) rightSide;
if (left > right) {
return 1;
} else if (right > left) {
return -1;
}
}
return 0;
}
private void renderInner(Graphics2D g, int width2, int height2, double[] spaces) {
double startAngle = 0D;
DataModel1D model1 = (DataModel1D) this.getDataModel();
int stop = model1.getSize();
g.setColor(this.innerColor);
// g.setColor(Color.BLACK);
double ratio = 360 / this.getTotalValue().doubleValue();
int posX = (getCenterX() - this.innerWidth / 2);
int posY = (getCenterY() - this.innerHeight / 2); //
// g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
// RenderingHints.VALUE_ANTIALIAS_OFF);
for (int i = 0; i < stop; i++) {
Number n = model1.getValueAt(i);
if (n == null) {
continue;
}
int angle = (int) Math.round(n.doubleValue() * ratio);
double moveAngle = startAngle - angle / 2D;
double angleRadian = ((moveAngle) * Math.PI * 2) / 360;
double current_space = spaces[i];
int x = posX + (int) ((Math.cos(angleRadian)) * current_space);
int y = posY + (int) ((-Math.sin(angleRadian)) * current_space);
// g.fillArc(x, y, width2 * 2, height2 * 2, (int)
// Math.round(startAngle), -angle);
g.fillArc(
x, y, this.innerWidth, this.innerHeight, (int) Math.round(startAngle) + 50, -angle - 100);
startAngle -= angle;
}
}
void _serializeNumber(String key, Number value) {
NodeList elements = numberElements.getElementsByTagName(ENTRY_FLAG);
final int size = elements.getLength();
for (int i = 0; i < size; ++i) {
Element e = (Element) elements.item(i);
Attr nameAttr = e.getAttributeNode(KEY_FLAG);
if (nameAttr == null) {
throw newMalformedKeyAttrException(Repository.NUMBER);
}
if (key.equals(nameAttr.getValue())) {
Attr valueAttr = e.getAttributeNode(VALUE_FLAG);
if (valueAttr == null) {
throw newMalformedValueAttrException(key, Repository.NUMBER);
}
Attr typeAttr = e.getAttributeNode(TYPE_FLAG);
if (typeAttr == null) {
throw newMalformedTypeAttrException(key, Repository.NUMBER);
}
typeAttr.setValue(Configs.resolveNumberType(value).name());
valueAttr.setValue(value.toString());
return;
}
}
// no existing element found
Element element = xmlDoc.createElement(ENTRY_FLAG);
element.setAttribute(KEY_FLAG, key);
element.setAttribute(VALUE_FLAG, value.toString());
element.setAttribute(TYPE_FLAG, Configs.resolveNumberType(value).name());
numberElements.appendChild(element);
}
// ***** VDMTOOLS START Name=BoardLine#2|List|Number KEEP=NO
public BoardLine(final List cells, final Number yi) throws CGException {
vdm_init_BoardLine();
if (!this.pre_BoardLine(cells, yi).booleanValue())
UTIL.RunTime("Precondition failure in BoardLine");
{
final Number atom_1 = yi;
Map res_m_8 = new HashMap();
{
Set e1_set_13 = new HashSet(cells);
Set e_set_14 = new HashSet();
e_set_14 = new HashSet();
for (int count_17 = 1; count_17 <= 9; count_17++) e_set_14.add(new Integer(count_17));
Number x = null;
Cell cell = null;
Set tmpSet_30 = new HashSet(e_set_14);
for (Iterator enm_29 = tmpSet_30.iterator(); enm_29.hasNext(); ) {
Number elem_28 = UTIL.NumberToInt(enm_29.next());
/* x */
x = elem_28;
Set tmpSet_27 = new HashSet(e1_set_13);
for (Iterator enm_26 = tmpSet_27.iterator(); enm_26.hasNext(); ) {
Cell elem_25 = (Cell) enm_26.next();
/* cell */
cell = elem_25;
if ((cell.x).intValue() == x.intValue()) res_m_8.put(x, cell);
}
}
}
final Map atom_2 = res_m_8;
y = UTIL.NumberToInt(UTIL.clone(atom_1));
line = (Map) UTIL.clone(atom_2);
}
}
public WOActionResults saveType() {
EOEditingContext ec = (EOEditingContext) valueForBinding("ec");
ec.lock();
try {
boolean newType = (currType == null);
if (newType) {
currType = (ItogType) EOUtilities.createAndInsertInstance(ec, ItogType.ENTITY_NAME);
Number maxSort = (Number) valueForBinding("maxSort");
if (maxSort != null) {
currType.setSort(new Integer(maxSort.intValue() + 1));
} else {
currType.setSort(new Integer(1));
}
}
currType.setName(itogName);
currType.setTitle(itogTitle);
currType.setInYearCount((itogCount == null) ? new Integer(0) : itogCount);
ec.saveChanges();
// if(newType) {
// allTypes = allTypes.arrayByAddingObject(currType);
// itogsList = NSArray.EmptyArray;
// }
setValueForBinding(currType, "currType");
} catch (Exception e) {
SetupItogs.logger.log(WOLogLevel.WARNING, "Error saving changes in list ", e);
session().takeValueForKey(e.getMessage(), "message");
ec.revert();
} finally {
ec.unlock();
}
return (WOActionResults) valueForBinding("actionResult");
}
/**
* Constructs a new <code>LongRange</code> with the specified minimum and maximum numbers (both
* inclusive).
*
* <p>The arguments may be passed in the order (min,max) or (max,min). The getMinimum and
* getMaximum methods will return the correct values.
*
* @param number1 first number that defines the edge of the range, inclusive
* @param number2 second number that defines the edge of the range, inclusive
* @throws IllegalArgumentException if either number is <code>null</code>
*/
public LongRange(Number number1, Number number2) {
super();
if (number1 == null || number2 == null) {
throw new IllegalArgumentException("The numbers must not be null");
}
long number1val = number1.longValue();
long number2val = number2.longValue();
if (number2val < number1val) {
this.min = number2val;
this.max = number1val;
if (number2 instanceof Long) {
this.minObject = (Long) number2;
}
if (number1 instanceof Long) {
this.maxObject = (Long) number1;
}
} else {
this.min = number1val;
this.max = number2val;
if (number1 instanceof Long) {
this.minObject = (Long) number1;
}
if (number2 instanceof Long) {
this.maxObject = (Long) number2;
}
}
}
private double[] retrieveFcReadings(NodeList cycleList) {
// Check the the first cycle is cycle #1, else throw an error dialog
Element firstCycleElement = (Element) cycleList.item(0);
String firstCycleNumber = firstCycleElement.getAttribute("X");
if (!firstCycleNumber.contains("1")) {
// TODO present an error dialog and terminate import
// ...pretty harsh but this is essential for baseline subtraction
}
NumberFormat numFormat =
NumberFormat.getInstance(); // Need to convert comma decimal seperators to periods
ArrayList<Double> fcDataSet = Lists.newArrayList();
// Cycle through the cycles and collect the Fc readings
for (int j = 0; j < cycleList.getLength(); j++) {
// This assumes that the first cycle is cycle 1
Element cycleElement = (Element) cycleList.item(j);
try {
// NumberFormat needed to prevent locale differences in numbers (e.g. comma vs period)
Number value = numFormat.parse(cycleElement.getAttribute("Y"));
fcDataSet.add(value.doubleValue());
} catch (Exception e) {
}
}
double[] fcArray = new double[fcDataSet.size()];
for (int k = 0; k < fcDataSet.size(); k++) {
fcArray[k] = fcDataSet.get(k);
}
return fcArray;
}
private void testCorrectnessOfErrorFunction(List<Number> inputList) throws Exception {
int inRange = 0;
int numberOfRuns = 1000;
double sampleRatio = 1 / (double) WEIGHT;
double actual = getExpectedValue(inputList);
Random rand = new Random(1);
for (int i = 0; i < numberOfRuns; i++) {
// Compute Sampled Value using sampledList (numberOfRuns times)
ImmutableList.Builder<Number> sampledList = ImmutableList.builder();
for (Number x : inputList) {
if (rand.nextDouble() < sampleRatio) {
sampledList.add(x);
}
}
BlockBuilder builder = getType().createBlockBuilder(new BlockBuilderStatus());
for (Number sample : sampledList.build()) {
if (getType() == BIGINT) {
BIGINT.writeLong(builder, sample.longValue());
} else if (getType() == DOUBLE) {
DOUBLE.writeDouble(builder, sample.doubleValue());
} else {
throw new AssertionError("Can only handle longs and doubles");
}
}
Page page = new Page(builder.build());
page = OperatorAssertion.appendSampleWeight(ImmutableList.of(page), WEIGHT).get(0);
Accumulator accumulator =
getFunction()
.bind(
ImmutableList.of(0),
Optional.<Integer>absent(),
Optional.of(page.getChannelCount() - 1),
getConfidence())
.createAccumulator();
accumulator.addInput(page);
Block result = accumulator.evaluateFinal();
String approxValue =
BlockAssertions.toValues(accumulator.getFinalType(), result).get(0).toString();
double approx = Double.parseDouble(approxValue.split(" ")[0]);
double error = Double.parseDouble(approxValue.split(" ")[2]);
// Check if actual answer lies within [approxAnswer - error, approxAnswer + error]
if (Math.abs(approx - actual) <= error) {
inRange++;
}
}
BinomialDistribution binomial = new BinomialDistribution(numberOfRuns, getConfidence());
int lowerBound = binomial.inverseCumulativeProbability(0.01);
int upperBound = binomial.inverseCumulativeProbability(0.99);
assertTrue(
lowerBound < inRange && inRange < upperBound,
String.format(
"%d out of %d passed. Expected [%d, %d]",
inRange, numberOfRuns, lowerBound, upperBound));
}
public Number compute(Number d1, Number d2) {
double d2Double = d2.doubleValue();
if ((divisionByZeroReturnsNull) && (d2Double == 0)) {
return null;
}
return d1.doubleValue() / d2Double;
}
static EvPixels apply(Number aVal, EvPixels b) {
if (aVal instanceof Integer && b.getType() == EvPixelsType.INT) {
// Should use the common higher type here
b = b.getReadOnly(EvPixelsType.INT);
int a = aVal.intValue();
int w = b.getWidth();
int h = b.getHeight();
EvPixels out = new EvPixels(b.getType(), w, h);
int[] bPixels = b.getArrayInt();
int[] outPixels = out.getArrayInt();
for (int i = 0; i < bPixels.length; i++) outPixels[i] = a / bPixels[i];
return out;
} else {
// Should use the common higher type here
b = b.getReadOnly(EvPixelsType.DOUBLE);
double a = aVal.doubleValue();
int w = b.getWidth();
int h = b.getHeight();
EvPixels out = new EvPixels(b.getType(), w, h);
double[] bPixels = b.getArrayDouble();
double[] outPixels = out.getArrayDouble();
for (int i = 0; i < bPixels.length; i++) outPixels[i] = a / bPixels[i];
return out;
}
}
public Number compute(Number d1, Number d2) {
long d2Long = d2.longValue();
if (d2Long == 0) {
return null;
}
return d1.longValue() / d2Long;
}
private void writeTable(
Iterable<Number> values,
FormatAndBits compression,
int count,
NormMap uniqueValues,
int numOrds)
throws IOException {
data.writeVInt(PackedInts.VERSION_CURRENT);
data.writeVInt(compression.format.getId());
data.writeVInt(compression.bitsPerValue);
data.writeVInt(numOrds);
for (int i = 0; i < numOrds; i++) {
data.writeByte(uniqueValues.values[i]);
}
final PackedInts.Writer writer =
PackedInts.getWriterNoHeader(
data,
compression.format,
count,
compression.bitsPerValue,
PackedInts.DEFAULT_BUFFER_SIZE);
for (Number nv : values) {
int ord = uniqueValues.ord(nv.byteValue());
if (ord < numOrds) {
writer.add(ord);
} else {
writer.add(numOrds); // collapses all ords >= numOrds into a single value
}
}
writer.finish();
}
public static double getPercentParameter(
HttpServletRequest request, String param, double defValue) {
double p = defValue;
String input = request.getParameter(param);
String pattern = "##.####%";
if ((input == null) || (input.equals(""))) {
return p;
}
// Make sure we have a % at the end of the string, if not add one.
if (input.indexOf('%') < 0) {
input = input + "%";
}
NumberFormat parser = null;
if (!pattern.equals("")) {
parser = new DecimalFormat(pattern);
} else {
parser = NumberFormat.getPercentInstance();
}
Number parsed = null;
try {
parsed = parser.parse(input);
} catch (ParseException pe) {
return defValue;
}
return parsed.doubleValue();
}
/**
* Returns the range of values the renderer requires to display all the items from the specified
* dataset.
*
* @param dataset the dataset (<code>null</code> not permitted).
* @return The range (or <code>null</code> if the dataset is empty).
*/
public Range findRangeBounds(CategoryDataset dataset) {
if (dataset == null) {
return null;
}
boolean allItemsNull = true; // we'll set this to false if there is at
// least one non-null data item...
double minimum = 0.0;
double maximum = 0.0;
int columnCount = dataset.getColumnCount();
for (int row = 0; row < dataset.getRowCount(); row++) {
double runningTotal = 0.0;
for (int column = 0; column <= columnCount - 1; column++) {
Number n = dataset.getValue(row, column);
if (n != null) {
allItemsNull = false;
double value = n.doubleValue();
if (column == columnCount - 1) {
// treat the last column value as an absolute
runningTotal = value;
} else {
runningTotal = runningTotal + value;
}
minimum = Math.min(minimum, runningTotal);
maximum = Math.max(maximum, runningTotal);
}
}
}
if (!allItemsNull) {
return new Range(minimum, maximum);
} else {
return null;
}
}
private Variable getVariableFromJmxAttribute(JmxAttribute pAttribute) throws JMException {
final Object value = pAttribute.getValue();
if (value == null) {
return new Null();
}
final String type = pAttribute.getType();
if ("int".equals(type)) {
final Number n = (Number) value;
return new Integer32(n.intValue());
} else if ("long".equals(type)) {
final Number n = (Number) value;
return new Counter64(n.longValue());
} else if ("boolean".equals(type)) {
final Boolean b = (Boolean) value;
return new Integer32(b ? 1 : 0);
} else if ("java.lang.String".equals(type)) {
return new OctetString(String.valueOf(value));
} else {
return new OctetString("Unsupported Type: " + pAttribute.getType());
}
}
@Override
protected Prompt acceptValidatedInput(ConversationContext context, Number input) {
boolean found = false;
for (NPC npc : choices) {
if (input.intValue() == npc.getId()) {
found = true;
break;
}
}
CommandSender sender = (CommandSender) context.getForWhom();
if (!found) {
Messaging.sendErrorTr(sender, Messages.SELECTION_PROMPT_INVALID_CHOICE, input);
return this;
}
NPC toSelect = CitizensAPI.getNPCRegistry().getById(input.intValue());
try {
callback.run(toSelect);
} catch (ServerCommandException ex) {
Messaging.sendTr(sender, CommandMessages.MUST_BE_INGAME);
} catch (CommandUsageException ex) {
Messaging.sendError(sender, ex.getMessage());
Messaging.sendError(sender, ex.getUsage());
} catch (UnhandledCommandException ex) {
ex.printStackTrace();
} catch (WrappedCommandException ex) {
ex.getCause().printStackTrace();
} catch (CommandException ex) {
Messaging.sendError(sender, ex.getMessage());
} catch (NumberFormatException ex) {
Messaging.sendErrorTr(sender, CommandMessages.INVALID_NUMBER);
}
return null;
}
@Override
public TokenStream tokenStream(Analyzer analyzer, TokenStream reuse) throws IOException {
if (!fieldType().indexed()) {
return null;
}
final NumericType numericType = fieldType().numericType();
if (numericType != null) {
if (!(reuse instanceof NumericTokenStream
&& ((NumericTokenStream) reuse).getPrecisionStep() == type.numericPrecisionStep())) {
// lazy init the TokenStream as it is heavy to instantiate
// (attributes,...) if not needed (stored field loading)
reuse = new NumericTokenStream(type.numericPrecisionStep());
}
final NumericTokenStream nts = (NumericTokenStream) reuse;
// initialize value in TokenStream
final Number val = (Number) fieldsData;
switch (numericType) {
case INT:
nts.setIntValue(val.intValue());
break;
case LONG:
nts.setLongValue(val.longValue());
break;
case FLOAT:
nts.setFloatValue(val.floatValue());
break;
case DOUBLE:
nts.setDoubleValue(val.doubleValue());
break;
default:
throw new AssertionError("Should never get here");
}
return reuse;
}
if (!fieldType().tokenized()) {
if (stringValue() == null) {
throw new IllegalArgumentException("Non-Tokenized Fields must have a String value");
}
if (!(reuse instanceof StringTokenStream)) {
// lazy init the TokenStream as it is heavy to instantiate
// (attributes,...) if not needed (stored field loading)
reuse = new StringTokenStream();
}
((StringTokenStream) reuse).setValue(stringValue());
return reuse;
}
if (tokenStream != null) {
return tokenStream;
} else if (readerValue() != null) {
return analyzer.tokenStream(name(), readerValue());
} else if (stringValue() != null) {
return analyzer.tokenStream(name(), stringValue());
}
throw new IllegalArgumentException(
"Field must have either TokenStream, String, Reader or Number value; got " + this);
}
public void saveDisplayObjectType() {
DOTPoint newDOTPoint =
(DOTPoint) _dotDefinitionDialogFrame.getScratchDisplayObjectType().getCopy(null);
final String name = _dotDefinitionDialogFrame.getNameText();
if ((name == null) || (name.length() == 0)) {
JOptionPane.showMessageDialog(
new JFrame(), "Bitte geben Sie einen Namen an!", "Fehler", JOptionPane.ERROR_MESSAGE);
return;
}
if (!_dotDefinitionDialogFrame.isReviseOnly()) {
if (_dotDefinitionDialogFrame.getDotManager().containsDisplayObjectType(name)) {
JOptionPane.showMessageDialog(
new JFrame(),
"Ein Darstellungstyp mit diesem Namen existiert bereits!",
"Fehler",
JOptionPane.ERROR_MESSAGE);
return;
}
}
newDOTPoint.setName(name);
newDOTPoint.setInfo(_dotDefinitionDialogFrame.getInfoText());
final Object value = _translationFactorSpinner.getValue();
if (value instanceof Number) {
final Number number = (Number) value;
newDOTPoint.setTranslationFactor(number.doubleValue());
}
newDOTPoint.setJoinByLine(_joinByLineCheckBox.isSelected());
_dotDefinitionDialogFrame.getDotManager().saveDisplayObjectType(newDOTPoint);
_dotDefinitionDialogFrame.setDisplayObjectType(newDOTPoint, true);
}
/**
* Tests if this object is equal to another
*
* @param a_obj the other object
* @return true: this object is equal to the other one
* @author Klaus Meffert
* @since 2.3
*/
public boolean equals(final Object a_obj) {
if (a_obj == null) {
return false;
}
if (a_obj == this) {
return true;
}
if (!(a_obj instanceof KeyedValues)) {
return false;
}
final KeyedValues kvs = (KeyedValues) a_obj;
final int count = size();
if (count != kvs.size()) {
return false;
}
for (int i = 0; i < count; i++) {
final Comparable k1 = getKey(i);
final Comparable k2 = kvs.getKey(i);
if (!k1.equals(k2)) {
return false;
}
final Number v1 = getValue(i);
final Number v2 = kvs.getValue(i);
if (v1 == null) {
if (v2 != null) {
return false;
}
} else {
if (!v1.equals(v2)) {
return false;
}
}
}
return true;
}
/**
* 对数字对象作处理，如果为0或空则返回默认值
*
* @param number 数字对象
* @param defaultValue 默认值
* @return
*/
public static String number(Number number, String defaultValue) {
if (number == null || StringUtils.isBlank(number.toString()) || "0".equals(number.toString())) {
return defaultValue;
} else {
return number.toString();
}
}
private Object maxOfList(Node lst, RuleContext context) {
java.util.List<Node> l = Util.convertList(lst, context);
Number max = null;
XSDDateTime maxDate = null;
for (int i = 0; l != null && i < l.size(); i++) {
Node elt = (Node) l.get(i);
if (elt != null && elt.isLiteral()) {
Object v1 = elt.getLiteralValue();
if (v1 instanceof Number) {
if (max == null || max.doubleValue() < ((Number) v1).doubleValue()) {
max = (Number) v1;
}
} else if (v1 instanceof XSDDateTime) {
if (maxDate == null || maxDate.compareTo((XSDDateTime) v1) < 0) {
maxDate = (XSDDateTime) v1;
}
} else {
throw new BuiltinException(
this, context, "Element of list input to max not a number: " + v1.toString());
}
} else {
throw new BuiltinException(
this, context, "Element of list input to max not a Literal: " + elt.toString());
}
}
if (maxDate != null) {
return maxDate;
}
return max;
}
@Override
public void setItem(Object anObject) {
// System.out.println("setItem: " + anObject + " " + anObject.getClass());
if (anObject instanceof String) {
try {
Object o = inputFormat.parseObject((String) anObject);
// HACK: have to fix up DecimalFormat parsed object because
// it may return Long whole number with fraction
if (isNumberModel) {
Number number = (Number) o;
// System.out.println("SetItem PARSED: " + number + " " + number.getClass());
if (isFloatingPoint) {
if (!(number instanceof Double) && !(number instanceof Float))
o = new Double(number.doubleValue());
} else {
if (!(number instanceof Integer) && !(number instanceof Long))
o = new Long(number.longValue());
}
}
spinner.setValue(o);
} catch (ParseException pe) {
RuntimeException t = new IllegalArgumentException("Illegal input: " + anObject);
t.initCause(pe);
throw t;
}
} else {
throw new RuntimeException("asdfasdasdf");
// spinner.setValue(anObject);
}
}
