2.1/user/src/com/google/gwt/user/rebind/rpc/RemoteServiceAsyncValidator.java - gwt - Git at Google

 /*
  * Copyright 2007 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.user.rebind.rpc;

 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.JPackage;
 import com.google.gwt.core.ext.typeinfo.JParameter;
 import com.google.gwt.core.ext.typeinfo.JPrimitiveType;
 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.google.gwt.http.client.Request;
 import com.google.gwt.http.client.RequestBuilder;
 import com.google.gwt.user.client.rpc.AsyncCallback;

 import java.util.HashMap;
 import java.util.Map;
 import java.util.TreeMap;

 /**
  * Validates the asynchronous version of
  * {@link com.google.gwt.user.client.rpc.RemoteService RemoteService} interface.
  */
 class RemoteServiceAsyncValidator {
   static void logValidAsyncInterfaceDeclaration(TreeLogger logger,
       JClassType remoteService) {
     TreeLogger branch = logger.branch(TreeLogger.INFO,
         "A valid definition for the asynchronous version of interface '"
             + remoteService.getQualifiedSourceName() + "' would be:\n", null);
     branch.log(TreeLogger.ERROR,
         synthesizeAsynchronousInterfaceDefinition(remoteService), null);
   }

   private static String computeAsyncMethodSignature(JMethod syncMethod,
       JClassType asyncCallbackClass) {
     return computeInternalSignature(syncMethod) + "/"
         + asyncCallbackClass.getQualifiedSourceName();
   }

   private static String computeInternalSignature(JMethod method) {
     StringBuffer sb = new StringBuffer();
     sb.setLength(0);
     sb.append(method.getName());
     JParameter[] params = method.getParameters();
     for (JParameter param : params) {
       sb.append("/");
       JType paramType = param.getType();
       sb.append(paramType.getErasedType().getQualifiedSourceName());
     }
     return sb.toString();
   }

   /**
    * Builds a map of asynchronous method internal signatures to the
    * corresponding asynchronous {@link JMethod}.
    */
   private static Map<String, JMethod> initializeAsyncMethodMap(
       JMethod[] asyncMethods) {
     Map<String, JMethod> sigs = new TreeMap<String, JMethod>();
     for (JMethod asyncMethod : asyncMethods) {
       sigs.put(computeInternalSignature(asyncMethod), asyncMethod);
     }
     return sigs;
   }

   private static String synthesizeAsynchronousInterfaceDefinition(
       JClassType serviceIntf) {
     StringBuffer sb = new StringBuffer();
     JPackage pkg = serviceIntf.getPackage();
     if (pkg != null) {
       sb.append("\npackage ");
       sb.append(pkg.getName());
       sb.append(";\n");
     }

     sb.append("\npublic interface ");
     sb.append(serviceIntf.getSimpleSourceName());
     sb.append("Async {\n");

     JMethod[] methods = serviceIntf.getOverridableMethods();
     for (JMethod method : methods) {
       assert (method != null);

       sb.append("\tvoid ");
       sb.append(method.getName());
       sb.append("(");

       JParameter[] params = method.getParameters();
       for (int paramIndex = 0; paramIndex < params.length; ++paramIndex) {
         JParameter param = params[paramIndex];

         if (paramIndex > 0) {
           sb.append(", ");
         }

         sb.append(param.toString());
       }

       if (params.length > 0) {
         sb.append(", ");
       }

       JType returnType = method.getReturnType();
       sb.append(AsyncCallback.class.getName());
       sb.append("<");
       if (returnType instanceof JPrimitiveType) {
         sb.append(((JPrimitiveType) returnType).getQualifiedBoxedSourceName());
       } else {
         sb.append(returnType.getParameterizedQualifiedSourceName());
       }
       sb.append("> arg");
       sb.append(Integer.toString(params.length + 1));
       sb.append(");\n");
     }

     sb.append("}");

     return sb.toString();
   }

   private static void validationFailed(TreeLogger branch,
       JClassType remoteService) throws UnableToCompleteException {
     logValidAsyncInterfaceDeclaration(branch, remoteService);
     throw new UnableToCompleteException();
   }

   /**
    * {@link JClassType} for the {@link AsyncCallback} interface.
    */
   private final JClassType asyncCallbackClass;

   /**
    * {@link JClassType} for the {@link RequestBuilder} class.
    */
   private final JClassType requestBuilderType;

   /**
    * {@link JClassType} for the {@link Request} class.
    */
   private final JClassType requestType;

   RemoteServiceAsyncValidator(TreeLogger logger, TypeOracle typeOracle)
       throws UnableToCompleteException {
     try {
       asyncCallbackClass = typeOracle.getType(AsyncCallback.class.getName());
       requestType = typeOracle.getType(Request.class.getCanonicalName());
       requestBuilderType = typeOracle.getType(RequestBuilder.class.getCanonicalName());
     } catch (NotFoundException e) {
       logger.log(TreeLogger.ERROR, null, e);
       throw new UnableToCompleteException();
     }
   }

   /**
    * Checks that for every method on the synchronous remote service interface
    * there is a corresponding asynchronous version in the asynchronous version
    * of the remote service. If the validation succeeds, a map of synchronous to
    * asynchronous methods is returned.
    *
    * @param logger
    * @param remoteService
    * @return map of synchronous method to asynchronous method
    *
    * @throws UnableToCompleteException if the asynchronous
    *           {@link com.google.gwt.user.client.rpc.RemoteService RemoteService}
    *           was not found, or if it does not have an asynchronous method
    *           version of every synchronous one
    */
   public Map<JMethod, JMethod> validate(TreeLogger logger,
       JClassType remoteService, JClassType remoteServiceAsync)
       throws UnableToCompleteException {
     TreeLogger branch = logger.branch(TreeLogger.DEBUG,
         "Checking the synchronous interface '"
             + remoteService.getQualifiedSourceName()
             + "' against its asynchronous version '"
             + remoteServiceAsync.getQualifiedSourceName() + "'", null);

     // Sync and async versions must have the same number of methods
     JMethod[] asyncMethods = remoteServiceAsync.getOverridableMethods();
     JMethod[] syncMethods = remoteService.getOverridableMethods();
     if (asyncMethods.length != syncMethods.length) {
       branch.branch(TreeLogger.ERROR, "The asynchronous version of "
           + remoteService.getQualifiedSourceName() + " has "
           + (asyncMethods.length > syncMethods.length ? "more" : "less")
           + " methods than the synchronous version", null);
       validationFailed(branch, remoteService);
     }

     // Check that for every sync method there is a corresponding async method
     boolean failed = false;
     Map<String, JMethod> asyncMethodMap = initializeAsyncMethodMap(asyncMethods);
     Map<JMethod, JMethod> syncMethodToAsyncMethodMap = new HashMap<JMethod, JMethod>();
     for (JMethod syncMethod : syncMethods) {
       String asyncSig = computeAsyncMethodSignature(syncMethod,
           asyncCallbackClass);
       JMethod asyncMethod = asyncMethodMap.get(asyncSig);
       if (asyncMethod == null) {
         branch.branch(TreeLogger.ERROR,
             "Missing asynchronous version of the synchronous method '"
                 + syncMethod.getReadableDeclaration() + "'", null);
         failed = true;
       } else {
         // TODO if async param is parameterized make sure that the sync return
         // type is assignable to the first type argument
         JType returnType = asyncMethod.getReturnType();
         if (returnType != JPrimitiveType.VOID && returnType != requestType
             && returnType != requestBuilderType) {
           branch.branch(TreeLogger.ERROR,
               "The asynchronous version of the synchronous method '"
                   + syncMethod.getReadableDeclaration()
                   + "' must have a return type of 'void' or '"
                   + Request.class.getCanonicalName() + "' or '"
                   + RequestBuilder.class.getCanonicalName() + "'", null);
           failed = true;
         } else {
           syncMethodToAsyncMethodMap.put(syncMethod, asyncMethod);
         }
       }
     }

     if (failed) {
       validationFailed(branch, remoteService);
     }

     branch.log(TreeLogger.DEBUG, "Interfaces are in sync");

     return syncMethodToAsyncMethodMap;
   }
 }
	/*
	* Copyright 2007 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.user.rebind.rpc;

	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.JPackage;
	import com.google.gwt.core.ext.typeinfo.JParameter;
	import com.google.gwt.core.ext.typeinfo.JPrimitiveType;
	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.google.gwt.http.client.Request;
	import com.google.gwt.http.client.RequestBuilder;
	import com.google.gwt.user.client.rpc.AsyncCallback;

	import java.util.HashMap;
	import java.util.Map;
	import java.util.TreeMap;

	/**
	* Validates the asynchronous version of
	* {@link com.google.gwt.user.client.rpc.RemoteService RemoteService} interface.
	*/
	class RemoteServiceAsyncValidator {
	static void logValidAsyncInterfaceDeclaration(TreeLogger logger,
	JClassType remoteService) {
	TreeLogger branch = logger.branch(TreeLogger.INFO,
	"A valid definition for the asynchronous version of interface '"
	+ remoteService.getQualifiedSourceName() + "' would be:\n", null);
	branch.log(TreeLogger.ERROR,
	synthesizeAsynchronousInterfaceDefinition(remoteService), null);
	}

	private static String computeAsyncMethodSignature(JMethod syncMethod,
	JClassType asyncCallbackClass) {
	return computeInternalSignature(syncMethod) + "/"
	+ asyncCallbackClass.getQualifiedSourceName();
	}

	private static String computeInternalSignature(JMethod method) {
	StringBuffer sb = new StringBuffer();
	sb.setLength(0);
	sb.append(method.getName());
	JParameter[] params = method.getParameters();
	for (JParameter param : params) {
	sb.append("/");
	JType paramType = param.getType();
	sb.append(paramType.getErasedType().getQualifiedSourceName());
	}
	return sb.toString();
	}

	/**
	* Builds a map of asynchronous method internal signatures to the
	* corresponding asynchronous {@link JMethod}.
	*/
	private static Map<String, JMethod> initializeAsyncMethodMap(
	JMethod[] asyncMethods) {
	Map<String, JMethod> sigs = new TreeMap<String, JMethod>();
	for (JMethod asyncMethod : asyncMethods) {
	sigs.put(computeInternalSignature(asyncMethod), asyncMethod);
	}
	return sigs;
	}

	private static String synthesizeAsynchronousInterfaceDefinition(
	JClassType serviceIntf) {
	StringBuffer sb = new StringBuffer();
	JPackage pkg = serviceIntf.getPackage();
	if (pkg != null) {
	sb.append("\npackage ");
	sb.append(pkg.getName());
	sb.append(";\n");
	}

	sb.append("\npublic interface ");
	sb.append(serviceIntf.getSimpleSourceName());
	sb.append("Async {\n");

	JMethod[] methods = serviceIntf.getOverridableMethods();
	for (JMethod method : methods) {
	assert (method != null);

	sb.append("\tvoid ");
	sb.append(method.getName());
	sb.append("(");

	JParameter[] params = method.getParameters();
	for (int paramIndex = 0; paramIndex < params.length; ++paramIndex) {
	JParameter param = params[paramIndex];

	if (paramIndex > 0) {
	sb.append(", ");
	}

	sb.append(param.toString());
	}

	if (params.length > 0) {
	sb.append(", ");
	}

	JType returnType = method.getReturnType();
	sb.append(AsyncCallback.class.getName());
	sb.append("<");
	if (returnType instanceof JPrimitiveType) {
	sb.append(((JPrimitiveType) returnType).getQualifiedBoxedSourceName());
	} else {
	sb.append(returnType.getParameterizedQualifiedSourceName());
	}
	sb.append("> arg");
	sb.append(Integer.toString(params.length + 1));
	sb.append(");\n");
	}

	sb.append("}");

	return sb.toString();
	}

	private static void validationFailed(TreeLogger branch,
	JClassType remoteService) throws UnableToCompleteException {
	logValidAsyncInterfaceDeclaration(branch, remoteService);
	throw new UnableToCompleteException();
	}

	/**
	* {@link JClassType} for the {@link AsyncCallback} interface.
	*/
	private final JClassType asyncCallbackClass;

	/**
	* {@link JClassType} for the {@link RequestBuilder} class.
	*/
	private final JClassType requestBuilderType;

	/**
	* {@link JClassType} for the {@link Request} class.
	*/
	private final JClassType requestType;

	RemoteServiceAsyncValidator(TreeLogger logger, TypeOracle typeOracle)
	throws UnableToCompleteException {
	try {
	asyncCallbackClass = typeOracle.getType(AsyncCallback.class.getName());
	requestType = typeOracle.getType(Request.class.getCanonicalName());
	requestBuilderType = typeOracle.getType(RequestBuilder.class.getCanonicalName());
	} catch (NotFoundException e) {
	logger.log(TreeLogger.ERROR, null, e);
	throw new UnableToCompleteException();
	}
	}

	/**
	* Checks that for every method on the synchronous remote service interface
	* there is a corresponding asynchronous version in the asynchronous version
	* of the remote service. If the validation succeeds, a map of synchronous to
	* asynchronous methods is returned.
	*
	* @param logger
	* @param remoteService
	* @return map of synchronous method to asynchronous method
	*
	* @throws UnableToCompleteException if the asynchronous
	* {@link com.google.gwt.user.client.rpc.RemoteService RemoteService}
	* was not found, or if it does not have an asynchronous method
	* version of every synchronous one
	*/
	public Map<JMethod, JMethod> validate(TreeLogger logger,
	JClassType remoteService, JClassType remoteServiceAsync)
	throws UnableToCompleteException {
	TreeLogger branch = logger.branch(TreeLogger.DEBUG,
	"Checking the synchronous interface '"
	+ remoteService.getQualifiedSourceName()
	+ "' against its asynchronous version '"
	+ remoteServiceAsync.getQualifiedSourceName() + "'", null);

	// Sync and async versions must have the same number of methods
	JMethod[] asyncMethods = remoteServiceAsync.getOverridableMethods();
	JMethod[] syncMethods = remoteService.getOverridableMethods();
	if (asyncMethods.length != syncMethods.length) {
	branch.branch(TreeLogger.ERROR, "The asynchronous version of "
	+ remoteService.getQualifiedSourceName() + " has "
	+ (asyncMethods.length > syncMethods.length ? "more" : "less")
	+ " methods than the synchronous version", null);
	validationFailed(branch, remoteService);
	}

	// Check that for every sync method there is a corresponding async method
	boolean failed = false;
	Map<String, JMethod> asyncMethodMap = initializeAsyncMethodMap(asyncMethods);
	Map<JMethod, JMethod> syncMethodToAsyncMethodMap = new HashMap<JMethod, JMethod>();
	for (JMethod syncMethod : syncMethods) {
	String asyncSig = computeAsyncMethodSignature(syncMethod,
	asyncCallbackClass);
	JMethod asyncMethod = asyncMethodMap.get(asyncSig);
	if (asyncMethod == null) {
	branch.branch(TreeLogger.ERROR,
	"Missing asynchronous version of the synchronous method '"
	+ syncMethod.getReadableDeclaration() + "'", null);
	failed = true;
	} else {
	// TODO if async param is parameterized make sure that the sync return
	// type is assignable to the first type argument
	JType returnType = asyncMethod.getReturnType();
	if (returnType != JPrimitiveType.VOID && returnType != requestType
	&& returnType != requestBuilderType) {
	branch.branch(TreeLogger.ERROR,
	"The asynchronous version of the synchronous method '"
	+ syncMethod.getReadableDeclaration()
	+ "' must have a return type of 'void' or '"
	+ Request.class.getCanonicalName() + "' or '"
	+ RequestBuilder.class.getCanonicalName() + "'", null);
	failed = true;
	} else {
	syncMethodToAsyncMethodMap.put(syncMethod, asyncMethod);
	}
	}
	}

	if (failed) {
	validationFailed(branch, remoteService);
	}

	branch.log(TreeLogger.DEBUG, "Interfaces are in sync");

	return syncMethodToAsyncMethodMap;
	}
	}