incubator-flex-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From cframp...@apache.org
Subject svn commit: r1343781 [14/17] - in /incubator/flex/trunk/modules: ./ thirdparty/velocity/ thirdparty/velocity/build/ thirdparty/velocity/build/lib/ thirdparty/velocity/build/xsl/ thirdparty/velocity/src/java/org/apache/velocity/anakia/ thirdparty/veloci...
Date Tue, 29 May 2012 15:35:15 GMT
Added: incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/ArrayIterator.java
URL: http://svn.apache.org/viewvc/incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/ArrayIterator.java?rev=1343781&view=auto
==============================================================================
--- incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/ArrayIterator.java (added)
+++ incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/ArrayIterator.java Tue May 29 15:35:01 2012
@@ -0,0 +1,114 @@
+package org.apache.velocity.util;
+
+/*
+ * Copyright 1999-2001,2004 The Apache Software Foundation.
+ * 
+ * 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.
+ */
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.lang.reflect.Array;
+
+
+/**
+ *  <p>
+ *  An Iterator wrapper for an Object[]. This will
+ *  allow us to deal with all array like structures
+ *  in a consistent manner.
+ *  </p>
+ *  <p>
+ *  WARNING : this class's operations are NOT synchronized.
+ *  It is meant to be used in a single thread, newly created
+ *  for each use in the #foreach() directive.
+ *  If this is used or shared, synchronize in the
+ *  next() method.
+ *  </p>
+ *
+ * @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
+ * @author <a href="mailto:geirm@apache.org">Geir Magnusson Jr.</a>
+ * @version $Id: ArrayIterator.java,v 1.6.8.1 2004/03/03 23:23:07 geirm Exp $
+ */
+public class ArrayIterator implements Iterator
+{
+    /**
+     * The objects to iterate.
+     */
+    private Object array;
+
+    /**
+     * The current position and size in the array.
+     */
+    private int pos;
+    private int size;
+
+    /**
+     * Creates a new iterator instance for the specified array.
+     *
+     * @param array The array for which an iterator is desired.
+     */
+    public ArrayIterator(Object array)
+    {
+        /*
+         * if this isn't an array, then throw.  Note that this is 
+         * for internal use - so this should never happen - if it does
+         *  we screwed up.
+         */
+         
+        if ( !array.getClass().isArray() )
+        {   
+            throw new IllegalArgumentException( 
+                "Programmer error : internal ArrayIterator invoked w/o array");
+        }
+            
+        this.array = array;
+        pos = 0;
+        size = Array.getLength( this.array );
+    }
+
+    /**
+     * Move to next element in the array.
+     *
+     * @return The next object in the array.
+     */
+    public Object next()
+    {
+        if (pos < size )
+            return Array.get( array, pos++);
+                
+        /*
+         *  we screwed up...
+         */
+         
+        throw new NoSuchElementException("No more elements: " + pos +
+                                         " / " + size);
+    }
+    
+    /**
+     * Check to see if there is another element in the array.
+     *
+     * @return Whether there is another element.
+     */
+    public boolean hasNext()
+    {
+        return (pos < size );
+    }
+
+    /**
+     * No op--merely added to satify the <code>Iterator</code> interface.
+     */
+    public void remove()
+    {
+        throw new UnsupportedOperationException();
+    }
+}

Propchange: incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/ArrayIterator.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/EnumerationIterator.java
URL: http://svn.apache.org/viewvc/incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/EnumerationIterator.java?rev=1343781&view=auto
==============================================================================
--- incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/EnumerationIterator.java (added)
+++ incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/EnumerationIterator.java Tue May 29 15:35:01 2012
@@ -0,0 +1,74 @@
+package org.apache.velocity.util;
+
+/*
+ * Copyright 1999-2001,2004 The Apache Software Foundation.
+ * 
+ * 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.
+ */
+
+import java.util.Iterator;
+import java.util.Enumeration;
+
+/**
+ * An Iterator wrapper for an Enumeration.
+ *
+ * @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
+ * @version $Id: EnumerationIterator.java,v 1.1.14.1 2004/03/03 23:23:07 geirm Exp $
+ */
+public class EnumerationIterator implements Iterator
+{
+    /**
+     * The enumeration to iterate.
+     */
+    private Enumeration enum = null;
+
+    /**
+     * Creates a new iteratorwrapper instance for the specified 
+     * Enumeration.
+     *
+     * @param enum  The Enumeration to wrap.
+     */
+    public EnumerationIterator( Enumeration enum)
+    {
+        this.enum = enum;
+    }
+
+    /**
+     * Move to next element in the array.
+     *
+     * @return The next object in the array.
+     */
+    public Object next()
+    {
+        return enum.nextElement();
+    }
+    
+    /**
+     * Check to see if there is another element in the array.
+     *
+     * @return Whether there is another element.
+     */
+    public boolean hasNext()
+    {
+        return enum.hasMoreElements();
+    }
+
+    /**
+     *  Unimplemented.  No analogy in Enumeration
+     */
+    public void remove()
+    {
+        // not implemented
+    }
+   
+}

Propchange: incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/EnumerationIterator.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/SimplePool.java
URL: http://svn.apache.org/viewvc/incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/SimplePool.java?rev=1343781&view=auto
==============================================================================
--- incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/SimplePool.java (added)
+++ incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/SimplePool.java Tue May 29 15:35:01 2012
@@ -0,0 +1,126 @@
+package org.apache.velocity.util;
+
+/*
+ * Copyright 1999-2001,2004 The Apache Software Foundation.
+ * 
+ * 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.
+ */
+
+/**
+ * Simple object pool. Based on ThreadPool and few other classes
+ *
+ * The pool will ignore overflow and return null if empty.
+ *
+ * @author Gal Shachor
+ * @author Costin
+ * @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
+ * @version $Id: SimplePool.java,v 1.2.14.1 2004/03/03 23:23:07 geirm Exp $
+ */
+public final class SimplePool  
+{
+    /*
+     * Where the objects are held.
+     */
+    private Object pool[];
+
+    /**
+     *  max amount of objects to be managed
+     *  set via CTOR
+     */
+    private int max;    
+    
+    /**
+     *  index of previous to next
+     *  free slot
+     */
+    private int current=-1;
+       
+    public SimplePool(int max) 
+    {
+        this.max = max;
+        pool = new Object[max];
+    } 
+
+    /**
+     * Add the object to the pool, silent nothing if the pool is full
+     */
+    public void put(Object o) 
+    {
+        int idx=-1;
+     
+        synchronized( this ) 
+        {
+            /*
+             *  if we aren't full
+             */
+
+            if( current < max - 1 )
+            {
+                /*
+                 *  then increment the 
+                 *  current index.
+                 */
+                idx = ++current;
+            }
+
+            if( idx >= 0 ) 
+            {
+                pool[idx] = o;
+            }
+        }
+    }
+
+    /**
+     * Get an object from the pool, null if the pool is empty.
+     */
+    public  Object get() 
+    {
+        int idx = -1;
+        
+        synchronized( this ) 
+        {
+            /*
+             *  if we have any in the pool
+             */
+            if( current >= 0 )
+            {
+                /*
+                 *  take one out, so to speak -
+                 *  separate the two operations
+                 *  to make it clear that you
+                 *  don't want idx = --current; :)
+                 */
+
+                idx = current;
+                current--;
+               
+                /*
+                 *  and since current was >= 0
+                 *  to get in here, idx must be as well
+                 *  so save the if() opration
+                 */
+
+                return pool[idx];
+            }
+        }
+        
+        return null;
+    }
+
+    /** Return the size of the pool
+     */
+    public int getMax() 
+    {
+        return max;
+    }
+}

Propchange: incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/SimplePool.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/StringUtils.java
URL: http://svn.apache.org/viewvc/incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/StringUtils.java?rev=1343781&view=auto
==============================================================================
--- incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/StringUtils.java (added)
+++ incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/StringUtils.java Tue May 29 15:35:01 2012
@@ -0,0 +1,596 @@
+package org.apache.velocity.util;
+
+/*
+ * Copyright 2001,2004 The Apache Software Foundation.
+ * 
+ * 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.
+ */
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.ByteArrayOutputStream;
+import java.io.PrintWriter;
+
+import java.net.MalformedURLException;
+
+import java.util.ArrayList;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.StringTokenizer;
+import java.util.Map;
+
+
+/**
+ * This class provides some methods for dynamically
+ * invoking methods in objects, and some string
+ * manipulation methods used by torque. The string
+ * methods will soon be moved into the turbine
+ * string utilities class.
+ *
+ *  @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
+ *  @author <a href="mailto:dlr@finemaltcoding.com">Daniel Rall</a>
+ *  @version $Id: StringUtils.java,v 1.16.8.1 2004/03/03 23:23:07 geirm Exp $
+ */
+public class StringUtils
+{
+    /**
+     * Line separator for the OS we are operating on.
+     */
+    private static final String EOL = System.getProperty("line.separator");
+    
+    /**
+     * Length of the line separator.
+     */
+    private static final int EOL_LENGTH = EOL.length();
+
+    /**
+     * Concatenates a list of objects as a String.
+     *
+     * @param list The list of objects to concatenate.
+     * @return     A text representation of the concatenated objects.
+     */
+    public String concat(List list)
+    {
+        StringBuffer sb = new StringBuffer();
+        int size = list.size();
+
+        for (int i = 0; i < size; i++)
+        {
+            sb.append(list.get(i).toString());
+        }
+        return sb.toString();
+    }
+
+    /**
+     * Return a package name as a relative path name
+     *
+     * @param String package name to convert to a directory.
+     * @return String directory path.
+     */
+    static public String getPackageAsPath(String pckge)
+    {
+        return pckge.replace( '.', File.separator.charAt(0) ) + File.separator;
+    }
+
+    /**
+     * <p>
+     * Remove underscores from a string and replaces first
+     * letters with capitals.  Other letters are changed to lower case. 
+     * </p>
+     *
+     * <p> 
+     * For example <code>foo_bar</code> becomes <code>FooBar</code>
+     * but <code>foo_barBar</code> becomes <code>FooBarbar</code>.
+     * </p>
+     *
+     * @param data string to remove underscores from.
+     * @return String 
+     * @deprecated Use the org.apache.commons.util.StringUtils class
+     * instead.  Using its firstLetterCaps() method in conjunction
+     * with a StringTokenizer will achieve the same result.
+     */
+    static public String removeUnderScores (String data)
+    {
+        String temp = null;
+        StringBuffer out = new StringBuffer();
+        temp = data;
+
+        StringTokenizer st = new StringTokenizer(temp, "_");
+       
+        while (st.hasMoreTokens())
+        {
+            String element = (String) st.nextElement();
+            out.append ( firstLetterCaps(element));
+        }
+
+        return out.toString();
+    }
+
+    /**
+     * <p> 
+     *  'Camels Hump' replacement of underscores.
+     * </p>
+     *
+     * <p> 
+     * Remove underscores from a string but leave the capitalization of the
+     * other letters unchanged.
+     * </p>
+     *
+     * <p> 
+     * For example <code>foo_barBar</code> becomes <code>FooBarBar</code>.
+     * </p>
+     *
+     * @param data string to hump
+     * @return String 
+     */
+    static public String removeAndHump (String data)
+    {
+        return removeAndHump(data,"_");
+    }
+
+    /**
+     * <p>
+     * 'Camels Hump' replacement.
+     * </p>
+     *
+     * <p> 
+     * Remove one string from another string but leave the capitalization of the
+     * other letters unchanged.
+     * </p>
+     *
+     * <p>
+     * For example, removing "_" from <code>foo_barBar</code> becomes <code>FooBarBar</code>.
+     * </p>
+     *
+     * @param data string to hump
+     * @param replaceThis string to be replaced
+     * @return String 
+     */
+    static public String removeAndHump (String data,String replaceThis)
+    {
+        String temp = null;
+        StringBuffer out = new StringBuffer();
+        temp = data;
+
+        StringTokenizer st = new StringTokenizer(temp, replaceThis);
+       
+        while (st.hasMoreTokens())
+        {
+            String element = (String) st.nextElement();
+            out.append ( capitalizeFirstLetter(element));
+        }//while
+        
+        return out.toString();
+    }
+
+    /**
+     * <p> 
+     *  Makes the first letter caps and the rest lowercase.
+     * </p>
+     *
+     * <p> 
+     *  For example <code>fooBar</code> becomes <code>Foobar</code>.
+     * </p>
+     *
+     * @param data capitalize this
+     * @return String
+     */
+    static public String firstLetterCaps ( String data )
+    {
+        String firstLetter = data.substring(0,1).toUpperCase();
+        String restLetters = data.substring(1).toLowerCase();
+        return firstLetter + restLetters;
+    }
+
+    /**
+     * <p> 
+     * Capitalize the first letter but leave the rest as they are. 
+     * </p>
+     *
+     * <p> 
+     *  For example <code>fooBar</code> becomes <code>FooBar</code>.
+     * </p>
+     *
+     * @param data capitalize this
+     * @return String
+     */
+    static public String capitalizeFirstLetter ( String data )
+    {
+        String firstLetter = data.substring(0,1).toUpperCase();
+        String restLetters = data.substring(1);
+        return firstLetter + restLetters;
+    }
+
+    /**
+     * Create a string array from a string separated by delim
+     *
+     * @param line the line to split
+     * @param delim the delimter to split by
+     * @return a string array of the split fields
+     */
+    public static String [] split(String line, String delim)
+    {
+        List list = new ArrayList();
+        StringTokenizer t = new StringTokenizer(line, delim);
+        while (t.hasMoreTokens())
+        {
+            list.add(t.nextToken());
+        }
+        return (String []) list.toArray(new String[list.size()]);
+    }
+
+    /**
+     * Chop i characters off the end of a string.
+     * This method assumes that any EOL characters in String s 
+     * and the platform EOL will be the same.
+     * A 2 character EOL will count as 1 character. 
+     *
+     * @param string String to chop.
+     * @param i Number of characters to chop.
+     * @return String with processed answer.
+     */
+    public static String chop(String s, int i)
+    {
+        return chop(s, i, EOL);
+    }
+
+    /**
+     * Chop i characters off the end of a string. 
+     * A 2 character EOL will count as 1 character. 
+     *
+     * @param string String to chop.
+     * @param i Number of characters to chop.
+     * @param eol A String representing the EOL (end of line).
+     * @return String with processed answer.
+     */
+    public static String chop(String s, int i, String eol)
+    {
+        if ( i == 0 || s == null || eol == null )
+        {
+           return s;
+        }
+
+        int length = s.length();
+
+        /*
+         * if it is a 2 char EOL and the string ends with
+         * it, nip it off.  The EOL in this case is treated like 1 character
+         */
+        if ( eol.length() == 2 && s.endsWith(eol ))
+        {
+            length -= 2;
+            i -= 1;
+        }
+
+        if ( i > 0)
+        {
+            length -= i;
+        }
+
+        if ( length < 0)
+        {
+            length = 0;
+        }
+
+        return s.substring( 0, length);
+    }
+
+    public static StringBuffer stringSubstitution( String argStr,
+                                                   Hashtable vars )
+    {
+        return stringSubstitution( argStr, (Map) vars );
+    }
+
+    /**
+     * Perform a series of substitutions. The substitions
+     * are performed by replacing $variable in the target
+     * string with the value of provided by the key "variable"
+     * in the provided hashtable.
+     *
+     * @param String target string
+     * @param Hashtable name/value pairs used for substitution
+     * @return String target string with replacements.
+     */
+    public static StringBuffer stringSubstitution(String argStr,
+            Map vars)
+    {
+        StringBuffer argBuf = new StringBuffer();
+
+        for (int cIdx = 0 ; cIdx < argStr.length();)
+        {
+            char ch = argStr.charAt(cIdx);
+
+            switch (ch)
+            {
+                case '$':
+                    StringBuffer nameBuf = new StringBuffer();
+                    for (++cIdx ; cIdx < argStr.length(); ++cIdx)
+                    {
+                        ch = argStr.charAt(cIdx);
+                        if (ch == '_' || Character.isLetterOrDigit(ch))
+                            nameBuf.append(ch);
+                        else
+                            break;
+                    }
+
+                    if (nameBuf.length() > 0)
+                    {
+                        String value =
+                                (String) vars.get(nameBuf.toString());
+
+                        if (value != null)
+                        {
+                            argBuf.append(value);
+                        }
+                    }
+                    break;
+
+                default:
+                    argBuf.append(ch);
+                    ++cIdx;
+                    break;
+            }
+        }
+
+        return argBuf;
+    }
+    
+    /**
+     * Read the contents of a file and place them in
+     * a string object.
+     *
+     * @param String path to file.
+     * @return String contents of the file.
+     */
+    public static String fileContentsToString(String file)
+    {
+        String contents = "";
+        
+        File f = new File(file);
+        
+        if (f.exists())
+        {
+            try
+            {
+                FileReader fr = new FileReader(f);
+                char[] template = new char[(int) f.length()];
+                fr.read(template);
+                contents = new String(template);
+            }
+            catch (Exception e)
+            {
+                System.out.println(e);
+                e.printStackTrace();
+            }
+        }
+        
+        return contents;
+    }
+    
+    /**
+     * Remove/collapse multiple newline characters.
+     *
+     * @param String string to collapse newlines in.
+     * @return String
+     */
+    public static String collapseNewlines(String argStr)
+    {
+        char last = argStr.charAt(0);
+        StringBuffer argBuf = new StringBuffer();
+
+        for (int cIdx = 0 ; cIdx < argStr.length(); cIdx++)
+        {
+            char ch = argStr.charAt(cIdx);
+            if (ch != '\n' || last != '\n')
+            {
+                argBuf.append(ch);
+                last = ch;
+            }
+        }
+
+        return argBuf.toString();
+    }
+
+    /**
+     * Remove/collapse multiple spaces.
+     *
+     * @param String string to remove multiple spaces from.
+     * @return String
+     */
+    public static String collapseSpaces(String argStr)
+    {
+        char last = argStr.charAt(0);
+        StringBuffer argBuf = new StringBuffer();
+
+        for (int cIdx = 0 ; cIdx < argStr.length(); cIdx++)
+        {
+            char ch = argStr.charAt(cIdx);
+            if (ch != ' ' || last != ' ')
+            {
+                argBuf.append(ch);
+                last = ch;
+            }
+        }
+
+        return argBuf.toString();
+    }
+
+    /**
+      * Replaces all instances of oldString with newString in line.
+      * Taken from the Jive forum package.
+      *
+      * @param String original string.
+      * @param String string in line to replace.
+      * @param String replace oldString with this.
+      * @return String string with replacements.
+      */
+    public static final String sub(String line, String oldString,
+            String newString)
+    {
+        int i = 0;
+        if ((i = line.indexOf(oldString, i)) >= 0)
+        {
+            char [] line2 = line.toCharArray();
+            char [] newString2 = newString.toCharArray();
+            int oLength = oldString.length();
+            StringBuffer buf = new StringBuffer(line2.length);
+            buf.append(line2, 0, i).append(newString2);
+            i += oLength;
+            int j = i;
+            while ((i = line.indexOf(oldString, i)) > 0)
+            {
+                buf.append(line2, j, i - j).append(newString2);
+                i += oLength;
+                j = i;
+            }
+            buf.append(line2, j, line2.length - j);
+            return buf.toString();
+        }
+        return line;
+    }
+    
+    /**
+     * Returns the output of printStackTrace as a String.
+     *
+     * @param e A Throwable.
+     * @return A String.
+     */
+    public static final String stackTrace(Throwable e)
+    {
+        String foo = null;
+        try
+        {
+            // And show the Error Screen.
+            ByteArrayOutputStream ostr = new ByteArrayOutputStream();
+            e.printStackTrace( new PrintWriter(ostr,true) );
+            foo = ostr.toString();
+        }
+        catch (Exception f)
+        {
+            // Do nothing.
+        }
+        return foo;
+    }
+
+    /**
+     * Return a context-relative path, beginning with a "/", that represents
+     * the canonical version of the specified path after ".." and "." elements
+     * are resolved out.  If the specified path attempts to go outside the
+     * boundaries of the current context (i.e. too many ".." path elements
+     * are present), return <code>null</code> instead.
+     *
+     * @param path Path to be normalized
+     * @return String normalized path
+     */
+    public static final String normalizePath(String path)
+    {
+        // Normalize the slashes and add leading slash if necessary
+        String normalized = path;
+        if (normalized.indexOf('\\') >= 0)
+        {
+            normalized = normalized.replace('\\', '/');
+        }
+
+        if (!normalized.startsWith("/"))
+        {
+            normalized = "/" + normalized;
+        }
+        
+        // Resolve occurrences of "//" in the normalized path
+        while (true)
+        {
+            int index = normalized.indexOf("//");
+            if (index < 0)
+                break;
+            normalized = normalized.substring(0, index) +
+            normalized.substring(index + 1);
+        }
+
+        // Resolve occurrences of "%20" in the normalized path
+        while (true)
+        {
+            int index = normalized.indexOf("%20");
+            if (index < 0)
+                break;
+            normalized = normalized.substring(0, index) + " " +
+            normalized.substring(index + 3);
+        }
+
+        // Resolve occurrences of "/./" in the normalized path
+        while (true)
+        {
+            int index = normalized.indexOf("/./");
+            if (index < 0)
+                break;
+            normalized = normalized.substring(0, index) +
+            normalized.substring(index + 2);
+        }
+
+        // Resolve occurrences of "/../" in the normalized path
+        while (true)
+        {
+            int index = normalized.indexOf("/../");
+            if (index < 0)
+                break;
+            if (index == 0)
+                return (null);  // Trying to go outside our context
+            int index2 = normalized.lastIndexOf('/', index - 1);
+            normalized = normalized.substring(0, index2) +
+            normalized.substring(index + 3);
+        }
+
+        // Return the normalized path that we have completed
+        return (normalized);
+    }
+
+    /**
+     * If state is true then return the trueString, else
+     * return the falseString.
+     *
+     * @param boolean 
+     * @param String trueString
+     * @param String falseString
+     */
+    public String select(boolean state, String trueString, String falseString)
+    {
+        if (state)
+        {
+            return trueString;
+        }            
+        else
+        {
+            return falseString;
+        }            
+    }            
+
+    /**
+     * Check to see if all the string objects passed
+     * in are empty.
+     *
+     * @param list A list of {@link java.lang.String} objects.
+     * @return     Whether all strings are empty.
+     */
+    public boolean allEmpty(List list)
+    {
+        int size = list.size();
+        
+        for (int i = 0; i < size; i++)
+        {
+            if (list.get(i) != null && list.get(i).toString().length() > 0)
+            {
+                return false;
+            }
+        }            
+        return true;
+    }
+}

Propchange: incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/StringUtils.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/ClassMap.java
URL: http://svn.apache.org/viewvc/incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/ClassMap.java?rev=1343781&view=auto
==============================================================================
--- incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/ClassMap.java (added)
+++ incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/ClassMap.java Tue May 29 15:35:01 2012
@@ -0,0 +1,522 @@
+package org.apache.velocity.util.introspection;
+
+/*
+ * Copyright 2001,2004 The Apache Software Foundation.
+ * 
+ * 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.
+ */
+
+import java.util.Map;
+import java.util.List;
+import java.util.Hashtable;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+
+/**
+ * A cache of introspection information for a specific class instance.
+ * Keys {@link java.lang.Method} objects by a concatenation of the
+ * method name and the names of classes that make up the parameters.
+ *
+ * @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
+ * @author <a href="mailto:bob@werken.com">Bob McWhirter</a>
+ * @author <a href="mailto:szegedia@freemail.hu">Attila Szegedi</a>
+ * @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
+ * @version $Id: ClassMap.java,v 1.20.8.1 2004/03/03 23:23:08 geirm Exp $
+ */
+public class ClassMap
+{
+    private static final class CacheMiss { }
+    private static final CacheMiss CACHE_MISS = new CacheMiss();
+    private static final Object OBJECT = new Object();
+
+    /** 
+     * Class passed into the constructor used to as
+     * the basis for the Method map.
+     */
+
+    private Class clazz;
+
+    /**
+     * Cache of Methods, or CACHE_MISS, keyed by method
+     * name and actual arguments used to find it.
+     */
+    private Map methodCache = new Hashtable();
+
+    private MethodMap methodMap = new MethodMap();
+
+    /**
+     * Standard constructor
+     */
+    public ClassMap( Class clazz)
+    {
+        this.clazz = clazz;
+        populateMethodCache();
+    }
+
+    private ClassMap()
+    {
+    }
+
+    /**
+     * @return the class object whose methods are cached by this map.
+     */
+     Class getCachedClass()
+     {
+         return clazz;
+     }
+    
+    /**
+     * Find a Method using the methodKey
+     * provided.
+     *
+     * Look in the methodMap for an entry.  If found,
+     * it'll either be a CACHE_MISS, in which case we
+     * simply give up, or it'll be a Method, in which
+     * case, we return it.
+     *
+     * If nothing is found, then we must actually go
+     * and introspect the method from the MethodMap.
+     */
+    public Method findMethod(String name, Object[] params)
+        throws MethodMap.AmbiguousException
+    {
+        String methodKey = makeMethodKey(name, params);
+        Object cacheEntry = methodCache.get( methodKey );
+
+        if (cacheEntry == CACHE_MISS)
+        {
+            return null;
+        }
+
+        if (cacheEntry == null)
+        {
+            try
+            {
+                cacheEntry = methodMap.find( name,
+                                             params );
+            }
+            catch( MethodMap.AmbiguousException ae )
+            {
+                /*
+                 *  that's a miss :)
+                 */
+
+                methodCache.put( methodKey,
+                                 CACHE_MISS );
+
+                throw ae;
+            }
+
+            if ( cacheEntry == null )
+            {
+                methodCache.put( methodKey,
+                                 CACHE_MISS );
+            }
+            else
+            {
+                methodCache.put( methodKey,
+                                 cacheEntry );
+            }
+        }
+
+        // Yes, this might just be null.
+        
+        return (Method) cacheEntry;
+    }
+    
+    /**
+     * Populate the Map of direct hits. These
+     * are taken from all the public methods
+     * that our class provides.
+     */
+    private void populateMethodCache()
+    {
+        StringBuffer methodKey;
+
+        /*
+         *  get all publicly accessible methods
+         */
+
+        Method[] methods = getAccessibleMethods(clazz);
+
+        /*
+         * map and cache them
+         */
+
+        for (int i = 0; i < methods.length; i++)
+        {
+            Method method = methods[i];
+
+            /*
+             *  now get the 'public method', the method declared by a 
+             *  public interface or class. (because the actual implementing
+             *  class may be a facade...
+             */
+
+            Method publicMethod = getPublicMethod( method );
+
+            /*
+             *  it is entirely possible that there is no public method for
+             *  the methods of this class (i.e. in the facade, a method
+             *  that isn't on any of the interfaces or superclass
+             *  in which case, ignore it.  Otherwise, map and cache
+             */
+
+            if ( publicMethod != null)
+            {
+                methodMap.add( publicMethod );
+                methodCache.put(  makeMethodKey( publicMethod), publicMethod);
+            }
+        }            
+    }
+
+    /**
+     * Make a methodKey for the given method using
+     * the concatenation of the name and the
+     * types of the method parameters.
+     */
+    private String makeMethodKey(Method method)
+    {
+        Class[] parameterTypes = method.getParameterTypes();
+        
+        StringBuffer methodKey = new StringBuffer(method.getName());
+        
+        for (int j = 0; j < parameterTypes.length; j++)
+        {
+            /*
+             * If the argument type is primitive then we want
+             * to convert our primitive type signature to the 
+             * corresponding Object type so introspection for
+             * methods with primitive types will work correctly.
+             */
+            if (parameterTypes[j].isPrimitive())
+            {
+                if (parameterTypes[j].equals(Boolean.TYPE))
+                    methodKey.append("java.lang.Boolean");
+                else if (parameterTypes[j].equals(Byte.TYPE))
+                    methodKey.append("java.lang.Byte");
+                else if (parameterTypes[j].equals(Character.TYPE))
+                    methodKey.append("java.lang.Character");
+                else if (parameterTypes[j].equals(Double.TYPE))
+                    methodKey.append("java.lang.Double");
+                else if (parameterTypes[j].equals(Float.TYPE))
+                    methodKey.append("java.lang.Float");
+                else if (parameterTypes[j].equals(Integer.TYPE))
+                    methodKey.append("java.lang.Integer");
+                else if (parameterTypes[j].equals(Long.TYPE))
+                    methodKey.append("java.lang.Long");
+                else if (parameterTypes[j].equals(Short.TYPE))
+                    methodKey.append("java.lang.Short");
+            }                
+            else
+            {
+                methodKey.append(parameterTypes[j].getName());
+            }
+        }            
+        
+        return methodKey.toString();
+    }
+
+    private static String makeMethodKey(String method, Object[] params)
+    {
+        StringBuffer methodKey = new StringBuffer().append(method);
+
+        for (int j = 0; j < params.length; j++)
+        {
+            Object arg = params[j];
+
+            if (arg == null)
+            {
+                arg = OBJECT;
+            }
+
+            methodKey.append(arg.getClass().getName());
+        }
+        
+        return methodKey.toString();
+    }
+
+    /**
+     * Retrieves public methods for a class. In case the class is not
+     * public, retrieves methods with same signature as its public methods
+     * from public superclasses and interfaces (if they exist). Basically
+     * upcasts every method to the nearest acccessible method.
+     */
+    private static Method[] getAccessibleMethods(Class clazz)
+    {
+        Method[] methods = clazz.getMethods();
+        
+        /*
+         *  Short circuit for the (hopefully) majority of cases where the
+         *  clazz is public
+         */
+        
+        if (Modifier.isPublic(clazz.getModifiers()))
+        {
+            return methods;
+        }
+
+        /*
+         *  No luck - the class is not public, so we're going the longer way.
+         */
+
+        MethodInfo[] methodInfos = new MethodInfo[methods.length];
+
+        for(int i = methods.length; i-- > 0; )
+        {
+            methodInfos[i] = new MethodInfo(methods[i]);
+        }
+
+        int upcastCount = getAccessibleMethods(clazz, methodInfos, 0);
+
+        /*
+         *  Reallocate array in case some method had no accessible counterpart.
+         */
+
+        if(upcastCount < methods.length)
+        {
+            methods = new Method[upcastCount];
+        }
+
+        int j = 0;
+        for(int i = 0; i < methodInfos.length; ++i)
+        {
+            MethodInfo methodInfo = methodInfos[i];
+            if(methodInfo.upcast)
+            {
+                methods[j++] = methodInfo.method;
+            }
+        }
+        return methods;
+    }
+
+    /**
+     *  Recursively finds a match for each method, starting with the class, and then
+     *  searching the superclass and interfaces.
+     *
+     *  @param clazz Class to check
+     *  @param methodInfos array of methods we are searching to match
+     *  @param upcastCount current number of methods we have matched
+     *  @return count of matched methods
+     */
+    private static int getAccessibleMethods( Class clazz, MethodInfo[] methodInfos, int upcastCount)
+    {
+        int l = methodInfos.length;
+        
+        /*
+         *  if this class is public, then check each of the currently
+         *  'non-upcasted' methods to see if we have a match
+         */
+
+        if( Modifier.isPublic(clazz.getModifiers()) )
+        {
+            for(int i = 0; i < l && upcastCount < l; ++i)
+            {
+                try
+                {
+                    MethodInfo methodInfo = methodInfos[i];
+
+                    if(!methodInfo.upcast)
+                    {
+                        methodInfo.tryUpcasting(clazz);
+                        upcastCount++;
+                    }
+                }
+                catch(NoSuchMethodException e)
+                {
+                    /*
+                     *  Intentionally ignored - it means
+                     *  it wasn't found in the current class
+                     */
+                }
+            }
+
+            /*
+             *  Short circuit if all methods were upcast
+             */
+
+            if(upcastCount == l)
+            {
+                return upcastCount;
+            }
+        }
+
+        /*
+         *   Examine superclass
+         */
+
+        Class superclazz = clazz.getSuperclass();
+
+        if(superclazz != null)
+        {
+            upcastCount = getAccessibleMethods(superclazz , methodInfos, upcastCount);
+
+            /*
+             *  Short circuit if all methods were upcast
+             */
+
+            if(upcastCount == l)
+            {
+                return upcastCount;
+            }
+        }
+
+        /*
+         *  Examine interfaces. Note we do it even if superclazz == null.
+         *  This is redundant as currently java.lang.Object does not implement
+         *  any interfaces, however nothing guarantees it will not in future.
+         */
+
+        Class[] interfaces = clazz.getInterfaces();
+
+        for(int i = interfaces.length; i-- > 0; )
+        {
+            upcastCount = getAccessibleMethods(interfaces[i], methodInfos, upcastCount);
+
+            /*
+             *  Short circuit if all methods were upcast
+             */
+
+            if(upcastCount == l)
+            {
+                return upcastCount;
+            }
+        }
+
+        return upcastCount;
+    }
+    
+    /**
+     *  For a given method, retrieves its publicly accessible counterpart. 
+     *  This method will look for a method with same name
+     *  and signature declared in a public superclass or implemented interface of this 
+     *  method's declaring class. This counterpart method is publicly callable.
+     *
+     *  @param method a method whose publicly callable counterpart is requested.
+     *  @return the publicly callable counterpart method. Note that if the parameter
+     *  method is itself declared by a public class, this method is an identity
+     *  function.
+     */
+    public static Method getPublicMethod(Method method)
+    {
+        Class clazz = method.getDeclaringClass();
+        
+        /*
+         *   Short circuit for (hopefully the majority of) cases where the declaring
+         *   class is public.
+         */
+
+        if((clazz.getModifiers() & Modifier.PUBLIC) != 0)
+        {
+            return method;
+        }
+
+        return getPublicMethod(clazz, method.getName(), method.getParameterTypes());
+    }
+
+    /**
+     *  Looks up the method with specified name and signature in the first public
+     *  superclass or implemented interface of the class. 
+     * 
+     *  @param class the class whose method is sought
+     *  @param name the name of the method
+     *  @param paramTypes the classes of method parameters
+     */
+    private static Method getPublicMethod(Class clazz, String name, Class[] paramTypes)
+    {
+        /*
+         *  if this class is public, then try to get it
+         */
+
+        if((clazz.getModifiers() & Modifier.PUBLIC) != 0)
+        {
+            try
+            {
+                return clazz.getMethod(name, paramTypes);
+            }
+            catch(NoSuchMethodException e)
+            {
+                /*
+                 *  If the class does not have the method, then neither its
+                 *  superclass nor any of its interfaces has it so quickly return
+                 *  null.
+                 */
+                 return null;
+            }
+        }
+
+        /*
+         *  try the superclass
+         */
+
+ 
+        Class superclazz = clazz.getSuperclass();
+
+        if ( superclazz != null )
+        {
+            Method superclazzMethod = getPublicMethod(superclazz, name, paramTypes);
+            
+            if(superclazzMethod != null)
+            {
+                return superclazzMethod;
+            }
+        }
+
+        /*
+         *  and interfaces
+         */
+
+        Class[] interfaces = clazz.getInterfaces();
+
+        for(int i = 0; i < interfaces.length; ++i)
+        {
+            Method interfaceMethod = getPublicMethod(interfaces[i], name, paramTypes);
+            
+            if(interfaceMethod != null)
+            {
+                return interfaceMethod;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     *  Used for the iterative discovery process for public methods.
+     */
+    private static final class MethodInfo
+    {
+        Method method;
+        String name;
+        Class[] parameterTypes;
+        boolean upcast;
+        
+        MethodInfo(Method method)
+        {
+            this.method = null;
+            name = method.getName();
+            parameterTypes = method.getParameterTypes();
+            upcast = false;
+        }
+        
+        void tryUpcasting(Class clazz)
+            throws NoSuchMethodException
+        {
+            method = clazz.getMethod(name, parameterTypes);
+            name = null;
+            parameterTypes = null;
+            upcast = true;
+        }
+    }
+}

Propchange: incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/ClassMap.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/IntrospectionCacheData.java
URL: http://svn.apache.org/viewvc/incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/IntrospectionCacheData.java?rev=1343781&view=auto
==============================================================================
--- incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/IntrospectionCacheData.java (added)
+++ incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/IntrospectionCacheData.java Tue May 29 15:35:01 2012
@@ -0,0 +1,40 @@
+package org.apache.velocity.util.introspection;
+
+/*
+ * Copyright 2001,2004 The Apache Software Foundation.
+ * 
+ * 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.
+ */
+
+/**
+ *  Holds information for node-local context data introspection
+ *  information.
+ *
+ * @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
+ * @version $Id: IntrospectionCacheData.java,v 1.3.14.1 2004/03/03 23:23:08 geirm Exp $
+ */
+public class IntrospectionCacheData
+{
+    /**  
+     *  Object to pair with class - currently either a Method or 
+     *  AbstractExecutor. It can be used in any way the using node
+     *  wishes. 
+     */
+    public Object thingy;
+    
+    /*
+     *  Class of context data object associated with the introspection
+     *  information
+     */
+    public Class  contextData;
+}

Propchange: incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/IntrospectionCacheData.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/Introspector.java
URL: http://svn.apache.org/viewvc/incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/Introspector.java?rev=1343781&view=auto
==============================================================================
--- incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/Introspector.java (added)
+++ incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/Introspector.java Tue May 29 15:35:01 2012
@@ -0,0 +1,136 @@
+package org.apache.velocity.util.introspection;
+
+/*
+ * Copyright 2001,2004 The Apache Software Foundation.
+ * 
+ * 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.
+ */
+
+import java.util.Map;
+import java.util.Set;
+import java.util.HashMap;
+import java.util.HashSet;
+
+import java.lang.reflect.Method;
+
+import org.apache.velocity.runtime.RuntimeServices;
+import org.apache.velocity.runtime.RuntimeLogger;
+
+/**
+ * This basic function of this class is to return a Method
+ * object for a particular class given the name of a method
+ * and the parameters to the method in the form of an Object[]
+ *
+ * The first time the Introspector sees a 
+ * class it creates a class method map for the
+ * class in question. Basically the class method map
+ * is a Hastable where Method objects are keyed by a
+ * concatenation of the method name and the names of
+ * classes that make up the parameters.
+ *
+ * For example, a method with the following signature:
+ *
+ * public void method(String a, StringBuffer b)
+ *
+ * would be mapped by the key:
+ *
+ * "method" + "java.lang.String" + "java.lang.StringBuffer"
+ *
+ * This mapping is performed for all the methods in a class
+ * and stored for 
+ * @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
+ * @author <a href="mailto:bob@werken.com">Bob McWhirter</a>
+ * @author <a href="mailto:szegedia@freemail.hu">Attila Szegedi</a>
+ * @author <a href="mailto:paulo.gaspar@krankikom.de">Paulo Gaspar</a>
+ * @version $Id: Introspector.java,v 1.21.4.1 2004/03/03 23:23:08 geirm Exp $
+ */
+public class Introspector extends IntrospectorBase
+{
+    /**
+     *  define a public string so that it can be looked for
+     *  if interested
+     */
+     
+    public final static String CACHEDUMP_MSG = 
+        "Introspector : detected classloader change. Dumping cache.";
+
+    /**
+     *  our engine runtime services
+     */
+    private RuntimeLogger rlog = null;
+
+    /**
+     *  Recieves our RuntimeServices object
+     */
+    public Introspector(RuntimeLogger logger)
+    {
+        this.rlog = logger;
+    }
+   
+    /**
+     * Gets the method defined by <code>name</code> and
+     * <code>params</code> for the Class <code>c</code>.
+     *
+     * @param c Class in which the method search is taking place
+     * @param name Name of the method being searched for
+     * @param params An array of Objects (not Classes) that describe the
+     *               the parameters
+     *
+     * @return The desired Method object.
+     */
+    public Method getMethod(Class c, String name, Object[] params)
+        throws Exception
+    {
+        /*
+         *  just delegate to the base class
+         */
+
+        try
+        {
+            return super.getMethod( c, name, params );
+        }
+        catch( MethodMap.AmbiguousException ae )
+        {
+            /*
+             *  whoops.  Ambiguous.  Make a nice log message and return null...
+             */
+
+            String msg = "Introspection Error : Ambiguous method invocation "
+                + name + "( ";
+
+            for (int i = 0; i < params.length; i++)
+            {
+                if ( i > 0)
+                    msg = msg + ", ";
+                
+                msg = msg + params[i].getClass().getName();
+            }
+            
+            msg = msg + ") for class " + c;
+            
+            rlog.error( msg );
+        }
+
+        return null;
+    }
+
+    /**
+     * Clears the classmap and classname
+     * caches, and logs that we did so
+     */
+    protected void clearCache()
+    {
+        super.clearCache();
+        rlog.info( CACHEDUMP_MSG );
+    }
+}

Propchange: incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/Introspector.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/IntrospectorBase.java
URL: http://svn.apache.org/viewvc/incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/IntrospectorBase.java?rev=1343781&view=auto
==============================================================================
--- incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/IntrospectorBase.java (added)
+++ incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/IntrospectorBase.java Tue May 29 15:35:01 2012
@@ -0,0 +1,152 @@
+package org.apache.velocity.util.introspection;
+
+/*
+ * Copyright 2001,2004 The Apache Software Foundation.
+ * 
+ * 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.
+ */
+
+import java.util.Map;
+import java.util.Set;
+import java.util.HashMap;
+import java.util.HashSet;
+
+import java.lang.reflect.Method;
+
+/**
+ * This basic function of this class is to return a Method
+ * object for a particular class given the name of a method
+ * and the parameters to the method in the form of an Object[]
+ *
+ * The first time the Introspector sees a 
+ * class it creates a class method map for the
+ * class in question. Basically the class method map
+ * is a Hastable where Method objects are keyed by a
+ * concatenation of the method name and the names of
+ * classes that make up the parameters.
+ *
+ * For example, a method with the following signature:
+ *
+ * public void method(String a, StringBuffer b)
+ *
+ * would be mapped by the key:
+ *
+ * "method" + "java.lang.String" + "java.lang.StringBuffer"
+ *
+ * This mapping is performed for all the methods in a class
+ * and stored for 
+ * @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
+ * @author <a href="mailto:bob@werken.com">Bob McWhirter</a>
+ * @author <a href="mailto:szegedia@freemail.hu">Attila Szegedi</a>
+ * @author <a href="mailto:paulo.gaspar@krankikom.de">Paulo Gaspar</a>
+ * @version $Id: IntrospectorBase.java,v 1.2.8.1 2004/03/03 23:23:08 geirm Exp $
+ */
+public class IntrospectorBase
+{   
+    /**
+     * Holds the method maps for the classes we know about, keyed by
+     * Class object.
+     */ 
+    protected  Map classMethodMaps = new HashMap();
+    
+    /**
+     * Holds the qualified class names for the classes
+     * we hold in the classMethodMaps hash
+     */
+    protected Set cachedClassNames = new HashSet();
+   
+    /**
+     * Gets the method defined by <code>name</code> and
+     * <code>params</code> for the Class <code>c</code>.
+     *
+     * @param c Class in which the method search is taking place
+     * @param name Name of the method being searched for
+     * @param params An array of Objects (not Classes) that describe the
+     *               the parameters
+     *
+     * @return The desired Method object.
+     */
+    public Method getMethod(Class c, String name, Object[] params)
+        throws Exception
+    {
+        if (c == null)
+        {
+            throw new Exception ( 
+                "Introspector.getMethod(): Class method key was null: " + name );
+        }                
+
+        ClassMap classMap = null;
+        
+        synchronized(classMethodMaps)
+        {
+            classMap = (ClassMap)classMethodMaps.get(c);
+          
+            /*
+             *  if we don't have this, check to see if we have it
+             *  by name.  if so, then we have a classloader change
+             *  so dump our caches.
+             */
+             
+            if (classMap == null)
+            {                
+                if ( cachedClassNames.contains( c.getName() ))
+                {
+                    /*
+                     * we have a map for a class with same name, but not
+                     * this class we are looking at.  This implies a 
+                     * classloader change, so dump
+                     */
+                    clearCache();                    
+                }
+                 
+                classMap = createClassMap(c);
+            }
+        }
+        
+        return classMap.findMethod(name, params);
+    }
+
+    /**
+     * Creates a class map for specific class and registers it in the
+     * cache.  Also adds the qualified name to the name->class map
+     * for later Classloader change detection.
+     */
+    protected ClassMap createClassMap(Class c)
+    {        
+        ClassMap classMap = new ClassMap( c );        
+        classMethodMaps.put(c, classMap);
+        cachedClassNames.add( c.getName() );
+
+        return classMap;
+    }
+
+    /**
+     * Clears the classmap and classname
+     * caches
+     */
+    protected void clearCache()
+    {
+        /*
+         *  since we are synchronizing on this
+         *  object, we have to clear it rather than
+         *  just dump it.
+         */            
+        classMethodMaps.clear();
+        
+        /*
+         * for speed, we can just make a new one
+         * and let the old one be GC'd
+         */
+        cachedClassNames = new HashSet();
+    }
+}

Propchange: incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/IntrospectorBase.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/MethodMap.java
URL: http://svn.apache.org/viewvc/incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/MethodMap.java?rev=1343781&view=auto
==============================================================================
--- incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/MethodMap.java (added)
+++ incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/MethodMap.java Tue May 29 15:35:01 2012
@@ -0,0 +1,467 @@
+package org.apache.velocity.util.introspection;
+
+/*
+ * Copyright 2001,2004 The Apache Software Foundation.
+ * 
+ * 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.
+ */
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Hashtable;
+
+import java.lang.reflect.Method;
+
+/**
+ *
+ * @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
+ * @author <a href="mailto:bob@werken.com">Bob McWhirter</a>
+ * @author <a href="mailto:Christoph.Reck@dlr.de">Christoph Reck</a>
+ * @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
+ * @author <a href="mailto:szegedia@freemail.hu">Attila Szegedi</a>
+ * @version $Id: MethodMap.java,v 1.15.4.1 2004/03/03 23:23:08 geirm Exp $
+ */
+public class MethodMap
+{
+    private static final int MORE_SPECIFIC = 0;
+    private static final int LESS_SPECIFIC = 1;
+    private static final int INCOMPARABLE = 2;
+
+    /**
+     * Keep track of all methods with the same name.
+     */
+    Map methodByNameMap = new Hashtable();
+
+    /**
+     * Add a method to a list of methods by name.
+     * For a particular class we are keeping track
+     * of all the methods with the same name.
+     */
+    public void add(Method method)
+    {
+        String methodName = method.getName();
+
+        List l = get( methodName );
+
+        if ( l == null)
+        {
+            l = new ArrayList();
+            methodByNameMap.put(methodName, l);
+        }
+
+        l.add(method);
+
+        return;
+    }
+
+    /**
+     * Return a list of methods with the same name.
+     *
+     * @param String key
+     * @return List list of methods
+     */
+    public List get(String key)
+    {
+        return (List) methodByNameMap.get(key);
+    }
+
+    /**
+     *  <p>
+     *  Find a method.  Attempts to find the
+     *  most specific applicable method using the
+     *  algorithm described in the JLS section
+     *  15.12.2 (with the exception that it can't
+     *  distinguish a primitive type argument from
+     *  an object type argument, since in reflection
+     *  primitive type arguments are represented by
+     *  their object counterparts, so for an argument of
+     *  type (say) java.lang.Integer, it will not be able
+     *  to decide between a method that takes int and a
+     *  method that takes java.lang.Integer as a parameter.
+     *  </p>
+     *
+     *  <p>
+     *  This turns out to be a relatively rare case
+     *  where this is needed - however, functionality
+     *  like this is needed.
+     *  </p>
+     *
+     *  @param methodName name of method
+     *  @param args the actual arguments with which the method is called
+     *  @return the most specific applicable method, or null if no
+     *  method is applicable.
+     *  @throws AmbiguousException if there is more than one maximally
+     *  specific applicable method
+     */
+    public Method find(String methodName, Object[] args)
+        throws AmbiguousException
+    {
+        List methodList = get(methodName);
+
+        if (methodList == null)
+        {
+            return null;
+        }
+
+        int l = args.length;
+        Class[] classes = new Class[l];
+
+        for(int i = 0; i < l; ++i)
+        {
+            Object arg = args[i];
+
+            /*
+             * if we are careful down below, a null argument goes in there
+             * so we can know that the null was passed to the method
+             */
+            classes[i] =
+                    arg == null ? null : arg.getClass();
+        }
+
+        return getMostSpecific(methodList, classes);
+    }
+
+    /**
+     *  simple distinguishable exception, used when
+     *  we run across ambiguous overloading
+     */
+    public static class AmbiguousException extends Exception
+    {
+    }
+
+
+    private static Method getMostSpecific(List methods, Class[] classes)
+        throws AmbiguousException
+    {
+        LinkedList applicables = getApplicables(methods, classes);
+
+        if(applicables.isEmpty())
+        {
+            return null;
+        }
+
+        if(applicables.size() == 1)
+        {
+            return (Method)applicables.getFirst();
+        }
+
+        /*
+         * This list will contain the maximally specific methods. Hopefully at
+         * the end of the below loop, the list will contain exactly one method,
+         * (the most specific method) otherwise we have ambiguity.
+         */
+
+        LinkedList maximals = new LinkedList();
+
+        for (Iterator applicable = applicables.iterator();
+             applicable.hasNext();)
+        {
+            Method app = (Method) applicable.next();
+            Class[] appArgs = app.getParameterTypes();
+            boolean lessSpecific = false;
+
+            for (Iterator maximal = maximals.iterator();
+                 !lessSpecific && maximal.hasNext();)
+            {
+                Method max = (Method) maximal.next();
+
+                switch(moreSpecific(appArgs, max.getParameterTypes()))
+                {
+                    case MORE_SPECIFIC:
+                    {
+                        /*
+                         * This method is more specific than the previously
+                         * known maximally specific, so remove the old maximum.
+                         */
+
+                        maximal.remove();
+                        break;
+                    }
+
+                    case LESS_SPECIFIC:
+                    {
+                        /*
+                         * This method is less specific than some of the
+                         * currently known maximally specific methods, so we
+                         * won't add it into the set of maximally specific
+                         * methods
+                         */
+
+                        lessSpecific = true;
+                        break;
+                    }
+                }
+            }
+
+            if(!lessSpecific)
+            {
+                maximals.addLast(app);
+            }
+        }
+
+        if(maximals.size() > 1)
+        {
+            // We have more than one maximally specific method
+            throw new AmbiguousException();
+        }
+
+        return (Method)maximals.getFirst();
+    }
+
+    /**
+     * Determines which method signature (represented by a class array) is more
+     * specific. This defines a partial ordering on the method signatures.
+     * @param c1 first signature to compare
+     * @param c2 second signature to compare
+     * @return MORE_SPECIFIC if c1 is more specific than c2, LESS_SPECIFIC if
+     * c1 is less specific than c2, INCOMPARABLE if they are incomparable.
+     */
+    private static int moreSpecific(Class[] c1, Class[] c2)
+    {
+        boolean c1MoreSpecific = false;
+        boolean c2MoreSpecific = false;
+
+        for(int i = 0; i < c1.length; ++i)
+        {
+            if(c1[i] != c2[i])
+            {
+                c1MoreSpecific =
+                    c1MoreSpecific ||
+                    isStrictMethodInvocationConvertible(c2[i], c1[i]);
+                c2MoreSpecific =
+                    c2MoreSpecific ||
+                    isStrictMethodInvocationConvertible(c1[i], c2[i]);
+            }
+        }
+
+        if(c1MoreSpecific)
+        {
+            if(c2MoreSpecific)
+            {
+                /*
+                 *  Incomparable due to cross-assignable arguments (i.e.
+                 * foo(String, Object) vs. foo(Object, String))
+                 */
+
+                return INCOMPARABLE;
+            }
+
+            return MORE_SPECIFIC;
+        }
+
+        if(c2MoreSpecific)
+        {
+            return LESS_SPECIFIC;
+        }
+
+        /*
+         * Incomparable due to non-related arguments (i.e.
+         * foo(Runnable) vs. foo(Serializable))
+         */
+
+        return INCOMPARABLE;
+    }
+
+    /**
+     * Returns all methods that are applicable to actual argument types.
+     * @param methods list of all candidate methods
+     * @param classes the actual types of the arguments
+     * @return a list that contains only applicable methods (number of
+     * formal and actual arguments matches, and argument types are assignable
+     * to formal types through a method invocation conversion).
+     */
+    private static LinkedList getApplicables(List methods, Class[] classes)
+    {
+        LinkedList list = new LinkedList();
+
+        for (Iterator imethod = methods.iterator(); imethod.hasNext();)
+        {
+            Method method = (Method) imethod.next();
+
+            if(isApplicable(method, classes))
+            {
+                list.add(method);
+            }
+
+        }
+        return list;
+    }
+
+    /**
+     * Returns true if the supplied method is applicable to actual
+     * argument types.
+     */
+    private static boolean isApplicable(Method method, Class[] classes)
+    {
+        Class[] methodArgs = method.getParameterTypes();
+
+        if(methodArgs.length != classes.length)
+        {
+            return false;
+        }
+
+        for(int i = 0; i < classes.length; ++i)
+        {
+            if(!isMethodInvocationConvertible(methodArgs[i], classes[i]))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Determines whether a type represented by a class object is
+     * convertible to another type represented by a class object using a
+     * method invocation conversion, treating object types of primitive
+     * types as if they were primitive types (that is, a Boolean actual
+     * parameter type matches boolean primitive formal type). This behavior
+     * is because this method is used to determine applicable methods for
+     * an actual parameter list, and primitive types are represented by
+     * their object duals in reflective method calls.
+     *
+     * @param formal the formal parameter type to which the actual
+     * parameter type should be convertible
+     * @param actual the actual parameter type.
+     * @return true if either formal type is assignable from actual type,
+     * or formal is a primitive type and actual is its corresponding object
+     * type or an object type of a primitive type that can be converted to
+     * the formal type.
+     */
+    private static boolean isMethodInvocationConvertible(Class formal,
+                                                         Class actual)
+    {
+        /*
+         * if it's a null, it means the arg was null
+         */
+        if (actual == null && !formal.isPrimitive())
+        {
+            return true;
+        }
+
+        /*
+         *  Check for identity or widening reference conversion
+         */
+
+        if (actual != null && formal.isAssignableFrom(actual))
+        {
+            return true;
+        }
+
+        /*
+         * Check for boxing with widening primitive conversion. Note that
+         * actual parameters are never primitives.
+         */
+
+        if (formal.isPrimitive())
+        {
+            if(formal == Boolean.TYPE && actual == Boolean.class)
+                return true;
+            if(formal == Character.TYPE && actual == Character.class)
+                return true;
+            if(formal == Byte.TYPE && actual == Byte.class)
+                return true;
+            if(formal == Short.TYPE &&
+               (actual == Short.class || actual == Byte.class))
+                return true;
+            if(formal == Integer.TYPE &&
+               (actual == Integer.class || actual == Short.class ||
+                actual == Byte.class))
+                return true;
+            if(formal == Long.TYPE &&
+               (actual == Long.class || actual == Integer.class ||
+                actual == Short.class || actual == Byte.class))
+                return true;
+            if(formal == Float.TYPE &&
+               (actual == Float.class || actual == Long.class ||
+                actual == Integer.class || actual == Short.class ||
+                actual == Byte.class))
+                return true;
+            if(formal == Double.TYPE &&
+               (actual == Double.class || actual == Float.class ||
+                actual == Long.class || actual == Integer.class ||
+                actual == Short.class || actual == Byte.class))
+                return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Determines whether a type represented by a class object is
+     * convertible to another type represented by a class object using a
+     * method invocation conversion, without matching object and primitive
+     * types. This method is used to determine the more specific type when
+     * comparing signatures of methods.
+     *
+     * @param formal the formal parameter type to which the actual
+     * parameter type should be convertible
+     * @param actual the actual parameter type.
+     * @return true if either formal type is assignable from actual type,
+     * or formal and actual are both primitive types and actual can be
+     * subject to widening conversion to formal.
+     */
+    private static boolean isStrictMethodInvocationConvertible(Class formal,
+                                                               Class actual)
+    {
+        /*
+         * we shouldn't get a null into, but if so
+         */
+        if (actual == null && !formal.isPrimitive())
+        {
+            return true;
+        }
+
+        /*
+         *  Check for identity or widening reference conversion
+         */
+
+        if(formal.isAssignableFrom(actual))
+        {
+            return true;
+        }
+
+        /*
+         *  Check for widening primitive conversion.
+         */
+
+        if(formal.isPrimitive())
+        {
+            if(formal == Short.TYPE && (actual == Byte.TYPE))
+                return true;
+            if(formal == Integer.TYPE &&
+               (actual == Short.TYPE || actual == Byte.TYPE))
+                return true;
+            if(formal == Long.TYPE &&
+               (actual == Integer.TYPE || actual == Short.TYPE ||
+                actual == Byte.TYPE))
+                return true;
+            if(formal == Float.TYPE &&
+               (actual == Long.TYPE || actual == Integer.TYPE ||
+                actual == Short.TYPE || actual == Byte.TYPE))
+                return true;
+            if(formal == Double.TYPE &&
+               (actual == Float.TYPE || actual == Long.TYPE ||
+                actual == Integer.TYPE || actual == Short.TYPE ||
+                actual == Byte.TYPE))
+                return true;
+        }
+        return false;
+    }
+}

Propchange: incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/MethodMap.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/Uberspect.java
URL: http://svn.apache.org/viewvc/incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/Uberspect.java?rev=1343781&view=auto
==============================================================================
--- incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/Uberspect.java (added)
+++ incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/Uberspect.java Tue May 29 15:35:01 2012
@@ -0,0 +1,57 @@
+package org.apache.velocity.util.introspection;
+
+/*
+ * Copyright 2002,2004 The Apache Software Foundation.
+ * 
+ * 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.
+ */
+
+import org.apache.velocity.runtime.RuntimeLogger;
+
+import java.util.Iterator;
+import java.lang.reflect.Method;
+
+/**
+ * 'Federated' introspection/reflection interface to allow the introspection
+ *  behavior in Velocity to be customized.
+ *
+ * @author <a href="mailto:geirm@apache.org">Geir Magusson Jr.</a>
+ * @version $Id: Uberspect.java,v 1.1.4.1 2004/03/03 23:23:08 geirm Exp $
+ */
+public interface Uberspect
+{
+    /**
+     *  Initializer - will be called before use
+     */
+    public void init() throws Exception;
+
+    /**
+     *  To support iteratives - #foreach()
+     */
+    public Iterator getIterator(Object obj, Info info) throws Exception;
+
+    /**
+     *  Returns a general method, corresponding to $foo.bar( $woogie )
+     */
+    public VelMethod getMethod(Object obj, String method, Object[] args, Info info) throws Exception;
+
+    /**
+     * Property getter - returns VelPropertyGet appropos for #set($foo = $bar.woogie)
+     */
+    public VelPropertyGet getPropertyGet(Object obj, String identifier, Info info) throws Exception;
+
+    /**
+     * Property setter - returns VelPropertySet appropos for #set($foo.bar = "geir")
+     */
+    public VelPropertySet getPropertySet(Object obj, String identifier, Object arg, Info info) throws Exception;
+}

Propchange: incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/Uberspect.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/UberspectImpl.java
URL: http://svn.apache.org/viewvc/incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/UberspectImpl.java?rev=1343781&view=auto
==============================================================================
--- incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/UberspectImpl.java (added)
+++ incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/UberspectImpl.java Tue May 29 15:35:01 2012
@@ -0,0 +1,366 @@
+package org.apache.velocity.util.introspection;
+
+/*
+ * Copyright 2002,2004 The Apache Software Foundation.
+ * 
+ * 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.
+ */
+
+import org.apache.velocity.util.ArrayIterator;
+import org.apache.velocity.util.EnumerationIterator;
+import org.apache.velocity.runtime.RuntimeServices;
+import org.apache.velocity.runtime.RuntimeLogger;
+import org.apache.velocity.runtime.parser.node.AbstractExecutor;
+import org.apache.velocity.runtime.parser.node.PropertyExecutor;
+import org.apache.velocity.runtime.parser.node.GetExecutor;
+import org.apache.velocity.runtime.parser.node.BooleanPropertyExecutor;
+
+import java.lang.reflect.Method;
+import java.util.Iterator;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Enumeration;
+import java.util.ArrayList;
+
+/**
+ *  Implementation of Uberspect to provide the default introspective
+ *  functionality of Velocity
+ *
+ * @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
+ * @version $Id: UberspectImpl.java,v 1.2.4.1 2004/03/03 23:23:08 geirm Exp $
+ */
+public class UberspectImpl implements Uberspect, UberspectLoggable
+{
+    /**
+     *  Our runtime logger.
+     */
+    private RuntimeLogger rlog;
+
+    /**
+     *  the default Velocity introspector
+     */
+    private static Introspector introspector;
+
+    /**
+     *  init - does nothing - we need to have setRuntimeLogger
+     *  called before getting our introspector, as the default
+     *  vel introspector depends upon it.
+     */
+    public void init()
+        throws Exception
+    {
+    }
+
+    /**
+     *  Sets the runtime logger - this must be called before anything
+     *  else besides init() as to get the logger.  Makes the pull
+     *  model appealing...
+     */
+    public void setRuntimeLogger(RuntimeLogger runtimeLogger)
+    {
+        rlog = runtimeLogger;
+        introspector = new Introspector(rlog);
+    }
+
+    /**
+     *  To support iteratives - #foreach()
+     */
+    public Iterator getIterator(Object obj, Info i)
+            throws Exception
+    {
+        if (obj.getClass().isArray())
+        {
+            return new ArrayIterator(obj);
+        }
+        else if (obj instanceof Collection)
+        {
+            return ((Collection) obj).iterator();
+        }
+        else if (obj instanceof Map)
+        {
+            return ((Map) obj).values().iterator();
+        }
+        else if (obj instanceof Iterator)
+        {
+            rlog.warn ("Warning! The iterative "
+                          + " is an Iterator in the #foreach() loop at ["
+                          + i.getLine() + "," + i.getColumn() + "]"
+                          + " in template " + i.getTemplateName()
+                          + ". Because it's not resetable,"
+                          + " if used in more than once, this may lead to"
+                          + " unexpected results.");
+
+            return ((Iterator) obj);
+        }
+        else if (obj instanceof Enumeration)
+        {
+            rlog.warn ("Warning! The iterative "
+                          + " is an Enumeration in the #foreach() loop at ["
+                          + i.getLine() + "," + i.getColumn() + "]"
+                          + " in template " + i.getTemplateName()
+                          + ". Because it's not resetable,"
+                          + " if used in more than once, this may lead to"
+                          + " unexpected results.");
+
+            return new EnumerationIterator((Enumeration) obj);
+        }
+
+        /*  we have no clue what this is  */
+        rlog.warn ("Could not determine type of iterator in "
+                      +  "#foreach loop "
+                      + " at [" + i.getLine() + "," + i.getColumn() + "]"
+                      + " in template " + i.getTemplateName() );
+
+        return null;
+    }
+
+    /**
+     *  Method
+     */
+    public VelMethod getMethod(Object obj, String methodName, Object[] args, Info i)
+            throws Exception
+    {
+        if (obj == null)
+            return null;
+
+        Method m = introspector.getMethod(obj.getClass(), methodName, args);
+
+        return (m != null) ? new VelMethodImpl(m) : null;
+    }
+
+    /**
+     * Property  getter
+     */
+    public VelPropertyGet getPropertyGet(Object obj, String identifier, Info i)
+            throws Exception
+    {
+        AbstractExecutor executor;
+
+        Class claz = obj.getClass();
+
+        /*
+         *  first try for a getFoo() type of property
+         *  (also getfoo() )
+         */
+
+        executor = new PropertyExecutor(rlog,introspector, claz, identifier);
+
+        /*
+         *  if that didn't work, look for get("foo")
+         */
+
+        if (executor.isAlive() == false)
+        {
+            executor = new GetExecutor(rlog, introspector, claz, identifier);
+        }
+
+        /*
+         *  finally, look for boolean isFoo()
+         */
+
+        if( executor.isAlive() == false)
+        {
+            executor = new BooleanPropertyExecutor(rlog, introspector, claz, identifier);
+        }
+
+        return (executor != null) ? new VelGetterImpl(executor) : null;
+    }
+
+    /**
+     * Property setter
+     */
+    public VelPropertySet getPropertySet(Object obj, String identifier, Object arg, Info i)
+            throws Exception
+    {
+        Class claz = obj.getClass();
+
+        VelPropertySet vs = null;
+        VelMethod vm = null;
+        try
+        {
+            /*
+             *  first, we introspect for the set<identifier> setter method
+             */
+
+            Object[] params = {arg};
+
+            try
+            {
+                vm = getMethod(obj, "set" + identifier, params, i);
+
+                if (vm == null)
+                {
+                   throw new NoSuchMethodException();
+                }
+            }
+            catch(NoSuchMethodException nsme2)
+            {
+                StringBuffer sb = new StringBuffer("set");
+                sb.append(identifier);
+
+                if (Character.isLowerCase( sb.charAt(3)))
+                {
+                    sb.setCharAt(3, Character.toUpperCase(sb.charAt(3)));
+                }
+                else
+                {
+                    sb.setCharAt(3, Character.toLowerCase(sb.charAt(3)));
+                }
+
+                vm = getMethod(obj, sb.toString(), params, i);
+
+                if (vm == null)
+                {
+                   throw new NoSuchMethodException();
+                }
+            }
+        }
+        catch (NoSuchMethodException nsme)
+        {
+            /*
+             *  right now, we only support the Map interface
+             */
+
+            if (Map.class.isAssignableFrom(claz))
+            {
+                Object[] params = {new Object(), new Object()};
+
+                vm = getMethod(obj, "put", params, i);
+
+                if (vm!=null)
+                    return new VelSetterImpl(vm, identifier);
+            }
+       }
+
+       return (vm!=null) ?  new VelSetterImpl(vm) : null;
+    }
+
+    /**
+     *  Implementation of VelMethod
+     */
+    public class VelMethodImpl implements VelMethod
+    {
+        Method method = null;
+
+        public VelMethodImpl(Method m)
+        {
+            method = m;
+        }
+
+        private VelMethodImpl()
+        {
+        }
+
+        public Object invoke(Object o, Object[] params)
+            throws Exception
+        {
+            return method.invoke(o, params);
+        }
+
+        public boolean isCacheable()
+        {
+            return true;
+        }
+
+        public String getMethodName()
+        {
+            return method.getName();
+        }
+
+        public Class getReturnType()
+        {
+            return method.getReturnType();
+        }
+    }
+
+    public class VelGetterImpl implements VelPropertyGet
+    {
+        AbstractExecutor ae = null;
+
+        public VelGetterImpl(AbstractExecutor exec)
+        {
+            ae = exec;
+        }
+
+        private VelGetterImpl()
+        {
+        }
+
+        public Object invoke(Object o)
+            throws Exception
+        {
+            return ae.execute(o);
+        }
+
+        public boolean isCacheable()
+        {
+            return true;
+        }
+
+        public String getMethodName()
+        {
+            return ae.getMethod().getName();
+        }
+
+    }
+
+    public class VelSetterImpl implements VelPropertySet
+    {
+        VelMethod vm = null;
+        String putKey = null;
+
+        public VelSetterImpl(VelMethod velmethod)
+        {
+            this.vm = velmethod;
+        }
+
+        public VelSetterImpl(VelMethod velmethod, String key)
+        {
+            this.vm = velmethod;
+            putKey = key;
+        }
+
+        private VelSetterImpl()
+        {
+        }
+
+        public Object invoke(Object o, Object value)
+            throws Exception
+        {
+            ArrayList al = new ArrayList();
+
+            if (putKey != null)
+            {
+                al.add(putKey);
+                al.add(value);
+            }
+            else
+            {
+                al.add(value);
+            }
+
+            return vm.invoke(o,al.toArray());
+        }
+
+        public boolean isCacheable()
+        {
+            return true;
+        }
+
+        public String getMethodName()
+        {
+            return vm.getMethodName();
+        }
+
+    }
+}

Propchange: incubator/flex/trunk/modules/thirdparty/velocity/src/java/org/apache/velocity/util/introspection/UberspectImpl.java
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message