/*
* Copyright 2000-2016 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.client.metadata;
import java.util.ArrayList;
import java.util.Collection;
import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.core.client.JsArrayString;
import com.vaadin.client.FastStringMap;
import com.vaadin.client.FastStringSet;
import com.vaadin.client.JsArrayObject;
import com.vaadin.client.annotations.OnStateChange;
import com.vaadin.client.communication.JSONSerializer;
import com.vaadin.shared.annotations.NoLayout;
public class TypeDataStore {
public static enum MethodAttribute {
DELAYED, LAST_ONLY, NO_LAYOUT, NO_LOADING_INDICATOR;
}
private static final String CONSTRUCTOR_NAME = "!new";
private final FastStringMap<Class<?>> identifiers = FastStringMap.create();
private final FastStringMap<Invoker> serializerFactories = FastStringMap
.create();
private final FastStringMap<ProxyHandler> proxyHandlers = FastStringMap
.create();
private final FastStringMap<JsArrayString> delegateToWidgetProperties = FastStringMap
.create();
private final FastStringMap<Type> presentationTypes = FastStringMap
.create();
/**
* Maps connector class -> state property name -> hander method data
*/
private final FastStringMap<FastStringMap<JsArrayObject<OnStateChangeMethod>>> onStateChangeMethods = FastStringMap
.create();
private final FastStringMap<FastStringSet> methodAttributes = FastStringMap
.create();
private final FastStringMap<Type> returnTypes = FastStringMap.create();
private final FastStringMap<Invoker> invokers = FastStringMap.create();
private final FastStringMap<Type[]> paramTypes = FastStringMap.create();
private final FastStringMap<String> delegateToWidget = FastStringMap
.create();
private final JavaScriptObject jsTypeData = JavaScriptObject.createObject();
public static TypeDataStore get() {
return ConnectorBundleLoader.get().getTypeDataStore();
}
public void setClass(String identifier, Class<?> type) {
identifiers.put(identifier, type);
}
public static Class<?> getClass(String identifier) throws NoDataException {
Class<?> class1 = get().identifiers.get(identifier);
if (class1 == null) {
throw new NoDataException(
"There is not class for identifier " + identifier);
}
return class1;
}
// this is a very inefficient implementation for getting all the identifiers
// for a class
public FastStringSet findIdentifiersFor(Class<?> type) {
FastStringSet result = FastStringSet.create();
JsArrayString keys = identifiers.getKeys();
for (int i = 0; i < keys.length(); i++) {
String key = keys.get(i);
if (identifiers.get(key) == type) {
result.add(key);
}
}
return result;
}
public static Type getType(Class<?> clazz) {
return new Type(clazz);
}
public static Type getReturnType(Method method) throws NoDataException {
Type type = get().returnTypes.get(method.getLookupKey());
if (type == null) {
throw new NoDataException(
"There is no return type for " + method.getSignature());
}
return type;
}
public static Invoker getInvoker(Method method) throws NoDataException {
Invoker invoker = get().invokers.get(method.getLookupKey());
if (invoker == null) {
throw new NoDataException(
"There is no invoker for " + method.getSignature());
}
return invoker;
}
public static Invoker getConstructor(Type type) throws NoDataException {
Invoker invoker = get().invokers
.get(new Method(type, CONSTRUCTOR_NAME).getLookupKey());
if (invoker == null) {
throw new NoDataException(
"There is no constructor for " + type.getSignature());
}
return invoker;
}
public static Object getValue(Property property, Object target)
throws NoDataException {
return getJsPropertyValue(get().jsTypeData,
property.getBeanType().getBaseTypeName(), property.getName(),
target);
}
public static String getDelegateToWidget(Property property) {
return get().delegateToWidget.get(property.getLookupKey());
}
public static JsArrayString getDelegateToWidgetProperites(Type type) {
return get().delegateToWidgetProperties.get(type.getBaseTypeName());
}
public static Type getPresentationType(Class<?> type) {
return get().presentationTypes.get(getType(type).getBaseTypeName());
}
public void setDelegateToWidget(Class<?> clazz, String propertyName,
String delegateValue) {
Type type = getType(clazz);
delegateToWidget.put(new Property(type, propertyName).getLookupKey(),
delegateValue);
JsArrayString typeProperties = delegateToWidgetProperties
.get(type.getBaseTypeName());
if (typeProperties == null) {
typeProperties = JavaScriptObject.createArray().cast();
delegateToWidgetProperties.put(type.getBaseTypeName(),
typeProperties);
}
typeProperties.push(propertyName);
}
public void setPresentationType(Class<?> type, Class<?> presentationType) {
presentationTypes.put(getType(type).getBaseTypeName(),
getType(presentationType));
}
public void setReturnType(Class<?> type, String methodName,
Type returnType) {
returnTypes.put(new Method(getType(type), methodName).getLookupKey(),
returnType);
}
public void setConstructor(Class<?> type, Invoker constructor) {
setInvoker(type, CONSTRUCTOR_NAME, constructor);
}
public void setInvoker(Class<?> type, String methodName, Invoker invoker) {
invokers.put(new Method(getType(type), methodName).getLookupKey(),
invoker);
}
public static Type[] getParamTypes(Method method) throws NoDataException {
Type[] types = get().paramTypes.get(method.getLookupKey());
if (types == null) {
throw new NoDataException("There are no parameter type data for "
+ method.getSignature());
}
return types;
}
public void setParamTypes(Class<?> type, String methodName,
Type[] paramTypes) {
this.paramTypes.put(
new Method(getType(type), methodName).getLookupKey(),
paramTypes);
}
public static boolean hasIdentifier(String identifier) {
return get().identifiers.containsKey(identifier);
}
public static ProxyHandler getProxyHandler(Type type)
throws NoDataException {
ProxyHandler proxyHandler = get().proxyHandlers
.get(type.getBaseTypeName());
if (proxyHandler == null) {
throw new NoDataException(
"No proxy handler for " + type.getSignature());
}
return proxyHandler;
}
public void setProxyHandler(Class<?> type, ProxyHandler proxyHandler) {
proxyHandlers.put(getType(type).getBaseTypeName(), proxyHandler);
}
public static boolean isDelayed(Method method) {
return hasMethodAttribute(method, MethodAttribute.DELAYED);
}
public static boolean isNoLoadingIndicator(Method method) {
return hasMethodAttribute(method, MethodAttribute.NO_LOADING_INDICATOR);
}
private static boolean hasMethodAttribute(Method method,
MethodAttribute attribute) {
FastStringSet attributes = get().methodAttributes
.get(method.getLookupKey());
return attributes != null && attributes.contains(attribute.name());
}
public void setMethodAttribute(Class<?> type, String methodName,
MethodAttribute attribute) {
String key = getType(type).getMethod(methodName).getLookupKey();
FastStringSet attributes = methodAttributes.get(key);
if (attributes == null) {
attributes = FastStringSet.create();
methodAttributes.put(key, attributes);
}
attributes.add(attribute.name());
}
public static boolean isLastOnly(Method method) {
return hasMethodAttribute(method, MethodAttribute.LAST_ONLY);
}
/**
* @param type
* @return
* @throws NoDataException
*
* @deprecated As of 7.0.1, use {@link #getPropertiesAsArray(Type)} instead
* for improved performance
*/
@Deprecated
public static Collection<Property> getProperties(Type type)
throws NoDataException {
JsArrayObject<Property> propertiesArray = getPropertiesAsArray(type);
int size = propertiesArray.size();
ArrayList<Property> properties = new ArrayList<>(size);
for (int i = 0; i < size; i++) {
properties.add(propertiesArray.get(i));
}
return properties;
}
public static JsArrayObject<Property> getPropertiesAsArray(Type type)
throws NoDataException {
JsArrayString names = getJsPropertyNames(get().jsTypeData,
type.getBaseTypeName());
// Create Property instances for each property name
JsArrayObject<Property> properties = JavaScriptObject.createArray()
.cast();
for (int i = 0; i < names.length(); i++) {
properties.add(new Property(type, names.get(i)));
}
return properties;
}
public static Type getType(Property property) throws NoDataException {
return getJsPropertyType(get().jsTypeData,
property.getBeanType().getBaseTypeName(), property.getName());
}
public void setPropertyType(Class<?> clazz, String propertyName,
Type type) {
setJsPropertyType(jsTypeData, clazz.getName(), propertyName, type);
}
public static void setValue(Property property, Object target,
Object value) {
setJsPropertyValue(get().jsTypeData,
property.getBeanType().getBaseTypeName(), property.getName(),
target, value);
}
public void setSerializerFactory(Class<?> clazz, Invoker factory) {
serializerFactories.put(getType(clazz).getBaseTypeName(), factory);
}
public static JSONSerializer<?> findSerializer(Type type) {
Invoker factoryCreator = get().serializerFactories
.get(type.getBaseTypeName());
if (factoryCreator == null) {
return null;
}
return (JSONSerializer<?>) factoryCreator.invoke(null);
}
public static boolean hasProperties(Type type) {
return hasJsProperties(get().jsTypeData, type.getBaseTypeName());
}
public void setSuperClass(Class<?> baseClass, Class<?> superClass) {
String superClassName = superClass == null ? null
: superClass.getName();
setSuperClass(jsTypeData, baseClass.getName(), superClassName);
}
public void setPropertyData(Class<?> type, String propertyName,
JavaScriptObject propertyData) {
setPropertyData(jsTypeData, type.getName(), propertyName, propertyData);
}
private static native void setPropertyData(JavaScriptObject typeData,
String className, String propertyName,
JavaScriptObject propertyData)
/*-{
typeData[className][propertyName] = propertyData;
}-*/;
/*
* This method sets up prototypes chain for <code>baseClassName</code>.
* Precondition is : <code>superClassName</code> had to be handled before
* its child <code>baseClassName</code>.
*
* It makes all properties defined in the <code>superClassName</code>
* available for <code>baseClassName</code> as well.
*/
private static native void setSuperClass(JavaScriptObject typeData,
String baseClassName, String superClassName)
/*-{
var parentType = typeData[superClassName];
if (parentType !== undefined ){
var ctor = function () {};
ctor.prototype = parentType;
typeData[baseClassName] = new ctor;
}
else {
typeData[baseClassName] = {};
}
}-*/;
private static native boolean hasGetter(JavaScriptObject typeData,
String beanName, String propertyName)
/*-{
return typeData[beanName][propertyName].getter !== undefined;
}-*/;
private static native boolean hasSetter(JavaScriptObject typeData,
String beanName, String propertyName)
/*-{
return typeData[beanName][propertyName].setter !== undefined;
}-*/;
private static native boolean hasNoLayout(JavaScriptObject typeData,
String beanName, String propertyName)
/*-{
// Data is not available for Javascript state object properties as GWT knows nothing about them
return typeData[beanName][propertyName] && typeData[beanName][propertyName].noLayout !== undefined;
}-*/;
private static native Object getJsPropertyValue(JavaScriptObject typeData,
String beanName, String propertyName, Object beanInstance)
/*-{
return typeData[beanName][propertyName].getter(beanInstance);
}-*/;
private static native void setJsPropertyValue(JavaScriptObject typeData,
String beanName, String propertyName, Object beanInstance,
Object value)
/*-{
typeData[beanName][propertyName].setter(beanInstance, value);
}-*/;
private static native Type getJsPropertyType(JavaScriptObject typeData,
String beanName, String propertyName)
/*-{
return typeData[beanName][propertyName].type;
}-*/;
private static native void setJsPropertyType(JavaScriptObject typeData,
String beanName, String propertyName, Type type)
/*-{
typeData[beanName][propertyName].type = type;
}-*/;
private static native JsArrayString getJsPropertyNames(
JavaScriptObject typeData, String beanName)
/*-{
var names = [];
for(var name in typeData[beanName]) {
names.push(name);
}
return names;
}-*/;
private static native boolean hasJsProperties(JavaScriptObject typeData,
String beanName)
/*-{
return typeData[beanName] !== undefined ;
}-*/;
/**
* Gets data for all methods annotated with {@link OnStateChange} in the
* given connector type.
*
* @since 7.2
* @param type
* the connector type
* @return a map of state property names to handler method data
*/
public static FastStringMap<JsArrayObject<OnStateChangeMethod>> getOnStateChangeMethods(
Class<?> type) {
return get().onStateChangeMethods.get(getType(type).getSignature());
}
/**
* Adds data about a method annotated with {@link OnStateChange} for the
* given connector type.
*
* @since 7.2
* @param clazz
* the connector type
* @param method
* the state change method data
*/
public void addOnStateChangeMethod(Class<?> clazz,
OnStateChangeMethod method) {
FastStringMap<JsArrayObject<OnStateChangeMethod>> handlers = getOnStateChangeMethods(
clazz);
if (handlers == null) {
handlers = FastStringMap.create();
onStateChangeMethods.put(getType(clazz).getSignature(), handlers);
}
for (String property : method.getProperties()) {
JsArrayObject<OnStateChangeMethod> propertyHandlers = handlers
.get(property);
if (propertyHandlers == null) {
propertyHandlers = JsArrayObject.createArray().cast();
handlers.put(property, propertyHandlers);
}
propertyHandlers.add(method);
}
}
/**
* Checks whether the provided method is annotated with {@link NoLayout}.
*
* @param method
* the rpc method to check
*
* @since 7.4
*
* @return <code>true</code> if the method has a NoLayout annotation;
* otherwise <code>false</code>
*/
public static boolean isNoLayoutRpcMethod(Method method) {
return hasMethodAttribute(method, MethodAttribute.NO_LAYOUT);
}
/**
* Checks whether the provided property is annotated with {@link NoLayout}.
*
* @param property
* the property to check
*
* @since 7.4
*
* @return <code>true</code> if the property has a NoLayout annotation;
* otherwise <code>false</code>
*/
public static boolean isNoLayoutProperty(Property property) {
return hasNoLayout(get().jsTypeData,
property.getBeanType().getSignature(), property.getName());
}
}