Inherit Java class from Luaj

Question

Is it possible, in Luaj, to have a Lua class extend a Java class? I tried using getmetatable() on the binded class but apparently it returns nil.

Here, Wizard is a Java class binded to Lua, and SetupWizard is the Lua class that I want to inherit fromWizard.

function SetupWizard:new()
    local self = setmetatable({}, getmetatable(Wizard))
    return self
end

Assigning __index to the value of Wizard didn't work either.

SetupWizard definition:

SetupWizard = {
    host = nil,
    user = nil,
    password = nil,
    database = nil,
    mySqlTables = {
        users = nil,
    },
}
SetupWizard.__index = Wizard

... SetupWizard methods here

I don't know much about LuaJ but chances are that `Wizard` is itself a userdata with its own `__index` method that won't be checked if it's assigned as a `__index` table for another object. Something you might try is just assigning `__index` of the metatable of your class to a function that fetches from `Wizard`, e.g. `function idx(self, k) return Wizard[k] end` — jgriego, Oct 25 '14 at 16:11

Jabermony · Answer 1 · 2014-11-03T17:28:28.417

LuaJ is fairly flexible in respects to how you can go about things such as importing classes from java. You've not specified how you have done this so I'm going to assume you've gone about it by creating a library of Java Functions as a bridge to build a module that you can require (with require"moduleName") like so:

import org.luaj.vm2.LuaValue;
import org.luaj.vm2.lib.OneArgFunction;
import org.luaj.vm2.lib.TwoArgFunction;


/*
 * When require"module name" is called in luaJ it also searches for java classes with a classname that matches
 * the given module name that inherit from LuaFunction and have a default constructor, it then
 * calls the method call(LuaValue moduleName, LuaValue globalEnviroment) passing the module name string and
 * global environment as LuaValues and returning the return value of this call as it's own. 
 * 
 */

public class Example extends TwoArgFunction{

    @Override
    public LuaValue call(LuaValue modname, LuaValue globalEnv) {
        // Creates a table to place all our functions in
        LuaValue table = LuaValue.tableOf();

        // Sets the value 'name' in our table to example. This is used in the example function
        table.set("name", "example");
        // Sets the value 'exampleMethod' in our table to the class of type OneArgFunction
        // we created below
        table.set("exampleMethod", exampleMethod);

        //Finally returns our table. This value is then returned by require.
        return table;
    }


    /* Creates a function that takes one arg, self.

      This emulates the creation of a method in lua and can be called,
      when added to a table, as table:exampleMethod().
      This is possible as in Lua the colon in functions is
      Syntactic suger for object.function(object) 

    */
    OneArgFunction exampleMethod = new OneArgFunction() {

        @Override
        public LuaValue call(LuaValue self) {

            if(self.istable()) {
                return self.get("name");
            }

            return NIL;
        }
    };

}

This can then be used in your Lua code as follows:

--Imports the class Wrapper we created
example = require"Example"
--Prints the return value of calling exampleMethod
print("The name of the class is: "..example:exampleMethod())


--And then used as an index like so
example2 = setmetatable({},{__index=example})

example2.name = "example2"

print("The name of the class is: "..example2:exampleMethod())

As I stated at the top of the answer, LuaJ is flexible in respects to how you can go about these things and this is only the way I would do it.

Due to my reputation I was unable to post a comment asking how you've gone about importing Java classes in LuaJ, feel free to clarify in the comment on this answer.

score 0 · Answer 2 · answered Mar 08 '15 at 23:26

Your Java based LuaJ module needs to return a table, and you use

local SetupWizard = require("SetupWizard")
local Wizard = {}
setmetatable(Wizard, {__index=SetupWizard})
--optionally create single metatable for all Wizard instances: local wizardMetaTable = {_index=Wizard}
function Wizard:new()
  local T = {}
  setmetatable(T, {__index=Wizard})
  -- setmetatable(T, wizardMetaTable)
  -- this increases performance by using one metatable for all wizards.
  return T
end

Inherit Java class from Luaj

2 Answers2