LuaValue (encryption-tools 1.0.0 API)

java.lang.Object
- org.luaj.vm2.Varargs
- - org.luaj.vm2.LuaValue

直接已知子类:

IoLib.File, LuaBoolean, LuaFunction, LuaNil, LuaNumber, LuaString, LuaTable, LuaThread, LuaUserdata, LuaUtf8String
```
public abstract class LuaValue
extends Varargs
```
Base class for all concrete lua type values.
Establishes base implementations for all the operations on lua types. This allows Java clients to deal essentially with one type for all Java values, namely LuaValue.
Constructors are provided as static methods for common Java types, such as valueOf(int) or valueOf(String) to allow for instance pooling.
Constants are defined for the lua values NIL, TRUE, and FALSE. A constant NONE is defined which is a Varargs list having no values.
Operations are performed on values directly via their Java methods. For example, the following code divides two numbers:
```
 
 LuaValue a = LuaValue.valueOf( 5 );
 LuaValue b = LuaValue.valueOf( 4 );
 LuaValue c = a.div(b);
  
```
Note that in this example, c will be a LuaDouble, but would be a LuaInteger if the value of a were changed to 8, say. In general the value of c in practice will vary depending on both the types and values of a and b as well as any metatable/metatag processing that occurs.
Field access and function calls are similar, with common overloads to simplify Java usage:
```
 
 LuaValue globals = JsePlatform.standardGlobals();
 LuaValue sqrt = globals.get("math").get("sqrt");
 LuaValue print = globals.get("print");
 LuaValue d = sqrt.call( a );
 print.call( LuaValue.valueOf("sqrt(5):"), a );
  
```
To supply variable arguments or get multiple return values, use invoke(Varargs) or invokemethod(LuaValue, Varargs) methods:
```
 
 LuaValue modf = globals.get("math").get("modf");
 Varargs r = modf.invoke( d );
 print.call( r.arg(1), r.arg(2) );
  
```
To load and run a script, LoadState is used:
```
 
 LoadState.load( new FileInputStream("main.lua"), "main.lua", globals ).call();
  
```
although require could also be used:
```
 
 globals.get("require").call(LuaValue.valueOf("main"));
  
```
For this to work the file must be in the current directory, or in the class path, dependening on the platform.
In general a LuaError may be thrown on any operation when the types supplied to any operation are illegal from a lua perspective. Examples could be attempting to concatenate a NIL value, or attempting arithmetic on values that are not number.
There are several methods for preinitializing tables, such as:
- listOf(LuaValue[]) for unnamed elements
- tableOf(LuaValue[]) for named elements
- tableOf(LuaValue[], LuaValue[], Varargs) for mixtures
Predefined constants exist for the standard lua type constants TNIL, TBOOLEAN, TLIGHTUSERDATA, TNUMBER, TSTRING, TTABLE, TFUNCTION, TUSERDATA, TTHREAD, and extended lua type constants TINT, TNONE, TVALUE
Predefined constants exist for all strings used as metatags: INDEX, NEWINDEX, CALL, MODE, METATABLE, ADD, SUB, DIV, MUL, POW, MOD, UNM, LEN, EQ, LT, LE, TOSTRING, and CONCAT.
另请参阅:

JsePlatform, LoadState, Varargs

字段概要

字段
限定符和类型	字段和说明
`static LuaString`	`ADD` LuaString constant with value "__add" for use as metatag
`static LuaString`	`BAND`
`static LuaString`	`BNOT`
`static LuaString`	`BOR`
`static LuaString`	`BXOR`
`static LuaString`	`CALL` LuaString constant with value "__call" for use as metatag
`static LuaString`	`CONCAT` LuaString constant with value "__concat" for use as metatag
`static LuaString`	`DIV` LuaString constant with value "__div" for use as metatag
`static LuaString`	`EMPTYSTRING` LuaString constant with value ""
`static LuaString`	`ENV` The variable name of the environment.
`static LuaString`	`EQ` LuaString constant with value "__eq" for use as metatag
`static LuaBoolean`	`FALSE` LuaBoolean constant corresponding to lua `false`
`static LuaString`	`IDIV`
`static LuaString`	`INDEX` LuaString constant with value "__index" for use as metatag
`static LuaString`	`LE` LuaString constant with value "__le" for use as metatag
`static LuaString`	`LEN` LuaString constant with value "__len" for use as metatag
`static LuaString`	`LT` LuaString constant with value "__lt" for use as metatag
`static LuaString`	`METATABLE` LuaString constant with value "__metatable" for use as metatag
`static LuaNumber`	`MINUSONE` LuaValue number constant equal to -1
`static LuaString`	`MOD` LuaString constant with value "__mod" for use as metatag
`static LuaString`	`MODE` LuaString constant with value "__mode" for use as metatag
`static LuaString`	`MUL` LuaString constant with value "__mul" for use as metatag
`static LuaString`	`NEWINDEX` LuaString constant with value "__newindex" for use as metatag
`static LuaValue`	`NIL` LuaValue constant corresponding to lua `#NIL`
`static LuaValue[]`	`NILS` Array of `NIL` values to optimize filling stacks using System.arraycopy().
`static LuaValue`	`NONE` LuaValue constant corresponding to a `Varargs` list of no values
`static LuaValue[]`	`NOVALS` LuaValue array constant with no values
`static LuaNumber`	`ONE` LuaValue number constant equal to 1
`static LuaString`	`POW` LuaString constant with value "__pow" for use as metatag
`static LuaString`	`SHL`
`static LuaString`	`SHR`
`static LuaString`	`SUB` LuaString constant with value "__sub" for use as metatag
`static int`	`TBOOLEAN` Type enumeration constant for lua booleans
`static int`	`TFUNCTION` Type enumeration constant for lua functions
`static int`	`TINT` Type enumeration constant for lua numbers that are ints, for compatibility with lua 5.1 number patch only
`static int`	`TLIGHTUSERDATA` Type enumeration constant for lua light userdata, for compatibility with C-based lua only
`static int`	`TNIL` Type enumeration constant for lua nil
`static int`	`TNONE` Type enumeration constant for lua values that have no type, for example weak table entries
`static int`	`TNUMBER` Type enumeration constant for lua numbers
`static LuaString`	`TOSTRING` LuaString constant with value "__tostring" for use as metatag
`static LuaBoolean`	`TRUE` LuaBoolean constant corresponding to lua `true`
`static int`	`TSTRING` Type enumeration constant for lua strings
`static int`	`TTABLE` Type enumeration constant for lua tables
`static int`	`TTHREAD` Type enumeration constant for lua threads
`static int`	`TUSERDATA` Type enumeration constant for lua userdatas
`static int`	`TVALUE` Type enumeration constant for unknown values, for compatibility with C-based lua only
`static String[]`	`TYPE_NAMES` String array constant containing names of each of the lua value types
`static LuaString`	`UNM` LuaString constant with value "__unm" for use as metatag
`LuaValue`	`uservalue`
`static LuaNumber`	`ZERO` LuaValue number constant equal to 0

构造器概要

构造器
构造器和说明

LuaValue()

构造器
构造器和说明
`LuaValue()`

方法概要

所有方法静态方法实例方法抽象方法具体方法
限定符和类型	方法和说明
`LuaValue`	`add(double rhs)` Add: Perform numeric add operation with another value of double type with metatag processing `this` must derive from `LuaNumber` or derive from `LuaString` and be convertible to a number
`LuaValue`	`add(long rhs)` Add: Perform numeric add operation with another value of int type with metatag processing `this` must derive from `LuaNumber` or derive from `LuaString` and be convertible to a number
`LuaValue`	`add(LuaValue rhs)` Add: Perform numeric add operation with another value including metatag processing.
`LuaValue`	`and(LuaValue rhs)` Perform boolean `and` with another operand, based on lua rules for boolean evaluation.
`LuaValue`	`arg(int index)` Get the n-th argument value (1-based).
`LuaValue`	`arg1()` Get the first argument in the list.
`static LuaValue`	`argerror(int iarg, String msg)` Throw a `LuaError` indicating an invalid argument was supplied to a function
`protected LuaValue`	`argerror(String expected)` Throw a `LuaError` indicating an invalid argument was supplied to a function
`protected LuaValue`	`aritherror()` Throw a `LuaError` based on an arithmetic error such as add, or pow, typically due to an invalid operand type
`protected LuaValue`	`aritherror(String fun)` Throw a `LuaError` based on an arithmetic error such as add, or pow, typically due to an invalid operand type
`protected LuaValue`	`arithmt(LuaValue tag, LuaValue op2)` Perform metatag processing for arithmetic operations.
`protected LuaValue`	`arithmtwith(LuaValue tag, double op1)` Perform metatag processing for arithmetic operations when the left-hand-side is a number.
`static void`	`assert_(boolean b, String msg)` Assert a condition is true, or throw a `LuaError` if not Returns no value when b is true, throws `error(String)` with `msg` as argument and does not return if b is false.
`LuaValue`	`band(long rhs)`
`LuaValue`	`band(LuaValue rhs)`
`LuaValue`	`bnot()`
`LuaValue`	`bor(long rhs)`
`LuaValue`	`bor(LuaValue rhs)`
`Buffer`	`buffer()` Convert the value to a `Buffer` for more efficient concatenation of multiple strings.
`LuaValue`	`bxor(long rhs)`
`LuaValue`	`bxor(LuaValue rhs)`
`LuaValue`	`call()` Call `this` with 0 arguments, including metatag processing, and return only the first return value.
`LuaValue`	`call(LuaValue arg)` Call `this` with 1 argument, including metatag processing, and return only the first return value.
`LuaValue`	`call(LuaValue arg1, LuaValue arg2)` Call `this` with 2 arguments, including metatag processing, and return only the first return value.
`LuaValue`	`call(LuaValue arg1, LuaValue arg2, LuaValue arg3)` Call `this` with 3 arguments, including metatag processing, and return only the first return value.
`LuaValue`	`call(String arg)` Convenience function which calls a luavalue with a single, string argument.
`protected LuaValue`	`callmt()` Get the metatag value for the `CALL` metatag, if it exists.
`boolean`	`checkboolean()` Check that the value is a `LuaBoolean`, or throw `LuaError` if not
`LuaClosure`	`checkclosure()` Check that the value is a `LuaClosure` , or throw `LuaError` if not `LuaClosure` is a subclass of `LuaFunction` that interprets lua bytecode.
`double`	`checkdouble()` Check that the value is numeric and return the value as a double, or throw `LuaError` if not numeric Values that are `LuaNumber` and values that are `LuaString` that can be converted to a number will be converted to double.
`LuaFunction`	`checkfunction()` Check that the value is a function , or throw `LuaError` if not A `LuaFunction` may either be a Java function that implements functionality directly in Java, or a `LuaClosure` which is a `LuaFunction` that executes lua bytecode.
`Globals`	`checkglobals()` Check that the value is a Globals instance, or throw `LuaError` if not `Globals` are a special `LuaTable` that establish the default global environment.
`int`	`checkint()` Check that the value is numeric, and convert and cast value to int, or throw `LuaError` if not numeric Values that are `LuaNumber` will be cast to int and may lose precision.
`LuaInteger`	`checkinteger()` Check that the value is numeric, and convert and cast value to int, or throw `LuaError` if not numeric Values that are `LuaNumber` will be cast to int and may lose precision.
`String`	`checkjstring()` Convert this value to a Java String.
`long`	`checklong()` Check that the value is numeric, and convert and cast value to long, or throw `LuaError` if not numeric Values that are `LuaNumber` will be cast to long and may lose precision.
`protected LuaValue`	`checkmetatag(LuaValue tag, String reason)` Get particular metatag, or throw `LuaError` if it doesn't exist
`LuaValue`	`checknotnil()` Check that this is not the value `NIL`, or throw `LuaError` if it is
`LuaNumber`	`checknumber()` Check that the value is numeric, and return as a LuaNumber if so, or throw `LuaError` Values that are `LuaString` that can be converted to a number will be converted and returned.
`LuaNumber`	`checknumber(String msg)` Check that the value is numeric, and return as a LuaNumber if so, or throw `LuaError` Values that are `LuaString` that can be converted to a number will be converted and returned.
`LuaString`	`checkstring()` Check that this is a lua string, or throw `LuaError` if it is not.
`LuaTable`	`checktable()` Check that this is a `LuaTable`, or throw `LuaError` if it is not
`LuaThread`	`checkthread()` Check that this is a `LuaThread`, or throw `LuaError` if it is not
`Object`	`checkuserdata()` Check that this is a `LuaUserdata`, or throw `LuaError` if it is not
`Object`	`checkuserdata(Class c)` Check that this is a `LuaUserdata`, or throw `LuaError` if it is not
`protected 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`	`compareerror(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`	`comparemt(LuaValue tag, LuaValue op1)` Perform metatag processing for comparison operations.
`Buffer`	`concat(Buffer rhs)` Concatenate a `Buffer` onto this value and return the result using rules of lua string concatenation including metatag processing.
`LuaValue`	`concat(LuaValue rhs)` Concatenate another value onto this value and return the result using rules of lua string concatenation including metatag processing.
`LuaValue`	`concatmt(LuaValue rhs)` Perform metatag processing for concatenation operations.
`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`	`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`	`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.
`LuaValue`	`div(double rhs)` Divide: Perform numeric divide operation by another value of double type without metatag processing `this` must derive from `LuaNumber` or derive from `LuaString` and be convertible to a number For metatag processing `div(LuaValue)` must be used
`LuaValue`	`div(long rhs)` Divide: Perform numeric divide operation by another value of int type without metatag processing `this` must derive from `LuaNumber` or derive from `LuaString` and be convertible to a number For metatag processing `div(LuaValue)` must be used
`LuaValue`	`div(LuaValue rhs)` Divide: Perform numeric divide operation by another value of unknown type, including metatag processing.
`LuaValue`	`divInto(double lhs)` Reverse-divide: Perform numeric divide operation into another value with metatag processing `this` must derive from `LuaNumber` or derive from `LuaString` and be convertible to a number
`boolean`	`eq_b(LuaValue val)` Equals: Perform equality comparison with another value including metatag processing using `EQ`, and return java boolean
`LuaValue`	`eq(LuaValue val)` Equals: Perform equality comparison with another value including metatag processing using `EQ`.
`static boolean`	`eqmtcall(LuaValue lhs, LuaValue lhsmt, LuaValue rhs, LuaValue rhsmt)` Perform equality testing metatag processing
`boolean`	`equals(Object obj)`
`static LuaValue`	`error(String message)` Throw a `LuaError` with a particular message
`LuaValue`	`get(int key)` Get a value in a table including metatag processing using `INDEX`.
`LuaValue`	`get(LuaValue key)` Get a value in a table including metatag processing using `INDEX`.
`LuaValue`	`get(String key)` Get a value in a table including metatag processing using `INDEX`.
`LuaValue`	`getfenv()`
`LuaValue`	`getmetatable()` Get the metatable for this `LuaValue` For `LuaTable` and `LuaUserdata` instances, the metatable returned is this instance metatable.
`protected static LuaValue`	`gettable(LuaValue t, LuaValue key)` get value from metatable operations, or NIL if not defined by metatables
`LuaValue`	`getuservalue()`
`boolean`	`gt_b(double rhs)` Greater than: Perform numeric or string comparison with another value of unknown type, including metatag processing, and returning java boolean.
`boolean`	`gt_b(long rhs)` Greater than: Perform numeric comparison with another value of int type, including metatag processing, and returning java boolean.
`boolean`	`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`	`gt(double rhs)` Greater than: Perform numeric comparison with another value of double type, including metatag processing, and returning `LuaValue`.
`LuaValue`	`gt(long rhs)` Greater than: Perform numeric comparison with another value of int type, including metatag processing, and returning `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`	`gteq_b(double rhs)` Greater than or equals: Perform numeric comparison with another value of double type, including metatag processing, and returning java boolean.
`boolean`	`gteq_b(long rhs)` Greater than or equals: Perform numeric comparison with another value of int type, including metatag processing, and returning java boolean.
`boolean`	`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`	`gteq(double rhs)` Greater than or equals: Perform numeric comparison with another value of double type, including metatag processing, and returning `LuaValue`.
`LuaValue`	`gteq(long rhs)` Greater than or equals: Perform numeric comparison with another value of int type, including metatag processing, and returning `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`.
`LuaValue`	`idiv(long rhs)`
`LuaValue`	`idiv(LuaValue rhs)`
`protected LuaValue`	`illegal(String op, String typename)` Throw a `LuaError` indicating an illegal operation occurred, typically involved in managing weak references
`Varargs`	`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`	`initupvalue1(LuaValue env)` Hook for implementations such as LuaJC to load the environment of the main chunk into the first upvalue location.
`Varargs`	`invoke()` Call `this` with 0 arguments, including metatag processing, and retain all return values in a `Varargs`.
`Varargs`	`invoke(LuaValue[] args)` Call `this` with variable arguments, including metatag processing, and retain all return values in a `Varargs`.
`Varargs`	`invoke(LuaValue[] args, Varargs varargs)` Call `this` with variable arguments, including metatag processing, and retain all return values in a `Varargs`.
`Varargs`	`invoke(LuaValue arg1, LuaValue arg2, Varargs varargs)` Call `this` with variable arguments, including metatag processing, and retain all return values in a `Varargs`.
`Varargs`	`invoke(LuaValue arg, Varargs varargs)` Call `this` with variable arguments, including metatag processing, and retain all return values in a `Varargs`.
`Varargs`	`invoke(Varargs args)` Call `this` with variable arguments, including metatag processing, and retain all return values in a `Varargs`.
`Varargs`	`invokemethod(LuaValue name)` Call named method on `this` with 0 arguments, including metatag processing, and retain all return values in a `Varargs`.
`Varargs`	`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`	`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`	`invokemethod(String name)` Call named method on `this` with 0 arguments, including metatag processing, and retain all return values in a `Varargs`.
`Varargs`	`invokemethod(String name, LuaValue[] args)` Call named method on `this` with 1 argument, including metatag processing, and retain all return values in a `Varargs`.
`Varargs`	`invokemethod(String name, Varargs args)` Call named method on `this` with 1 argument, including metatag processing, and retain all return values in a `Varargs`.
`boolean`	`isboolean()` Check if `this` is a `boolean`
`boolean`	`isclosure()` Check if `this` is a `function` that is a closure, meaning interprets lua bytecode for its execution
`boolean`	`isfunction()` Check if `this` is a `function`
`boolean`	`isint()` Check if `this` is a `number` and is representable by java int without rounding or truncation
`boolean`	`isinttype()` Check if `this` is a `LuaInteger` No attempt to convert from string will be made by this call.
`boolean`	`islong()` Check if `this` is a `number` and is representable by java long without rounding or truncation
`boolean`	`isnil()` Check if `this` is `#NIL`
`boolean`	`isnumber()` Check if `this` is a `number`
`boolean`	`isstring()` Check if `this` is a `string`
`boolean`	`istable()` Check if `this` is a `table`
`boolean`	`isthread()` Check if `this` is a `thread`
`boolean`	`isuserdata()` Check if `this` is a `userdata`
`boolean`	`isuserdata(Class c)` Check if `this` is a `userdata` of type `c`
`boolean`	`isvalidkey()` Return true if this is a valid key in a table index operation.
`Object`	`jcall(Object... args)`
`Object`	`jget(String key)`
`void`	`jset(String key, Object value)`
`LuaValue`	`len()` Length operator: return lua length of object `(#this)` including metatag processing as java int
`protected LuaValue`	`lenerror()` Throw a `LuaError` based on the len operator, typically due to an invalid operand type
`int`	`length()` Length operator: return lua length of object `(#this)` including metatag processing as java int
`static LuaTable`	`listOf(LuaValue[] unnamedValues)` Construct a `LuaTable` initialized with supplied array values.
`static LuaTable`	`listOf(LuaValue[] unnamedValues, Varargs lastarg)` Construct a `LuaTable` initialized with supplied array values.
`LuaValue`	`load(LuaValue library)` Load a library instance by calling it with and empty string as the modname, and this Globals as the environment.
`boolean`	`lt_b(double rhs)` Less than: Perform numeric or string comparison with another value of unknown type, including metatag processing, and returning java boolean.
`boolean`	`lt_b(long rhs)` Less than: Perform numeric comparison with another value of int type, including metatag processing, and returning java boolean.
`boolean`	`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`	`lt(double rhs)` Less than: Perform numeric comparison with another value of double type, including metatag processing, and returning `LuaValue`.
`LuaValue`	`lt(long rhs)` Less than: Perform numeric comparison with another value of int type, including metatag processing, and returning `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`	`lteq_b(double rhs)` Less than or equals: Perform numeric comparison with another value of double type, including metatag processing, and returning java boolean.
`boolean`	`lteq_b(long rhs)` Less than or equals: Perform numeric comparison with another value of int type, including metatag processing, and returning java boolean.
`boolean`	`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`	`lteq(double rhs)` Less than or equals: Perform numeric comparison with another value of double type, including metatag processing, and returning `LuaValue`.
`LuaValue`	`lteq(long rhs)` Less than or equals: Perform numeric comparison with another value of int type, including metatag processing, and returning `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`	`metatableOf(LuaValue mt)` Construct a Metatable instance from the given LuaValue
`LuaValue`	`metatag(LuaValue tag)` Get particular metatag, or return `NIL` if it doesn't exist
`LuaValue`	`method(LuaValue name)` Call named method on `this` with 0 arguments, including metatag processing, and return only the first return value.
`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`	`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`	`method(String name)` Call named method on `this` with 0 arguments, including metatag processing, and return only the first return value.
`LuaValue`	`method(String name, LuaValue arg)` Call named method on `this` with 1 argument, including metatag processing, and return only the first return value.
`LuaValue`	`method(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`	`mod(double rhs)` Modulo: Perform numeric modulo operation with another value of double type without metatag processing `this` must derive from `LuaNumber` or derive from `LuaString` and be convertible to a number For metatag processing `mod(LuaValue)` must be used
`LuaValue`	`mod(long rhs)` Modulo: Perform numeric modulo operation with another value of int type without metatag processing `this` must derive from `LuaNumber` or derive from `LuaString` and be convertible to a number For metatag processing `mod(LuaValue)` must be used
`LuaValue`	`mod(LuaValue rhs)` Modulo: Perform numeric modulo operation with another value of unknown type, including metatag processing.
`LuaValue`	`modFrom(double lhs)` Reverse-modulo: Perform numeric modulo operation from another value with metatag processing `this` must derive from `LuaNumber` or derive from `LuaString` and be convertible to a number
`LuaValue`	`mul(double rhs)` Multiply: Perform numeric multiply operation with another value of double type with metatag processing `this` must derive from `LuaNumber` or derive from `LuaString` and be convertible to a number
`LuaValue`	`mul(long rhs)` Multiply: Perform numeric multiply operation with another value of int type with metatag processing `this` must derive from `LuaNumber` or derive from `LuaString` and be convertible to a number
`LuaValue`	`mul(LuaValue rhs)` Multiply: Perform numeric multiply operation with another value of unknown type, including metatag processing.
`int`	`narg()` Get the number of arguments, or 0 if there are none.
`LuaValue`	`neg()` Unary minus: return negative value `(-this)` as defined by lua unary minus operator
`boolean`	`neq_b(LuaValue val)` Notquals: Perform inequality comparison with another value including metatag processing using `EQ`.
`LuaValue`	`neq(LuaValue val)` Notquals: Perform inequality comparison with another value including metatag processing using `EQ`.
`Varargs`	`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`	`not()` Unary not: return inverse boolean value `(~this)` as defined by lua not operator
`Varargs`	`onInvoke(Varargs args)` Callback used during tail call processing to invoke the function once.
`boolean`	`optboolean(boolean defval)` Check that optional argument is a boolean and return its boolean value
`LuaClosure`	`optclosure(LuaClosure defval)` Check that optional argument is a closure and return as `LuaClosure` A `LuaClosure` is a `LuaFunction` that executes lua byteccode.
`double`	`optdouble(double defval)` Check that optional argument is a number or string convertible to number and return as double
`LuaFunction`	`optfunction(LuaFunction defval)` Check that optional argument is a function and return as `LuaFunction` A `LuaFunction` may either be a Java function that implements functionality directly in Java, or a `LuaClosure` which is a `LuaFunction` that executes lua bytecode.
`int`	`optint(int defval)` Check that optional argument is a number or string convertible to number and return as int
`LuaInteger`	`optinteger(LuaInteger defval)` Check that optional argument is a number or string convertible to number and return as `LuaInteger`
`String`	`optjstring(String defval)` Check that optional argument is a string or number and return as Java String
`long`	`optlong(long defval)` Check that optional argument is a number or string convertible to number and return as long
`LuaNumber`	`optnumber(LuaNumber defval)` Check that optional argument is a number or string convertible to number and return as `LuaNumber`
`LuaString`	`optstring(LuaString defval)` Check that optional argument is a string or number and return as `LuaString`
`LuaTable`	`opttable(LuaTable defval)` Check that optional argument is a table and return as `LuaTable`
`LuaThread`	`optthread(LuaThread defval)` Check that optional argument is a thread and return as `LuaThread`
`Object`	`optuserdata(Class c, Object defval)` Check that optional argument is a userdata whose instance is of a type and return the Object instance
`Object`	`optuserdata(Object defval)` Check that optional argument is a userdata and return the Object instance
`LuaValue`	`optvalue(LuaValue defval)` Perform argument check that this is not nil or none.
`LuaValue`	`or(LuaValue rhs)` Perform boolean `or` with another operand, based on lua rules for boolean evaluation.
`LuaValue`	`pow(double rhs)` Raise to power: Raise this value to a power of double type with metatag processing `this` must derive from `LuaNumber` or derive from `LuaString` and be convertible to a number
`LuaValue`	`pow(long rhs)` Raise to power: Raise this value to a power of int type with metatag processing `this` must derive from `LuaNumber` or derive from `LuaString` and be convertible to a number
`LuaValue`	`pow(LuaValue rhs)` Raise to power: Raise this value to a power including metatag processing.
`LuaValue`	`powWith(double lhs)` Reverse-raise to power: Raise another value of double type to this power with metatag processing `this` must derive from `LuaNumber` or derive from `LuaString` and be convertible to a number
`LuaValue`	`powWith(long lhs)` Reverse-raise to power: Raise another value of double type to this power with metatag processing `this` must derive from `LuaNumber` or derive from `LuaString` and be convertible to a number
`void`	`presize(int i)` Preallocate the array part of a table to be a certain size, Primarily used internally in response to a SETLIST bytecode.
`boolean`	`raweq(double val)` Equals: Perform direct equality comparison with a double value without metatag processing.
`boolean`	`raweq(long val)` Equals: Perform direct equality comparison with a int value without metatag processing.
`boolean`	`raweq(LuaString val)` Equals: Perform direct equality comparison with a `LuaString` value without metatag processing.
`boolean`	`raweq(LuaUserdata val)` Equals: Perform direct equality comparison with a `LuaUserdata` value without metatag processing.
`boolean`	`raweq(LuaValue val)` Equals: Perform direct equality comparison with another value without metatag processing.
`LuaValue`	`rawget(int key)` Get a value in a table without metatag processing.
`LuaValue`	`rawget(LuaValue key)` Get a value in a table without metatag processing.
`LuaValue`	`rawget(String key)` Get a value in a table without metatag processing.
`int`	`rawlen()` Get raw length of table or string without metatag processing.
`void`	`rawset(int key, LuaValue value)` Set a value in a table without metatag processing.
`void`	`rawset(int key, String value)` Set a value in a table without metatag processing.
`void`	`rawset(LuaValue key, LuaValue value)` Set a value in a table without metatag processing.
`void`	`rawset(String key, double value)` Set a value in a table without metatag processing.
`void`	`rawset(String key, int value)` Set a value in a table without metatag processing.
`void`	`rawset(String key, LuaValue value)` Set a value in a table without metatag processing.
`void`	`rawset(String key, String value)` Set a value in a table without metatag processing.
`void`	`rawsetlist(int key0, Varargs values)` Set list values in a table without invoking metatag processing Primarily used internally in response to a SETLIST bytecode.
`void`	`set(int key, LuaValue value)` Set a value in a table without metatag processing using `NEWINDEX`.
`void`	`set(int key, String value)` Set a value in a table without metatag processing using `NEWINDEX`.
`void`	`set(LuaValue key, LuaValue value)` Set a value in a table without metatag processing using `NEWINDEX`.
`void`	`set(String key, double value)` Set a value in a table without metatag processing using `NEWINDEX`.
`void`	`set(String key, int value)` Set a value in a table without metatag processing using `NEWINDEX`.
`void`	`set(String key, LuaValue value)` Set a value in a table without metatag processing using `NEWINDEX`.
`void`	`set(String key, String value)` Set a value in a table without metatag processing using `NEWINDEX`.
`void`	`setfenv(LuaValue env)`
`LuaValue`	`setmetatable(LuaValue metatable)` Set the metatable for this `LuaValue` For `LuaTable` and `LuaUserdata` instances, the metatable is per instance.
`protected static boolean`	`settable(LuaValue t, LuaValue key, LuaValue value)` Perform field assignment including metatag processing.
`void`	`setuservalue(LuaValue uservalue)`
`LuaValue`	`shl(long rhs)`
`LuaValue`	`shl(LuaValue rhs)`
`LuaValue`	`shr(long rhs)`
`LuaValue`	`shr(LuaValue rhs)`
`int`	`strcmp(LuaString rhs)` Perform string comparison with another value known to be a `LuaString` using string comparison based on byte values.
`int`	`strcmp(LuaValue rhs)` Perform string comparison with another value of any type using string comparison based on byte values.
`LuaValue`	`strongvalue()` Return this value as a strong reference, or null if it was weak and is no longer referenced.
`LuaString`	`strvalue()` Convert this value to a string if it is a `LuaString` or `LuaNumber`, or throw a `LuaError` if it is not
`LuaValue`	`sub(double rhs)` Subtract: Perform numeric subtract operation with another value of double type with metatag processing `this` must derive from `LuaNumber` or derive from `LuaString` and be convertible to a number
`LuaValue`	`sub(long rhs)` Subtract: Perform numeric subtract operation with another value of int type with metatag processing `this` must derive from `LuaNumber` or derive from `LuaString` and be convertible to a number
`LuaValue`	`sub(LuaValue rhs)` Subtract: Perform numeric subtract operation with another value of unknown type, including metatag processing.
`Varargs`	`subargs(int start)` Create a `Varargs` instance containing arguments starting at index `start`
`LuaValue`	`subFrom(double lhs)` Reverse-subtract: Perform numeric subtract operation from an int value with metatag processing `this` must derive from `LuaNumber` or derive from `LuaString` and be convertible to a number
`LuaValue`	`subFrom(long lhs)` Reverse-subtract: Perform numeric subtract operation from a double value without metatag processing `this` must derive from `LuaNumber` or derive from `LuaString` and be convertible to a number For metatag processing `sub(LuaValue)` must be used
`static LuaTable`	`tableOf()` Construct an empty `LuaTable`.
`static LuaTable`	`tableOf(int narray, int nhash)` Construct an empty `LuaTable` preallocated to hold array and hashed elements
`static LuaTable`	`tableOf(LuaValue[] namedValues)` Construct a `LuaTable` initialized with supplied named values.
`static LuaTable`	`tableOf(LuaValue[] namedValues, LuaValue[] unnamedValues)` Construct a `LuaTable` initialized with supplied named values and sequential elements.
`static LuaTable`	`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`	`tableOf(Varargs varargs, int firstarg)` Construct a `LuaTable` initialized with supplied array values.
`static Varargs`	`tailcallOf(LuaValue func, Varargs args)` Construct a `TailcallVarargs` around a function and arguments.
`boolean`	`testfor_b(LuaValue limit, LuaValue step)` Perform end-condition test in for-loop processing.
`boolean`	`toboolean()` Convert to boolean false if `NIL` or `FALSE`, true if anything else
`byte`	`tobyte()` Convert to byte if numeric, or 0 if not.
`char`	`tochar()` Convert to char if numeric, or 0 if not.
`double`	`todouble()` Convert to double if numeric, or 0 if not.
`float`	`tofloat()` Convert to float if numeric, or 0 if not.
`int`	`toint()` Convert to int if numeric, or 0 if not.
`String`	`tojstring()` Convert to human readable String for any type.
`long`	`tolong()` Convert to long if numeric, or 0 if not.
`LuaValue`	`tonumber()` Conditionally convert to lua number without throwing errors.
`short`	`toshort()` Convert to short if numeric, or 0 if not.
`LuaValue`	`tostring()` Conditionally convert to lua string without throwing errors.
`String`	`toString()` Convert the value to a human readable string using `tojstring()`
`Object`	`touserdata()` Convert to userdata instance, or null.
`<T> T`	`touserdata(Class<T> c)` Convert to userdata instance if specific type, or null.
`abstract int`	`type()` Get the enumeration value for the type of this value.
`abstract String`	`typename()` Get the String name of the type of this value.
`protected LuaValue`	`typerror(String expected)` Throw a `LuaError` indicating an invalid type was supplied to a function
`protected LuaValue`	`unimplemented(String fun)` Throw a `LuaError` indicating an operation is not implemented
`static LuaUserdata`	`userdataOf(Object o)` Construct a LuaUserdata for an object.
`static LuaUserdata`	`userdataOf(Object o, LuaValue metatable)` Construct a LuaUserdata for an object with a user supplied metatable.
`static LuaBoolean`	`valueOf(boolean b)` Convert java boolean to a `LuaValue`.
`static LuaString`	`valueOf(byte[] bytes)` Convert bytes in an array to a `LuaValue`.
`static LuaString`	`valueOf(byte[] bytes, int off, int len)` Convert bytes in an array to a `LuaValue`.
`static LuaNumber`	`valueOf(double d)` Convert java double to a `LuaValue`.
`static LuaInteger`	`valueOf(int i)` Convert java int to a `LuaValue`.
`static LuaNumber`	`valueOf(long i)`
`static LuaString`	`valueOf(String s)` Convert java string to a `LuaValue`.
`static Varargs`	`varargsOf(LuaValue[] v)` Construct a `Varargs` around an array of `LuaValue`s.
`static Varargs`	`varargsOf(LuaValue[] v, int offset, int length)` Construct a `Varargs` around an array of `LuaValue`s.
`static Varargs`	`varargsOf(LuaValue[] v, int offset, int length, Varargs more)` Construct a `Varargs` around an array of `LuaValue`s.
`static Varargs`	`varargsOf(LuaValue[] v, Varargs r)` Construct a `Varargs` around an array of `LuaValue`s.
`static Varargs`	`varargsOf(LuaValue v1, LuaValue v2, Varargs v3)` Construct a `Varargs` around a set of 3 or more `LuaValue`s.
`static Varargs`	`varargsOf(LuaValue v, Varargs r)` Construct a `Varargs` around a set of 2 or more `LuaValue`s.

从类继承的方法 org.luaj.vm2.Varargs
argcheck, checkboolean, checkclosure, checkdouble, checkfunction, checkint, checkinteger, checkjstring, checklong, checknotnil, checknumber, checkstring, checktable, checkthread, checkuserdata, checkuserdata, checkvalue, dealias, eval, isfunction, isnil, isnoneornil, isnumber, isstring, istable, isTailcall, isthread, isuserdata, isvalue, optboolean, optclosure, optdouble, optfunction, optint, optinteger, optjstring, optlong, optnumber, optstring, opttable, optthread, optuserdata, optuserdata, optvalue, toboolean, tobyte, tochar, todouble, tofloat, toint, tojstring, tolong, toshort, touserdata, touserdata, type

从类继承的方法 java.lang.Object
clone, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- 字段详细资料
  - TINT
```
public static final int TINT
```
    Type enumeration constant for lua numbers that are ints, for compatibility with lua 5.1 number patch only
    
    另请参阅:
    
    常量字段值
  - TNONE
```
public static final int TNONE
```
    Type enumeration constant for lua values that have no type, for example weak table entries
    
    另请参阅:
    
    常量字段值
  - TNIL
```
public static final int TNIL
```
    Type enumeration constant for lua nil
    
    另请参阅:
    
    常量字段值
  - TBOOLEAN
```
public static final int TBOOLEAN
```
    Type enumeration constant for lua booleans
    
    另请参阅:
    
    常量字段值
  - TLIGHTUSERDATA
```
public static final int TLIGHTUSERDATA
```
    Type enumeration constant for lua light userdata, for compatibility with C-based lua only
    
    另请参阅:
    
    常量字段值
  - TNUMBER
```
public static final int TNUMBER
```
    Type enumeration constant for lua numbers
    
    另请参阅:
    
    常量字段值
  - TSTRING
```
public static final int TSTRING
```
    Type enumeration constant for lua strings
    
    另请参阅:
    
    常量字段值
  - TTABLE
```
public static final int TTABLE
```
    Type enumeration constant for lua tables
    
    另请参阅:
    
    常量字段值
  - TFUNCTION
```
public static final int TFUNCTION
```
    Type enumeration constant for lua functions
    
    另请参阅:
    
    常量字段值
  - TUSERDATA
```
public static final int TUSERDATA
```
    Type enumeration constant for lua userdatas
    
    另请参阅:
    
    常量字段值
  - TTHREAD
```
public static final int TTHREAD
```
    Type enumeration constant for lua threads
    
    另请参阅:
    
    常量字段值
  - TVALUE
```
public static final int TVALUE
```
    Type enumeration constant for unknown values, for compatibility with C-based lua only
    
    另请参阅:
    
    常量字段值
  - TYPE_NAMES
```
public static final String[] TYPE_NAMES
```
    String array constant containing names of each of the lua value types
    
    另请参阅:
    
    type(), typename()
  - NIL
```
public static final LuaValue NIL
```
    LuaValue constant corresponding to lua #NIL
  - TRUE
```
public static final LuaBoolean TRUE
```
    LuaBoolean constant corresponding to lua true
  - FALSE
```
public static final LuaBoolean FALSE
```
    LuaBoolean constant corresponding to lua false
  - NONE
```
public static final LuaValue NONE
```
    LuaValue constant corresponding to a Varargs list of no values
  - ZERO
```
public static final LuaNumber ZERO
```
    LuaValue number constant equal to 0
  - ONE
```
public static final LuaNumber ONE
```
    LuaValue number constant equal to 1
  - MINUSONE
```
public static final LuaNumber MINUSONE
```
    LuaValue number constant equal to -1
  - NOVALS
```
public static final LuaValue[] NOVALS
```
    LuaValue array constant with no values
  - ENV
```
public static LuaString ENV
```
    The variable name of the environment.
  - INDEX
```
public static final LuaString INDEX
```
    LuaString constant with value "__index" for use as metatag
  - NEWINDEX
```
public static final LuaString NEWINDEX
```
    LuaString constant with value "__newindex" for use as metatag
  - CALL
```
public static final LuaString CALL
```
    LuaString constant with value "__call" for use as metatag
  - MODE
```
public static final LuaString MODE
```
    LuaString constant with value "__mode" for use as metatag
  - METATABLE
```
public static final LuaString METATABLE
```
    LuaString constant with value "__metatable" for use as metatag
  - ADD
```
public static final LuaString ADD
```
    LuaString constant with value "__add" for use as metatag
  - SUB
```
public static final LuaString SUB
```
    LuaString constant with value "__sub" for use as metatag
  - DIV
```
public static final LuaString DIV
```
    LuaString constant with value "__div" for use as metatag
  - MUL
```
public static final LuaString MUL
```
    LuaString constant with value "__mul" for use as metatag
  - POW
```
public static final LuaString POW
```
    LuaString constant with value "__pow" for use as metatag
  - MOD
```
public static final LuaString MOD
```
    LuaString constant with value "__mod" for use as metatag
  - UNM
```
public static final LuaString UNM
```
    LuaString constant with value "__unm" for use as metatag
  - LEN
```
public static final LuaString LEN
```
    LuaString constant with value "__len" for use as metatag
  - EQ
```
public static final LuaString EQ
```
    LuaString constant with value "__eq" for use as metatag
  - LT
```
public static final LuaString LT
```
    LuaString constant with value "__lt" for use as metatag
  - LE
```
public static final LuaString LE
```
    LuaString constant with value "__le" for use as metatag
  - TOSTRING
```
public static final LuaString TOSTRING
```
    LuaString constant with value "__tostring" for use as metatag
  - CONCAT
```
public static final LuaString CONCAT
```
    LuaString constant with value "__concat" for use as metatag
  - EMPTYSTRING
```
public static final LuaString EMPTYSTRING
```
    LuaString constant with value ""
  - NILS
```
public static final LuaValue[] NILS
```
    Array of NIL values to optimize filling stacks using System.arraycopy(). Must not be modified.
  - uservalue
```
public LuaValue uservalue
```
  - IDIV
```
public static final LuaString IDIV
```
  - BAND
```
public static final LuaString BAND
```
  - BOR
```
public static final LuaString BOR
```
  - BXOR
```
public static final LuaString BXOR
```
  - SHL
```
public static final LuaString SHL
```
  - SHR
```
public static final LuaString SHR
```
  - BNOT
```
public static final LuaString BNOT
```
- 构造器详细资料
  - LuaValue
```
public LuaValue()
```
- 方法详细资料
  - type
```
public abstract int type()
```
    Get the enumeration value for the type of this value.
    
    返回:
    
    value for this type, one of TNIL, TBOOLEAN, TNUMBER, TSTRING, TTABLE, TFUNCTION, TUSERDATA, TTHREAD
    
    另请参阅:
    
    typename()
  - typename
```
public abstract String typename()
```
    Get the String name of the type of this value.
    
    返回:
    
    name from type name list TYPE_NAMES corresponding to the type of this value: "nil", "boolean", "number", "string", "table", "function", "userdata", "thread"
    
    另请参阅:
    
    type()
  - isboolean
```
public boolean isboolean()
```
    Check if this is a boolean
    
    返回:
    
    true if this is a boolean, otherwise false
    
    另请参阅:
    
    isboolean(), toboolean(), checkboolean(), optboolean(boolean), TBOOLEAN
  - isclosure
```
public boolean isclosure()
```
    Check if this is a function that is a closure, meaning interprets lua bytecode for its execution
    
    返回:
    
    true if this is a closure, otherwise false
    
    另请参阅:
    
    isfunction(), checkclosure(), optclosure(LuaClosure), TFUNCTION
  - isfunction
```
public boolean isfunction()
```
    Check if this is a function
    
    返回:
    
    true if this is a function, otherwise false
    
    另请参阅:
    
    isclosure(), checkfunction(), optfunction(LuaFunction), TFUNCTION
  - isint
```
public boolean isint()
```
    Check if this is a number and is representable by java int without rounding or truncation
    
    返回:
    
    true if this is a number meaning derives from LuaNumber or derives from LuaString and is convertible to a number, and can be represented by int, otherwise false
    
    另请参阅:
    
    isinttype(), islong(), tonumber(), checkint(), optint(int), TNUMBER
  - isinttype
```
public boolean isinttype()
```
    Check if this is a LuaInteger
    No attempt to convert from string will be made by this call.
    
    返回:
    
    true if this is a LuaInteger, otherwise false
    
    另请参阅:
    
    isint(), isnumber(), tonumber(), TNUMBER
  - islong
```
public boolean islong()
```
    Check if this is a number and is representable by java long without rounding or truncation
    
    返回:
    
    true if this is a number meaning derives from LuaNumber or derives from LuaString and is convertible to a number, and can be represented by long, otherwise false
    
    另请参阅:
    
    tonumber(), checklong(), optlong(long), TNUMBER
  - isnil
```
public boolean isnil()
```
    Check if this is #NIL
    
    返回:
    
    true if this is #NIL, otherwise false
    
    另请参阅:
    
    NIL, NONE, checknotnil(), optvalue(LuaValue), Varargs.isnoneornil(int), TNIL, TNONE
  - isnumber
```
public boolean isnumber()
```
    Check if this is a number
    
    返回:
    
    true if this is a number, meaning derives from LuaNumber or derives from LuaString and is convertible to a number, otherwise false
    
    另请参阅:
    
    tonumber(), checknumber(), optnumber(LuaNumber), TNUMBER
  - isstring
```
public boolean isstring()
```
    Check if this is a string
    
    返回:
    
    true if this is a string, meaning derives from LuaString or LuaNumber, otherwise false
    
    另请参阅:
    
    tostring(), checkstring(), optstring(LuaString), TSTRING
  - isthread
```
public boolean isthread()
```
    Check if this is a thread
    
    返回:
    
    true if this is a thread, otherwise false
    
    另请参阅:
    
    checkthread(), optthread(LuaThread), TTHREAD
  - istable
```
public boolean istable()
```
    Check if this is a table
    
    返回:
    
    true if this is a table, otherwise false
    
    另请参阅:
    
    checktable(), opttable(LuaTable), TTABLE
  - isuserdata
```
public boolean isuserdata()
```
    Check if this is a userdata
    
    返回:
    
    true if this is a userdata, otherwise false
    
    另请参阅:
    
    isuserdata(Class), touserdata(), checkuserdata(), optuserdata(Object), TUSERDATA
  - isuserdata
```
public boolean isuserdata(Class c)
```
    Check if this is a userdata of type c
    
    参数:
    
    c - Class to test instance against
    
    返回:
    
    true if this is a userdata and the instance is assignable to c, otherwise false
    
    另请参阅:
    
    isuserdata(), touserdata(Class), checkuserdata(Class), optuserdata(Class, Object), TUSERDATA
  - toboolean
```
public boolean toboolean()
```
    Convert to boolean false if NIL or FALSE, true if anything else
    
    返回:
    
    Value cast to byte if number or string convertible to number, otherwise 0
    
    另请参阅:
    
    optboolean(boolean), checkboolean(), isboolean(), TBOOLEAN
  - tobyte
```
public byte tobyte()
```
    Convert to byte if numeric, or 0 if not.
    
    返回:
    
    Value cast to byte if number or string convertible to number, otherwise 0
    
    另请参阅:
    
    toint(), todouble(), checknumber(), isnumber(), TNUMBER
  - tochar
```
public char tochar()
```
    Convert to char if numeric, or 0 if not.
    
    返回:
    
    Value cast to char if number or string convertible to number, otherwise 0
    
    另请参阅:
    
    toint(), todouble(), checknumber(), isnumber(), TNUMBER
  - todouble
```
public double todouble()
```
    Convert to double if numeric, or 0 if not.
    
    返回:
    
    Value cast to double if number or string convertible to number, otherwise 0
    
    另请参阅:
    
    toint(), tobyte(), tochar(), toshort(), tolong(), tofloat(), optdouble(double), checknumber(), isnumber(), TNUMBER
  - tofloat
```
public float tofloat()
```
    Convert to float if numeric, or 0 if not.
    
    返回:
    
    Value cast to float if number or string convertible to number, otherwise 0
    
    另请参阅:
    
    toint(), todouble(), checknumber(), isnumber(), TNUMBER
  - toint
```
public int toint()
```
    Convert to int if numeric, or 0 if not.
    
    返回:
    
    Value cast to int if number or string convertible to number, otherwise 0
    
    另请参阅:
    
    tobyte(), tochar(), toshort(), tolong(), tofloat(), todouble(), optint(int), checknumber(), isnumber(), TNUMBER
  - tolong
```
public long tolong()
```
    Convert to long if numeric, or 0 if not.
    
    返回:
    
    Value cast to long if number or string convertible to number, otherwise 0
    
    另请参阅:
    
    isint(), isinttype(), toint(), todouble(), optlong(long), checknumber(), isnumber(), TNUMBER
  - toshort
```
public short toshort()
```
    Convert to short if numeric, or 0 if not.
    
    返回:
    
    Value cast to short if number or string convertible to number, otherwise 0
    
    另请参阅:
    
    toint(), todouble(), checknumber(), isnumber(), TNUMBER
  - tojstring
```
public String tojstring()
```
    Convert to human readable String for any type.
    
    覆盖:
    
    tojstring 在类中 Varargs
    
    返回:
    
    String for use by human readers based on type.
    
    另请参阅:
    
    tostring(), optjstring(String), checkjstring(), isstring(), TSTRING
  - touserdata
```
public Object touserdata()
```
    Convert to userdata instance, or null.
    
    返回:
    
    userdata instance if userdata, or null if not LuaUserdata
    
    另请参阅:
    
    optuserdata(Object), checkuserdata(), isuserdata(), TUSERDATA
  - touserdata
```
public <T> T touserdata(Class<T> c)
```
    Convert to userdata instance if specific type, or null.
    
    返回:
    
    userdata instance if is a userdata whose instance derives from c, or null if not LuaUserdata
    
    另请参阅:
    
    optuserdata(Class,Object), checkuserdata(Class), isuserdata(Class), TUSERDATA
  - toString
```
public String toString()
```
    Convert the value to a human readable string using tojstring()
    
    覆盖:
    
    toString 在类中 Varargs
    
    返回:
    
    String value intended to be human readible.
    
    另请参阅:
    
    tostring(), tojstring(), optstring(LuaString), checkstring(), toString()
  - tonumber
```
public LuaValue tonumber()
```
    Conditionally convert to lua number without throwing errors.
    In lua all numbers are strings, but not all strings are numbers. This function will return the LuaValue this if it is a number or a string convertible to a number, and NIL for all other cases.
    This allows values to be tested for their "numeric-ness" without the penalty of throwing exceptions, nor the cost of converting the type and creating storage for it.
    
    返回:
    
    this if it is a LuaNumber or LuaString that can be converted to a number, otherwise NIL
    
    另请参阅:
    
    tostring(), optnumber(LuaNumber), checknumber(), toint(), todouble()
  - tostring
```
public LuaValue tostring()
```
    Conditionally convert to lua string without throwing errors.
    In lua all numbers are strings, so this function will return the LuaValue this if it is a string or number, and NIL for all other cases.
    This allows values to be tested for their "string-ness" without the penalty of throwing exceptions.
    
    返回:
    
    this if it is a LuaString or LuaNumber, otherwise NIL
    
    另请参阅:
    
    tonumber(), tojstring(), optstring(LuaString), checkstring(), toString()
  - optboolean
```
public boolean optboolean(boolean defval)
```
    Check that optional argument is a boolean and return its boolean value
    
    参数:
    
    defval - boolean value to return if this is nil or none
    
    返回:
    
    this cast to boolean if a LuaBoolean, defval if nil or none, throws LuaError otherwise
    
    抛出:
    
    LuaError - if was not a boolean or nil or none.
    
    另请参阅:
    
    checkboolean(), isboolean(), TBOOLEAN
  - optclosure
```
public LuaClosure optclosure(LuaClosure defval)
```
    Check that optional argument is a closure and return as LuaClosure
    A LuaClosure is a LuaFunction that executes lua byteccode.
    
    参数:
    
    defval - LuaClosure to return if this is nil or none
    
    返回:
    
    this cast to LuaClosure if a function, defval if nil or none, throws LuaError otherwise
    
    抛出:
    
    LuaError - if was not a closure or nil or none.
    
    另请参阅:
    
    checkclosure(), isclosure(), TFUNCTION
  - optdouble
```
public double optdouble(double defval)
```
    Check that optional argument is a number or string convertible to number and return as double
    
    参数:
    
    defval - double to return if this is nil or none
    
    返回:
    
    this cast to double if numeric, defval if nil or none, throws LuaError otherwise
    
    抛出:
    
    LuaError - if was not numeric or nil or none.
    
    另请参阅:
    
    optint(int), optinteger(LuaInteger), checkdouble(), todouble(), tonumber(), isnumber(), TNUMBER
  - optfunction
```
public LuaFunction optfunction(LuaFunction defval)
```
    Check that optional argument is a function and return as LuaFunction
    A LuaFunction may either be a Java function that implements functionality directly in Java, or a LuaClosure which is a LuaFunction that executes lua bytecode.
    
    参数:
    
    defval - LuaFunction to return if this is nil or none
    
    返回:
    
    this cast to LuaFunction if a function, defval if nil or none, throws LuaError otherwise
    
    抛出:
    
    LuaError - if was not a function or nil or none.
    
    另请参阅:
    
    checkfunction(), isfunction(), TFUNCTION
  - optint
```
public int optint(int defval)
```
    Check that optional argument is a number or string convertible to number and return as int
    
    参数:
    
    defval - int to return if this is nil or none
    
    返回:
    
    this cast to int if numeric, defval if nil or none, throws LuaError otherwise
    
    抛出:
    
    LuaError - if was not numeric or nil or none.
    
    另请参阅:
    
    optdouble(double), optlong(long), optinteger(LuaInteger), checkint(), toint(), tonumber(), isnumber(), TNUMBER
  - optinteger
```
public LuaInteger optinteger(LuaInteger defval)
```
    Check that optional argument is a number or string convertible to number and return as LuaInteger
    
    参数:
    
    defval - LuaInteger to return if this is nil or none
    
    返回:
    
    this converted and wrapped in LuaInteger if numeric, defval if nil or none, throws LuaError otherwise
    
    抛出:
    
    LuaError - if was not numeric or nil or none.
    
    另请参阅:
    
    optdouble(double), optint(int), checkint(), toint(), tonumber(), isnumber(), TNUMBER
  - optlong
```
public long optlong(long defval)
```
    Check that optional argument is a number or string convertible to number and return as long
    
    参数:
    
    defval - long to return if this is nil or none
    
    返回:
    
    this cast to long if numeric, defval if nil or none, throws LuaError otherwise
    
    抛出:
    
    LuaError - if was not numeric or nil or none.
    
    另请参阅:
    
    optdouble(double), optint(int), checkint(), toint(), tonumber(), isnumber(), TNUMBER
  - optnumber
```
public LuaNumber optnumber(LuaNumber defval)
```
    Check that optional argument is a number or string convertible to number and return as LuaNumber
    
    参数:
    
    defval - LuaNumber to return if this is nil or none
    
    返回:
    
    this cast to LuaNumber if numeric, defval if nil or none, throws LuaError otherwise
    
    抛出:
    
    LuaError - if was not numeric or nil or none.
    
    另请参阅:
    
    optdouble(double), optlong(long), optint(int), checkint(), toint(), tonumber(), isnumber(), TNUMBER
  - optjstring
```
public String optjstring(String defval)
```
    Check that optional argument is a string or number and return as Java String
    
    参数:
    
    defval - LuaString to return if this is nil or none
    
    返回:
    
    this converted to String if a string or number, defval if nil or none, throws LuaError if some other type
    
    抛出:
    
    LuaError - if was not a string or number or nil or none.
    
    另请参阅:
    
    tojstring(), optstring(LuaString), checkjstring(), toString(), TSTRING
  - optstring
```
public LuaString optstring(LuaString defval)
```
    Check that optional argument is a string or number and return as LuaString
    
    参数:
    
    defval - LuaString to return if this is nil or none
    
    返回:
    
    this converted to LuaString if a string or number, defval if nil or none, throws LuaError if some other type
    
    抛出:
    
    LuaError - if was not a string or number or nil or none.
    
    另请参阅:
    
    tojstring(), optjstring(String), checkstring(), toString(), TSTRING
  - opttable
```
public LuaTable opttable(LuaTable defval)
```
    Check that optional argument is a table and return as LuaTable
    
    参数:
    
    defval - LuaTable to return if this is nil or none
    
    返回:
    
    this cast to LuaTable if a table, defval if nil or none, throws LuaError if some other type
    
    抛出:
    
    LuaError - if was not a table or nil or none.
    
    另请参阅:
    
    checktable(), istable(), TTABLE
  - optthread
```
public LuaThread optthread(LuaThread defval)
```
    Check that optional argument is a thread and return as LuaThread
    
    参数:
    
    defval - LuaThread to return if this is nil or none
    
    返回:
    
    this cast to LuaTable if a thread, defval if nil or none, throws LuaError if some other type
    
    抛出:
    
    LuaError - if was not a thread or nil or none.
    
    另请参阅:
    
    checkthread(), isthread(), TTHREAD
  - optuserdata
```
public Object optuserdata(Object defval)
```
    Check that optional argument is a userdata and return the Object instance
    
    参数:
    
    defval - Object to return if this is nil or none
    
    返回:
    
    Object instance of the userdata if a LuaUserdata, defval if nil or none, throws LuaError if some other type
    
    抛出:
    
    LuaError - if was not a userdata or nil or none.
    
    另请参阅:
    
    checkuserdata(), isuserdata(), optuserdata(Class, Object), TUSERDATA
  - optuserdata
```
public Object optuserdata(Class c,
                          Object defval)
```
    Check that optional argument is a userdata whose instance is of a type and return the Object instance
    
    参数:
    
    c - Class to test userdata instance against
    
    defval - Object to return if this is nil or none
    
    返回:
    
    Object instance of the userdata if a LuaUserdata and instance is assignable to c, defval if nil or none, throws LuaError if some other type
    
    抛出:
    
    LuaError - if was not a userdata whose instance is assignable to c or nil or none.
    
    另请参阅:
    
    checkuserdata(Class), isuserdata(Class), optuserdata(Object), TUSERDATA
  - optvalue
```
public LuaValue optvalue(LuaValue defval)
```
    Perform argument check that this is not nil or none.
    
    参数:
    
    defval - LuaValue to return if this is nil or none
    
    返回:
    
    this if not nil or none, else defval
    
    另请参阅:
    
    NIL, NONE, isnil(), Varargs.isnoneornil(int), TNIL, TNONE
  - checkboolean
```
public boolean checkboolean()
```
    Check that the value is a LuaBoolean, or throw LuaError if not
    
    返回:
    
    boolean value for this if it is a LuaBoolean
    
    抛出:
    
    LuaError - if not a LuaBoolean
    
    另请参阅:
    
    optboolean(boolean), TBOOLEAN
  - checkclosure
```
public LuaClosure checkclosure()
```
    Check that the value is a LuaClosure , or throw LuaError if not
    LuaClosure is a subclass of LuaFunction that interprets lua bytecode.
    
    返回:
    
    this cast as LuaClosure
    
    抛出:
    
    LuaError - if not a LuaClosure
    
    另请参阅:
    
    checkfunction(), optclosure(LuaClosure), isclosure(), TFUNCTION
  - checkdouble
```
public double checkdouble()
```
    Check that the value is numeric and return the value as a double, or throw LuaError if not numeric
    Values that are LuaNumber and values that are LuaString that can be converted to a number will be converted to double.
    
    返回:
    
    value cast to a double if numeric
    
    抛出:
    
    LuaError - if not a LuaNumber or is a LuaString that can't be converted to number
    
    另请参阅:
    
    checkint(), checkinteger(), checklong(), optdouble(double), TNUMBER
  - checkfunction
```
public LuaFunction checkfunction()
```
    Check that the value is a function , or throw LuaError if not
    A LuaFunction may either be a Java function that implements functionality directly in Java, or a LuaClosure which is a LuaFunction that executes lua bytecode.
    
    返回:
    
    this if it is a lua function or closure
    
    抛出:
    
    LuaError - if not a function
    
    另请参阅:
    
    checkclosure()
  - checkglobals
```
public Globals checkglobals()
```
    Check that the value is a Globals instance, or throw LuaError if not
    Globals are a special LuaTable that establish the default global environment.
    
    返回:
    
    this if if an instance fof Globals
    
    抛出:
    
    LuaError - if not a Globals instance.
  - checkint
```
public int checkint()
```
    Check that the value is numeric, and convert and cast value to int, or throw LuaError if not numeric
    Values that are LuaNumber will be cast to int and may lose precision. Values that are LuaString that can be converted to a number will be converted, then cast to int, so may also lose precision.
    
    返回:
    
    value cast to a int if numeric
    
    抛出:
    
    LuaError - if not a LuaNumber or is a LuaString that can't be converted to number
    
    另请参阅:
    
    checkinteger(), checklong(), checkdouble(), optint(int), TNUMBER
  - checkinteger
```
public LuaInteger checkinteger()
```
    Check that the value is numeric, and convert and cast value to int, or throw LuaError if not numeric
    Values that are LuaNumber will be cast to int and may lose precision. Values that are LuaString that can be converted to a number will be converted, then cast to int, so may also lose precision.
    
    返回:
    
    value cast to a int and wrapped in LuaInteger if numeric
    
    抛出:
    
    LuaError - if not a LuaNumber or is a LuaString that can't be converted to number
    
    另请参阅:
    
    checkint(), checklong(), checkdouble(), optinteger(LuaInteger), TNUMBER
  - checklong
```
public long checklong()
```
    Check that the value is numeric, and convert and cast value to long, or throw LuaError if not numeric
    Values that are LuaNumber will be cast to long and may lose precision. Values that are LuaString that can be converted to a number will be converted, then cast to long, so may also lose precision.
    
    返回:
    
    value cast to a long if numeric
    
    抛出:
    
    LuaError - if not a LuaNumber or is a LuaString that can't be converted to number
    
    另请参阅:
    
    checkint(), checkinteger(), checkdouble(), optlong(long), TNUMBER
  - checknumber
```
public LuaNumber checknumber()
```
    Check that the value is numeric, and return as a LuaNumber if so, or throw LuaError
    Values that are LuaString that can be converted to a number will be converted and returned.
    
    返回:
    
    value as a LuaNumber if numeric
    
    抛出:
    
    LuaError - if not a LuaNumber or is a LuaString that can't be converted to number
    
    另请参阅:
    
    checkint(), checkinteger(), checkdouble(), checklong(), optnumber(LuaNumber), TNUMBER
  - checknumber
```
public LuaNumber checknumber(String msg)
```
    Check that the value is numeric, and return as a LuaNumber if so, or throw LuaError
    Values that are LuaString that can be converted to a number will be converted and returned.
    
    参数:
    
    msg - String message to supply if conversion fails
    
    返回:
    
    value as a LuaNumber if numeric
    
    抛出:
    
    LuaError - if not a LuaNumber or is a LuaString that can't be converted to number
    
    另请参阅:
    
    checkint(), checkinteger(), checkdouble(), checklong(), optnumber(LuaNumber), TNUMBER
  - checkjstring
```
public String checkjstring()
```
    Convert this value to a Java String.
    The string representations here will roughly match what is produced by the C lua distribution, however hash codes have no relationship, and there may be differences in number formatting.
    
    返回:
    
    String representation of the value
    
    另请参阅:
    
    checkstring(), optjstring(String), tojstring(), isstring(), TSTRING
  - checkstring
```
public LuaString checkstring()
```
    Check that this is a lua string, or throw LuaError if it is not.
    In lua all numbers are strings, so this will succeed for anything that derives from LuaString or LuaNumber. Numbers will be converted to LuaString.
    
    返回:
    
    LuaString representation of the value if it is a LuaString or LuaNumber
    
    抛出:
    
    LuaError - if this is not a LuaTable
    
    另请参阅:
    
    checkjstring(), optstring(LuaString), tostring(), isstring(), TSTRING
  - checktable
```
public LuaTable checktable()
```
    Check that this is a LuaTable, or throw LuaError if it is not
    
    返回:
    
    this if it is a LuaTable
    
    抛出:
    
    LuaError - if this is not a LuaTable
    
    另请参阅:
    
    istable(), opttable(LuaTable), TTABLE
  - checkthread
```
public LuaThread checkthread()
```
    Check that this is a LuaThread, or throw LuaError if it is not
    
    返回:
    
    this if it is a LuaThread
    
    抛出:
    
    LuaError - if this is not a LuaThread
    
    另请参阅:
    
    isthread(), optthread(LuaThread), TTHREAD
  - checkuserdata
```
public Object checkuserdata()
```
    Check that this is a LuaUserdata, or throw LuaError if it is not
    
    返回:
    
    this if it is a LuaUserdata
    
    抛出:
    
    LuaError - if this is not a LuaUserdata
    
    另请参阅:
    
    isuserdata(), optuserdata(Object), checkuserdata(Class), TUSERDATA
  - checkuserdata
```
public Object checkuserdata(Class c)
```
    Check that this is a LuaUserdata, or throw LuaError if it is not
    
    返回:
    
    this if it is a LuaUserdata
    
    抛出:
    
    LuaError - if this is not a LuaUserdata
    
    另请参阅:
    
    isuserdata(Class), optuserdata(Class, Object), checkuserdata(), TUSERDATA
  - checknotnil
```
public LuaValue checknotnil()
```
    Check that this is not the value NIL, or throw LuaError if it is
    
    返回:
    
    this if it is not NIL
    
    抛出:
    
    LuaError - if this is NIL
    
    另请参阅:
    
    optvalue(LuaValue)
  - isvalidkey
```
public boolean isvalidkey()
```
    Return true if this is a valid key in a table index operation.
    
    返回:
    
    true if valid as a table key, otherwise false
    
    另请参阅:
    
    isnil(), isinttype()
  - error
```
public static LuaValue error(String message)
```
    Throw a LuaError with a particular message
    
    参数:
    
    message - String providing message details
    
    抛出:
    
    LuaError - in all cases
  - assert_
```
public static void assert_(boolean b,
                           String msg)
```
    Assert a condition is true, or throw a LuaError if not Returns no value when b is true, throws error(String) with msg as argument and does not return if b is false.
    
    参数:
    
    b - condition to test
    
    msg - String message to produce on failure
    
    抛出:
    
    LuaError - if b is not true
  - argerror
```
protected LuaValue argerror(String expected)
```
    Throw a LuaError indicating an invalid argument was supplied to a function
    
    参数:
    
    expected - String naming the type that was expected
    
    抛出:
    
    LuaError - in all cases
  - argerror
```
public static LuaValue argerror(int iarg,
                                String msg)
```
    Throw a LuaError indicating an invalid argument was supplied to a function
    
    参数:
    
    iarg - index of the argument that was invalid, first index is 1
    
    msg - String providing information about the invalid argument
    
    抛出:
    
    LuaError - in all cases
  - typerror
```
protected LuaValue typerror(String expected)
```
    Throw a LuaError indicating an invalid type was supplied to a function
    
    参数:
    
    expected - String naming the type that was expected
    
    抛出:
    
    LuaError - in all cases
  - unimplemented
```
protected LuaValue unimplemented(String fun)
```
    Throw a LuaError indicating an operation is not implemented
    
    抛出:
    
    LuaError - in all cases
  - illegal
```
protected LuaValue illegal(String op,
                           String typename)
```
    Throw a LuaError indicating an illegal operation occurred, typically involved in managing weak references
    
    抛出:
    
    LuaError - in all cases
  - lenerror
```
protected LuaValue lenerror()
```
    Throw a LuaError based on the len operator, typically due to an invalid operand type
    
    抛出:
    
    LuaError - in all cases
  - aritherror
```
protected LuaValue aritherror()
```
    Throw a LuaError based on an arithmetic error such as add, or pow, typically due to an invalid operand type
    
    抛出:
    
    LuaError - in all cases
  - aritherror
```
protected LuaValue aritherror(String fun)
```
    Throw a LuaError based on an arithmetic error such as add, or pow, typically due to an invalid operand type
    
    参数:
    
    fun - String description of the function that was attempted
    
    抛出:
    
    LuaError - in all cases
  - compareerror
```
protected LuaValue compareerror(String rhs)
```
    Throw a LuaError based on a comparison error such as greater-than or less-than, typically due to an invalid operand type
    
    参数:
    
    rhs - String description of what was on the right-hand-side of the comparison that resulted in the error.
    
    抛出:
    
    LuaError - in all cases
  - compareerror
```
protected 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
    
    参数:
    
    rhs - Right-hand-side of the comparison that resulted in the error.
    
    抛出:
    
    LuaError - in all cases
  - get
```
public LuaValue get(LuaValue key)
```
    Get a value in a table including metatag processing using INDEX.
    
    参数:
    
    key - the key to look up, must not be NIL or null
    
    返回:
    
    LuaValue for that key, or NIL if not found and no metatag
    
    抛出:
    
    LuaError - if this is not a table, or there is no INDEX metatag, or key is NIL
    
    另请参阅:
    
    get(int), get(String), rawget(LuaValue)
  - get
```
public LuaValue get(int key)
```
    Get a value in a table including metatag processing using INDEX.
    
    参数:
    
    key - the key to look up
    
    返回:
    
    LuaValue for that key, or NIL if not found
    
    抛出:
    
    LuaError - if this is not a table, or there is no INDEX metatag
    
    另请参阅:
    
    get(LuaValue), rawget(int)
  - get
```
public LuaValue get(String key)
```
    Get a value in a table including metatag processing using INDEX.
    
    参数:
    
    key - the key to look up, must not be null
    
    返回:
    
    LuaValue for that key, or NIL if not found
    
    抛出:
    
    LuaError - if this is not a table, or there is no INDEX metatag
    
    另请参阅:
    
    get(LuaValue), rawget(String)
  - set
```
public void set(LuaValue key,
                LuaValue value)
```
    Set a value in a table without metatag processing using NEWINDEX.
    
    参数:
    
    key - the key to use, must not be NIL or null
    
    value - the value to use, can be NIL, must not be null
    
    抛出:
    
    LuaError - if this is not a table, or key is NIL, or there is no NEWINDEX metatag
  - set
```
public void set(int key,
                LuaValue value)
```
    Set a value in a table without metatag processing using NEWINDEX.
    
    参数:
    
    key - the key to use
    
    value - the value to use, can be NIL, must not be null
    
    抛出:
    
    LuaError - if this is not a table, or there is no NEWINDEX metatag
  - set
```
public void set(int key,
                String value)
```
    Set a value in a table without metatag processing using NEWINDEX.
    
    参数:
    
    key - the key to use
    
    value - the value to use, must not be null
    
    抛出:
    
    LuaError - if this is not a table, or there is no NEWINDEX metatag
  - set
```
public void set(String key,
                LuaValue value)
```
    Set a value in a table without metatag processing using NEWINDEX.
    
    参数:
    
    key - the key to use, must not be NIL or null
    
    value - the value to use, can be NIL, must not be null
    
    抛出:
    
    LuaError - if this is not a table, or there is no NEWINDEX metatag
  - set
```
public void set(String key,
                double value)
```
    Set a value in a table without metatag processing using NEWINDEX.
    
    参数:
    
    key - the key to use, must not be null
    
    value - the value to use
    
    抛出:
    
    LuaError - if this is not a table, or there is no NEWINDEX metatag
  - set
```
public void set(String key,
                int value)
```
    Set a value in a table without metatag processing using NEWINDEX.
    
    参数:
    
    key - the key to use, must not be null
    
    value - the value to use
    
    抛出:
    
    LuaError - if this is not a table, or there is no NEWINDEX metatag
  - set
```
public void set(String key,
                String value)
```
    Set a value in a table without metatag processing using NEWINDEX.
    
    参数:
    
    key - the key to use, must not be null
    
    value - the value to use, must not be null
    
    抛出:
    
    LuaError - if this is not a table, or there is no NEWINDEX metatag
  - rawget
```
public LuaValue rawget(LuaValue key)
```
    Get a value in a table without metatag processing.
    
    参数:
    
    key - the key to look up, must not be NIL or null
    
    返回:
    
    LuaValue for that key, or NIL if not found
    
    抛出:
    
    LuaError - if this is not a table, or key is NIL
  - rawget
```
public LuaValue rawget(int key)
```
    Get a value in a table without metatag processing.
    
    参数:
    
    key - the key to look up
    
    返回:
    
    LuaValue for that key, or NIL if not found
    
    抛出:
    
    LuaError - if this is not a table
  - rawget
```
public LuaValue rawget(String key)
```
    Get a value in a table without metatag processing.
    
    参数:
    
    key - the key to look up, must not be null
    
    返回:
    
    LuaValue for that key, or NIL if not found
    
    抛出:
    
    LuaError - if this is not a table
  - rawset
```
public void rawset(LuaValue key,
                   LuaValue value)
```
    Set a value in a table without metatag processing.
    
    参数:
    
    key - the key to use, must not be NIL or null
    
    value - the value to use, can be NIL, must not be null
    
    抛出:
    
    LuaError - if this is not a table, or key is NIL
  - rawset
```
public void rawset(int key,
                   LuaValue value)
```
    Set a value in a table without metatag processing.
    
    参数:
    
    key - the key to use
    
    value - the value to use, can be NIL, must not be null
    
    抛出:
    
    LuaError - if this is not a table
  - rawset
```
public void rawset(int key,
                   String value)
```
    Set a value in a table without metatag processing.
    
    参数:
    
    key - the key to use
    
    value - the value to use, can be NIL, must not be null
    
    抛出:
    
    LuaError - if this is not a table
  - rawset
```
public void rawset(String key,
                   LuaValue value)
```
    Set a value in a table without metatag processing.
    
    参数:
    
    key - the key to use, must not be null
    
    value - the value to use, can be NIL, must not be null
    
    抛出:
    
    LuaError - if this is not a table
  - rawset
```
public void rawset(String key,
                   double value)
```
    Set a value in a table without metatag processing.
    
    参数:
    
    key - the key to use, must not be null
    
    value - the value to use
    
    抛出:
    
    LuaError - if this is not a table
  - rawset
```
public void rawset(String key,
                   int value)
```
    Set a value in a table without metatag processing.
    
    参数:
    
    key - the key to use, must not be null
    
    value - the value to use
    
    抛出:
    
    LuaError - if this is not a table
  - rawset
```
public void rawset(String key,
                   String value)
```
    Set a value in a table without metatag processing.
    
    参数:
    
    key - the key to use, must not be null
    
    value - the value to use, must not be null
    
    抛出:
    
    LuaError - if this is not a table
  - rawsetlist
```
public void rawsetlist(int key0,
                       Varargs values)
```
    Set list values in a table without invoking metatag processing
    Primarily used internally in response to a SETLIST bytecode.
    
    参数:
    
    key0 - the first key to set in the table
    
    values - the list of values to set
    
    抛出:
    
    LuaError - if this is not a table.
  - presize
```
public void presize(int i)
```
    Preallocate the array part of a table to be a certain size,
    Primarily used internally in response to a SETLIST bytecode.
    
    参数:
    
    i - the number of array slots to preallocate in the table.
    
    抛出:
    
    LuaError - if this is not a table.
  - next
```
public Varargs 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.
    To iterate over all key-value pairs in a table you can use
```
 
 LuaValue k = LuaValue.NIL;
 while ( true ) {
    Varargs n = table.next(k);
    if ( (k = n.arg1()).isnil() )
       break;
    LuaValue v = n.arg(2)
    process( k, v )
 }
```
    参数:
    
    index - LuaInteger value identifying a key to start from, or NIL to start at the beginning
    
    返回:
    
    Varargs containing {key,value} for the next entry, or NIL if there are no more.
    
    抛出:
    
    LuaError - if this is not a table, or the supplied key is invalid.
    
    另请参阅:
    
    LuaTable, inext(LuaValue), valueOf(int), Varargs.arg1(), Varargs.arg(int), isnil()
  - inext
```
public Varargs 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.
    To iterate over integer keys in a table you can use
```
 
   LuaValue k = LuaValue.NIL;
   while ( true ) {
      Varargs n = table.inext(k);
      if ( (k = n.arg1()).isnil() )
         break;
      LuaValue v = n.arg(2)
      process( k, v )
   }
  
```
    参数:
    
    index - LuaInteger value identifying a key to start from, or NIL to start at the beginning
    
    返回:
    
    Varargs containing (key,value) for the next entry, or NONE if there are no more.
    
    抛出:
    
    LuaError - if this is not a table, or the supplied key is invalid.
    
    另请参阅:
    
    LuaTable, next(LuaValue), valueOf(int), Varargs.arg1(), Varargs.arg(int), isnil()
  - load
```
public LuaValue load(LuaValue library)
```
    Load a library instance by calling it with and empty string as the modname, and this Globals as the environment. This is normally used to iniitalize the library instance and which may install itself into these globals.
    
    参数:
    
    library - The callable LuaValue to load into this
    
    返回:
    
    LuaValue returned by the initialization call.
  - arg
```
public LuaValue arg(int index)
```
    从类复制的说明: Varargs
    
    Get the n-th argument value (1-based).
    
    指定者:
    
    arg 在类中 Varargs
    
    参数:
    
    index - the index of the argument to get, 1 is the first argument
    
    返回:
    
    Value at position i, or LuaValue.NIL if there is none.
    
    另请参阅:
    
    Varargs.arg1(), NIL
  - narg
```
public int narg()
```
    从类复制的说明: Varargs
    
    Get the number of arguments, or 0 if there are none.
    
    指定者:
    
    narg 在类中 Varargs
    
    返回:
    
    number of arguments.
  - arg1
```
public LuaValue arg1()
```
    从类复制的说明: Varargs
    
    Get the first argument in the list.
    
    指定者:
    
    arg1 在类中 Varargs
    
    返回:
    
    LuaValue which is first in the list, or LuaValue.NIL if there are no values.
    
    另请参阅:
    
    Varargs.arg(int), NIL
  - getmetatable
```
public LuaValue getmetatable()
```
    Get the metatable for this LuaValue
    For LuaTable and LuaUserdata instances, the metatable returned is this instance metatable. For all other types, the class metatable value will be returned.
    
    返回:
    
    metatable, or null if it there is none
    
    另请参阅:
    
    LuaBoolean.s_metatable, LuaNumber.s_metatable, LuaNil.s_metatable, LuaFunction.s_metatable, LuaThread.s_metatable
  - setmetatable
```
public LuaValue setmetatable(LuaValue metatable)
```
    Set the metatable for this LuaValue
    For LuaTable and LuaUserdata instances, the metatable is per instance. For all other types, there is one metatable per type that can be set directly from java
    
    参数:
    
    metatable - LuaValue instance to serve as the metatable, or null to reset it.
    
    返回:
    
    this to allow chaining of Java function calls
    
    另请参阅:
    
    LuaBoolean.s_metatable, LuaNumber.s_metatable, LuaNil.s_metatable, LuaFunction.s_metatable, LuaThread.s_metatable
  - call
```
public LuaValue call()
```
    Call this with 0 arguments, including metatag processing, and return only the first return value.
    If this is a LuaFunction, call it, and return only its first return value, dropping any others. Otherwise, look for the CALL metatag and call that.
    If the return value is a Varargs, only the 1st value will be returned. To get multiple values, use invoke() instead.
    To call this as a method call, use method(LuaValue) instead.
    
    返回:
    
    First return value (this()), or NIL if there were none.
    
    抛出:
    
    LuaError - if not a function and CALL is not defined, or the invoked function throws a LuaError or the invoked closure throw a lua error
    
    另请参阅:
    
    call(LuaValue), call(LuaValue,LuaValue), call(LuaValue, LuaValue, LuaValue), invoke(), method(String), method(LuaValue)
  - call
```
public LuaValue call(LuaValue arg)
```
    Call this with 1 argument, including metatag processing, and return only the first return value.
    If this is a LuaFunction, call it, and return only its first return value, dropping any others. Otherwise, look for the CALL metatag and call that.
    If the return value is a Varargs, only the 1st value will be returned. To get multiple values, use invoke() instead.
    To call this as a method call, use method(LuaValue) instead.
    
    参数:
    
    arg - First argument to supply to the called function
    
    返回:
    
    First return value (this(arg)), or NIL if there were none.
    
    抛出:
    
    LuaError - if not a function and CALL is not defined, or the invoked function throws a LuaError or the invoked closure throw a lua error
    
    另请参阅:
    
    call(), call(LuaValue,LuaValue), call(LuaValue, LuaValue, LuaValue), invoke(Varargs), method(String,LuaValue), method(LuaValue,LuaValue)
  - call
```
public LuaValue call(String arg)
```
    Convenience function which calls a luavalue with a single, string argument.
    
    参数:
    
    arg - String argument to the function. This will be converted to a LuaString.
    
    返回:
    
    return value of the invocation.
    
    另请参阅:
    
    call(LuaValue)
  - call
```
public LuaValue call(LuaValue arg1,
                     LuaValue arg2)
```
    Call this with 2 arguments, including metatag processing, and return only the first return value.
    If this is a LuaFunction, call it, and return only its first return value, dropping any others. Otherwise, look for the CALL metatag and call that.
    If the return value is a Varargs, only the 1st value will be returned. To get multiple values, use invoke() instead.
    To call this as a method call, use method(LuaValue) instead.
    
    参数:
    
    arg1 - First argument to supply to the called function
    
    arg2 - Second argument to supply to the called function
    
    返回:
    
    First return value (this(arg1,arg2)), or NIL if there were none.
    
    抛出:
    
    LuaError - if not a function and CALL is not defined, or the invoked function throws a LuaError or the invoked closure throw a lua error
    
    另请参阅:
    
    call(), call(LuaValue), call(LuaValue, LuaValue, LuaValue), invoke(LuaValue, Varargs), method(String,LuaValue,LuaValue), method(LuaValue,LuaValue,LuaValue)
  - call
```
public LuaValue call(LuaValue arg1,
                     LuaValue arg2,
                     LuaValue arg3)
```
    Call this with 3 arguments, including metatag processing, and return only the first return value.
    If this is a LuaFunction, call it, and return only its first return value, dropping any others. Otherwise, look for the CALL metatag and call that.
    If the return value is a Varargs, only the 1st value will be returned. To get multiple values, use invoke() instead.
    To call this as a method call, use method(LuaValue) instead.
    
    参数:
    
    arg1 - First argument to supply to the called function
    
    arg2 - Second argument to supply to the called function
    
    arg3 - Second argument to supply to the called function
    
    返回:
    
    First return value (this(arg1,arg2,arg3)), or NIL if there were none.
    
    抛出:
    
    LuaError - if not a function and CALL is not defined, or the invoked function throws a LuaError or the invoked closure throw a lua error
    
    另请参阅:
    
    call(), call(LuaValue), call(LuaValue, LuaValue), invoke(LuaValue, LuaValue, Varargs), invokemethod(String,Varargs), invokemethod(LuaValue,Varargs)
  - method
```
public LuaValue method(String name)
```
    Call named method on this with 0 arguments, including metatag processing, and return only the first return value.
    Look up this[name] and if it is a LuaFunction, call it inserting this as an additional first argument. and return only its first return value, dropping any others. Otherwise, look for the CALL metatag and call that.
    If the return value is a Varargs, only the 1st value will be returned. To get multiple values, use invoke() instead.
    To call this as a plain call, use call() instead.
    
    参数:
    
    name - Name of the method to look up for invocation
    
    返回:
    
    All values returned from this:name() as a Varargs instance
    
    抛出:
    
    LuaError - if not a function and CALL is not defined, or the invoked function throws a LuaError or the invoked closure throw a lua error
    
    另请参阅:
    
    call(), invoke(), method(LuaValue), method(String,LuaValue), method(String,LuaValue,LuaValue)
  - method
```
public LuaValue method(LuaValue name)
```
    Call named method on this with 0 arguments, including metatag processing, and return only the first return value.
    Look up this[name] and if it is a LuaFunction, call it inserting this as an additional first argument, and return only its first return value, dropping any others. Otherwise, look for the CALL metatag and call that.
    If the return value is a Varargs, only the 1st value will be returned. To get multiple values, use invoke() instead.
    To call this as a plain call, use call() instead.
    
    参数:
    
    name - Name of the method to look up for invocation
    
    返回:
    
    All values returned from this:name() as a Varargs instance
    
    抛出:
    
    LuaError - if not a function and CALL is not defined, or the invoked function throws a LuaError or the invoked closure throw a lua error
    
    另请参阅:
    
    call(), invoke(), method(String), method(LuaValue,LuaValue), method(LuaValue,LuaValue,LuaValue)
  - method
```
public LuaValue method(String name,
                       LuaValue arg)
```
    Call named method on this with 1 argument, including metatag processing, and return only the first return value.
    Look up this[name] and if it is a LuaFunction, call it inserting this as an additional first argument, and return only its first return value, dropping any others. Otherwise, look for the CALL metatag and call that.
    If the return value is a Varargs, only the 1st value will be returned. To get multiple values, use invoke() instead.
    To call this as a plain call, use call(LuaValue) instead.
    
    参数:
    
    name - Name of the method to look up for invocation
    
    arg - Argument to supply to the method
    
    返回:
    
    All values returned from this:name(arg) as a Varargs instance
    
    抛出:
    
    LuaError - if not a function and CALL is not defined, or the invoked function throws a LuaError or the invoked closure throw a lua error
    
    另请参阅:
    
    call(LuaValue), invoke(Varargs), method(String), method(LuaValue), method(String,LuaValue,LuaValue)
  - method
```
public LuaValue method(LuaValue name,
                       LuaValue arg)
```
    Call named method on this with 1 argument, including metatag processing, and return only the first return value.
    Look up this[name] and if it is a LuaFunction, call it inserting this as an additional first argument, and return only its first return value, dropping any others. Otherwise, look for the CALL metatag and call that.
    If the return value is a Varargs, only the 1st value will be returned. To get multiple values, use invoke() instead.
    To call this as a plain call, use call(LuaValue) instead.
    
    参数:
    
    name - Name of the method to look up for invocation
    
    arg - Argument to supply to the method
    
    返回:
    
    All values returned from this:name(arg) as a Varargs instance
    
    抛出:
    
    LuaError - if not a function and CALL is not defined, or the invoked function throws a LuaError or the invoked closure throw a lua error
    
    另请参阅:
    
    call(LuaValue), invoke(Varargs), method(String,LuaValue), method(LuaValue), method(LuaValue,LuaValue,LuaValue)
  - method
```
public LuaValue method(String name,
                       LuaValue arg1,
                       LuaValue arg2)
```
    Call named method on this with 2 arguments, including metatag processing, and return only the first return value.
    Look up this[name] and if it is a LuaFunction, call it inserting this as an additional first argument, and return only its first return value, dropping any others. Otherwise, look for the CALL metatag and call that.
    If the return value is a Varargs, only the 1st value will be returned. To get multiple values, use invoke() instead.
    To call this as a plain call, use call(LuaValue,LuaValue) instead.
    
    参数:
    
    name - Name of the method to look up for invocation
    
    arg1 - First argument to supply to the method
    
    arg2 - Second argument to supply to the method
    
    返回:
    
    All values returned from this:name(arg1,arg2) as a Varargs instance
    
    抛出:
    
    LuaError - if not a function and CALL is not defined, or the invoked function throws a LuaError or the invoked closure throw a lua error
    
    另请参阅:
    
    call(LuaValue,LuaValue), invoke(LuaValue,Varargs), method(String,LuaValue), method(LuaValue,LuaValue,LuaValue)
  - method
```
public 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.
    Look up this[name] and if it is a LuaFunction, call it inserting this as an additional first argument, and return only its first return value, dropping any others. Otherwise, look for the CALL metatag and call that.
    If the return value is a Varargs, only the 1st value will be returned. To get multiple values, use invoke() instead.
    To call this as a plain call, use call(LuaValue,LuaValue) instead.
    
    参数:
    
    name - Name of the method to look up for invocation
    
    arg1 - First argument to supply to the method
    
    arg2 - Second argument to supply to the method
    
    返回:
    
    All values returned from this:name(arg1,arg2) as a Varargs instance
    
    抛出:
    
    LuaError - if not a function and CALL is not defined, or the invoked function throws a LuaError or the invoked closure throw a lua error
    
    另请参阅:
    
    call(LuaValue,LuaValue), invoke(LuaValue,Varargs), method(LuaValue,LuaValue), method(String,LuaValue,LuaValue)
  - invoke
```
public Varargs invoke()
```
    Call this with 0 arguments, including metatag processing, and retain all return values in a Varargs.
    If this is a LuaFunction, call it, and return all values. Otherwise, look for the CALL metatag and call that.
    To get a particular return value, us Varargs.arg(int)
    To call this as a method call, use invokemethod(LuaValue) instead.
    
    返回:
    
    All return values as a Varargs instance.
    
    抛出:
    
    LuaError - if not a function and CALL is not defined, or the invoked function throws a LuaError or the invoked closure throw a lua error
    
    另请参阅:
    
    call(), invoke(Varargs), invokemethod(String), invokemethod(LuaValue)
  - invoke
```
public Varargs invoke(Varargs args)
```
    Call this with variable arguments, including metatag processing, and retain all return values in a Varargs.
    If this is a LuaFunction, call it, and return all values. Otherwise, look for the CALL metatag and call that.
    To get a particular return value, us Varargs.arg(int)
    To call this as a method call, use invokemethod(LuaValue) instead.
    
    参数:
    
    args - Varargs containing the arguments to supply to the called function
    
    返回:
    
    All return values as a Varargs instance.
    
    抛出:
    
    LuaError - if not a function and CALL is not defined, or the invoked function throws a LuaError or the invoked closure throw a lua error
    
    另请参阅:
    
    varargsOf(LuaValue[]), call(LuaValue), invoke(), invoke(LuaValue,Varargs), invokemethod(String,Varargs), invokemethod(LuaValue,Varargs)
  - invoke
```
public Varargs invoke(LuaValue arg,
                      Varargs varargs)
```
    Call this with variable arguments, including metatag processing, and retain all return values in a Varargs.
    If this is a LuaFunction, call it, and return all values. Otherwise, look for the CALL metatag and call that.
    To get a particular return value, us Varargs.arg(int)
    To call this as a method call, use invokemethod(LuaValue,Varargs) instead.
    
    参数:
    
    arg - The first argument to supply to the called function
    
    varargs - Varargs containing the remaining arguments to supply to the called function
    
    返回:
    
    All return values as a Varargs instance.
    
    抛出:
    
    LuaError - if not a function and CALL is not defined, or the invoked function throws a LuaError or the invoked closure throw a lua error
    
    另请参阅:
    
    varargsOf(LuaValue[]), call(LuaValue,LuaValue), invoke(LuaValue,Varargs), invokemethod(String,Varargs), invokemethod(LuaValue,Varargs)
  - invoke
```
public Varargs invoke(LuaValue arg1,
                      LuaValue arg2,
                      Varargs varargs)
```
    Call this with variable arguments, including metatag processing, and retain all return values in a Varargs.
    If this is a LuaFunction, call it, and return all values. Otherwise, look for the CALL metatag and call that.
    To get a particular return value, us Varargs.arg(int)
    To call this as a method call, use invokemethod(LuaValue,Varargs) instead.
    
    参数:
    
    arg1 - The first argument to supply to the called function
    
    arg2 - The second argument to supply to the called function
    
    varargs - Varargs containing the remaining arguments to supply to the called function
    
    返回:
    
    All return values as a Varargs instance.
    
    抛出:
    
    LuaError - if not a function and CALL is not defined, or the invoked function throws a LuaError or the invoked closure throw a lua error
    
    另请参阅:
    
    varargsOf(LuaValue[]), call(LuaValue,LuaValue,LuaValue), invoke(LuaValue,LuaValue,Varargs), invokemethod(String,Varargs), invokemethod(LuaValue,Varargs)
  - invoke
```
public Varargs invoke(LuaValue[] args)
```
    Call this with variable arguments, including metatag processing, and retain all return values in a Varargs.
    If this is a LuaFunction, call it, and return all values. Otherwise, look for the CALL metatag and call that.
    To get a particular return value, us Varargs.arg(int)
    To call this as a method call, use invokemethod(LuaValue,Varargs) instead.
    
    参数:
    
    args - Array of arguments to supply to the called function
    
    返回:
    
    All return values as a Varargs instance.
    
    抛出:
    
    LuaError - if not a function and CALL is not defined, or the invoked function throws a LuaError or the invoked closure throw a lua error
    
    另请参阅:
    
    varargsOf(LuaValue[]), call(LuaValue,LuaValue,LuaValue), invoke(LuaValue,LuaValue,Varargs), invokemethod(String,LuaValue[]), invokemethod(LuaValue,LuaValue[])
  - invoke
```
public Varargs invoke(LuaValue[] args,
                      Varargs varargs)
```
    Call this with variable arguments, including metatag processing, and retain all return values in a Varargs.
    If this is a LuaFunction, call it, and return all values. Otherwise, look for the CALL metatag and call that.
    To get a particular return value, us Varargs.arg(int)
    To call this as a method call, use invokemethod(LuaValue,Varargs) instead.
    
    参数:
    
    args - Array of arguments to supply to the called function
    
    varargs - Varargs containing additional arguments to supply to the called function
    
    返回:
    
    All return values as a Varargs instance.
    
    抛出:
    
    LuaError - if not a function and CALL is not defined, or the invoked function throws a LuaError or the invoked closure throw a lua error
    
    另请参阅:
    
    varargsOf(LuaValue[]), call(LuaValue,LuaValue,LuaValue), invoke(LuaValue,LuaValue,Varargs), invokemethod(String,LuaValue[]), invokemethod(LuaValue,LuaValue[]), invokemethod(String,Varargs), invokemethod(LuaValue,Varargs)
  - invokemethod
```
public Varargs invokemethod(String name)
```
    Call named method on this with 0 arguments, including metatag processing, and retain all return values in a Varargs.
    Look up this[name] and if it is a LuaFunction, call it inserting this as an additional first argument, and return all return values as a Varargs instance. Otherwise, look for the CALL metatag and call that.
    To get a particular return value, us Varargs.arg(int)
    To call this as a plain call, use invoke() instead.
    
    参数:
    
    name - Name of the method to look up for invocation
    
    返回:
    
    All values returned from this:name() as a Varargs instance
    
    抛出:
    
    LuaError - if not a function and CALL is not defined, or the invoked function throws a LuaError or the invoked closure throw a lua error
    
    另请参阅:
    
    call(), invoke(), method(String), invokemethod(LuaValue), invokemethod(String, LuaValue[]), invokemethod(String, Varargs), invokemethod(LuaValue, LuaValue[]), invokemethod(LuaValue, Varargs)
  - invokemethod
```
public Varargs invokemethod(LuaValue name)
```
    Call named method on this with 0 arguments, including metatag processing, and retain all return values in a Varargs.
    Look up this[name] and if it is a LuaFunction, call it inserting this as an additional first argument, and return all return values as a Varargs instance. Otherwise, look for the CALL metatag and call that.
    To get a particular return value, us Varargs.arg(int)
    To call this as a plain call, use invoke() instead.
    
    参数:
    
    name - Name of the method to look up for invocation
    
    返回:
    
    All values returned from this:name() as a Varargs instance
    
    抛出:
    
    LuaError - if not a function and CALL is not defined, or the invoked function throws a LuaError or the invoked closure throw a lua error
    
    另请参阅:
    
    call(), invoke(), method(LuaValue), invokemethod(String), invokemethod(String, LuaValue[]), invokemethod(String, Varargs), invokemethod(LuaValue, LuaValue[]), invokemethod(LuaValue, Varargs)
  - invokemethod
```
public Varargs invokemethod(String name,
                            Varargs args)
```
    Call named method on this with 1 argument, including metatag processing, and retain all return values in a Varargs.
    Look up this[name] and if it is a LuaFunction, call it inserting this as an additional first argument, and return all return values as a Varargs instance. Otherwise, look for the CALL metatag and call that.
    To get a particular return value, us Varargs.arg(int)
    To call this as a plain call, use invoke(Varargs) instead.
    
    参数:
    
    name - Name of the method to look up for invocation
    
    args - Varargs containing arguments to supply to the called function after this
    
    返回:
    
    All values returned from this:name(args) as a Varargs instance
    
    抛出:
    
    LuaError - if not a function and CALL is not defined, or the invoked function throws a LuaError or the invoked closure throw a lua error
    
    另请参阅:
    
    call(), invoke(Varargs), method(String), invokemethod(String), invokemethod(LuaValue), invokemethod(String, LuaValue[]), invokemethod(LuaValue, LuaValue[]), invokemethod(LuaValue, Varargs)
  - invokemethod
```
public Varargs invokemethod(LuaValue name,
                            Varargs args)
```
    Call named method on this with variable arguments, including metatag processing, and retain all return values in a Varargs.
    Look up this[name] and if it is a LuaFunction, call it inserting this as an additional first argument, and return all return values as a Varargs instance. Otherwise, look for the CALL metatag and call that.
    To get a particular return value, us Varargs.arg(int)
    To call this as a plain call, use invoke(Varargs) instead.
    
    参数:
    
    name - Name of the method to look up for invocation
    
    args - Varargs containing arguments to supply to the called function after this
    
    返回:
    
    All values returned from this:name(args) as a Varargs instance
    
    抛出:
    
    LuaError - if not a function and CALL is not defined, or the invoked function throws a LuaError or the invoked closure throw a lua error
    
    另请参阅:
    
    call(), invoke(Varargs), method(String), invokemethod(String), invokemethod(LuaValue), invokemethod(String, LuaValue[]), invokemethod(String, Varargs), invokemethod(LuaValue, LuaValue[])
  - invokemethod
```
public Varargs invokemethod(String name,
                            LuaValue[] args)
```
    Call named method on this with 1 argument, including metatag processing, and retain all return values in a Varargs.
    Look up this[name] and if it is a LuaFunction, call it inserting this as an additional first argument, and return all return values as a Varargs instance. Otherwise, look for the CALL metatag and call that.
    To get a particular return value, us Varargs.arg(int)
    To call this as a plain call, use invoke(Varargs) instead.
    
    参数:
    
    name - Name of the method to look up for invocation
    
    args - Array of LuaValue containing arguments to supply to the called function after this
    
    返回:
    
    All values returned from this:name(args) as a Varargs instance
    
    抛出:
    
    LuaError - if not a function and CALL is not defined, or the invoked function throws a LuaError or the invoked closure throw a lua error
    
    另请参阅:
    
    call(), invoke(Varargs), method(String), invokemethod(String), invokemethod(LuaValue), invokemethod(String, Varargs), invokemethod(LuaValue, LuaValue[]), invokemethod(LuaValue, Varargs), varargsOf(LuaValue[])
  - invokemethod
```
public Varargs invokemethod(LuaValue name,
                            LuaValue[] args)
```
    Call named method on this with variable arguments, including metatag processing, and retain all return values in a Varargs.
    Look up this[name] and if it is a LuaFunction, call it inserting this as an additional first argument, and return all return values as a Varargs instance. Otherwise, look for the CALL metatag and call that.
    To get a particular return value, us Varargs.arg(int)
    To call this as a plain call, use invoke(Varargs) instead.
    
    参数:
    
    name - Name of the method to look up for invocation
    
    args - Array of LuaValue containing arguments to supply to the called function after this
    
    返回:
    
    All values returned from this:name(args) as a Varargs instance
    
    抛出:
    
    LuaError - if not a function and CALL is not defined, or the invoked function throws a LuaError or the invoked closure throw a lua error
    
    另请参阅:
    
    call(), invoke(Varargs), method(String), invokemethod(String), invokemethod(LuaValue), invokemethod(String, LuaValue[]), invokemethod(String, Varargs), invokemethod(LuaValue, Varargs), varargsOf(LuaValue[])
  - callmt
```
protected LuaValue callmt()
```
    Get the metatag value for the CALL metatag, if it exists.
    
    返回:
    
    LuaValue value if metatag is defined
    
    抛出:
    
    LuaError - if CALL metatag is not defined.
  - not
```
public LuaValue not()
```
    Unary not: return inverse boolean value (~this) as defined by lua not operator
    
    返回:
    
    TRUE if NIL or FALSE, otherwise FALSE
  - neg
```
public LuaValue neg()
```
    Unary minus: return negative value (-this) as defined by lua unary minus operator
    
    返回:
    
    boolean inverse as LuaBoolean if boolean or nil, numeric inverse as LuaNumber if numeric, or metatag processing result if UNM metatag is defined
    
    抛出:
    
    LuaError - if this is not a table or string, and has no UNM metatag
  - len
```
public LuaValue len()
```
    Length operator: return lua length of object (#this) including metatag processing as java int
    
    返回:
    
    length as defined by the lua # operator or metatag processing result
    
    抛出:
    
    LuaError - if this is not a table or string, and has no LEN metatag
  - length
```
public int length()
```
    Length operator: return lua length of object (#this) including metatag processing as java int
    
    返回:
    
    length as defined by the lua # operator or metatag processing result converted to java int using toint()
    
    抛出:
    
    LuaError - if this is not a table or string, and has no LEN metatag
  - rawlen
```
public int rawlen()
```
    Get raw length of table or string without metatag processing.
    
    返回:
    
    the length of the table or string.
    
    抛出:
    
    LuaError - if this is not a table or string.
  - equals
```
public boolean equals(Object obj)
```
    覆盖:
    
    equals 在类中 Object
  - eq
```
public LuaValue eq(LuaValue val)
```
    Equals: Perform equality comparison with another value including metatag processing using EQ.
    
    参数:
    
    val - The value to compare with.
    
    返回:
    
    TRUE if values are comparable and (this == rhs), FALSE if comparable but not equal, LuaValue if metatag processing occurs.
    
    另请参阅:
    
    eq_b(LuaValue), raweq(LuaValue), neq(LuaValue), eqmtcall(LuaValue, LuaValue, LuaValue, LuaValue), EQ
  - eq_b
```
public boolean eq_b(LuaValue val)
```
    Equals: Perform equality comparison with another value including metatag processing using EQ, and return java boolean
    
    参数:
    
    val - The value to compare with.
    
    返回:
    
    true if values are comparable and (this == rhs), false if comparable but not equal, result converted to java boolean if metatag processing occurs.
    
    另请参阅:
    
    eq(LuaValue), raweq(LuaValue), neq_b(LuaValue), eqmtcall(LuaValue, LuaValue, LuaValue, LuaValue), EQ
  - neq
```
public LuaValue neq(LuaValue val)
```
    Notquals: Perform inequality comparison with another value including metatag processing using EQ.
    
    参数:
    
    val - The value to compare with.
    
    返回:
    
    TRUE if values are comparable and (this != rhs), FALSE if comparable but equal, inverse of LuaValue converted to LuaBoolean if metatag processing occurs.
    
    另请参阅:
    
    eq(LuaValue), raweq(LuaValue), eqmtcall(LuaValue, LuaValue, LuaValue, LuaValue), EQ
  - neq_b
```
public boolean neq_b(LuaValue val)
```
    Notquals: Perform inequality comparison with another value including metatag processing using EQ.
    
    参数:
    
    val - The value to compare with.
    
    返回:
    
    true if values are comparable and (this != rhs), false if comparable but equal, inverse of result converted to boolean if metatag processing occurs.
    
    另请参阅:
    
    eq_b(LuaValue), raweq(LuaValue), eqmtcall(LuaValue, LuaValue, LuaValue, LuaValue), EQ
  - raweq
```
public boolean raweq(LuaValue val)
```
    Equals: Perform direct equality comparison with another value without metatag processing.
    
    参数:
    
    val - The value to compare with.
    
    返回:
    
    true if (this == rhs), false otherwise
    
    另请参阅:
    
    eq(LuaValue), raweq(LuaUserdata), raweq(LuaString), raweq(double), #raweq(int), EQ
  - raweq
```
public boolean raweq(LuaUserdata val)
```
    Equals: Perform direct equality comparison with a LuaUserdata value without metatag processing.
    
    参数:
    
    val - The LuaUserdata to compare with.
    
    返回:
    
    true if this is userdata and their metatables are the same using == and their instances are equal using equals(Object), otherwise false
    
    另请参阅:
    
    eq(LuaValue), raweq(LuaValue)
  - raweq
```
public boolean raweq(LuaString val)
```
    Equals: Perform direct equality comparison with a LuaString value without metatag processing.
    
    参数:
    
    val - The LuaString to compare with.
    
    返回:
    
    true if this is a LuaString and their byte sequences match, otherwise false
  - raweq
```
public boolean raweq(double val)
```
    Equals: Perform direct equality comparison with a double value without metatag processing.
    
    参数:
    
    val - The double value to compare with.
    
    返回:
    
    true if this is a LuaNumber whose value equals val, otherwise false
  - raweq
```
public boolean raweq(long val)
```
    Equals: Perform direct equality comparison with a int value without metatag processing.
    
    参数:
    
    val - The double value to compare with.
    
    返回:
    
    true if this is a LuaNumber whose value equals val, otherwise false
  - eqmtcall
```
public static final boolean eqmtcall(LuaValue lhs,
                                     LuaValue lhsmt,
                                     LuaValue rhs,
                                     LuaValue rhsmt)
```
    Perform equality testing metatag processing
    
    参数:
    
    lhs - left-hand-side of equality expression
    
    lhsmt - metatag value for left-hand-side
    
    rhs - right-hand-side of equality expression
    
    rhsmt - metatag value for right-hand-side
    
    返回:
    
    true if metatag processing result is not NIL or FALSE
    
    抛出:
    
    LuaError - if metatag was not defined for either operand
    
    另请参阅:
    
    equals(Object), eq(LuaValue), raweq(LuaValue), EQ
  - add
```
public LuaValue add(LuaValue rhs)
```
    Add: Perform numeric add operation with another value including metatag processing.
    Each operand must derive from LuaNumber or derive from LuaString and be convertible to a number
    
    参数:
    
    rhs - The right-hand-side value to perform the add with
    
    返回:
    
    value of (this + rhs) if both are numeric, or LuaValue if metatag processing occurs
    
    抛出:
    
    LuaError - if either operand is not a number or string convertible to number, and neither has the ADD metatag defined
    
    另请参阅:
    
    arithmt(LuaValue, LuaValue)
  - add
```
public LuaValue add(double rhs)
```
    Add: Perform numeric add operation with another value of double type with metatag processing
    this must derive from LuaNumber or derive from LuaString and be convertible to a number
    
    参数:
    
    rhs - The right-hand-side value to perform the add with
    
    返回:
    
    value of (this + rhs) if this is numeric
    
    抛出:
    
    LuaError - if this is not a number or string convertible to number
    
    另请参阅:
    
    add(LuaValue)
  - add
```
public LuaValue add(long rhs)
```
    Add: Perform numeric add operation with another value of int type with metatag processing
    this must derive from LuaNumber or derive from LuaString and be convertible to a number
    
    参数:
    
    rhs - The right-hand-side value to perform the add with
    
    返回:
    
    value of (this + rhs) if this is numeric
    
    抛出:
    
    LuaError - if this is not a number or string convertible to number
    
    另请参阅:
    
    add(LuaValue)
  - sub
```
public LuaValue sub(LuaValue rhs)
```
    Subtract: Perform numeric subtract operation with another value of unknown type, including metatag processing.
    Each operand must derive from LuaNumber or derive from LuaString and be convertible to a number
    
    参数:
    
    rhs - The right-hand-side value to perform the subtract with
    
    返回:
    
    value of (this - rhs) if both are numeric, or LuaValue if metatag processing occurs
    
    抛出:
    
    LuaError - if either operand is not a number or string convertible to number, and neither has the SUB metatag defined
    
    另请参阅:
    
    arithmt(LuaValue, LuaValue)
  - sub
```
public LuaValue sub(double rhs)
```
    Subtract: Perform numeric subtract operation with another value of double type with metatag processing
    this must derive from LuaNumber or derive from LuaString and be convertible to a number
    
    参数:
    
    rhs - The right-hand-side value to perform the subtract with
    
    返回:
    
    value of (this - rhs) if this is numeric
    
    抛出:
    
    LuaError - if this is not a number or string convertible to number
    
    另请参阅:
    
    sub(LuaValue)
  - sub
```
public LuaValue sub(long rhs)
```
    Subtract: Perform numeric subtract operation with another value of int type with metatag processing
    this must derive from LuaNumber or derive from LuaString and be convertible to a number
    
    参数:
    
    rhs - The right-hand-side value to perform the subtract with
    
    返回:
    
    value of (this - rhs) if this is numeric
    
    抛出:
    
    LuaError - if this is not a number or string convertible to number
    
    另请参阅:
    
    sub(LuaValue)
  - subFrom
```
public LuaValue subFrom(double lhs)
```
    Reverse-subtract: Perform numeric subtract operation from an int value with metatag processing
    this must derive from LuaNumber or derive from LuaString and be convertible to a number
    
    参数:
    
    lhs - The left-hand-side value from which to perform the subtraction
    
    返回:
    
    value of (lhs - this) if this is numeric
    
    抛出:
    
    LuaError - if this is not a number or string convertible to number
    
    另请参阅:
    
    sub(LuaValue), sub(double), #sub(int)
  - subFrom
```
public LuaValue subFrom(long lhs)
```
    Reverse-subtract: Perform numeric subtract operation from a double value without metatag processing
    this must derive from LuaNumber or derive from LuaString and be convertible to a number
    For metatag processing sub(LuaValue) must be used
    
    参数:
    
    lhs - The left-hand-side value from which to perform the subtraction
    
    返回:
    
    value of (lhs - this) if this is numeric
    
    抛出:
    
    LuaError - if this is not a number or string convertible to number
    
    另请参阅:
    
    sub(LuaValue), sub(double), #sub(int)
  - mul
```
public LuaValue mul(LuaValue rhs)
```
    Multiply: Perform numeric multiply operation with another value of unknown type, including metatag processing.
    Each operand must derive from LuaNumber or derive from LuaString and be convertible to a number
    
    参数:
    
    rhs - The right-hand-side value to perform the multiply with
    
    返回:
    
    value of (this * rhs) if both are numeric, or LuaValue if metatag processing occurs
    
    抛出:
    
    LuaError - if either operand is not a number or string convertible to number, and neither has the MUL metatag defined
    
    另请参阅:
    
    arithmt(LuaValue, LuaValue)
  - mul
```
public LuaValue mul(double rhs)
```
    Multiply: Perform numeric multiply operation with another value of double type with metatag processing
    this must derive from LuaNumber or derive from LuaString and be convertible to a number
    
    参数:
    
    rhs - The right-hand-side value to perform the multiply with
    
    返回:
    
    value of (this * rhs) if this is numeric
    
    抛出:
    
    LuaError - if this is not a number or string convertible to number
    
    另请参阅:
    
    mul(LuaValue)
  - mul
```
public LuaValue mul(long rhs)
```
    Multiply: Perform numeric multiply operation with another value of int type with metatag processing
    this must derive from LuaNumber or derive from LuaString and be convertible to a number
    
    参数:
    
    rhs - The right-hand-side value to perform the multiply with
    
    返回:
    
    value of (this * rhs) if this is numeric
    
    抛出:
    
    LuaError - if this is not a number or string convertible to number
    
    另请参阅:
    
    mul(LuaValue)
  - pow
```
public LuaValue pow(LuaValue rhs)
```
    Raise to power: Raise this value to a power including metatag processing.
    Each operand must derive from LuaNumber or derive from LuaString and be convertible to a number
    
    参数:
    
    rhs - The power to raise this value to
    
    返回:
    
    value of (this ^ rhs) if both are numeric, or LuaValue if metatag processing occurs
    
    抛出:
    
    LuaError - if either operand is not a number or string convertible to number, and neither has the POW metatag defined
    
    另请参阅:
    
    arithmt(LuaValue, LuaValue)
  - pow
```
public LuaValue pow(double rhs)
```
    Raise to power: Raise this value to a power of double type with metatag processing
    this must derive from LuaNumber or derive from LuaString and be convertible to a number
    
    参数:
    
    rhs - The power to raise this value to
    
    返回:
    
    value of (this ^ rhs) if this is numeric
    
    抛出:
    
    LuaError - if this is not a number or string convertible to number
    
    另请参阅:
    
    pow(LuaValue)
  - pow
```
public LuaValue pow(long rhs)
```
    Raise to power: Raise this value to a power of int type with metatag processing
    this must derive from LuaNumber or derive from LuaString and be convertible to a number
    
    参数:
    
    rhs - The power to raise this value to
    
    返回:
    
    value of (this ^ rhs) if this is numeric
    
    抛出:
    
    LuaError - if this is not a number or string convertible to number
    
    另请参阅:
    
    pow(LuaValue)
  - powWith
```
public LuaValue powWith(double lhs)
```
    Reverse-raise to power: Raise another value of double type to this power with metatag processing
    this must derive from LuaNumber or derive from LuaString and be convertible to a number
    
    参数:
    
    lhs - The left-hand-side value which will be raised to this power
    
    返回:
    
    value of (lhs ^ this) if this is numeric
    
    抛出:
    
    LuaError - if this is not a number or string convertible to number
    
    另请参阅:
    
    pow(LuaValue), pow(double), #pow(int)
  - powWith
```
public LuaValue powWith(long lhs)
```
    Reverse-raise to power: Raise another value of double type to this power with metatag processing
    this must derive from LuaNumber or derive from LuaString and be convertible to a number
    
    参数:
    
    lhs - The left-hand-side value which will be raised to this power
    
    返回:
    
    value of (lhs ^ this) if this is numeric
    
    抛出:
    
    LuaError - if this is not a number or string convertible to number
    
    另请参阅:
    
    pow(LuaValue), pow(double), #pow(int)
  - div
```
public LuaValue div(LuaValue rhs)
```
    Divide: Perform numeric divide operation by another value of unknown type, including metatag processing.
    Each operand must derive from LuaNumber or derive from LuaString and be convertible to a number
    
    参数:
    
    rhs - The right-hand-side value to perform the divulo with
    
    返回:
    
    value of (this / rhs) if both are numeric, or LuaValue if metatag processing occurs
    
    抛出:
    
    LuaError - if either operand is not a number or string convertible to number, and neither has the DIV metatag defined
    
    另请参阅:
    
    arithmt(LuaValue, LuaValue)
  - div
```
public LuaValue div(double rhs)
```
    Divide: Perform numeric divide operation by another value of double type without metatag processing
    this must derive from LuaNumber or derive from LuaString and be convertible to a number
    For metatag processing div(LuaValue) must be used
    
    参数:
    
    rhs - The right-hand-side value to perform the divulo with
    
    返回:
    
    value of (this / rhs) if this is numeric
    
    抛出:
    
    LuaError - if this is not a number or string convertible to number
    
    另请参阅:
    
    div(LuaValue)
  - div
```
public LuaValue div(long rhs)
```
    Divide: Perform numeric divide operation by another value of int type without metatag processing
    this must derive from LuaNumber or derive from LuaString and be convertible to a number
    For metatag processing div(LuaValue) must be used
    
    参数:
    
    rhs - The right-hand-side value to perform the divulo with
    
    返回:
    
    value of (this / rhs) if this is numeric
    
    抛出:
    
    LuaError - if this is not a number or string convertible to number
    
    另请参阅:
    
    div(LuaValue)
  - divInto
```
public LuaValue divInto(double lhs)
```
    Reverse-divide: Perform numeric divide operation into another value with metatag processing
    this must derive from LuaNumber or derive from LuaString and be convertible to a number
    
    参数:
    
    lhs - The left-hand-side value which will be divided by this
    
    返回:
    
    value of (lhs / this) if this is numeric
    
    抛出:
    
    LuaError - if this is not a number or string convertible to number
    
    另请参阅:
    
    div(LuaValue), div(double), #div(int)
  - mod
```
public LuaValue mod(LuaValue rhs)
```
    Modulo: Perform numeric modulo operation with another value of unknown type, including metatag processing.
    Each operand must derive from LuaNumber or derive from LuaString and be convertible to a number
    
    参数:
    
    rhs - The right-hand-side value to perform the modulo with
    
    返回:
    
    value of (this % rhs) if both are numeric, or LuaValue if metatag processing occurs
    
    抛出:
    
    LuaError - if either operand is not a number or string convertible to number, and neither has the MOD metatag defined
    
    另请参阅:
    
    arithmt(LuaValue, LuaValue)
  - mod
```
public LuaValue mod(double rhs)
```
    Modulo: Perform numeric modulo operation with another value of double type without metatag processing
    this must derive from LuaNumber or derive from LuaString and be convertible to a number
    For metatag processing mod(LuaValue) must be used
    
    参数:
    
    rhs - The right-hand-side value to perform the modulo with
    
    返回:
    
    value of (this % rhs) if this is numeric
    
    抛出:
    
    LuaError - if this is not a number or string convertible to number
    
    另请参阅:
    
    mod(LuaValue)
  - mod
```
public LuaValue mod(long rhs)
```
    Modulo: Perform numeric modulo operation with another value of int type without metatag processing
    this must derive from LuaNumber or derive from LuaString and be convertible to a number
    For metatag processing mod(LuaValue) must be used
    
    参数:
    
    rhs - The right-hand-side value to perform the modulo with
    
    返回:
    
    value of (this % rhs) if this is numeric
    
    抛出:
    
    LuaError - if this is not a number or string convertible to number
    
    另请参阅:
    
    mod(LuaValue)
  - modFrom
```
public LuaValue modFrom(double lhs)
```
    Reverse-modulo: Perform numeric modulo operation from another value with metatag processing
    this must derive from LuaNumber or derive from LuaString and be convertible to a number
    
    参数:
    
    lhs - The left-hand-side value which will be modulo'ed by this
    
    返回:
    
    value of (lhs % this) if this is numeric
    
    抛出:
    
    LuaError - if this is not a number or string convertible to number
    
    另请参阅:
    
    mod(LuaValue), mod(double), #mod(int)
  - arithmt
```
protected LuaValue arithmt(LuaValue tag,
                           LuaValue op2)
```
    Perform metatag processing for arithmetic operations.
    Finds the supplied metatag value for this or op2 and invokes it, or throws LuaError if neither is defined.
    
    参数:
    
    tag - The metatag to look up
    
    op2 - The other operand value to perform the operation with
    
    返回:
    
    LuaValue resulting from metatag processing
    
    抛出:
    
    LuaError - if metatag was not defined for either operand
    
    另请参阅:
    
    add(LuaValue), sub(LuaValue), mul(LuaValue), pow(LuaValue), div(LuaValue), mod(LuaValue), ADD, SUB, MUL, POW, DIV, MOD
  - arithmtwith
```
protected LuaValue arithmtwith(LuaValue tag,
                               double op1)
```
    Perform metatag processing for arithmetic operations when the left-hand-side is a number.
    Finds the supplied metatag value for this and invokes it, or throws LuaError if neither is defined.
    
    参数:
    
    tag - The metatag to look up
    
    op1 - The value of the left-hand-side to perform the operation with
    
    返回:
    
    LuaValue resulting from metatag processing
    
    抛出:
    
    LuaError - if metatag was not defined for either operand
    
    另请参阅:
    
    add(LuaValue), sub(LuaValue), mul(LuaValue), pow(LuaValue), div(LuaValue), mod(LuaValue), ADD, SUB, MUL, POW, DIV, MOD
  - lt
```
public LuaValue lt(LuaValue rhs)
```
    Less than: Perform numeric or string comparison with another value of unknown type, including metatag processing, and returning LuaValue.
    To be comparable, both operands must derive from LuaString or both must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    TRUE if (this < rhs), FALSE if not, or LuaValue if metatag processing occurs
    
    抛出:
    
    LuaError - if either both operands are not a strings or both are not numbers and no LT metatag is defined.
    
    另请参阅:
    
    gteq_b(LuaValue), comparemt(LuaValue, LuaValue)
  - lt
```
public LuaValue lt(double rhs)
```
    Less than: Perform numeric comparison with another value of double type, including metatag processing, and returning LuaValue.
    To be comparable, this must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    TRUE if (this < rhs), FALSE if not, or LuaValue if metatag processing occurs
    
    抛出:
    
    LuaError - if this is not a number and no LT metatag is defined.
    
    另请参阅:
    
    gteq_b(double), comparemt(LuaValue, LuaValue)
  - lt
```
public LuaValue lt(long rhs)
```
    Less than: Perform numeric comparison with another value of int type, including metatag processing, and returning LuaValue.
    To be comparable, this must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    TRUE if (this < rhs), FALSE if not, or LuaValue if metatag processing occurs
    
    抛出:
    
    LuaError - if this is not a number and no LT metatag is defined.
    
    另请参阅:
    
    #gteq_b(int), comparemt(LuaValue, LuaValue)
  - lt_b
```
public boolean lt_b(LuaValue rhs)
```
    Less than: Perform numeric or string comparison with another value of unknown type, including metatag processing, and returning java boolean.
    To be comparable, both operands must derive from LuaString or both must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    true if (this < rhs), false if not, and boolean interpreation of result if metatag processing occurs.
    
    抛出:
    
    LuaError - if either both operands are not a strings or both are not numbers and no LT metatag is defined.
    
    另请参阅:
    
    gteq(LuaValue), comparemt(LuaValue, LuaValue)
  - lt_b
```
public boolean lt_b(long rhs)
```
    Less than: Perform numeric comparison with another value of int type, including metatag processing, and returning java boolean.
    To be comparable, this must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    true if (this < rhs), false if not, and boolean interpreation of result if metatag processing occurs.
    
    抛出:
    
    LuaError - if this is not a number and no LT metatag is defined.
    
    另请参阅:
    
    #gteq(int), comparemt(LuaValue, LuaValue)
  - lt_b
```
public boolean lt_b(double rhs)
```
    Less than: Perform numeric or string comparison with another value of unknown type, including metatag processing, and returning java boolean.
    To be comparable, both operands must derive from LuaString or both must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    true if (this < rhs), false if not, and boolean interpreation of result if metatag processing occurs.
    
    抛出:
    
    LuaError - if either both operands are not a strings or both are not numbers and no LT metatag is defined.
    
    另请参阅:
    
    gteq(LuaValue), comparemt(LuaValue, LuaValue)
  - lteq
```
public 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.
    To be comparable, both operands must derive from LuaString or both must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    TRUE if (this <= rhs), FALSE if not, or LuaValue if metatag processing occurs
    
    抛出:
    
    LuaError - if either both operands are not a strings or both are not numbers and no LE metatag is defined.
    
    另请参阅:
    
    gteq_b(LuaValue), comparemt(LuaValue, LuaValue)
  - lteq
```
public LuaValue lteq(double rhs)
```
    Less than or equals: Perform numeric comparison with another value of double type, including metatag processing, and returning LuaValue.
    To be comparable, this must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    TRUE if (this <= rhs), FALSE if not, or LuaValue if metatag processing occurs
    
    抛出:
    
    LuaError - if this is not a number and no LE metatag is defined.
    
    另请参阅:
    
    gteq_b(double), comparemt(LuaValue, LuaValue)
  - lteq
```
public LuaValue lteq(long rhs)
```
    Less than or equals: Perform numeric comparison with another value of int type, including metatag processing, and returning LuaValue.
    To be comparable, this must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    TRUE if (this <= rhs), FALSE if not, or LuaValue if metatag processing occurs
    
    抛出:
    
    LuaError - if this is not a number and no LE metatag is defined.
    
    另请参阅:
    
    #gteq_b(int), comparemt(LuaValue, LuaValue)
  - lteq_b
```
public boolean 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.
    To be comparable, both operands must derive from LuaString or both must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    true if (this <= rhs), false if not, and boolean interpreation of result if metatag processing occurs.
    
    抛出:
    
    LuaError - if either both operands are not a strings or both are not numbers and no LE metatag is defined.
    
    另请参阅:
    
    gteq(LuaValue), comparemt(LuaValue, LuaValue)
  - lteq_b
```
public boolean lteq_b(long rhs)
```
    Less than or equals: Perform numeric comparison with another value of int type, including metatag processing, and returning java boolean.
    To be comparable, this must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    true if (this <= rhs), false if not, and boolean interpreation of result if metatag processing occurs.
    
    抛出:
    
    LuaError - if this is not a number and no LE metatag is defined.
    
    另请参阅:
    
    #gteq(int), comparemt(LuaValue, LuaValue)
  - lteq_b
```
public boolean lteq_b(double rhs)
```
    Less than or equals: Perform numeric comparison with another value of double type, including metatag processing, and returning java boolean.
    To be comparable, this must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    true if (this <= rhs), false if not, and boolean interpreation of result if metatag processing occurs.
    
    抛出:
    
    LuaError - if this is not a number and no LE metatag is defined.
    
    另请参阅:
    
    gteq(double), comparemt(LuaValue, LuaValue)
  - gt
```
public LuaValue gt(LuaValue rhs)
```
    Greater than: Perform numeric or string comparison with another value of unknown type, including metatag processing, and returning LuaValue.
    To be comparable, both operands must derive from LuaString or both must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    TRUE if (this > rhs), FALSE if not, or LuaValue if metatag processing occurs
    
    抛出:
    
    LuaError - if either both operands are not a strings or both are not numbers and no LE metatag is defined.
    
    另请参阅:
    
    gteq_b(LuaValue), comparemt(LuaValue, LuaValue)
  - gt
```
public LuaValue gt(double rhs)
```
    Greater than: Perform numeric comparison with another value of double type, including metatag processing, and returning LuaValue.
    To be comparable, this must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    TRUE if (this > rhs), FALSE if not, or LuaValue if metatag processing occurs
    
    抛出:
    
    LuaError - if this is not a number and no LE metatag is defined.
    
    另请参阅:
    
    gteq_b(double), comparemt(LuaValue, LuaValue)
  - gt
```
public LuaValue gt(long rhs)
```
    Greater than: Perform numeric comparison with another value of int type, including metatag processing, and returning LuaValue.
    To be comparable, this must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    TRUE if (this > rhs), FALSE if not, or LuaValue if metatag processing occurs
    
    抛出:
    
    LuaError - if this is not a number and no LE metatag is defined.
    
    另请参阅:
    
    #gteq_b(int), comparemt(LuaValue, LuaValue)
  - gt_b
```
public boolean gt_b(LuaValue rhs)
```
    Greater than: Perform numeric or string comparison with another value of unknown type, including metatag processing, and returning java boolean.
    To be comparable, both operands must derive from LuaString or both must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    true if (this > rhs), false if not, and boolean interpreation of result if metatag processing occurs.
    
    抛出:
    
    LuaError - if either both operands are not a strings or both are not numbers and no LE metatag is defined.
    
    另请参阅:
    
    gteq(LuaValue), comparemt(LuaValue, LuaValue)
  - gt_b
```
public boolean gt_b(long rhs)
```
    Greater than: Perform numeric comparison with another value of int type, including metatag processing, and returning java boolean.
    To be comparable, this must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    true if (this > rhs), false if not, and boolean interpreation of result if metatag processing occurs.
    
    抛出:
    
    LuaError - if this is not a number and no LE metatag is defined.
    
    另请参阅:
    
    #gteq(int), comparemt(LuaValue, LuaValue)
  - gt_b
```
public boolean gt_b(double rhs)
```
    Greater than: Perform numeric or string comparison with another value of unknown type, including metatag processing, and returning java boolean.
    To be comparable, both operands must derive from LuaString or both must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    true if (this > rhs), false if not, and boolean interpreation of result if metatag processing occurs.
    
    抛出:
    
    LuaError - if either both operands are not a strings or both are not numbers and no LE metatag is defined.
    
    另请参阅:
    
    gteq(LuaValue), comparemt(LuaValue, LuaValue)
  - gteq
```
public 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.
    To be comparable, both operands must derive from LuaString or both must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    TRUE if (this >= rhs), FALSE if not, or LuaValue if metatag processing occurs
    
    抛出:
    
    LuaError - if either both operands are not a strings or both are not numbers and no LT metatag is defined.
    
    另请参阅:
    
    gteq_b(LuaValue), comparemt(LuaValue, LuaValue)
  - gteq
```
public LuaValue gteq(double rhs)
```
    Greater than or equals: Perform numeric comparison with another value of double type, including metatag processing, and returning LuaValue.
    To be comparable, this must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    TRUE if (this >= rhs), FALSE if not, or LuaValue if metatag processing occurs
    
    抛出:
    
    LuaError - if this is not a number and no LT metatag is defined.
    
    另请参阅:
    
    gteq_b(double), comparemt(LuaValue, LuaValue)
  - gteq
```
public LuaValue gteq(long rhs)
```
    Greater than or equals: Perform numeric comparison with another value of int type, including metatag processing, and returning LuaValue.
    To be comparable, this must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    TRUE if (this >= rhs), FALSE if not, or LuaValue if metatag processing occurs
    
    抛出:
    
    LuaError - if this is not a number and no LT metatag is defined.
    
    另请参阅:
    
    #gteq_b(int), comparemt(LuaValue, LuaValue)
  - gteq_b
```
public boolean 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.
    To be comparable, both operands must derive from LuaString or both must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    true if (this >= rhs), false if not, and boolean interpreation of result if metatag processing occurs.
    
    抛出:
    
    LuaError - if either both operands are not a strings or both are not numbers and no LT metatag is defined.
    
    另请参阅:
    
    gteq(LuaValue), comparemt(LuaValue, LuaValue)
  - gteq_b
```
public boolean gteq_b(long rhs)
```
    Greater than or equals: Perform numeric comparison with another value of int type, including metatag processing, and returning java boolean.
    To be comparable, this must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    true if (this >= rhs), false if not, and boolean interpreation of result if metatag processing occurs.
    
    抛出:
    
    LuaError - if this is not a number and no LT metatag is defined.
    
    另请参阅:
    
    #gteq(int), comparemt(LuaValue, LuaValue)
  - gteq_b
```
public boolean gteq_b(double rhs)
```
    Greater than or equals: Perform numeric comparison with another value of double type, including metatag processing, and returning java boolean.
    To be comparable, this must derive from LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    true if (this >= rhs), false if not, and boolean interpreation of result if metatag processing occurs.
    
    抛出:
    
    LuaError - if this is not a number and no LT metatag is defined.
    
    另请参阅:
    
    gteq(double), comparemt(LuaValue, LuaValue)
  - comparemt
```
public LuaValue comparemt(LuaValue tag,
                          LuaValue op1)
```
    Perform metatag processing for comparison operations.
    Finds the supplied metatag value and invokes it, or throws LuaError if none applies.
    
    参数:
    
    tag - The metatag to look up
    
    op1 - The operand with which to to perform the operation
    
    返回:
    
    LuaValue resulting from metatag processing
    
    抛出:
    
    LuaError - if metatag was not defined for either operand, or if the operands are not the same type, or the metatag values for the two operands are different.
    
    另请参阅:
    
    gt(LuaValue), gteq(LuaValue), lt(LuaValue), lteq(LuaValue)
  - strcmp
```
public int strcmp(LuaValue rhs)
```
    Perform string comparison with another value of any type using string comparison based on byte values.
    Only strings can be compared, meaning each operand must derive from LuaString.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    int < 0 for (this < rhs), int > 0 for (this > rhs), or 0 when same string.
    
    抛出:
    
    LuaError - if either operand is not a string
  - strcmp
```
public int strcmp(LuaString rhs)
```
    Perform string comparison with another value known to be a LuaString using string comparison based on byte values.
    Only strings can be compared, meaning each operand must derive from LuaString.
    
    参数:
    
    rhs - The right-hand-side value to perform the comparison with
    
    返回:
    
    int < 0 for (this < rhs), int > 0 for (this > rhs), or 0 when same string.
    
    抛出:
    
    LuaError - if this is not a string
  - concat
```
public LuaValue concat(LuaValue rhs)
```
    Concatenate another value onto this value and return the result using rules of lua string concatenation including metatag processing.
    Only strings and numbers as represented can be concatenated, meaning each operand must derive from LuaString or LuaNumber.
    
    参数:
    
    rhs - The right-hand-side value to perform the operation with
    
    返回:
    
    LuaValue resulting from concatenation of (this .. rhs)
    
    抛出:
    
    LuaError - if either operand is not of an appropriate type, such as nil or a table
  - concatTo
```
public 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.
    Only strings and numbers as represented can be concatenated, meaning each operand must derive from LuaString or LuaNumber.
    
    参数:
    
    lhs - The left-hand-side value onto which this will be concatenated
    
    返回:
    
    LuaValue resulting from concatenation of (lhs .. this)
    
    抛出:
    
    LuaError - if either operand is not of an appropriate type, such as nil or a table
    
    另请参阅:
    
    concat(LuaValue)
  - concatTo
```
public 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.
    Only strings and numbers as represented can be concatenated, meaning each operand must derive from LuaString or LuaNumber.
    
    参数:
    
    lhs - The left-hand-side value onto which this will be concatenated
    
    返回:
    
    LuaValue resulting from concatenation of (lhs .. this)
    
    抛出:
    
    LuaError - if either operand is not of an appropriate type, such as nil or a table
    
    另请参阅:
    
    concat(LuaValue)
  - concatTo
```
public 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.
    Only strings and numbers as represented can be concatenated, meaning each operand must derive from LuaString or LuaNumber.
    
    参数:
    
    lhs - The left-hand-side value onto which this will be concatenated
    
    返回:
    
    LuaValue resulting from concatenation of (lhs .. this)
    
    抛出:
    
    LuaError - if either operand is not of an appropriate type, such as nil or a table
    
    另请参阅:
    
    concat(LuaValue)
  - buffer
```
public Buffer buffer()
```
    Convert the value to a Buffer for more efficient concatenation of multiple strings.
    
    返回:
    
    Buffer instance containing the string or number
  - concat
```
public Buffer concat(Buffer rhs)
```
    Concatenate a Buffer onto this value and return the result using rules of lua string concatenation including metatag processing.
    Only strings and numbers as represented can be concatenated, meaning each operand must derive from LuaString or LuaNumber.
    
    参数:
    
    rhs - The right-hand-side Buffer to perform the operation with
    
    返回:
    
    LuaString resulting from concatenation of (this .. rhs)
    
    抛出:
    
    LuaError - if either operand is not of an appropriate type, such as nil or a table
  - concatmt
```
public LuaValue concatmt(LuaValue rhs)
```
    Perform metatag processing for concatenation operations.
    Finds the CONCAT metatag value and invokes it, or throws LuaError if it doesn't exist.
    
    参数:
    
    rhs - The right-hand-side value to perform the operation with
    
    返回:
    
    LuaValue resulting from metatag processing for CONCAT metatag.
    
    抛出:
    
    LuaError - if metatag was not defined for either operand
  - and
```
public LuaValue and(LuaValue rhs)
```
    Perform boolean and with another operand, based on lua rules for boolean evaluation. This returns either this or rhs depending on the boolean value for this.
    
    参数:
    
    rhs - The right-hand-side value to perform the operation with
    
    返回:
    
    this if this.toboolean() is false, rhs otherwise.
  - or
```
public LuaValue or(LuaValue rhs)
```
    Perform boolean or with another operand, based on lua rules for boolean evaluation. This returns either this or rhs depending on the boolean value for this.
    
    参数:
    
    rhs - The right-hand-side value to perform the operation with
    
    返回:
    
    this if this.toboolean() is true, rhs otherwise.
  - testfor_b
```
public boolean testfor_b(LuaValue limit,
                         LuaValue step)
```
    Perform end-condition test in for-loop processing.
    Used in lua-bytecode to Java-bytecode conversion.
    
    参数:
    
    limit - the numerical limit to complete the for loop
    
    step - the numberical step size to use.
    
    返回:
    
    true if limit has not been reached, false otherwise.
  - strvalue
```
public LuaString strvalue()
```
    Convert this value to a string if it is a LuaString or LuaNumber, or throw a LuaError if it is not
    
    返回:
    
    LuaString corresponding to the value if a string or number
    
    抛出:
    
    LuaError - if not a string or number
  - strongvalue
```
public LuaValue strongvalue()
```
    Return this value as a strong reference, or null if it was weak and is no longer referenced.
    
    返回:
    
    LuaValue referred to, or null if it was weak and is no longer referenced.
    
    另请参阅:
    
    WeakTable
  - valueOf
```
public static LuaBoolean valueOf(boolean b)
```
    Convert java boolean to a LuaValue.
    
    参数:
    
    b - boolean value to convert
    
    返回:
    
    TRUE if not or FALSE if false
  - valueOf
```
public static LuaInteger valueOf(int i)
```
    Convert java int to a LuaValue.
    
    参数:
    
    i - int value to convert
    
    返回:
    
    LuaInteger instance, possibly pooled, whose value is i
  - valueOf
```
public static LuaNumber valueOf(long i)
```
  - valueOf
```
public static LuaNumber valueOf(double d)
```
    Convert java double to a LuaValue. This may return a LuaInteger or LuaDouble depending on the value supplied.
    
    参数:
    
    d - double value to convert
    
    返回:
    
    LuaNumber instance, possibly pooled, whose value is d
  - valueOf
```
public static LuaString valueOf(String s)
```
    Convert java string to a LuaValue.
    
    参数:
    
    s - String value to convert
    
    返回:
    
    LuaString instance, possibly pooled, whose value is s
  - valueOf
```
public static LuaString valueOf(byte[] bytes)
```
    Convert bytes in an array to a LuaValue.
    
    参数:
    
    bytes - byte array to convert
    
    返回:
    
    LuaString instance, possibly pooled, whose bytes are those in the supplied array
  - valueOf
```
public static LuaString valueOf(byte[] bytes,
                                int off,
                                int len)
```
    Convert bytes in an array to a LuaValue.
    
    参数:
    
    bytes - byte array to convert
    
    off - offset into the byte array, starting at 0
    
    len - number of bytes to include in the LuaString
    
    返回:
    
    LuaString instance, possibly pooled, whose bytes are those in the supplied array
  - tableOf
```
public static LuaTable tableOf()
```
    Construct an empty LuaTable.
    
    返回:
    
    new LuaTable instance with no values and no metatable.
  - tableOf
```
public static LuaTable tableOf(Varargs varargs,
                               int firstarg)
```
    Construct a LuaTable initialized with supplied array values.
    
    参数:
    
    varargs - Varargs containing the values to use in initialization
    
    firstarg - the index of the first argument to use from the varargs, 1 being the first.
    
    返回:
    
    new LuaTable instance with sequential elements coming from the varargs.
  - tableOf
```
public static LuaTable tableOf(int narray,
                               int nhash)
```
    Construct an empty LuaTable preallocated to hold array and hashed elements
    
    参数:
    
    narray - Number of array elements to preallocate
    
    nhash - Number of hash elements to preallocate
    
    返回:
    
    new LuaTable instance with no values and no metatable, but preallocated for array and hashed elements.
  - listOf
```
public static LuaTable listOf(LuaValue[] unnamedValues)
```
    Construct a LuaTable initialized with supplied array values.
    
    参数:
    
    unnamedValues - array of LuaValue containing the values to use in initialization
    
    返回:
    
    new LuaTable instance with sequential elements coming from the array.
  - listOf
```
public static LuaTable listOf(LuaValue[] unnamedValues,
                              Varargs lastarg)
```
    Construct a LuaTable initialized with supplied array values.
    
    参数:
    
    unnamedValues - array of LuaValue containing the first values to use in initialization
    
    lastarg - Varargs containing additional values to use in initialization to be put after the last unnamedValues element
    
    返回:
    
    new LuaTable instance with sequential elements coming from the array and varargs.
  - tableOf
```
public static LuaTable tableOf(LuaValue[] namedValues)
```
    Construct a LuaTable initialized with supplied named values.
    
    参数:
    
    namedValues - array of LuaValue containing the keys and values to use in initialization in order {key-a, value-a, key-b, value-b, ...}
    
    返回:
    
    new LuaTable instance with non-sequential keys coming from the supplied array.
  - tableOf
```
public static LuaTable tableOf(LuaValue[] namedValues,
                               LuaValue[] unnamedValues)
```
    Construct a LuaTable initialized with supplied named values and sequential elements. The named values will be assigned first, and the sequential elements will be assigned later, possibly overwriting named values at the same slot if there are conflicts.
    
    参数:
    
    namedValues - array of LuaValue containing the keys and values to use in initialization in order {key-a, value-a, key-b, value-b, ...}
    
    unnamedValues - array of LuaValue containing the sequenctial elements to use in initialization in order {value-1, value-2, ...} , or null if there are none
    
    返回:
    
    new LuaTable instance with named and sequential values supplied.
  - tableOf
```
public static LuaTable 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. The named values will be assigned first, and the sequential elements will be assigned later, possibly overwriting named values at the same slot if there are conflicts.
    
    参数:
    
    namedValues - array of LuaValue containing the keys and values to use in initialization in order {key-a, value-a, key-b, value-b, ...}
    
    unnamedValues - array of LuaValue containing the first sequenctial elements to use in initialization in order {value-1, value-2, ...} , or null if there are none
    
    lastarg - Varargs containing additional values to use in the sequential part of the initialization, to be put after the last unnamedValues element
    
    返回:
    
    new LuaTable instance with named and sequential values supplied.
  - userdataOf
```
public static LuaUserdata userdataOf(Object o)
```
    Construct a LuaUserdata for an object.
    
    参数:
    
    o - The java instance to be wrapped as userdata
    
    返回:
    
    LuaUserdata value wrapping the java instance.
  - userdataOf
```
public static LuaUserdata userdataOf(Object o,
                                     LuaValue metatable)
```
    Construct a LuaUserdata for an object with a user supplied metatable.
    
    参数:
    
    o - The java instance to be wrapped as userdata
    
    metatable - The metatble to associate with the userdata instance.
    
    返回:
    
    LuaUserdata value wrapping the java instance.
  - gettable
```
protected static LuaValue gettable(LuaValue t,
                                   LuaValue key)
```
    get value from metatable operations, or NIL if not defined by metatables
  - settable
```
protected static boolean settable(LuaValue t,
                                  LuaValue key,
                                  LuaValue value)
```
    Perform field assignment including metatag processing.
    
    参数:
    
    t - LuaValue on which value is being set, typically a table or something with the metatag NEWINDEX defined
    
    key - LuaValue naming the field to assign
    
    value - LuaValue the new value to assign to key
    
    返回:
    
    true if assignment or metatag processing succeeded, false otherwise
    
    抛出:
    
    LuaError - if there is a loop in metatag processing
  - metatag
```
public LuaValue metatag(LuaValue tag)
```
    Get particular metatag, or return NIL if it doesn't exist
    
    参数:
    
    tag - Metatag name to look up, typically a string such as INDEX or NEWINDEX
    
    返回:
    
    LuaValue for tag reason, or NIL
  - checkmetatag
```
protected LuaValue checkmetatag(LuaValue tag,
                                String reason)
```
    Get particular metatag, or throw LuaError if it doesn't exist
    
    参数:
    
    tag - Metatag name to look up, typically a string such as INDEX or NEWINDEX
    
    reason - Description of error when tag lookup fails.
    
    返回:
    
    LuaValue that can be called
    
    抛出:
    
    LuaError - when the lookup fails.
  - metatableOf
```
protected static org.luaj.vm2.Metatable metatableOf(LuaValue mt)
```
    Construct a Metatable instance from the given LuaValue
  - varargsOf
```
public static Varargs varargsOf(LuaValue[] v)
```
    Construct a Varargs around an array of LuaValues.
    
    参数:
    
    v - The array of LuaValues
    
    返回:
    
    Varargs wrapping the supplied values.
    
    另请参阅:
    
    varargsOf(LuaValue, Varargs), varargsOf(LuaValue[], int, int)
  - varargsOf
```
public static Varargs varargsOf(LuaValue[] v,
                                Varargs r)
```
    Construct a Varargs around an array of LuaValues.
    
    参数:
    
    v - The array of LuaValues
    
    r - Varargs contain values to include at the end
    
    返回:
    
    Varargs wrapping the supplied values.
    
    另请参阅:
    
    varargsOf(LuaValue[]), varargsOf(LuaValue[], int, int, Varargs)
  - varargsOf
```
public static Varargs varargsOf(LuaValue[] v,
                                int offset,
                                int length)
```
    Construct a Varargs around an array of LuaValues.
    
    参数:
    
    v - The array of LuaValues
    
    offset - number of initial values to skip in the array
    
    length - number of values to include from the array
    
    返回:
    
    Varargs wrapping the supplied values.
    
    另请参阅:
    
    varargsOf(LuaValue[]), varargsOf(LuaValue[], int, int, Varargs)
  - varargsOf
```
public static Varargs varargsOf(LuaValue[] v,
                                int offset,
                                int length,
                                Varargs more)
```
    Construct a Varargs around an array of LuaValues. Caller must ensure that array contents are not mutated after this call or undefined behavior will result.
    
    参数:
    
    v - The array of LuaValues
    
    offset - number of initial values to skip in the array
    
    length - number of values to include from the array
    
    more - Varargs contain values to include at the end
    
    返回:
    
    Varargs wrapping the supplied values.
    
    另请参阅:
    
    varargsOf(LuaValue[], Varargs), varargsOf(LuaValue[], int, int)
  - varargsOf
```
public static Varargs varargsOf(LuaValue v,
                                Varargs r)
```
    Construct a Varargs around a set of 2 or more LuaValues.
    This can be used to wrap exactly 2 values, or a list consisting of 1 initial value followed by another variable list of remaining values.
    
    参数:
    
    v - First LuaValue in the Varargs
    
    r - LuaValue supplying the 2rd value, or Varargss supplying all values beyond the first
    
    返回:
    
    Varargs wrapping the supplied values.
  - varargsOf
```
public static Varargs varargsOf(LuaValue v1,
                                LuaValue v2,
                                Varargs v3)
```
    Construct a Varargs around a set of 3 or more LuaValues.
    This can be used to wrap exactly 3 values, or a list consisting of 2 initial values followed by another variable list of remaining values.
    
    参数:
    
    v1 - First LuaValue in the Varargs
    
    v2 - Second LuaValue in the Varargs
    
    v3 - LuaValue supplying the 3rd value, or Varargss supplying all values beyond the second
    
    返回:
    
    Varargs wrapping the supplied values.
  - tailcallOf
```
public static Varargs tailcallOf(LuaValue func,
                                 Varargs args)
```
    Construct a TailcallVarargs around a function and arguments.
    The tail call is not yet called or processing until the client invokes TailcallVarargs.eval() which performs the tail call processing.
    This method is typically not used directly by client code. Instead use one of the function invocation methods.
    
    参数:
    
    func - LuaValue to be called as a tail call
    
    args - Varargs containing the arguments to the call
    
    返回:
    
    TailcallVarargs to be used in tailcall oprocessing.
    
    另请参阅:
    
    call(), invoke(), method(LuaValue), invokemethod(LuaValue)
  - onInvoke
```
public Varargs onInvoke(Varargs args)
```
    Callback used during tail call processing to invoke the function once.
    This may return a TailcallVarargs to be evaluated by the client.
    This should not be called directly, instead use one of the call invocation functions.
    
    参数:
    
    args - the arguments to the call invocation.
    
    返回:
    
    Varargs the return values, possible a TailcallVarargs.
    
    另请参阅:
    
    call(), invoke(), method(LuaValue), invokemethod(LuaValue)
  - initupvalue1
```
public void initupvalue1(LuaValue env)
```
    Hook for implementations such as LuaJC to load the environment of the main chunk into the first upvalue location. If the function has no upvalues or is not a main chunk, calling this will be no effect.
    
    参数:
    
    env - The environment to load into the first upvalue, if there is one.
  - setuservalue
```
public void setuservalue(LuaValue uservalue)
```
  - getuservalue
```
public LuaValue getuservalue()
```
  - idiv
```
public LuaValue idiv(LuaValue rhs)
```
  - idiv
```
public LuaValue idiv(long rhs)
```
  - band
```
public LuaValue band(LuaValue rhs)
```
  - band
```
public LuaValue band(long rhs)
```
  - bor
```
public LuaValue bor(LuaValue rhs)
```
  - bor
```
public LuaValue bor(long rhs)
```
  - bxor
```
public LuaValue bxor(LuaValue rhs)
```
  - bxor
```
public LuaValue bxor(long rhs)
```
  - shl
```
public LuaValue shl(LuaValue rhs)
```
  - shl
```
public LuaValue shl(long rhs)
```
  - shr
```
public LuaValue shr(LuaValue rhs)
```
  - shr
```
public LuaValue shr(long rhs)
```
  - bnot
```
public LuaValue bnot()
```
  - setfenv
```
public void setfenv(LuaValue env)
```
  - getfenv
```
public LuaValue getfenv()
```
  - jcall
```
public Object jcall(Object... args)
```
  - jset
```
public void jset(String key,
                 Object value)
```
  - jget
```
public Object jget(String key)
```
  - subargs
```
public Varargs subargs(int start)
```
    Create a Varargs instance containing arguments starting at index start
    
    指定者:
    
    subargs 在类中 Varargs
    
    参数:
    
    start - the index from which to include arguments, where 1 is the first argument.
    
    返回:
    
    Varargs containing argument { start, start+1, ... , narg-start-1 }

类 LuaValue

字段概要

构造器概要

方法概要

从类继承的方法 org.luaj.vm2.Varargs

从类继承的方法 java.lang.Object

字段详细资料

TINT

TNONE

TNIL

TBOOLEAN

TLIGHTUSERDATA

TNUMBER

TSTRING

TTABLE

TFUNCTION

TUSERDATA

TTHREAD

TVALUE

TYPE_NAMES

NIL

TRUE

FALSE

NONE

ZERO

ONE

MINUSONE

NOVALS

ENV

INDEX

NEWINDEX

CALL

MODE

METATABLE

ADD

SUB

DIV

MUL

POW

MOD

UNM

LEN

EQ

LT

LE

TOSTRING

CONCAT

EMPTYSTRING

NILS

uservalue

IDIV

BAND

BOR

BXOR

SHL

SHR

BNOT

构造器详细资料

LuaValue

方法详细资料

type

typename

isboolean

isclosure

isfunction

isint

isinttype

islong

isnil

isnumber

isstring

isthread

istable

isuserdata

isuserdata

toboolean

tobyte

tochar

todouble

tofloat