2.1/dev/core/src/com/google/gwt/dev/util/xml/HandlerMethod.java - gwt - Git at Google

 /*
  * Copyright 2006 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.dev.util.xml;

 import com.google.gwt.core.ext.UnableToCompleteException;

 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.List;

 /**
  * Represents metadata about a handler method in a class derived from {@link Schema}.
  */
 public final class HandlerMethod {

   private static final HandlerParam[] EMPTY_HANDLERPARAMS = new HandlerParam[0];

   // A schema level that ignores everything.
   private static final Schema sArbitraryChildHandler = new Schema() {

     @Override
     public void onBadAttributeValue(int lineNumber, String elemName,
         String attrName, String attrValue, Class<?> paramType) {
       // Ignore
     }

     @Override
     public void onHandlerException(int lineNumber, String elemLocalName,
         Method method, Throwable e) {
       // Ignore
     }

     @Override
     public void onMissingAttribute(int lineNumber, String elemName,
         String argName) {
       // Ignore
     }

     @Override
     public void onUnexpectedAttribute(int lineNumber, String elemName,
         String attrName, String attrValue) {
       // Ignore
     }

     @Override
     public void onUnexpectedChild(int lineNumber, String elemName) {
       // Ignore
     }

     @Override
     public void onUnexpectedElement(int lineNumber, String elemName) {
       // Ignore
     }
   };

   private static final int TYPE_NONE = 0;
   private static final int TYPE_BEGIN = 1;
   private static final int TYPE_END = 2;
   private static final int TYPE_TEXT = 3;

   static {
     ReflectiveParser.registerSchemaLevel(sArbitraryChildHandler.getClass());
   }

   /**
    * Attempts to create a handler method from any method. You can pass in any
    * method at all, but an exception will be thrown if the method is clearly a
    * handler but the containing class does not have the proper parameter
    * metafields.
    */
   @SuppressWarnings("unchecked")
   public static HandlerMethod tryCreate(Method method) {
     String methodName = method.getName();
     String normalizedTagName = null;
     try {
       int type = TYPE_NONE;

       if (methodName.startsWith("__")) {
         if (methodName.endsWith("_begin")) {
           type = TYPE_BEGIN;
           normalizedTagName = methodName.substring(0, methodName.length()
               - "_begin".length());
         } else if (methodName.endsWith("_end")) {
           type = TYPE_END;
           normalizedTagName = methodName.substring(0, methodName.length()
               - "_end".length());
         } else if (methodName.equals("__text")) {
           type = TYPE_TEXT;
         }
       }

       if (type == TYPE_NONE) {
         // This was not a handler method.
         // Exit early.
         //
         return null;
       }

       assert (type == TYPE_BEGIN || type == TYPE_END || type == TYPE_TEXT);

       // Can the corresponding element have arbitrary children?
       //
       Class<?> returnType = method.getReturnType();
       boolean arbitraryChildren = false;
       if (type == TYPE_BEGIN) {
         if (Schema.class.isAssignableFrom(returnType)) {
           arbitraryChildren = false;

           // Also, we need to register this schema type.
           //
           ReflectiveParser.registerSchemaLevel((Class<? extends Schema>) returnType);

         } else if (returnType.equals(Void.TYPE)) {
           arbitraryChildren = true;
         } else {
           throw new IllegalArgumentException(
               "The return type of begin handlers must be 'void' or assignable to 'SchemaLevel'");
         }
       } else if (!Void.TYPE.equals(returnType)) {
         throw new IllegalArgumentException(
             "Only 'void' may be specified as a return type for 'end' and 'text' handlers");
       }

       // Create handler args.
       //
       if (type == TYPE_TEXT) {
         Class<?>[] paramTypes = method.getParameterTypes();
         if (paramTypes.length != 1 || !String.class.equals(paramTypes[0])) {
           throw new IllegalArgumentException(
               "__text handlers must have exactly one String parameter");
         }

         // We pretend it doesn't have any param since they're always
         // pre-determined.
         //
         return new HandlerMethod(method, type, false, EMPTY_HANDLERPARAMS);
       } else {
         Class<?>[] paramTypes = method.getParameterTypes();
         List<HandlerParam> handlerParams = new ArrayList<HandlerParam>();
         for (int i = 0, n = paramTypes.length; i < n; ++i) {
           HandlerParam handlerParam = HandlerParam.create(method,
               normalizedTagName, i);
           if (handlerParam != null) {
             handlerParams.add(handlerParam);
           } else {
             throw new IllegalArgumentException("In method '" + method.getName()
                 + "', parameter " + (i + 1) + " is an unsupported type");
           }
         }

         HandlerParam[] hpa = handlerParams.toArray(EMPTY_HANDLERPARAMS);
         return new HandlerMethod(method, type, arbitraryChildren, hpa);
       }
     } catch (Exception e) {
       throw new RuntimeException("Unable to use method '" + methodName
           + "' as a handler", e);
     }
   }

   private final boolean arbitraryChildren;

   private final HandlerParam[] handlerParams;

   private final Method method;

   private final int methodType;

   private HandlerMethod(Method method, int type, boolean arbitraryChildren,
       HandlerParam[] hpa) {
     this.method = method;
     this.methodType = type;
     this.arbitraryChildren = arbitraryChildren;
     this.handlerParams = hpa.clone();

     this.method.setAccessible(true);
   }

   public HandlerArgs createArgs(Schema schema, int lineNumber, String elemName) {
     return new HandlerArgs(schema, lineNumber, elemName, handlerParams);
   }

   public String getNormalizedName() {
     String name = method.getName();
     if (isStartMethod()) {
       return name.substring(2, name.length() - "_begin".length());
     } else if (isEndMethod()) {
       return name.substring(2, name.length() - "_end".length());
     } else {
       throw new IllegalStateException("Unexpected method name");
     }
   }

   public HandlerParam getParam(int i) {
     return handlerParams[i];
   }

   public int getParamCount() {
     return handlerParams.length;
   }

   public Schema invokeBegin(int lineNumber, String elemLocalName,
       Schema target, HandlerArgs args, Object[] outInvokeArgs)
       throws UnableToCompleteException {
     assert (outInvokeArgs.length == args.getArgCount());

     for (int i = 0, n = args.getArgCount(); i < n; ++i) {
       Object invokeArg = args.convertToArg(i);
       outInvokeArgs[i] = invokeArg;
     }

     Schema nextSchemaLevel = null;

     Throwable caught = null;
     try {
       target.setLineNumber(lineNumber);
       nextSchemaLevel = (Schema) method.invoke(target, outInvokeArgs);
     } catch (IllegalArgumentException e) {
       caught = e;
     } catch (IllegalAccessException e) {
       caught = e;
     } catch (InvocationTargetException e) {
       caught = e.getTargetException();
     }

     if (caught != null) {
       target.onHandlerException(lineNumber, elemLocalName, method, caught);
     }

     // Prepare a resulting schema level that allows the reflective parser
     // to simply perform its normal logic, even while there are some
     // special cases.
     //
     // Four cases:
     // (1) childSchemaLevel is non-null, in which case it becomes the new
     // schema used for child elements
     // (2) the handler method has return type "SchemaLevel" but the result
     // was null, meaning that it cannot have child elements;
     // we return null to indicate this
     // (3) the handler method has return type "void", meaning that child
     // elements are simply ignored; we push null to detect this
     // (4) the method failed or could not be called, which is treated the same
     // as case (3)
     //
     if (nextSchemaLevel != null) {
       return nextSchemaLevel;
     } else if (arbitraryChildren) {
       return sArbitraryChildHandler;
     } else {
       return null;
     }
   }

   public void invokeEnd(int lineNumber, String elem, Schema target,
       Object[] args) throws UnableToCompleteException {
     Throwable caught = null;
     try {
       target.setLineNumber(lineNumber);
       method.invoke(target, args);
       return;
     } catch (IllegalArgumentException e) {
       caught = e;
     } catch (IllegalAccessException e) {
       caught = e;
     } catch (InvocationTargetException e) {
       caught = e.getTargetException();
     }
     target.onHandlerException(lineNumber, elem, method, caught);
   }

   public void invokeText(int lineNumber, String text, Schema target)
       throws UnableToCompleteException {
     Throwable caught = null;
     try {
       target.setLineNumber(lineNumber);
       method.invoke(target, new Object[] {text});
       return;
     } catch (IllegalArgumentException e) {
       caught = e;
     } catch (IllegalAccessException e) {
       caught = e;
     } catch (InvocationTargetException e) {
       caught = e.getTargetException();
     }
     target.onHandlerException(lineNumber, "#text", method, caught);
   }

   public boolean isEndMethod() {
     return methodType == TYPE_END;
   }

   public boolean isStartMethod() {
     return methodType == TYPE_BEGIN;
   }
 }
	/*
	* Copyright 2006 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.dev.util.xml;

	import com.google.gwt.core.ext.UnableToCompleteException;

	import java.lang.reflect.InvocationTargetException;
	import java.lang.reflect.Method;
	import java.util.ArrayList;
	import java.util.List;

	/**
	* Represents metadata about a handler method in a class derived from {@link Schema}.
	*/
	public final class HandlerMethod {

	private static final HandlerParam[] EMPTY_HANDLERPARAMS = new HandlerParam[0];

	// A schema level that ignores everything.
	private static final Schema sArbitraryChildHandler = new Schema() {

	@Override
	public void onBadAttributeValue(int lineNumber, String elemName,
	String attrName, String attrValue, Class<?> paramType) {
	// Ignore
	}

	@Override
	public void onHandlerException(int lineNumber, String elemLocalName,
	Method method, Throwable e) {
	// Ignore
	}

	@Override
	public void onMissingAttribute(int lineNumber, String elemName,
	String argName) {
	// Ignore
	}

	@Override
	public void onUnexpectedAttribute(int lineNumber, String elemName,
	String attrName, String attrValue) {
	// Ignore
	}

	@Override
	public void onUnexpectedChild(int lineNumber, String elemName) {
	// Ignore
	}

	@Override
	public void onUnexpectedElement(int lineNumber, String elemName) {
	// Ignore
	}
	};

	private static final int TYPE_NONE = 0;
	private static final int TYPE_BEGIN = 1;
	private static final int TYPE_END = 2;
	private static final int TYPE_TEXT = 3;

	static {
	ReflectiveParser.registerSchemaLevel(sArbitraryChildHandler.getClass());
	}

	/**
	* Attempts to create a handler method from any method. You can pass in any
	* method at all, but an exception will be thrown if the method is clearly a
	* handler but the containing class does not have the proper parameter
	* metafields.
	*/
	@SuppressWarnings("unchecked")
	public static HandlerMethod tryCreate(Method method) {
	String methodName = method.getName();
	String normalizedTagName = null;
	try {
	int type = TYPE_NONE;

	if (methodName.startsWith("__")) {
	if (methodName.endsWith("_begin")) {
	type = TYPE_BEGIN;
	normalizedTagName = methodName.substring(0, methodName.length()
	- "_begin".length());
	} else if (methodName.endsWith("_end")) {
	type = TYPE_END;
	normalizedTagName = methodName.substring(0, methodName.length()
	- "_end".length());
	} else if (methodName.equals("__text")) {
	type = TYPE_TEXT;
	}
	}

	if (type == TYPE_NONE) {
	// This was not a handler method.
	// Exit early.
	//
	return null;
	}

	assert (type == TYPE_BEGIN \|\| type == TYPE_END \|\| type == TYPE_TEXT);

	// Can the corresponding element have arbitrary children?
	//
	Class<?> returnType = method.getReturnType();
	boolean arbitraryChildren = false;
	if (type == TYPE_BEGIN) {
	if (Schema.class.isAssignableFrom(returnType)) {
	arbitraryChildren = false;

	// Also, we need to register this schema type.
	//
	ReflectiveParser.registerSchemaLevel((Class<? extends Schema>) returnType);

	} else if (returnType.equals(Void.TYPE)) {
	arbitraryChildren = true;
	} else {
	throw new IllegalArgumentException(
	"The return type of begin handlers must be 'void' or assignable to 'SchemaLevel'");
	}
	} else if (!Void.TYPE.equals(returnType)) {
	throw new IllegalArgumentException(
	"Only 'void' may be specified as a return type for 'end' and 'text' handlers");
	}

	// Create handler args.
	//
	if (type == TYPE_TEXT) {
	Class<?>[] paramTypes = method.getParameterTypes();
	if (paramTypes.length != 1 \|\| !String.class.equals(paramTypes[0])) {
	throw new IllegalArgumentException(
	"__text handlers must have exactly one String parameter");
	}

	// We pretend it doesn't have any param since they're always
	// pre-determined.
	//
	return new HandlerMethod(method, type, false, EMPTY_HANDLERPARAMS);
	} else {
	Class<?>[] paramTypes = method.getParameterTypes();
	List<HandlerParam> handlerParams = new ArrayList<HandlerParam>();
	for (int i = 0, n = paramTypes.length; i < n; ++i) {
	HandlerParam handlerParam = HandlerParam.create(method,
	normalizedTagName, i);
	if (handlerParam != null) {
	handlerParams.add(handlerParam);
	} else {
	throw new IllegalArgumentException("In method '" + method.getName()
	+ "', parameter " + (i + 1) + " is an unsupported type");
	}
	}

	HandlerParam[] hpa = handlerParams.toArray(EMPTY_HANDLERPARAMS);
	return new HandlerMethod(method, type, arbitraryChildren, hpa);
	}
	} catch (Exception e) {
	throw new RuntimeException("Unable to use method '" + methodName
	+ "' as a handler", e);
	}
	}

	private final boolean arbitraryChildren;

	private final HandlerParam[] handlerParams;

	private final Method method;

	private final int methodType;

	private HandlerMethod(Method method, int type, boolean arbitraryChildren,
	HandlerParam[] hpa) {
	this.method = method;
	this.methodType = type;
	this.arbitraryChildren = arbitraryChildren;
	this.handlerParams = hpa.clone();

	this.method.setAccessible(true);
	}

	public HandlerArgs createArgs(Schema schema, int lineNumber, String elemName) {
	return new HandlerArgs(schema, lineNumber, elemName, handlerParams);
	}

	public String getNormalizedName() {
	String name = method.getName();
	if (isStartMethod()) {
	return name.substring(2, name.length() - "_begin".length());
	} else if (isEndMethod()) {
	return name.substring(2, name.length() - "_end".length());
	} else {
	throw new IllegalStateException("Unexpected method name");
	}
	}

	public HandlerParam getParam(int i) {
	return handlerParams[i];
	}

	public int getParamCount() {
	return handlerParams.length;
	}

	public Schema invokeBegin(int lineNumber, String elemLocalName,
	Schema target, HandlerArgs args, Object[] outInvokeArgs)
	throws UnableToCompleteException {
	assert (outInvokeArgs.length == args.getArgCount());

	for (int i = 0, n = args.getArgCount(); i < n; ++i) {
	Object invokeArg = args.convertToArg(i);
	outInvokeArgs[i] = invokeArg;
	}

	Schema nextSchemaLevel = null;

	Throwable caught = null;
	try {
	target.setLineNumber(lineNumber);
	nextSchemaLevel = (Schema) method.invoke(target, outInvokeArgs);
	} catch (IllegalArgumentException e) {
	caught = e;
	} catch (IllegalAccessException e) {
	caught = e;
	} catch (InvocationTargetException e) {
	caught = e.getTargetException();
	}

	if (caught != null) {
	target.onHandlerException(lineNumber, elemLocalName, method, caught);
	}

	// Prepare a resulting schema level that allows the reflective parser
	// to simply perform its normal logic, even while there are some
	// special cases.
	//
	// Four cases:
	// (1) childSchemaLevel is non-null, in which case it becomes the new
	// schema used for child elements
	// (2) the handler method has return type "SchemaLevel" but the result
	// was null, meaning that it cannot have child elements;
	// we return null to indicate this
	// (3) the handler method has return type "void", meaning that child
	// elements are simply ignored; we push null to detect this
	// (4) the method failed or could not be called, which is treated the same
	// as case (3)
	//
	if (nextSchemaLevel != null) {
	return nextSchemaLevel;
	} else if (arbitraryChildren) {
	return sArbitraryChildHandler;
	} else {
	return null;
	}
	}

	public void invokeEnd(int lineNumber, String elem, Schema target,
	Object[] args) throws UnableToCompleteException {
	Throwable caught = null;
	try {
	target.setLineNumber(lineNumber);
	method.invoke(target, args);
	return;
	} catch (IllegalArgumentException e) {
	caught = e;
	} catch (IllegalAccessException e) {
	caught = e;
	} catch (InvocationTargetException e) {
	caught = e.getTargetException();
	}
	target.onHandlerException(lineNumber, elem, method, caught);
	}

	public void invokeText(int lineNumber, String text, Schema target)
	throws UnableToCompleteException {
	Throwable caught = null;
	try {
	target.setLineNumber(lineNumber);
	method.invoke(target, new Object[] {text});
	return;
	} catch (IllegalArgumentException e) {
	caught = e;
	} catch (IllegalAccessException e) {
	caught = e;
	} catch (InvocationTargetException e) {
	caught = e.getTargetException();
	}
	target.onHandlerException(lineNumber, "#text", method, caught);
	}

	public boolean isEndMethod() {
	return methodType == TYPE_END;
	}

	public boolean isStartMethod() {
	return methodType == TYPE_BEGIN;
	}
	}