public static Comparable<?> remainder(Comparable<?> param1, Comparable<?> param2) throws ParseException { if (param1 == null || param2 == null) { return null; } if (param1 instanceof String) { param1 = parse((String) param1); } if (param2 instanceof String) { param2 = parse((String) param2); } if (param1 instanceof Number && param2 instanceof Number) { // BigInteger type is not supported if (param1 instanceof BigDecimal || param2 instanceof BigDecimal) { BigDecimal b1 = getBigDecimal((Number) param1); BigDecimal b2 = getBigDecimal((Number) param2); return b1.remainder(b2); } if (param1 instanceof Double || param2 instanceof Double || param1 instanceof Float || param2 instanceof Float) { return ((Number) param1).doubleValue() % ((Number) param2).doubleValue(); } else { // Long, Integer, Short, Byte long l1 = ((Number) param1).longValue(); long l2 = ((Number) param2).longValue(); return l1 % l2; } } else { throw new ParseException( WRONG_TYPE + " (" + param1.getClass() + "%" + param2.getClass() + ")"); } }
public static java.util.Date addMonths(Comparable<?> param1, Comparable<?> param2, Calendar cal) throws ParseException { if (param1 == null && param2 == null) { return null; } try { int months = getInteger(param2); if (param1 instanceof Timestamp) { Timestamp d = (Timestamp) param1; cal.setTimeInMillis(d.getTime()); cal.add(Calendar.MONTH, months); return new Timestamp(cal.getTimeInMillis()); } else if (param1 instanceof java.sql.Date) { java.util.Date d = (java.util.Date) param1; cal.setTimeInMillis(d.getTime()); cal.add(Calendar.MONTH, months); return new java.util.Date(cal.getTimeInMillis()); } else { throw new ParseException(); } } catch (ParseException e) { throw new ParseException( WRONG_TYPE + " month_between(" + param1.getClass() + "," + param2.getClass() + ")"); } }
Comparable<?> coerceValue(Comparable<?> value, Class targetClass) { if (value == null) return null; if (value.getClass() == targetClass) return value; // FIXME: For now we convert by first converting the source value to a // string and then converting to the target type. This logic probably needs // another pass to make it more robust/optimized. String s = value.toString(); Comparable<?> obj = null; try { if (targetClass == Integer.class) { obj = new Integer(s); } else if (targetClass == Long.class) { obj = new Long(s); } else if (targetClass == Short.class) { obj = new Short(s); } else if (targetClass == Boolean.class) { obj = new Boolean(s); } else if (targetClass == Float.class) { obj = new Float(s); } else if (targetClass == Double.class) { obj = new Double(s); } else if (targetClass == Byte.class) { obj = new Byte(s); } else if (targetClass == String.class) { obj = s; } else if (targetClass == Date.class) { SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS"); dateFormat.setTimeZone(TimeZone.getTimeZone("GMT")); try { obj = dateFormat.parse(s); } catch (ParseException exc) { throw new TypeMismatchStorageException( Date.class.getName(), value.getClass().getName(), "???"); } } } catch (Exception exc) { // Ignore the exception here. In this case obj will not be set, so we'll // throw the StorageException below when we check for a null obj. } if (obj == null) throw new StorageException("Column value could not be coerced to the correct type"); return obj; }
/** * 根据传入的参数决定使用哪类枚举器 * * @param comp * @param needMergeValueInCloseInterval * @return */ private CloseIntervalFieldsEnumeratorHandler getCloseIntervalEnumeratorHandlerByComparative( Comparative comp, boolean needMergeValueInCloseInterval) { if (!needMergeValueInCloseInterval) { return enumeratorMap.get(DEFAULT_ENUMERATOR); } if (comp == null) { throw new IllegalArgumentException("comp is null"); } Comparable value = comp.getValue(); if (value instanceof ComparativeBaseList) { ComparativeBaseList comparativeBaseList = (ComparativeBaseList) value; for (Comparative comparative : comparativeBaseList.getList()) { return getCloseIntervalEnumeratorHandlerByComparative( comparative, needMergeValueInCloseInterval); } throw new NotSupportException(); // 不可能到这一步 } else if (value instanceof Comparative) { return getCloseIntervalEnumeratorHandlerByComparative(comp, needMergeValueInCloseInterval); } else { // 表明是一个comparative对象 CloseIntervalFieldsEnumeratorHandler enumeratorHandler = enumeratorMap.get(value.getClass().getName()); if (enumeratorHandler != null) { return enumeratorHandler; } else { return enumeratorMap.get(DEFAULT_ENUMERATOR); } } }
private boolean compare_Comparable(int operation, Comparable<Object> value1, Object value2) { if (operation == SUBSTRING) { return false; } value2 = valueOf(value1.getClass(), (String) value2); if (value2 == null) { return false; } try { switch (operation) { case APPROX: case EQUAL: { return value1.compareTo(value2) == 0; } case GREATER: { return value1.compareTo(value2) >= 0; } case LESS: { return value1.compareTo(value2) <= 0; } } } catch (Exception e) { // if the compareTo method throws an exception; return false return false; } return false; }
public static Boolean not(Comparable<?> param) throws ParseException { if (param == null) { return null; } if (param instanceof Boolean) { return ((Boolean) param).booleanValue() ? Boolean.TRUE : Boolean.FALSE; } throw new ParseException(WRONG_TYPE + " not " + param.getClass()); }
/** * Method getTypes returns an array of the element classes. Null if the element is null. * * @return the types (type Class[]) of this Tuple object. */ public Class[] getTypes() { Class[] types = new Class[elements.size()]; for (int i = 0; i < elements.size(); i++) { Comparable value = elements.get(i); if (value != null) types[i] = value.getClass(); } return types; }
public static Integer second(Comparable<?> param, Calendar cal) throws ParseException { if (param == null) { return null; } if (param instanceof Timestamp || param instanceof java.sql.Time) { java.util.Date ts = (java.util.Date) param; cal.setTimeInMillis(ts.getTime()); return new Integer(cal.get(SECOND)); } throw new ParseException(WRONG_TYPE + " second(" + param.getClass() + ")"); }
boolean matchesValue(Comparable<?> value) { boolean isNullEqPredicate = (startValue == null) && (endValue == null) && startInclusive && endInclusive; if (value == null) return isNullEqPredicate; if (isNullEqPredicate) return false; int result; Comparable<?> coercedValue; if (startValue != null) { coercedValue = coerceValue(value, startValue.getClass()); result = ((Comparable) coercedValue).compareTo(startValue); if ((result < 0) || (!startInclusive && (result == 0))) return false; } if (endValue != null) { coercedValue = coerceValue(value, endValue.getClass()); result = ((Comparable) coercedValue).compareTo(endValue); if ((result > 0) || (!endInclusive && (result == 0))) return false; } return true; }
@Override public Comparable value(NodeCommon node) { if (args.size() < 1) return null; // sysdate ? if (function.names.size() > 1) return null; // static List<Comparable> margs = ListUtil.newList(); for (Expression arg : args) { margs.add(arg.value(node)); } String fnName = function.names.get(0); Comparable target = margs.get(0); try { if (margs.size() == 1) return (Comparable) target.getClass().getMethod(fnName).invoke(target); Iterator argIter = Iterables.skip(margs, 1).iterator(); Class[] argClz = new Class[margs.size() - 1]; Object[] argObj = new Object[margs.size() - 1]; int i = 0; while (argIter.hasNext()) { Object aobj = argIter.next(); argClz[i] = (aobj.getClass().equals(BigDecimal.class)) ? int.class : aobj.getClass(); argObj[i++] = (aobj instanceof BigDecimal) ? ((BigDecimal) aobj).intValue() : aobj; } final Object result = target.getClass().getMethod(fnName, argClz).invoke(target, argObj); if ((result instanceof Integer) || result instanceof Long || result instanceof Float || result instanceof Double) return NumberUtil.createBigDecimal(result.toString()); return (Comparable) result; } catch (Throwable ex) { throw new IllegalArgumentException(ex); } }
public static Integer dayOfWeek(Comparable<?> param, Calendar cal) throws ParseException { if (param == null) { return null; } if (param instanceof Timestamp || param instanceof java.sql.Date) { java.util.Date ts = (java.util.Date) param; cal.setTimeInMillis(ts.getTime()); int dayOfWeek = cal.get(DAY_OF_WEEK) - 1; if (dayOfWeek == 0) { dayOfWeek = 7; } return new Integer(dayOfWeek); } throw new ParseException(WRONG_TYPE + " dayofweek(" + param.getClass() + ")"); }
/** * Adds 1 to the frequency count for v. * * <p>If other objects have already been added to this Frequency, v must be comparable to those * that have already been added. * * @param v the value to add. * @throws IllegalArgumentException if <code>v</code> is not comparable with previous entries */ public void addValue(Comparable<?> v) { Comparable<?> obj = v; if (v instanceof Integer) { obj = Long.valueOf(((Integer) v).longValue()); } try { Long count = freqTable.get(obj); if (count == null) { freqTable.put(obj, Long.valueOf(1)); } else { freqTable.put(obj, Long.valueOf(count.longValue() + 1)); } } catch (ClassCastException ex) { // TreeMap will throw ClassCastException if v is not comparable throw MathRuntimeException.createIllegalArgumentException( LocalizedFormats.INSTANCES_NOT_COMPARABLE_TO_EXISTING_VALUES, v.getClass().getName()); } }
private boolean compare_Comparable(int operation, Comparable value1, Object value2) { if (operation == SUBSTRING) { return false; } Constructor constructor; try { constructor = value1.getClass().getConstructor(constructorType); } catch (NoSuchMethodException e) { return false; } try { if (!constructor.isAccessible()) AccessController.doPrivileged(new SetAccessibleAction(constructor)); value2 = constructor.newInstance(new Object[] {((String) value2).trim()}); } catch (IllegalAccessException e) { return false; } catch (InvocationTargetException e) { return false; } catch (InstantiationException e) { return false; } switch (operation) { case APPROX: case EQUAL: { return value1.compareTo(value2) == 0; } case GREATER: { return value1.compareTo(value2) >= 0; } case LESS: { return value1.compareTo(value2) <= 0; } } return false; }
public void saveEntryIndex(QueryableEntry e) throws QueryException { Data key = e.getIndexKey(); Comparable oldValue = recordValues.remove(key); Comparable newValue = e.getAttribute(attribute); if (newValue == null) { newValue = NULL; } recordValues.put(key, newValue); if (newValue.getClass().isEnum()) { newValue = TypeConverters.ENUM_CONVERTER.convert(newValue); } if (oldValue == null) { // new indexStore.newIndex(newValue, e); } else { // update indexStore.removeIndex(oldValue, key); indexStore.newIndex(newValue, e); } if (attributeType == null) { attributeType = e.getAttributeType(attribute); } }
public static Comparable<?> round(Comparable<?> param, Calendar cal) throws ParseException { if (param == null) { return null; } if (param instanceof String) { param = parse((String) param); } if (param instanceof BigDecimal) { // BigInteger is not supported BigDecimal b = ((BigDecimal) param).setScale(0, BigDecimal.ROUND_HALF_UP); try { return b.longValueExact(); } catch (ArithmeticException e) { } return b; } if (param instanceof Double || param instanceof Float) { return Math.round(((Number) param).doubleValue()); } if (param instanceof Number) { // Long, Integer, Short, Byte return param; } if (param instanceof Timestamp) { Timestamp ts = (Timestamp) param; cal.setTimeInMillis(ts.getTime()); int year = cal.get(YEAR); int month = cal.get(MONTH); int date = cal.get(DATE); int hour = cal.get(HOUR_OF_DAY); cal.clear(); if (hour > 11) { date++; } cal.set(year, month, date); return new Timestamp(cal.getTimeInMillis()); } throw new ParseException(WRONG_TYPE + " round(" + param.getClass() + ")"); }
public AttributeType getAttributeType(String attributeName) { return ReflectionHelper.getAttributeType(attributeValue.getClass()); }
public void setMinimum(final Comparable min) { this.min = min; if (min != null) { setValueClass(min.getClass()); } }
/** * Sets the maximum permissible value. If the <code>valueClass</code> has not been specified, and * <code>max</code> is non null, the <code>valueClass</code> will be set to that of the class of * <code>max</code>. * * @param max Maximum legal value that can be input * @see #setValueClass */ public void setMaximum(Comparable max) { if (getValueClass() == null && max != null) { setValueClass(max.getClass()); } this.max = max; }
/** * Sets the minimum permissible value. If the <code>valueClass</code> has not been specified, and * <code>minimum</code> is non null, the <code>valueClass</code> will be set to that of the class * of <code>minimum</code>. * * @param minimum Minimum legal value that can be input * @see #setValueClass */ public void setMinimum(Comparable minimum) { if (getValueClass() == null && minimum != null) { setValueClass(minimum.getClass()); } min = minimum; }
protected Boolean compare(Comparable lv, Comparable rv) { Class lc = lv.getClass(); Class rc = rv.getClass(); // If the the objects are not of the same type, // try to convert up to allow the comparison. if (lc != rc) { if (lc == Byte.class) { if (rc == Short.class) { lv = ((Number) lv).shortValue(); } else if (rc == Integer.class) { lv = ((Number) lv).intValue(); } else if (rc == Long.class) { lv = ((Number) lv).longValue(); } else if (rc == Float.class) { lv = ((Number) lv).floatValue(); } else if (rc == Double.class) { lv = ((Number) lv).doubleValue(); } else { return Boolean.FALSE; } } else if (lc == Short.class) { if (rc == Integer.class) { lv = ((Number) lv).intValue(); } else if (rc == Long.class) { lv = ((Number) lv).longValue(); } else if (rc == Float.class) { lv = ((Number) lv).floatValue(); } else if (rc == Double.class) { lv = ((Number) lv).doubleValue(); } else { return Boolean.FALSE; } } else if (lc == Integer.class) { if (rc == Long.class) { lv = ((Number) lv).longValue(); } else if (rc == Float.class) { lv = ((Number) lv).floatValue(); } else if (rc == Double.class) { lv = ((Number) lv).doubleValue(); } else { return Boolean.FALSE; } } else if (lc == Long.class) { if (rc == Integer.class) { rv = ((Number) rv).longValue(); } else if (rc == Float.class) { lv = ((Number) lv).floatValue(); } else if (rc == Double.class) { lv = ((Number) lv).doubleValue(); } else { return Boolean.FALSE; } } else if (lc == Float.class) { if (rc == Integer.class) { rv = ((Number) rv).floatValue(); } else if (rc == Long.class) { rv = ((Number) rv).floatValue(); } else if (rc == Double.class) { lv = ((Number) lv).doubleValue(); } else { return Boolean.FALSE; } } else if (lc == Double.class) { if (rc == Integer.class) { rv = ((Number) rv).doubleValue(); } else if (rc == Long.class) { rv = ((Number) rv).doubleValue(); } else if (rc == Float.class) { rv = ((Number) rv).doubleValue(); } else { return Boolean.FALSE; } } else { return Boolean.FALSE; } } return asBoolean(lv.compareTo(rv)) ? Boolean.TRUE : Boolean.FALSE; }
public void setMaximum(final Comparable max) { this.max = max; if (max != null) { setValueClass(max.getClass()); } }
public static Comparable<?> round(Comparable<?> param1, Comparable<?> param2, Calendar cal) throws ParseException { if (param1 == null || param2 == null) { return null; } if (param1 instanceof String) { param1 = parse((String) param1); } if (param1 instanceof Number) { int scale; try { scale = getInteger(param2); } catch (ParseException e) { throw new ParseException(PARAM_EXCEPTION); } if (scale < 0) { return ZERO; } if (param1 instanceof BigDecimal) { // BigInteger is not supported return ((BigDecimal) param1).setScale(scale, BigDecimal.ROUND_HALF_UP); } if (param1 instanceof Double || param1 instanceof Float) { double d = ((Number) param1).doubleValue(); long mult = 1; for (int i = 0; i < scale; i++) { mult *= 10; } d *= mult; return (Math.round(d)) / mult; } if (param1 instanceof Number) { // Long, Integer, Short, Byte return param1; } throw new ParseException( WRONG_TYPE + " round(" + param1.getClass() + "," + param2.getClass() + ")"); } else if (param1 instanceof java.util.Date) { if (param2 instanceof String) { String s = (String) param2; java.util.Date d = (java.util.Date) param1; cal.setTimeInMillis(d.getTime()); if (s.equalsIgnoreCase("CC") || s.equalsIgnoreCase("SCC")) { if (d instanceof java.sql.Time) { throw new ParseException(Trunc.TIME_EXCEPTION); } int year = cal.get(YEAR); int year1 = (year / 100) * 100; if (year - year1 > 50) { year1 += 100; } cal.clear(); cal.set(year1 + 1, 0, 1); return new Timestamp(cal.getTimeInMillis()); } else if (s.equalsIgnoreCase("SYYYY") || s.equalsIgnoreCase("YYYY") || s.equalsIgnoreCase("YYY") || s.equalsIgnoreCase("Y") || s.equalsIgnoreCase("YEAR") || s.equalsIgnoreCase("SYEAR")) { if (d instanceof java.sql.Time) { throw new ParseException(Trunc.TIME_EXCEPTION); } int year = cal.get(YEAR); int month = cal.get(MONTH); if (month > 6) { year++; } cal.clear(); cal.set(year, 0, 1); return new Timestamp(cal.getTimeInMillis()); } else if (s.equalsIgnoreCase("IYYY") || s.equalsIgnoreCase("IY") || s.equalsIgnoreCase("I")) { throw new ParseException(NOT_IMPLIMENTED_EXCEPTION); } else if (s.equalsIgnoreCase("Q")) { if (d instanceof java.sql.Time) { throw new ParseException(Trunc.TIME_EXCEPTION); } int year = cal.get(YEAR); int month = cal.get(MONTH); int q = (month / 3) * 3; if (month > q + 1) { q++; } else if (month > q) { int day = cal.get(DAY_OF_MONTH); if (day > 15) { q++; } } cal.clear(); cal.set(year, q, 1); return new Timestamp(cal.getTimeInMillis()); } else if (s.equalsIgnoreCase("MONTH") || s.equalsIgnoreCase("MON") || s.equalsIgnoreCase("MM") || s.equalsIgnoreCase("RM")) { if (d instanceof java.sql.Time) { throw new ParseException(Trunc.TIME_EXCEPTION); } int year = cal.get(YEAR); int month = cal.get(MONTH); int day = cal.get(DAY_OF_MONTH); if (day > 15) { month++; } cal.clear(); cal.set(year, month, 1); return new Timestamp(cal.getTimeInMillis()); } else if (s.equalsIgnoreCase("WW")) { if (d instanceof java.sql.Time) { throw new ParseException(Trunc.TIME_EXCEPTION); } int year = cal.get(YEAR); int month = cal.get(MONTH); int day = cal.get(DAY_OF_MONTH); int dw = cal.get(DAY_OF_WEEK); cal.clear(); cal.set(year, 0, 1); int dayOfWeek = cal.get(DAY_OF_WEEK); int delta = (dw < dayOfWeek ? 7 - (dayOfWeek - dw) : dw - dayOfWeek); if (delta > 2) { delta = delta - 7; } cal.set(year, month, day - delta); return new Timestamp(cal.getTimeInMillis()); } else if (s.equalsIgnoreCase("W")) { if (d instanceof java.sql.Time) { throw new ParseException(Trunc.TIME_EXCEPTION); } int year = cal.get(YEAR); int month = cal.get(MONTH); int day = cal.get(DAY_OF_MONTH); int dw = cal.get(DAY_OF_WEEK); cal.clear(); cal.set(year, month, 1); int dayOfWeek = cal.get(DAY_OF_WEEK); int delta = (dw < dayOfWeek ? 7 - (dayOfWeek - dw) : dw - dayOfWeek); if (delta > 2) { delta = delta - 7; } cal.set(year, month, day - delta); return new Timestamp(cal.getTimeInMillis()); } else if (s.equalsIgnoreCase("IW")) { throw new ParseException(NOT_IMPLIMENTED_EXCEPTION); } else if (s.equalsIgnoreCase("DAY") || s.equalsIgnoreCase("DY") || s.equalsIgnoreCase("D")) { if (d instanceof java.sql.Time) { throw new ParseException(Trunc.TIME_EXCEPTION); } int year = cal.get(YEAR); int month = cal.get(MONTH); int day = cal.get(DAY_OF_MONTH); int dw = cal.get(DAY_OF_WEEK); int delta = dw - cal.getFirstDayOfWeek(); if (delta > 2) { delta = delta - 7; } cal.clear(); cal.set(year, month, day - delta); return new Timestamp(cal.getTimeInMillis()); } else if (s.equalsIgnoreCase("HH") || s.equalsIgnoreCase("HH12") || s.equalsIgnoreCase("HH24")) { if (d instanceof java.sql.Date) { throw new ParseException(Trunc.DATE_EXCEPTION); } int minute = cal.get(MINUTE); if (minute >= 30) { cal.get(HOUR_OF_DAY); cal.add(HOUR_OF_DAY, 1); } cal.set(MINUTE, 0); cal.set(SECOND, 0); cal.set(MILLISECOND, 0); return new Timestamp(cal.getTimeInMillis()); } else if (s.equalsIgnoreCase("MI")) { if (d instanceof java.sql.Date) { throw new ParseException(Trunc.DATE_EXCEPTION); } int second = cal.get(SECOND); if (second >= 30) { cal.get(MINUTE); cal.add(MINUTE, 1); } cal.set(SECOND, 0); cal.set(MILLISECOND, 0); return new Timestamp(cal.getTimeInMillis()); } else { throw new ParseException(Trunc.FORMAT_EXCEPTION); } } } throw new ParseException( WRONG_TYPE + " trunc(" + param1.getClass() + "," + param2.getClass() + ")"); }
// lazy load private void internal_lazyLoadChilderenIfNeeded(Object obj) { if (obj instanceof UserNode) { UserNode un = (UserNode) obj; if (!un.isInitialized()) { un.flagInitialized(); // check if we have multiple child relations RelationInfo[] relationInfos = bindingInfo.getNRelationInfos(un); if (relationInfos != null && relationInfos.length > 0) { int id = 0; for (RelationInfo relationInfo : relationInfos) un.add(new RelationNode(id++, relationInfo)); return; } IRecord rec = un.getRecord(); if (rec != null) { IFoundSet nfs; String n_relationName = bindingInfo.getNRelationName(un); String m_relationName = bindingInfo.getMRelationName(un); nfs = rec.getRelatedFoundSet(n_relationName); if (nfs != null && nfs.getSize() > 0) { if (m_relationName == null) { List sortColumns = getSortColumns( (Table) ((IFoundSetInternal) nfs).getTable(), bindingInfo.getChildSortDataprovider(un)); if (sortColumns != null) { try { nfs.sort(sortColumns); } catch (Exception ex) { Debug.error(ex); } } for (int i = 0; i < nfs.getSize(); i++) { nfs.getRecord(i); // to force next record loading createChildNode(un, nfs, i); } } else { ArrayList mfsRecordsSortedIdx = new ArrayList(); ArrayList mfsSorted = new ArrayList(); int sortOrder = SortColumn.ASCENDING; for (int ii = 0; ii < nfs.getSize(); ii++) { IRecord rel = nfs.getRecord(ii); IFoundSet mfs = rel.getRelatedFoundSet(m_relationName); if (mfs != null) { for (int i = 0; i < mfs.getSize(); i++) { IRecord mfsRec = mfs.getRecord(i); // if sorting add mfs value o right position List sortColumns = getSortColumns( (Table) ((IFoundSetInternal) mfs).getTable(), bindingInfo.getChildSortDataprovider(un)); if (sortColumns != null) { SortColumn sortCol = (SortColumn) sortColumns.get(0); String sortDataProvider = sortCol.getDataProviderID(); sortOrder = sortCol.getSortOrder(); if (mfsRec != null) { if (mfsRec.getValue(sortDataProvider) != null && mfsRec.getValue(sortDataProvider) instanceof Comparable) { Comparable sMfsRecValue = (Comparable) mfsRec.getValue(sortDataProvider); Comparable sSortedValue; int n; for (n = 0; n < mfsRecordsSortedIdx.size(); n++) { int nSortedRecIdx = ((Integer) mfsRecordsSortedIdx.get(n)).intValue(); sSortedValue = (Comparable) ((IFoundSet) mfsSorted.get(n)) .getRecord(nSortedRecIdx) .getValue(sortDataProvider); if (sSortedValue == null) continue; if (sMfsRecValue .getClass() .getName() .equals(sSortedValue.getClass().getName()) && sMfsRecValue.compareTo(sSortedValue) < 0) { break; } } mfsRecordsSortedIdx.add(n, new Integer(i)); mfsSorted.add(n, mfs); } else { mfsRecordsSortedIdx.add(0, new Integer(i)); mfsSorted.add(0, mfs); } } } else { mfsRecordsSortedIdx.add(new Integer(i)); mfsSorted.add(mfs); } } } } // should be done better if (sortOrder == SortColumn.ASCENDING) { for (int i = 0; i < mfsRecordsSortedIdx.size(); i++) { createChildNode( (DefaultMutableTreeNode) un, (IFoundSet) mfsSorted.get(i), ((Integer) mfsRecordsSortedIdx.get(i)).intValue()); } } else { for (int i = mfsRecordsSortedIdx.size() - 1; i >= 0; i--) { createChildNode( (DefaultMutableTreeNode) un, (IFoundSet) mfsSorted.get(i), ((Integer) mfsRecordsSortedIdx.get(i)).intValue()); } } } } } } } else if (obj instanceof RelationNode) { RelationNode un = (RelationNode) obj; if (!un.isInitialized()) { un.flagInitialized(); UserNode parentUserNode = (UserNode) un.getParent(); IRecord parentRecord = parentUserNode.getRecord(); IFoundSet nfs = parentRecord.getRelatedFoundSet(((RelationInfo) un.getUserObject()).getNRelationName()); if (nfs != null && nfs.getSize() > 0) { for (int i = 0; i < nfs.getSize(); i++) { createChildNode(un, nfs, i); nfs.getRecord(i); } } } } }