maven2-plugins/myfaces-builder-plugin/src/main/java/org/apache/myfaces/buildtools/maven2/plugin/builder/utils/MyfacesUtils.java - myfaces-build-tools - Git at Google

 /*
  *  Licensed to the Apache Software Foundation (ASF) under one
  *  or more contributor license agreements.  See the NOTICE file
  *  distributed with this work for additional information
  *  regarding copyright ownership.  The ASF licenses this file
  *  to you 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.apache.myfaces.buildtools.maven2.plugin.builder.utils;

 import java.io.File;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Set;
 import java.util.TreeSet;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 import org.apache.commons.lang.StringUtils;
 import org.apache.myfaces.buildtools.maven2.plugin.builder.model.ComponentMeta;
 import org.apache.myfaces.buildtools.maven2.plugin.builder.model.MethodSignatureMeta;
 import org.apache.myfaces.buildtools.maven2.plugin.builder.model.PropertyMeta;

 import org.apache.myfaces.buildtools.maven2.plugin.builder.model.PropertyHolder;

 /**
  * Collection of useful utility methods.
  * <p>
  * An instance of this type is made available to the templates used to generate
  * output files, so that they can call these useful methods.
  */
 public class MyfacesUtils
 {
     public MyfacesUtils()
     {
     }

     public static String getPrefixedPropertyName(String prefix,
             String propertyName)
     {
         return prefix + Character.toUpperCase(propertyName.charAt(0))
                 + propertyName.substring(1);
     }

     /**
      * Convert h:commandButton to commandButton
      *
      * @param prefixedName
      * @return
      */
     public static String getTagName(String prefixedName)
     {
         return prefixedName.substring(prefixedName.indexOf(':')+1);
     }

     public static String getTagPrefix(String prefixedName)
     {
         return prefixedName.substring(0,prefixedName.indexOf(':'));
     }

     public static String getJspPropertyType11(PropertyMeta property)
     {
 //        if (property.isMethodExpression())
 //            return "MethodBinding";

 //        if (property.isMethodBinding())
 //            return "MethodBinding";
         //On 1.1 all properties is mapped as String
         return "String";
     }

     public static String getFullJspPropertyType11(PropertyMeta property)
     {
         if (property.isMethodExpression())
         {
             return "javax.faces.el.MethodBinding";
         }

         if (property.isMethodBinding())
         {
             return "javax.faces.el.MethodBinding";
         }

         return "java.lang.String";
     }


     public static String getJspPropertyType12(PropertyMeta property)
     {
         if (property.getJspName().equals("actionListener"))
         {
             return "javax.el.MethodExpression";
         }
         if (property.getJspName().equals("validator"))
         {
             return "javax.el.MethodExpression";
         }
         if (property.getJspName().equals("valueChangeListener"))
         {
             return "javax.el.MethodExpression";
         }

         if (property.isMethodExpression())
         {
             return "MethodExpression";
         }

         if (property.isMethodBinding())
         {
             return "MethodBinding";
         }

         if (!property.isLiteralOnly().booleanValue())
         {
             return "ValueExpression";
         }
         else
         {
             return property.getClassName();
         }
     }

     public static String getVariableFromName(String name)
     {
         if (name == null)
         {
             return null;
         }

         if (RESERVED_WORDS.contains(name))
         {
             name = name + "Param";
         }

         return name;
     }

     // TODO: perhaps this could just return a list of class names for
     // templates to iterate over, rather than building the text itself?
     //
     // TODO: why are we importing tag classes into components anyway?
     public static String importTagClasses(PropertyHolder component)
     {
         Set imports = new HashSet();
         for (Iterator it = component.properties(); it.hasNext();)
         {
             PropertyMeta property = (PropertyMeta) it.next();
             if (property.getClassName() != null &&
                     !PRIMITIVE_TYPES.contains(property.getClassName()))
             {
                 if (!property.getClassName().startsWith("java.lang"))
                 {
                     imports.add(property.getClassName());
                 }
             }
         }

         StringBuffer value = new StringBuffer();

         for (Iterator importIterator = imports.iterator(); importIterator
                 .hasNext();)
         {
             value.append("import ");
             value.append((String) importIterator.next());
             value.append(';');
             value.append('\n');
         }

         return value.toString();
     }

     public static String importTagClasses12(ComponentMeta component)
     {
         Set imports = new HashSet();
         for (Iterator it = component.properties(); it.hasNext();)
         {
             PropertyMeta property = (PropertyMeta) it.next();
             if (property.getClassName() != null &&
                     !PRIMITIVE_TYPES.contains(property.getClassName()))
             {
                 if (!property.getClassName().startsWith("java.lang"))
                 {
                     imports.add(property.getClassName());
                 }
             }
             if (property.getJspName().equals("actionListener"))
             {
                 imports.add("javax.faces.event.MethodExpressionActionListener");
             }
             if (property.getJspName().equals("valueChangeListener"))
             {
                 imports.add("javax.faces.event.MethodExpressionValueChangeListener");
             }
             if (property.getJspName().equals("validator"))
             {
                 imports.add("javax.faces.validator.MethodExpressionValidator");
             }
         }

         StringBuffer value = new StringBuffer();

         for (Iterator importIterator = imports.iterator(); importIterator
                 .hasNext();)
         {
             value.append("import ");
             value.append((String) importIterator.next());
             value.append(';');
             value.append('\n');
         }

         return value.toString();
     }


     public static boolean isConverter(String propClass)
     {
         return ("javax.faces.convert.Converter".equals(propClass));
     }

     public static boolean isList(String propClass)
     {
         if (propClass == null)
         {
             return false;
         }
         else if(StringUtils.contains(propClass, "List"))
         {
             return true;
         }
         else
         {
             return false;
         }
     }

     public static String castIfNecessary(String propClass)
     {
       if (propClass.equals("Object") || propClass.equals("java.lang.Object"))
       {
         return "";
       }

       if (isPrimitiveClass(propClass))
       {
         propClass = getBoxedClass(propClass);
       }

       return "(" + propClass + ")";
     }

     public static String getBoxedClass(String className)
     {
         if ("boolean".equals(className))
         {
             return "Boolean";
         }
         else if ("byte".equals(className))
         {
             return "Byte";
         }
         else if ("char".equals(className))
         {
             return "Character";
         }
         else if ("double".equals(className))
         {
             return "Double";
         }
         else if ("float".equals(className))
         {
             return "Float";
         }
         else if ("int".equals(className))
         {
             return "Integer";
         }
         else if ("long".equals(className))
         {
             return "Long";
         }
         else if ("short".equals(className))
         {
             return "Short";
         }
         else
         {
             return className;
         }
     }

     public static String getSignatureParams(MethodSignatureMeta signature)
     {
         String[] paramTypes = (signature != null) ? signature.getParameterTypes() : null;

         String classArray;

         if (paramTypes == null || paramTypes.length == 0)
         {
           classArray = "new Class[0]";
         }
         else
         {
           StringBuffer sb = new StringBuffer();
           sb.append("new Class[]{");
           for (int i = 0; i < paramTypes.length; i++)
           {
             if (i > 0)
             {
               sb.append(',');
             }
             sb.append(paramTypes[i]);
             sb.append(".class");
           }

           // TODO: remove trailing comma
           sb.append(',');

           sb.append('}');
           classArray = sb.toString();
         }
         return classArray;
     }

     public static boolean isStringMethodBindingReturnType(MethodSignatureMeta sig)
     {
         return (sig != null && "java.lang.String".equals(sig.getReturnType()));
     }

     static public String getMethodReaderFromProperty(String propertyName,
             String propertyClass)
     {
         String methodPrefix = ("boolean".equals(propertyClass) ? "is" : "get");
         return getPrefixedPropertyName(methodPrefix, propertyName);
     }

     public static String getPrimitiveType(String className)
     {
         if (className.startsWith("java.lang."))
         {
             className = StringUtils.replace(className, "java.lang.", "");
         }

         if (className.endsWith("eger"))
         {
             className = StringUtils.replace(className, "eger", "");
         }

         if (MyfacesUtils.isPrimitiveClass(className.toLowerCase()))
         {
             return className.toLowerCase();
         }
         else
         {
             return className;
         }
     }

     public static boolean isPrimitiveClass(String className)
     {
         return "boolean".equals(className) || "byte".equals(className)
                 || "char".equals(className) || "double".equals(className)
                 || "float".equals(className) || "int".equals(className)
                 || "long".equals(className) || "short".equals(className);
     }

     private static Set _createPrimitiveTypesSet()
     {
         Set primitives = new TreeSet();
         for (int i = 0; i < _PRIMITIVE_TYPES.length; i++)
         {
             String type = _PRIMITIVE_TYPES[i];
             primitives.add(type);
             primitives.add(type + "[]");
         }
         return Collections.unmodifiableSet(primitives);
     }

     private static Set _createReservedWordsSet()
     {
         Set reserved = new TreeSet();
         for (int i = 0; i < _RESERVED_WORDS.length; i++)
         {
             String keyword = _RESERVED_WORDS[i];
             reserved.add(keyword);
         }
         return Collections.unmodifiableSet(reserved);
     }

     static private final String[] _PRIMITIVE_TYPES = new String[] {
         // TODO: Shouldn't java.lang.* be specified in that list as well?
     "boolean", "byte", "char", "float", "double", "int", "short", "long", };

     static private final String[] _RESERVED_WORDS = new String[] { "abstract",
             "assert", "boolean", "break", "byte", "case", "catch", "char",
             "class", "const", "continue", "default", "do", "double", "else",
             "extends", "final", "finally", "float", "for", "goto", "if",
             "implements", "import", "instanceof", "int", "interface", "long",
             "native", "new", "package", "private", "protected", "public",
             "return", "short", "static", "super", "switch", "synchronized",
             "this", "throw", "throws", "transient", "try", "void", "volatile",
             "while", };

     static public final Set RESERVED_WORDS = _createReservedWordsSet();
     static public final Set PRIMITIVE_TYPES = _createPrimitiveTypesSet();

     static private final Pattern _GENERIC_TYPE = Pattern
             .compile("([^<]+)<(.+)>");

     //UNUSED METHODS


     static public String convertClassToSourcePath(String className,
             String fileExtension)
     {
         return (className.replace('.', File.separatorChar) + fileExtension);
     }

     static public boolean isFullClass(String className)
     {
         return (className != null && className.indexOf('.') != -1);
     }

     /*
     public static String getGenericsFromProperty(PropertyMeta property){
         String gen = "";
         for (int i = 0; i < property.getAttributeClassParameters().length; i++) {
             if (i>0){
                 gen += ",";
             }
             gen += getClassFromFullClass(property.getAttributeClassParameters()[i]);
         }
         return (gen.length() > 0?"<"+gen+">":gen);
     }
     */

     /**
      * Extract the simple class name from a fully-qualified classname.
      * <p>
      * Given a string like "org.apache.Foo", this method returns "Foo".
      */
     static public String getClassFromFullClass(String fullClass)
     {
         if (fullClass == null)
         {
             return null;
         }

         int lastSep = fullClass.lastIndexOf('.');
         // Note: this code also works for the empty package
         return (fullClass.substring(lastSep + 1));
     }

     static public String getPackageFromFullClass(String fullClass)
     {
         if (fullClass == null)
         {
             return null;
         }

         int lastSep = fullClass.lastIndexOf('.');

         // detect the empty package
         if (lastSep == -1)
         {
             return "";
         }

         return (fullClass.substring(0, lastSep));
     }

     static public String getConstantNameFromProperty(String propertyName)
     {
         return getConstantNameFromProperty(propertyName, null);
     }

     static public String getConstantNameFromProperty(String propertyName,
             String constantSuffix)
     {
         StringBuffer constantName = new StringBuffer();

         for (int i = 0; i < propertyName.length(); i++)
         {
             char ch = propertyName.charAt(i);
             if (i > 0 && Character.isUpperCase(ch)
                     && Character.isLowerCase(propertyName.charAt(i - 1)))
             {
                 constantName.append('_');
             }
             ch = Character.toUpperCase(ch);
             constantName.append(ch);
         }

         if (constantSuffix != null)
         {
             constantName.append(constantSuffix);
         }

         return constantName.toString();
     }

     static public String getPropertyClass(PropertyMeta property)
     {
         String propertyFullClass = property.getClassName();
         String propertyClass = MyfacesUtils
                 .getClassFromFullClass(propertyFullClass);
         /*
         String[] genericTypes = property.getPropertyClassParameters();
         if(genericTypes != null && genericTypes.length > 0)
         {
           StringBuffer buffer = new StringBuffer(60);
           buffer.append(propertyClass);
           buffer.append('<');
           int max = genericTypes.length - 1;
           for(int i = 0; i <= max; i++)
           {
             _buildPropertyClass(buffer, genericTypes[i]);
             if(i < max)
             {
               buffer.append(", ");
             }
           }
           buffer.append('>');

           propertyClass = buffer.toString();
         }*/

         return propertyClass;
     }

     static public String getMethodNameFromEvent(String methodPrefix,
             String eventName, String methodSuffix)
     {
         return methodPrefix + Character.toUpperCase(eventName.charAt(0))
                 + eventName.substring(1) + methodSuffix;
     }

     static public String getEventNameFromEventType(String eventFullClass)
     {
         String eventName = getClassFromFullClass(eventFullClass);
         return Character.toLowerCase(eventName.charAt(0))
                 + eventName.substring(1, eventName.length());
     }

     /*
     static public String getAlternatePropertyClass(PropertyMeta property)
     {
       StringBuffer buffer = new StringBuffer(60);
       _buildPropertyClass(buffer, property.getAlternateClass());

       return buffer.toString();
     }
     */

     static public String primitiveDefaultValue(String className)
     {
         if ("boolean".equals(className))
         {
             return "false";
         }
         else if ("byte".equals(className))
         {
             return "0";
         }
         else if ("char".equals(className))
         {
             return "''";
         }
         else if ("double".equals(className))
         {
             return "0.0d";
         }
         else if ("float".equals(className))
         {
             return "0.0f";
         }
         else if ("int".equals(className))
         {
             return "0";
         }
         else if ("long".equals(className))
         {
             return "0L";
         }
         else if ("short".equals(className))
         {
             return "0";
         }
         else
         {
             return className;
         }
     }

     static public String fill(String base, int length)
     {
         if (base == null || base.length() > length)
         {
             return base;
         }

         StringBuffer filled = new StringBuffer(base);
         for (int i = base.length(); i < length; i++)
         {
             filled.append(' ');
         }
         return filled.toString();
     }

     static public String getVariableFromClass(String className)
     {
         if (className == null)
         {
             return null;
         }

         for (int i = 0; i < className.length(); i++)
         {
             char ch = className.charAt(i);
             if (Character.isLowerCase(ch))
             {
                 if (i > 0)
                 {
                     return Character.toLowerCase(className.charAt(i - 1))
                             + className.substring(i);
                 }
                 break;
             }
         }

         throw new IllegalStateException("Class name \"" + className
                 + "\" does not use initcaps");
     }

     static public String convertStringToLiteral(String value)
     {
         return convertStringToLiteral("String", value);
     }

     static public String convertStringToLiteral(String className, String value)
     {
         if (value == null)
         {
             return null;
         }
         else if ("String".equals(className))
         {
             return "\"" + value.replaceAll("\'", "\\'") + "\"";
         }
         else if ("Number".equals(className))
         {
             // Double vs. Integer.
             if (value.indexOf(".") == -1)
             {
                 return "Integer.valueOf(" + value + ")";
             }
             else
             {
                 return "Double.valueOf(" + value + ")";
             }
         }
         else
         {
             return value;
         }
     }

     static public String getDefaultValue(PropertyMeta property)
     {
         String propertyFullClass = property.getClassName();
         String def = property.getDefaultValue();
         if (def == null || def.length() == 0)
         {
             return null;
         }
         if (isPrimitiveClass(propertyFullClass))
         {
             return def;
         }
         else if ("java.lang.String".equals(propertyFullClass))
         {
             if (def.startsWith("\"") && def.endsWith("\""))
             {
                 return def;
             }
             else
             {
                 return "\"" + def + "\"";
             }
         }
         else
         {
             //Any other class, so we return the default value
             return def;
         }
     }

     public static String getDefaultValueField(PropertyMeta property)
     {
         String def =  getDefaultValue(property);

         if (property.getClassName().endsWith("Boolean") && def != null)
         {
                 def = "Boolean.valueOf("+def+")";
         }
         return def;
     }

     static private void _buildPropertyClass(StringBuffer buffer, String type)
     {
         Matcher matcher = _GENERIC_TYPE.matcher(type);
         if (matcher.matches())
         {
             // Generic type
             buffer.append(MyfacesUtils.getClassFromFullClass(matcher.group(1)));
             buffer.append('<');
             String[] types = matcher.group(2).split(",");
             int max = types.length - 1;
             for (int i = 0; i <= max; i++)
             {
                 _buildPropertyClass(buffer, types[i]);
                 if (i < max)
                 {
                     buffer.append(", ");
                 }
             }
             buffer.append('>');
         }
         else
         {
             // Non-generic type
             buffer.append(MyfacesUtils.getClassFromFullClass(type));
         }
     }

 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you 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.apache.myfaces.buildtools.maven2.plugin.builder.utils;

	import java.io.File;
	import java.util.Collections;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.Set;
	import java.util.TreeSet;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;

	import org.apache.commons.lang.StringUtils;
	import org.apache.myfaces.buildtools.maven2.plugin.builder.model.ComponentMeta;
	import org.apache.myfaces.buildtools.maven2.plugin.builder.model.MethodSignatureMeta;
	import org.apache.myfaces.buildtools.maven2.plugin.builder.model.PropertyMeta;

	import org.apache.myfaces.buildtools.maven2.plugin.builder.model.PropertyHolder;

	/**
	* Collection of useful utility methods.
	* <p>
	* An instance of this type is made available to the templates used to generate
	* output files, so that they can call these useful methods.
	*/
	public class MyfacesUtils
	{
	public MyfacesUtils()
	{
	}

	public static String getPrefixedPropertyName(String prefix,
	String propertyName)
	{
	return prefix + Character.toUpperCase(propertyName.charAt(0))
	+ propertyName.substring(1);
	}

	/**
	* Convert h:commandButton to commandButton
	*
	* @param prefixedName
	* @return
	*/
	public static String getTagName(String prefixedName)
	{
	return prefixedName.substring(prefixedName.indexOf(':')+1);
	}

	public static String getTagPrefix(String prefixedName)
	{
	return prefixedName.substring(0,prefixedName.indexOf(':'));
	}

	public static String getJspPropertyType11(PropertyMeta property)
	{
	// if (property.isMethodExpression())
	// return "MethodBinding";

	// if (property.isMethodBinding())
	// return "MethodBinding";
	//On 1.1 all properties is mapped as String
	return "String";
	}

	public static String getFullJspPropertyType11(PropertyMeta property)
	{
	if (property.isMethodExpression())
	{
	return "javax.faces.el.MethodBinding";
	}

	if (property.isMethodBinding())
	{
	return "javax.faces.el.MethodBinding";
	}

	return "java.lang.String";
	}


	public static String getJspPropertyType12(PropertyMeta property)
	{
	if (property.getJspName().equals("actionListener"))
	{
	return "javax.el.MethodExpression";
	}
	if (property.getJspName().equals("validator"))
	{
	return "javax.el.MethodExpression";
	}
	if (property.getJspName().equals("valueChangeListener"))
	{
	return "javax.el.MethodExpression";
	}

	if (property.isMethodExpression())
	{
	return "MethodExpression";
	}

	if (property.isMethodBinding())
	{
	return "MethodBinding";
	}

	if (!property.isLiteralOnly().booleanValue())
	{
	return "ValueExpression";
	}
	else
	{
	return property.getClassName();
	}
	}

	public static String getVariableFromName(String name)
	{
	if (name == null)
	{
	return null;
	}

	if (RESERVED_WORDS.contains(name))
	{
	name = name + "Param";
	}

	return name;
	}

	// TODO: perhaps this could just return a list of class names for
	// templates to iterate over, rather than building the text itself?
	//
	// TODO: why are we importing tag classes into components anyway?
	public static String importTagClasses(PropertyHolder component)
	{
	Set imports = new HashSet();
	for (Iterator it = component.properties(); it.hasNext();)
	{
	PropertyMeta property = (PropertyMeta) it.next();
	if (property.getClassName() != null &&
	!PRIMITIVE_TYPES.contains(property.getClassName()))
	{
	if (!property.getClassName().startsWith("java.lang"))
	{
	imports.add(property.getClassName());
	}
	}
	}

	StringBuffer value = new StringBuffer();

	for (Iterator importIterator = imports.iterator(); importIterator
	.hasNext();)
	{
	value.append("import ");
	value.append((String) importIterator.next());
	value.append(';');
	value.append('\n');
	}

	return value.toString();
	}

	public static String importTagClasses12(ComponentMeta component)
	{
	Set imports = new HashSet();
	for (Iterator it = component.properties(); it.hasNext();)
	{
	PropertyMeta property = (PropertyMeta) it.next();
	if (property.getClassName() != null &&
	!PRIMITIVE_TYPES.contains(property.getClassName()))
	{
	if (!property.getClassName().startsWith("java.lang"))
	{
	imports.add(property.getClassName());
	}
	}
	if (property.getJspName().equals("actionListener"))
	{
	imports.add("javax.faces.event.MethodExpressionActionListener");
	}
	if (property.getJspName().equals("valueChangeListener"))
	{
	imports.add("javax.faces.event.MethodExpressionValueChangeListener");
	}
	if (property.getJspName().equals("validator"))
	{
	imports.add("javax.faces.validator.MethodExpressionValidator");
	}
	}

	StringBuffer value = new StringBuffer();

	for (Iterator importIterator = imports.iterator(); importIterator
	.hasNext();)
	{
	value.append("import ");
	value.append((String) importIterator.next());
	value.append(';');
	value.append('\n');
	}

	return value.toString();
	}


	public static boolean isConverter(String propClass)
	{
	return ("javax.faces.convert.Converter".equals(propClass));
	}

	public static boolean isList(String propClass)
	{
	if (propClass == null)
	{
	return false;
	}
	else if(StringUtils.contains(propClass, "List"))
	{
	return true;
	}
	else
	{
	return false;
	}
	}

	public static String castIfNecessary(String propClass)
	{
	if (propClass.equals("Object") \|\| propClass.equals("java.lang.Object"))
	{
	return "";
	}

	if (isPrimitiveClass(propClass))
	{
	propClass = getBoxedClass(propClass);
	}

	return "(" + propClass + ")";
	}

	public static String getBoxedClass(String className)
	{
	if ("boolean".equals(className))
	{
	return "Boolean";
	}
	else if ("byte".equals(className))
	{
	return "Byte";
	}
	else if ("char".equals(className))
	{
	return "Character";
	}
	else if ("double".equals(className))
	{
	return "Double";
	}
	else if ("float".equals(className))
	{
	return "Float";
	}
	else if ("int".equals(className))
	{
	return "Integer";
	}
	else if ("long".equals(className))
	{
	return "Long";
	}
	else if ("short".equals(className))
	{
	return "Short";
	}
	else
	{
	return className;
	}
	}

	public static String getSignatureParams(MethodSignatureMeta signature)
	{
	String[] paramTypes = (signature != null) ? signature.getParameterTypes() : null;

	String classArray;

	if (paramTypes == null \|\| paramTypes.length == 0)
	{
	classArray = "new Class[0]";
	}
	else
	{
	StringBuffer sb = new StringBuffer();
	sb.append("new Class[]{");
	for (int i = 0; i < paramTypes.length; i++)
	{
	if (i > 0)
	{
	sb.append(',');
	}
	sb.append(paramTypes[i]);
	sb.append(".class");
	}

	// TODO: remove trailing comma
	sb.append(',');

	sb.append('}');
	classArray = sb.toString();
	}
	return classArray;
	}

	public static boolean isStringMethodBindingReturnType(MethodSignatureMeta sig)
	{
	return (sig != null && "java.lang.String".equals(sig.getReturnType()));
	}

	static public String getMethodReaderFromProperty(String propertyName,
	String propertyClass)
	{
	String methodPrefix = ("boolean".equals(propertyClass) ? "is" : "get");
	return getPrefixedPropertyName(methodPrefix, propertyName);
	}

	public static String getPrimitiveType(String className)
	{
	if (className.startsWith("java.lang."))
	{
	className = StringUtils.replace(className, "java.lang.", "");
	}

	if (className.endsWith("eger"))
	{
	className = StringUtils.replace(className, "eger", "");
	}

	if (MyfacesUtils.isPrimitiveClass(className.toLowerCase()))
	{
	return className.toLowerCase();
	}
	else
	{
	return className;
	}
	}

	public static boolean isPrimitiveClass(String className)
	{
	return "boolean".equals(className) \|\| "byte".equals(className)
	\|\| "char".equals(className) \|\| "double".equals(className)
	\|\| "float".equals(className) \|\| "int".equals(className)
	\|\| "long".equals(className) \|\| "short".equals(className);
	}

	private static Set _createPrimitiveTypesSet()
	{
	Set primitives = new TreeSet();
	for (int i = 0; i < _PRIMITIVE_TYPES.length; i++)
	{
	String type = _PRIMITIVE_TYPES[i];
	primitives.add(type);
	primitives.add(type + "[]");
	}
	return Collections.unmodifiableSet(primitives);
	}

	private static Set _createReservedWordsSet()
	{
	Set reserved = new TreeSet();
	for (int i = 0; i < _RESERVED_WORDS.length; i++)
	{
	String keyword = _RESERVED_WORDS[i];
	reserved.add(keyword);
	}
	return Collections.unmodifiableSet(reserved);
	}

	static private final String[] _PRIMITIVE_TYPES = new String[] {
	// TODO: Shouldn't java.lang.* be specified in that list as well?
	"boolean", "byte", "char", "float", "double", "int", "short", "long", };

	static private final String[] _RESERVED_WORDS = new String[] { "abstract",
	"assert", "boolean", "break", "byte", "case", "catch", "char",
	"class", "const", "continue", "default", "do", "double", "else",
	"extends", "final", "finally", "float", "for", "goto", "if",
	"implements", "import", "instanceof", "int", "interface", "long",
	"native", "new", "package", "private", "protected", "public",
	"return", "short", "static", "super", "switch", "synchronized",
	"this", "throw", "throws", "transient", "try", "void", "volatile",
	"while", };

	static public final Set RESERVED_WORDS = _createReservedWordsSet();
	static public final Set PRIMITIVE_TYPES = _createPrimitiveTypesSet();

	static private final Pattern _GENERIC_TYPE = Pattern
	.compile("([^<]+)<(.+)>");

	//UNUSED METHODS


	static public String convertClassToSourcePath(String className,
	String fileExtension)
	{
	return (className.replace('.', File.separatorChar) + fileExtension);
	}

	static public boolean isFullClass(String className)
	{
	return (className != null && className.indexOf('.') != -1);
	}

	/*
	public static String getGenericsFromProperty(PropertyMeta property){
	String gen = "";
	for (int i = 0; i < property.getAttributeClassParameters().length; i++) {
	if (i>0){
	gen += ",";
	}
	gen += getClassFromFullClass(property.getAttributeClassParameters()[i]);
	}
	return (gen.length() > 0?"<"+gen+">":gen);
	}
	*/

	/**
	* Extract the simple class name from a fully-qualified classname.
	* <p>
	* Given a string like "org.apache.Foo", this method returns "Foo".
	*/
	static public String getClassFromFullClass(String fullClass)
	{
	if (fullClass == null)
	{
	return null;
	}

	int lastSep = fullClass.lastIndexOf('.');
	// Note: this code also works for the empty package
	return (fullClass.substring(lastSep + 1));
	}

	static public String getPackageFromFullClass(String fullClass)
	{
	if (fullClass == null)
	{
	return null;
	}

	int lastSep = fullClass.lastIndexOf('.');

	// detect the empty package
	if (lastSep == -1)
	{
	return "";
	}

	return (fullClass.substring(0, lastSep));
	}

	static public String getConstantNameFromProperty(String propertyName)
	{
	return getConstantNameFromProperty(propertyName, null);
	}

	static public String getConstantNameFromProperty(String propertyName,
	String constantSuffix)
	{
	StringBuffer constantName = new StringBuffer();

	for (int i = 0; i < propertyName.length(); i++)
	{
	char ch = propertyName.charAt(i);
	if (i > 0 && Character.isUpperCase(ch)
	&& Character.isLowerCase(propertyName.charAt(i - 1)))
	{
	constantName.append('_');
	}
	ch = Character.toUpperCase(ch);
	constantName.append(ch);
	}

	if (constantSuffix != null)
	{
	constantName.append(constantSuffix);
	}

	return constantName.toString();
	}

	static public String getPropertyClass(PropertyMeta property)
	{
	String propertyFullClass = property.getClassName();
	String propertyClass = MyfacesUtils
	.getClassFromFullClass(propertyFullClass);
	/*
	String[] genericTypes = property.getPropertyClassParameters();
	if(genericTypes != null && genericTypes.length > 0)
	{
	StringBuffer buffer = new StringBuffer(60);
	buffer.append(propertyClass);
	buffer.append('<');
	int max = genericTypes.length - 1;
	for(int i = 0; i <= max; i++)
	{
	_buildPropertyClass(buffer, genericTypes[i]);
	if(i < max)
	{
	buffer.append(", ");
	}
	}
	buffer.append('>');

	propertyClass = buffer.toString();
	}*/

	return propertyClass;
	}

	static public String getMethodNameFromEvent(String methodPrefix,
	String eventName, String methodSuffix)
	{
	return methodPrefix + Character.toUpperCase(eventName.charAt(0))
	+ eventName.substring(1) + methodSuffix;
	}

	static public String getEventNameFromEventType(String eventFullClass)
	{
	String eventName = getClassFromFullClass(eventFullClass);
	return Character.toLowerCase(eventName.charAt(0))
	+ eventName.substring(1, eventName.length());
	}

	/*
	static public String getAlternatePropertyClass(PropertyMeta property)
	{
	StringBuffer buffer = new StringBuffer(60);
	_buildPropertyClass(buffer, property.getAlternateClass());

	return buffer.toString();
	}
	*/

	static public String primitiveDefaultValue(String className)
	{
	if ("boolean".equals(className))
	{
	return "false";
	}
	else if ("byte".equals(className))
	{
	return "0";
	}
	else if ("char".equals(className))
	{
	return "''";
	}
	else if ("double".equals(className))
	{
	return "0.0d";
	}
	else if ("float".equals(className))
	{
	return "0.0f";
	}
	else if ("int".equals(className))
	{
	return "0";
	}
	else if ("long".equals(className))
	{
	return "0L";
	}
	else if ("short".equals(className))
	{
	return "0";
	}
	else
	{
	return className;
	}
	}

	static public String fill(String base, int length)
	{
	if (base == null \|\| base.length() > length)
	{
	return base;
	}

	StringBuffer filled = new StringBuffer(base);
	for (int i = base.length(); i < length; i++)
	{
	filled.append(' ');
	}
	return filled.toString();
	}

	static public String getVariableFromClass(String className)
	{
	if (className == null)
	{
	return null;
	}

	for (int i = 0; i < className.length(); i++)
	{
	char ch = className.charAt(i);
	if (Character.isLowerCase(ch))
	{
	if (i > 0)
	{
	return Character.toLowerCase(className.charAt(i - 1))
	+ className.substring(i);
	}
	break;
	}
	}

	throw new IllegalStateException("Class name \"" + className
	+ "\" does not use initcaps");
	}

	static public String convertStringToLiteral(String value)
	{
	return convertStringToLiteral("String", value);
	}

	static public String convertStringToLiteral(String className, String value)
	{
	if (value == null)
	{
	return null;
	}
	else if ("String".equals(className))
	{
	return "\"" + value.replaceAll("\'", "\\'") + "\"";
	}
	else if ("Number".equals(className))
	{
	// Double vs. Integer.
	if (value.indexOf(".") == -1)
	{
	return "Integer.valueOf(" + value + ")";
	}
	else
	{
	return "Double.valueOf(" + value + ")";
	}
	}
	else
	{
	return value;
	}
	}

	static public String getDefaultValue(PropertyMeta property)
	{
	String propertyFullClass = property.getClassName();
	String def = property.getDefaultValue();
	if (def == null \|\| def.length() == 0)
	{
	return null;
	}
	if (isPrimitiveClass(propertyFullClass))
	{
	return def;
	}
	else if ("java.lang.String".equals(propertyFullClass))
	{
	if (def.startsWith("\"") && def.endsWith("\""))
	{
	return def;
	}
	else
	{
	return "\"" + def + "\"";
	}
	}
	else
	{
	//Any other class, so we return the default value
	return def;
	}
	}

	public static String getDefaultValueField(PropertyMeta property)
	{
	String def = getDefaultValue(property);

	if (property.getClassName().endsWith("Boolean") && def != null)
	{
	def = "Boolean.valueOf("+def+")";
	}
	return def;
	}

	static private void _buildPropertyClass(StringBuffer buffer, String type)
	{
	Matcher matcher = _GENERIC_TYPE.matcher(type);
	if (matcher.matches())
	{
	// Generic type
	buffer.append(MyfacesUtils.getClassFromFullClass(matcher.group(1)));
	buffer.append('<');
	String[] types = matcher.group(2).split(",");
	int max = types.length - 1;
	for (int i = 0; i <= max; i++)
	{
	_buildPropertyClass(buffer, types[i]);
	if (i < max)
	{
	buffer.append(", ");
	}
	}
	buffer.append('>');
	}
	else
	{
	// Non-generic type
	buffer.append(MyfacesUtils.getClassFromFullClass(type));
	}
	}

	}