/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.harmony.beans;
import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Vector;
import org.apache.harmony.beans.internal.nls.Messages;
import org.xml.sax.Attributes;
import com.googlecode.openbeans.BeanInfo;
import com.googlecode.openbeans.Expression;
import com.googlecode.openbeans.IndexedPropertyDescriptor;
import com.googlecode.openbeans.IntrospectionException;
import com.googlecode.openbeans.Introspector;
import com.googlecode.openbeans.PropertyDescriptor;
import com.googlecode.openbeans.Statement;
import com.googlecode.openbeans.XMLDecoder;
public class Command {
private static final int INITIALIZED = 0;
private static final int CHILDREN_FILTERED = 1;
private static final int COMMAND_EXECUTED = 2;
private static final int CHILDREN_PROCESSED = 3;
private String tagName; // tag name
private Map<String, String> attrs; // set of attrs
private String data; // string data
// inner commands
private Vector<Command> commands = new Vector<Command>();
// arguments
private Vector<Command> arguments = new Vector<Command>();
// operations
private Vector<Command> operations = new Vector<Command>();
// additional arguments placed before others
private Vector<Argument> auxArguments = new Vector<Argument>();
private Argument result; // result argument
private Object target; // target to execute a command on
private String methodName; // method name
private Command ctx; // context for command
private int status; // commands
private XMLDecoder decoder;
// private int tabCount = 0;
public Command(String tagName, Map<String, String> attrs) {
this.tagName = tagName;
this.attrs = attrs;
this.status = initializeStatus(tagName);
}
public Command(XMLDecoder decoder, String tagName, Map<String, String> attrs) {
this.decoder = decoder;
this.tagName = tagName;
this.attrs = attrs;
this.status = initializeStatus(tagName);
}
// set data for command
public void setData(String data) {
this.data = data;
}
// set tab count to display log messages
// public void setTabCount(int tabCount) {
// this.tabCount = tabCount;
// }
// set context - upper level command
public void setContext(Command ctx) {
this.ctx = ctx;
}
// add child command
public void addChild(Command cmd) {
if (cmd != null) {
cmd.setContext(this);
commands.add(cmd);
}
}
// remove child command
public void removeChild(Command cmd) {
if ((cmd != null) && commands.remove(cmd)) {
cmd.setContext(null);
}
}
// command status
public int getStatus() {
return status;
}
// check if one of arguments or operations is unresolved
private boolean isResolved() {
if (getStatus() < Command.CHILDREN_PROCESSED) {
return false;
}
for (int i = 0; i < arguments.size(); ++i) {
Command arg = arguments.elementAt(i);
if (!arg.isResolved()) {
return false;
}
}
for (int j = 0; j < operations.size(); ++j) {
Command opr = operations.elementAt(j);
if (!opr.isResolved()) {
return false;
}
}
return true;
}
// execute command and return execution flags
public int exec(Map<String, Command> references) throws Exception {
// System.out.println("in exec() status = " + translateStatus(status) +
// "...");
if (status < Command.CHILDREN_PROCESSED) {
if (status < Command.COMMAND_EXECUTED) {
if (status < Command.CHILDREN_FILTERED) {
status = doBeforeRun(references);
// System.out.println("after doBeforeRun() status = " +
// translateStatus(status));
}
if (status == Command.CHILDREN_FILTERED) {
status = doRun(references);
// System.out.println("after doRun() status = " +
// translateStatus(status));
}
}
if (status == Command.COMMAND_EXECUTED) {
status = doAfterRun(references);
// System.out.println("after doAfterRun() status = " +
// translateStatus(status));
}
}
// System.out.println("...out of exec() status = " +
// translateStatus(status));
return status;
}
// execute commands in backtrack order
public boolean backtrack(Map<String, Command> references) throws Exception {
for (int i = 0; i < arguments.size(); ++i) {
Command arg = arguments.elementAt(i);
arg.backtrack(references);
}
for (int i = 0; i < operations.size(); ++i) {
Command opr = operations.elementAt(i);
opr.backtrack(references);
}
if (status == Command.CHILDREN_FILTERED) {
status = doRun(references);
}
if (status == Command.COMMAND_EXECUTED) {
status = doAfterRun(references);
return (getStatus() == Command.CHILDREN_PROCESSED);
}
return false;
}
// put command in one of two collections - arguments or operations
private int doBeforeRun(Map<String, Command> references) throws Exception {
if (status == Command.INITIALIZED) {
for (int i = 0; i < commands.size(); ++i) {
Command cmd = commands.elementAt(i);
// XXX is this correct?
if (cmd.isExecutable()) {
arguments.add(cmd);
} else {
operations.add(cmd);
}
}
return Command.CHILDREN_FILTERED;
}
return status;
}
// run command
private int doRun(Map<String, Command> references) throws Exception {
if (status == Command.CHILDREN_FILTERED) {
if (isRoot()) {
result = new Argument(decoder);
// System.out.println("doRun(): result is decoder...");
return Command.COMMAND_EXECUTED;
}
if (isNull()) {
result = new Argument(null);
// System.out.println("doRun(): result is null...");
return Command.COMMAND_EXECUTED;
}
if (ctx != null && ctx.isArray() && (ctx.getResultValue() == null)
&& !isExecutable()) {
// System.out.println("doRun(): context is array...");
return status;
}
Object target = getTarget(references);
if (target == null) {
// System.out.println("doRun(): target is null...");
return status;
}
// if (target instanceof Class) {
// System.out.println("doRun(): target = " +
// ((Class)target).getName());
// } else {
// System.out.println("doRun(): target = " +
// target.getClass().getName());
// }
if (isReference()) {
result = getReferencedArgument(references);
// System.out.println("doRun(): reference - result is " +
// result.getType());
} else {
String methodName = getMethodName(references);
// System.out.println("doRun(): methodName = " +
// methodName);
Argument[] arguments = getArguments();
if (arguments == null) {
return status;
}
// for (Argument element : arguments) {
// if (element != null) {
// System.out.println("doRun(): arg [" + i + "] = "
// + arguments[i].getType());
// } else {
// System.out.println("doRun(): arg [" + i + "] =
// null");
// }
// }
Expression expr = new Expression(target, methodName,
getArgumentsValues());
result = new Argument(expr.getValue());
if (isPrimitiveClassName(getTagName())) {
result.setType(getPrimitiveClass(tagName));
}
// System.out.println("doRun(): method call - result is " +
// result.getType());
}
return Command.COMMAND_EXECUTED;
}
return status;
}
// run child commands
private int doAfterRun(Map<String, Command> references) throws Exception {
if (status == Command.COMMAND_EXECUTED) {
// System.out.println("doAfterRun(): command " + getResultType() + "
// processed...");
Vector<Command> toBeRemoved = new Vector<Command>();
try {
Statement[] statements = null;
for (int i = 0; i < operations.size(); ++i) {
Command cmd = operations.elementAt(i);
if (cmd.isArrayElement()) {
if (cmd.isResolved()) {
if (statements == null) {
statements = new Statement[operations.size()];
}
statements[i] = new Statement(getResultValue(),
"set", new Object[] { Integer.valueOf(i), //$NON-NLS-1$
cmd.getResultValue() });
if ((i + 1) == operations.size()) {
for (int j = 0; j < operations.size(); ++j) {
statements[j].execute();
}
toBeRemoved.addAll(operations);
}
} else {
break;
}
} else {
// since the call is Array.set()
if (!isArray()) {
cmd.setTarget(getResultValue());
}
cmd.exec(references);
if (cmd.isResolved()) {
// System.out.println("doAfterRun(): cmd = " +
// cmd.methodName + " is resolved");
toBeRemoved.add(cmd);
} else {
// System.out.println("doAfterRun(): cmd = " +
// cmd.methodName + " is unresolved");
break;
}
}
}
} catch (Exception e) {
throw new Exception(e);
} finally {
operations.removeAll(toBeRemoved);
}
// if (operations.size() == 0) {
// System.out.println("doAfterRun(): command " + getResultType()
// + " completely processed.");
// } else {
// System.out.println("doAfterRun(): command " + getResultType()
// + " contains incomplete " +
// operations.size() + " commands.");
// }
return (operations.size() == 0) ? Command.CHILDREN_PROCESSED
: status;
}
return status;
}
// Result accessors
// Return result - Argument class
public Argument getResult() {
return result;
}
// Returns result value
public Object getResultValue() {
return (result != null) ? result.getValue() : null;
}
// Returns result type
public Class<?> getResultType() throws ClassNotFoundException {
return (result != null) ? result.getType() : null;
}
// accessors to XML tags and attrs
public boolean hasAttr(String name) {
return attrs.get(name) != null;
}
public String getAttr(String name) {
return attrs.get(name);
}
public boolean isTag(String name) {
return tagName.equals(name);
}
public boolean hasAttr(String name, String value) {
return value.equals(attrs.get(name));
}
public String getTagName() {
return tagName;
}
// Checks if the object is primitive - int, float, etc...
private boolean isPrimitive() {
return isPrimitiveClassName(tagName);
}
// Checks if the object is constructor
private boolean isConstructor() {
return isPrimitive() || !isStaticMethod() && !isMethod()
&& !isProperty() && !isField() && !isArray() && !isReference();
}
// Checks if the command is static method
private boolean isStaticMethod() {
return isTag("object") && hasAttr("method") || isTag("class"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
}
// Checks if the command is public method
private boolean isMethod() {
return isTag("void") && (hasAttr("method") || hasAttr("index")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
}
// Check if the command relates to property - getter ot setter depends on
// number of args
private boolean isProperty() {
return isTag("void") && hasAttr("property"); //$NON-NLS-1$ //$NON-NLS-2$
}
// Check if the command is field accessor
private boolean isField() {
return isTag("object") && hasAttr("field"); //$NON-NLS-1$ //$NON-NLS-2$
}
// Check if the command is array
private boolean isArray() {
return isTag("array"); //$NON-NLS-1$
}
// Check if the command is array element
private boolean isArrayElement() {
return (ctx != null) && (ctx.isArray()) && isExecutable();
}
private boolean isReference() {
return hasAttr("idref"); //$NON-NLS-1$
}
// Check if the command is root object
private boolean isRoot() {
return isTag("java"); //$NON-NLS-1$
}
// Check if the command is null
private boolean isNull() {
return isTag("null"); //$NON-NLS-1$
}
// Checks if the command could generate object
public boolean isExecutable() {
boolean result = isTag("object") || isTag("void") && hasAttr("class") //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
&& hasAttr("method") || isTag("array") || isPrimitive() //$NON-NLS-1$ //$NON-NLS-2$
|| isTag("class") || isTag("null"); //$NON-NLS-1$ //$NON-NLS-2$
return result;
}
private Argument getReferencedArgument(Map<String, Command> references) {
return references.get(getAttr("idref")).getResult(); //$NON-NLS-1$
}
// get a target through tag and attrs analysis
private Object getTarget(Map<String, Command> references) throws Exception {
if (target == null) {
if (isReference()) {
Command cmd = references.get(getAttr("idref")); //$NON-NLS-1$
target = (cmd != null) ? cmd.getResultValue() : null;
} else if (isExecutable()) {
String className = null;
if (isPrimitive()) {
className = getPrimitiveClassName(tagName);
} else if (isTag("class")) { //$NON-NLS-1$
className = getPrimitiveClassName(tagName);
} else if (isConstructor() || isStaticMethod() || isField()) {
className = getAttr("class"); //$NON-NLS-1$
} else if (isArray()) {
className = getAttr("class"); //$NON-NLS-1$
Class<?> componentType = isPrimitiveClassName(className) ? getPrimitiveClass(className)
: Class.forName(className, true, Thread
.currentThread().getContextClassLoader());
className = Array.newInstance(componentType, 0).getClass()
.getName();
}
if (className != null) {
try {
target = Class.forName(className, true, Thread
.currentThread().getContextClassLoader());
} catch (ClassNotFoundException e) {
target = Class.forName(className);
}
if (isField()) {
String fieldName = getAttr("field"); //$NON-NLS-1$
target = ((Class<?>) target).getField(fieldName);
}
} else {
throw new Exception(Messages.getString(
"beans.42", className)); //$NON-NLS-1$
}
} else if (ctx.isArray()) {
// target = ctx.getTarget(references);
target = Class.forName("java.lang.reflect.Array"); //$NON-NLS-1$
}
}
return target;
}
// set target to execute command on
private void setTarget(Object target) {
this.target = target;
}
// Return a method name of command
private String getMethodName(Map<String, Command> references)
throws NoSuchMethodException, IntrospectionException, Exception {
if (methodName == null) {
String methodValue = null;
if (isTag("class")) { //$NON-NLS-1$
addArgument(new Argument(String.class, data), 0);
methodValue = "forName"; //$NON-NLS-1$
} else if (isPrimitive()) {
if (isTag("char")) { //$NON-NLS-1$
if (data.length() != 1) {
throw new IntrospectionException(Messages.getString(
"beans.43", //$NON-NLS-1$
data));
}
addArgument(new Argument(char.class, Character.valueOf(data
.charAt(0))), 0);
} else {
addArgument(new Argument(String.class, data), 0);
}
methodValue = "new"; //$NON-NLS-1$
} else if (isConstructor() || hasAttr("method", "new")) { //$NON-NLS-1$ //$NON-NLS-2$
methodValue = "new"; //$NON-NLS-1$
} else if (isArray()) {
methodValue = "new"; //$NON-NLS-1$
int length = hasAttr("length") ? Integer //$NON-NLS-1$
.parseInt(getAttr("length")) : getArgumentsNumber(); //$NON-NLS-1$
copyArgumentsToCommands();
addArgument(new Argument(int.class, Integer.valueOf(length)), 0);
} else if (hasAttr("property")) { //$NON-NLS-1$
String propertyValue = getAttr("property"); //$NON-NLS-1$
if (hasAttr("index")) { //$NON-NLS-1$
addArgument(new Argument(int.class, new Integer(
getAttr("index"))), 0); //$NON-NLS-1$
}
BeanInfo beanInfo = Introspector.getBeanInfo(getTarget(
references).getClass());
PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
boolean methodFound = false;
Method method = null;
for (PropertyDescriptor pd : pds) {
if (propertyValue.equals(pd.getName())) {
int argsNum = getArgumentsNumber();
if (hasAttr("index")) { //$NON-NLS-1$
IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
if (argsNum == 1) {
method = ipd.getIndexedReadMethod();
} else if (argsNum == 0) {
method = ipd.getReadMethod();
}
} else {
method = pd.getReadMethod();
}
if (method != null) {
methodFound = matchMethodParams(method, references);
}
if (methodFound == false) {
if (hasAttr("index")) { //$NON-NLS-1$
IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
if (argsNum == 2) {
method = ipd.getIndexedWriteMethod();
} else if (argsNum == 1) {
method = ipd.getWriteMethod();
}
} else {
method = pd.getWriteMethod();
}
}
if (method != null) {
methodFound = matchMethodParams(method, references);
}
}
}
if (method == null) {
throw new NoSuchMethodException(Messages.getString(
"beans.44", //$NON-NLS-1$
propertyValue));
}
methodValue = method.getName();
} else if (hasAttr("method")) { //$NON-NLS-1$
if (hasAttr("index")) { //$NON-NLS-1$
addArgument(new Argument(int.class, Integer
.valueOf(getAttr("index"))), 0); //$NON-NLS-1$
}
methodValue = getAttr("method"); //$NON-NLS-1$
} else if (hasAttr("index")) { //$NON-NLS-1$
addArgument(new Argument(int.class, Integer
.valueOf(getAttr("index"))), 0); //$NON-NLS-1$
methodValue = getArgumentsNumber() > 1 ? "set" : "get"; //$NON-NLS-1$ //$NON-NLS-2$
if (ctx.isArray()) {
addArgument(ctx.getResult(), 0);
}
} else if (hasAttr("field")) { //$NON-NLS-1$
addArgument(new Argument(Class.forName(getAttr("class"), true, //$NON-NLS-1$
Thread.currentThread().getContextClassLoader())), 0);
methodValue = "get"; //$NON-NLS-1$
} else {
throw new Exception(Messages.getString("beans.45")); //$NON-NLS-1$
}
methodName = methodValue;
}
return methodName;
}
// return a list of arguments as of Argument type
private Argument[] getArguments() {
Argument[] args = new Argument[auxArguments.size() + arguments.size()];
for (int i = 0; i < auxArguments.size(); ++i) {
args[i] = auxArguments.elementAt(i);
}
for (int j = 0; j < arguments.size(); ++j) {
Command cmd = arguments.elementAt(j);
if (cmd.getStatus() >= Command.COMMAND_EXECUTED) {
args[auxArguments.size() + j] = cmd.getResult();
} else {
// System.out.println("arg: " + cmd.getResultValue());
args = null;
break;
}
}
return args;
}
// return argument values
private Object[] getArgumentsValues() {
Argument[] args = getArguments();
Object[] result = new Object[args.length];
for (int i = 0; i < args.length; ++i) {
result[i] = args[i].getValue();
}
return result;
}
// copy arguments to treat as commands
private void copyArgumentsToCommands() {
Iterator<Command> i = arguments.iterator();
while (i.hasNext()) {
Command cmd = i.next();
cmd.status = Command.CHILDREN_FILTERED;
operations.add(cmd);
}
arguments.clear();
}
// return number of arguments
private int getArgumentsNumber() {
return auxArguments.size() + arguments.size();
}
// return number of commands
// private int getOperationsNumber() {
// return operations.size();
// }
// add argument to the beginning of arguments
private void addArgument(Argument argument, int idx) {
auxArguments.insertElementAt(argument, idx);
}
// Check if the name of class is primitive
public static boolean isPrimitiveClassName(String className) {
return className.equalsIgnoreCase("boolean") //$NON-NLS-1$
|| className.equalsIgnoreCase("byte") //$NON-NLS-1$
|| className.equalsIgnoreCase("char") //$NON-NLS-1$
|| className.equalsIgnoreCase("short") //$NON-NLS-1$
|| className.equalsIgnoreCase("int") //$NON-NLS-1$
|| className.equalsIgnoreCase("long") //$NON-NLS-1$
|| className.equalsIgnoreCase("float") //$NON-NLS-1$
|| className.equalsIgnoreCase("double") //$NON-NLS-1$
|| className.equalsIgnoreCase("string"); //$NON-NLS-1$
}
// Transforms a primitive class name
private String getPrimitiveClassName(String data) {
String shortClassName = null;
if (data.equals("int")) { //$NON-NLS-1$
shortClassName = "Integer"; //$NON-NLS-1$
} else if (data.equals("char")) { //$NON-NLS-1$
shortClassName = "Character"; //$NON-NLS-1$
} else {
shortClassName = data.substring(0, 1).toUpperCase()
+ data.substring(1, data.length());
}
return "java.lang." + shortClassName; //$NON-NLS-1$
}
public static Class<?> getPrimitiveClass(String className) {
Class<?> result = null;
if (className.equals("boolean")) { //$NON-NLS-1$
result = boolean.class;
} else if (className.equals("byte")) { //$NON-NLS-1$
result = byte.class;
} else if (className.equals("char")) { //$NON-NLS-1$
result = char.class;
} else if (className.equals("short")) { //$NON-NLS-1$
result = short.class;
} else if (className.equals("int")) { //$NON-NLS-1$
result = int.class;
} else if (className.equals("long")) { //$NON-NLS-1$
result = long.class;
} else if (className.equals("float")) { //$NON-NLS-1$
result = float.class;
} else if (className.equals("double")) { //$NON-NLS-1$
result = double.class;
} else if (className.equals("string")) { //$NON-NLS-1$
result = String.class;
}
return result;
}
private boolean matchMethodParams(Method method, Map<String, Command> references) {
Class<?>[] paramTypes = method.getParameterTypes();
Argument[] args = getArguments();
if (args == null) {
return false;
}
boolean result = true;
if (paramTypes.length == args.length) {
for (int j = 0; j < paramTypes.length; ++j) {
// System.out.println("paramTypes[j] = " + paramTypes[j]);
// System.out.println("args[j] = " + args[j].getType());
boolean isAssignable = (args[j].getType() == null) ? !paramTypes[j]
.isPrimitive()
: paramTypes[j].isAssignableFrom(args[j].getType());
// System.out.println("args[j] = " + args[j].getType());
if (!isAssignable) {
result = false;
break;
}
}
} else {
result = false;
}
return result;
}
public static Map<String, String> parseAttrs(String tagName, Attributes attrs) {
Map<String, String> result = new HashMap<String, String>();
if (tagName.equals("object")) { //$NON-NLS-1$
for (String name : objectAttrNames) {
String value = attrs.getValue(name);
if (value != null) {
result.put(name, value);
}
}
} else if (tagName.equals("void")) { //$NON-NLS-1$
for (String name : voidAttrNames) {
String value = attrs.getValue(name);
if (value != null) {
result.put(name, value);
}
}
} else if (tagName.equals("array")) { //$NON-NLS-1$
for (String name : arrayAttrNames) {
String value = attrs.getValue(name);
if (value != null) {
result.put(name, value);
}
}
} else if (tagName.equals("java")) { //$NON-NLS-1$
for (String name : javaAttrNames) {
String value = attrs.getValue(name);
if (value != null) {
result.put(name, value);
}
}
}
return result;
}
// Auxiliary logging with tabs functions
public static void pr(String msg) {
// System.out.print(msg);
}
public static void pr(int tabCount, String msg) {
String result = ""; //$NON-NLS-1$
for (int i = 0; i < tabCount; ++i) {
result += '\t';
}
result += msg;
// System.out.print(result);
}
public static void prn(String msg) {
// System.out.println(msg);
}
public static void prn(int tabCount, String msg) {
String result = ""; //$NON-NLS-1$
for (int i = 0; i < tabCount; ++i) {
result += '\t';
}
result += msg;
// System.out.println(result);
}
public static void printAttrs(int tabCount, String tagName, Attributes attrs) {
pr(tabCount, tabCount + ">in <" + tagName); //$NON-NLS-1$
for (int i = 0; i < attrs.getLength(); ++i) {
String attrName = attrs.getQName(i);
String attrValue = attrs.getValue(i);
pr(" " + attrName + "=" + attrValue); //$NON-NLS-1$ //$NON-NLS-2$
}
prn(">"); //$NON-NLS-1$
}
private static int initializeStatus(String tagName) {
// return tagName.equals("java") ? Command.COMMAND_EXECUTED :
// Command.INITIALIZED;
return Command.INITIALIZED;
}
// private static String translateStatus(int status) {
// String result = "unknown";
// if(status == Command.INITIALIZED) {
// result = "initialized";
// } else if(status == Command.CHILDREN_FILTERED) {
// result = "children filtered";
// } else if(status == Command.COMMAND_EXECUTED) {
// result = "executed";
// } else if(status == Command.CHILDREN_PROCESSED) {
// result = "children processed";
// }
// return result;
// }
private static final String[] objectAttrNames = { "id", "idref", "class", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"field", "method", "property", "index" }; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
private static final String[] voidAttrNames = { "id", "class", "method", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"property", "index" }; //$NON-NLS-1$ //$NON-NLS-2$
private static final String[] arrayAttrNames = { "id", "class", "length" }; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
private static final String[] javaAttrNames = { "version", "class" }; //$NON-NLS-1$ //$NON-NLS-2$
}