Java tutorial
/* * Copyright 2011 JBoss, by Red Hat, Inc * * 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.jboss.errai.marshalling.rebind.util; import static org.jboss.errai.codegen.meta.MetaClassFactory.parameterizedAs; import static org.jboss.errai.codegen.meta.MetaClassFactory.typeParametersOf; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.List; import java.util.Map; import org.apache.commons.lang3.StringUtils; import org.jboss.errai.codegen.Statement; import org.jboss.errai.codegen.builder.BlockBuilder; import org.jboss.errai.codegen.builder.ClassStructureBuilder; import org.jboss.errai.codegen.meta.MetaClass; import org.jboss.errai.codegen.meta.MetaClassFactory; import org.jboss.errai.codegen.meta.MetaMethod; import org.jboss.errai.codegen.meta.MetaParameterizedType; import org.jboss.errai.codegen.meta.MetaType; import org.jboss.errai.codegen.util.GenUtil; import org.jboss.errai.codegen.util.If; import org.jboss.errai.codegen.util.Stmt; import org.jboss.errai.config.rebind.EnvUtil; import org.jboss.errai.marshalling.client.Marshalling; import org.jboss.errai.marshalling.client.api.Marshaller; /** * @author Mike Brock <cbrock@redhat.com> * @author Christian Sadilek <csadilek@redhat.com> */ public class MarshallingGenUtil { private static final String USE_STATIC_MARSHALLERS = "errai.marshalling.use_static_marshallers"; private static final String FORCE_STATIC_MARSHALLERS = "errai.marshalling.force_static_marshallers"; public static final String ARRAY_VAR_PREFIX = "arrayOf_"; public static final String ERRAI_DOLLARSIGN_REPLACEMENT = ".erraiD."; public static final String ERRAI_UNDERSCORE_REPLACEMENT = ".erraiU."; public static String getVarName(final MetaClass clazz) { return clazz.isArray() ? getArrayVarName(clazz.getOuterComponentType().getFullyQualifiedName()) + "_D" + GenUtil.getArrayDimensions(clazz) : getVarName(clazz.asBoxed().getFullyQualifiedName()); } public static String getVarName(final Class<?> clazz) { return getVarName(MetaClassFactory.get(clazz)); } public static String getArrayVarName(final String clazz) { return ARRAY_VAR_PREFIX + normalizeName(clazz); } public static String getVarName(String clazz) { return normalizeName(clazz); } private static String normalizeName(final String sourceString) { String result = sourceString; result = StringUtils.replace(result, "_", ERRAI_UNDERSCORE_REPLACEMENT); result = StringUtils.replace(result, "$", ERRAI_DOLLARSIGN_REPLACEMENT); result = StringUtils.replace(result, ".", "_"); return result; } public static MetaMethod findGetterMethod(MetaClass cls, String key) { MetaMethod metaMethod = _findGetterMethod("get", cls, key); if (metaMethod != null) return metaMethod; metaMethod = _findGetterMethod("is", cls, key); return metaMethod; } private static MetaMethod _findGetterMethod(String prefix, MetaClass cls, String key) { key = (prefix + key).toUpperCase(); for (MetaMethod m : cls.getDeclaredMethods()) { if (m.getName().toUpperCase().equals(key) && m.getParameters().length == 0) { return m; } } return null; } /** * Returns the element type of the given metaclass under the following conditions: * <ul> * <li>toType is a collection type * <li>toType has a single type parameter * <li>toType's type parameter is not a wildcard * <li>toType's type parameter is a non-abstract (concrete) type * <li>toType's type parameter is not java.lang.Object * </ul> * * @param toType * The type to check for a known concrete collection element type. * @return The concrete element type meeting all above-mentioned criteria, or null if one or more * of the criteria fails. */ public static MetaClass getConcreteCollectionElementType(MetaClass toType) { if (toType.isAssignableTo(Collection.class)) { return getConcreteElementType(toType); } return null; } /** * Returns the element type of the given metaclass under the following conditions: * <ul> * <li>toType has a single type parameter * <li>toType's type parameter is not a wildcard * <li>toType's type parameter is a non-abstract (concrete) type * <li>toType's type parameter is not java.lang.Object * </ul> * * @param toType * The type to check for a known concrete collection element type. * @return The concrete element type meeting all above-mentioned criteria, or null if one or more * of the criteria fails. */ public static MetaClass getConcreteElementType(MetaClass toType) { return getConcreteTypeParameter(toType, 0, 1); } /** * Returns the map key type of the given metaclass under the following conditions: * <ul> * <li>toType is a {@link Map} * <li>toType's key type is not a wildcard * <li>toType's key type is a non-abstract (concrete) type * </ul> * * @param toType * The type to check for a known concrete map key type. * @return The concrete map key type meeting all above-mentioned criteria, or null if one or more * of the criteria fails. */ public static MetaClass getConcreteMapKeyType(MetaClass toType) { if (toType.isAssignableTo(Map.class)) { return getConcreteTypeParameter(toType, 0, 2); } return null; } /** * Returns the map value type of the given metaclass under the following conditions: * <ul> * <li>toType is a {@link Map} * <li>toType's value type is not a wildcard * <li>toType's value type is a non-abstract (concrete) type * </ul> * * @param toType * The type to check for a known concrete map key type. * @return The concrete map value type meeting all above-mentioned criteria, or null if one or * more of the criteria fails. */ public static MetaClass getConcreteMapValueType(MetaClass toType) { if (toType.isAssignableTo(Map.class)) { return getConcreteTypeParameter(toType, 1, 2); } return null; } private static MetaClass getConcreteTypeParameter(MetaClass toType, int typeParamIndex, int typeParamsSize) { if (toType.getParameterizedType() != null) { MetaType[] typeParms = toType.getParameterizedType().getTypeParameters(); if (typeParms != null && typeParms.length == typeParamsSize) { MetaClass typeParameter = null; if (typeParms[typeParamIndex] instanceof MetaParameterizedType) { MetaParameterizedType parameterizedTypeParemeter = (MetaParameterizedType) typeParms[typeParamIndex]; typeParameter = (MetaClass) parameterizedTypeParemeter.getRawType(); } else if (typeParms[typeParamIndex] instanceof MetaClass) { typeParameter = (MetaClass) typeParms[typeParamIndex]; } return typeParameter; } } return null; } public static Collection<MetaClass> getDefaultArrayMarshallers() { final List<MetaClass> l = new ArrayList<MetaClass>(); l.add(MetaClassFactory.get(Object[].class)); l.add(MetaClassFactory.get(String[].class)); l.add(MetaClassFactory.get(int[].class)); l.add(MetaClassFactory.get(long[].class)); l.add(MetaClassFactory.get(double[].class)); l.add(MetaClassFactory.get(float[].class)); l.add(MetaClassFactory.get(short[].class)); l.add(MetaClassFactory.get(boolean[].class)); l.add(MetaClassFactory.get(byte[].class)); l.add(MetaClassFactory.get(char[].class)); l.add(MetaClassFactory.get(Integer[].class)); l.add(MetaClassFactory.get(Long[].class)); l.add(MetaClassFactory.get(Double[].class)); l.add(MetaClassFactory.get(Float[].class)); l.add(MetaClassFactory.get(Short[].class)); l.add(MetaClassFactory.get(Boolean[].class)); l.add(MetaClassFactory.get(Byte[].class)); l.add(MetaClassFactory.get(Character[].class)); return Collections.unmodifiableCollection(l); } public static boolean isUseStaticMarshallers() { if (isForceStaticMarshallers()) return true; if (EnvUtil.isDevMode() && !EnvUtil.isJUnitTest()) return false; if (System.getProperty(USE_STATIC_MARSHALLERS) != null) { return Boolean.getBoolean(USE_STATIC_MARSHALLERS); } final Map<String, String> frameworkProperties = EnvUtil.getEnvironmentConfig().getFrameworkProperties(); if (frameworkProperties.containsKey(USE_STATIC_MARSHALLERS)) { return "true".equals(frameworkProperties.get(USE_STATIC_MARSHALLERS)); } else { return !EnvUtil.isDevMode(); } } public static boolean isForceStaticMarshallers() { if (System.getProperty(FORCE_STATIC_MARSHALLERS) != null) { return Boolean.getBoolean(FORCE_STATIC_MARSHALLERS); } final Map<String, String> frameworkProperties = EnvUtil.getEnvironmentConfig().getFrameworkProperties(); if (frameworkProperties.containsKey(FORCE_STATIC_MARSHALLERS)) { return "true".equals(frameworkProperties.get(FORCE_STATIC_MARSHALLERS)); } else { return false; } } public static void ensureMarshallerFieldCreated(ClassStructureBuilder<?> classStructureBuilder, MetaClass marshallerForType, MetaClass type, BlockBuilder<?> initMethod) { ensureMarshallerFieldCreated(classStructureBuilder, marshallerForType, type, initMethod, null); } public static void ensureMarshallerFieldCreated(ClassStructureBuilder<?> classStructureBuilder, MetaClass marshallerForType, MetaClass type, BlockBuilder<?> initMethod, Statement marshallerCreationCallback) { String fieldName = MarshallingGenUtil.getVarName(type); if (classStructureBuilder.getClassDefinition().getField(fieldName) == null) { Statement marshallerLookup = createMarshallerLookup(marshallerForType, type, marshallerCreationCallback); if (initMethod == null) { classStructureBuilder .privateField(fieldName, parameterizedAs(Marshaller.class, typeParametersOf(type.getErased().asBoxed()))) .initializesWith(marshallerLookup).finish(); } else { classStructureBuilder .privateField(fieldName, parameterizedAs(Marshaller.class, typeParametersOf(type.getErased().asBoxed()))) .initializesWith(Stmt.load(null)).finish(); initMethod.append(If.isNull(Stmt.loadVariable(fieldName)) .append(Stmt.loadVariable(fieldName).assignValue(marshallerLookup)).finish()); } } } private static Statement createMarshallerLookup(MetaClass marshallerForType, MetaClass type, Statement marshallerCreationCallback) { Statement marshallerLookup = null; if (type.equals(marshallerForType)) { marshallerLookup = Stmt.loadVariable("this"); } else if (marshallerCreationCallback == null) { marshallerLookup = Stmt.invokeStatic(Marshalling.class, "getMarshaller", Stmt.loadLiteral(type.asBoxed().asClass())); } else { marshallerLookup = Stmt.invokeStatic(Marshalling.class, "getMarshaller", Stmt.loadLiteral(type.asBoxed().asClass()), marshallerCreationCallback); } return marshallerLookup; } }