# Uses of Class org.luaj.vm2.LuaValue (Luaj API)
Date: 2015-04-29

## Uses of Class
org.luaj.vm2.LuaValue

Packages that use LuaValue
org.luaj.vm2
org.luaj.vm2.compiler
org.luaj.vm2.lib
org.luaj.vm2.lib.jme
org.luaj.vm2.lib.jse
org.luaj.vm2.luajc

Uses of LuaValue in org.luaj.vm2

Subclasses of LuaValue in org.luaj.vm2
`class` `Globals` Global environment used by luaj.
`class` `LuaBoolean` Extension of `LuaValue` which can hold a Java boolean as its value.
`class` `LuaClosure` Extension of `LuaFunction` which executes lua bytecode.
`class` `LuaDouble` Extension of `LuaNumber` which can hold a Java double as its value.
`class` `LuaFunction` Base class for functions implemented in Java.
`class` `LuaInteger` Extension of `LuaNumber` which can hold a Java int as its value.
`class` `LuaNil` Class to encapsulate behavior of the singleton instance `nil`
`class` `LuaNumber` Base class for representing numbers as lua values directly.
`class` `LuaString` Subclass of `LuaValue` for representing lua strings.
`class` `LuaTable` Subclass of `LuaValue` for representing lua tables.
`class` `LuaThread` Subclass of `LuaValue` that implements a lua coroutine thread using Java Threads.
`class` `LuaUserdata`

Fields in org.luaj.vm2 declared as LuaValue
`protected LuaValue[]` `LuaTable.array` the array values
`LuaValue` `LuaThread.errorfunc` Error message handler for this thread, if any.
`LuaValue` `LuaThread.State.function`
`LuaValue` `LuaThread.State.hookfunc` Hook function control state used by debug lib.
`LuaValue[]` `Prototype.k`
`LuaValue` `LuaUserdata.m_metatable`
`static LuaValue` `LuaValue.NIL` LuaValue constant corresponding to lua `#NIL`
`static LuaValue[]` `LuaValue.NILS` Array of `NIL` values to optimize filling stacks using System.arraycopy().
`static LuaValue` `LuaValue.NONE` LuaValue constant corresponding to a `Varargs` list of no values
`static LuaValue[]` `LuaValue.NOVALS` LuaValue array constant with no values
`static LuaValue` `LuaBoolean.s_metatable` Shared static metatable for boolean values represented in lua.
`static LuaValue` `LuaFunction.s_metatable` Shared static metatable for all functions and closures.
`static LuaValue` `LuaNil.s_metatable`
`static LuaValue` `LuaNumber.s_metatable` Shared static metatable for all number values represented in lua.
`static LuaValue` `LuaString.s_metatable` The singleton instance for string metatables that forwards to the string functions.
`static LuaValue` `LuaThread.s_metatable` Shared metatable for lua threads.

Methods in org.luaj.vm2 that return LuaValue
`LuaValue` `LuaDouble.add(double lhs)`
`LuaValue` `LuaInteger.add(double lhs)`
`LuaValue` `LuaString.add(double rhs)`
`LuaValue` `LuaValue.add(double rhs)` Add: Perform numeric add operation with another value of double type with metatag processing
`LuaValue` `LuaInteger.add(int lhs)`
`LuaValue` `LuaString.add(int rhs)`
`LuaValue` `LuaValue.add(int rhs)` Add: Perform numeric add operation with another value of int type with metatag processing
`LuaValue` `LuaDouble.add(LuaValue rhs)`
`LuaValue` `LuaInteger.add(LuaValue rhs)`
`LuaValue` `LuaString.add(LuaValue rhs)`
`LuaValue` `LuaValue.add(LuaValue rhs)` Add: Perform numeric add operation with another value including metatag processing.
`LuaValue` `LuaValue.and(LuaValue rhs)` Perform boolean `and` with another operand, based on lua rules for boolean evaluation.
`LuaValue` `LuaValue.arg(int index)`
`LuaValue` `TailcallVarargs.arg(int i)`
`abstract LuaValue` `Varargs.arg(int i)` Get the n-th argument value (1-based).
`LuaValue` `LuaValue.arg1()`
`LuaValue` `TailcallVarargs.arg1()`
`abstract LuaValue` `Varargs.arg1()` Get the first argument in the list.
`static LuaValue` `LuaValue.argerror(int iarg, java.lang.String msg)` Throw a `LuaError` indicating an invalid argument was supplied to a function
`protected LuaValue` `LuaValue.argerror(java.lang.String expected)` Throw a `LuaError` indicating an invalid argument was supplied to a function
`protected LuaValue` `LuaValue.aritherror()` Throw a `LuaError` based on an arithmetic error such as add, or pow, typically due to an invalid operand type
`protected LuaValue` `LuaValue.aritherror(java.lang.String fun)` Throw a `LuaError` based on an arithmetic error such as add, or pow, typically due to an invalid operand type
`protected LuaValue` `LuaValue.arithmt(LuaValue tag, LuaValue op2)` Perform metatag processing for arithmetic operations.
`protected LuaValue` `LuaValue.arithmtwith(LuaValue tag, double op1)` Perform metatag processing for arithmetic operations when the left-hand-side is a number.
`LuaValue` `LuaTable.arrayget(LuaValue[] array, int index)`
`LuaValue` `WeakTable.arrayget(LuaValue[] array, int index)`
`LuaValue` `LuaClosure.call()`
`LuaValue` `LuaValue.call()` Call `this` with 0 arguments, including metatag processing, and return only the first return value.
`LuaValue` `LuaClosure.call(LuaValue arg)`
`LuaValue` `LuaValue.call(LuaValue arg)` Call `this` with 1 argument, including metatag processing, and return only the first return value.
`LuaValue` `LuaClosure.call(LuaValue arg1, LuaValue arg2)`
`LuaValue` `LuaValue.call(LuaValue arg1, LuaValue arg2)` Call `this` with 2 arguments, including metatag processing, and return only the first return value.
`LuaValue` `LuaClosure.call(LuaValue arg1, LuaValue arg2, LuaValue arg3)`
`LuaValue` `LuaValue.call(LuaValue arg1, LuaValue arg2, LuaValue arg3)` Call `this` with 3 arguments, including metatag processing, and return only the first return value.
`LuaValue` `LuaValue.call(java.lang.String arg)` Convenience function which calls a luavalue with a single, string argument.
`protected LuaValue` `LuaValue.callmt()` Get the metatag value for the `CALL` metatag, if it exists.
`protected LuaValue` `LuaValue.checkmetatag(LuaValue tag, java.lang.String reason)` Get particular metatag, or throw `LuaError` if it doesn't exist
`LuaValue` `LuaNil.checknotnil()`
`LuaValue` `LuaValue.checknotnil()` Check that this is not the value `NIL`, or throw `LuaError` if it is
`LuaValue` `Varargs.checknotnil(int i)` Return argument i as a LuaValue if it is not nil, or throw an error if it is nil.
`LuaValue` `Varargs.checkvalue(int i)` Return argument i as a LuaValue if it exists, or throw an error.
`protected LuaValue` `LuaValue.compareerror(LuaValue rhs)` Throw a `LuaError` based on a comparison error such as greater-than or less-than, typically due to an invalid operand type
`protected LuaValue` `LuaValue.compareerror(java.lang.String rhs)` Throw a `LuaError` based on a comparison error such as greater-than or less-than, typically due to an invalid operand type
`LuaValue` `LuaValue.comparemt(LuaValue tag, LuaValue op1)` Perform metatag processing for comparison operations.
`LuaValue` `LuaTable.concat(LuaString sep, int i, int j)` Concatenate the contents of a table efficiently, using `Buffer`
`LuaValue` `LuaNumber.concat(LuaValue rhs)`
`LuaValue` `LuaString.concat(LuaValue rhs)`
`LuaValue` `LuaValue.concat(LuaValue rhs)` Concatenate another value onto this value and return the result using rules of lua string concatenation including metatag processing.
`LuaValue` `LuaValue.concatmt(LuaValue rhs)` Perform metatag processing for concatenation operations.
`LuaValue` `LuaNumber.concatTo(LuaNumber lhs)`
`LuaValue` `LuaString.concatTo(LuaNumber lhs)`
`LuaValue` `LuaValue.concatTo(LuaNumber lhs)` Reverse-concatenation: concatenate this value onto another value known to be a `LuaNumber` and return the result using rules of lua string concatenation including metatag processing.
`LuaValue` `LuaNumber.concatTo(LuaString lhs)`
`LuaValue` `LuaString.concatTo(LuaString lhs)`
`LuaValue` `LuaValue.concatTo(LuaString lhs)` Reverse-concatenation: concatenate this value onto another value known to be a `LuaString` and return the result using rules of lua string concatenation including metatag processing.
`LuaValue` `LuaValue.concatTo(LuaValue lhs)` Reverse-concatenation: concatenate this value onto another value whose type is unknwon and return the result using rules of lua string concatenation including metatag processing.
`static LuaValue` `LuaDouble.ddiv(double lhs, double rhs)` Divide two double numbers according to lua math, and return a `LuaValue` result.
`LuaValue` `LuaDouble.div(double rhs)`
`LuaValue` `LuaInteger.div(double rhs)`
`LuaValue` `LuaString.div(double rhs)`
`LuaValue` `LuaValue.div(double rhs)` Divide: Perform numeric divide operation by another value of double type without metatag processing
`LuaValue` `LuaDouble.div(int rhs)`
`LuaValue` `LuaInteger.div(int rhs)`
`LuaValue` `LuaString.div(int rhs)`
`LuaValue` `LuaValue.div(int rhs)` Divide: Perform numeric divide operation by another value of int type without metatag processing
`LuaValue` `LuaDouble.div(LuaValue rhs)`
`LuaValue` `LuaInteger.div(LuaValue rhs)`
`LuaValue` `LuaString.div(LuaValue rhs)`
`LuaValue` `LuaValue.div(LuaValue rhs)` Divide: Perform numeric divide operation by another value of unknown type, including metatag processing.
`LuaValue` `LuaDouble.divInto(double lhs)`
`LuaValue` `LuaInteger.divInto(double lhs)`
`LuaValue` `LuaString.divInto(double lhs)`
`LuaValue` `LuaValue.divInto(double lhs)` Reverse-divide: Perform numeric divide operation into another value with metatag processing
`static LuaValue` `LuaDouble.dmod(double lhs, double rhs)` Take modulo double numbers according to lua math, and return a `LuaValue` result.
`LuaValue` `LuaDouble.eq(LuaValue val)`
`LuaValue` `LuaInteger.eq(LuaValue val)`
`LuaValue` `LuaString.eq(LuaValue val)`
`LuaValue` `LuaTable.eq(LuaValue val)`
`LuaValue` `LuaUserdata.eq(LuaValue val)`
`LuaValue` `LuaValue.eq(LuaValue val)` Equals: Perform equality comparison with another value including metatag processing using `EQ`.
`static LuaValue` `LuaValue.error(java.lang.String message)` Throw a `LuaError` with a particular message
`LuaValue` `LuaTable.get(int key)`
`LuaValue` `LuaValue.get(int key)` Get a value in a table including metatag processing using `INDEX`.
`LuaValue` `LuaTable.get(LuaValue key)`
`LuaValue` `LuaUserdata.get(LuaValue key)`
`LuaValue` `LuaValue.get(LuaValue key)` Get a value in a table including metatag processing using `INDEX`.
`LuaValue` `LuaValue.get(java.lang.String key)` Get a value in a table including metatag processing using `INDEX`.
`LuaValue` `LuaError.getMessageObject()` Get the LuaValue that was provided in the constructor, or a LuaString containing the message if it was a string error argument.
`LuaValue` `LuaBoolean.getmetatable()`
`LuaValue` `LuaClosure.getmetatable()`
`LuaValue` `LuaFunction.getmetatable()`
`LuaValue` `LuaNil.getmetatable()`
`LuaValue` `LuaNumber.getmetatable()`
`LuaValue` `LuaString.getmetatable()`
`LuaValue` `LuaTable.getmetatable()`
`LuaValue` `LuaThread.getmetatable()`
`LuaValue` `LuaUserdata.getmetatable()`
`LuaValue` `LuaValue.getmetatable()` Get the metatable for this `LuaValue`
`protected static LuaValue` `LuaValue.gettable(LuaValue t, LuaValue key)` get value from metatable operations, or NIL if not defined by metatables
`protected LuaValue` `LuaClosure.getUpvalue(int i)`
`LuaValue` `UpValue.getValue()` Get the value of the upvalue
`LuaValue` `LuaDouble.gt(double rhs)`
`LuaValue` `LuaInteger.gt(double rhs)`
`LuaValue` `LuaValue.gt(double rhs)` Greater than: Perform numeric comparison with another value of double type, including metatag processing, and returning `LuaValue`.
`LuaValue` `LuaDouble.gt(int rhs)`
`LuaValue` `LuaInteger.gt(int rhs)`
`LuaValue` `LuaValue.gt(int rhs)` Greater than: Perform numeric comparison with another value of int type, including metatag processing, and returning `LuaValue`.
`LuaValue` `LuaDouble.gt(LuaValue rhs)`
`LuaValue` `LuaInteger.gt(LuaValue rhs)`
`LuaValue` `LuaString.gt(LuaValue rhs)`
`LuaValue` `LuaValue.gt(LuaValue rhs)` Greater than: Perform numeric or string comparison with another value of unknown type, including metatag processing, and returning `LuaValue`.
`LuaValue` `LuaDouble.gteq(double rhs)`
`LuaValue` `LuaInteger.gteq(double rhs)`
`LuaValue` `LuaValue.gteq(double rhs)` Greater than or equals: Perform numeric comparison with another value of double type, including metatag processing, and returning `LuaValue`.
`LuaValue` `LuaDouble.gteq(int rhs)`
`LuaValue` `LuaInteger.gteq(int rhs)`
`LuaValue` `LuaValue.gteq(int rhs)` Greater than or equals: Perform numeric comparison with another value of int type, including metatag processing, and returning `LuaValue`.
`LuaValue` `LuaDouble.gteq(LuaValue rhs)`
`LuaValue` `LuaInteger.gteq(LuaValue rhs)`
`LuaValue` `LuaString.gteq(LuaValue rhs)`
`LuaValue` `LuaValue.gteq(LuaValue rhs)` Greater than or equals: Perform numeric or string comparison with another value of unknown type, including metatag processing, and returning `LuaValue`.
`protected LuaValue` `LuaTable.hashget(LuaValue key)`
`protected LuaValue` `LuaValue.illegal(java.lang.String op, java.lang.String typename)` Throw a `LuaError` indicating an illegal operation occurred, typically involved in managing weak references
`LuaValue[]` `LuaTable.keys()` This may be deprecated in a future release.
`LuaValue` `LuaString.len()`
`LuaValue` `LuaTable.len()`
`LuaValue` `LuaValue.len()` Length operator: return lua length of object `(#this)` including metatag processing as java int
`protected LuaValue` `LuaValue.lenerror()` Throw a `LuaError` based on the len operator, typically due to an invalid operand type
`LuaValue` `Globals.load(java.io.InputStream is, java.lang.String chunkname, java.lang.String mode, LuaValue environment)` Load the content form an input stream as a binary chunk or text file.
`LuaValue` `LuaValue.load(LuaValue library)` Load a library instance by calling it with and empty string as the modname, and this Globals as the environment.
`LuaValue` `Globals.load(java.io.Reader reader, java.lang.String chunkname)` Load the content form a reader as a text file.
`LuaValue` `Globals.load(java.io.Reader reader, java.lang.String chunkname, LuaTable environment)` Load the content form a reader as a text file, supplying a custom environment.
`LuaValue` `Globals.load(java.lang.String script)` Convenience function to load a string value as a script.
`LuaValue` `Globals.load(java.lang.String script, java.lang.String chunkname)` Convenience function to load a string value as a script.
`LuaValue` `Globals.load(java.lang.String script, java.lang.String chunkname, LuaTable environment)` Convenience function to load a string value as a script with a custom environment.
`LuaValue` `Globals.loadfile(java.lang.String filename)` Convenience function for loading a file that is either binary lua or lua source.
`static LuaValue` `LoadState.longBitsToLuaNumber(long bits)` Convert bits in a long value to a `LuaValue`.
`LuaValue` `LuaDouble.lt(double rhs)`
`LuaValue` `LuaInteger.lt(double rhs)`
`LuaValue` `LuaValue.lt(double rhs)` Less than: Perform numeric comparison with another value of double type, including metatag processing, and returning `LuaValue`.
`LuaValue` `LuaDouble.lt(int rhs)`
`LuaValue` `LuaInteger.lt(int rhs)`
`LuaValue` `LuaValue.lt(int rhs)` Less than: Perform numeric comparison with another value of int type, including metatag processing, and returning `LuaValue`.
`LuaValue` `LuaDouble.lt(LuaValue rhs)`
`LuaValue` `LuaInteger.lt(LuaValue rhs)`
`LuaValue` `LuaString.lt(LuaValue rhs)`
`LuaValue` `LuaValue.lt(LuaValue rhs)` Less than: Perform numeric or string comparison with another value of unknown type, including metatag processing, and returning `LuaValue`.
`LuaValue` `LuaDouble.lteq(double rhs)`
`LuaValue` `LuaInteger.lteq(double rhs)`
`LuaValue` `LuaValue.lteq(double rhs)` Less than or equals: Perform numeric comparison with another value of double type, including metatag processing, and returning `LuaValue`.
`LuaValue` `LuaDouble.lteq(int rhs)`
`LuaValue` `LuaInteger.lteq(int rhs)`
`LuaValue` `LuaValue.lteq(int rhs)` Less than or equals: Perform numeric comparison with another value of int type, including metatag processing, and returning `LuaValue`.
`LuaValue` `LuaDouble.lteq(LuaValue rhs)`
`LuaValue` `LuaInteger.lteq(LuaValue rhs)`
`LuaValue` `LuaString.lteq(LuaValue rhs)`
`LuaValue` `LuaValue.lteq(LuaValue rhs)` Less than or equals: Perform numeric or string comparison with another value of unknown type, including metatag processing, and returning `LuaValue`.
`LuaValue` `LuaValue.metatag(LuaValue tag)` Get particular metatag, or return `NIL` if it doesn't exist
`LuaValue` `LuaValue.method(LuaValue name)` Call named method on `this` with 0 arguments, including metatag processing, and return only the first return value.
`LuaValue` `LuaValue.method(LuaValue name, LuaValue arg)` Call named method on `this` with 1 argument, including metatag processing, and return only the first return value.
`LuaValue` `LuaValue.method(LuaValue name, LuaValue arg1, LuaValue arg2)` Call named method on `this` with 2 arguments, including metatag processing, and return only the first return value.
`LuaValue` `LuaValue.method(java.lang.String name)` Call named method on `this` with 0 arguments, including metatag processing, and return only the first return value.
`LuaValue` `LuaValue.method(java.lang.String name, LuaValue arg)` Call named method on `this` with 1 argument, including metatag processing, and return only the first return value.
`LuaValue` `LuaValue.method(java.lang.String name, LuaValue arg1, LuaValue arg2)` Call named method on `this` with 2 arguments, including metatag processing, and return only the first return value.
`LuaValue` `LuaDouble.mod(double rhs)`
`LuaValue` `LuaInteger.mod(double rhs)`
`LuaValue` `LuaString.mod(double rhs)`
`LuaValue` `LuaValue.mod(double rhs)` Modulo: Perform numeric modulo operation with another value of double type without metatag processing
`LuaValue` `LuaDouble.mod(int rhs)`
`LuaValue` `LuaInteger.mod(int rhs)`
`LuaValue` `LuaString.mod(int rhs)`
`LuaValue` `LuaValue.mod(int rhs)` Modulo: Perform numeric modulo operation with another value of int type without metatag processing
`LuaValue` `LuaDouble.mod(LuaValue rhs)`
`LuaValue` `LuaInteger.mod(LuaValue rhs)`
`LuaValue` `LuaString.mod(LuaValue rhs)`
`LuaValue` `LuaValue.mod(LuaValue rhs)` Modulo: Perform numeric modulo operation with another value of unknown type, including metatag processing.
`LuaValue` `LuaDouble.modFrom(double lhs)`
`LuaValue` `LuaInteger.modFrom(double lhs)`
`LuaValue` `LuaString.modFrom(double lhs)`
`LuaValue` `LuaValue.modFrom(double lhs)` Reverse-modulo: Perform numeric modulo operation from another value with metatag processing
`LuaValue` `LuaDouble.mul(double lhs)`
`LuaValue` `LuaInteger.mul(double lhs)`
`LuaValue` `LuaString.mul(double rhs)`
`LuaValue` `LuaValue.mul(double rhs)` Multiply: Perform numeric multiply operation with another value of double type with metatag processing
`LuaValue` `LuaDouble.mul(int lhs)`
`LuaValue` `LuaInteger.mul(int lhs)`
`LuaValue` `LuaString.mul(int rhs)`
`LuaValue` `LuaValue.mul(int rhs)` Multiply: Perform numeric multiply operation with another value of int type with metatag processing
`LuaValue` `LuaDouble.mul(LuaValue rhs)`
`LuaValue` `LuaInteger.mul(LuaValue rhs)`
`LuaValue` `LuaString.mul(LuaValue rhs)`
`LuaValue` `LuaValue.mul(LuaValue rhs)` Multiply: Perform numeric multiply operation with another value of unknown type, including metatag processing.
`LuaValue` `LuaDouble.neg()`
`LuaValue` `LuaInteger.neg()`
`LuaValue` `LuaString.neg()`
`LuaValue` `LuaValue.neg()` Unary minus: return negative value `(-this)` as defined by lua unary minus operator
`LuaValue` `LuaValue.neq(LuaValue val)` Notquals: Perform inequality comparison with another value including metatag processing using `EQ`.
`LuaValue` `LuaBoolean.not()`
`LuaValue` `LuaNil.not()`
`LuaValue` `LuaValue.not()` Unary not: return inverse boolean value `(~this)` as defined by lua not operator
`LuaValue` `Varargs.optvalue(int i, LuaValue defval)` Return argument i as a LuaValue if it exists, or `defval`.
`LuaValue` `LuaNil.optvalue(LuaValue defval)`
`LuaValue` `LuaValue.optvalue(LuaValue defval)` Perform argument check that this is not nil or none.
`LuaValue` `LuaValue.or(LuaValue rhs)` Perform boolean `or` with another operand, based on lua rules for boolean evaluation.
`LuaValue` `LuaDouble.pow(double rhs)`
`LuaValue` `LuaInteger.pow(double rhs)`
`LuaValue` `LuaString.pow(double rhs)`
`LuaValue` `LuaValue.pow(double rhs)` Raise to power: Raise this value to a power of double type with metatag processing
`LuaValue` `LuaDouble.pow(int rhs)`
`LuaValue` `LuaInteger.pow(int rhs)`
`LuaValue` `LuaString.pow(int rhs)`
`LuaValue` `LuaValue.pow(int rhs)` Raise to power: Raise this value to a power of int type with metatag processing
`LuaValue` `LuaDouble.pow(LuaValue rhs)`
`LuaValue` `LuaInteger.pow(LuaValue rhs)`
`LuaValue` `LuaString.pow(LuaValue rhs)`
`LuaValue` `LuaValue.pow(LuaValue rhs)` Raise to power: Raise this value to a power including metatag processing.
`LuaValue` `LuaDouble.powWith(double lhs)`
`LuaValue` `LuaInteger.powWith(double lhs)`
`LuaValue` `LuaString.powWith(double lhs)`
`LuaValue` `LuaValue.powWith(double lhs)` Reverse-raise to power: Raise another value of double type to this power with metatag processing
`LuaValue` `LuaDouble.powWith(int lhs)`
`LuaValue` `LuaInteger.powWith(int lhs)`
`LuaValue` `LuaString.powWith(int lhs)`
`LuaValue` `LuaValue.powWith(int lhs)` Reverse-raise to power: Raise another value of double type to this power with metatag processing
`LuaValue` `LuaTable.rawget(int key)`
`LuaValue` `LuaValue.rawget(int key)` Get a value in a table without metatag processing.
`LuaValue` `LuaTable.rawget(LuaValue key)`
`LuaValue` `LuaValue.rawget(LuaValue key)` Get a value in a table without metatag processing.
`LuaValue` `LuaValue.rawget(java.lang.String key)` Get a value in a table without metatag processing.
`LuaValue` `LuaTable.remove(int pos)` Remove the element at a position in a list-table
`LuaValue` `LuaTable.setmetatable(LuaValue metatable)`
`LuaValue` `LuaUserdata.setmetatable(LuaValue metatable)`
`LuaValue` `LuaValue.setmetatable(LuaValue metatable)` Set the metatable for this `LuaValue`
`protected static LuaValue` `WeakTable.strengthen(java.lang.Object ref)` Unwrap a LuaValue from a WeakReference and/or WeakUserdata.
`LuaValue` `WeakTable.WeakSlot.strongkey()`
`LuaValue` `LuaValue.strongvalue()` Return this value as a strong reference, or null if it was weak and is no longer referenced.
`LuaValue` `WeakTable.WeakSlot.strongvalue()`
`LuaValue` `LuaDouble.sub(double rhs)`
`LuaValue` `LuaInteger.sub(double rhs)`
`LuaValue` `LuaString.sub(double rhs)`
`LuaValue` `LuaValue.sub(double rhs)` Subtract: Perform numeric subtract operation with another value of double type with metatag processing
`LuaValue` `LuaDouble.sub(int rhs)`
`LuaValue` `LuaInteger.sub(int rhs)`
`LuaValue` `LuaString.sub(int rhs)`
`LuaValue` `LuaValue.sub(int rhs)` Subtract: Perform numeric subtract operation with another value of int type with metatag processing
`LuaValue` `LuaDouble.sub(LuaValue rhs)`
`LuaValue` `LuaInteger.sub(LuaValue rhs)`
`LuaValue` `LuaString.sub(LuaValue rhs)`
`LuaValue` `LuaValue.sub(LuaValue rhs)` Subtract: Perform numeric subtract operation with another value of unknown type, including metatag processing.
`LuaValue` `LuaDouble.subFrom(double lhs)`
`LuaValue` `LuaInteger.subFrom(double lhs)`
`LuaValue` `LuaString.subFrom(double lhs)`
`LuaValue` `LuaValue.subFrom(double lhs)` Reverse-subtract: Perform numeric subtract operation from an int value with metatag processing
`LuaValue` `LuaInteger.subFrom(int lhs)`
`LuaValue` `LuaValue.subFrom(int lhs)` Reverse-subtract: Perform numeric subtract operation from a double value without metatag processing
`LuaValue` `LuaTable.toLuaValue()`
`LuaValue` `WeakTable.toLuaValue()`
`LuaValue` `LuaDouble.tonumber()`
`LuaValue` `LuaNumber.tonumber()`
`LuaValue` `LuaString.tonumber()` convert to a number using baee 10 or base 16 if it starts with '0x', or NIL if it can't be converted
`LuaValue` `LuaValue.tonumber()` Conditionally convert to lua number without throwing errors.
`LuaValue` `LuaString.tonumber(int base)` convert to a number using a supplied base, or NIL if it can't be converted
`LuaValue` `LuaDouble.tostring()`
`LuaValue` `LuaInteger.tostring()`
`LuaValue` `LuaString.tostring()`
`LuaValue` `LuaValue.tostring()` Conditionally convert to lua string without throwing errors.
`protected LuaValue` `LuaValue.typerror(java.lang.String expected)` Throw a `LuaError` indicating an invalid type was supplied to a function
`protected LuaValue` `LuaValue.unimplemented(java.lang.String fun)` Throw a `LuaError` indicating an operation is not implemented
`LuaValue` `Buffer.value()` Get buffer contents as a `LuaValue`
`protected static LuaValue` `WeakTable.weaken(LuaValue value)` Self-sent message to convert a value to its weak counterpart
`LuaValue` `LuaTable.wrap(LuaValue value)`
`LuaValue` `WeakTable.wrap(LuaValue value)`

Methods in org.luaj.vm2 with parameters of type LuaValue
`LuaValue` `LuaDouble.add(LuaValue rhs)`
`LuaValue` `LuaInteger.add(LuaValue rhs)`
`LuaValue` `LuaString.add(LuaValue rhs)`
`LuaValue` `LuaValue.add(LuaValue rhs)` Add: Perform numeric add operation with another value including metatag processing.
`LuaValue` `LuaValue.and(LuaValue rhs)` Perform boolean `and` with another operand, based on lua rules for boolean evaluation.
`Buffer` `Buffer.append(LuaValue val)` Append a `LuaValue` to the buffer.
`protected LuaValue` `LuaValue.arithmt(LuaValue tag, LuaValue op2)` Perform metatag processing for arithmetic operations.
`protected LuaValue` `LuaValue.arithmtwith(LuaValue tag, double op1)` Perform metatag processing for arithmetic operations when the left-hand-side is a number.
`LuaValue` `LuaTable.arrayget(LuaValue[] array, int index)`
`LuaValue` `WeakTable.arrayget(LuaValue[] array, int index)`
`LuaValue` `LuaClosure.call(LuaValue arg)`
`LuaValue` `LuaValue.call(LuaValue arg)` Call `this` with 1 argument, including metatag processing, and return only the first return value.
`LuaValue` `LuaClosure.call(LuaValue arg1, LuaValue arg2)`
`LuaValue` `LuaValue.call(LuaValue arg1, LuaValue arg2)` Call `this` with 2 arguments, including metatag processing, and return only the first return value.
`LuaValue` `LuaClosure.call(LuaValue arg1, LuaValue arg2, LuaValue arg3)`
`LuaValue` `LuaValue.call(LuaValue arg1, LuaValue arg2, LuaValue arg3)` Call `this` with 3 arguments, including metatag processing, and return only the first return value.
`protected LuaValue` `LuaValue.checkmetatag(LuaValue tag, java.lang.String reason)` Get particular metatag, or throw `LuaError` if it doesn't exist
`protected LuaValue` `LuaValue.compareerror(LuaValue rhs)` Throw a `LuaError` based on a comparison error such as greater-than or less-than, typically due to an invalid operand type
`LuaValue` `LuaValue.comparemt(LuaValue tag, LuaValue op1)` Perform metatag processing for comparison operations.
`LuaValue` `LuaNumber.concat(LuaValue rhs)`
`LuaValue` `LuaString.concat(LuaValue rhs)`
`LuaValue` `LuaValue.concat(LuaValue rhs)` Concatenate another value onto this value and return the result using rules of lua string concatenation including metatag processing.
`LuaValue` `LuaValue.concatmt(LuaValue rhs)` Perform metatag processing for concatenation operations.
`Buffer` `Buffer.concatTo(LuaValue lhs)` Concatenate this buffer onto a `LuaValue`
`LuaValue` `LuaValue.concatTo(LuaValue lhs)` Reverse-concatenation: concatenate this value onto another value whose type is unknwon and return the result using rules of lua string concatenation including metatag processing.
`protected static org.luaj.vm2.LuaTable.Entry` `LuaTable.defaultEntry(LuaValue key, LuaValue value)`
`LuaValue` `LuaDouble.div(LuaValue rhs)`
`LuaValue` `LuaInteger.div(LuaValue rhs)`
`LuaValue` `LuaString.div(LuaValue rhs)`
`LuaValue` `LuaValue.div(LuaValue rhs)` Divide: Perform numeric divide operation by another value of unknown type, including metatag processing.
`org.luaj.vm2.LuaTable.Slot` `LuaTable.entry(LuaValue key, LuaValue value)`
`org.luaj.vm2.LuaTable.Slot` `WeakTable.entry(LuaValue key, LuaValue value)`
`boolean` `LuaDouble.eq_b(LuaValue val)`
`boolean` `LuaInteger.eq_b(LuaValue val)`
`boolean` `LuaString.eq_b(LuaValue val)`
`boolean` `LuaTable.eq_b(LuaValue val)`
`boolean` `LuaUserdata.eq_b(LuaValue val)`
`boolean` `LuaValue.eq_b(LuaValue val)` Equals: Perform equality comparison with another value including metatag processing using `EQ`, and return java boolean
`LuaValue` `LuaDouble.eq(LuaValue val)`
`LuaValue` `LuaInteger.eq(LuaValue val)`
`LuaValue` `LuaString.eq(LuaValue val)`
`LuaValue` `LuaTable.eq(LuaValue val)`
`LuaValue` `LuaUserdata.eq(LuaValue val)`
`LuaValue` `LuaValue.eq(LuaValue val)` Equals: Perform equality comparison with another value including metatag processing using `EQ`.
`boolean` `LuaUserdata.eqmt(LuaValue val)`
`static boolean` `LuaValue.eqmtcall(LuaValue lhs, LuaValue lhsmt, LuaValue rhs, LuaValue rhsmt)` Perform equality testing metatag processing
`protected Varargs` `LuaClosure.execute(LuaValue[] stack, Varargs varargs)`
`org.luaj.vm2.LuaTable.StrongSlot` `WeakTable.WeakSlot.find(LuaValue key)`
`LuaValue` `LuaTable.get(LuaValue key)`
`LuaValue` `LuaUserdata.get(LuaValue key)`
`LuaValue` `LuaValue.get(LuaValue key)` Get a value in a table including metatag processing using `INDEX`.
`protected static LuaValue` `LuaValue.gettable(LuaValue t, LuaValue key)` get value from metatable operations, or NIL if not defined by metatables
`boolean` `LuaDouble.gt_b(LuaValue rhs)`
`boolean` `LuaInteger.gt_b(LuaValue rhs)`
`boolean` `LuaString.gt_b(LuaValue rhs)`
`boolean` `LuaValue.gt_b(LuaValue rhs)` Greater than: Perform numeric or string comparison with another value of unknown type, including metatag processing, and returning java boolean.
`LuaValue` `LuaDouble.gt(LuaValue rhs)`
`LuaValue` `LuaInteger.gt(LuaValue rhs)`
`LuaValue` `LuaString.gt(LuaValue rhs)`
`LuaValue` `LuaValue.gt(LuaValue rhs)` Greater than: Perform numeric or string comparison with another value of unknown type, including metatag processing, and returning `LuaValue`.
`boolean` `LuaDouble.gteq_b(LuaValue rhs)`
`boolean` `LuaInteger.gteq_b(LuaValue rhs)`
`boolean` `LuaString.gteq_b(LuaValue rhs)`
`boolean` `LuaValue.gteq_b(LuaValue rhs)` Greater than or equals: Perform numeric or string comparison with another value of unknown type, including metatag processing, and returning java boolean.
`LuaValue` `LuaDouble.gteq(LuaValue rhs)`
`LuaValue` `LuaInteger.gteq(LuaValue rhs)`
`LuaValue` `LuaString.gteq(LuaValue rhs)`
`LuaValue` `LuaValue.gteq(LuaValue rhs)` Greater than or equals: Perform numeric or string comparison with another value of unknown type, including metatag processing, and returning `LuaValue`.
`protected LuaValue` `LuaTable.hashget(LuaValue key)`
`void` `LuaTable.hashset(LuaValue key, LuaValue value)` Set a hashtable value
`static int` `LuaTable.hashSlot(LuaValue key, int hashMask)` Find the hashtable slot index to use.
`Varargs` `LuaTable.inext(LuaValue key)` Get the next element after a particular key in the contiguous array part of a table
`Varargs` `LuaValue.inext(LuaValue index)` Find the next integer-key,value pair if `this` is a table, return `NIL` if there are no more, or throw a `LuaError` if not a table.
`void` `LuaValue.initupvalue1(LuaValue env)` Hook for implementations such as LuaJC to load the environment of the main chunk into the first upvalue location.
`void` `LuaTable.insert(int pos, LuaValue value)` Insert an element at a position in a list-table
`Varargs` `LuaValue.invoke(LuaValue[] args)` Call `this` with variable arguments, including metatag processing, and retain all return values in a `Varargs`.
`Varargs` `LuaValue.invoke(LuaValue[] args, Varargs varargs)` Call `this` with variable arguments, including metatag processing, and retain all return values in a `Varargs`.
`Varargs` `LuaValue.invoke(LuaValue arg1, LuaValue arg2, Varargs varargs)` Call `this` with variable arguments, including metatag processing, and retain all return values in a `Varargs`.
`Varargs` `LuaValue.invoke(LuaValue arg, Varargs varargs)` Call `this` with variable arguments, including metatag processing, and retain all return values in a `Varargs`.
`Varargs` `LuaValue.invokemethod(LuaValue name)` Call named method on `this` with 0 arguments, including metatag processing, and retain all return values in a `Varargs`.
`Varargs` `LuaValue.invokemethod(LuaValue name, LuaValue[] args)` Call named method on `this` with variable arguments, including metatag processing, and retain all return values in a `Varargs`.
`Varargs` `LuaValue.invokemethod(LuaValue name, LuaValue[] args)` Call named method on `this` with variable arguments, including metatag processing, and retain all return values in a `Varargs`.
`Varargs` `LuaValue.invokemethod(LuaValue name, Varargs args)` Call named method on `this` with variable arguments, including metatag processing, and retain all return values in a `Varargs`.
`Varargs` `LuaValue.invokemethod(java.lang.String name, LuaValue[] args)` Call named method on `this` with 1 argument, including metatag processing, and retain all return values in a `Varargs`.
`protected static boolean` `LuaTable.isLargeKey(LuaValue key)`
`boolean` `WeakTable.WeakSlot.keyeq(LuaValue key)`
`static LuaTable` `LuaValue.listOf(LuaValue[] unnamedValues)` Construct a `LuaTable` initialized with supplied array values.
`static LuaTable` `LuaValue.listOf(LuaValue[] unnamedValues, Varargs lastarg)` Construct a `LuaTable` initialized with supplied array values.
`LuaValue` `Globals.load(java.io.InputStream is, java.lang.String chunkname, java.lang.String mode, LuaValue environment)` Load the content form an input stream as a binary chunk or text file.
`LuaValue` `LuaValue.load(LuaValue library)` Load a library instance by calling it with and empty string as the modname, and this Globals as the environment.
`LuaFunction` `Globals.Loader.load(Prototype prototype, java.lang.String chunkname, LuaValue env)` Convert the prototype into a LuaFunction with the supplied environment.
`boolean` `LuaDouble.lt_b(LuaValue rhs)`
`boolean` `LuaInteger.lt_b(LuaValue rhs)`
`boolean` `LuaString.lt_b(LuaValue rhs)`
`boolean` `LuaValue.lt_b(LuaValue rhs)` Less than: Perform numeric or string comparison with another value of unknown type, including metatag processing, and returning java boolean.
`LuaValue` `LuaDouble.lt(LuaValue rhs)`
`LuaValue` `LuaInteger.lt(LuaValue rhs)`
`LuaValue` `LuaString.lt(LuaValue rhs)`
`LuaValue` `LuaValue.lt(LuaValue rhs)` Less than: Perform numeric or string comparison with another value of unknown type, including metatag processing, and returning `LuaValue`.
`boolean` `LuaDouble.lteq_b(LuaValue rhs)`
`boolean` `LuaInteger.lteq_b(LuaValue rhs)`
`boolean` `LuaString.lteq_b(LuaValue rhs)`
`boolean` `LuaValue.lteq_b(LuaValue rhs)` Less than or equals: Perform numeric or string comparison with another value of unknown type, including metatag processing, and returning java boolean.
`LuaValue` `LuaDouble.lteq(LuaValue rhs)`
`LuaValue` `LuaInteger.lteq(LuaValue rhs)`
`LuaValue` `LuaString.lteq(LuaValue rhs)`
`LuaValue` `LuaValue.lteq(LuaValue rhs)` Less than or equals: Perform numeric or string comparison with another value of unknown type, including metatag processing, and returning `LuaValue`.
`protected static org.luaj.vm2.Metatable` `LuaValue.metatableOf(LuaValue mt)` Construct a Metatable instance from the given LuaValue
`LuaValue` `LuaValue.metatag(LuaValue tag)` Get particular metatag, or return `NIL` if it doesn't exist
`LuaValue` `LuaValue.method(LuaValue name)` Call named method on `this` with 0 arguments, including metatag processing, and return only the first return value.
`LuaValue` `LuaValue.method(LuaValue name, LuaValue arg)` Call named method on `this` with 1 argument, including metatag processing, and return only the first return value.
`LuaValue` `LuaValue.method(LuaValue name, LuaValue arg1, LuaValue arg2)` Call named method on `this` with 2 arguments, including metatag processing, and return only the first return value.
`LuaValue` `LuaValue.method(java.lang.String name, LuaValue arg)` Call named method on `this` with 1 argument, including metatag processing, and return only the first return value.
`LuaValue` `LuaValue.method(java.lang.String name, LuaValue arg1, LuaValue arg2)` Call named method on `this` with 2 arguments, including metatag processing, and return only the first return value.
`LuaValue` `LuaDouble.mod(LuaValue rhs)`
`LuaValue` `LuaInteger.mod(LuaValue rhs)`
`LuaValue` `LuaString.mod(LuaValue rhs)`
`LuaValue` `LuaValue.mod(LuaValue rhs)` Modulo: Perform numeric modulo operation with another value of unknown type, including metatag processing.
`LuaValue` `LuaDouble.mul(LuaValue rhs)`
`LuaValue` `LuaInteger.mul(LuaValue rhs)`
`LuaValue` `LuaString.mul(LuaValue rhs)`
`LuaValue` `LuaValue.mul(LuaValue rhs)` Multiply: Perform numeric multiply operation with another value of unknown type, including metatag processing.
`boolean` `LuaValue.neq_b(LuaValue val)` Notquals: Perform inequality comparison with another value including metatag processing using `EQ`.
`LuaValue` `LuaValue.neq(LuaValue val)` Notquals: Perform inequality comparison with another value including metatag processing using `EQ`.
`Varargs` `LuaTable.next(LuaValue key)` Get the next element after a particular key in the table
`Varargs` `LuaValue.next(LuaValue index)` Find the next key,value pair if `this` is a table, return `NIL` if there are no more, or throw a `LuaError` if not a table.
`LuaValue` `Varargs.optvalue(int i, LuaValue defval)` Return argument i as a LuaValue if it exists, or `defval`.
`LuaValue` `LuaNil.optvalue(LuaValue defval)`
`LuaValue` `LuaValue.optvalue(LuaValue defval)` Perform argument check that this is not nil or none.
`LuaValue` `LuaValue.or(LuaValue rhs)` Perform boolean `or` with another operand, based on lua rules for boolean evaluation.
`LuaValue` `LuaDouble.pow(LuaValue rhs)`
`LuaValue` `LuaInteger.pow(LuaValue rhs)`
`LuaValue` `LuaString.pow(LuaValue rhs)`
`LuaValue` `LuaValue.pow(LuaValue rhs)` Raise to power: Raise this value to a power including metatag processing.
`static void` `Print.printStack(LuaValue[] stack, int top, Varargs varargs)`
`static void` `Print.printState(LuaClosure cl, int pc, LuaValue[] stack, int top, Varargs varargs)` Print the state of a `LuaClosure` that is being executed
`boolean` `LuaDouble.raweq(LuaValue val)`
`boolean` `LuaInteger.raweq(LuaValue val)`
`boolean` `LuaString.raweq(LuaValue val)`
`boolean` `LuaUserdata.raweq(LuaValue val)`
`boolean` `LuaValue.raweq(LuaValue val)` Equals: Perform direct equality comparison with another value without metatag processing.
`LuaValue` `LuaTable.rawget(LuaValue key)`
`LuaValue` `LuaValue.rawget(LuaValue key)` Get a value in a table without metatag processing.
`void` `LuaTable.rawset(int key, LuaValue value)`
`void` `LuaValue.rawset(int key, LuaValue value)` Set a value in a table without metatag processing.
`void` `LuaTable.rawset(LuaValue key, LuaValue value)` caller must ensure key is not nil
`void` `LuaValue.rawset(LuaValue key, LuaValue value)` Set a value in a table without metatag processing.
`void` `LuaValue.rawset(java.lang.String key, LuaValue value)` Set a value in a table without metatag processing.
`void` `LuaTable.set(int key, LuaValue value)`
`void` `LuaValue.set(int key, LuaValue value)` Set a value in a table without metatag processing using `NEWINDEX`.
`org.luaj.vm2.LuaTable.Slot` `WeakTable.WeakSlot.set(org.luaj.vm2.LuaTable.StrongSlot target, LuaValue value)`
`abstract org.luaj.vm2.LuaTable.Slot` `WeakTable.WeakSlot.set(LuaValue value)`
`void` `LuaTable.set(LuaValue key, LuaValue value)` caller must ensure key is not nil
`void` `LuaUserdata.set(LuaValue key, LuaValue value)`
`void` `LuaValue.set(LuaValue key, LuaValue value)` Set a value in a table without metatag processing using `NEWINDEX`.
`void` `LuaValue.set(java.lang.String key, LuaValue value)` Set a value in a table without metatag processing using `NEWINDEX`.
`LuaValue` `LuaTable.setmetatable(LuaValue metatable)`
`LuaValue` `LuaUserdata.setmetatable(LuaValue metatable)`
`LuaValue` `LuaValue.setmetatable(LuaValue metatable)` Set the metatable for this `LuaValue`
`protected static boolean` `LuaValue.settable(LuaValue t, LuaValue key, LuaValue value)` Perform field assignment including metatag processing.
`protected void` `LuaClosure.setUpvalue(int i, LuaValue v)`
`Buffer` `Buffer.setvalue(LuaValue value)` Set buffer contents as a `LuaValue`
`void` `UpValue.setValue(LuaValue value)` Set the value of the upvalue
`void` `LuaTable.sort(LuaValue comparator)` Sort the table using a comparator.
`int` `LuaString.strcmp(LuaValue lhs)`
`int` `LuaValue.strcmp(LuaValue rhs)` Perform string comparison with another value of any type using string comparison based on byte values.
`LuaValue` `LuaDouble.sub(LuaValue rhs)`
`LuaValue` `LuaInteger.sub(LuaValue rhs)`
`LuaValue` `LuaString.sub(LuaValue rhs)`
`LuaValue` `LuaValue.sub(LuaValue rhs)` Subtract: Perform numeric subtract operation with another value of unknown type, including metatag processing.
`static LuaTable` `LuaValue.tableOf(LuaValue[] namedValues)` Construct a `LuaTable` initialized with supplied named values.
`static LuaTable` `LuaValue.tableOf(LuaValue[] namedValues, LuaValue[] unnamedValues)` Construct a `LuaTable` initialized with supplied named values and sequential elements.
`static LuaTable` `LuaValue.tableOf(LuaValue[] namedValues, LuaValue[] unnamedValues)` Construct a `LuaTable` initialized with supplied named values and sequential elements.
`static LuaTable` `LuaValue.tableOf(LuaValue[] namedValues, LuaValue[] unnamedValues, Varargs lastarg)` Construct a `LuaTable` initialized with supplied named values and sequential elements in an array part and as varargs.
`static LuaTable` `LuaValue.tableOf(LuaValue[] namedValues, LuaValue[] unnamedValues, Varargs lastarg)` Construct a `LuaTable` initialized with supplied named values and sequential elements in an array part and as varargs.
`static Varargs` `LuaValue.tailcallOf(LuaValue func, Varargs args)` Construct a `TailcallVarargs` around a function and arguments.
`boolean` `LuaValue.testfor_b(LuaValue limit, LuaValue step)` Perform end-condition test in for-loop processing.
`static LuaUserdata` `LuaValue.userdataOf(java.lang.Object o, LuaValue metatable)` Construct a LuaUserdata for an object with a user supplied metatable.
`static Varargs` `LuaValue.varargsOf(LuaValue[] v)` Construct a `Varargs` around an array of `LuaValue`s.
`static Varargs` `LuaValue.varargsOf(LuaValue[] v, int offset, int length)` Construct a `Varargs` around an array of `LuaValue`s.
`static Varargs` `LuaValue.varargsOf(LuaValue[] v, int offset, int length, Varargs more)` Construct a `Varargs` around an array of `LuaValue`s.
`static Varargs` `LuaValue.varargsOf(LuaValue[] v, Varargs r)` Construct a `Varargs` around an array of `LuaValue`s.
`static Varargs` `LuaValue.varargsOf(LuaValue v1, LuaValue v2, Varargs v3)` Construct a `Varargs` around a set of 3 or more `LuaValue`s.
`static Varargs` `LuaValue.varargsOf(LuaValue v, Varargs r)` Construct a `Varargs` around a set of 2 or more `LuaValue`s.
`protected static LuaValue` `WeakTable.weaken(LuaValue value)` Self-sent message to convert a value to its weak counterpart
`LuaValue` `LuaTable.wrap(LuaValue value)`
`LuaValue` `WeakTable.wrap(LuaValue value)`

Constructors in org.luaj.vm2 with parameters of type LuaValue
`Buffer(LuaValue value)` Create buffer with specified initial value
`LuaClosure(Prototype p, LuaValue env)` Create a closure around a Prototype with a specific environment.
`LuaError(LuaValue message_object)` Construct a LuaError with a LuaValue as the message object, and level to draw line number information from.
`LuaTable(LuaValue[] named, LuaValue[] unnamed, Varargs lastarg)` Construct table with named and unnamed parts.
`LuaTable(LuaValue[] named, LuaValue[] unnamed, Varargs lastarg)` Construct table with named and unnamed parts.
`LuaThread(Globals globals, LuaValue func)` Create a LuaThread around a function and environment
`LuaUserdata(java.lang.Object obj, LuaValue metatable)`
`TailcallVarargs(LuaValue object, LuaValue methodname, Varargs args)`
`TailcallVarargs(LuaValue f, Varargs args)`
`UpValue(LuaValue[] stack, int index)` Create an upvalue relative to a stack
`WeakTable(boolean weakkeys, boolean weakvalues, LuaValue backing)` Construct a table with weak keys, weak values, or both

Uses of LuaValue in org.luaj.vm2.compiler

Methods in org.luaj.vm2.compiler that return LuaValue
`LuaValue` `LuaC.load(java.io.InputStream stream, java.lang.String chunkname, Globals globals)` Deprecated. Use Globals.load(InputString, String, String) instead, or LuaC.compile(InputStream, String) and construct LuaClosure directly.

Methods in org.luaj.vm2.compiler with parameters of type LuaValue
`LuaFunction` `LuaC.load(Prototype prototype, java.lang.String chunkname, LuaValue env)`

Uses of LuaValue in org.luaj.vm2.lib

Subclasses of LuaValue in org.luaj.vm2.lib
`class` `BaseLib` Subclass of `LibFunction` which implements the lua basic library functions.
`class` `Bit32Lib` Subclass of LibFunction that implements the Lua standard `bit32` library.
`class` `CoroutineLib` Subclass of `LibFunction` which implements the lua standard `coroutine` library.
`class` `DebugLib` Subclass of `LibFunction` which implements the lua standard `debug` library.
`class` `IoLib` Abstract base class extending `LibFunction` which implements the core of the lua standard `io` library.
`protected class` `IoLib.File`
`class` `LibFunction` Subclass of `LuaFunction` common to Java functions exposed to lua.
`class` `MathLib` Subclass of `LibFunction` which implements the lua standard `math` library.
`protected static class` `MathLib.BinaryOp`
`protected static class` `MathLib.UnaryOp`
`class` `OneArgFunction` Abstract base class for Java function implementations that take one argument and return one value.
`class` `OsLib` Subclass of `LibFunction` which implements the standard lua `os` library.
`class` `PackageLib` Subclass of `LibFunction` which implements the lua standard package and module library functions.
`class` `PackageLib.java_searcher`
`static class` `PackageLib.loadlib`
`class` `PackageLib.lua_searcher`
`class` `PackageLib.preload_searcher`
`class` `PackageLib.require` require (modname) Loads the given module.
`class` `PackageLib.searchpath`
`class` `StringLib` Subclass of `LibFunction` which implements the lua standard `string` library.
`class` `TableLib` Subclass of `LibFunction` which implements the lua standard `table` library.
`class` `ThreeArgFunction` Abstract base class for Java function implementations that take two arguments and return one value.
`class` `TwoArgFunction` Abstract base class for Java function implementations that take two arguments and return one value.
`class` `VarArgFunction` Abstract base class for Java function implementations that takes varaiable arguments and returns multiple return values.
`class` `ZeroArgFunction` Abstract base class for Java function implementations that take no arguments and return one value.

Methods in org.luaj.vm2.lib that return LuaValue
`LuaValue` `LibFunction.call()`
`LuaValue` `OneArgFunction.call()`
`LuaValue` `ThreeArgFunction.call()`
`LuaValue` `TwoArgFunction.call()`
`LuaValue` `VarArgFunction.call()`
`abstract LuaValue` `ZeroArgFunction.call()`
`LuaValue` `LibFunction.call(LuaValue a)`
`LuaValue` `MathLib.UnaryOp.call(LuaValue arg)`
`abstract LuaValue` `OneArgFunction.call(LuaValue arg)`
`LuaValue` `PackageLib.require.call(LuaValue arg)`
`LuaValue` `ThreeArgFunction.call(LuaValue arg)`
`LuaValue` `TwoArgFunction.call(LuaValue arg)`
`LuaValue` `VarArgFunction.call(LuaValue arg)`
`LuaValue` `ZeroArgFunction.call(LuaValue arg)`
`LuaValue` `BaseLib.call(LuaValue modname, LuaValue env)` Perform one-time initialization on the library by adding base functions to the supplied environment, and returning it as the return value.
`LuaValue` `Bit32Lib.call(LuaValue modname, LuaValue env)` Perform one-time initialization on the library by creating a table containing the library functions, adding that table to the supplied environment, adding the table to package.loaded, and returning table as the return value.
`LuaValue` `CoroutineLib.call(LuaValue modname, LuaValue env)` Perform one-time initialization on the library by creating a table containing the library functions, adding that table to the supplied environment, adding the table to package.loaded, and returning table as the return value.
`LuaValue` `DebugLib.call(LuaValue modname, LuaValue env)` Perform one-time initialization on the library by creating a table containing the library functions, adding that table to the supplied environment, adding the table to package.loaded, and returning table as the return value.
`LuaValue` `IoLib.call(LuaValue modname, LuaValue env)`
`LuaValue` `LibFunction.call(LuaValue a, LuaValue b)`
`LuaValue` `MathLib.call(LuaValue modname, LuaValue env)` Perform one-time initialization on the library by creating a table containing the library functions, adding that table to the supplied environment, adding the table to package.loaded, and returning table as the return value.
`LuaValue` `MathLib.BinaryOp.call(LuaValue x, LuaValue y)`
`LuaValue` `OneArgFunction.call(LuaValue arg1, LuaValue arg2)`
`LuaValue` `OsLib.call(LuaValue modname, LuaValue env)` Perform one-time initialization on the library by creating a table containing the library functions, adding that table to the supplied environment, adding the table to package.loaded, and returning table as the return value.
`LuaValue` `PackageLib.call(LuaValue modname, LuaValue env)` Perform one-time initialization on the library by adding package functions to the supplied environment, and returning it as the return value.
`LuaValue` `StringLib.call(LuaValue modname, LuaValue env)` Perform one-time initialization on the library by creating a table containing the library functions, adding that table to the supplied environment, adding the table to package.loaded, and returning table as the return value.
`LuaValue` `TableLib.call(LuaValue modname, LuaValue env)` Perform one-time initialization on the library by creating a table containing the library functions, adding that table to the supplied environment, adding the table to package.loaded, and returning table as the return value.
`LuaValue` `ThreeArgFunction.call(LuaValue arg1, LuaValue arg2)`
`abstract LuaValue` `TwoArgFunction.call(LuaValue arg1, LuaValue arg2)`
`LuaValue` `VarArgFunction.call(LuaValue arg1, LuaValue arg2)`
`LuaValue` `ZeroArgFunction.call(LuaValue arg1, LuaValue arg2)`
`LuaValue` `LibFunction.call(LuaValue a, LuaValue b, LuaValue c)`
`LuaValue` `OneArgFunction.call(LuaValue arg1, LuaValue arg2, LuaValue arg3)`
`abstract LuaValue` `ThreeArgFunction.call(LuaValue arg1, LuaValue arg2, LuaValue arg3)`
`LuaValue` `TwoArgFunction.call(LuaValue arg1, LuaValue arg2, LuaValue arg3)`
`LuaValue` `VarArgFunction.call(LuaValue arg1, LuaValue arg2, LuaValue arg3)`
`LuaValue` `ZeroArgFunction.call(LuaValue arg1, LuaValue arg2, LuaValue arg3)`
`LuaValue` `LibFunction.call(LuaValue a, LuaValue b, LuaValue c, LuaValue d)`
`static LuaValue` `MathLib.dpow(double a, double b)` compute power using installed math library, or default if there is no math library installed
`static LuaValue` `IoLib.freadall(IoLib.File f)`
`static LuaValue` `IoLib.freadbytes(IoLib.File f, int count)`
`static LuaValue` `IoLib.freadline(IoLib.File f)`
`static LuaValue` `IoLib.freadnumber(IoLib.File f)`
`static LuaValue` `IoLib.freaduntil(IoLib.File f, boolean lineonly)`
`LuaValue` `IoLib.File.get(LuaValue key)`
`protected static LuaValue[]` `LibFunction.newupe()` Java code generation utility to allocate storage for upvalue, leave it empty
`protected static LuaValue[]` `LibFunction.newupl(LuaValue v)` Java code generation utility to allocate storage for upvalue, initialize with value
`protected static LuaValue[]` `LibFunction.newupn()` Java code generation utility to allocate storage for upvalue, initialize with nil

Methods in org.luaj.vm2.lib with parameters of type LuaValue
`Varargs` `IoLib._file_close(LuaValue file)`
`Varargs` `IoLib._file_flush(LuaValue file)`
`Varargs` `IoLib._file_lines(LuaValue file)`
`Varargs` `IoLib._file_read(LuaValue file, Varargs subargs)`
`Varargs` `IoLib._file_seek(LuaValue file, java.lang.String whence, int offset)`
`Varargs` `IoLib._file_setvbuf(LuaValue file, java.lang.String mode, int size)`
`Varargs` `IoLib._file_write(LuaValue file, Varargs subargs)`
`Varargs` `IoLib._io_close(LuaValue file)`
`Varargs` `IoLib._io_index(LuaValue v)`
`Varargs` `IoLib._io_input(LuaValue file)`
`Varargs` `IoLib._io_output(LuaValue filename)`
`Varargs` `IoLib._io_type(LuaValue obj)`
`Varargs` `IoLib._lines_iter(LuaValue file)`
`protected void` `LibFunction.bind(LuaValue env, java.lang.Class factory, java.lang.String[] names)` Bind a set of library functions.
`protected void` `LibFunction.bind(LuaValue env, java.lang.Class factory, java.lang.String[] names, int firstopcode)` Bind a set of library functions, with an offset
`LuaValue` `LibFunction.call(LuaValue a)`
`LuaValue` `MathLib.UnaryOp.call(LuaValue arg)`
`abstract LuaValue` `OneArgFunction.call(LuaValue arg)`
`LuaValue` `PackageLib.require.call(LuaValue arg)`
`LuaValue` `ThreeArgFunction.call(LuaValue arg)`
`LuaValue` `TwoArgFunction.call(LuaValue arg)`
`LuaValue` `VarArgFunction.call(LuaValue arg)`
`LuaValue` `ZeroArgFunction.call(LuaValue arg)`
`LuaValue` `BaseLib.call(LuaValue modname, LuaValue env)` Perform one-time initialization on the library by adding base functions to the supplied environment, and returning it as the return value.
`LuaValue` `Bit32Lib.call(LuaValue modname, LuaValue env)` Perform one-time initialization on the library by creating a table containing the library functions, adding that table to the supplied environment, adding the table to package.loaded, and returning table as the return value.
`LuaValue` `CoroutineLib.call(LuaValue modname, LuaValue env)` Perform one-time initialization on the library by creating a table containing the library functions, adding that table to the supplied environment, adding the table to package.loaded, and returning table as the return value.
`LuaValue` `DebugLib.call(LuaValue modname, LuaValue env)` Perform one-time initialization on the library by creating a table containing the library functions, adding that table to the supplied environment, adding the table to package.loaded, and returning table as the return value.
`LuaValue` `IoLib.call(LuaValue modname, LuaValue env)`
`LuaValue` `LibFunction.call(LuaValue a, LuaValue b)`
`LuaValue` `MathLib.call(LuaValue modname, LuaValue env)` Perform one-time initialization on the library by creating a table containing the library functions, adding that table to the supplied environment, adding the table to package.loaded, and returning table as the return value.
`LuaValue` `MathLib.BinaryOp.call(LuaValue x, LuaValue y)`
`LuaValue` `OneArgFunction.call(LuaValue arg1, LuaValue arg2)`
`LuaValue` `OsLib.call(LuaValue modname, LuaValue env)` Perform one-time initialization on the library by creating a table containing the library functions, adding that table to the supplied environment, adding the table to package.loaded, and returning table as the return value.
`LuaValue` `PackageLib.call(LuaValue modname, LuaValue env)` Perform one-time initialization on the library by adding package functions to the supplied environment, and returning it as the return value.
`LuaValue` `StringLib.call(LuaValue modname, LuaValue env)` Perform one-time initialization on the library by creating a table containing the library functions, adding that table to the supplied environment, adding the table to package.loaded, and returning table as the return value.
`LuaValue` `TableLib.call(LuaValue modname, LuaValue env)` Perform one-time initialization on the library by creating a table containing the library functions, adding that table to the supplied environment, adding the table to package.loaded, and returning table as the return value.
`LuaValue` `ThreeArgFunction.call(LuaValue arg1, LuaValue arg2)`
`abstract LuaValue` `TwoArgFunction.call(LuaValue arg1, LuaValue arg2)`
`LuaValue` `VarArgFunction.call(LuaValue arg1, LuaValue arg2)`
`LuaValue` `ZeroArgFunction.call(LuaValue arg1, LuaValue arg2)`
`LuaValue` `LibFunction.call(LuaValue a, LuaValue b, LuaValue c)`
`LuaValue` `OneArgFunction.call(LuaValue arg1, LuaValue arg2, LuaValue arg3)`
`abstract LuaValue` `ThreeArgFunction.call(LuaValue arg1, LuaValue arg2, LuaValue arg3)`
`LuaValue` `TwoArgFunction.call(LuaValue arg1, LuaValue arg2, LuaValue arg3)`
`LuaValue` `VarArgFunction.call(LuaValue arg1, LuaValue arg2, LuaValue arg3)`
`LuaValue` `ZeroArgFunction.call(LuaValue arg1, LuaValue arg2, LuaValue arg3)`
`LuaValue` `LibFunction.call(LuaValue a, LuaValue b, LuaValue c, LuaValue d)`
`LuaValue` `IoLib.File.get(LuaValue key)`
`Varargs` `BaseLib.loadFile(java.lang.String filename, java.lang.String mode, LuaValue env)` Load from a named file, returning the chunk or nil,error of can't load
`Varargs` `BaseLib.loadStream(java.io.InputStream is, java.lang.String chunkname, java.lang.String mode, LuaValue env)`
`protected static LuaValue[]` `LibFunction.newupl(LuaValue v)` Java code generation utility to allocate storage for upvalue, initialize with value
`void` `DebugLib.onCall(LuaClosure c, Varargs varargs, LuaValue[] stack)`

Uses of LuaValue in org.luaj.vm2.lib.jme

Subclasses of LuaValue in org.luaj.vm2.lib.jme
`class` `JmeIoLib` Subclass of `IoLib` and therefore `LibFunction` which implements the lua standard `io` library for the JSE platform.

Uses of LuaValue in org.luaj.vm2.lib.jse

Subclasses of LuaValue in org.luaj.vm2.lib.jse
`class` `JseBaseLib` Subclass of `BaseLib` and `LibFunction` which implements the lua basic library functions and provides a directory based `ResourceFinder` as the `Globals.finder`.
`class` `JseIoLib` Subclass of `IoLib` and therefore `LibFunction` which implements the lua standard `io` library for the JSE platform.
`class` `JseMathLib` Subclass of `LibFunction` which implements the lua standard `math` library.
`class` `JseOsLib` Subclass of `LibFunction` which implements the standard lua `os` library.
`class` `LuajavaLib` Subclass of `LibFunction` which implements the features of the luajava package.

Methods in org.luaj.vm2.lib.jse that return LuaValue
`LuaValue` `JseBaseLib.call(LuaValue modname, LuaValue env)` Perform one-time initialization on the library by creating a table containing the library functions, adding that table to the supplied environment, adding the table to package.loaded, and returning table as the return value.
`LuaValue` `JseMathLib.call(LuaValue modname, LuaValue env)` Perform one-time initialization on the library by creating a table containing the library functions, adding that table to the supplied environment, adding the table to package.loaded, and returning table as the return value.
`static LuaValue` `CoerceJavaToLua.coerce(java.lang.Object o)` Coerse a Java object to a corresponding lua value.

Methods in org.luaj.vm2.lib.jse with parameters of type LuaValue
`LuaValue` `JseBaseLib.call(LuaValue modname, LuaValue env)` Perform one-time initialization on the library by creating a table containing the library functions, adding that table to the supplied environment, adding the table to package.loaded, and returning table as the return value.
`LuaValue` `JseMathLib.call(LuaValue modname, LuaValue env)` Perform one-time initialization on the library by creating a table containing the library functions, adding that table to the supplied environment, adding the table to package.loaded, and returning table as the return value.
`static java.lang.Object` `CoerceLuaToJava.coerce(LuaValue value, java.lang.Class clazz)` Coerce a LuaValue value to a specified java class
`static void` `JsePlatform.luaMain(LuaValue mainChunk, java.lang.String[] args)` Simple wrapper for invoking a lua function with command line arguments.

Uses of LuaValue in org.luaj.vm2.luajc

Methods in org.luaj.vm2.luajc with parameters of type LuaValue
`LuaFunction` `LuaJC.load(Prototype p, java.lang.String name, LuaValue globals)`

Copyright © 2007-2015 Luaj.org. All Rights Reserved.