axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From aj...@apache.org
Subject svn commit: r306583 [8/9] - in /webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2: databinding/ databinding/gen/ databinding/gen/impl/ databinding/symbolTable/ databinding/toJava/ databinding/utils/ databinding/utils/support/ wsdl/codeg...
Date Thu, 06 Oct 2005 10:55:27 GMT
Added: webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/utils/JavaUtils.java
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/utils/JavaUtils.java?rev=306583&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/utils/JavaUtils.java (added)
+++ webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/utils/JavaUtils.java Thu Oct  6 03:54:18 2005
@@ -0,0 +1,1349 @@
+/*
+ * 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.
+ */
+
+package org.apache.axis2.databinding.utils;
+
+
+//import org.apache.axis.attachments.AttachmentPart;
+//import org.apache.axis.attachments.OctetStream;
+//import org.apache.axis.components.image.ImageIO;
+//import org.apache.axis.components.image.ImageIOFactory;
+//import org.apache.axis.components.logger.LogFactory;
+//import org.apache.axis.types.HexBinary;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+//import javax.activation.DataHandler;
+//import javax.xml.soap.SOAPException;
+import javax.xml.transform.Source;
+import javax.xml.transform.stream.StreamSource;
+import java.awt.*;
+import java.beans.Introspector;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.StringReader;
+import java.io.ByteArrayOutputStream;
+import java.lang.reflect.Array;
+import java.lang.reflect.Field;
+import java.text.Collator;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Collection;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+
+/** Utility class to deal with Java language related issues, such
+ * as type conversions.
+ *
+ * @author Glen Daniels (gdaniels@apache.org)
+ */
+public class JavaUtils
+{
+    private JavaUtils() {
+    }
+
+    protected static Log log =
+        LogFactory.getLog(JavaUtils.class.getName());
+    
+    public static final char NL = '\n';
+
+    public static final char CR = '\r';
+
+    /**
+     * The prefered line separator
+     */
+    public static final String LS = System.getProperty("line.separator",
+                                                       (new Character(NL)).toString());
+
+
+    public static Class getWrapperClass(Class primitive)
+    {
+        if (primitive == int.class)
+            return java.lang.Integer.class;
+        else if (primitive == short.class)
+            return java.lang.Short.class;
+        else if (primitive == boolean.class)
+            return java.lang.Boolean.class;
+        else if (primitive == byte.class)
+            return java.lang.Byte.class;
+        else if (primitive == long.class)
+            return java.lang.Long.class;
+        else if (primitive == double.class)
+            return java.lang.Double.class;
+        else if (primitive == float.class)
+            return java.lang.Float.class;
+        else if (primitive == char.class)
+            return java.lang.Character.class;
+        
+        return null;
+    }
+    
+    public static String getWrapper(String primitive)
+    {
+        if (primitive.equals("int"))
+            return "Integer";
+        else if (primitive.equals("short"))
+            return "Short";
+        else if (primitive.equals("boolean"))
+            return "Boolean";
+        else if (primitive.equals("byte"))
+            return "Byte";
+        else if (primitive.equals("long"))
+            return "Long";
+        else if (primitive.equals("double"))
+            return "Double";
+        else if (primitive.equals("float"))
+            return "Float";
+        else if (primitive.equals("char"))
+            return "Character";
+        
+        return null;
+    }
+
+    public static Class getPrimitiveClass(Class wrapper)
+    {
+        if (wrapper == java.lang.Integer.class)
+            return int.class;
+        else if (wrapper == java.lang.Short.class)
+            return short.class;
+        else if (wrapper == java.lang.Boolean.class)
+            return boolean.class;
+        else if (wrapper == java.lang.Byte.class)
+            return byte.class;
+        else if (wrapper == java.lang.Long.class)
+            return long.class;
+        else if (wrapper == java.lang.Double.class)
+            return double.class;
+        else if (wrapper == java.lang.Float.class)
+            return float.class;
+        else if (wrapper == java.lang.Character.class)
+            return char.class;
+        
+        return null;
+    }
+
+    /*
+         * Any builtin type that has a constructor that takes a String is a basic
+         * type.
+         * This is for optimization purposes, so that we don't introspect
+         * primitive java types or some basic Axis types.
+         */
+    public static boolean isBasic(Class javaType) {
+        return (javaType.isPrimitive() ||
+                javaType == String.class ||
+                javaType == Boolean.class ||
+                javaType == Float.class ||
+                javaType == Double.class ||
+                Number.class.isAssignableFrom(javaType));// ||
+//                javaType == org.apache.axis.types.Day.class ||
+//                javaType == org.apache.axis.types.Duration.class ||
+//                javaType == org.apache.axis.types.Entities.class ||
+//                javaType == org.apache.axis.types.Entity.class ||
+//                javaType == HexBinary.class ||
+//                javaType == org.apache.axis.types.Id.class ||
+//                javaType == org.apache.axis.types.IDRef.class ||
+//                javaType == org.apache.axis.types.IDRefs.class ||
+//                javaType == org.apache.axis.types.Language.class ||
+//                javaType == org.apache.axis.types.Month.class ||
+//                javaType == org.apache.axis.types.MonthDay.class ||
+//                javaType == org.apache.axis.types.Name.class ||
+//                javaType == org.apache.axis.types.NCName.class ||
+//                javaType == org.apache.axis.types.NegativeInteger.class ||
+//                javaType == org.apache.axis.types.NMToken.class ||
+//                javaType == org.apache.axis.types.NMTokens.class ||
+//                javaType == org.apache.axis.types.NonNegativeInteger.class ||
+//                javaType == org.apache.axis.types.NonPositiveInteger.class ||
+//                javaType == org.apache.axis.types.NormalizedString.class ||
+//                javaType == org.apache.axis.types.PositiveInteger.class ||
+//                javaType == org.apache.axis.types.Time.class ||
+//                javaType == org.apache.axis.types.Token.class ||
+//                javaType == org.apache.axis.types.UnsignedByte.class ||
+//                javaType == org.apache.axis.types.UnsignedInt.class ||
+//                javaType == org.apache.axis.types.UnsignedLong.class ||
+//                javaType == org.apache.axis.types.UnsignedShort.class ||
+//                javaType == org.apache.axis.types.URI.class ||
+//                javaType == org.apache.axis.types.Year.class ||
+//                javaType == org.apache.axis.types.YearMonth.class);
+    }
+
+    /**
+     * It the argument to the convert(...) method implements
+     * the ConvertCache interface, the convert(...) method
+     * will use the set/get methods to store and retrieve
+     * converted values.
+     **/
+    public interface ConvertCache {
+        /**
+         * Set/Get converted values of the convert method.
+         **/
+        public void setConvertedValue(Class cls, Object value);
+        public Object getConvertedValue(Class cls);
+        /**
+         * Get the destination array class described by the xml
+         **/
+        public Class getDestClass();
+    }
+
+//    /** Utility function to convert an Object to some desired Class.
+//     *
+//     * Right now this works for:
+//     *     arrays <-> Lists,
+//     *     Holders <-> held values
+//     * @param arg the array to convert
+//     * @param destClass the actual class we want
+//     */
+//    public static Object convert(Object arg, Class destClass)
+//    {
+//        if (destClass == null) {
+//            return arg;
+//        }
+//
+//        Class argHeldType = null;
+//        if (arg != null) {
+//            argHeldType = getHolderValueType(arg.getClass());
+//        }
+//
+//        if (arg != null && argHeldType == null && destClass.isAssignableFrom(arg.getClass())) {
+//            return arg;
+//        }
+//
+//        if (log.isDebugEnabled()) {
+//            String clsName = "null";
+//            if (arg != null) clsName = arg.getClass().getName();
+////            log.debug( Messages.getMessage("convert00", clsName, destClass.getName()));
+//        }
+//
+//        // See if a previously converted value is stored in the argument.
+//        Object destValue = null;
+//        if (arg instanceof ConvertCache) {
+//            destValue = (( ConvertCache) arg).getConvertedValue(destClass);
+//            if (destValue != null)
+//                return destValue;
+//        }
+//
+//        // Get the destination held type or the argument held type if they exist
+//        Class destHeldType = getHolderValueType(destClass);
+//
+//        // Convert between Axis special purpose HexBinary and byte[]
+//        if (arg instanceof HexBinary &&
+//            destClass == byte[].class) {
+//            return ((HexBinary) arg).getBytes();
+//        } else if (arg instanceof byte[] &&
+//                   destClass == HexBinary.class) {
+//            return new HexBinary((byte[]) arg);
+//        }
+//
+//        // Convert between Calendar and Date
+//        if (arg instanceof Calendar && destClass == Date.class) {
+//            return ((Calendar) arg).getTime();
+//        }
+//        if (arg instanceof Date && destClass == Calendar.class) {
+//        	Calendar calendar = Calendar.getInstance();
+//        	calendar.setTime((Date) arg);
+//            return calendar;
+//        }
+//
+//        // Convert between Calendar and java.sql.Date
+//        if (arg instanceof Calendar && destClass == java.sql.Date.class) {
+//            return new java.sql.Date(((Calendar) arg).getTime().getTime());
+//        }
+//
+//        // Convert between HashMap and Hashtable
+//        if (arg instanceof HashMap && destClass == Hashtable.class) {
+//            return new Hashtable((HashMap)arg);
+//        }
+//
+//        // Convert an AttachmentPart to the given destination class.
+//        if (isAttachmentSupported() &&
+//                (arg instanceof InputStream || arg instanceof AttachmentPart || arg instanceof DataHandler)) {
+//            try {
+//                String destName = destClass.getName();
+//                if (destClass == String.class
+//                        || destClass == OctetStream.class
+//                        || destClass == byte[].class
+//                        || destClass == Image.class
+//                        || destClass == Source.class
+//                        || destClass == DataHandler.class
+//                        || destName.equals("javax.mail.internet.MimeMultipart")) {
+//                    DataHandler handler = null;
+//                    if (arg instanceof AttachmentPart) {
+//                        handler = ((AttachmentPart) arg).getDataHandler();
+//                    }
+//                    else if (arg instanceof DataHandler) {
+//                        handler = (DataHandler) arg;
+//                    }
+//                    if (destClass == Image.class) {
+//                        // Note:  An ImageIO component is required to process an Image
+//                        // attachment, but if the image would be null
+//                        // (is.available == 0) then ImageIO component isn't needed
+//                        // and we can return null.
+//                        InputStream is = (InputStream) handler.getContent();
+//                        if (is.available() == 0) {
+//                            return null;
+//                        }
+//                        else {
+//                            ImageIO imageIO = ImageIOFactory.getImageIO();
+//                            if (imageIO != null) {
+//                                return getImageFromStream(is);
+//                            }
+//                            else {
+//                                log.info(Messages.getMessage("needImageIO"));
+//                                return arg;
+//                            }
+//                        }
+//                    }
+//                    else if (destClass == javax.xml.transform.Source.class) {
+//                        // For a reason unknown to me, the handler's
+//                        // content is a String.  Convert it to a
+//                        // StreamSource.
+//                        return new StreamSource(new StringReader(
+//                                (String) handler.getContent()));
+//                    }
+//                    else if (destClass == OctetStream.class || destClass == byte[].class) {
+//                        InputStream in = null;
+//                        if (arg instanceof InputStream) {
+//                            in = (InputStream) arg;
+//                        } else {
+//                            in = (InputStream)handler.getContent();
+//                        }
+//                        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+//                        int byte1 = -1;
+//                        while((byte1 = in.read())!=-1)
+//                            baos.write(byte1);
+//                        return new OctetStream(baos.toByteArray());
+//                    }
+//                    else if (destClass == DataHandler.class) {
+//                        return handler;
+//                    }
+//                    else {
+//                        return handler.getContent();
+//                    }
+//                }
+//            }
+//            catch (IOException ioe) {
+//            }
+//            catch (SOAPException se) {
+//            }
+//        }
+//
+//        // If the destination is an array and the source
+//        // is a suitable component, return an array with
+//        // the single item.
+//        if (arg != null &&
+//            destClass.isArray() &&
+//            !destClass.getComponentType().equals(Object.class) &&
+//            destClass.getComponentType().isAssignableFrom(arg.getClass())) {
+//            Object array =
+//                Array.newInstance(destClass.getComponentType(), 1);
+//            Array.set(array, 0, arg);
+//            return array;
+//        }
+//
+//        // in case destClass is array and arg is ArrayOfT class. (ArrayOfT -> T[])
+//        if (arg != null && destClass.isArray()) {
+//            Object newArg = ArrayUtil.convertObjectToArray(arg, destClass);
+//            if (newArg == null
+//                    || (newArg != ArrayUtil.NON_CONVERTABLE && newArg != arg)) {
+//                return newArg;
+//            }
+//        }
+//
+//        // in case arg is ArrayOfT and destClass is an array. (T[] -> ArrayOfT)
+//        if (arg != null && arg.getClass().isArray()) {
+//            Object newArg = ArrayUtil.convertArrayToObject(arg, destClass);
+//            if (newArg != null)
+//                return newArg;
+//        }
+//
+//        // Return if no conversion is available
+//        if (!(arg instanceof Collection ||
+//              (arg != null && arg.getClass().isArray())) &&
+//            ((destHeldType == null && argHeldType == null) ||
+//             (destHeldType != null && argHeldType != null))) {
+//            return arg;
+//        }
+//
+//        // Take care of Holder conversion
+//        if (destHeldType != null) {
+//            // Convert arg into Holder holding arg.
+//            Object newArg = convert(arg, destHeldType);
+//            Object argHolder = null;
+//            try {
+//                argHolder = destClass.newInstance();
+//                setHolderValue(argHolder, newArg);
+//                return argHolder;
+//            } catch (Exception e) {
+//                return arg;
+//            }
+//        } else if (argHeldType != null) {
+//            // Convert arg into the held type
+//            try {
+//                Object newArg = getHolderValue(arg);
+//                return convert(newArg, destClass);
+//            } catch (HolderException e) {
+//                return arg;
+//            }
+//        }
+//
+//        // Flow to here indicates that neither arg or destClass is a Holder
+//
+//        // Check to see if the argument has a prefered destination class.
+//        if (arg instanceof ConvertCache &&
+//            (( ConvertCache) arg).getDestClass() != destClass) {
+//            Class hintClass = ((ConvertCache) arg).getDestClass();
+//            if (hintClass != null &&
+//                hintClass.isArray() &&
+//                destClass.isArray() &&
+//                destClass.isAssignableFrom(hintClass)) {
+//                destClass = hintClass;
+//                destValue = ((ConvertCache) arg).getConvertedValue(destClass);
+//                if (destValue != null)
+//                    return destValue;
+//            }
+//        }
+//
+//        if (arg == null) {
+//            return arg;
+//        }
+//
+//        // The arg may be an array or List
+//        int length = 0;
+//        if (arg.getClass().isArray()) {
+//            length = Array.getLength(arg);
+//        } else {
+//            length = ((Collection) arg).size();
+//        }
+//        if (destClass.isArray()) {
+//            if (destClass.getComponentType().isPrimitive()) {
+//
+//                Object array = Array.newInstance(destClass.getComponentType(),
+//                                                 length);
+//                // Assign array elements
+//                if (arg.getClass().isArray()) {
+//                    for (int i = 0; i < length; i++) {
+//                        Array.set(array, i, Array.get(arg, i));
+//                    }
+//                } else {
+//                    int idx = 0;
+//                    for (Iterator i = ((Collection)arg).iterator();
+//                            i.hasNext();) {
+//                        Array.set(array, idx++, i.next());
+//                    }
+//                }
+//                destValue = array;
+//
+//            } else {
+//                Object [] array;
+//                try {
+//                    array = (Object [])Array.newInstance(destClass.getComponentType(),
+//                                                         length);
+//                } catch (Exception e) {
+//                    return arg;
+//                }
+//
+//                // Use convert to assign array elements.
+//                if (arg.getClass().isArray()) {
+//                    for (int i = 0; i < length; i++) {
+//                        array[i] = convert(Array.get(arg, i),
+//                                           destClass.getComponentType());
+//                    }
+//                } else {
+//                    int idx = 0;
+//                    for (Iterator i = ((Collection)arg).iterator();
+//                            i.hasNext();) {
+//                        array[idx++] = convert(i.next(),
+//                                           destClass.getComponentType());
+//                    }
+//                }
+//                destValue = array;
+//            }
+//        }
+//        else if (Collection.class.isAssignableFrom(destClass)) {
+//            Collection newList = null;
+//            try {
+//                // if we are trying to create an interface, build something
+//                // that implements the interface
+//                if (destClass == Collection.class || destClass == List.class) {
+//                    newList = new ArrayList();
+//                } else if (destClass == Set.class) {
+//                    newList = new HashSet();
+//                } else {
+//                    newList = (Collection)destClass.newInstance();
+//                }
+//            } catch (Exception e) {
+//                // Couldn't build one for some reason... so forget it.
+//                return arg;
+//            }
+//
+//            if (arg.getClass().isArray()) {
+//                for (int j = 0; j < length; j++) {
+//                    newList.add(Array.get(arg, j));
+//                }
+//            } else {
+//                for (Iterator j = ((Collection)arg).iterator();
+//                            j.hasNext();) {
+//                    newList.add(j.next());
+//                }
+//            }
+//            destValue = newList;
+//        }
+//        else {
+//            destValue = arg;
+//        }
+//
+//        // Store the converted value in the argument if possible.
+//        if (arg instanceof ConvertCache) {
+//            (( ConvertCache) arg).setConvertedValue(destClass, destValue);
+//        }
+//        return destValue;
+//    }
+
+//    public static boolean isConvertable(Object obj, Class dest)
+//    {
+//        return isConvertable(obj, dest, false);
+//    }
+//
+//    public static boolean isConvertable(Object obj, Class dest, boolean isEncoded)
+//    {
+//        Class src = null;
+//
+//        if (obj != null) {
+//            if (obj instanceof Class) {
+//                src = (Class)obj;
+//            } else {
+//                src = obj.getClass();
+//            }
+//        } else {
+//            if(!dest.isPrimitive())
+//                return true;
+//        }
+//
+//        if (dest == null)
+//            return false;
+//
+//        if (src != null) {
+//            // If we're directly assignable, we're good.
+//            if (dest.isAssignableFrom(src))
+//                return true;
+//
+//            //Allow mapping of Map's to Map's
+//            if (java.util.Map.class.isAssignableFrom(dest) &&
+//                java.util.Map.class.isAssignableFrom(src)) {
+//                  return true;
+//            }
+//
+//            // If it's a wrapping conversion, we're good.
+//            if (getWrapperClass(src) == dest)
+//                return true;
+//            if (getWrapperClass(dest) == src)
+//                return true;
+//
+//            // If it's List -> Array or vice versa, we're good.
+//            if ((Collection.class.isAssignableFrom(src) || src.isArray()) &&
+//                (Collection.class.isAssignableFrom(dest) || dest.isArray()) &&
+//                (src.getComponentType() == Object.class ||
+//                 src.getComponentType() == null ||
+//                 dest.getComponentType() == Object.class ||
+//                 dest.getComponentType() == null ||
+//                 isConvertable(src.getComponentType(), dest.getComponentType())))
+//                    return true;
+//
+//            // If destination is an array, and src is a component, we're good
+//            // if we're not encoded!
+//            if (!isEncoded && dest.isArray() &&
+////                !dest.getComponentType().equals(Object.class) &&
+//                dest.getComponentType().isAssignableFrom(src))
+//                return true;
+//
+//            if ((src == HexBinary.class && dest == byte[].class) ||
+//                (src == byte[].class && dest == HexBinary.class))
+//                return true;
+//
+//            // Allow mapping of Calendar to Date
+//            if (Calendar.class.isAssignableFrom(src) && dest == Date.class)
+//                return true;
+//
+//            // Allow mapping of Date to Calendar
+//            if (Date.class.isAssignableFrom(src) && dest == Calendar.class)
+//                return true;
+//
+//            // Allow mapping of Calendar to java.sql.Date
+//            if (Calendar.class.isAssignableFrom(src) && dest == java.sql.Date.class)
+//                return true;
+//        }
+//
+//        Class destHeld = JavaUtils.getHolderValueType(dest);
+//        // Can always convert a null to an empty holder
+//        if (src == null)
+//            return (destHeld != null);
+//
+//        if (destHeld != null) {
+//            if (destHeld.isAssignableFrom(src) || isConvertable(src, destHeld))
+//                return true;
+//        }
+//
+//        // If it's holder -> held or held -> holder, we're good
+//        Class srcHeld = JavaUtils.getHolderValueType(src);
+//        if (srcHeld != null) {
+//            if (dest.isAssignableFrom(srcHeld) || isConvertable(srcHeld, dest))
+//                return true;
+//        }
+//
+//        // If it's a MIME type mapping and we want a DataHandler,
+//        // then we're good.
+//        if (dest.getName().equals("javax.activation.DataHandler")) {
+//            String name = src.getName();
+//            if (src == String.class
+//                    || src == java.awt.Image.class
+//                    || src == OctetStream.class
+//                    || name.equals("javax.mail.internet.MimeMultipart")
+//                    || name.equals("javax.xml.transform.Source"))
+//                return true;
+//        }
+//
+//        if (src.getName().equals("javax.activation.DataHandler")) {
+//            if (dest ==  byte[].class)
+//                return true;
+//            if (dest.isArray() && dest.getComponentType() == byte[].class)
+//                return true;
+//        }
+//
+//        if (dest.getName().equals("javax.activation.DataHandler")) {
+//            if (src ==  Object[].class)
+//                return true;
+//            if (src.isArray() && src.getComponentType() == Object[].class)
+//                return true;
+//        }
+//
+//        if (obj instanceof java.io.InputStream) {
+//            if (dest ==  OctetStream.class)
+//                return true;
+//        }
+//
+//        if (src.isPrimitive()) {
+//            return isConvertable(getWrapperClass(src),dest);
+//        }
+//
+//        // ArrayOfT -> T[] ?
+//        if (dest.isArray()) {
+//        	if (ArrayUtil.isConvertable(src, dest) == true)
+//        		return true;
+//        }
+//
+//        // T[] -> ArrayOfT ?
+//        if (src.isArray()) {
+//        	if (ArrayUtil.isConvertable(src, dest) == true)
+//        		return true;
+//        }
+//
+//        return false;
+//    }
+//
+//    public static Image getImageFromStream(InputStream is) {
+//        try {
+//            return ImageIOFactory.getImageIO().loadImage(is);
+//        }
+//        catch (Throwable t) {
+//            return null;
+//        }
+//    } // getImageFromStream
+    
+    /**
+     * These are java keywords as specified at the following URL (sorted alphabetically).
+     * http://java.sun.com/docs/books/jls/second_edition/html/lexical.doc.html#229308
+     * Note that false, true, and null are not strictly keywords; they are literal values,
+     * but for the purposes of this array, they can be treated as literals.
+     *    ****** PLEASE KEEP THIS LIST SORTED IN ASCENDING ORDER ******
+     */
+    static final String keywords[] =
+    {
+        "abstract",  "assert",       "boolean",    "break",      "byte",      "case",
+        "catch",     "char",         "class",      "const",     "continue",
+        "default",   "do",           "double",     "else",      "extends",
+        "false",     "final",        "finally",    "float",     "for",
+        "goto",      "if",           "implements", "import",    "instanceof",
+        "int",       "interface",    "long",       "native",    "new",
+        "null",      "package",      "private",    "protected", "public",
+        "return",    "short",        "static",     "strictfp",  "super",
+        "switch",    "synchronized", "this",       "throw",     "throws",
+        "transient", "true",         "try",        "void",      "volatile",
+        "while"
+    };
+
+    /** Collator for comparing the strings */
+    static final Collator englishCollator = Collator.getInstance(Locale.ENGLISH);
+
+    /** Use this character as suffix */
+    static final char keywordPrefix = '_';
+
+    /**
+     * isJavaId
+     * Returns true if the name is a valid java identifier.
+     * @param id to check
+     * @return boolean true/false
+     **/
+    public static boolean isJavaId(String id) {
+        if (id == null || id.equals("") || isJavaKeyword(id))
+            return false;
+        if (!Character.isJavaIdentifierStart(id.charAt(0)))
+            return false;
+        for (int i=1; i<id.length(); i++)
+            if (!Character.isJavaIdentifierPart(id.charAt(i)))
+                return false;
+        return true;
+    }
+
+    /**
+     * checks if the input string is a valid java keyword.
+     * @return boolean true/false
+     */
+    public static boolean isJavaKeyword(String keyword) {
+      return (Arrays.binarySearch(keywords, keyword, englishCollator) >= 0);
+    }
+
+    /**
+     * Turn a java keyword string into a non-Java keyword string.  (Right now
+     * this simply means appending an underscore.)
+     */
+    public static String makeNonJavaKeyword(String keyword){
+        return  keywordPrefix + keyword;
+     }
+
+    /**
+     * Converts text of the form
+     * Foo[] to the proper class name for loading [LFoo
+     */
+    public static String getLoadableClassName(String text) {
+        if (text == null ||
+            text.indexOf("[") < 0 ||
+            text.charAt(0) == '[')
+            return text;
+        String className = text.substring(0,text.indexOf("["));
+        if (className.equals("byte"))
+            className = "B";
+        else if (className.equals("char"))
+            className = "C";
+        else if (className.equals("double"))
+            className = "D";
+        else if (className.equals("float"))
+            className = "F";
+        else if (className.equals("int"))
+            className = "I";
+        else if (className.equals("long"))
+            className = "J";
+        else if (className.equals("short"))
+            className = "S";
+        else if (className.equals("boolean"))
+            className = "Z";
+        else
+            className = "L" + className + ";";
+        int i = text.indexOf("]");
+        while (i > 0) {
+            className = "[" + className;
+            i = text.indexOf("]", i+1);
+        }
+        return className;
+    }
+
+    /**
+     * Converts text of the form
+     * [LFoo to the Foo[]
+     */
+    public static String getTextClassName(String text) {
+        if (text == null ||
+            text.indexOf("[") != 0)
+            return text;
+        String className = "";
+        int index = 0;
+        while(index < text.length() &&
+              text.charAt(index) == '[') {
+            index ++;
+            className += "[]";
+        }
+        if (index < text.length()) {
+            if (text.charAt(index)== 'B')
+                className = "byte" + className;
+            else if (text.charAt(index) == 'C')
+                className = "char" + className;
+            else if (text.charAt(index) == 'D')
+                className = "double" + className;
+            else if (text.charAt(index) == 'F')
+                className = "float" + className;
+            else if (text.charAt(index) == 'I')
+                className = "int" + className;
+            else if (text.charAt(index) == 'J')
+                className = "long" + className;
+            else if (text.charAt(index) == 'S')
+                className = "short" + className;
+            else if (text.charAt(index) == 'Z')
+                className = "boolean" + className;
+            else {
+                className = text.substring(index+1, text.indexOf(";")) + className;
+            }
+        }
+        return className;
+    }
+
+    /**
+     * Map an XML name to a Java identifier per
+     * the mapping rules of JSR 101 (in version 1.0 this is
+     * "Chapter 20: Appendix: Mapping of XML Names"
+     * 
+     * @param name is the xml name
+     * @return the java name per JSR 101 specification
+     */
+    public static String xmlNameToJava(String name)
+    {
+        // protect ourselves from garbage
+        if (name == null || name.equals(""))
+            return name;
+
+        char[] nameArray = name.toCharArray();
+        int nameLen = name.length();
+        StringBuffer result = new StringBuffer(nameLen);
+        boolean wordStart = false;
+
+        // The mapping indicates to convert first character.
+        int i = 0;
+        while (i < nameLen
+                && (isPunctuation(nameArray[i])
+                || !Character.isJavaIdentifierStart(nameArray[i]))) {
+            i++;
+        }
+        if (i < nameLen) {
+            // Decapitalization code used to be here, but we use the
+            // Introspector function now after we filter out all bad chars.
+            
+            result.append(nameArray[i]);
+            //wordStart = !Character.isLetter(nameArray[i]);
+            wordStart = !Character.isLetter(nameArray[i]) && nameArray[i] != "_".charAt(0);
+        }
+        else {
+            // The identifier cannot be mapped strictly according to
+            // JSR 101
+            if (Character.isJavaIdentifierPart(nameArray[0])) {
+                result.append("_" + nameArray[0]);
+            }
+            else {
+                // The XML identifier does not contain any characters
+                // we can map to Java.  Using the length of the string
+                // will make it somewhat unique.
+                result.append("_" + nameArray.length);
+            }
+        }
+
+        // The mapping indicates to skip over
+        // all characters that are not letters or
+        // digits.  The first letter/digit
+        // following a skipped character is
+        // upper-cased.
+        for (++i; i < nameLen; ++i) {
+            char c = nameArray[i];
+
+            // if this is a bad char, skip it and remember to capitalize next
+            // good character we encounter
+            if (isPunctuation(c) || !Character.isJavaIdentifierPart(c)) {
+                wordStart = true;
+                continue;
+            }
+            if (wordStart && Character.isLowerCase(c)) {
+                result.append(Character.toUpperCase(c));
+            }
+            else {
+                result.append(c);
+            }
+            // If c is not a character, but is a legal Java
+            // identifier character, capitalize the next character.
+            // For example:  "22hi" becomes "22Hi"
+            //wordStart = !Character.isLetter(c);
+            wordStart = !Character.isLetter(c) && c != "_".charAt(0);
+        }
+
+        // covert back to a String
+        String newName = result.toString();
+        
+        // Follow JavaBean rules, but we need to check if the first 
+        // letter is uppercase first
+        if (Character.isUpperCase(newName.charAt(0)))
+            newName = Introspector.decapitalize(newName);
+
+        // check for Java keywords
+        if (isJavaKeyword(newName))
+            newName = makeNonJavaKeyword(newName);
+
+        return newName;
+    } // xmlNameToJava
+
+    /**
+     * Is this an XML punctuation character?
+     */
+    private static boolean isPunctuation(char c)
+    {
+        return '-' == c
+            || '.' == c
+            || ':' == c
+            || '\u00B7' == c
+            || '\u0387' == c
+            || '\u06DD' == c
+            || '\u06DE' == c;
+    } // isPunctuation
+
+
+    /**
+     * replace:
+     * Like String.replace except that the old new items are strings.
+     *
+     * @param name string
+     * @param oldT old text to replace
+     * @param newT new text to use
+     * @return replacement string
+     **/
+    public static final String replace (String name,
+                                        String oldT, String newT) {
+
+        if (name == null) return "";
+
+        // Create a string buffer that is twice initial length.
+        // This is a good starting point.
+        StringBuffer sb = new StringBuffer(name.length()* 2);
+
+        int len = oldT.length ();
+        try {
+            int start = 0;
+            int i = name.indexOf (oldT, start);
+
+            while (i >= 0) {
+                sb.append(name.substring(start, i));
+                sb.append(newT);
+                start = i+len;
+                i = name.indexOf(oldT, start);
+            }
+            if (start < name.length())
+                sb.append(name.substring(start));
+        } catch (NullPointerException e) {
+        }
+
+        return new String(sb);
+    }
+
+//    /**
+//     * Determines if the Class is a Holder class. If so returns Class of held type
+//     * else returns null
+//     * @param type the suspected Holder Class
+//     * @return class of held type or null
+//     */
+//    public static Class getHolderValueType(Class type) {
+//        if (type != null) {
+//            Class[] intf = type.getInterfaces();
+//            boolean isHolder = false;
+//            for (int i=0; i<intf.length && !isHolder; i++) {
+//                if (intf[i] == javax.xml.rpc.holders.Holder.class) {
+//                    isHolder = true;
+//                }
+//            }
+//            if (isHolder == false) {
+//                return null;
+//            }
+//
+//            // Holder is supposed to have a public value field.
+//            java.lang.reflect.Field field;
+//            try {
+//                field = type.getField("value");
+//            } catch (Exception e) {
+//                field = null;
+//            }
+//            if (field != null) {
+//                return field.getType();
+//            }
+//        }
+//        return null;
+//    }
+
+//    /**
+//     * Gets the Holder value.
+//     * @param holder Holder object
+//     * @return value object
+//     */
+//    public static Object getHolderValue(Object holder) throws HolderException {
+//        if (!(holder instanceof javax.xml.rpc.holders.Holder)) {
+//            throw new HolderException(Messages.getMessage("badHolder00"));
+//        }
+//        try {
+//            Field valueField = holder.getClass().getField("value");
+//            return valueField.get(holder);
+//        } catch (Exception e) {
+//          throw new HolderException(Messages.getMessage("exception01", e.getMessage()));
+//        }
+//    }
+//
+//    /**
+//     * Sets the Holder value.
+//     * @param holder Holder object
+//     * @param value is the object value
+//     */
+//    public static void setHolderValue(Object holder, Object value) throws HolderException {
+//        if (!(holder instanceof javax.xml.rpc.holders.Holder)) {
+//            throw new HolderException(Messages.getMessage("badHolder00"));
+//        }
+//        try {
+//            Field valueField = holder.getClass().getField("value");
+//            if (valueField.getType().isPrimitive()) {
+//                if (value == null)
+//                    ;  // Don't need to set anything
+//                else
+//                    valueField.set(holder, value);  // Automatically unwraps value to primitive
+//            } else {
+//                valueField.set(holder, value);
+//            }
+//        } catch (Exception e) {
+//          throw new HolderException(Messages.getMessage("exception01", e.getMessage()));
+//        }
+//    }
+    public static class HolderException extends Exception
+    {
+        public HolderException(String msg) { super(msg); }
+    }
+
+    
+    /**
+     * Used to cache a result from IsEnumClassSub(). 
+     * Class->Boolean mapping.
+     */
+    private static HashMap enumMap = new HashMap();
+    
+    /**
+     * Determine if the class is a JAX-RPC enum class.
+     * An enumeration class is recognized by
+     * a getValue() method, a toString() method, a fromString(String) method
+     * a fromValue(type) method and the lack
+     * of a setValue(type) method
+     */
+    public static boolean isEnumClass(Class cls) {
+        Boolean b = (Boolean)enumMap.get(cls);
+        if (b == null) {
+            b = (isEnumClassSub(cls)) ? Boolean.TRUE : Boolean.FALSE;
+            enumMap.put(cls, b);
+        }
+        return b.booleanValue();
+    }
+
+    private static boolean isEnumClassSub(Class cls) {
+        try {
+            java.lang.reflect.Method[] methods = cls.getMethods();
+            java.lang.reflect.Method getValueMethod = null, 
+                fromValueMethod = null,
+                setValueMethod = null, fromStringMethod = null;
+            
+            // linear search: in practice, this is faster than
+            // sorting/searching a short array of methods.
+            for (int i = 0; i < methods.length; i++) {
+                String name = methods[i].getName();
+
+                if (name.equals("getValue")
+                    && methods[i].getParameterTypes().length == 0) { // getValue()
+                    getValueMethod = methods[i];
+                } else if (name.equals("fromString")) { // fromString(String s)
+                    Object[] params = methods[i].getParameterTypes();
+                    if (params.length == 1
+                        && params[0] == String.class) {
+                        fromStringMethod = methods[i];
+                    }
+                } else if (name.equals("fromValue")
+                           && methods[i].getParameterTypes().length == 1) { // fromValue(Something s)
+                    fromValueMethod = methods[i];
+                } else if (name.equals("setValue")
+                           && methods[i].getParameterTypes().length == 1) { // setValue(Something s)
+                    setValueMethod = methods[i];
+                }
+            }
+
+            // must have getValue and fromString, but not setValue
+            // must also have toString(), but every Object subclass has that, so
+            // no need to check for it.
+            if (null != getValueMethod && null != fromStringMethod) {
+                if (null != setValueMethod
+                    && setValueMethod.getParameterTypes().length == 1
+                    && getValueMethod.getReturnType() == setValueMethod.getParameterTypes()[0]) {
+                    // setValue exists: return false
+                    return false;
+                } else {
+                    return true;
+                }
+            } else {
+                return false;
+            }
+        } catch (java.lang.SecurityException e) {
+            return false;
+        } // end of catch
+    }
+
+    public static String stackToString(Throwable e){
+      java.io.StringWriter sw= new java.io.StringWriter(1024); 
+      java.io.PrintWriter pw= new java.io.PrintWriter(sw); 
+      e.printStackTrace(pw);
+      pw.close();
+      return sw.toString();
+    }
+
+    /**
+     * Tests the String 'value':
+     *   return 'false' if its 'false', '0', or 'no' - else 'true'
+     * 
+     * Follow in 'C' tradition of boolean values:
+     * false is specific (0), everything else is true;
+     */
+    public static final boolean isTrue(String value) {
+        return !isFalseExplicitly(value);
+    }
+
+    /**
+     * Tests the String 'value':
+     *   return 'true' if its 'true', '1', or 'yes' - else 'false'
+     */
+    public static final boolean isTrueExplicitly(String value) {
+        return value != null  &&
+               (value.equalsIgnoreCase("true")  ||
+                value.equals("1")  ||
+                value.equalsIgnoreCase("yes"));
+    }
+
+    /**
+     * Tests the Object 'value':
+     *   if its null, return default.
+     *   if its a Boolean, return booleanValue()
+     *   if its an Integer,  return 'false' if its '0' else 'true'
+     *   if its a String, return isTrueExplicitly((String)value).
+     *   All other types return 'true'
+     */
+    public static final boolean isTrueExplicitly(Object value, boolean defaultVal) {
+        if ( value == null ) return defaultVal;
+        if ( value instanceof Boolean ) {
+            return ((Boolean)value).booleanValue();
+        }
+        if ( value instanceof Integer ) {
+            return ((Integer)value).intValue() != 0;
+        }
+        if ( value instanceof String ) {
+            return isTrueExplicitly( (String)value );
+        }
+        return true;
+    }
+    
+    public static final boolean isTrueExplicitly(Object value) {
+        return isTrueExplicitly(value, false);
+    }
+
+    /**
+     * Tests the Object 'value':
+     *   if its null, return default.
+     *   if its a Boolean, return booleanValue()
+     *   if its an Integer,  return 'false' if its '0' else 'true'
+     *   if its a String, return 'false' if its 'false', 'no', or '0' - else 'true'
+     *   All other types return 'true'
+     */
+    public static final boolean isTrue(Object value, boolean defaultVal) {
+        return !isFalseExplicitly(value, !defaultVal);
+    }
+    
+    public static final boolean isTrue(Object value) {
+        return isTrue(value, false);
+    }
+    
+    /**
+     * Tests the String 'value':
+     *   return 'true' if its 'false', '0', or 'no' - else 'false'
+     * 
+     * Follow in 'C' tradition of boolean values:
+     * false is specific (0), everything else is true;
+     */
+    public static final boolean isFalse(String value) {
+        return isFalseExplicitly(value);
+    }
+
+    /**
+     * Tests the String 'value':
+     *   return 'true' if its null, 'false', '0', or 'no' - else 'false'
+     */
+    public static final boolean isFalseExplicitly(String value) {
+        return value == null  ||
+               value.equalsIgnoreCase("false")  ||
+               value.equals("0")  ||
+               value.equalsIgnoreCase("no");
+    }
+    
+    /**
+     * Tests the Object 'value':
+     *   if its null, return default.
+     *   if its a Boolean, return !booleanValue()
+     *   if its an Integer,  return 'true' if its '0' else 'false'
+     *   if its a String, return isFalseExplicitly((String)value).
+     *   All other types return 'false'
+     */
+    public static final boolean isFalseExplicitly(Object value, boolean defaultVal) {
+        if ( value == null ) return defaultVal;
+        if ( value instanceof Boolean ) {
+            return !((Boolean)value).booleanValue();
+        }
+        if ( value instanceof Integer ) {
+            return ((Integer)value).intValue() == 0;
+        }
+        if ( value instanceof String ) {
+            return isFalseExplicitly( (String)value );
+        }
+        return false;
+    }
+    
+    public static final boolean isFalseExplicitly(Object value) {
+        return isFalseExplicitly(value, true);
+    }
+
+    /**
+     * Tests the Object 'value':
+     *   if its null, return default.
+     *   if its a Boolean, return booleanValue()
+     *   if its an Integer,  return 'false' if its '0' else 'true'
+     *   if its a String, return 'false' if its 'false', 'no', or '0' - else 'true'
+     *   All other types return 'true'
+     */
+    public static final boolean isFalse(Object value, boolean defaultVal) {
+        return isFalseExplicitly(value, defaultVal);
+    }
+    
+    public static final boolean isFalse(Object value) {
+        return isFalse(value, true);
+    }
+    
+    /**
+     * Given the MIME type string, return the Java mapping.
+     */
+    public static String mimeToJava(String mime) {
+        if ("image/gif".equals(mime) || "image/jpeg".equals(mime)) {
+            return "java.awt.Image";
+        }
+        else if ("text/plain".equals(mime)) {
+            return "java.lang.String";
+        }
+        else if ("text/xml".equals(mime) || "application/xml".equals(mime)) {
+            return "javax.xml.transform.Source";
+        }
+        else if ("application/octet-stream".equals(mime)||
+                 "application/octetstream".equals(mime)) {
+            return "org.apache.axis.attachments.OctetStream";
+        }
+        else if (mime != null && mime.startsWith("multipart/")) {
+            return "javax.mail.internet.MimeMultipart";
+        }
+        else {
+            return "javax.activation.DataHandler";
+        }
+    } // mimeToJava
+
+    //avoid testing and possibly failing everytime.
+    private static boolean checkForAttachmentSupport = true;
+    private static boolean attachmentSupportEnabled = false;
+
+    /**
+     * Determine whether attachments are supported by checking if the following
+     * classes are available:  javax.activation.DataHandler,
+     * javax.mail.internet.MimeMultipart.
+     */
+//    public static synchronized boolean isAttachmentSupported() {
+//
+//        if (checkForAttachmentSupport) {
+//            //aviod testing and possibly failing everytime.
+//            checkForAttachmentSupport = false;
+//            try {
+//                // Attempt to resolve DataHandler and MimeMultipart and
+//                // javax.xml.transform.Source, all necessary for full
+//                // attachment support
+//                ClassUtils.forName("javax.activation.DataHandler");
+//                ClassUtils.forName("javax.mail.internet.MimeMultipart");
+//                attachmentSupportEnabled = true;
+//            } catch (Throwable t) {
+//            }
+//            log.debug(Messages.getMessage("attachEnabled") + "  " +
+//                    attachmentSupportEnabled);
+//            if(!attachmentSupportEnabled) {
+//                log.warn(Messages.getMessage("attachDisabled"));
+//            }
+//        }
+//
+//        return attachmentSupportEnabled;
+//    } // isAttachmentSupported
+
+    /**
+     * Makes the value passed in <code>initValue</code> unique among the
+     * {@link String} values contained in <code>values</code> by suffixing
+     * it with a decimal digit suffix.
+     */
+    public static String  getUniqueValue(Collection values, String initValue) {
+
+        if (!values.contains(initValue))  {
+            return  initValue;
+        }
+        else  {
+
+            StringBuffer   unqVal = new StringBuffer(initValue);
+            int   beg = unqVal.length(),  cur,  end;
+            while (Character.isDigit(unqVal.charAt(beg - 1)))  {
+                beg--;
+            }
+            if (beg == unqVal.length())  {
+                unqVal.append('1');
+            }
+            cur = end = unqVal.length() - 1;
+
+            while (values.contains(unqVal.toString()))  {
+
+                if (unqVal.charAt(cur) < '9')  {
+                    unqVal.setCharAt(cur, (char) (unqVal.charAt(cur) + 1));
+                }
+
+                else  {
+
+                    while (cur-- > beg)  {
+                        if (unqVal.charAt(cur) < '9')  {
+                            unqVal.setCharAt(cur,
+                                (char) (unqVal.charAt(cur) + 1));
+                            break;
+                        }
+                    }
+
+                    // See if there's a need to insert a new digit.
+                    if (cur < beg)  {
+                        unqVal.insert(++cur, '1');     end++;
+                    }
+                    while (cur < end)  {
+                        unqVal.setCharAt(++cur, '0');
+                    }
+
+                }
+
+            }
+
+            return  unqVal.toString();
+
+        }  /*  For  else  clause  of  selection-statement   If(!values ...   */
+
+    }  /*  For  class  method   JavaUtils.getUniqueValue   */
+}



Mime
View raw message