Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Copyright 2010 Google 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 com.google.web.bindery.requestfactory.gwt.rebind.model;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JMethod;
import com.google.gwt.core.ext.typeinfo.JParameter;
import com.google.gwt.core.ext.typeinfo.JParameterizedType;
import com.google.gwt.core.ext.typeinfo.JType;
import com.google.gwt.core.ext.typeinfo.TypeOracle;
import com.google.gwt.editor.rebind.model.ModelUtils;
import com.google.web.bindery.autobean.gwt.rebind.model.JBeanMethod;
import com.google.web.bindery.autobean.shared.Splittable;
import com.google.web.bindery.requestfactory.gwt.rebind.model.EntityProxyModel.Type;
import com.google.web.bindery.requestfactory.gwt.rebind.model.RequestMethod.CollectionType;
import com.google.web.bindery.requestfactory.shared.BaseProxy;
import com.google.web.bindery.requestfactory.shared.EntityProxy;
import com.google.web.bindery.requestfactory.shared.EntityProxyId;
import com.google.web.bindery.requestfactory.shared.ExtraTypes;
import com.google.web.bindery.requestfactory.shared.InstanceRequest;
import com.google.web.bindery.requestfactory.shared.JsonRpcProxy;
import com.google.web.bindery.requestfactory.shared.JsonRpcService;
import com.google.web.bindery.requestfactory.shared.ProxyFor;
import com.google.web.bindery.requestfactory.shared.ProxyForName;
import com.google.web.bindery.requestfactory.shared.Request;
import com.google.web.bindery.requestfactory.shared.RequestContext;
import com.google.web.bindery.requestfactory.shared.RequestFactory;
import com.google.web.bindery.requestfactory.shared.Service;
import com.google.web.bindery.requestfactory.shared.ServiceName;
import com.google.web.bindery.requestfactory.shared.ValueProxy;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* Represents a RequestFactory interface declaration.
*/
public class RequestFactoryModel implements AcceptsModelVisitor, HasExtraTypes {
public static String poisonedMessage() {
return "Unable to create RequestFactoryModel model due to previous errors";
}
static String badContextReturnType(JMethod method, JClassType requestInterface,
JClassType instanceRequestInterface) {
return String.format("Return type %s in method %s must be an interface assignable"
+ " to %s or %s", method.getReturnType(), method.getName(), requestInterface
.getSimpleSourceName(), instanceRequestInterface.getSimpleSourceName());
}
static String noSettersAllowed(JMethod found) {
return String.format("Optional setters not allowed here: %s", found.getName());
}
private final JClassType collectionInterface;
private final List contextMethods = new ArrayList();
private final JClassType entityProxyIdInterface;
private final JClassType entityProxyInterface;
private final List extraTypes;
private final JClassType factoryType;
private final JClassType instanceRequestInterface;
private final JClassType listInterface;
private final TreeLogger logger;
private final JClassType mapInterface;
private final TypeOracle oracle;
/**
* This map prevents cyclic type dependencies from overflowing the stack.
*/
private final Map peerBuilders =
new HashMap();
/**
* Iterated by {@link #getAllProxyModels()}.
*/
private final Map peers =
new LinkedHashMap();
private boolean poisoned;
private final JClassType requestContextInterface;
private final JClassType requestFactoryInterface;
private final JClassType requestInterface;
private final JClassType setInterface;
private final JClassType splittableType;
private final JClassType valueProxyInterface;
public RequestFactoryModel(TreeLogger logger, JClassType factoryType)
throws UnableToCompleteException {
this.logger = logger;
this.factoryType = factoryType;
this.oracle = factoryType.getOracle();
collectionInterface = oracle.findType(Collection.class.getCanonicalName());
entityProxyIdInterface = oracle.findType(EntityProxyId.class.getCanonicalName());
entityProxyInterface = oracle.findType(EntityProxy.class.getCanonicalName());
instanceRequestInterface = oracle.findType(InstanceRequest.class.getCanonicalName());
listInterface = oracle.findType(List.class.getCanonicalName());
mapInterface = oracle.findType(Map.class.getCanonicalName());
requestContextInterface = oracle.findType(RequestContext.class.getCanonicalName());
requestFactoryInterface = oracle.findType(RequestFactory.class.getCanonicalName());
requestInterface = oracle.findType(Request.class.getCanonicalName());
setInterface = oracle.findType(Set.class.getCanonicalName());
splittableType = oracle.findType(Splittable.class.getCanonicalName());
valueProxyInterface = oracle.findType(ValueProxy.class.getCanonicalName());
extraTypes = checkExtraTypes(factoryType, false);
for (JMethod method : factoryType.getOverridableMethods()) {
if (method.getEnclosingType().equals(requestFactoryInterface)) {
// Ignore methods defined an RequestFactory itself
continue;
}
if (method.getParameters().length > 0) {
poison("Unexpected parameter on method %s", method.getName());
continue;
}
JClassType contextType = method.getReturnType().isInterface();
if (contextType == null || !requestContextInterface.isAssignableFrom(contextType)) {
poison("Unexpected return type %s on method %s is not" + " an interface assignable to %s",
method.getReturnType().getQualifiedSourceName(), method.getName(),
requestContextInterface.getSimpleSourceName());
continue;
}
ContextMethod.Builder builder = new ContextMethod.Builder();
builder.setDeclaredMethod(method);
buildContextMethod(builder, contextType);
contextMethods.add(builder.build());
}
if (poisoned) {
die(poisonedMessage());
}
}
public void accept(ModelVisitor visitor) {
if (visitor.visit(this)) {
for (EntityProxyModel model : getAllProxyModels()) {
model.accept(visitor);
}
for (ContextMethod method : getMethods()) {
method.accept(visitor);
}
}
visitor.endVisit(this);
}
public Collection getAllProxyModels() {
return Collections.unmodifiableCollection(peers.values());
}
/**
* These extra types will have already been added to the extra types for each
* {@link ContextMethod} in the model.
*/
public List getExtraTypes() {
return Collections.unmodifiableList(extraTypes);
}
public JClassType getFactoryType() {
return factoryType;
}
public List getMethods() {
return Collections.unmodifiableList(contextMethods);
}
public EntityProxyModel getPeer(JClassType entityProxyType) {
return peers.get(entityProxyType);
}
/**
* For debugging use only.
*/
@Override
public String toString() {
return getFactoryType().getQualifiedSourceName();
}
/**
* Examine a RequestContext subtype to populate a ContextMethod.
*/
private void buildContextMethod(ContextMethod.Builder contextBuilder, JClassType contextType)
throws UnableToCompleteException {
Service serviceAnnotation = contextType.getAnnotation(Service.class);
ServiceName serviceNameAnnotation = contextType.getAnnotation(ServiceName.class);
JsonRpcService jsonRpcAnnotation = contextType.getAnnotation(JsonRpcService.class);
if (serviceAnnotation == null && serviceNameAnnotation == null && jsonRpcAnnotation == null) {
poison("RequestContext subtype %s is missing a @%s or @%s annotation", contextType
.getQualifiedSourceName(), Service.class.getSimpleName(), JsonRpcService.class
.getSimpleName());
return;
}
List requestMethods = new ArrayList();
for (JMethod method : contextType.getInheritableMethods()) {
if (method.getEnclosingType().equals(requestContextInterface)) {
// Ignore methods declared in RequestContext
continue;
}
RequestMethod.Builder methodBuilder = new RequestMethod.Builder();
methodBuilder.setDeclarationMethod(contextType, method);
if (!validateContextMethodAndSetDataType(methodBuilder, method, jsonRpcAnnotation != null)) {
continue;
}
requestMethods.add(methodBuilder.build());
}
contextBuilder.setExtraTypes(checkExtraTypes(contextType, true)).setRequestMethods(
requestMethods);
}
/**
* Checks type and its supertypes for {@link ExtraTypes} annotations.
*
* @param type the type to examine
* @param addModelExtraTypes if {@code true} the contents of the
* {@link #extraTypes} field will be added to the returned list.
*/
private List checkExtraTypes(JClassType type, boolean addModelExtraTypes)
throws UnableToCompleteException {
Set toReturn = new LinkedHashSet();
if (addModelExtraTypes && extraTypes != null) {
toReturn.addAll(extraTypes);
}
for (JClassType toExamine : type.getFlattenedSupertypeHierarchy()) {
ExtraTypes proxyExtraTypes = toExamine.getAnnotation(ExtraTypes.class);
if (proxyExtraTypes != null) {
for (Class clazz : proxyExtraTypes.value()) {
JClassType proxy = oracle.findType(clazz.getCanonicalName());
if (proxy == null) {
poison("Unknown class %s in @%s", clazz.getCanonicalName(), ExtraTypes.class
.getSimpleName());
} else {
toReturn.add(getEntityProxyType(proxy));
}
}
}
}
if (toReturn.isEmpty()) {
return Collections.emptyList();
}
return new ArrayList(toReturn);
}
private void die(String message) throws UnableToCompleteException {
poison(message);
throw new UnableToCompleteException();
}
private EntityProxyModel getEntityProxyType(JClassType entityProxyType)
throws UnableToCompleteException {
entityProxyType = ModelUtils.ensureBaseType(entityProxyType);
EntityProxyModel toReturn = peers.get(entityProxyType);
if (toReturn == null) {
EntityProxyModel.Builder inProgress = peerBuilders.get(entityProxyType);
if (inProgress != null) {
toReturn = inProgress.peek();
}
}
if (toReturn == null) {
EntityProxyModel.Builder builder = new EntityProxyModel.Builder();
peerBuilders.put(entityProxyType, builder);
// Validate possible super-proxy types first
for (JClassType supertype : entityProxyType.getFlattenedSupertypeHierarchy()) {
List superTypes = new ArrayList();
if (supertype != entityProxyType && shouldAttemptProxyValidation(supertype)) {
superTypes.add(getEntityProxyType(supertype));
}
builder.setSuperProxyTypes(superTypes);
}
builder.setQualifiedBinaryName(ModelUtils.getQualifiedBaseBinaryName(entityProxyType));
builder.setQualifiedSourceName(ModelUtils.getQualifiedBaseSourceName(entityProxyType));
if (entityProxyInterface.isAssignableFrom(entityProxyType)) {
builder.setType(Type.ENTITY);
} else if (valueProxyInterface.isAssignableFrom(entityProxyType)) {
builder.setType(Type.VALUE);
} else {
poison("The type %s is not assignable to either %s or %s", entityProxyInterface
.getQualifiedSourceName(), valueProxyInterface.getQualifiedSourceName());
// Cannot continue, since knowing the behavior is crucial
die(poisonedMessage());
}
// Get the server domain object type
ProxyFor proxyFor = entityProxyType.getAnnotation(ProxyFor.class);
ProxyForName proxyForName = entityProxyType.getAnnotation(ProxyForName.class);
JsonRpcProxy jsonRpcProxy = entityProxyType.getAnnotation(JsonRpcProxy.class);
if (proxyFor == null && proxyForName == null && jsonRpcProxy == null) {
poison("The %s type does not have a @%s, @%s, or @%s annotation", entityProxyType
.getQualifiedSourceName(), ProxyFor.class.getSimpleName(), ProxyForName.class
.getSimpleName(), JsonRpcProxy.class.getSimpleName());
}
// Look at the methods declared on the EntityProxy
List requestMethods = new ArrayList();
Map duplicatePropertyGetters = new HashMap();
for (JMethod method : entityProxyType.getInheritableMethods()) {
if (method.getEnclosingType().equals(entityProxyInterface)) {
// Ignore methods on EntityProxy
continue;
}
RequestMethod.Builder methodBuilder = new RequestMethod.Builder();
methodBuilder.setDeclarationMethod(entityProxyType, method);
JType transportedType;
String name = method.getName();
if (JBeanMethod.GET.matches(method)) {
transportedType = method.getReturnType();
String propertyName = JBeanMethod.GET.inferName(method);
JMethod previouslySeen = duplicatePropertyGetters.get(propertyName);
if (previouslySeen == null) {
duplicatePropertyGetters.put(propertyName, method);
} else {
poison("Duplicate accessors for property %s: %s() and %s()", propertyName,
previouslySeen.getName(), method.getName());
}
} else if (JBeanMethod.SET.matches(method) || JBeanMethod.SET_BUILDER.matches(method)) {
transportedType = method.getParameters()[0].getType();
} else if (name.equals("stableId") && method.getParameters().length == 0) {
// Ignore any overload of stableId
continue;
} else {
poison("The method %s is neither a getter nor a setter", method.getReadableDeclaration());
continue;
}
validateTransportableType(methodBuilder, transportedType, false);
RequestMethod requestMethod = methodBuilder.build();
requestMethods.add(requestMethod);
}
builder.setExtraTypes(checkExtraTypes(entityProxyType, false)).setRequestMethods(
requestMethods);
toReturn = builder.build();
peers.put(entityProxyType, toReturn);
peerBuilders.remove(entityProxyType);
}
return toReturn;
}
private void poison(String message, Object... args) {
logger.log(TreeLogger.ERROR, String.format(message, args));
poisoned = true;
}
/**
* Returns {@code true} if the type is assignable to EntityProxy or ValueProxy
* and has a mapping to a domain type.
*
* @see com.google.web.bindery.requestfactory.server.RequestFactoryInterfaceValidator#shouldAttemptProxyValidation()
*/
private boolean shouldAttemptProxyValidation(JClassType maybeProxy) {
if (!entityProxyInterface.isAssignableFrom(maybeProxy)
&& !valueProxyInterface.isAssignableFrom(maybeProxy)) {
return false;
}
if (maybeProxy.getAnnotation(ProxyFor.class) == null
&& maybeProxy.getAnnotation(ProxyForName.class) == null) {
return false;
}
return true;
}
/**
* Examine a RequestContext method to see if it returns a transportable type.
*/
private boolean validateContextMethodAndSetDataType(RequestMethod.Builder methodBuilder,
JMethod method, boolean allowSetters) throws UnableToCompleteException {
JClassType requestReturnType = method.getReturnType().isInterface();
JClassType invocationReturnType;
if (requestReturnType == null) {
// Primitive return type
poison(badContextReturnType(method, requestInterface, instanceRequestInterface));
return false;
}
if (instanceRequestInterface.isAssignableFrom(requestReturnType)) {
// Instance method invocation
JClassType[] params =
ModelUtils.findParameterizationOf(instanceRequestInterface, requestReturnType);
methodBuilder.setInstanceType(getEntityProxyType(params[0]));
invocationReturnType = params[1];
} else if (requestInterface.isAssignableFrom(requestReturnType)) {
// Static method invocation
JClassType[] params = ModelUtils.findParameterizationOf(requestInterface, requestReturnType);
invocationReturnType = params[0];
} else {
// Unhandled return type, must be something random
poison(badContextReturnType(method, requestInterface, instanceRequestInterface));
return false;
}
// Validate the parameters
boolean paramsOk = true;
JParameter[] params = method.getParameters();
for (int i = 0; i < params.length; ++i) {
JParameter param = params[i];
paramsOk =
validateTransportableType(new RequestMethod.Builder(), param.getType(), false)
&& paramsOk;
}
// Validate any extra properties on the request type
for (JMethod maybeSetter : requestReturnType.getInheritableMethods()) {
if (JBeanMethod.SET.matches(maybeSetter) || JBeanMethod.SET_BUILDER.matches(maybeSetter)) {
if (allowSetters) {
methodBuilder.addExtraSetter(maybeSetter);
} else {
poison(noSettersAllowed(maybeSetter));
}
}
}
return validateTransportableType(methodBuilder, invocationReturnType, true);
}
/**
* Examines a type to see if it can be transported.
*/
private boolean validateTransportableType(RequestMethod.Builder methodBuilder, JType type,
boolean requireObject) throws UnableToCompleteException {
JClassType transportedClass = type.isClassOrInterface();
if (transportedClass == null) {
if (requireObject) {
poison("The type %s cannot be transported by RequestFactory as" + " a return type", type
.getQualifiedSourceName());
return false;
} else {
// Primitives always ok
return true;
}
}
if (ModelUtils.isValueType(oracle, transportedClass) || splittableType.equals(transportedClass)) {
// Simple values, like Integer and String
methodBuilder.setValueType(true);
} else if (entityProxyInterface.isAssignableFrom(transportedClass)
|| valueProxyInterface.isAssignableFrom(transportedClass)) {
// EntityProxy and ValueProxy return types
methodBuilder.setEntityType(getEntityProxyType(transportedClass));
} else if (entityProxyIdInterface.isAssignableFrom(transportedClass)) {
JParameterizedType parameterized = transportedClass.isParameterized();
if (parameterized == null) {
poison("EntityProxyId must be parameterized");
return false;
}
// Also check that the EntityProxy type can be transported
JClassType entityType =
ModelUtils.findParameterizationOf(entityProxyIdInterface, transportedClass)[0];
methodBuilder.setEntityType(getEntityProxyType(entityType));
} else if (collectionInterface.isAssignableFrom(transportedClass)) {
// Only allow certain collections for now
JParameterizedType parameterized = transportedClass.isParameterized();
if (parameterized == null) {
poison("Requests that return collections of List or Set must be parameterized");
return false;
}
if (listInterface.equals(parameterized.getBaseType())) {
methodBuilder.setCollectionType(CollectionType.LIST);
} else if (setInterface.equals(parameterized.getBaseType())) {
methodBuilder.setCollectionType(CollectionType.SET);
} else {
poison("Requests that return collections may be declared with" + " %s or %s only",
listInterface.getQualifiedSourceName(), setInterface.getQualifiedSourceName());
return false;
}
// Also record the element type in the method builder
JClassType elementType =
ModelUtils.findParameterizationOf(collectionInterface, transportedClass)[0];
methodBuilder.setCollectionElementType(elementType);
validateTransportableType(methodBuilder, elementType, requireObject);
} else if (mapInterface.isAssignableFrom(transportedClass)) {
JParameterizedType parameterized = transportedClass.isParameterized();
if (parameterized == null) {
poison("Requests that return Maps must be parameterized");
return false;
}
if (mapInterface.equals(parameterized.getBaseType())) {
methodBuilder.setCollectionType(CollectionType.MAP);
} else {
poison("Requests that return maps may be declared with" + " %s only", mapInterface
.getQualifiedSourceName());
return false;
}
// Also record the element type in the method builder
JClassType[] params = ModelUtils.findParameterizationOf(mapInterface, transportedClass);
JClassType keyType = params[0];
JClassType valueType = params[1];
methodBuilder.setMapKeyType(keyType);
methodBuilder.setMapValueType(valueType);
validateTransportableType(methodBuilder, keyType, requireObject);
validateTransportableType(methodBuilder, valueType, requireObject);
} else {
// Unknown type, fail
poison("Invalid Request parameterization %s", transportedClass.getQualifiedSourceName());
return false;
}
methodBuilder.setDataType(transportedClass);
return true;
}
}
