root/lu/LUClass.lua

--------------------------------------------------------------------------------
-- Title:               LUClass.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 LUObject = require( "LUObject" )
local LUBundle = require( "LUBundle" )
local LUList = require( "LUList" )
local LUString = require( "LUString" )

-- define the class
local super = LUObject
local self = super()

-- initialization method
function self:init( anEntity )
        self = super.init( self )
        
        self._entity = anEntity
        
        return self
end

-- method to access this class bundle
function self:bundle()
        return LUBundle:bundleWithName( self:name() )
end
        
-- method to access the underlying entity
function self:entity()
        return self._entity
end

-- method to compare the given object with this object for equality
function self:equals( anObject )
        if self:isKindOf( anObject ) == true then
                if rawequal( self:entity(), anObject:entity() ) == true then
                        return true
                end
        end
        
        return false
end

-- method for retrieving all the method names define by this entity
function self:methodNames()
        local aList = LUList()
        local anEntity = self:entity()
        
        for aMethod, aFunction in pairs( anEntity ) do
                if LUString:startsWith( aMethod, "_" ) == false and type( aFunction ) == "function" then
                       aList:add( aMethod )
                end
        end

        return aList:sort()
end

-- method to retrieve the class name
function self:name()
        return self:entity():className()
end

-- method to access the super class
function self:superClass()
        if self._superClass == nil then
                local aParent = self:entity():super()
                
                if aParent ~= nil then
                        self._superClass = self:new( aParent )
                end
        end

        return self._superClass
end

-- method for string representation
function self:toString()
        return self:name()
end

-- method to access all the known classes
function self:classes()
        local someClasses = LUList()
        
        for _, aClassName in self:classNames():iterator() do
                someClasses:add( self:classWithName( aClassName ) )
        end
        
        return someClasses
end

-- method to access all the known class names
function self:classNames()
        return LUBundle:bundleNames()
end

-- method to return a class for a given object
function self:classWithObject( anObject )
        if anObject ~= nil then
                return self:classWithName( anObject:className() )
        end
        
        return  nil
end

-- method to access a known classs
function self:classWithName( aName )
        local aBundle, aStatus = LUBundle:bundleWithName( aName )
        
        if aBundle ~= nil then
                return self:new( aBundle:entity() )
        end
        
        return nil, aStatus
end

return self