root/lu/LUObject.lua

--------------------------------------------------------------------------------
-- Title:               LUObject.lua
-- Description:         Like a square peg in a round hole
-- Author:              Raphaël Szwarc http://alt.textdrive.com/lua/
-- Creation Date:       February 1, 2005
-- Legal:               Copyright (C) 2005 Raphaël Szwarc
--------------------------------------------------------------------------------

-- import dependencies
local table = require( "table" )

-- define the class
local self = {}

--------------------------------------------------------------------------------
-- Metamethods
--------------------------------------------------------------------------------

local function Call( anObject, ... )
        return anObject:new( ... )
end

local function Concat( anObject, anotherObject )
        return tostring( anObject ) .. tostring( anotherObject )
end

local function Equal( anObject, anotherObject )
        return anObject:equals( anotherObject )
end

local function LessThan( anObject, anotherObject )
        return anObject:compare( anotherObject )
end

local function ToString( anObject )
        return anObject:toString()        
end

--------------------------------------------------------------------------------
-- Object methods
--------------------------------------------------------------------------------

-- class loading
do
        local meta = {}

        meta.__call = Call
        meta.__concat = Concat
        meta.__eq = Equal
        meta.__lt = LessThan
        meta.__tostring = ToString
        
        setmetatable( self, meta )
end

-- factory method
function self:new( ... )
        local anObject = {} 
        local aClass = self:class()
        
        setmetatable( anObject, aClass )
                        
        return anObject:init( ... )
end

-- method for instance initialization
function self:init()
        return self
end

-- method for class initialization
function self:initialize()
        self.__index = self
        self.__call = Call
        self.__concat = Concat
        self.__eq = Equal
        self.__lt = LessThan
        self.__tostring = ToString

        return self
end

-- method to access this class
function self:class()
        local aValue = rawget( self, "_class" )

        if aValue == nil then
                local somePackages = package[ "loaded" ]
                
                for aName, anEntity in pairs( somePackages ) do
                        if rawequal( self, anEntity ) == true then
                                rawset( self, "_className", aName )

                                aValue = anEntity
                                aValue:initialize()
                                
                                break
                        end
                end
                
                if aValue == nil then
                        aValue = getmetatable( self )
                end

                rawset( self, "_class", aValue )
        end

        return aValue
end

-- method to access this super class
function self:super()
        local aValue = rawget( self, "_super" )

        if aValue == nil then
                local aSuper = getmetatable( self:class() )
                
                if self:isObject( aSuper ) == true then
                        aValue = aSuper
                        rawset( self, "_super", aValue )
                end
        end

        return aValue
end
        
-- method to access this class name
function self:className()
        local aValue = rawget( self, "_className" )

        if aValue == nil then
                aValue = self:class():className()
                rawset( self, "_className", aValue ) 
        end
        
        return aValue
end

-- method to compare the given object with this object
function self:compare( anObject )
        local aDescription = self:toString():lower()
        local anotherDescription = anObject:toString():lower()
        
        return aDescription < anotherDescription
end

-- method for equality
function self:equals( anObject )
        return rawequal( self, anObject )
end

-- method for hashing
function self:hashCode()
        local aValue = rawget( self, "_hashCode" )

        if aValue == nil then
                aValue = tonumber( tostring( {} ):gsub( "table: ", "" ), 16 )
                rawset( self, "_hashCode", aValue )
        end
        
        return aValue      
end

-- method to check if the given object is an instance of this object
function self:isKindOf( anObject )
        if self:isObject( anObject ) == true then
                local aClass = anObject:class()
                
                anObject = self:class()
        
                while anObject ~= nil do
                        if rawequal( aClass, anObject ) == true then
                                return true
                        end
                
                        anObject = anObject:super()
                end
        end
        
        return false
end

-- method to check if the given object is indeed an object
function self:isObject( anObject )
        if type( anObject ) == "table" then
                local aMeta = getmetatable( anObject )
                
                if aMeta ~= nil and aMeta.__call == Call then
                        return true
                end
        end
        
        return false
end

 -- method to invoke the named method
function self:invoke( aMethod, ... )
        local aTarget = self
        
        for aMethodName in ( aMethod or "" ):gmatch( "([^%.]+)" ) do
                if type( aTarget ) == "table" or getmetatable( aTarget ) ~= nil then
                        local aFunction = aTarget[ aMethodName ]
                        
                        if type( aFunction ) == "function" then
                                aTarget = aFunction( aTarget, ... )
                        elseif type( aTarget[ "get" ] ) == "function" then
                                aTarget = aTarget[ "get" ]( aTarget, aMethodName )
                        else
                                aTarget = aFunction
                                
                                break
                        end
                else
                        aTarget = nil
                
                        break
                end
        end
        
        return aTarget
end

 -- method to check if this object implements the given method name
function self:respondsTo( aMethod )
        if type( self[ aMethod ] ) == "function" then
                return true
        end
        
        return false 
end

-- method to access self
function self:self()
        return self
end

-- method for string representation
function self:toString()
        return self:className() .. "@" .. self:hashCode()        
end

-- try to execute the given method
function self:try( aMethod, ... )
        local someArguments = { ... }
        local aLength = select( "#", ... )
        
        return function( catch )
                local aMethod = self[ aMethod ]
                local someResults = { pcall( aMethod, self, unpack( someArguments, 1, aLength ) )  }
                local aStatus = someResults[ 1 ]
                
                if aStatus == true then
                        return unpack( someResults, 2, table.maxn( someResults ) )
                else
                        local anException = someResults[ 2 ]
        
                        if catch ~= nil then
                                return catch( anException, self, aMethod, unpack( someArguments, 1, aLength ) )
                        end
        
                        return nil, anException
                end
        end
end

-- method for serialization (see LUObjectWriter)
function self:writeObject()
        local aTable = {}
        
        for aKey, aValue in pairs( self ) do
                if aKey:sub( 1, 1 ) == "_"
                        and aKey:sub( 1, 2 ) ~= "__"
                        and aKey ~= "_class"
                        and aKey ~= "_className" 
                        and aKey ~= "_hashCode"
                        and aKey ~= "_super" then
                        
                        aTable[ aKey ] = aValue
                end
        end
        
        return aTable
end

return self