root/lu/LUList.lua

--------------------------------------------------------------------------------
-- Title:               LUList.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 LUString = require( "LUString" )
local io = require( "io" )
local math = require( "math" )
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:addAll( aContent )

        return self
end
                
-- method to add an object to this list
function self:add( aValue )
        if aValue ~= nil then
                local aContent = self:content()
        
                aContent[ #aContent + 1 ] = aValue
        end
        
        return self
end

-- method to add all the values of the given list to this list
function self:addAll( someValues )
        if self:isKindOf( someValues ) == true then
                for anIndex, aValue in someValues:iterator() do
                        self:add( aValue )
                end
        elseif type( someValues ) == "table" then
                for anIndex, aValue in ipairs( someValues ) do
                        self:add( aValue )
                end
        end
       
        return self
end

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

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

        return self._content
end

-- method to copy this list
function self:copy()
        return self:new():addAll( self )
end

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

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

-- method to get an object at a given index
function self:get( anIndex )
        anIndex = tonumber( anIndex )
        
        return self:content()[ anIndex or 1 ]
end

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

-- method to check if this list contains a given object
function self:hasValue( aValue )
        local anIndex = self:indexOf( aValue )

        if anIndex ~= nil then
                return true, anIndex
        end
        
        return false
end

-- method to get the index of an object
function self:indexOf( anObject )
        if anObject ~= nil then
                for anIndex, aValue in self:iterator() do
                        if anObject == aValue then
                                return anIndex
                        end
                end
        end
        
        return nil
end

function self:iterator()
        return ipairs( self:content() )
end

-- method to join this list items with a given string
function self:join( aString )
        local aBuffer = {}

        for anIndex, aValue in self:iterator() do
                aValue = tostring( aValue )

                aBuffer[ #aBuffer + 1 ] = aValue
        end
                
        return table.concat( aBuffer, aString or "" )
end

-- method to return a portion of this list
function self:range( aStart, anEnd )
        local aList = self:new()
        
        for index = aStart, anEnd do
                local aValue = self:get( index )
                
                aList:add( aValue )
        end
        
        return aList
end

-- method to remove from this list
function self:remove( anIndex )
        anIndex = tonumber( anIndex )

        table.remove( self:content(), anIndex or 1 )
        
        return self
end

-- method to remove all the values of the given list
function self:removeAll( someValues )
        if self:isKindOf( someValues ) == true then
                for anIndex, aValue in someValues:iterator() do
                        self:removeValue( aValue )
                end
        elseif type( someValues ) == "table" then
                for anIndex, aValue in ipairs( someValues ) do                       
                        self:removeValue( aValue )
                end
        end
       
        return self
end

-- method to remove the last value of this list
function self:removeLast()
        return self:remove( self:size() )
end

-- method to remove the given object from this list
function self:removeValue( aValue )
        local anIndex = self:indexOf( aValue )
        
        if anIndex ~= nil then
                return self:remove( anIndex )
        end
        
        return self
end

-- method to reverse this list order
function self:reverse()
        local aSize = self:size()
        
        if aSize > 1 then
                local aContent = self:content()
                local count = math.floor( aSize / 2 )
                
                for index = 1, count do
                        local anObject = aContent[ index ]
                        local anotherIndex = aSize - index + 1
                        local anotherObject = aContent[ anotherIndex ]        

                        aContent[ index ] = anotherObject
                        aContent[ anotherIndex ] = anObject
                end
        end
        
        return self
end

-- method to pseudo-randomely sort this list
function self:shuffle()
        if self:size() > 1 then
                local aContent = self:content()
                local count = self:size()
                
                for index = 1, count do
                        local anObject = aContent[ index ]
                        local anotherIndex = math.random( index, count )
                        local anotherObject = aContent[ anotherIndex ]
                        
                        aContent[ index ] = anotherObject
                        aContent[ anotherIndex ] = anObject
                end
        end

        return self
end

-- method to access this list size
function self:size()
        return #self:content()
end

-- method to sort this list
function self:sort( aComparator )
        table.sort( self:content(), aComparator )
        
        return self
end

-- method for string representation
function self:toString( isFormal )
        local aBuffer = {}

        aBuffer[ #aBuffer + 1 ] = "{ "
        
        if self:size() > 0 then
                for anIndex, aValue in self:iterator() do
                        if isFormal == true then
                                aBuffer[ #aBuffer + 1 ] = ( "[ %d ] = " ):format( anIndex )
                        end
                        
                        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 load this list 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:addAll( 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 list 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

--------------------------------------------------------------------------------
-- query methods
--------------------------------------------------------------------------------

function self:first()
        return self:get( 1 )
end

function self:last()
        return self:get( self:size() )
end

function self:min( aMethod )
        local aType = type( aMethod )
        local aMin = nil

        for anIndex, aValue in self:iterator() do
                local aLocalValue = aValue
                
                if aType == "string" then
                        aLocalValue = aLocalValue:invoke( aMethod )
                elseif aType == "function" then
                        aLocalValue = aMethod( aLocalValue )
                end
                
                if aLocalValue ~= nil and aMin == nil or aMin > aLocalValue then
                        aMin = aValue
                end
        end

        return aMin
end

function self:max( aMethod )
        local aType = type( aMethod )
        local aMax = nil

        for anIndex, aValue in self:iterator() do
                local aLocalValue = aValue
                
                if aType == "string" then
                        aLocalValue = aLocalValue:invoke( aMethod )
                elseif aType == "function" then
                        aLocalValue = aMethod( aLocalValue )
                end
                
                if aLocalValue ~= nil and aMax == nil or aMax < aValue then
                        aMax = aValue
                end
        end

        return aMax
end

function self:sum( aMethod )
        local aType = type( aMethod )
        local aSum = 0
        
        for anIndex, aValue in self:iterator() do
                if aType == "string" then
                        aValue = aValue:invoke( aMethod )
                elseif aType == "function" then
                        aValue = aMethod( aValue )
                end
                
                aValue = tonumber( aValue )
                
                if aValue ~= nil then
                        aSum = aSum + aValue
                end
        end
        
        return aSum
end

function self:select( aMethod )
        local aList = self:new()
        local aType = type( aMethod )

        for anIndex, aValue in self:iterator() do
                if aType == "string" then
                        aValue = aValue:invoke( aMethod )
                elseif aType == "function" then
                        aValue = aMethod( aValue )
                end
                
                aList:add( aValue )
        end

        return aList
end

function self:distinct( aMethod )
        local aType = type( aMethod )
        local aMap = require( "LUMap" ):new()
        
        for anIndex, aValue in self:iterator() do
                local aLocalValue = aValue
                
                if aType == "string" then
                        aLocalValue = aLocalValue:invoke( aMethod )
                elseif aType == "function" then
                        aLocalValue = aMethod( aLocalValue )
                end

                aMap:put( aLocalValue, aValue )
        end
        
        return aMap:values()
end

function self:between( aMin, aMax, aMethod )
        local aType = type( aMethod )
        local aList = self:new()

        for anIndex, aValue in self:iterator() do
                local aLocalValue = aValue

                if aType == "string" then
                        aLocalValue = aLocalValue:invoke( aMethod )
                elseif aType == "function" then
                        aLocalValue = aMethod( aLocalValue )
                end
                
                if aLocalValue ~= nil and aLocalValue >= aMin and aLocalValue <= aMax then
                        aList:add( aValue )
                end
        end

        return aList
end

function self:exists( aMethod )
        local aType = type( aMethod )

        for anIndex, aValue in self:iterator() do
                if aType == "string" then
                        aValue = aValue:invoke( aMethod )
                elseif aType == "function" then
                        aValue = aMethod( aValue )
                end

                if aValue ~= nil and aValue ~= false then
                        return true
                end
        end
        
        return false
end

function self:group( aMethod )
        local aType = type( aMethod )
        local aMap = require( "LUMap" ):new()

        for anIndex, aValue in self:iterator() do                
                local aLocalValue = aValue
                
                if aType == "string" then
                        aLocalValue = aLocalValue:invoke( aMethod )
                elseif aType == "function" then
                        aLocalValue = aMethod( aLocalValue )
                end
                
                if aLocalValue ~= nil then
                        local aList = aMap:get( aLocalValue )
                        
                        if aList == nil then
                                aList = self:new()
                                aMap:put( aLocalValue, aList )        
                        end
                        
                        aList:add( aValue )
                end
        end
        
        return aMap
end

function self:having( aMethod )
        local aType = type( aMethod )
        local aList = self:new()
        
        for anIndex, aValue in self:iterator() do
                local aLocalValue = aValue

                if aType == "string" then
                        aLocalValue = aLocalValue:invoke( aMethod )
                elseif aType == "function" then
                        aLocalValue = aMethod( aLocalValue )
                end

                if aLocalValue ~= nil and aLocalValue ~= false then
                        aList:add( aValue )
                end
        end
        
        return aList
end

function self:order( aMethod )
        local aType = type( aMethod )
        local aList = self:copy()
        local aComparator = nil
        
        if aType == "string" then
                aComparator = function( anObject, anotherObject )
                        return anObject:invoke( aMethod ) < anotherObject:invoke( aMethod )
                end
        elseif aType == "function" then
                aComparator = function( anObject, anotherObject )
                        return aMethod( anObject ) < aMethod( anotherObject )
                end
        end

        table.sort( aList:content(), aComparator )
        
        return aList
end

function self:union( someValues, aMethod )
        local aList = self:copy()
        
        aList:addAll( someValues )
        
        return aList:distinct( aMethod )
end

function self:unionAll( someValues )
        local aList = self:copy()

        aList:addAll( someValues ) 

        return aList
end

function self:intersect( someValues, aMethod )
        local aType = type( aMethod )
        local aList = self:new()
        local aMap = someValues:group( aMethod )

        for anIndex, aValue in self:iterator() do
                local aLocalValue = aValue

                if aType == "string" then
                        aLocalValue = aLocalValue:invoke( aMethod )
                elseif aType == "function" then
                        aLocalValue = aMethod( aLocalValue )
                end

                if aMap:hasKey( aLocalValue ) == true then
                        aList:add( aValue )
                end         
        end
        
        return aList
end

function self:minus( someValues, aMethod )
        local aType = type( aMethod )
        local aList = self:new()
        local aMap = someValues:group( aMethod )

        for anIndex, aValue in self:iterator() do
                local aLocalValue = aValue

                if aType == "string" then
                        aLocalValue = aLocalValue:invoke( aMethod )
                elseif aType == "function" then
                        aLocalValue = aMethod( aLocalValue )
                end

                if aMap:hasKey( aLocalValue ) == false then
                        aList:add( aValue )
                end         
        end
        
        return aList
end


return self