Java LuaError类代码示例

import org.luaj.vm2.LuaError; //导入依赖的package包/类
/**
 * bind lua functions using method
 *
 * @param factory
 * @param methods
 * @return
 */
public static LuaTable bindMethods(Class<? extends LibFunction> factory, List<Method> methods) {
    LuaTable env = new LuaTable();
    try {
        if (methods != null) {
            for (int i = 0; i < methods.size(); i++) {
                LibFunction f = factory.newInstance();
                f.opcode = -1;
                f.method = methods.get(i);
                f.name = methods.get(i).getName();
                env.set(f.name, f);
            }
        }
    } catch (Exception e) {
        throw new LuaError("[Bind Failed] " + e);
    } finally {
        return env;
    }
}
 

import org.luaj.vm2.LuaError; //导入依赖的package包/类
/**
 * bind lua functions using opcode
 *
 * @param factory
 * @param methods
 * @return
 */
public static LuaTable bind(Class<? extends LibFunction> factory, List<String> methods) {
    LuaTable env = new LuaTable();
    try {
        if (methods != null) {
            for (int i = 0; i < methods.size(); i++) {
                LibFunction f = factory.newInstance();
                f.opcode = i;
                f.method = null;
                f.name = methods.get(i);
                env.set(f.name, f);
            }
        }
    } catch (Exception e) {
        throw new LuaError("[Bind Failed] " + e);
    } finally {
        return env;
    }
}
 

import org.luaj.vm2.LuaError; //导入依赖的package包/类
public LuaValue get(LuaValue key) {
	if ( jclass == null )
		jclass = JavaClass.forClass(m_instance.getClass());
	Field f = jclass.getField(key);
	if ( f != null )
		try {
			return CoerceJavaToLua.coerce(f.get(m_instance));
		} catch (Exception e) {
			throw new LuaError(e);
		}
	LuaValue m = jclass.getMethod(key);
	if ( m != null )
		return m;
	Class c = jclass.getInnerClass(key);
	if ( c != null )
		return JavaClass.forClass(c);
	return super.get(key);
}
 

import org.luaj.vm2.LuaError; //导入依赖的package包/类
private void invokeFor(Class[] parameters, Object[] param, Varargs args, Method method) {
	try {
		for (int i = 0; i < parameters.length; i++) {

			param[i] = LuaConversion.convertToJava(parameters[i], args.arg(i + 1));
		}
	} catch (Exception ignored) {
		continue;
	}
	try {
		Object invoke = method.invoke(null, param);
		return LuaConversion.convertToLua(invoke);
	} catch (Exception e) {
		throw new LuaError(e);
	}
}
 

import org.luaj.vm2.LuaError; //导入依赖的package包/类
public void completed(String message, SocketReader socketReader) throws IOException {
    final int valueSize = Integer.parseInt(message);
    final String valueString = socketReader.readBytes(valueSize);

    log.debug("Read value: " + valueString);
    try {
        Globals globals = JsePlatform.debugGlobals();
        LuaValue chunk = globals.load(valueString);
        LuaTable stackDump = chunk.call().checktable();  // Executes the chunk and returns it
        LuaRemoteStack.clearIdKey(stackDump);
        LuaValue rawValue = stackDump;
        if (stackDump.keyCount() == 1)
            rawValue = stackDump.get(1);
        else if (stackDump.keyCount() == 0)
            rawValue = LuaValue.NIL;
        LuaDebugValue value = new LuaDebugValue(rawValue, AllIcons.Debugger.Watch);
        myPromise.setResult(value);
    } catch (LuaError e) {
        LuaDebugValue errorValue = new LuaDebugValue(
                "error",
                "Error during evaluation: " + e.getMessage(),
                AllIcons.Nodes.ErrorMark
        );
        myPromise.setResult(errorValue);
    }
}
 

import org.luaj.vm2.LuaError; //导入依赖的package包/类
public Runnable getRunnableExecution(final String text) {
    return new FutureTask<Object>(new Runnable() {
        @Override
        public void run() {
            try {
                setStatus("[running...]");
                final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

                // evaluate Lua code from String
                final PrintStream stdout = _G.STDOUT;
                _G.STDOUT = new PrintStream(outputStream);
                _G.get("load").call(LuaValue.valueOf(text)).call();

                print(new String(outputStream.toByteArray(), CharsetToolkit.UTF8_CHARSET));
                _G.STDOUT = stdout;
            } catch (LuaError e) {
                printError(e);
            } finally {
                setStatus("");
            }
        }
    }, null);
}
 

import org.luaj.vm2.LuaError; //导入依赖的package包/类
@Override
public LuaValue call(LuaValue arg) {
	if (limit == null) {
		throw new LuaError("Calling this function is not allowed in the current state.");
	}
	
	if (arg.isstring()) {
		String toLoad = arg.tojstring();
		
		toLoad = toLoad.replaceAll("\\.+", ".");
		toLoad = Paths.get(limit.toString(), toLoad).toString();
		
		return originalFunction.call(LuaValue.valueOf(toLoad));
	}
	
	return LuaValue.NIL;
}
 

import org.luaj.vm2.LuaError; //导入依赖的package包/类
/**
 * Returns the given {@link LuaValue} as the appropriate
 * type of {@link LuaObjectValue}, directed by the
 * provided {@link LuaObjectMeta} type.
 * 
 * <p>If the provided value is not of the appropriate
 * type, a {@link LuaError} is raised.</p>
 * 
 * @param value the LuaValue to check
 * @param clazz the target LuaObjectMeta type to check
 *        with
 * 
 * @return the appropriately typed LuaValue as a
 *         LuaObjectValue
 */
public static <T> LuaObjectValue<T> checkType(LuaValue value,
    Class<? extends LuaObjectMeta> clazz) {
    LuaObjectMeta meta = Lua.getMeta(clazz);
    if (meta == null) {
        throw new IllegalArgumentException(
            "Meta class " + clazz.getSimpleName() + " isn't registered");
    }

    if (value instanceof LuaObjectValue) {
        LuaObjectValue<?> objectValue = ((LuaObjectValue<?>) value);
        if (meta.getTargetObjectClass().isInstance(objectValue.getObject())) {
            return (LuaObjectValue<T>) objectValue;
        }
    }

    throw new LuaError(String.format(INVALID_TYPE_MSG, meta.getTypeName(), value.typename()));
}
 

import org.luaj.vm2.LuaError; //导入依赖的package包/类
public ColorsLib() {
    super("colors");

    set("fromHex", asFunction(vargs -> {
        String hex = vargs.checkjstring(1);
        if(hex.length() < 6) {
            throw new LuaError("bad argument: bad hex color string (must be at least 6 hexadecimal characters)");
        }

        return of(Color.valueOf(hex));
    }));

    set("fromRGB", asFunction(vargs -> {
        int r = vargs.optint(1, 0);
        int g = vargs.optint(2, 0);
        int b = vargs.optint(3, 0);
        return of(new Color(r / 255F, g / 255F, b / 255F, 1F));
    }));
}
 

import org.luaj.vm2.LuaError; //导入依赖的package包/类
public LuaWorldRoom(ScriptManager manager, File luaFile, Varargs params)
    throws FileNotFoundException, LuaScriptException {
    this();

    this.luaObj.load(manager, luaFile);

    String loadedMap = this.luaObj.get(FIELD_TILEMAP).optjstring(null);
    if (loadedMap != null) {
        Tilemap map = Undertailor.getInstance().getAssetManager().getTilemapManager()
            .getTilemap(loadedMap);
        if (map == null) {
            throw new LuaError("unknown tilemap " + loadedMap);
        }

        super.tilemap = map;
    }
}
 

import org.luaj.vm2.LuaError; //导入依赖的package包/类
public LuaValue off(LuaValue inventoryWrapper, LuaValue eventName, LuaValue callback) {
    if (inventoryWrapper instanceof InventoryWrapper) {
        Inventory inventory = ((InventoryWrapper) inventoryWrapper).getInventory();
        if (eventName.isnil()) {
            return LuaValue.valueOf(!eventHandlers.remove(inventory).isEmpty());
        } else {
            Multimap<String, LuaFunction> handlers = eventHandlers.get(inventory);
            if (handlers != null) {
                if (callback.isnil()) {
                    return LuaValue.valueOf(!handlers.removeAll(eventName.checkjstring()).isEmpty());
                } else {
                    return LuaFunction.valueOf(handlers.remove(eventName.checkjstring(), callback.checkfunction()));
                }
            } else {
                return LuaValue.FALSE;
            }
        }
    }else {
        throw new LuaError("Not an inventory");
    }
}
 

import org.luaj.vm2.LuaError; //导入依赖的package包/类
@LuaFunction("log")
public void log(Varargs varargs) {
    if (varargs.narg() >= 2) {
        switch (varargs.checkjstring(1)) {
            case "info":
                plugin.getLogger().info(varargs.checkjstring(2));
                break;
            case "warn":
                plugin.getLogger().warning(varargs.checkjstring(2));
                break;
            case "error":
                plugin.getLogger().severe(varargs.checkjstring(2));
                break;
            default:
                throw new LuaError("Invalid argument, first parameter must be info, warn or error.");
        }
    } else {
        plugin.getLogger().info(varargs.checkjstring(1));
    }
}
 

import org.luaj.vm2.LuaError; //导入依赖的package包/类
/**
 * Get the managed entity that is represented by the given lua value.
 *
 * @param entity lua value that represents a managed entity
 * @param strict if true, a {@link LuaError} will be thrown if the entity is not a managed entity, if false, null will be returned
 * @return the managed entity or null
 * @throws LuaError if there are missing attributes or if strict is true and the entity is not a managed entity
 */
public static RpgPlusEntity getManagedEntity(LuaValue entity, boolean strict) {
    if (entity.isuserdata(Entity.class)) {
        // TODO get managed entity
        /*
        ManagedEntity managedEntity = RpgPlus.getPlugin(RpgPlus.class).getEntityManager().getEntity((Entity) CoerceLuaToJava.coerce(entity, Entity.class));
        if (managedEntity instanceof RpgPlusEntity) {
            return (RpgPlusEntity) managedEntity;
        }
        */
    } else if (entity.isuserdata(RpgPlusEntity.class)) {
        return (RpgPlusEntity) CoerceLuaToJava.coerce(entity, RpgPlusEntity.class);
    } else if (entity instanceof EntityWrapper) {
        return ((EntityWrapper) entity).getEntity();
    }

    if (strict) {
        throw new LuaError(entity + " is not a managed entity");
    } else {
        return null;
    }
}
 

import org.luaj.vm2.LuaError; //导入依赖的package包/类
/**
 * Bind a set of library functions, with an offset
 * <p>
 * An array of names is provided, and the first name is bound
 * with opcode = {@code firstopcode}, second with {@code firstopcode+1}, etc.
 * @param env The environment to apply to each bound function
 * @param factory the Class to instantiate for each bound function
 * @param names array of String names, one for each function.
 * @param firstopcode the first opcode to use
 * @see #bind(LuaValue, Class, String[])
 */
protected static void bind(LuaValue env, Class<?> factory, String[] names, int firstopcode)
{
	try
	{
		for(int i = 0, n = names.length; i < n; i++)
		{
			LibFunction f = (LibFunction)factory.newInstance();
			f._opcode = firstopcode + i;
			f._name = names[i];
			f._env = env;
			env.set(f._name, f);
		}
	}
	catch(Exception e)
	{
		throw new LuaError("bind failed: " + e);
	}
}
 

import org.luaj.vm2.LuaError; //导入依赖的package包/类
@Override
public LuaValue get(LuaValue key)
{
	if(_jclass == null)
	    _jclass = JavaClass.forClass(_instance.getClass());
	Field f = _jclass.getField(key);
	if(f != null)
	    try
	    {
		    return CoerceJavaToLua.coerce(f.get(_instance));
	    }
	    catch(Exception e)
	    {
		    throw new LuaError(e);
	    }
	LuaValue m = _jclass.getMethod(key);
	if(m != null)
	    return m;
	return super.get(key);
}