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 2009 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.gwt.uibinder.rebind;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JPrimitiveType;
import com.google.gwt.core.ext.typeinfo.JType;
import com.google.gwt.core.ext.typeinfo.TypeOracle;
import java.util.Arrays;
import java.util.LinkedHashSet;
/**
* Represents a {field.reference}. Collects all the types a
* particular reference has been asked to return, and can validate that it
* actually does so.
*/
public class FieldReference {
private static class LeftHand {
/**
* The type of values acceptible to this LHS, in order of preference
*/
private final JType[] types;
/**
* The element on the LHS, for error reporting
*/
private final XMLElement source;
LeftHand(XMLElement source, JType... types) {
this.types = Arrays.copyOf(types, types.length);
this.source = source;
}
}
public static String renderTypesList(JType[] types) {
StringBuilder b = new StringBuilder();
for (int i = 0; i < types.length; i++) {
if (i > 0 && i == types.length - 1) {
b.append(" or ");
} else if (i > 0) {
b.append(", ");
}
b.append(types[i].getQualifiedSourceName());
}
return b.toString();
}
private final FieldManager fieldManager;
private final XMLElement source;
private final String debugString;
private final String[] elements;
private final LinkedHashSet leftHandTypes = new LinkedHashSet();
private final TypeOracle typeOracle;
FieldReference(String reference, XMLElement source, FieldManager fieldManager,
TypeOracle typeOracle) {
this.source = source;
this.debugString = "{" + reference + "}";
this.fieldManager = fieldManager;
this.typeOracle = typeOracle;
elements = reference.split("\\.");
}
public void addLeftHandType(XMLElement source, JType... types) {
leftHandTypes.add(new LeftHand(source, types));
}
public String getFieldName() {
return elements[0];
}
public JType getReturnType() {
return getReturnType(null);
}
/**
* Returns the type returned by this field ref.
*
* @param logger optional logger to report errors on, may be null
* @return the field ref, or null
*/
public JType getReturnType(MonitoredLogger logger) {
FieldWriter field = fieldManager.lookup(elements[0]);
if (field == null) {
if (logger != null) {
/*
* It's null when called from HtmlTemplateMethodWriter, which fires
* after validation has already succeeded.
*/
logger.error(source, "in %s, no field named %s", this, elements[0]);
}
return null;
}
return field.getReturnType(elements, logger);
}
public XMLElement getSource() {
return source;
}
@Override
public String toString() {
return debugString;
}
public void validate(MonitoredLogger logger) {
JType myReturnType = getReturnType(logger);
if (myReturnType == null) {
return;
}
for (LeftHand left : leftHandTypes) {
ensureAssignable(left, myReturnType, logger);
}
}
/**
* Returns a failure message if the types don't mesh, or null on success.
*/
private void ensureAssignable(LeftHand left, JType rightHandType, MonitoredLogger logger) {
assert left.types.length > 0;
for (JType leftType : left.types) {
if (leftType == rightHandType) {
return;
}
if (matchingNumberTypes(leftType, rightHandType)) {
return;
}
boolean[] explicitFailure = {false};
if (handleMismatchedNonNumericPrimitives(leftType, rightHandType, explicitFailure)) {
if (explicitFailure[0]) {
continue;
}
}
JClassType leftClass = leftType.isClassOrInterface();
if (leftClass != null) {
JClassType rightClass = rightHandType.isClassOrInterface();
if ((rightClass == null) || !leftClass.isAssignableFrom(rightClass)) {
continue;
}
}
/*
* If we have reached the bottom of the loop, we don't see a problem with
* assigning to this left hand type. Return without logging any error.
* This is pretty conservative -- we have a white list of bad conditions,
* not an exhaustive check of valid assignments. We're not confident that
* we know every error case, and are more worried about being artificially
* restrictive.
*/
return;
}
/*
* Every possible left hand type had some kind of failure. Log this sad
* fact, which will halt processing.
*/
logger.error(left.source, "%s required, but %s returns %s", renderTypesList(left.types),
FieldReference.this, rightHandType.getQualifiedSourceName());
}
private boolean handleMismatchedNonNumericPrimitives(JType leftType, JType rightHandType,
boolean[] explicitFailure) {
JPrimitiveType leftPrimitive = leftType.isPrimitive();
JPrimitiveType rightPrimitive = rightHandType.isPrimitive();
if (leftPrimitive == null && rightPrimitive == null) {
return false;
}
if (leftPrimitive != null) {
JClassType autobox = typeOracle.findType(leftPrimitive.getQualifiedBoxedSourceName());
if (rightHandType != autobox) {
explicitFailure[0] = true;
}
} else { // rightPrimitive != null
JClassType autobox = typeOracle.findType(rightPrimitive.getQualifiedBoxedSourceName());
if (leftType != autobox) {
explicitFailure[0] = true;
}
}
return true;
}
private boolean isNumber(JType type) {
JClassType numberType = typeOracle.findType(Number.class.getCanonicalName());
JClassType asClass = type.isClass();
if (asClass != null) {
return numberType.isAssignableFrom(asClass);
}
JPrimitiveType asPrimitive = type.isPrimitive();
if (asPrimitive != null) {
JClassType autoboxed = typeOracle.findType(asPrimitive.getQualifiedBoxedSourceName());
return numberType.isAssignableFrom(autoboxed);
}
return false;
}
private boolean matchingNumberTypes(JType leftHandType, JType rightHandType) {
/*
* int i = (int) 1.0 is okay Integer i = (int) 1.0 is okay int i = (int)
* Double.valueOf(1.0) is not
*/
if (isNumber(leftHandType) && isNumber(rightHandType) //
&& (rightHandType.isPrimitive() != null)) {
return true; // They will be cast into submission
}
return false;
}
}
