public static boolean isTruthy(Object obj) { return DefaultTypeTransformation.castToBoolean(obj); }
public static boolean booleanUnbox(Object value) { return castToBoolean(value); }
private boolean closureYieldsTrueForNode(Object childNode) { return DefaultTypeTransformation.castToBoolean(FilteredNodeChildren.this.closure.call(new Object[]{childNode})); } }
public static boolean isCase(Object switchValue, Object caseExpression) throws Throwable { if (caseExpression == null) { return switchValue == null; } return DefaultTypeTransformation.castToBoolean(invokeMethodN(caseExpression.getClass(), caseExpression, "isCase", new Object[]{switchValue})); }
protected Object getNextNode(final Iterator iter) { while (iter.hasNext()) { final Object node = iter.next(); if (DefaultTypeTransformation.castToBoolean(FilteredAttributes.this.closure.call(new Object[]{node}))) { return node; } } return null; } };
/** * 'Case' implementation for maps which tests the groovy truth * value obtained using the 'switch' operand as key. * For example: * <pre class="groovyTestCase">switch( 'foo' ) { * case [foo:true, bar:false]: * assert true * break * default: * assert false * }</pre> * * @param caseValue the case value * @param switchValue the switch value * @return the groovy truth value from caseValue corresponding to the switchValue key * @since 1.7.6 */ public static boolean isCase(Map caseValue, Object switchValue) { return DefaultTypeTransformation.castToBoolean(caseValue.get(switchValue)); }
public static boolean isApplicationClass(String className) { for (Closure test : tests) { Object result = test.call(className); if (result != null) { return DefaultTypeTransformation.castToBoolean(result); } } for (String groovyPackage : GROOVY_PACKAGES) { if (className.startsWith(groovyPackage)) { return false; } } return true; }
public GPathResult find(final Closure closure) { if (DefaultTypeTransformation.castToBoolean(closure.call(new Object[]{this}))) { return this; } else { return new NoChildren(this, "", this.namespaceTagHints); } }
public GPathResult find(final Closure closure) { if (DefaultTypeTransformation.castToBoolean(closure.call(new Object[]{this.node}))) { return this; } else { return new NoChildren(this, "", this.namespaceTagHints); } }
/** * This method is used by both sleep() methods to implement sleeping * for the given time even if interrupted * * @param millis the number of milliseconds to sleep * @param closure optional closure called when interrupted * as long as the closure returns false the sleep continues */ private static void sleepImpl(long millis, Closure closure) { long start = System.currentTimeMillis(); long rest = millis; long current; while (rest > 0) { try { Thread.sleep(rest); rest = 0; } catch (InterruptedException e) { if (closure != null) { if (DefaultTypeTransformation.castToBoolean(closure.call(e))) { return; } } current = System.currentTimeMillis(); // compensate for closure's time rest = millis + start - current; } } }
public GPathResult find(final Closure closure) { final Iterator iter = iterator(); while (iter.hasNext()) { final Object node = iter.next(); if (DefaultTypeTransformation.castToBoolean(closure.call(new Object[]{node}))) { return (GPathResult) node; } } return new NoChildren(this, this.name, namespaceTagHints); }
private static boolean notFiltered(File file, Object filter, Object nameFilter, Object excludeFilter, Object excludeNameFilter) { if (filter == null && nameFilter == null && excludeFilter == null && excludeNameFilter == null) return true; if (filter != null && nameFilter != null) throw new IllegalArgumentException("Can't set both 'filter' and 'nameFilter'"); if (excludeFilter != null && excludeNameFilter != null) throw new IllegalArgumentException("Can't set both 'excludeFilter' and 'excludeNameFilter'"); Object filterToUse = null; Object filterParam = null; if (filter != null) { filterToUse = filter; filterParam = file; } else if (nameFilter != null) { filterToUse = nameFilter; filterParam = file.getName(); } Object excludeFilterToUse = null; Object excludeParam = null; if (excludeFilter != null) { excludeFilterToUse = excludeFilter; excludeParam = file; } else if (excludeNameFilter != null) { excludeFilterToUse = excludeNameFilter; excludeParam = file.getName(); } final MetaClass filterMC = filterToUse == null ? null : InvokerHelper.getMetaClass(filterToUse); final MetaClass excludeMC = excludeFilterToUse == null ? null : InvokerHelper.getMetaClass(excludeFilterToUse); boolean included = filterToUse == null || DefaultTypeTransformation.castToBoolean(filterMC.invokeMethod(filterToUse, "isCase", filterParam)); boolean excluded = excludeFilterToUse != null && DefaultTypeTransformation.castToBoolean(excludeMC.invokeMethod(excludeFilterToUse, "isCase", excludeParam)); return included && !excluded; }
/** * Asserts the asBoolean method returns the given flag */ protected void assertAsBoolean(boolean expected, Object value) { boolean answer = DefaultTypeTransformation.castToBoolean(value); assertEquals("value: " + value + " asBoolean()", expected, answer); }
public static Object castToType(Object object, Class type) { if (object == null) return null; if (type == Object.class) return object; final Class aClass = object.getClass(); if (type == aClass) return object; if (type.isAssignableFrom(aClass)) return object; if (ReflectionCache.isArray(type)) return asArray(object, type); if (type.isEnum()) { return ShortTypeHandling.castToEnum(object, type); } else if (Collection.class.isAssignableFrom(type)) { return continueCastOnCollection(object, type); } else if (type == String.class) { return InvokerHelper.toString(object); } else if (type == Character.class) { return ShortTypeHandling.castToChar(object); } else if (type == Boolean.class) { return castToBoolean(object); } else if (type == Class.class) { return ShortTypeHandling.castToClass(object); } else if (type.isPrimitive()) { return castToPrimitive(object, type); } return continueCastOnNumber(object, type); }
protected Object getNextNode(final Iterator iter) { while (iter.hasNext()) { final Object node = iter.next(); if (DefaultTypeTransformation.castToBoolean(FilteredAttributes.this.closure.call(new Object[]{node}))) { return node; } } return null; } };
protected Object getNextNode(final Iterator iter) { while (iter.hasNext()) { final Object node = iter.next(); if (DefaultTypeTransformation.castToBoolean(FilteredAttributes.this.closure.call(new Object[]{node}))) { return node; } } return null; } };
private static Collection findAll(Closure closure, Collection answer, Iterator iter) { while (iter.hasNext()) { Object value = iter.next(); if (DefaultTypeTransformation.castToBoolean(closure.call(value))) { answer.add(value); } } return answer; }
public GPathResult find(final Closure closure) { if (DefaultTypeTransformation.castToBoolean(closure.call(new Object[]{this}))) { return this; } else { return new NoChildren(this, "", this.namespaceTagHints); } }
public Next loopCond(Object cond) { if (DefaultTypeTransformation.castToBoolean(cond)) { // loop return then(body,e,increment); } else { // exit loop return loopEnd.receive(null); } }
public Next jump(Object cond) { if (DefaultTypeTransformation.castToBoolean(cond)) { return k.receive(cond); } else { return then(falseExp, e, k); } }