Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2003-2008 the original author or authors.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.codehaus.groovy.runtime;
 
 import groovy.lang.*;
 
 import java.io.*;
 import java.util.*;
A static helper class to make bytecode generation easier and act as a facade over the Invoker

Author(s):
James Strachan
Version:
$Revision: 16276 $
 
 public class InvokerHelper {
     private   static final Object[] EMPTY_MAIN_ARGS = new Object[]{new String[0]};
 
     public    static final Object[] EMPTY_ARGS = {};
     protected static final Object[] EMPTY_ARGUMENTS = ;
     protected static final Class[]  EMPTY_TYPES = {};
 
     public static final MetaClassRegistry metaRegistry = GroovySystem.getMetaClassRegistry();
 
     public static void removeClass(Class clazz) {
         .removeMetaClass(clazz);
         Introspector.flushFromCaches(clazz);
     }
 
     public static Object invokeMethodSafe(Object objectString methodNameObject arguments) {
         if (object != null) {
             return invokeMethod(objectmethodNamearguments);
         }
         return null;
     }
 
     public static Object invokeStaticMethod(String klassString methodNameObject argumentsthrows ClassNotFoundException {
         Class type = Class.forName(klass);
         return invokeStaticMethod(typemethodNamearguments);
     }
 
 
     public static Object invokeStaticNoArgumentsMethod(Class typeString methodName) {
         return invokeStaticMethod(typemethodName);
     }
 
     public static Object invokeConstructorOf(String klassObject argumentsthrows ClassNotFoundException {
         Class type = Class.forName(klass);
         return invokeConstructorOf(typearguments);
     }
 
     public static Object invokeNoArgumentsConstructorOf(Class type) {
         return invokeConstructorOf(type);
     }
 
     public static Object invokeClosure(Object closureObject arguments) {
         return invokeMethod(closure"doCall"arguments);
     }
 
     public static List asList(Object value) {
         if (value == null) {
             return .;
         }
         if (value instanceof List) {
             return (Listvalue;
         }
         if (value.getClass().isArray()) {
             return Arrays.asList((Object[]) value);
         }
         if (value instanceof Enumeration) {
             List answer = new ArrayList();
             for (Enumeration e = (Enumerationvaluee.hasMoreElements();) {
                 answer.add(e.nextElement());
             }
             return answer;
        }
        // lets assume its a collection of 1
        return Collections.singletonList(value);
    }
    public static String toString(Object arguments) {
        if (arguments instanceof Object[])
            return toArrayString((Object[]) arguments);
        if (arguments instanceof Collection)
            return toListString((Collectionarguments);
        if (arguments instanceof Map)
            return toMapString((Maparguments);
        return format(argumentsfalse);
    }
    public static String inspect(Object self) {
        return format(selftrue);
    }
    public static Object getAttribute(Object objectString attribute) {
        if (object == null) {
            object = NullObject.getNullObject();
        }
        if (object instanceof Class) {
            return .getMetaClass((Classobject).getAttribute(objectattribute);
        } else if (object instanceof GroovyObject) {
            return ((GroovyObjectobject).getMetaClass().getAttribute(objectattribute);
        } else {
            return .getMetaClass(object.getClass()).getAttribute(objectattribute);
        }
    }
    public static void setAttribute(Object objectString attributeObject newValue) {
        if (object == null) {
            object = NullObject.getNullObject();
        }
        if (object instanceof Class) {
            .getMetaClass((Classobject).setAttribute(objectattributenewValue);
        } else if (object instanceof GroovyObject) {
            ((GroovyObjectobject).getMetaClass().setAttribute(objectattributenewValue);
        } else {
            .getMetaClass(object.getClass()).setAttribute(objectattributenewValue);
        }
    }
    public static Object getProperty(Object objectString property) {
        if (object == null) {
            object = NullObject.getNullObject();
        }
        
        if (object instanceof GroovyObject) {
            GroovyObject pogo = (GroovyObjectobject;
            return pogo.getProperty(property);
        } else if (object instanceof Class) {
            Class c = (Classobject;
            return .getMetaClass(c).getProperty(objectproperty);
        } else {
            return ((MetaClassRegistryImpl)).getMetaClass(object).getProperty(objectproperty);
        }
    }
    public static Object getPropertySafe(Object objectString property) {
        if (object != null) {
            return getProperty(objectproperty);
        }
        return null;
    }
    public static void setProperty(Object objectString propertyObject newValue) {
        if (object == null) {
            object = NullObject.getNullObject();
        }
        if (object instanceof GroovyObject) {
            GroovyObject pogo = (GroovyObjectobject;
            pogo.setProperty(propertynewValue);
        } else if (object instanceof Class) {
            .getMetaClass((Classobject).setProperty((ClassobjectpropertynewValue);
        } else {
            ((MetaClassRegistryImpl) GroovySystem.getMetaClassRegistry()).getMetaClass(object).setProperty(objectpropertynewValue);
        }
    }

    
This is so we don't have to reorder the stack when we call this method. At some point a better name might be in order.
    public static void setProperty2(Object newValueObject objectString property) {
        setProperty(objectpropertynewValue);
    }


    
This is so we don't have to reorder the stack when we call this method. At some point a better name might be in order.
    public static void setGroovyObjectProperty(Object newValueGroovyObject objectString property) {
        object.setProperty(propertynewValue);
    }
    public static Object getGroovyObjectProperty(GroovyObject objectString property) {
        return object.getProperty(property);
    }


    
This is so we don't have to reorder the stack when we call this method. At some point a better name might be in order.
    public static void setPropertySafe2(Object newValueObject objectString property) {
        if (object != null) {
            setProperty2(newValueobjectproperty);
        }
    }

    
Returns the method pointer for the given object name
    public static Closure getMethodPointer(Object objectString methodName) {
        if (object == null) {
            throw new NullPointerException("Cannot access method pointer for '" + methodName + "' on null object");
        }
        return new MethodClosure(objectmethodName);
    }
    public static Object unaryMinus(Object value) {
        if (value instanceof Integer) {
            Integer number = (Integervalue;
            return Integer.valueOf(-number.intValue());
        }
        if (value instanceof Long) {
            Long number = (Longvalue;
            return new Long(-number.longValue());
        }
        if (value instanceof BigInteger) {
            return ((BigIntegervalue).negate();
        }
        if (value instanceof BigDecimal) {
            return ((BigDecimalvalue).negate();
        }
        if (value instanceof Double) {
            Double number = (Doublevalue;
            return new Double(-number.doubleValue());
        }
        if (value instanceof Float) {
            Float number = (Floatvalue;
            return new Float(-number.floatValue());
        }
        if (value instanceof ArrayList) {
            // value is an list.
            List newlist = new ArrayList();
            Iterator it = ((ArrayListvalue).iterator();
            for (; it.hasNext();) {
                newlist.add(unaryMinus(it.next()));
            }
            return newlist;
        }
        return invokeMethod(value"negative");
    }
    public static Object unaryPlus(Object value) {
        if (value instanceof Integer ||
                value instanceof Long ||
                value instanceof BigInteger ||
                value instanceof BigDecimal ||
                value instanceof Double ||
                value instanceof Float) {
            return value;
        }
        if (value instanceof ArrayList) {
            // value is an list.
            List newlist = new ArrayList();
            Iterator it = ((ArrayListvalue).iterator();
            for (; it.hasNext();) {
                newlist.add(unaryPlus(it.next()));
            }
            return newlist;
        }
        return invokeMethod(value"positive");
    }

    
Find the right hand regex within the left hand string and return a matcher.

Parameters:
left string to compare
right regular expression to compare the string to
    public static Matcher findRegex(Object leftObject right) {
        String stringToCompare;
        if (left instanceof String) {
            stringToCompare = (Stringleft;
        } else {
            stringToCompare = toString(left);
        }
        String regexToCompareTo;
        if (right instanceof String) {
            regexToCompareTo = (Stringright;
        } else if (right instanceof Pattern) {
            Pattern pattern = (Patternright;
            return pattern.matcher(stringToCompare);
        } else {
            regexToCompareTo = toString(right);
        }
        Matcher matcher = Pattern.compile(regexToCompareTo).matcher(stringToCompare);
        return matcher;
    }


    
Find the right hand regex within the left hand string and return a matcher.

Parameters:
left string to compare
right regular expression to compare the string to
    public static boolean matchRegex(Object leftObject right) {
        Pattern pattern;
        if (right instanceof Pattern) {
            pattern = (Patternright;
        } else {
            pattern = Pattern.compile(toString(right));
        }
        String stringToCompare = toString(left);
        Matcher matcher = pattern.matcher(stringToCompare);
        RegexSupport.setLastMatcher(matcher);
        return matcher.matches();
    }
    public static Tuple createTuple(Object[] array) {
        return new Tuple(array);
    }
    public static SpreadMap spreadMap(Object value) {
        if (value instanceof Map) {
            Object[] values = new Object[((Mapvalue).keySet().size() * 2];
            int index = 0;
            Iterator it = ((Mapvalue).keySet().iterator();
            for (; it.hasNext();) {
                Object key = it.next();
                values[index++] = key;
                values[index++] = ((Mapvalue).get(key);
            }
            return new SpreadMap(values);
        }
        throw new SpreadMapEvaluatingException("Cannot spread the map " + value.getClass().getName() + ", value " + value);
    }
    public static List createList(Object[] values) {
        List answer = new ArrayList(values.length);
        answer.addAll(Arrays.asList(values));
        return answer;
    }
    public static Map createMap(Object[] values) {
        Map answer = new LinkedHashMap(values.length / 2);
        int i = 0;
        while (i < values.length - 1) {
            if ((values[iinstanceof SpreadMap) && (values[i + 1] instanceof Map)) {
                Map smap = (Mapvalues[i + 1];
                Iterator iter = smap.keySet().iterator();
                for (; iter.hasNext();) {
                    Object key = iter.next();
                    answer.put(keysmap.get(key));
                }
                i += 2;
            } else {
                answer.put(values[i++], values[i++]);
            }
        }
        return answer;
    }
    public static void assertFailed(Object expressionObject message) {
        if (message == null || "".equals(message)) {
            throw new AssertionError("Expression: " + expression);
        }
        throw new AssertionError(String.valueOf(message) + ". Expression: " + expression);
    }
    public static Object runScript(Class scriptClassString[] args) {
        Binding context = new Binding(args);
        Script script = createScript(scriptClasscontext);
        return invokeMethod(script"run");
    }
    public static Script createScript(Class scriptClassBinding context) {
        Script script = null;
        // for empty scripts
        if (scriptClass == null) {
            script = new Script() {
                public Object run() {
                    return null;
                }
            };
        } else {
            try {
                final GroovyObject object = (GroovyObjectscriptClass
                        .newInstance();
                if (object instanceof Script) {
                    script = (Scriptobject;
                } else {
                    // it could just be a class, so lets wrap it in a Script
                    // wrapper
                    // though the bindings will be ignored
                    script = new Script() {
                        public Object run() {
                        	Object args = getBinding().getVariables().get("args");
                        	Object argsToPass = ;
                        	if(args != null && args instanceof String[]) {
                        		argsToPass = args;
                        	}
                            object.invokeMethod("main"argsToPass);
                            return null;
                        }
                    };
                    setProperties(objectcontext.getVariables());
                }
            } catch (Exception e) {
                throw new GroovyRuntimeException(
                        "Failed to create Script instance for class: "
                                + scriptClass + ". Reason: " + ee);
            }
        }
        script.setBinding(context);
        return script;
    }

    
Sets the properties on the given object
    public static void setProperties(Object objectMap map) {
        MetaClass mc = getMetaClass(object);
        for (Iterator iter = map.entrySet().iterator(); iter.hasNext();) {
            Map.Entry entry = (Map.Entryiter.next();
            String key = entry.getKey().toString();
            Object value = entry.getValue();
            try {
                mc.setProperty(objectkeyvalue);
            } catch (MissingPropertyException mpe) {
                // Ignore
            }
        }
    }
    public static String getVersion() {
        String version = null;
        Package p = Package.getPackage("groovy.lang");
        if (p != null) {
            version = p.getImplementationVersion();
        }
        if (version == null) {
            version = "";
        }
        return version;
    }

    
Writes the given object to the given stream
    public static void write(Writer outObject objectthrows IOException {
        if (object instanceof String) {
            out.write((Stringobject);
        } else if (object instanceof Object[]) {
            out.write(toArrayString((Object[]) object));
        } else if (object instanceof Map) {
            out.write(toMapString((Mapobject));
        } else if (object instanceof Collection) {
            out.write(toListString((Collectionobject));
        } else if (object instanceof Writable) {
            Writable writable = (Writableobject;
            writable.writeTo(out);
        } else if (object instanceof InputStream || object instanceof Reader) {
            // Copy stream to stream
            Reader reader;
            if (object instanceof InputStream) {
                reader = new InputStreamReader((InputStreamobject);
            } else {
                reader = (Readerobject;
            }
            char[] chars = new char[8192];
            int i;
            while ((i = reader.read(chars)) != -1) {
                out.write(chars, 0, i);
            }
            reader.close();
        } else {
            out.write(toString(object));
        }
    }
    public static Iterator asIterator(Object o) {
        return (IteratorinvokeMethod(o"iterator");
    }
    protected static String format(Object argumentsboolean verbose) {
        if (arguments == null) {
            final NullObject nullObject = NullObject.getNullObject();
            return (StringnullObject.getMetaClass().invokeMethod(nullObject"toString");
        }
        if (arguments.getClass().isArray()) {
            if (arguments instanceof char[]) {
                return new String((char[]) arguments);
            }
            return format(DefaultTypeTransformation.asCollection(arguments), verbose);
        }
        if (arguments instanceof Range) {
            Range range = (Rangearguments;
            if (verbose) {
                return range.inspect();
            } else {
                return range.toString();
            }
        }
        if (arguments instanceof Collection) {
            return formatList((Collectionargumentsverbose);
        }
        if (arguments instanceof Map) {
            return formatMap((Mapargumentsverbose);
        }
        if (arguments instanceof Element) {
            return XmlUtil.serialize((Elementarguments);
        }
        if (arguments instanceof String) {
            if (verbose) {
                String arg = ((Stringarguments).replaceAll("\\n""\\\\n");    // line feed
                arg = arg.replaceAll("\\r""\\\\r");      // carriage return
                arg = arg.replaceAll("\\t""\\\\t");      // tab
                arg = arg.replaceAll("\\f""\\\\f");      // form feed
                arg = arg.replaceAll("\\\"""\\\\\"");    // double quotation mark
                arg = arg.replaceAll("\\\\""\\\\");      // backslash
                return "\"" + arg + "\"";
            } else {
                return (Stringarguments;
            }
        }
        // TODO: For GROOVY-2599 do we need something like below but it breaks other things
//        return (String) invokeMethod(arguments, "toString", EMPTY_ARGS);
        return arguments.toString();
    }
    private static String formatMap(Map mapboolean verbose) {
        if (map.isEmpty()) {
            return "[:]";
        }
        StringBuffer buffer = new StringBuffer("[");
        boolean first = true;
        for (Iterator iter = map.entrySet().iterator(); iter.hasNext();) {
            if (first) {
                first = false;
            } else {
                buffer.append(", ");
            }
            Map.Entry entry = (Map.Entryiter.next();
            buffer.append(format(entry.getKey(), verbose));
            buffer.append(":");
            if (entry.getValue() == map) {
                buffer.append("this Map_");
            } else {
                buffer.append(format(entry.getValue(), verbose));
            }
        }
        buffer.append("]");
        return buffer.toString();
    }
    private static String formatList(Collection listboolean verbose) {
        StringBuffer buffer = new StringBuffer("[");
        boolean first = true;
        for (Iterator iter = list.iterator(); iter.hasNext();) {
            if (first) {
                first = false;
            } else {
                buffer.append(", ");
            }
            buffer.append(format(iter.next(), verbose));
        }
        buffer.append("]");
        return buffer.toString();
    }

    
A helper method to format the arguments types as a comma-separated list.

Parameters:
arguments the type to process
Returns:
the string representation of the type
    public static String toTypeString(Object[] arguments) {
        if (arguments == null) {
            return "null";
        }
        StringBuffer argBuf = new StringBuffer();
        for (int i = 0; i < arguments.lengthi++) {
            if (i > 0) {
                argBuf.append(", ");
            }
            argBuf.append(arguments[i] != null ? arguments[i].getClass().getName() : "null");
        }
        return argBuf.toString();
    }

    
A helper method to return the string representation of a map with bracket boundaries "[" and "]".

Parameters:
arg the map to process
Returns:
the string representation of the map
    public static String toMapString(Map arg) {
        return formatMap(argfalse);
    }

    
A helper method to return the string representation of a list with bracket boundaries "[" and "]".

Parameters:
arg the collection to process
Returns:
the string representation of the collection
    public static String toListString(Collection arg) {
        return formatList(argfalse);
    }

    
A helper method to return the string representation of an array of objects with brace boundaries "{" and "}".

Parameters:
arguments the array to process
Returns:
the string representation of the array
    public static String toArrayString(Object[] arguments) {
        if (arguments == null) {
            return "null";
        }
        String sbdry = "[";
        String ebdry = "]";
        StringBuffer argBuf = new StringBuffer(sbdry);
        for (int i = 0; i < arguments.lengthi++) {
            if (i > 0) {
                argBuf.append(", ");
            }
            argBuf.append(format(arguments[i], false));
        }
        argBuf.append(ebdry);
        return argBuf.toString();
    }
    public static List createRange(Object fromObject toboolean inclusive) {
        try {
            return ScriptBytecodeAdapter.createRange(fromtoinclusive);
        } catch (RuntimeException re) {
            throw re;
        } catch (Error e) {
            throw e;
        } catch (Throwable t) {
            throw new RuntimeException(t);
        }
    }
    public static Object bitwiseNegate(Object value) {
        if (value instanceof Integer) {
            Integer number = (Integervalue;
            return Integer.valueOf(~number.intValue());
        }
        if (value instanceof Long) {
            Long number = (Longvalue;
            return new Long(~number.longValue());
        }
        if (value instanceof BigInteger) {
            return ((BigIntegervalue).not();
        }
        if (value instanceof String) {
            // value is a regular expression.
            return DefaultGroovyMethods.bitwiseNegate(value.toString());
        }
        if (value instanceof GString) {
            // value is a regular expression.
            return DefaultGroovyMethods.bitwiseNegate(value.toString());
        }
        if (value instanceof ArrayList) {
            // value is an list.
            List newlist = new ArrayList();
            Iterator it = ((ArrayListvalue).iterator();
            for (; it.hasNext();) {
                newlist.add(bitwiseNegate(it.next()));
            }
            return newlist;
        }
        return invokeMethod(value"bitwiseNegate");
    }
    public static MetaClassRegistry getMetaRegistry() {
        return ;
    }
    public static MetaClass getMetaClass(Object object) {
        if (object instanceof GroovyObject)
            return ((GroovyObjectobject).getMetaClass();
        else
            return ((MetaClassRegistryImpl) GroovySystem.getMetaClassRegistry()).getMetaClass(object);
    }
    public static MetaClass getMetaClass(Class cls) {
        return .getMetaClass(cls);
    }

    
Invokes the given method on the object.
    public static Object invokeMethod(Object objectString methodNameObject arguments) {
        if (object == null) {
            object = NullObject.getNullObject();
            //throw new NullPointerException("Cannot invoke method " + methodName + "() on null object");
        }
        // if the object is a Class, call a static method from that class
        if (object instanceof Class) {
            Class theClass = (Classobject;
            MetaClass metaClass = .getMetaClass(theClass);
            return metaClass.invokeStaticMethod(objectmethodNameasArray(arguments));
        }
        // it's an instance; check if it's a Java one
        if (!(object instanceof GroovyObject)) {
            return invokePojoMethod(objectmethodNamearguments);
        }
        // a groovy instance (including builder, closure, ...)
        return invokePogoMethod(objectmethodNamearguments);
    }
    static Object invokePojoMethod(Object objectString methodNameObject arguments) {
        MetaClass metaClass = InvokerHelper.getMetaClass(object);
        return metaClass.invokeMethod(objectmethodNameasArray(arguments));
    }
    static Object invokePogoMethod(Object objectString methodNameObject arguments) {
        GroovyObject groovy = (GroovyObjectobject;
        boolean intercepting = groovy instanceof GroovyInterceptable;
        try {
            // if it's a pure interceptable object (even intercepting toString(), clone(), ...)
            if (intercepting) {
                return groovy.invokeMethod(methodNameasUnwrappedArray(arguments));
            }
            //else try a statically typed method or a GDK method
            return groovy.getMetaClass().invokeMethod(objectmethodNameasArray(arguments));
        } catch (MissingMethodException e) {
            if (e instanceof MissingMethodExecutionFailed) {
                throw (MissingMethodExceptione.getCause();
            } else if (!intercepting && e.getMethod().equals(methodName) && object.getClass() == e.getType()) {
                // in case there's nothing else, invoke the object's own invokeMethod()
                return groovy.invokeMethod(methodNameasUnwrappedArray(arguments));
            } else {
                throw e;
            }
        }
    }
    public static Object invokeSuperMethod(Object objectString methodNameObject arguments) {
        if (object == null) {
            throw new NullPointerException("Cannot invoke method " + methodName + "() on null object");
        }
        Class theClass = object.getClass();
        MetaClass metaClass = .getMetaClass(theClass.getSuperclass());
        return metaClass.invokeMethod(objectmethodNameasArray(arguments));
    }
    public static Object invokeStaticMethod(Class typeString methodObject arguments) {
        MetaClass metaClass = .getMetaClass(type);
        return metaClass.invokeStaticMethod(typemethodasArray(arguments));
    }
    public static Object invokeConstructorOf(Class typeObject arguments) {
        MetaClass metaClass = .getMetaClass(type);
        return metaClass.invokeConstructor(asArray(arguments));
    }

    
Converts the given object into an array; if its an array then just cast otherwise wrap it in an array
    public static Object[] asArray(Object arguments) {
    	if (arguments == null) {
    		return ;
    	}
    	if (arguments instanceof Object[]) {
    		return  (Object[]) arguments;
    	}
    	return new Object[]{arguments};
    }
    public static Object[] asUnwrappedArray(Object arguments) {
        Object[] args = asArray(arguments);
        for (int i=0; i<args.lengthi++) {
            if (args[iinstanceof PojoWrapper) {
                args[i] = ((PojoWrapper)args[i]).unwrap();
            }
        }
        return args;
    }
New to GrepCode? Check out our FAQ X