----------------------------------------------------------
--面向对象核心库
----------------------------------------------------------
----------------------------------------------------------
--base object
object = {}
function object:getName()
return "unknow"
end
function object:resetHashCode()
self.__hashcode = nil
self:getHashCode()
end
function object:getHashCode()
self.__hashcode = self.__hashcode or (os.time() + math.random())
return self.__hashcode
end
----------------------------------------------
-- create interface helper
function createInterface(object,name,func)
warning(object[name] == nil,"Interface exists,create fail" .. name)
end
function callInsterface(object,name,...)
local func = object[name]
return func(object,...)
end
function callmethod(object,name,...)
local func = object[name]
return func(object,...)
end
function implementInterface(object,name,func)
object[name] = func
end
function createAbstract(object,name,func)
object[name] = function(self)
warning(false,"not implement Abstract " .. name)
return nil
end
end
function createVirtualFunction(object,name,func)
implementInterface(object,name,func)
end
function override(object,name,func)
implementInterface(object,name,func)
end
function sealed(object)
object.__sealed = true
end
----------------------------------------------
--oop helpers
local function addctor(class)
assert(class,"class is nil value")
if class.ctor == nil then
class.ctor = function(self) end
end
end
function registerFun_getInstance(cls)
-- warning(cls.getInstance == false,"cls has function:getInstacnce")
cls.__instance = nil;
cls.getInstance =function()
if cls.__instance == nil then
assert(cls.new and type(cls.new)== "function","not found ctor function :new");
cls.__instance = cls:new()
return cls.__instance
end
return cls.__instance
end
end
---向对象中添加临时数据
function setTempVariable(object,key,value)
assert(key,"key is a nil value")
assert(value~=nil,"value is a nil value")
object.__tempData = object.__tempData or {}
object.__tempData["__"..key] = value
end
---查找对象中保存的临时数据
function getTempVariable(object,key)
assert(object,"object is a nil value")
assert(key,"key is a nil value")
if object.__tempData == nil then return nil end
return object.__tempData["__"..key]
end
function callSupper(instance,supperName,name,cls,...)
if instance ~= nil then
if instance.supper == nil then return end
if instance.supper[supperName] ~=nil then
for key, var in pairs( instance.supper[supperName]) do
if key == name then
local fun = var
local returnValue,e = pcall(fun,cls or instance,...)
assert(e==nil,e)
return returnValue,true
end
end
else
for key, var in pairs(instance.supper) do
if type(var) == "table" and key~="__index" and key ~= "__child" then
local returnValue,result = callSupper(var,supperName,name,instance,...)
if result == true then return returnValue,true end
end
end
end
if instance.__child ~=nil then
local returnValue,result = callSupper(instance.__child,supperName,name,cls,...)
if result == false and instance.__child.__child then
returnValue,result = callSupper(instance.__child.__child,supperName,name,cls,...)
end
return returnValue,true
end
end
return nil,false
end
---调用基类中的函数
function callSupperA(instance,supperName,name,...)
return callSupper(instance,supperName,name,instance,...)
end
local function copyAllSupper(class,base)
if base ~= nil and class ~= nil and base.supper ~= nil then
class.supper = class.supper or {}
for key, var in pairs(base.supper) do
if class.supper[key] == nil then
class.supper[key] = var
end
end
end
end
--继承帮助函数
--ext:扩展类,
--base:基类
--supper name
---------------------------------------------
--@param #table ext 当前类的定义
--@param #table base 当前类的要继承的类，一般也为table
--@param #string suppername 当前继承的基类的别名
--@return #table 一个新的对旬的实列
function inheritanceA(ext,base,suppername)
-- assert(ext,"not set ext object.")
-- assert(base,"not set base object.")
-- assert(base.__sealed == nil,"基类设置为了禁止继承.")
if base.__sealed ~= nil then
assert(base.__sealed == nil,"基类设置为了禁止继承.")
return
end
--metatable copy
local function setmetatableA(tag,source)
for k,v in pairs(source) do
if tag[k] == nil then
if type(v) == "table" and k ~= "__index" and k~= "__child" then
tag[k] = {}
setmetatableA (tag[k],v)
tag[k].__index = tag[k]
else
tag[k] = v
end
end
end
return tag
end
ext = setmetatableA(ext,base)
ext.__index = ext
--添加自己的构造函数
if ext.new == nil then
function ext.new ( self )
local instance = {}
setmetatableA(instance,self)
instance.__index = instance
instance:ctor()
instance:resetHashCode()
return instance,ext.supper
end
addctor(ext)
end
ext.supper = ext.supper or {}
setmetatableA(ext.supper,base)
ext.supper.__child = ext
ext.supper.__index = ext.supper;
---添加基类的默认构造函数
if ext.supper and ext.supper.new == nil then
---此逻辑的意义不大
ext.supper.new = ext.supper.new or function ( self )
local instance = {}
setmetatableA(instance,self)
instance:resetHashCode()
return ext.supper,ext.supper or {}
end
addctor(ext.supper)
end
if suppername ~= nil and type(ext.supper[suppername])~= "function" then
ext.supper[suppername] = ext.supper[suppername] or {}
setmetatableA(ext.supper[suppername],base)
ext.supper[suppername].__index = ext.supper[suppername]
end
ext.__index = ext;
---注册单列接口
registerFun_getInstance(ext)
return ext,ext.supper
end
---继承对象实例
--@param #table ext 当前对象的实例
--@param #table base 基类的实例
function inheritance(ext,base)
-- assert(false,"调用本函数只能通过supper来访问，如果多少继承，只有最后一次继承的会生效")
return inheritanceA(ext or {},base,"__supper")
end
---继承自model 文件
--@param #table ext 当前对象的实例
--@param #string mname 当前要继承的模块对象
function inheritanceM(ext,mname)
local obj = require (mname)
assert(obj~=nil,"load mode error,mode name:"..mname)
return inheritanceA(ext,obj,mname)
end
return object