com/naef/jnlua/JavaModule.java - minecraft/opencomputers - Rivoreo Source Code Repositories

 /*
  * $Id: JavaModule.java 76 2012-01-06 01:25:52Z andre@naef.com $
  * See LICENSE.txt for license terms.
  */

 package com.naef.jnlua;

 import java.lang.reflect.Array;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;

 import com.naef.jnlua.JavaReflector.Metamethod;

 /**
  * Provides the Java module for Lua. The Java module contains Java functions for
  * using Java in Lua.
  */
 public class JavaModule {
 	// -- Static
 	private static final JavaModule INSTANCE = new JavaModule();
 	private static final Map<String, Class<?>> PRIMITIVE_TYPES = new HashMap<String, Class<?>>();
 	static {
 		PRIMITIVE_TYPES.put("boolean", Boolean.TYPE);
 		PRIMITIVE_TYPES.put("byte", Byte.TYPE);
 		PRIMITIVE_TYPES.put("char", Character.TYPE);
 		PRIMITIVE_TYPES.put("double", Double.TYPE);
 		PRIMITIVE_TYPES.put("float", Float.TYPE);
 		PRIMITIVE_TYPES.put("int", Integer.TYPE);
 		PRIMITIVE_TYPES.put("long", Long.TYPE);
 		PRIMITIVE_TYPES.put("short", Short.TYPE);
 		PRIMITIVE_TYPES.put("void", Void.TYPE);
 	}

 	// -- State
 	private final NamedJavaFunction[] functions = { new Require(), new New(),
 			new InstanceOf(), new Cast(), new Proxy(), new Pairs(),
 			new IPairs(), new ToTable(), new Elements(), new Fields(),
 			new Methods(), new Properties() };

 	// -- Static methods
 	/**
 	 * Returns the instance of the Java module.
 	 *
 	 * @return the instance
 	 */
 	public static JavaModule getInstance() {
 		return INSTANCE;
 	}

 	// -- Construction
 	/**
 	 * Singleton.
 	 */
 	private JavaModule() {
 	}

 	// -- Operations
 	/**
 	 * Opens this module in a Lua state. The method is invoked by
 	 * {@link LuaState#openLibs()} or by
 	 * {@link LuaState#openLib(com.naef.jnlua.LuaState.Library)} if
 	 * {@link LuaState.Library#JAVA} is passed. The module is pushed onto the
 	 * stack.
 	 *
 	 * @param luaState
 	 *            the Lua state to open in
 	 */
 	public void open(LuaState luaState) {
 		luaState.register("java", functions, true);
 	}

 	/**
 	 * Returns a table-like Lua value for the specified map. The returned value
 	 * corresponds to the return value of the <code>totable()</code> function
 	 * provided by this Java module.
 	 *
 	 * @param map
 	 *            the map
 	 * @return the table-like Lua value
 	 */
 	public TypedJavaObject toTable(Map<?, ?> map) {
 		return ToTable.toTable(map);
 	}

 	/**
 	 * Returns a table-like Lua value for the specified list. The returned value
 	 * corresponds to the return value of the <code>totable()</code> function
 	 * provided by this Java module.
 	 *
 	 * @param list
 	 *            the list
 	 * @return the table-like Lua value
 	 */
 	public TypedJavaObject toTable(List<?> list) {
 		return ToTable.toTable(list);
 	}

 	// -- Private methods
 	/**
 	 * Loads a type. The named type is a primitive type or a class.
 	 */
 	private static Class<?> loadType(LuaState luaState, String typeName) {
 		Class<?> clazz;
 		if ((clazz = PRIMITIVE_TYPES.get(typeName)) != null) {
 			return clazz;
 		}
 		try {
 			clazz = luaState.getClassLoader().loadClass(typeName);
 			return clazz;
 		} catch (ClassNotFoundException e) {
 			throw new RuntimeException(e);
 		}
 	}

 	// -- Nested types
 	/**
 	 * Imports a Java class into the Lua namespace. Returns the class and a
 	 * status code. The status code indicates if the class was stored in the Lua
 	 * namespace. Primitive types and classes without a package are not stored
 	 * in the Lua namespace.
 	 */
 	private static class Require implements NamedJavaFunction {
 		// -- JavaFunction methods
 		@Override
 		public int invoke(LuaState luaState) {
 			// Check arguments
 			String className = luaState.checkString(1);
 			boolean doImport = luaState.toBoolean(2);

 			// Load
 			Class<?> clazz = loadType(luaState, className);
 			luaState.pushJavaObject(clazz);

 			// Import
 			if (doImport) {
 				luaState.rawGet(LuaState.REGISTRYINDEX, LuaState.RIDX_GLOBALS);
 				String name = clazz.getName();
 				int index = name.indexOf('.');
 				while (index >= 0) {
 					String part = name.substring(0, index);
 					luaState.getField(-1, part);
 					if (!luaState.isTable(-1)) {
 						luaState.pop(1);
 						luaState.newTable();
 						luaState.pushValue(-1);
 						luaState.setField(-3, part);
 					}
 					luaState.remove(-2);
 					name = name.substring(index + 1);
 					index = name.indexOf('.');
 				}
 				luaState.pushValue(-2);
 				luaState.setField(-2, name);
 				luaState.pop(1);
 			}
 			luaState.pushBoolean(doImport);

 			// Return
 			return 2;
 		}

 		@Override
 		public String getName() {
 			return "require";
 		}
 	}

 	/**
 	 * Creates and returns a new Java object or array thereof. The first
 	 * argument designates the type to instantiate, either as a class or a
 	 * string. The remaining arguments are the dimensions.
 	 */
 	private static class New implements NamedJavaFunction {
 		// -- JavaFunction methods
 		@Override
 		public int invoke(LuaState luaState) {
 			// Find class
 			Class<?> clazz;
 			if (luaState.isJavaObject(1, Class.class)) {
 				clazz = luaState.checkJavaObject(1, Class.class);
 			} else {
 				String className = luaState.checkString(1);
 				clazz = loadType(luaState, className);
 			}

 			// Instantiate
 			Object object;
 			int dimensionCount = luaState.getTop() - 1;
 			switch (dimensionCount) {
 			case 0:
 				try {
 					object = clazz.newInstance();
 				} catch (InstantiationException e) {
 					throw new RuntimeException(e);
 				} catch (IllegalAccessException e) {
 					throw new RuntimeException(e);
 				}
 				break;
 			case 1:
 				object = Array.newInstance(clazz, luaState.checkInteger(2));
 				break;
 			default:
 				int[] dimensions = new int[dimensionCount];
 				for (int i = 0; i < dimensionCount; i++) {
 					dimensions[i] = luaState.checkInteger(i + 2);
 				}
 				object = Array.newInstance(clazz, dimensions);
 			}

 			// Return
 			luaState.pushJavaObject(object);
 			return 1;
 		}

 		@Override
 		public String getName() {
 			return "new";
 		}
 	}

 	/**
 	 * Returns whether an object is an instance of a type. The object is given
 	 * as the first argument. the type is given as the second argument, either
 	 * as a class or as a type name.
 	 */
 	private static class InstanceOf implements NamedJavaFunction {
 		// -- JavaFunction methods
 		@Override
 		public int invoke(LuaState luaState) {
 			// Get the object
 			Object object = luaState.checkJavaObject(1, Object.class);

 			// Find class
 			Class<?> clazz;
 			if (luaState.isJavaObject(2, Class.class)) {
 				clazz = luaState.checkJavaObject(2, Class.class);
 			} else {
 				String className = luaState.checkString(2);
 				clazz = loadType(luaState, className);
 			}

 			// Type check
 			luaState.pushBoolean(clazz.isInstance(object));
 			return 1;
 		}

 		@Override
 		public String getName() {
 			return "instanceof";
 		}
 	}

 	/**
 	 * Creates a typed Java object.
 	 */
 	private static class Cast implements NamedJavaFunction {
 		// -- NamedJavaFunction methods
 		@Override
 		public int invoke(LuaState luaState) {
 			// Find class
 			final Class<?> clazz;
 			if (luaState.isJavaObject(2, Class.class)) {
 				clazz = luaState.checkJavaObject(2, Class.class);
 			} else {
 				String className = luaState.checkString(2);
 				clazz = loadType(luaState, className);
 			}

 			// Get the object
 			final Object object = luaState.checkJavaObject(1, clazz);

 			// Push result
 			luaState.pushJavaObject(new TypedJavaObject() {
 				@Override
 				public Object getObject() {
 					return object;
 				}

 				@Override
 				public Class<?> getType() {
 					return clazz;
 				}

 				@Override
 				public boolean isStrong() {
 					return false;
 				}
 			});
 			return 1;
 		}

 		@Override
 		public String getName() {
 			return "cast";
 		}
 	}

 	/**
 	 * Creates a dynamic proxy object the implements a set of Java interfaces in
 	 * Lua.
 	 */
 	private static class Proxy implements NamedJavaFunction {
 		// -- JavaFunction methods
 		@Override
 		public int invoke(LuaState luaState) {
 			// Check table
 			luaState.checkType(1, LuaType.TABLE);

 			// Get interfaces
 			int interfaceCount = luaState.getTop() - 1;
 			luaState.checkArg(2, interfaceCount > 0, "no interface specified");
 			Class<?>[] interfaces = new Class<?>[interfaceCount];
 			for (int i = 0; i < interfaceCount; i++) {
 				if (luaState.isJavaObject(i + 2, Class.class)) {
 					interfaces[i] = luaState
 							.checkJavaObject(i + 2, Class.class);
 				} else {
 					String interfaceName = luaState.checkString(i + 2);
 					interfaces[i] = loadType(luaState, interfaceName);
 				}
 			}

 			// Create proxy
 			luaState.pushJavaObjectRaw(luaState.getProxy(1, interfaces));
 			return 1;
 		}

 		@Override
 		public String getName() {
 			return "proxy";
 		}
 	}

 	/**
 	 * Provides the pairs iterator from the Java reflector.
 	 */
 	private static class Pairs implements NamedJavaFunction {
 		// -- NamedJavaFunction methods
 		@Override
 		public int invoke(LuaState luaState) {
 			luaState.checkArg(
 					1,
 					luaState.isJavaObjectRaw(1),
 					String.format("Java object expected, got %s",
 							luaState.typeName(1)));
 			JavaFunction metamethod = luaState.getMetamethod(
 					luaState.toJavaObjectRaw(1), Metamethod.PAIRS);
 			return metamethod.invoke(luaState);
 		}

 		@Override
 		public String getName() {
 			return "pairs";
 		}
 	}

 	/**
 	 * Provides the ipairs iterator from the Java reflector.
 	 */
 	private static class IPairs implements NamedJavaFunction {
 		// -- NamedJavaFunction methods
 		@Override
 		public int invoke(LuaState luaState) {
 			luaState.checkArg(
 					1,
 					luaState.isJavaObjectRaw(1),
 					String.format("Java object expected, got %s",
 							luaState.typeName(1)));
 			JavaFunction metamethod = luaState.getMetamethod(
 					luaState.toJavaObjectRaw(1), Metamethod.IPAIRS);
 			return metamethod.invoke(luaState);
 		}

 		@Override
 		public String getName() {
 			return "ipairs";
 		}
 	}

 	/**
 	 * Provides a wrapper object for table-like map and list access from Lua.
 	 */
 	private static class ToTable implements NamedJavaFunction {
 		// -- Static methods
 		/**
 		 * Returns a table-like Lua value for the specified map.
 		 */
 		@SuppressWarnings("unchecked")
 		public static TypedJavaObject toTable(Map<?, ?> map) {
 			return new LuaMap((Map<Object, Object>) map);
 		}

 		/**
 		 * Returns a table-list Lua value for the specified list.
 		 */
 		@SuppressWarnings("unchecked")
 		public static TypedJavaObject toTable(List<?> list) {
 			return new LuaList((List<Object>) list);
 		}

 		// -- JavaFunction methods
 		@SuppressWarnings("unchecked")
 		@Override
 		public int invoke(LuaState luaState) {
 			if (luaState.isJavaObject(1, Map.class)) {
 				Map<Object, Object> map = luaState.toJavaObject(1, Map.class);
 				luaState.pushJavaObject(new LuaMap(map));
 			} else if (luaState.isJavaObject(1, List.class)) {
 				List<Object> list = luaState.toJavaObject(1, List.class);
 				luaState.pushJavaObject(new LuaList(list));
 			} else {
 				luaState.checkArg(
 						1,
 						false,
 						String.format("expected map or list, got %s",
 								luaState.typeName(1)));
 			}
 			return 1;
 		}

 		@Override
 		public String getName() {
 			return "totable";
 		}

 		// -- Member types
 		/**
 		 * Provides table-like access in Lua to a Java map.
 		 */
 		private static class LuaMap implements JavaReflector, TypedJavaObject {
 			// -- Static
 			private static final JavaFunction INDEX = new Index();
 			private static final JavaFunction NEW_INDEX = new NewIndex();

 			// -- State
 			private Map<Object, Object> map;

 			// -- Construction
 			/**
 			 * Creates a new instance.
 			 */
 			public LuaMap(Map<Object, Object> map) {
 				this.map = map;
 			}

 			// -- Properties
 			/**
 			 * Returns the map.
 			 */
 			public Map<Object, Object> getMap() {
 				return map;
 			}

 			// -- JavaReflector methods
 			@Override
 			public JavaFunction getMetamethod(Metamethod metamethod) {
 				switch (metamethod) {
 				case INDEX:
 					return INDEX;
 				case NEWINDEX:
 					return NEW_INDEX;
 				default:
 					return null;
 				}
 			}

 			// -- TypedJavaObject methods
 			@Override
 			public Object getObject() {
 				return map;
 			}

 			@Override
 			public Class<?> getType() {
 				return Map.class;
 			}

 			@Override
 			public boolean isStrong() {
 				return true;
 			}

 			// -- Member types
 			/**
 			 * __index implementation for maps.
 			 */
 			private static class Index implements JavaFunction {
 				// -- JavaFunction methods
 				@Override
 				public int invoke(LuaState luaState) {
 					LuaMap luaMap = (LuaMap) luaState.toJavaObjectRaw(1);
 					Object key = luaState.toJavaObject(2, Object.class);
 					if (key == null) {
 						throw new LuaRuntimeException(String.format(
 								"attempt to read map with %s accessor",
 								luaState.typeName(2)));
 					}
 					luaState.pushJavaObject(luaMap.getMap().get(key));
 					return 1;
 				}
 			}

 			/**
 			 * __newindex implementation for maps.
 			 */
 			private static class NewIndex implements JavaFunction {
 				// -- JavaFunction methods
 				@Override
 				public int invoke(LuaState luaState) {
 					LuaMap luaMap = (LuaMap) luaState.toJavaObjectRaw(1);
 					Object key = luaState.toJavaObject(2, Object.class);
 					if (key == null) {
 						throw new LuaRuntimeException(String.format(
 								"attempt to write map with %s accessor",
 								luaState.typeName(2)));
 					}
 					Object value = luaState.toJavaObject(3, Object.class);
 					if (value != null) {
 						luaMap.getMap().put(key, value);
 					} else {
 						luaMap.getMap().remove(key);
 					}
 					return 0;
 				}
 			}
 		}

 		/**
 		 * Provides table-like access in Lua to a Java list.
 		 */
 		private static class LuaList implements JavaReflector, TypedJavaObject {
 			// -- Static
 			private static final JavaFunction INDEX = new Index();
 			private static final JavaFunction NEW_INDEX = new NewIndex();
 			private static final JavaFunction LENGTH = new Length();

 			// -- State
 			private List<Object> list;

 			// -- Construction
 			/**
 			 * Creates a new instance.
 			 */
 			public LuaList(List<Object> list) {
 				this.list = list;
 			}

 			// -- Properties
 			/**
 			 * Returns the map.
 			 */
 			public List<Object> getList() {
 				return list;
 			}

 			// -- JavaReflector methods
 			@Override
 			public JavaFunction getMetamethod(Metamethod metamethod) {
 				switch (metamethod) {
 				case INDEX:
 					return INDEX;
 				case NEWINDEX:
 					return NEW_INDEX;
 				case LEN:
 					return LENGTH;
 				default:
 					return null;
 				}
 			}

 			// -- TypedJavaObject methods
 			@Override
 			public Object getObject() {
 				return list;
 			}

 			@Override
 			public Class<?> getType() {
 				return List.class;
 			}

 			@Override
 			public boolean isStrong() {
 				return true;
 			}

 			// -- Member types
 			/**
 			 * __index implementation for lists.
 			 */
 			private static class Index implements JavaFunction {
 				// -- JavaFunction methods
 				@Override
 				public int invoke(LuaState luaState) {
 					LuaList luaList = (LuaList) luaState.toJavaObjectRaw(1);
 					if (!luaState.isNumber(2)) {
 						throw new LuaRuntimeException(String.format(
 								"attempt to read list with %s accessor",
 								luaState.typeName(2)));
 					}
 					int index = luaState.toInteger(2);
 					luaState.pushJavaObject(luaList.getList().get(index - 1));
 					return 1;
 				}
 			}

 			/**
 			 * __newindex implementation for lists.
 			 */
 			private static class NewIndex implements JavaFunction {
 				// -- JavaFunction methods
 				@Override
 				public int invoke(LuaState luaState) {
 					LuaList luaList = (LuaList) luaState.toJavaObjectRaw(1);
 					if (!luaState.isNumber(2)) {
 						throw new LuaRuntimeException(String.format(
 								"attempt to write list with %s accessor",
 								luaState.typeName(2)));
 					}
 					int index = luaState.toInteger(2);
 					Object value = luaState.toJavaObject(3, Object.class);
 					if (value != null) {
 						int size = luaList.getList().size();
 						if (index - 1 != size) {
 							luaList.getList().set(index - 1, value);
 						} else {
 							luaList.getList().add(value);
 						}
 					} else {
 						luaList.getList().remove(index - 1);
 					}
 					return 0;
 				}
 			}

 			/**
 			 * __len implementation for lists.
 			 */
 			private static class Length implements JavaFunction {
 				// -- JavaFunction methods
 				@Override
 				public int invoke(LuaState luaState) {
 					LuaList luaList = (LuaList) luaState.toJavaObjectRaw(1);
 					luaState.pushInteger(luaList.getList().size());
 					return 1;
 				}
 			}
 		}
 	}

 	/**
 	 * Provides an iterator for Iterable objects.
 	 */
 	private static class Elements implements NamedJavaFunction {
 		// -- NamedJavaFunction methods
 		@Override
 		public int invoke(LuaState luaState) {
 			Iterable<?> iterable = luaState.checkJavaObject(1, Iterable.class);
 			luaState.pushJavaObject(new ElementIterator(iterable.iterator()));
 			luaState.pushJavaObject(iterable);
 			luaState.pushNil();
 			return 3;
 		}

 		@Override
 		public String getName() {
 			return "elements";
 		}

 		// -- Member types
 		private static class ElementIterator implements JavaFunction {
 			// -- State
 			private Iterator<?> iterator;

 			// -- Construction
 			/**
 			 * Creates a new instance.
 			 */
 			public ElementIterator(Iterator<?> iterator) {
 				this.iterator = iterator;
 			}

 			// -- JavaFunction methods
 			@Override
 			public int invoke(LuaState luaState) {
 				if (iterator.hasNext()) {
 					luaState.pushJavaObject(iterator.next());
 				} else {
 					luaState.pushNil();
 				}
 				return 1;
 			}
 		}
 	}

 	/**
 	 * Provides an iterator for Java object fields.
 	 */
 	private static class Fields implements NamedJavaFunction {
 		// -- NamedJavaFunction methods
 		@Override
 		public int invoke(LuaState luaState) {
 			luaState.checkArg(
 					1,
 					luaState.isJavaObjectRaw(1),
 					String.format("expected Java object, got %s",
 							luaState.typeName(1)));
 			JavaFunction metamethod = luaState.getMetamethod(
 					luaState.toJavaObjectRaw(1), Metamethod.JAVAFIELDS);
 			return metamethod.invoke(luaState);
 		}

 		@Override
 		public String getName() {
 			return "fields";
 		}
 	}

 	/**
 	 * Provides an iterator for Java methods.
 	 */
 	private static class Methods implements NamedJavaFunction {
 		// -- NamedJavaFunction methods
 		@Override
 		public int invoke(LuaState luaState) {
 			luaState.checkArg(
 					1,
 					luaState.isJavaObjectRaw(1),
 					String.format("expected Java object, got %s",
 							luaState.typeName(1)));
 			JavaFunction metamethod = luaState.getMetamethod(
 					luaState.toJavaObjectRaw(1), Metamethod.JAVAMETHODS);
 			return metamethod.invoke(luaState);
 		}

 		@Override
 		public String getName() {
 			return "methods";
 		}
 	}

 	/**
 	 * Provides an iterator for Java object properties.
 	 */
 	private static class Properties implements NamedJavaFunction {
 		// -- NamedJavaFunction methods
 		@Override
 		public int invoke(LuaState luaState) {
 			luaState.checkArg(
 					1,
 					luaState.isJavaObjectRaw(1),
 					String.format("expected Java object, got %s",
 							luaState.typeName(1)));
 			JavaFunction metamethod = luaState.getMetamethod(
 					luaState.toJavaObjectRaw(1), Metamethod.JAVAPROPERTIES);
 			return metamethod.invoke(luaState);
 		}

 		@Override
 		public String getName() {
 			return "properties";
 		}
 	}
 }
	/*
	* $Id: JavaModule.java 76 2012-01-06 01:25:52Z andre@naef.com $
	* See LICENSE.txt for license terms.
	*/

	package com.naef.jnlua;

	import java.lang.reflect.Array;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;

	import com.naef.jnlua.JavaReflector.Metamethod;

	/**
	* Provides the Java module for Lua. The Java module contains Java functions for
	* using Java in Lua.
	*/
	public class JavaModule {
	// -- Static
	private static final JavaModule INSTANCE = new JavaModule();
	private static final Map<String, Class<?>> PRIMITIVE_TYPES = new HashMap<String, Class<?>>();
	static {
	PRIMITIVE_TYPES.put("boolean", Boolean.TYPE);
	PRIMITIVE_TYPES.put("byte", Byte.TYPE);
	PRIMITIVE_TYPES.put("char", Character.TYPE);
	PRIMITIVE_TYPES.put("double", Double.TYPE);
	PRIMITIVE_TYPES.put("float", Float.TYPE);
	PRIMITIVE_TYPES.put("int", Integer.TYPE);
	PRIMITIVE_TYPES.put("long", Long.TYPE);
	PRIMITIVE_TYPES.put("short", Short.TYPE);
	PRIMITIVE_TYPES.put("void", Void.TYPE);
	}

	// -- State
	private final NamedJavaFunction[] functions = { new Require(), new New(),
	new InstanceOf(), new Cast(), new Proxy(), new Pairs(),
	new IPairs(), new ToTable(), new Elements(), new Fields(),
	new Methods(), new Properties() };

	// -- Static methods
	/**
	* Returns the instance of the Java module.
	*
	* @return the instance
	*/
	public static JavaModule getInstance() {
	return INSTANCE;
	}

	// -- Construction
	/**
	* Singleton.
	*/
	private JavaModule() {
	}

	// -- Operations
	/**
	* Opens this module in a Lua state. The method is invoked by
	* {@link LuaState#openLibs()} or by
	* {@link LuaState#openLib(com.naef.jnlua.LuaState.Library)} if
	* {@link LuaState.Library#JAVA} is passed. The module is pushed onto the
	* stack.
	*
	* @param luaState
	* the Lua state to open in
	*/
	public void open(LuaState luaState) {
	luaState.register("java", functions, true);
	}

	/**
	* Returns a table-like Lua value for the specified map. The returned value
	* corresponds to the return value of the <code>totable()</code> function
	* provided by this Java module.
	*
	* @param map
	* the map
	* @return the table-like Lua value
	*/
	public TypedJavaObject toTable(Map<?, ?> map) {
	return ToTable.toTable(map);
	}

	/**
	* Returns a table-like Lua value for the specified list. The returned value
	* corresponds to the return value of the <code>totable()</code> function
	* provided by this Java module.
	*
	* @param list
	* the list
	* @return the table-like Lua value
	*/
	public TypedJavaObject toTable(List<?> list) {
	return ToTable.toTable(list);
	}

	// -- Private methods
	/**
	* Loads a type. The named type is a primitive type or a class.
	*/
	private static Class<?> loadType(LuaState luaState, String typeName) {
	Class<?> clazz;
	if ((clazz = PRIMITIVE_TYPES.get(typeName)) != null) {
	return clazz;
	}
	try {
	clazz = luaState.getClassLoader().loadClass(typeName);
	return clazz;
	} catch (ClassNotFoundException e) {
	throw new RuntimeException(e);
	}
	}

	// -- Nested types
	/**
	* Imports a Java class into the Lua namespace. Returns the class and a
	* status code. The status code indicates if the class was stored in the Lua
	* namespace. Primitive types and classes without a package are not stored
	* in the Lua namespace.
	*/
	private static class Require implements NamedJavaFunction {
	// -- JavaFunction methods
	@Override
	public int invoke(LuaState luaState) {
	// Check arguments
	String className = luaState.checkString(1);
	boolean doImport = luaState.toBoolean(2);

	// Load
	Class<?> clazz = loadType(luaState, className);
	luaState.pushJavaObject(clazz);

	// Import
	if (doImport) {
	luaState.rawGet(LuaState.REGISTRYINDEX, LuaState.RIDX_GLOBALS);
	String name = clazz.getName();
	int index = name.indexOf('.');
	while (index >= 0) {
	String part = name.substring(0, index);
	luaState.getField(-1, part);
	if (!luaState.isTable(-1)) {
	luaState.pop(1);
	luaState.newTable();
	luaState.pushValue(-1);
	luaState.setField(-3, part);
	}
	luaState.remove(-2);
	name = name.substring(index + 1);
	index = name.indexOf('.');
	}
	luaState.pushValue(-2);
	luaState.setField(-2, name);
	luaState.pop(1);
	}
	luaState.pushBoolean(doImport);

	// Return
	return 2;
	}

	@Override
	public String getName() {
	return "require";
	}
	}

	/**
	* Creates and returns a new Java object or array thereof. The first
	* argument designates the type to instantiate, either as a class or a
	* string. The remaining arguments are the dimensions.
	*/
	private static class New implements NamedJavaFunction {
	// -- JavaFunction methods
	@Override
	public int invoke(LuaState luaState) {
	// Find class
	Class<?> clazz;
	if (luaState.isJavaObject(1, Class.class)) {
	clazz = luaState.checkJavaObject(1, Class.class);
	} else {
	String className = luaState.checkString(1);
	clazz = loadType(luaState, className);
	}

	// Instantiate
	Object object;
	int dimensionCount = luaState.getTop() - 1;
	switch (dimensionCount) {
	case 0:
	try {
	object = clazz.newInstance();
	} catch (InstantiationException e) {
	throw new RuntimeException(e);
	} catch (IllegalAccessException e) {
	throw new RuntimeException(e);
	}
	break;
	case 1:
	object = Array.newInstance(clazz, luaState.checkInteger(2));
	break;
	default:
	int[] dimensions = new int[dimensionCount];
	for (int i = 0; i < dimensionCount; i++) {
	dimensions[i] = luaState.checkInteger(i + 2);
	}
	object = Array.newInstance(clazz, dimensions);
	}

	// Return
	luaState.pushJavaObject(object);
	return 1;
	}

	@Override
	public String getName() {
	return "new";
	}
	}

	/**
	* Returns whether an object is an instance of a type. The object is given
	* as the first argument. the type is given as the second argument, either
	* as a class or as a type name.
	*/
	private static class InstanceOf implements NamedJavaFunction {
	// -- JavaFunction methods
	@Override
	public int invoke(LuaState luaState) {
	// Get the object
	Object object = luaState.checkJavaObject(1, Object.class);

	// Find class
	Class<?> clazz;
	if (luaState.isJavaObject(2, Class.class)) {
	clazz = luaState.checkJavaObject(2, Class.class);
	} else {
	String className = luaState.checkString(2);
	clazz = loadType(luaState, className);
	}

	// Type check
	luaState.pushBoolean(clazz.isInstance(object));
	return 1;
	}

	@Override
	public String getName() {
	return "instanceof";
	}
	}

	/**
	* Creates a typed Java object.
	*/
	private static class Cast implements NamedJavaFunction {
	// -- NamedJavaFunction methods
	@Override
	public int invoke(LuaState luaState) {
	// Find class
	final Class<?> clazz;
	if (luaState.isJavaObject(2, Class.class)) {
	clazz = luaState.checkJavaObject(2, Class.class);
	} else {
	String className = luaState.checkString(2);
	clazz = loadType(luaState, className);
	}

	// Get the object
	final Object object = luaState.checkJavaObject(1, clazz);

	// Push result
	luaState.pushJavaObject(new TypedJavaObject() {
	@Override
	public Object getObject() {
	return object;
	}

	@Override
	public Class<?> getType() {
	return clazz;
	}

	@Override
	public boolean isStrong() {
	return false;
	}
	});
	return 1;
	}

	@Override
	public String getName() {
	return "cast";
	}
	}

	/**
	* Creates a dynamic proxy object the implements a set of Java interfaces in
	* Lua.
	*/
	private static class Proxy implements NamedJavaFunction {
	// -- JavaFunction methods
	@Override
	public int invoke(LuaState luaState) {
	// Check table
	luaState.checkType(1, LuaType.TABLE);

	// Get interfaces
	int interfaceCount = luaState.getTop() - 1;
	luaState.checkArg(2, interfaceCount > 0, "no interface specified");
	Class<?>[] interfaces = new Class<?>[interfaceCount];
	for (int i = 0; i < interfaceCount; i++) {
	if (luaState.isJavaObject(i + 2, Class.class)) {
	interfaces[i] = luaState
	.checkJavaObject(i + 2, Class.class);
	} else {
	String interfaceName = luaState.checkString(i + 2);
	interfaces[i] = loadType(luaState, interfaceName);
	}
	}

	// Create proxy
	luaState.pushJavaObjectRaw(luaState.getProxy(1, interfaces));
	return 1;
	}

	@Override
	public String getName() {
	return "proxy";
	}
	}

	/**
	* Provides the pairs iterator from the Java reflector.
	*/
	private static class Pairs implements NamedJavaFunction {
	// -- NamedJavaFunction methods
	@Override
	public int invoke(LuaState luaState) {
	luaState.checkArg(
	1,
	luaState.isJavaObjectRaw(1),
	String.format("Java object expected, got %s",
	luaState.typeName(1)));
	JavaFunction metamethod = luaState.getMetamethod(
	luaState.toJavaObjectRaw(1), Metamethod.PAIRS);
	return metamethod.invoke(luaState);
	}

	@Override
	public String getName() {
	return "pairs";
	}
	}

	/**
	* Provides the ipairs iterator from the Java reflector.
	*/
	private static class IPairs implements NamedJavaFunction {
	// -- NamedJavaFunction methods
	@Override
	public int invoke(LuaState luaState) {
	luaState.checkArg(
	1,
	luaState.isJavaObjectRaw(1),
	String.format("Java object expected, got %s",
	luaState.typeName(1)));
	JavaFunction metamethod = luaState.getMetamethod(
	luaState.toJavaObjectRaw(1), Metamethod.IPAIRS);
	return metamethod.invoke(luaState);
	}

	@Override
	public String getName() {
	return "ipairs";
	}
	}

	/**
	* Provides a wrapper object for table-like map and list access from Lua.
	*/
	private static class ToTable implements NamedJavaFunction {
	// -- Static methods
	/**
	* Returns a table-like Lua value for the specified map.
	*/
	@SuppressWarnings("unchecked")
	public static TypedJavaObject toTable(Map<?, ?> map) {
	return new LuaMap((Map<Object, Object>) map);
	}

	/**
	* Returns a table-list Lua value for the specified list.
	*/
	@SuppressWarnings("unchecked")
	public static TypedJavaObject toTable(List<?> list) {
	return new LuaList((List<Object>) list);
	}

	// -- JavaFunction methods
	@SuppressWarnings("unchecked")
	@Override
	public int invoke(LuaState luaState) {
	if (luaState.isJavaObject(1, Map.class)) {
	Map<Object, Object> map = luaState.toJavaObject(1, Map.class);
	luaState.pushJavaObject(new LuaMap(map));
	} else if (luaState.isJavaObject(1, List.class)) {
	List<Object> list = luaState.toJavaObject(1, List.class);
	luaState.pushJavaObject(new LuaList(list));
	} else {
	luaState.checkArg(
	1,
	false,
	String.format("expected map or list, got %s",
	luaState.typeName(1)));
	}
	return 1;
	}

	@Override
	public String getName() {
	return "totable";
	}

	// -- Member types
	/**
	* Provides table-like access in Lua to a Java map.
	*/
	private static class LuaMap implements JavaReflector, TypedJavaObject {
	// -- Static
	private static final JavaFunction INDEX = new Index();
	private static final JavaFunction NEW_INDEX = new NewIndex();

	// -- State
	private Map<Object, Object> map;

	// -- Construction
	/**
	* Creates a new instance.
	*/
	public LuaMap(Map<Object, Object> map) {
	this.map = map;
	}

	// -- Properties
	/**
	* Returns the map.
	*/
	public Map<Object, Object> getMap() {
	return map;
	}

	// -- JavaReflector methods
	@Override
	public JavaFunction getMetamethod(Metamethod metamethod) {
	switch (metamethod) {
	case INDEX:
	return INDEX;
	case NEWINDEX:
	return NEW_INDEX;
	default:
	return null;
	}
	}

	// -- TypedJavaObject methods
	@Override
	public Object getObject() {
	return map;
	}

	@Override
	public Class<?> getType() {
	return Map.class;
	}

	@Override
	public boolean isStrong() {
	return true;
	}

	// -- Member types
	/**
	* __index implementation for maps.
	*/
	private static class Index implements JavaFunction {
	// -- JavaFunction methods
	@Override
	public int invoke(LuaState luaState) {
	LuaMap luaMap = (LuaMap) luaState.toJavaObjectRaw(1);
	Object key = luaState.toJavaObject(2, Object.class);
	if (key == null) {
	throw new LuaRuntimeException(String.format(
	"attempt to read map with %s accessor",
	luaState.typeName(2)));
	}
	luaState.pushJavaObject(luaMap.getMap().get(key));
	return 1;
	}
	}

	/**
	* __newindex implementation for maps.
	*/
	private static class NewIndex implements JavaFunction {
	// -- JavaFunction methods
	@Override
	public int invoke(LuaState luaState) {
	LuaMap luaMap = (LuaMap) luaState.toJavaObjectRaw(1);
	Object key = luaState.toJavaObject(2, Object.class);
	if (key == null) {
	throw new LuaRuntimeException(String.format(
	"attempt to write map with %s accessor",
	luaState.typeName(2)));
	}
	Object value = luaState.toJavaObject(3, Object.class);
	if (value != null) {
	luaMap.getMap().put(key, value);
	} else {
	luaMap.getMap().remove(key);
	}
	return 0;
	}
	}
	}

	/**
	* Provides table-like access in Lua to a Java list.
	*/
	private static class LuaList implements JavaReflector, TypedJavaObject {
	// -- Static
	private static final JavaFunction INDEX = new Index();
	private static final JavaFunction NEW_INDEX = new NewIndex();
	private static final JavaFunction LENGTH = new Length();

	// -- State
	private List<Object> list;

	// -- Construction
	/**
	* Creates a new instance.
	*/
	public LuaList(List<Object> list) {
	this.list = list;
	}

	// -- Properties
	/**
	* Returns the map.
	*/
	public List<Object> getList() {
	return list;
	}

	// -- JavaReflector methods
	@Override
	public JavaFunction getMetamethod(Metamethod metamethod) {
	switch (metamethod) {
	case INDEX:
	return INDEX;
	case NEWINDEX:
	return NEW_INDEX;
	case LEN:
	return LENGTH;
	default:
	return null;
	}
	}

	// -- TypedJavaObject methods
	@Override
	public Object getObject() {
	return list;
	}

	@Override
	public Class<?> getType() {
	return List.class;
	}

	@Override
	public boolean isStrong() {
	return true;
	}

	// -- Member types
	/**
	* __index implementation for lists.
	*/
	private static class Index implements JavaFunction {
	// -- JavaFunction methods
	@Override
	public int invoke(LuaState luaState) {
	LuaList luaList = (LuaList) luaState.toJavaObjectRaw(1);
	if (!luaState.isNumber(2)) {
	throw new LuaRuntimeException(String.format(
	"attempt to read list with %s accessor",
	luaState.typeName(2)));
	}
	int index = luaState.toInteger(2);
	luaState.pushJavaObject(luaList.getList().get(index - 1));
	return 1;
	}
	}

	/**
	* __newindex implementation for lists.
	*/
	private static class NewIndex implements JavaFunction {
	// -- JavaFunction methods
	@Override
	public int invoke(LuaState luaState) {
	LuaList luaList = (LuaList) luaState.toJavaObjectRaw(1);
	if (!luaState.isNumber(2)) {
	throw new LuaRuntimeException(String.format(
	"attempt to write list with %s accessor",
	luaState.typeName(2)));
	}
	int index = luaState.toInteger(2);
	Object value = luaState.toJavaObject(3, Object.class);
	if (value != null) {
	int size = luaList.getList().size();
	if (index - 1 != size) {
	luaList.getList().set(index - 1, value);
	} else {
	luaList.getList().add(value);
	}
	} else {
	luaList.getList().remove(index - 1);
	}
	return 0;
	}
	}

	/**
	* __len implementation for lists.
	*/
	private static class Length implements JavaFunction {
	// -- JavaFunction methods
	@Override
	public int invoke(LuaState luaState) {
	LuaList luaList = (LuaList) luaState.toJavaObjectRaw(1);
	luaState.pushInteger(luaList.getList().size());
	return 1;
	}
	}
	}
	}

	/**
	* Provides an iterator for Iterable objects.
	*/
	private static class Elements implements NamedJavaFunction {
	// -- NamedJavaFunction methods
	@Override
	public int invoke(LuaState luaState) {
	Iterable<?> iterable = luaState.checkJavaObject(1, Iterable.class);
	luaState.pushJavaObject(new ElementIterator(iterable.iterator()));
	luaState.pushJavaObject(iterable);
	luaState.pushNil();
	return 3;
	}

	@Override
	public String getName() {
	return "elements";
	}

	// -- Member types
	private static class ElementIterator implements JavaFunction {
	// -- State
	private Iterator<?> iterator;

	// -- Construction
	/**
	* Creates a new instance.
	*/
	public ElementIterator(Iterator<?> iterator) {
	this.iterator = iterator;
	}

	// -- JavaFunction methods
	@Override
	public int invoke(LuaState luaState) {
	if (iterator.hasNext()) {
	luaState.pushJavaObject(iterator.next());
	} else {
	luaState.pushNil();
	}
	return 1;
	}
	}
	}

	/**
	* Provides an iterator for Java object fields.
	*/
	private static class Fields implements NamedJavaFunction {
	// -- NamedJavaFunction methods
	@Override
	public int invoke(LuaState luaState) {
	luaState.checkArg(
	1,
	luaState.isJavaObjectRaw(1),
	String.format("expected Java object, got %s",
	luaState.typeName(1)));
	JavaFunction metamethod = luaState.getMetamethod(
	luaState.toJavaObjectRaw(1), Metamethod.JAVAFIELDS);
	return metamethod.invoke(luaState);
	}

	@Override
	public String getName() {
	return "fields";
	}
	}

	/**
	* Provides an iterator for Java methods.
	*/
	private static class Methods implements NamedJavaFunction {
	// -- NamedJavaFunction methods
	@Override
	public int invoke(LuaState luaState) {
	luaState.checkArg(
	1,
	luaState.isJavaObjectRaw(1),
	String.format("expected Java object, got %s",
	luaState.typeName(1)));
	JavaFunction metamethod = luaState.getMetamethod(
	luaState.toJavaObjectRaw(1), Metamethod.JAVAMETHODS);
	return metamethod.invoke(luaState);
	}

	@Override
	public String getName() {
	return "methods";
	}
	}

	/**
	* Provides an iterator for Java object properties.
	*/
	private static class Properties implements NamedJavaFunction {
	// -- NamedJavaFunction methods
	@Override
	public int invoke(LuaState luaState) {
	luaState.checkArg(
	1,
	luaState.isJavaObjectRaw(1),
	String.format("expected Java object, got %s",
	luaState.typeName(1)));
	JavaFunction metamethod = luaState.getMetamethod(
	luaState.toJavaObjectRaw(1), Metamethod.JAVAPROPERTIES);
	return metamethod.invoke(luaState);
	}

	@Override
	public String getName() {
	return "properties";
	}
	}
	}