2.1/user/src/com/google/gwt/user/rebind/rpc/CustomFieldSerializerValidator.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.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.JPrimitiveType;
 import com.google.gwt.core.ext.typeinfo.JType;
 import com.google.gwt.user.client.rpc.SerializationStreamReader;
 import com.google.gwt.user.client.rpc.SerializationStreamWriter;

 import java.text.MessageFormat;
 import java.util.ArrayList;
 import java.util.List;

 /**
  * Checks that a custom serializer is valid.
  */
 public class CustomFieldSerializerValidator {
   private static final String NO_DESERIALIZE_METHOD = "Custom Field Serializer ''{0}'' does not define a deserialize method: ''public static void deserialize({1} reader,{2} instance)''";
   private static final String NO_INSTANTIATE_METHOD = "Custom Field Serializer ''{0}'' does not define an instantiate method: ''public static {1} instantiate({2} reader)''; but ''{1}'' is not default instantiable";
   private static final String NO_SERIALIZE_METHOD = "Custom Field Serializer ''{0}'' does not define a serialize method: ''public static void serialize({1} writer,{2} instance)''";
   private static final String TOO_MANY_METHODS = "Custom Field Serializer ''{0}'' defines too many methods named ''{1}''; please define only one method with that name";
   private static final String WRONG_CONCRETE_TYPE_RETURN = "Custom Field Serializer ''{0}'' returns the wrong type from ''concreteType''; return type must be ''java.lang.Class''";

   public static JMethod getConcreteTypeMethod(JClassType serializer) {
     return serializer.findMethod("concreteType", new JType[0]);
   }

   public static JMethod getDeserializationMethod(JClassType serializer,
       JClassType serializee) {
     return getMethod("deserialize", SerializationStreamReader.class.getName(),
         serializer, serializee);
   }

   public static JMethod getInstantiationMethod(JClassType serializer,
       JClassType serializee) {
     JMethod[] overloads = serializer.getOverloads("instantiate");
     for (JMethod overload : overloads) {
       JParameter[] parameters = overload.getParameters();

       if (parameters.length != 1) {
         // Different overload
         continue;
       }

       if (!parameters[0].getType().getQualifiedSourceName().equals(
           SerializationStreamReader.class.getName())) {
         // First param is not a stream class
         continue;
       }

       if (!isValidCustomFieldSerializerMethod(overload)) {
         continue;
       }

       JType type = overload.getReturnType();
       if (type.isPrimitive() != null) {
         // Primitives are auto serialized so this can't be the right method
         continue;
       }

       // TODO: if isArray answered yes to isClass this cast would not be
       // necessary
       JClassType clazz = (JClassType) type;
       if (clazz.isAssignableFrom(serializee)) {
         return overload;
       }
     }

     return null;
   }

   public static JMethod getSerializationMethod(JClassType serializer,
       JClassType serializee) {
     return getMethod("serialize", SerializationStreamWriter.class.getName(),
         serializer, serializee);
   }

   public static boolean hasDeserializationMethod(JClassType serializer,
       JClassType serializee) {
     return getDeserializationMethod(serializer, serializee) != null;
   }

   public static boolean hasInstantiationMethod(JClassType serializer,
       JClassType serializee) {
     return getInstantiationMethod(serializer, serializee) != null;
   }

   public static boolean hasSerializationMethod(JClassType serializer,
       JClassType serializee) {
     return getSerializationMethod(serializer, serializee) != null;
   }

   /**
    * Returns a list of error messages associated with the custom field
    * serializer.
    *
    * @param serializer the class which performs the serialization
    * @param serializee the class being serialized
    * @return list of error messages, if any, associated with the custom field
    *         serializer
    */
   public static List<String> validate(JClassType serializer,
       JClassType serializee) {
     List<String> reasons = new ArrayList<String>();

     if (serializee.isEnum() != null) {
       /*
        * Enumerated types cannot have custom field serializers because it would
        * introduce shared state between the client and the server via the
        * enumerated constants.
        */
       reasons.add("Enumerated types cannot have custom field serializers.");
       return reasons;
     }

     if (!hasDeserializationMethod(serializer, serializee)) {
       // No valid deserialize method was found.
       reasons.add(MessageFormat.format(NO_DESERIALIZE_METHOD,
           serializer.getQualifiedSourceName(),
           SerializationStreamReader.class.getName(),
           serializee.getQualifiedSourceName()));
     } else {
       checkTooMany("deserialize", serializer, reasons);
     }

     if (!hasSerializationMethod(serializer, serializee)) {
       // No valid serialize method was found.
       reasons.add(MessageFormat.format(NO_SERIALIZE_METHOD,
           serializer.getQualifiedSourceName(),
           SerializationStreamWriter.class.getName(),
           serializee.getQualifiedSourceName()));
     } else {
       checkTooMany("serialize", serializer, reasons);
     }

     if (!hasInstantiationMethod(serializer, serializee)) {
       if (!serializee.isDefaultInstantiable() && !serializee.isAbstract()) {
         // Not default instantiable and no instantiate method was found.
         reasons.add(MessageFormat.format(NO_INSTANTIATE_METHOD,
             serializer.getQualifiedSourceName(),
             serializee.getQualifiedSourceName(),
             SerializationStreamReader.class.getName()));
       }
     } else {
       checkTooMany("instantiate", serializer, reasons);
     }

     JMethod concreteTypeMethod = getConcreteTypeMethod(serializer);
     if (concreteTypeMethod != null) {
       if (!"java.lang.Class".equals(concreteTypeMethod.getReturnType().getQualifiedSourceName())) {
         // Wrong return type.
         reasons.add(MessageFormat.format(WRONG_CONCRETE_TYPE_RETURN,
             serializer.getQualifiedSourceName()));
       } else {
         checkTooMany("concreteType", serializer, reasons);
       }
     }

     return reasons;
   }

   private static void checkTooMany(String methodName, JClassType serializer,
       List<String> reasons) {
     JMethod[] overloads = serializer.getOverloads(methodName);
     if (overloads.length > 1) {
       reasons.add(MessageFormat.format(TOO_MANY_METHODS,
           serializer.getQualifiedSourceName(), methodName));
     }
   }

   private static JMethod getMethod(String methodName, String streamClassName,
       JClassType serializer, JClassType serializee) {
     JMethod[] overloads = serializer.getOverloads(methodName);
     for (JMethod overload : overloads) {
       JParameter[] parameters = overload.getParameters();

       if (parameters.length != 2) {
         // Different overload
         continue;
       }

       if (!parameters[0].getType().getQualifiedSourceName().equals(
           streamClassName)) {
         // First param is not a stream class
         continue;
       }

       JParameter serializeeParam = parameters[1];
       JType type = serializeeParam.getType();
       if (type.isPrimitive() != null) {
         // Primitives are auto serialized so this can't be the right method
         continue;
       }

       // TODO: if isArray answered yes to isClass this cast would not be
       // necessary
       JClassType clazz = (JClassType) type;
       if (clazz.isAssignableFrom(serializee)) {
         if (isValidCustomFieldSerializerMethod(overload)
             && overload.getReturnType() == JPrimitiveType.VOID) {
           return overload;
         }
       }
     }

     return null;
   }

   private static boolean isValidCustomFieldSerializerMethod(JMethod method) {
     if (method == null) {
       return false;
     }

     if (!method.isStatic()) {
       return false;
     }

     if (!method.isPublic()) {
       return false;
     }

     return true;
   }

   private CustomFieldSerializerValidator() {
   }
 }
	/*
	* 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.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.JPrimitiveType;
	import com.google.gwt.core.ext.typeinfo.JType;
	import com.google.gwt.user.client.rpc.SerializationStreamReader;
	import com.google.gwt.user.client.rpc.SerializationStreamWriter;

	import java.text.MessageFormat;
	import java.util.ArrayList;
	import java.util.List;

	/**
	* Checks that a custom serializer is valid.
	*/
	public class CustomFieldSerializerValidator {
	private static final String NO_DESERIALIZE_METHOD = "Custom Field Serializer ''{0}'' does not define a deserialize method: ''public static void deserialize({1} reader,{2} instance)''";
	private static final String NO_INSTANTIATE_METHOD = "Custom Field Serializer ''{0}'' does not define an instantiate method: ''public static {1} instantiate({2} reader)''; but ''{1}'' is not default instantiable";
	private static final String NO_SERIALIZE_METHOD = "Custom Field Serializer ''{0}'' does not define a serialize method: ''public static void serialize({1} writer,{2} instance)''";
	private static final String TOO_MANY_METHODS = "Custom Field Serializer ''{0}'' defines too many methods named ''{1}''; please define only one method with that name";
	private static final String WRONG_CONCRETE_TYPE_RETURN = "Custom Field Serializer ''{0}'' returns the wrong type from ''concreteType''; return type must be ''java.lang.Class''";

	public static JMethod getConcreteTypeMethod(JClassType serializer) {
	return serializer.findMethod("concreteType", new JType[0]);
	}

	public static JMethod getDeserializationMethod(JClassType serializer,
	JClassType serializee) {
	return getMethod("deserialize", SerializationStreamReader.class.getName(),
	serializer, serializee);
	}

	public static JMethod getInstantiationMethod(JClassType serializer,
	JClassType serializee) {
	JMethod[] overloads = serializer.getOverloads("instantiate");
	for (JMethod overload : overloads) {
	JParameter[] parameters = overload.getParameters();

	if (parameters.length != 1) {
	// Different overload
	continue;
	}

	if (!parameters[0].getType().getQualifiedSourceName().equals(
	SerializationStreamReader.class.getName())) {
	// First param is not a stream class
	continue;
	}

	if (!isValidCustomFieldSerializerMethod(overload)) {
	continue;
	}

	JType type = overload.getReturnType();
	if (type.isPrimitive() != null) {
	// Primitives are auto serialized so this can't be the right method
	continue;
	}

	// TODO: if isArray answered yes to isClass this cast would not be
	// necessary
	JClassType clazz = (JClassType) type;
	if (clazz.isAssignableFrom(serializee)) {
	return overload;
	}
	}

	return null;
	}

	public static JMethod getSerializationMethod(JClassType serializer,
	JClassType serializee) {
	return getMethod("serialize", SerializationStreamWriter.class.getName(),
	serializer, serializee);
	}

	public static boolean hasDeserializationMethod(JClassType serializer,
	JClassType serializee) {
	return getDeserializationMethod(serializer, serializee) != null;
	}

	public static boolean hasInstantiationMethod(JClassType serializer,
	JClassType serializee) {
	return getInstantiationMethod(serializer, serializee) != null;
	}

	public static boolean hasSerializationMethod(JClassType serializer,
	JClassType serializee) {
	return getSerializationMethod(serializer, serializee) != null;
	}

	/**
	* Returns a list of error messages associated with the custom field
	* serializer.
	*
	* @param serializer the class which performs the serialization
	* @param serializee the class being serialized
	* @return list of error messages, if any, associated with the custom field
	* serializer
	*/
	public static List<String> validate(JClassType serializer,
	JClassType serializee) {
	List<String> reasons = new ArrayList<String>();

	if (serializee.isEnum() != null) {
	/*
	* Enumerated types cannot have custom field serializers because it would
	* introduce shared state between the client and the server via the
	* enumerated constants.
	*/
	reasons.add("Enumerated types cannot have custom field serializers.");
	return reasons;
	}

	if (!hasDeserializationMethod(serializer, serializee)) {
	// No valid deserialize method was found.
	reasons.add(MessageFormat.format(NO_DESERIALIZE_METHOD,
	serializer.getQualifiedSourceName(),
	SerializationStreamReader.class.getName(),
	serializee.getQualifiedSourceName()));
	} else {
	checkTooMany("deserialize", serializer, reasons);
	}

	if (!hasSerializationMethod(serializer, serializee)) {
	// No valid serialize method was found.
	reasons.add(MessageFormat.format(NO_SERIALIZE_METHOD,
	serializer.getQualifiedSourceName(),
	SerializationStreamWriter.class.getName(),
	serializee.getQualifiedSourceName()));
	} else {
	checkTooMany("serialize", serializer, reasons);
	}

	if (!hasInstantiationMethod(serializer, serializee)) {
	if (!serializee.isDefaultInstantiable() && !serializee.isAbstract()) {
	// Not default instantiable and no instantiate method was found.
	reasons.add(MessageFormat.format(NO_INSTANTIATE_METHOD,
	serializer.getQualifiedSourceName(),
	serializee.getQualifiedSourceName(),
	SerializationStreamReader.class.getName()));
	}
	} else {
	checkTooMany("instantiate", serializer, reasons);
	}

	JMethod concreteTypeMethod = getConcreteTypeMethod(serializer);
	if (concreteTypeMethod != null) {
	if (!"java.lang.Class".equals(concreteTypeMethod.getReturnType().getQualifiedSourceName())) {
	// Wrong return type.
	reasons.add(MessageFormat.format(WRONG_CONCRETE_TYPE_RETURN,
	serializer.getQualifiedSourceName()));
	} else {
	checkTooMany("concreteType", serializer, reasons);
	}
	}

	return reasons;
	}

	private static void checkTooMany(String methodName, JClassType serializer,
	List<String> reasons) {
	JMethod[] overloads = serializer.getOverloads(methodName);
	if (overloads.length > 1) {
	reasons.add(MessageFormat.format(TOO_MANY_METHODS,
	serializer.getQualifiedSourceName(), methodName));
	}
	}

	private static JMethod getMethod(String methodName, String streamClassName,
	JClassType serializer, JClassType serializee) {
	JMethod[] overloads = serializer.getOverloads(methodName);
	for (JMethod overload : overloads) {
	JParameter[] parameters = overload.getParameters();

	if (parameters.length != 2) {
	// Different overload
	continue;
	}

	if (!parameters[0].getType().getQualifiedSourceName().equals(
	streamClassName)) {
	// First param is not a stream class
	continue;
	}

	JParameter serializeeParam = parameters[1];
	JType type = serializeeParam.getType();
	if (type.isPrimitive() != null) {
	// Primitives are auto serialized so this can't be the right method
	continue;
	}

	// TODO: if isArray answered yes to isClass this cast would not be
	// necessary
	JClassType clazz = (JClassType) type;
	if (clazz.isAssignableFrom(serializee)) {
	if (isValidCustomFieldSerializerMethod(overload)
	&& overload.getReturnType() == JPrimitiveType.VOID) {
	return overload;
	}
	}
	}

	return null;
	}

	private static boolean isValidCustomFieldSerializerMethod(JMethod method) {
	if (method == null) {
	return false;
	}

	if (!method.isStatic()) {
	return false;
	}

	if (!method.isPublic()) {
	return false;
	}

	return true;
	}

	private CustomFieldSerializerValidator() {
	}
	}