root/lu/LUMap.lua

--------------------------------------------------------------------------------
-- Title:               LUMap.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 LUObjectReader = require( "LUObjectReader" )
local LUObjectWriter = require( "LUObjectWriter" )
local LUList = require( "LUList" )
local LUString = require( "LUString" )
local io = require( "io" )
local table = require( "table" )

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

-- method for initialization
function self:init( aContent, aMode )
        self = super.init( self )

        if aMode ~= nil then
                setmetatable( self:content(), { __mode = aMode } )
        end
        
        self:putAll( aContent )

        return self
end

-- method to clear this map
function self:clear()
        for aKey, aValue in self:iterator() do
                self:remove( aKey )
        end
        
        return self
end

-- method to access this map content
function self:content()
        if self._content == nil then
                self._content = {}
        end

        return self._content
end

-- method to copy this map
function self:copy()
        return self:new():putAll( self )
end

-- method to check if this map contains any data
function self:hasData()
        for aKey, aValue in self:iterator() do
                return true
        end
        
        return false
end

-- method to check if this map contains a given key
function self:hasKey( aKey )
        if self:get( aKey ) ~= nil then
                return true
        end
        
        return false
end

-- method to check if this map contains a given value
function self:hasValue( aValue )
        if aValue ~= nil then
                for aKey, anotherValue in self:iterator() do
                        if aValue == anotherValue then
                                return true, aKey
                        end
                end
        end
        
        return false
end

-- method to return a value for a given key
function self:get( aKey )
        if aKey ~= nil then
                return self:content()[ aKey ]
        end
        
        return nil
end

-- method to compare a given object with this map for equality
function self:equals( anObject )
        if self:isKindOf( anObject ) == true then
                if self:size() == anObject:size() then
                        for aKey, aValue in self:iterator() do
                                local anotherValue = anObject:get( aKey )

                                if aValue ~= anotherValue then
                                        return false
                                end
                        end
                        
                        return true
                end
        end
        
        return false
end

-- method to access this map iterator
function self:iterator()
        return pairs( self:content() )
end

-- method to access all the keys of this map
function self:keys()
        local someKeys = LUList()
        
        for aKey, aValue in self:iterator() do
                someKeys:add( aKey )
        end
        
        return someKeys
end

-- method to return all the keys with a given value
function self:keysWithValue( aValue )
        if aValue ~= nil then
                local someKeys = LUList()
                
                for aKey, anotherValue in self:iterator() do
                        if aValue == anotherValue then
                                someKeys:add( aKey )
                        end
                end
                
                if someKeys:size() > 0 then
                        return someKeys
                end
        end
        
        return nil
end

-- method to associate a given value with a given key
function self:put( aKey, aValue )
        if aKey ~= nil then
                self:content()[ aKey ] = aValue
        end

        return self
end

-- method to add all the key-value pairs from a given map
function self:putAll( aMap )
        if self:isKindOf( aMap ) == true then
                for aKey, aValue in aMap:iterator() do
                        self:put( aKey, aValue )
                end
        elseif type( aMap ) == "table" then
                for aKey, aValue in pairs( aMap ) do
                        self:put( aKey, aValue )
                end
        end
        
        return self
end

-- method to remove a given key
function self:remove( aKey )
        if aKey ~= nil then
                self:content()[ aKey ] = nil
        end

        return self
end

-- method to remove the given keys
function self:removeAll( someKeys )
        if someKeys ~= nil then
                for anIndex, aValue in someKeys:iterator() do
                        self:remove( aValue )
                end
        end

        return self
end

-- method to returns the size of this map
function self:size()
        local aSize = 0

        for aKey, aValue in self:iterator() do
                aSize = aSize + 1
        end
        
        return aSize
end

-- method for string representation
function self:toString( isFormal )
        local aBuffer = {}
        
        aBuffer[ #aBuffer + 1 ] = "{ "
        
        if self:size() > 0 then
                for aKey, aValue in self:iterator() do
                        if isFormal == true then
                                aBuffer[ #aBuffer + 1 ] = "[ "
                        end
                        
                        aBuffer[ #aBuffer + 1 ] = LUString:toString( aKey, isFormal )

                        if isFormal == true then
                                aBuffer[ #aBuffer + 1 ] = " ]"
                        end
                        
                        aBuffer[ #aBuffer + 1 ] = " = "

                        aBuffer[ #aBuffer + 1 ] = LUString:toString( aValue, isFormal )
                        
                        aBuffer[ #aBuffer + 1 ] = ", "
                end

                aBuffer[ #aBuffer ] = nil
        end
        
        aBuffer[ #aBuffer + 1 ] = " }"
        
        return table.concat( aBuffer, "" )
end

-- method to access all the values of this map
function self:values()
        local someValues = LUList()

        for aKey, aValue in self:iterator() do
                someValues:add( aValue )
        end
        
        return someValues
end

-- method to load this map content from a given location
function self:load( aPath )
        if aPath == nil then
                aPath = self._path
        else
                aPath = tostring( aPath )
                self._path = aPath
        end

        if aPath ~= nil then
                local aFile = io.open( aPath, "r" )
                
                if aFile ~= nil then
                        local aContent = aFile:read( "*all" )
                        
                        aFile:close()
                        
                        if aContent ~= nil then
                                self:putAll( LUObjectReader:read( aContent ) )
                        else
                                return nil, ( "invalid content at '%s'" ):format( aPath )
                        end
                else
                        return nil, ( "invalid path '%s'" ):format( aPath )
                end
        else
                return nil, "invalid path"
        end
        
        return self
end

-- method to store this map at a given location
function self:store( aPath )
        if aPath == nil then
                aPath = self._path
        else
                aPath = tostring( aPath )
                self._path = aPath
        end

        if aPath ~= nil then
                local aFile = io.open( aPath, "w" )
                
                if aFile ~= nil then                        
                        aFile:write( LUObjectWriter:write( self:content() ) )
                        aFile:close()
                else
                        return nil, ( "invalid path at '%s'" ):format( aPath )
                end
        else
                return nil, "invalid path"
        end
        
        return self
end

return self