- /*
- * Copyright 2000-2018 Vaadin Ltd.
- *
- * 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 com.vaadin.server.widgetsetutils.metadata;
-
- import java.io.Serializable;
- import java.util.Arrays;
- import java.util.Collection;
- import java.util.Collections;
- import java.util.Comparator;
- import java.util.HashMap;
- import java.util.HashSet;
- import java.util.Iterator;
- import java.util.LinkedHashSet;
- import java.util.List;
- import java.util.Map;
- import java.util.Set;
- import java.util.TreeMap;
- import java.util.TreeSet;
-
- import com.google.gwt.core.ext.TreeLogger;
- import com.google.gwt.core.ext.TreeLogger.Type;
- import com.google.gwt.core.ext.UnableToCompleteException;
- import com.google.gwt.core.ext.typeinfo.JArrayType;
- import com.google.gwt.core.ext.typeinfo.JClassType;
- import com.google.gwt.core.ext.typeinfo.JEnumType;
- import com.google.gwt.core.ext.typeinfo.JMethod;
- import com.google.gwt.core.ext.typeinfo.JParameterizedType;
- import com.google.gwt.core.ext.typeinfo.JType;
- import com.google.gwt.core.ext.typeinfo.NotFoundException;
- import com.google.gwt.core.ext.typeinfo.TypeOracle;
- import com.vaadin.client.ApplicationConnection;
- import com.vaadin.client.ComponentConnector;
- import com.vaadin.client.ServerConnector;
- import com.vaadin.client.communication.JSONSerializer;
- import com.vaadin.client.connectors.AbstractRendererConnector;
- import com.vaadin.client.metadata.TypeDataStore.MethodAttribute;
- import com.vaadin.client.ui.UnknownComponentConnector;
- import com.vaadin.client.ui.UnknownExtensionConnector;
- import com.vaadin.shared.communication.ClientRpc;
- import com.vaadin.shared.communication.ServerRpc;
- import com.vaadin.shared.ui.Connect;
-
- import elemental.json.JsonValue;
-
- public class ConnectorBundle {
- private static final String FAIL_IF_NOT_SERIALIZABLE = "vFailIfNotSerializable";
-
- public static final Comparator<JClassType> jClassComparator = new Comparator<JClassType>() {
- @Override
- public int compare(JClassType o1, JClassType o2) {
- return o1.getQualifiedSourceName()
- .compareTo(o2.getQualifiedSourceName());
- }
- };
-
- public static final Comparator<JMethod> jMethodComparator = new Comparator<JMethod>() {
- @Override
- public int compare(JMethod o1, JMethod o2) {
- return o1.getReadableDeclaration()
- .compareTo(o2.getReadableDeclaration());
- }
- };
-
- private final String name;
- private final ConnectorBundle previousBundle;
- private final Collection<TypeVisitor> visitors;
- private final Map<JType, JClassType> customSerializers;
-
- private final Set<JType> hasSerializeSupport = new HashSet<JType>();
- private final Set<JType> needsSerializeSupport = new HashSet<JType>();
-
- private final Map<JType, GeneratedSerializer> serializers = new TreeMap<JType, GeneratedSerializer>(
- new Comparator<JType>() {
- @Override
- public int compare(JType o1, JType o2) {
- return o1.toString().compareTo(o2.toString());
- }
- });
-
- private final Map<JClassType, Map<JMethod, Set<MethodAttribute>>> methodAttributes = new TreeMap<JClassType, Map<JMethod, Set<MethodAttribute>>>(
- jClassComparator);
- private final Set<JClassType> needsSuperClass = new TreeSet<JClassType>(
- jClassComparator);
- private final Set<JClassType> needsGwtConstructor = new TreeSet<JClassType>(
- jClassComparator);
- private final Set<JClassType> visitedTypes = new HashSet<JClassType>();
-
- private final Set<JClassType> needsProxySupport = new TreeSet<JClassType>(
- jClassComparator);
-
- private final Map<JClassType, JType> presentationTypes = new TreeMap<JClassType, JType>(
- jClassComparator);
- private final Map<JClassType, Set<String>> identifiers = new TreeMap<JClassType, Set<String>>(
- jClassComparator);
- private final Map<JClassType, Set<JMethod>> needsReturnType = new TreeMap<JClassType, Set<JMethod>>(
- jClassComparator);
- private final Map<JClassType, Set<JMethod>> needsInvoker = new TreeMap<JClassType, Set<JMethod>>(
- jClassComparator);
- private final Map<JClassType, Set<JMethod>> needsParamTypes = new TreeMap<JClassType, Set<JMethod>>(
- jClassComparator);
- private final Map<JClassType, Set<JMethod>> needsOnStateChange = new TreeMap<JClassType, Set<JMethod>>(
- jClassComparator);
-
- private final Set<Property> needsProperty = new TreeSet<Property>();
- private final Map<JClassType, Set<Property>> needsDelegateToWidget = new TreeMap<JClassType, Set<Property>>(
- jClassComparator);
-
- private ConnectorBundle(String name, ConnectorBundle previousBundle,
- Collection<TypeVisitor> visitors,
- Map<JType, JClassType> customSerializers) {
- this.name = name;
- this.previousBundle = previousBundle;
- this.visitors = visitors;
- this.customSerializers = customSerializers;
- }
-
- public ConnectorBundle(String name, ConnectorBundle previousBundle) {
- this(name, previousBundle, previousBundle.visitors,
- previousBundle.customSerializers);
- }
-
- public ConnectorBundle(String name, Collection<TypeVisitor> visitors,
- TypeOracle oracle) throws NotFoundException {
- this(name, null, visitors, findCustomSerializers(oracle));
- }
-
- private static Map<JType, JClassType> findCustomSerializers(
- TypeOracle oracle) throws NotFoundException {
- Map<JType, JClassType> serializers = new HashMap<JType, JClassType>();
-
- JClassType serializerInterface = oracle
- .findType(JSONSerializer.class.getName());
- JType[] deserializeParamTypes = new JType[] {
- oracle.findType(
- com.vaadin.client.metadata.Type.class.getName()),
- oracle.findType(JsonValue.class.getName()),
- oracle.findType(ApplicationConnection.class.getName()) };
- String deserializeMethodName = "deserialize";
- // Just test that the method exists
- serializerInterface.getMethod(deserializeMethodName,
- deserializeParamTypes);
-
- for (JClassType serializer : serializerInterface.getSubtypes()) {
- JMethod deserializeMethod = serializer
- .findMethod(deserializeMethodName, deserializeParamTypes);
- if (deserializeMethod == null) {
- continue;
- }
- JType returnType = deserializeMethod.getReturnType();
-
- serializers.put(returnType, serializer);
- }
- return serializers;
- }
-
- public void setNeedsGwtConstructor(JClassType type) {
- if (!needsGwtConstructor(type)) {
- needsGwtConstructor.add(type);
- }
- }
-
- private boolean needsGwtConstructor(JClassType type) {
- if (needsGwtConstructor.contains(type)) {
- return true;
- } else {
- return previousBundle != null
- && previousBundle.needsGwtConstructor(type);
- }
- }
-
- public void setIdentifier(JClassType type, String identifier) {
- if (!hasIdentifier(type, identifier)) {
- addMapping(identifiers, type, identifier);
- }
- }
-
- private boolean hasIdentifier(JClassType type, String identifier) {
- if (hasMapping(identifiers, type, identifier)) {
- return true;
- } else {
- return previousBundle != null
- && previousBundle.hasIdentifier(type, identifier);
- }
- }
-
- public ConnectorBundle getPreviousBundle() {
- return previousBundle;
- }
-
- public String getName() {
- return name;
- }
-
- public Map<JClassType, Set<String>> getIdentifiers() {
- return Collections.unmodifiableMap(identifiers);
- }
-
- public Set<JClassType> getGwtConstructors() {
- return Collections.unmodifiableSet(needsGwtConstructor);
- }
-
- public void processTypes(TreeLogger logger, Collection<JClassType> types)
- throws UnableToCompleteException {
- for (JClassType type : types) {
- processType(logger, type);
- }
- }
-
- public void processType(TreeLogger logger, JClassType type)
- throws UnableToCompleteException {
- if (!isTypeVisited(type)) {
- for (TypeVisitor typeVisitor : visitors) {
- invokeVisitor(logger, type, typeVisitor);
- }
- visitedTypes.add(type);
- purgeSerializeSupportQueue(logger);
- }
- }
-
- private boolean isTypeVisited(JClassType type) {
- if (visitedTypes.contains(type)) {
- return true;
- } else {
- return previousBundle != null && previousBundle.isTypeVisited(type);
- }
- }
-
- private void purgeSerializeSupportQueue(TreeLogger logger)
- throws UnableToCompleteException {
- while (!needsSerializeSupport.isEmpty()) {
- Iterator<JType> iterator = needsSerializeSupport.iterator();
- JType type = iterator.next();
- iterator.remove();
-
- if (hasSerializeSupport(type)) {
- continue;
- }
-
- addSerializeSupport(logger, type);
- }
- }
-
- private void addSerializeSupport(TreeLogger logger, JType type)
- throws UnableToCompleteException {
- hasSerializeSupport.add(type);
-
- JParameterizedType parametrized = type.isParameterized();
- if (parametrized != null) {
- for (JClassType parameterType : parametrized.getTypeArgs()) {
- setNeedsSerialize(parameterType);
- }
- }
-
- if (serializationHandledByFramework(type)) {
- return;
- }
-
- JClassType customSerializer = customSerializers.get(type);
- JClassType typeAsClass = type.isClass();
- JEnumType enumType = type.isEnum();
- JArrayType arrayType = type.isArray();
-
- if (customSerializer != null) {
- logger.log(Type.INFO, "Will serialize " + type + " using "
- + customSerializer.getName());
- setSerializer(type, new CustomSerializer(customSerializer));
- } else if (arrayType != null) {
- logger.log(Type.INFO, "Will serialize " + type + " as an array");
- setSerializer(type, new ArraySerializer(arrayType));
- setNeedsSerialize(arrayType.getComponentType());
- } else if (enumType != null) {
- logger.log(Type.INFO, "Will serialize " + type + " as an enum");
- setSerializer(type, new EnumSerializer(enumType));
- } else if (typeAsClass != null) {
- // Bean
- checkSerializable(logger, typeAsClass);
-
- logger.log(Type.INFO, "Will serialize " + type + " as a bean");
-
- JClassType needsSuperClass = typeAsClass;
- while (needsSuperClass != null) {
- if (needsSuperClass.isPublic()) {
- setNeedsSuperclass(needsSuperClass);
- }
- needsSuperClass = needsSuperClass.getSuperclass();
- }
-
- setNeedsGwtConstructor(typeAsClass);
-
- for (Property property : getProperties(typeAsClass)) {
- setNeedsProperty(property);
-
- JType propertyType = property.getPropertyType();
- setNeedsSerialize(propertyType);
- }
- }
- }
-
- private void checkSerializable(TreeLogger logger, JClassType type)
- throws UnableToCompleteException {
- JClassType javaSerializable = type.getOracle()
- .findType(Serializable.class.getName());
- boolean serializable = type.isAssignableTo(javaSerializable);
- if (!serializable) {
- boolean abortCompile = "true"
- .equals(System.getProperty(FAIL_IF_NOT_SERIALIZABLE));
- logger.log(abortCompile ? Type.ERROR : Type.WARN, type
- + " is used in RPC or shared state but does not implement "
- + Serializable.class.getName()
- + ". Communication will work but the Application on server side cannot be serialized if it refers to objects of this type. "
- + "If the system property " + FAIL_IF_NOT_SERIALIZABLE
- + " is set to \"true\", this causes the compilation to fail instead of just emitting a warning.");
- if (abortCompile) {
- throw new UnableToCompleteException();
- }
- }
- }
-
- private void setSerializer(JType type, GeneratedSerializer serializer) {
- if (!hasSerializer(type)) {
- serializers.put(type, serializer);
- }
- }
-
- private boolean hasSerializer(JType type) {
- if (serializers.containsKey(type)) {
- return true;
- } else {
- return previousBundle != null && previousBundle.hasSerializer(type);
- }
- }
-
- public Map<JType, GeneratedSerializer> getSerializers() {
- return Collections.unmodifiableMap(serializers);
- }
-
- public void setPresentationType(JClassType type, JType presentationType) {
- if (!hasPresentationType(type)) {
- presentationTypes.put(type, presentationType);
- }
- }
-
- private boolean hasPresentationType(JClassType type) {
- if (presentationTypes.containsKey(type)) {
- return true;
- } else {
- return previousBundle != null
- && previousBundle.hasPresentationType(type);
- }
- }
-
- public Map<JClassType, JType> getPresentationTypes() {
- return Collections.unmodifiableMap(presentationTypes);
- }
-
- private void setNeedsSuperclass(JClassType typeAsClass) {
- if (!isNeedsSuperClass(typeAsClass)) {
- needsSuperClass.add(typeAsClass);
- }
- }
-
- private boolean isNeedsSuperClass(JClassType typeAsClass) {
- if (needsSuperClass.contains(typeAsClass)) {
- return true;
- } else {
- return previousBundle != null
- && previousBundle.isNeedsSuperClass(typeAsClass);
- }
- }
-
- public Set<JClassType> getNeedsSuperclass() {
- return Collections.unmodifiableSet(needsSuperClass);
- }
-
- private void setNeedsProperty(Property property) {
- if (!isNeedsProperty(property)) {
- needsProperty.add(property);
- }
- }
-
- private boolean isNeedsProperty(Property property) {
- if (needsProperty.contains(property)) {
- return true;
- } else {
- return previousBundle != null
- && previousBundle.isNeedsProperty(property);
- }
- }
-
- public Set<Property> getNeedsProperty() {
- return Collections.unmodifiableSet(needsProperty);
- }
-
- public Collection<Property> getProperties(JClassType type) {
- Set<Property> properties = new TreeSet<Property>();
-
- properties.addAll(MethodProperty.findProperties(type));
- properties.addAll(FieldProperty.findProperties(type));
-
- return properties;
- }
-
- private void invokeVisitor(TreeLogger logger, JClassType type,
- TypeVisitor typeVisitor) throws UnableToCompleteException {
- TreeLogger subLogger = logger.branch(Type.TRACE,
- "Visiting " + type.getName() + " with "
- + typeVisitor.getClass().getSimpleName());
- if (isConnectedConnector(type)) {
- typeVisitor.visitConnector(subLogger, type, this);
- }
- if (isClientRpc(type)) {
- typeVisitor.visitClientRpc(subLogger, type, this);
- }
- if (isServerRpc(type)) {
- typeVisitor.visitServerRpc(subLogger, type, this);
- }
- }
-
- public void processSubTypes(TreeLogger logger, JClassType type)
- throws UnableToCompleteException {
- processTypes(logger, Arrays.asList(type.getSubtypes()));
- }
-
- public void setNeedsReturnType(JClassType type, JMethod method) {
- if (!isNeedsReturnType(type, method)) {
- addMapping(needsReturnType, type, method);
- }
- }
-
- private boolean isNeedsReturnType(JClassType type, JMethod method) {
- if (hasMapping(needsReturnType, type, method)) {
- return true;
- } else {
- return previousBundle != null
- && previousBundle.isNeedsReturnType(type, method);
- }
- }
-
- public Map<JClassType, Set<JMethod>> getMethodReturnTypes() {
- return Collections.unmodifiableMap(needsReturnType);
- }
-
- private static boolean isClientRpc(JClassType type) {
- return isInterfaceType(type, ClientRpc.class);
- }
-
- private static boolean isServerRpc(JClassType type) {
- return isInterfaceType(type, ServerRpc.class);
- }
-
- public static boolean isConnectedConnector(JClassType type) {
- return isConnected(type) && isType(type, ServerConnector.class);
- }
-
- private static boolean isConnected(JClassType type) {
- return type.isAnnotationPresent(Connect.class)
- || type.getQualifiedSourceName().equals(
- UnknownComponentConnector.class.getCanonicalName())
- || type.getQualifiedSourceName().equals(
- UnknownExtensionConnector.class.getCanonicalName());
- }
-
- public static boolean isConnectedComponentConnector(JClassType type) {
- return isConnected(type) && isType(type, ComponentConnector.class);
- }
-
- public static boolean isConnectedRendererConnector(JClassType type) {
- return isConnected(type)
- && isType(type, AbstractRendererConnector.class);
- }
-
- private static boolean isInterfaceType(JClassType type, Class<?> class1) {
- return type.isInterface() != null && isType(type, class1);
- }
-
- private static boolean isType(JClassType type, Class<?> class1) {
- try {
- return type.getOracle().getType(class1.getName())
- .isAssignableFrom(type);
- } catch (NotFoundException e) {
- throw new RuntimeException("Could not find " + class1.getName(), e);
- }
- }
-
- public void setNeedsInvoker(JClassType type, JMethod method) {
- if (!isNeedsInvoker(type, method)) {
- addMapping(needsInvoker, type, method);
- }
- }
-
- private <K> void addMapping(Map<K, Set<String>> map, K key, String value) {
- Set<String> set = map.get(key);
- if (set == null) {
- set = new TreeSet<String>();
- map.put(key, set);
- }
- set.add(value);
- }
-
- private <K> void addMapping(Map<K, Set<JMethod>> map, K key,
- JMethod value) {
- Set<JMethod> set = map.get(key);
- if (set == null) {
- set = new TreeSet<JMethod>(jMethodComparator);
- map.put(key, set);
- }
- set.add(value);
- }
-
- private <K, V> boolean hasMapping(Map<K, Set<V>> map, K key, V value) {
- return map.containsKey(key) && map.get(key).contains(value);
- }
-
- private boolean isNeedsInvoker(JClassType type, JMethod method) {
- if (hasMapping(needsInvoker, type, method)) {
- return true;
- } else {
- return previousBundle != null
- && previousBundle.isNeedsInvoker(type, method);
- }
- }
-
- public Map<JClassType, Set<JMethod>> getNeedsInvoker() {
- return Collections.unmodifiableMap(needsInvoker);
- }
-
- public void setNeedsParamTypes(JClassType type, JMethod method) {
- if (!isNeedsParamTypes(type, method)) {
- addMapping(needsParamTypes, type, method);
- }
- }
-
- private boolean isNeedsParamTypes(JClassType type, JMethod method) {
- if (hasMapping(needsParamTypes, type, method)) {
- return true;
- } else {
- return previousBundle != null
- && previousBundle.isNeedsParamTypes(type, method);
- }
- }
-
- public Map<JClassType, Set<JMethod>> getNeedsParamTypes() {
- return Collections.unmodifiableMap(needsParamTypes);
- }
-
- public void setNeedsProxySupport(JClassType type) {
- if (!isNeedsProxySupport(type)) {
- needsProxySupport.add(type);
- }
- }
-
- private boolean isNeedsProxySupport(JClassType type) {
- if (needsProxySupport.contains(type)) {
- return true;
- } else {
- return previousBundle != null
- && previousBundle.isNeedsProxySupport(type);
- }
- }
-
- public Set<JClassType> getNeedsProxySupport() {
- return Collections.unmodifiableSet(needsProxySupport);
- }
-
- public void setMethodAttribute(JClassType type, JMethod method,
- MethodAttribute methodAttribute) {
- if (!hasMethodAttribute(type, method, methodAttribute)) {
- Map<JMethod, Set<MethodAttribute>> typeData = methodAttributes
- .get(type);
- if (typeData == null) {
- typeData = new TreeMap<JMethod, Set<MethodAttribute>>(
- jMethodComparator);
- methodAttributes.put(type, typeData);
- }
-
- Map<JMethod, Set<MethodAttribute>> methods = methodAttributes
- .get(type);
- if (methods == null) {
- methods = new TreeMap<JMethod, Set<MethodAttribute>>(
- jMethodComparator);
- methodAttributes.put(type, methods);
- }
-
- Set<MethodAttribute> attributes = methods.get(method);
- if (attributes == null) {
- attributes = new TreeSet<MethodAttribute>();
- methods.put(method, attributes);
- }
-
- attributes.add(methodAttribute);
- }
- }
-
- private boolean hasMethodAttribute(JClassType type, JMethod method,
- MethodAttribute methodAttribute) {
- Map<JMethod, Set<MethodAttribute>> typeData = methodAttributes
- .get(type);
- if (typeData != null && hasMapping(typeData, method, methodAttribute)) {
- return true;
- } else {
- return previousBundle != null && previousBundle
- .hasMethodAttribute(type, method, methodAttribute);
- }
- }
-
- public Map<JClassType, Map<JMethod, Set<MethodAttribute>>> getMethodAttributes() {
- return Collections.unmodifiableMap(methodAttributes);
- }
-
- public void setNeedsSerialize(JType type) {
- if (!hasSerializeSupport(type)) {
- needsSerializeSupport.add(type);
- }
- }
-
- private static Set<Class<?>> frameworkHandledTypes = new LinkedHashSet<Class<?>>();
- {
- frameworkHandledTypes.add(String.class);
- frameworkHandledTypes.add(Boolean.class);
- frameworkHandledTypes.add(Integer.class);
- frameworkHandledTypes.add(Float.class);
- frameworkHandledTypes.add(Double.class);
- frameworkHandledTypes.add(Long.class);
- frameworkHandledTypes.add(Enum.class);
- frameworkHandledTypes.add(String[].class);
- frameworkHandledTypes.add(Object[].class);
- frameworkHandledTypes.add(Map.class);
- frameworkHandledTypes.add(List.class);
- frameworkHandledTypes.add(Set.class);
- frameworkHandledTypes.add(Byte.class);
- frameworkHandledTypes.add(Character.class);
- frameworkHandledTypes.add(Void.class);
- }
-
- private boolean serializationHandledByFramework(JType setterType) {
- // Some types are handled by the framework at the moment. See #8449
- // This method should be removed at some point.
- if (setterType.isPrimitive() != null) {
- return true;
- }
-
- String qualifiedName = setterType.getQualifiedSourceName();
- for (Class<?> cls : frameworkHandledTypes) {
- if (qualifiedName.equals(cls.getName())) {
- return true;
- }
- }
-
- return false;
- }
-
- private boolean hasSerializeSupport(JType type) {
- if (hasSerializeSupport.contains(type)) {
- return true;
- } else {
- return previousBundle != null
- && previousBundle.hasSerializeSupport(type);
- }
- }
-
- public void setNeedsDelegateToWidget(Property property, JClassType type) {
- if (!isNeedsDelegateToWidget(type)) {
- TreeSet<Property> set = new TreeSet<Property>();
- set.add(property);
- needsDelegateToWidget.put(type, set);
- } else if (!needsDelegateToWidget.get(type).contains(property)) {
- needsDelegateToWidget.get(type).add(property);
- }
- }
-
- private boolean isNeedsDelegateToWidget(JClassType type) {
- if (needsDelegateToWidget.containsKey(type)) {
- return true;
- } else {
- return previousBundle != null
- && previousBundle.isNeedsDelegateToWidget(type);
- }
- }
-
- public Map<JClassType, Set<Property>> getNeedsDelegateToWidget() {
- return Collections.unmodifiableMap(needsDelegateToWidget);
- }
-
- public void setNeedsOnStateChangeHandler(JClassType type, JMethod method) {
- if (!isNeedsOnStateChangeHandler(type, method)) {
- addMapping(needsOnStateChange, type, method);
- }
- }
-
- private boolean isNeedsOnStateChangeHandler(JClassType type,
- JMethod method) {
- if (hasMapping(needsOnStateChange, type, method)) {
- return true;
- } else {
- return previousBundle != null
- && previousBundle.isNeedsOnStateChangeHandler(type, method);
- }
- }
-
- public Map<JClassType, Set<JMethod>> getNeedsOnStateChangeHandler() {
- return Collections.unmodifiableMap(needsOnStateChange);
- }
-
- public static JMethod findInheritedMethod(JClassType type,
- String methodName, JType... params) {
-
- JClassType currentType = type;
- while (currentType != null) {
- JMethod method = currentType.findMethod(methodName, params);
- if (method != null) {
- return method;
- }
- currentType = currentType.getSuperclass();
- }
-
- JClassType[] interfaces = type.getImplementedInterfaces();
- for (JClassType iface : interfaces) {
- JMethod method = iface.findMethod(methodName, params);
- if (method != null) {
- return method;
- }
- }
-
- return null;
- }
- }
|