v1/src/xmlconfig/org/apache/xmlbeans/impl/config/InterfaceExtension.java - xmlbeans - Git at Google

 /*   Copyright 2004 The Apache Software Foundation
  *
  *   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.
  */
 /**
  * Author: Cezar Andrei ( cezar.andrei at bea.com )
  * Date: Mar 25, 2004
  */
 package org.apache.xmlbeans.impl.config;

 import org.apache.xml.xmlbeans.x2004.x02.xbean.config.Extensionconfig;
 import org.apache.xmlbeans.XmlObject;

 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;

 public class InterfaceExtension
 {
     private NameSet _xbeanSet;
     private Class _interface;
     private Class _delegateToClass;
     private String _delegateToClassName;
     private Method[] _interfaceMethods;
     private Method[] _delegateToMethods;

     static InterfaceExtension newInstance(NameSet xbeanSet, Extensionconfig.Interface intfXO)
     {
         InterfaceExtension result = new InterfaceExtension();

         result._xbeanSet = xbeanSet;
         result._interface = validateInterface(intfXO.getName(), intfXO);

         if (result._interface == null)
         {
             SchemaConfig.error("Interface '" + intfXO.getStaticHandler() + "' not found.", intfXO);
             return null;
         }

         result._delegateToClassName = intfXO.getStaticHandler();
         result._delegateToClass = validateClass(result._delegateToClassName, intfXO);

         if ( result._delegateToClass==null ) // no HandlerClass
         {
             SchemaConfig.warning("Handler class '" + intfXO.getStaticHandler() + "' not found on classpath, skip validation.", intfXO);
             return result;
         }

         if (!result.validateMethods(intfXO))
             return null;

         return result;
     }

     private static Class validateInterface(String intfStr, XmlObject loc)
     {
         return validateJava(intfStr, true, loc);
     }

     static Class validateClass(String clsStr, XmlObject loc)
     {
         return validateJava(clsStr, false, loc);
     }

     static Class validateJava(String clsStr, boolean isInterface, XmlObject loc)
     {
         final String ent = isInterface ? "Interface" : "Class";
         try
         {
             Class cls = Class.forName(clsStr);
             if ( (isInterface && !cls.isInterface()) ||
                     (!isInterface && cls.isInterface()))
             {
                 SchemaConfig.error("'" + clsStr + "' must be " +
                     (isInterface ? "an interface" : "a class") + ".", loc);
             }

             if (!Modifier.isPublic(cls.getModifiers()))
             {
                 SchemaConfig.error(ent + " '" + clsStr + "' is not public.", loc);
             }

             return cls;
         }
         catch (ClassNotFoundException e)
         {
             SchemaConfig.error(ent + " '" + clsStr + "' not found.", loc);
             return null;
         }
     }

     private boolean validateMethods(XmlObject loc)
     {
         assert _delegateToClass != null : "Delegate to class handler expected.";
         boolean valid = true;

         _interfaceMethods = _interface.getMethods();
         _delegateToMethods = new Method[_interfaceMethods.length];

         for (int i = 0; i < _interfaceMethods.length; i++)
         {
             valid &= validateMethod(i, _interfaceMethods[i], loc);
         }

         return valid;
     }

     private boolean validateMethod(int index, Method method, XmlObject loc)
     {
         String methodName = method.getName();
         Class[] paramTypes = method.getParameterTypes();
         Class returnType = method.getReturnType();

         Class[] delegateParams = new Class[paramTypes.length+1];
         delegateParams[0] = XmlObject.class;
         for (int i = 1; i < delegateParams.length; i++)
         {
             delegateParams[i] = paramTypes[i-1];
         }

         Method handlerMethod = null;
         try
         {
             handlerMethod = _delegateToClass.getMethod(methodName, delegateParams);

             // check for throws exceptions
             Class[] intfExceptions = method.getExceptionTypes();
             Class[] delegateExceptions = handlerMethod.getExceptionTypes();
             if ( delegateExceptions.length!=intfExceptions.length )
             {
                 SchemaConfig.error("Handler method '" + _delegateToClass.getName() + "." + methodName + "(" + listTypes(delegateParams) +
                     ")' must declare the same exceptions as the interface method '" + _interface.getName() + "." + methodName + "(" + listTypes(paramTypes), loc);
                 return false;
             }

             for (int i = 0; i < delegateExceptions.length; i++)
             {
                 if ( delegateExceptions[i]!=intfExceptions[i] )
                 {
                     SchemaConfig.error("Handler method '" + _delegateToClass.getName() + "." + methodName + "(" + listTypes(delegateParams) +
                         ")' must declare the same exceptions as the interface method '" + _interface.getName() + "." + methodName + "(" + listTypes(paramTypes), loc);
                     return false;
                 }
             }
         }
         catch (NoSuchMethodException e)
         {
             SchemaConfig.error("Handler class '" + _delegateToClass.getName() + "' does not contain method " + methodName + "(" + listTypes(delegateParams) + ")", loc);
             return false;
         }
         catch (SecurityException e)
         {
             SchemaConfig.error("Security violation for class '" + _interface.getName() + "' accesing method " + methodName + "(" + listTypes(delegateParams) + ")", loc);
             return false;
         }

         if (!Modifier.isPublic(handlerMethod.getModifiers()) || !Modifier.isStatic(handlerMethod.getModifiers()))
         {
             SchemaConfig.error("Method '" + _delegateToClass.getName() + "." + methodName + "(" + listTypes(delegateParams) + ")' must be declared public and static.", loc);
             return false;
         }

         if (!returnType.equals(handlerMethod.getReturnType()))
         {
             SchemaConfig.error("Return type for method '" + handlerMethod.getReturnType() + " " + _delegateToClass.getName() +
                     "." + methodName + "(" + listTypes(delegateParams) + ")' does not match the return type of the interface method :'" + returnType + "'.", loc);
             return false;
         }

         _delegateToMethods[index] = method;

         return true;
     }

     private static String listTypes(Class[] types)
     {
         StringBuffer result = new StringBuffer();
         for (int i = 0; i < types.length; i++)
         {
             Class type = types[i];
             if (i>0)
                 result.append(", ");
             result.append(emitType(type));
         }
         return result.toString();
     }

     public static String emitType(Class cls)
     {
         if (cls.isArray())
             return emitType(cls.getComponentType()) + "[]";
         else
             return cls.getName().replace('$', '.');
     }

     /* public getters */
     public boolean contains(String fullJavaName)
     {
         return _xbeanSet.contains(fullJavaName);
     }

     public String getInterfaceName()
     {
         return _interface.getName();
     }

     public String getInterfaceNameForJavaSource()
     {
         return emitType(_interface);
     }

     // used only for validation
     public String getHandlerNameForJavaSource()
     {
         if (_delegateToClass==null)
             return null;

         return emitType(_delegateToClass);
     }

     public int getInterfaceMethodCount()
     {
         return _interfaceMethods.length;
     }

     public String getInterfaceMethodName(int methodIndex)
     {
         return _interfaceMethods[methodIndex].getName();
     }

     public Method getInterfaceMethod(int methodIndex)
     {
         return _interfaceMethods[methodIndex];
     }

     public String getInterfaceMethodDecl(int methodIndex)
     {
         StringBuffer sb = new StringBuffer();
         Method m = _interfaceMethods[methodIndex];
         Class[] paramTypes = m.getParameterTypes();

         for (int i = 0; i < paramTypes.length; i++)
         {
             Class paramType = paramTypes[i];
             sb.append( i==0 ? "" : ", " );
             sb.append( emitType(paramType) + " p" + i);
         }

         StringBuffer exceptions = new StringBuffer();
         Class[] excClasses = m.getExceptionTypes();

         for (int i=0; i<excClasses.length; i++)
             exceptions.append((i==0 ? " throws " : ", ") + emitType(excClasses[i]));

         return "public " + emitType(m.getReturnType()) + " " + m.getName() + "(" + sb.toString() + ")" + exceptions.toString();
     }

     public String getInterfaceMethodImpl(int methodIndex)
     {
 	// use the methods from the interface for gen the call to the handler
         StringBuffer sb = new StringBuffer();

         if (!void.class.equals(_interfaceMethods[methodIndex].getReturnType()))
             sb.append("return ");

         sb.append(_delegateToClassName + "." + _delegateToMethods[methodIndex].getName() + "(this");

         int paramCount = _interfaceMethods[methodIndex].getParameterTypes().length;
         for (int i=0; i<paramCount; i++)
         {
             sb.append(", p" + i);
         }

         sb.append(");");
         return sb.toString();
     }
 }
	/* Copyright 2004 The Apache Software Foundation
	*
	* 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.
	*/
	/**
	* Author: Cezar Andrei ( cezar.andrei at bea.com )
	* Date: Mar 25, 2004
	*/
	package org.apache.xmlbeans.impl.config;

	import org.apache.xml.xmlbeans.x2004.x02.xbean.config.Extensionconfig;
	import org.apache.xmlbeans.XmlObject;

	import java.lang.reflect.Method;
	import java.lang.reflect.Modifier;

	public class InterfaceExtension
	{
	private NameSet _xbeanSet;
	private Class _interface;
	private Class _delegateToClass;
	private String _delegateToClassName;
	private Method[] _interfaceMethods;
	private Method[] _delegateToMethods;

	static InterfaceExtension newInstance(NameSet xbeanSet, Extensionconfig.Interface intfXO)
	{
	InterfaceExtension result = new InterfaceExtension();

	result._xbeanSet = xbeanSet;
	result._interface = validateInterface(intfXO.getName(), intfXO);

	if (result._interface == null)
	{
	SchemaConfig.error("Interface '" + intfXO.getStaticHandler() + "' not found.", intfXO);
	return null;
	}

	result._delegateToClassName = intfXO.getStaticHandler();
	result._delegateToClass = validateClass(result._delegateToClassName, intfXO);

	if ( result._delegateToClass==null ) // no HandlerClass
	{
	SchemaConfig.warning("Handler class '" + intfXO.getStaticHandler() + "' not found on classpath, skip validation.", intfXO);
	return result;
	}

	if (!result.validateMethods(intfXO))
	return null;

	return result;
	}

	private static Class validateInterface(String intfStr, XmlObject loc)
	{
	return validateJava(intfStr, true, loc);
	}

	static Class validateClass(String clsStr, XmlObject loc)
	{
	return validateJava(clsStr, false, loc);
	}

	static Class validateJava(String clsStr, boolean isInterface, XmlObject loc)
	{
	final String ent = isInterface ? "Interface" : "Class";
	try
	{
	Class cls = Class.forName(clsStr);
	if ( (isInterface && !cls.isInterface()) \|\|
	(!isInterface && cls.isInterface()))
	{
	SchemaConfig.error("'" + clsStr + "' must be " +
	(isInterface ? "an interface" : "a class") + ".", loc);
	}

	if (!Modifier.isPublic(cls.getModifiers()))
	{
	SchemaConfig.error(ent + " '" + clsStr + "' is not public.", loc);
	}

	return cls;
	}
	catch (ClassNotFoundException e)
	{
	SchemaConfig.error(ent + " '" + clsStr + "' not found.", loc);
	return null;
	}
	}

	private boolean validateMethods(XmlObject loc)
	{
	assert _delegateToClass != null : "Delegate to class handler expected.";
	boolean valid = true;

	_interfaceMethods = _interface.getMethods();
	_delegateToMethods = new Method[_interfaceMethods.length];

	for (int i = 0; i < _interfaceMethods.length; i++)
	{
	valid &= validateMethod(i, _interfaceMethods[i], loc);
	}

	return valid;
	}

	private boolean validateMethod(int index, Method method, XmlObject loc)
	{
	String methodName = method.getName();
	Class[] paramTypes = method.getParameterTypes();
	Class returnType = method.getReturnType();

	Class[] delegateParams = new Class[paramTypes.length+1];
	delegateParams[0] = XmlObject.class;
	for (int i = 1; i < delegateParams.length; i++)
	{
	delegateParams[i] = paramTypes[i-1];
	}

	Method handlerMethod = null;
	try
	{
	handlerMethod = _delegateToClass.getMethod(methodName, delegateParams);

	// check for throws exceptions
	Class[] intfExceptions = method.getExceptionTypes();
	Class[] delegateExceptions = handlerMethod.getExceptionTypes();
	if ( delegateExceptions.length!=intfExceptions.length )
	{
	SchemaConfig.error("Handler method '" + _delegateToClass.getName() + "." + methodName + "(" + listTypes(delegateParams) +
	")' must declare the same exceptions as the interface method '" + _interface.getName() + "." + methodName + "(" + listTypes(paramTypes), loc);
	return false;
	}

	for (int i = 0; i < delegateExceptions.length; i++)
	{
	if ( delegateExceptions[i]!=intfExceptions[i] )
	{
	SchemaConfig.error("Handler method '" + _delegateToClass.getName() + "." + methodName + "(" + listTypes(delegateParams) +
	")' must declare the same exceptions as the interface method '" + _interface.getName() + "." + methodName + "(" + listTypes(paramTypes), loc);
	return false;
	}
	}
	}
	catch (NoSuchMethodException e)
	{
	SchemaConfig.error("Handler class '" + _delegateToClass.getName() + "' does not contain method " + methodName + "(" + listTypes(delegateParams) + ")", loc);
	return false;
	}
	catch (SecurityException e)
	{
	SchemaConfig.error("Security violation for class '" + _interface.getName() + "' accesing method " + methodName + "(" + listTypes(delegateParams) + ")", loc);
	return false;
	}

	if (!Modifier.isPublic(handlerMethod.getModifiers()) \|\| !Modifier.isStatic(handlerMethod.getModifiers()))
	{
	SchemaConfig.error("Method '" + _delegateToClass.getName() + "." + methodName + "(" + listTypes(delegateParams) + ")' must be declared public and static.", loc);
	return false;
	}

	if (!returnType.equals(handlerMethod.getReturnType()))
	{
	SchemaConfig.error("Return type for method '" + handlerMethod.getReturnType() + " " + _delegateToClass.getName() +
	"." + methodName + "(" + listTypes(delegateParams) + ")' does not match the return type of the interface method :'" + returnType + "'.", loc);
	return false;
	}

	_delegateToMethods[index] = method;

	return true;
	}

	private static String listTypes(Class[] types)
	{
	StringBuffer result = new StringBuffer();
	for (int i = 0; i < types.length; i++)
	{
	Class type = types[i];
	if (i>0)
	result.append(", ");
	result.append(emitType(type));
	}
	return result.toString();
	}

	public static String emitType(Class cls)
	{
	if (cls.isArray())
	return emitType(cls.getComponentType()) + "[]";
	else
	return cls.getName().replace('$', '.');
	}

	/* public getters */
	public boolean contains(String fullJavaName)
	{
	return _xbeanSet.contains(fullJavaName);
	}

	public String getInterfaceName()
	{
	return _interface.getName();
	}

	public String getInterfaceNameForJavaSource()
	{
	return emitType(_interface);
	}

	// used only for validation
	public String getHandlerNameForJavaSource()
	{
	if (_delegateToClass==null)
	return null;

	return emitType(_delegateToClass);
	}

	public int getInterfaceMethodCount()
	{
	return _interfaceMethods.length;
	}

	public String getInterfaceMethodName(int methodIndex)
	{
	return _interfaceMethods[methodIndex].getName();
	}

	public Method getInterfaceMethod(int methodIndex)
	{
	return _interfaceMethods[methodIndex];
	}

	public String getInterfaceMethodDecl(int methodIndex)
	{
	StringBuffer sb = new StringBuffer();
	Method m = _interfaceMethods[methodIndex];
	Class[] paramTypes = m.getParameterTypes();

	for (int i = 0; i < paramTypes.length; i++)
	{
	Class paramType = paramTypes[i];
	sb.append( i==0 ? "" : ", " );
	sb.append( emitType(paramType) + " p" + i);
	}

	StringBuffer exceptions = new StringBuffer();
	Class[] excClasses = m.getExceptionTypes();

	for (int i=0; i<excClasses.length; i++)
	exceptions.append((i==0 ? " throws " : ", ") + emitType(excClasses[i]));

	return "public " + emitType(m.getReturnType()) + " " + m.getName() + "(" + sb.toString() + ")" + exceptions.toString();
	}

	public String getInterfaceMethodImpl(int methodIndex)
	{
	// use the methods from the interface for gen the call to the handler
	StringBuffer sb = new StringBuffer();

	if (!void.class.equals(_interfaceMethods[methodIndex].getReturnType()))
	sb.append("return ");

	sb.append(_delegateToClassName + "." + _delegateToMethods[methodIndex].getName() + "(this");

	int paramCount = _interfaceMethods[methodIndex].getParameterTypes().length;
	for (int i=0; i<paramCount; i++)
	{
	sb.append(", p" + i);
	}

	sb.append(");");
	return sb.toString();
	}
	}