public boolean contains(Object value) { if (intervals.contains(value)) { return true; } for (Interval interval : intervals) { if (interval.contains(value)) { return true; } } return false; }
public TimeExpression apply(MatchResult matched) { TimeExpression te = new TimeExpression( Interval.toInterval( matched.start(group), matched.end(group), Interval.INTERVAL_OPEN_END), null, extractor, 0); te.setIncludeNested(includeNested); return te; }
/** * Add a type to the slice at a given position, possibly changing the endpoints of some descendant * intervals. * * @param type the type to add to the slice * @param position a type already in the slice before which the new type will be placed, <code> * null</code> if the type should be placed at the end of the slice * @param ancestors the new type's ancestors * @return the event for the endpoint changes, though there might be none */ protected EndpointsChangedEvent add(Constant type, Constant position, Set<Constant> ancestors) { EndpointsChangedEvent event = new EndpointsChangedEvent(this, type); order.add(type, position); int typeLambda = lambdas.get(position), positionLambda = typeLambda; Set<Constant> reducedAncestors = new HashSet<Constant>(ancestors); for (Map.Entry<Constant, Interval<Constant>> entry : descendentIntervals.entrySet()) { Interval<Constant> value = entry.getValue(); if (reducedAncestors.remove(entry.getKey())) { if (value.getMin() == position) { ++positionLambda; value.setMin(type); event.addMinChange(entry.getKey()); } if (value.getMax() == position) { ++typeLambda; } } else if (value.getMax() == position) { value.setMax(type); event.addMaxChange(entry.getKey()); } } descendentIntervals.put(type, new Interval<Constant>(order, type, position)); for (Constant ancestor : reducedAncestors) { descendentIntervals.put(ancestor, new Interval<Constant>(order, type, position)); } lambdas.put(type, typeLambda); lambdas.put(position, positionLambda); return event; }
void generateProperties( boolean includeSuperclasses, boolean includeGetClass, boolean includeExtensions) { if (object != null && auxillary == null) { // generate the properties Class c = object.getClass(); try { // handle integers if (object instanceof Long || object instanceof Integer || object instanceof Short || object instanceof Byte) { Method meth = c.getMethod("longValue", new Class[0]); getMethods.add(meth); setMethods.add(null); domMethods.add(null); hideMethods.add(null); desMethods.add(null); nameMethods.add(null); } // handle other kinds of numbers else if (object instanceof Number) { Method meth = c.getMethod("doubleValue", new Class[0]); getMethods.add(meth); setMethods.add(null); domMethods.add(null); hideMethods.add(null); desMethods.add(null); nameMethods.add(null); } // handle Booleans if (object instanceof Boolean) { Method meth = c.getMethod("booleanValue", new Class[0]); getMethods.add(meth); setMethods.add(null); domMethods.add(null); hideMethods.add(null); desMethods.add(null); nameMethods.add(null); } // handle Strings if (object instanceof CharSequence) { Method meth = c.getMethod("toString", new Class[0]); getMethods.add(meth); setMethods.add(null); domMethods.add(null); hideMethods.add(null); desMethods.add(null); nameMethods.add(null); } } catch (Exception e) // just in case of RuntimeExceptions { e.printStackTrace(); } // handle general properties Method[] m = (includeSuperclasses ? c.getMethods() : c.getDeclaredMethods()); for (int x = 0; x < m.length; x++) { try // we handle exceptions here by going to the next method and trying that one. { if (!("get".equals(m[x].getName())) && !("is".equals(m[x].getName())) && // "get()" and "is()" aren't properties (m[x].getName().startsWith("get") || m[x].getName().startsWith("is"))) // corrrect syntax? { int modifier = m[x].getModifiers(); if ((includeGetClass || !m[x].getName().equals("getClass")) && m[x].getParameterTypes().length == 0 && Modifier.isPublic(modifier)) // no arguments, and public, non-abstract? { //// Add all properties... Class returnType = m[x].getReturnType(); if (returnType != Void.TYPE) { getMethods.add(m[x]); setMethods.add(getWriteProperty(m[x], c)); domMethods.add(getDomain(m[x], c, includeExtensions)); hideMethods.add(getHidden(m[x], c, includeExtensions)); desMethods.add(getDescription(m[x], c, includeExtensions)); nameMethods.add(getName(m[x], c, includeExtensions)); // simple check for invalid Interval domains int lastIndex = domMethods.size() - 1; Object domain = getDomain(lastIndex); if (returnType == Float.TYPE || returnType == Double.TYPE) { if (domain != null && domain instanceof Interval) { Interval interval = (Interval) domain; if (!interval.isDouble()) { System.err.println( "WARNING: Property is double or float valued, but the Interval provided for the property's domain is byte/short/integer/long valued: " + getName(lastIndex) + " on Object " + object); // get rid of the domain domMethods.set(lastIndex, null); } } } else if (returnType == Byte.TYPE || returnType == Short.TYPE || returnType == Integer.TYPE || returnType == Long.TYPE) { if (domain != null && domain instanceof Interval) { Interval interval = (Interval) domain; if (interval.isDouble()) { System.err.println( "WARNING: Property is byte/short/integer/long valued, but the Interval provided for the property's domain is double or float valued: " + getName(lastIndex) + " on Object " + object); // get rid of the domain domMethods.set(lastIndex, null); } } } else if (domain != null && domain instanceof Interval) { System.err.println( "WARNING: Property is not a basic number type, but an Interval was provided for the property's domain: " + getName(lastIndex) + " on Object " + object); // get rid of the domain domMethods.set(lastIndex, null); } } } } } catch (Exception e1) { e1.printStackTrace(); // try again though } } } }
/** * Attempt to add a type to the slice, possibly changing the endpoints of some descendant * intervals. * * @param type the type to add to the slice * @param ancestors the new type's ancestors * @return if the addition was successful, the event for the endpoint changes, though there might * be none; if the addition failed, <code>null</code> */ public EndpointsChangedEvent add(Constant type, Set<Constant> ancestors) { Interval<Constant> common = asInterval(); for (Constant ancestor : ancestors) { Interval<Constant> mask = descendentIntervals.get(ancestor); if (mask != null) { common.intersect(mask); } } // empty is okay, as long as we still have location if (order.compare(common.getMin(), common.getMax()) > 0) { return null; } int surroundMin = 0, surroundMax = 0; for (Constant ancestor : ancestors) { Interval<Constant> range = descendentIntervals.get(ancestor); if (range != null) { if (order.compare(range.getMin(), common.getMin()) < 0 && order.compare(range.getMax(), common.getMin()) > 0) { ++surroundMin; } if (order.compare(range.getMin(), common.getMax()) < 0 && order.compare(range.getMax(), common.getMax()) > 0) { ++surroundMax; } } } if (lambdas.get(common.getMin()) == surroundMin) { return add(type, common.getMin(), ancestors); } if (lambdas.get(common.getMax()) == surroundMax) { return add(type, common.getMax(), ancestors); } //// fast slicing: don't check between min and max return null; }