darmie/Bo-LuaOOP

Introduction

Bo-Lua OOP is a Java-like Lua Object Oriented Programming (OOP) implementation. Its purpose is to give the power of the Object-Oriented Programming to Lua and at the same time to keep itself as simple as possible, because of this, not all the Object-Oriented Programming features are supported by Bo-Lua OOP. Unlike the other Lua OOP implementation, Bo-Lua OOP enables multple inheritance through interface, which is from the concept of Java. The implemented features of Bo-Lua OOP are listed below:

###OOP features

Objects and Classes: supported
Encapsulation: not supported
Inheritance: multiple inheritance through interface
Virtual method: supported
Constructor/Destructor: supported
Abstract Methods and Classes: supported
Interfaces: supported
Method Overloading: not supported, but could be easily implemented
Operator Overloading: not supported, but could be easily implemented
Properties Exceptions: not supported

###Other features

Super: supported
Instanceof: supported
GetClassName: supported
Reflection: supported

###Todo list

Utils Classes

###Lua version Currently supports Lua 5.3.x, 5.2.x and 5.1.x

Usage

copy the directory bhou/oo/* to your lua path,

to load the module, use

local oo = require("bhou.oo.base")

this way does not pollute the global table.

if you include ?/init.lua to your lua path, you can load the module by using

require 'bhou.oo'

This way will automatically register a global table 'oo', more details see init.lua

Document

Create interface

local oo = require("bhou.oo.base")
oo.interface("InterfaceA", nil)
function InterfaceA:interfaceAFunction()
end

oo.interface("InterfaceB", nil)
function InterfaceB:interfaceBFunction()
end

oo.interface("InterfaceC", {InterfaceA, InterfaceB})
function InterfaceC:interfaceCFunction()
end

###Create a class

local oo = require("bhou.oo.base")

oo.class("ClassName", BaseClase, {InterfaceA, InterfaceB})  -- ClassName is automatically registered as global variable

ClassName.STATIC_VARIABLE = "static"

-- constructor
function ClassName:init(a)
  self.a = a
end

function ClassName:add(b)
  self.a = self.a + b
end

function ClassName:print()
  print(self.a)
end

-- inherited from interface A
function ClassName:interfaceAFunction()
  print("interface A")
end

-- inherited from interface B
function ClassName:interfaceBFunction()
  print("interface B")
end

-- static method
function ClassName.printUsage()  
  print("usage")
end

Compact way to define a class

local oo = require("bhou.oo.base")
oo.class("ClassName", BaseClass, {InterfaceA, InterfaceB}, {
  a = 100;    -- ',' is ok as well
  init = function(self, a)
        self.a = a
      end,
  add = function(self, b)
        self.a = self.a + b
      end,
  printUsage = function()   -- no self as arguement for static method
        print("usage")
      end,
  interfaceAFunction = function(self)
        print("interface A")
      end,
  interfaceBFunction = function(self)
        print("interface B")
      end,
})

Create sub class

local oo = require("bhou.oo.base")
oo.class("SubClass", ClassName)
function SubClass:init(a)
  self.a = a + 1
end

function SubClass:add(b)
  self.a = self.a + 1
  SubClass.super.add(self, b)    -- call super method
end

function SubClass:divide(b)
  self.a = self.a / b
end

create object

local oo = require("bhou.oo.base")
local obj = oo.new(SubClass, 100)
obj:print() -- 101, automatically call the parent's method if not defined in subclass
obj:add(5)
obj:print() -- 107

object build-in method

obj:getClassName()  -- "SubClass"
obj:instanceof(SubClass)    -- true
obj:instanceof(ClassName)   -- true
obj:toString()      -- return class name "SubClass"

upgrade

upgrade is a feature to turn a normal lua table into an object, which gives the table oop ability and meanwhile keep its own data.

There are two kinds of upgrade. One is strong upgrade, which will call the constructor of the class that you want your table turns to. Another one is weak upgrade, which does not call the constructor

to turn a table, let's say t into an object of class ClassA, we can do:

local t = {
  v1 = 100,
  v2 = 200,
  ... -- any thing you want to be in the table
}

local upgradedT = oo.upgrade(t, ClassA, ... --[[constructor arguments for ClassA--]])
-- now you can call any instance method defined in ClassA on upgradedT
upgradedT:instanceMethod()
-- or you can call method/variable defined in table t
print(upgradedT.v1)

or we can use weak upgrade (no constructor called to initiate the object)

local wt = {
  v1 = 100,
  v2 = 200,
  ... -- any thing you want to be in the table
}

local upgradedWT = oo.upgradeWeak(wt, ClassA) -- no constructor arguments
-- now you can call any instance method defined in ClassA on upgradedT
upgradedWT:instanceMethod()
-- or you can call method/variable defined in table wt
print(upgradedWT.v1)

Reflection

Since any object/class is a table as well, you can access any function, data in the object/class. A util module is provided to help you access some meta information of the object/class/interface. To use it, require it by :

local reflection = require 'bhou.oo.Reflection'

Currently there is only one method in reflection module: functions, which returns a list of name-function pair of the object, including the functions of its ancestor. See the end of the test.lua

reflection.functions(obj)

darmie / Bo-LuaOOP