001    // Copyright 2006 The Apache Software Foundation
002    //
003    // Licensed under the Apache License, Version 2.0 (the "License");
004    // you may not use this file except in compliance with the License.
005    // You may obtain a copy of the License at
006    //
007    //     http://www.apache.org/licenses/LICENSE-2.0
008    //
009    // Unless required by applicable law or agreed to in writing, software
010    // distributed under the License is distributed on an "AS IS" BASIS,
011    // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
012    // See the License for the specific language governing permissions and
013    // limitations under the License.
014    
015    package org.apache.tapestry5.services;
016    
017    import static org.apache.tapestry5.ioc.internal.util.CollectionFactory.newMap;
018    
019    import java.util.Map;
020    
021    /**
022     * Support code for generating code (used when transforming component classes).
023     */
024    public final class TransformUtils
025    {
026        private static final Map<String, PrimitiveTypeInfo> nameToInfo = newMap();
027    
028        private static final Map<Class, PrimitiveTypeInfo> classToInfo = newMap();
029    
030        static class PrimitiveTypeInfo
031        {
032            private final Class wrapperType;
033    
034            private final String unwrapperMethodName;
035    
036            private final String defaultValue;
037    
038            public PrimitiveTypeInfo(Class wrapperType, String unwrapperMethodName, String defaultValue)
039            {
040                this.wrapperType = wrapperType;
041                this.unwrapperMethodName = unwrapperMethodName;
042                this.defaultValue = defaultValue;
043            }
044        }
045    
046        static
047        {
048            add(boolean.class, Boolean.class, "booleanValue", "false");
049            add(byte.class, Byte.class, "byteValue", "0");
050            add(char.class, Character.class, "charValue", "0");
051            add(short.class, Short.class, "shortValue", "0");
052            add(int.class, Integer.class, "intValue", "0");
053            add(long.class, Long.class, "longValue", "0L");
054            add(float.class, Float.class, "floatValue", "0.0f");
055            add(double.class, Double.class, "doubleValue", "0.0d");
056        }
057    
058        private TransformUtils()
059        {
060        }
061    
062        private static void add(Class primitiveType, Class wrapperType, String unwrapperMethodName, String defaultValue)
063        {
064            PrimitiveTypeInfo info = new PrimitiveTypeInfo(wrapperType, unwrapperMethodName, defaultValue);
065    
066            classToInfo.put(primitiveType, info);
067            nameToInfo.put(primitiveType.getName(), info);
068        }
069    
070        /**
071         * Returns true if the specified type is a primitive type.
072         */
073        public static boolean isPrimitive(String type)
074        {
075            return nameToInfo.containsKey(type);
076        }
077    
078        /**
079         * Returns the name of wrapper type for a given input type. For primitive types, returns the wrapper type. For other
080         * types, returns the input type name.
081         *
082         * @param type primitive type name, or fully qualified class name
083         */
084        public static String getWrapperTypeName(String type)
085        {
086            PrimitiveTypeInfo info = nameToInfo.get(type);
087    
088            return info == null ? type : info.wrapperType.getName();
089        }
090    
091        /**
092         * For primitive types, returns the method on the <em>wrapper type</em> that converts back to the primitive.
093         *
094         * @param type the primitive type
095         * @return the method of the corresponding wrapper type, or null if type is not a primitive type
096         */
097        public static String getUnwrapperMethodName(String type)
098        {
099            PrimitiveTypeInfo info = nameToInfo.get(type);
100    
101            return info == null ? null : info.unwrapperMethodName;
102        }
103    
104        /**
105         * Returns the wrapper type for a given input type. For primitive types, returns the wrapper type. For other types,
106         * returns the type itself.
107         *
108         * @param type primitive or object type
109         */
110        public static Class getWrapperType(Class type)
111        {
112            PrimitiveTypeInfo info = classToInfo.get(type);
113    
114            return info == null ? type : info.wrapperType;
115        }
116    
117        /**
118         * Returns the default value for a type. This is the string "null" for most types, or a literal value for primitive
119         * types.
120         */
121        public static String getDefaultValue(String type)
122        {
123            PrimitiveTypeInfo info = nameToInfo.get(type);
124    
125            return info == null ? "null" : info.defaultValue;
126        }
127    }