root/lu/Example.lua

package.path = package.path .. ";./Library/Lua/?.lua"
package.cpath = package.cpath .. ";./Library/Modules/?.so"

-- import dependencies

local LUObject = require( "LUObject" )
local LUBundle = require( "LUBundle" )
local LUString = require( "LUString" )
local LUList = require( "LUList" )
local LUMap = require( "LUMap" )
local MyClass = require( "MyClass" )
local MyOtherClass = require( "MyOtherClass" )
local ATask = require( "ATask" )
local LUTask = require( "LUTask" )
local LURunLoop = require( "LURunLoop" )
local LUClass = require( "LUClass" )
local LUDate = require( "LUDate" )
local LULog = require( "LULog" )
local LUTimer = require( "LUTimer" )
local LUFile = require( "LUFile" )
local LFSFile = require( "LFSFile" )
local LUConfig = require( "LUConfig" )
local DBMap = require( "DBMap" )
local LUInputStream = require( "LUInputStream" )
local LULocale = require( "LULocale" )
local LUModule = require( "LUModule" )
local LUCrypto = require( "LUCrypto" )
local debug = require( "debug" )
local os = require( "os" )

local anObject = LUObject()

LULog:debug( LUObject )

local anotherObject = LUObject()

LULog:debug( LUObject )

LULog:debug( anObject )
LULog:debug( anotherObject )
LULog:debug( anObject:hashCode() )
LULog:debug( anotherObject:hashCode() )
LULog:debug( anObject == anotherObject )

LULog:debug( anObject )
LULog:debug( type( anObject ) )

local aList = LUList()

LULog:debug( "aList.hashCode", aList:hashCode() )

-- aList:add( anObject );
-- aList:add( anotherObject );

LULog:debug( LUList( { 1, 2, 3 } ):store( LUBundle( LUList ):path() .. "/list.txt" ) )

aList:add( "aString" );
aList:add( true );
aList:add( false );
aList:add( 10 );
aList:add( { 1, 2, 3 } );

-- LULog:debug( "aList:get", aList:get( anObject ) )
-- LULog:debug( "aList:get", aList:get( 1 ) )
LULog:debug( aList:get( true ) )
LULog:debug( aList:size() )
LULog:debug( aList )

aList:removeValue( anObject )

LULog:debug( aList:size() )

aList:removeValue( anotherObject );

LULog:debug( aList:size() )
LULog:debug( aList:equals( aList ) )

local anotherList = LUList()

LULog:debug( anotherList:equals( aList ) )

anotherList:addAll( aList )

LULog:debug( "anotherList.hashCode", anotherList:hashCode() )
LULog:debug( "anotherList.equals", anotherList:equals( aList ) )

local aPath = LUBundle:bundleWithName( "MyClass" ):path()

LULog:debug( "aPath",  aPath )

aList:store( aPath .. "/list.txt" )

--[[
local aTable = { [ 1 ] = false, [ 2 ] = 10, [ 3 ] = { "1" = 1, "3" = 3, "2" = 2 } }

LULog:debug( "* aTable", aTable )

local aTable, anError = loadstring( "return { [ 1 ] = false, [ 2 ] = 10, [ 3 ] = { "1" = 1, "3" = 3, "2" = 2 } }" )()
LULog:debug( "* aTable loadstring", anError, aTable )
--]]

LULog:debug( aPath )

local aPersistentList, aStatus = LUList():load( aPath .. "/list.txt" )

LULog:debug( "aList", aList )
LULog:debug( "aPersistentList", aPersistentList )
LULog:debug( "aPersistentList.equals", aPersistentList:equals( aList ) )

local aMap = LUMap()

LULog:debug( "aMap.hashCode", aMap:hashCode() )

aMap:put( "aKey", "aValue" )
aMap:put( 1, true )
aMap:put( 2, false )
aMap:put( 3, 4 )
aMap:put( true, false )
-- aMap:put( anObject, anObject )

-- aMap:put( anObject, nil )
aMap:put( "aList", aList )

LULog:debug( aMap:size() )
LULog:debug( aMap )
LULog:debug( aMap:keys() )
LULog:debug( aMap:values() )

aMap:store( aPath .. "/map.txt" )

LULog:debug( "* " .. aPath )

local aPersistentMap = LUMap():load( aPath .. "/map.txt" )


LULog:debug( "aMap", aMap )
LULog:debug( "aPersistentMap", aPersistentMap )
LULog:debug( "aPersistentMap.equals", aPersistentMap:equals( aMap ) )

local anotherMap = LUMap()

anotherMap:putAll( aMap )
anotherMap:put( "anotherKey", "anotherValue" )

LULog:debug( anotherMap:keys() )
LULog:debug( anotherMap:values() )
LULog:debug( anotherMap:equals( aMap ) )

local myClass = MyClass()
local myOtherClass = MyOtherClass()

myClass:dwim()
myOtherClass:dwim()

LULog:debug( LUMap( _G ):keys():sort() )
LULog:debug( LUMap( io ):keys():sort() )
LULog:debug( LUMap( arg ) )
LULog:debug( LUMap( os ):keys():sort() )
LULog:debug( LUMap( math ):keys():sort() )
LULog:debug( LUMap( string ):keys():sort() )
LULog:debug( LUMap( table ):keys():sort() )
LULog:debug( "package", LUMap( package ):keys():sort() )
LULog:debug( "package.loaded", LUMap( package[ "loaded" ] ):keys():sort() )
LULog:debug( package.path )
LULog:debug( package.cpath )

LULog:debug( myOtherClass )
LULog:debug( myOtherClass.isKindOf( myClass ) )

LULog:debug( LUClass:classNames(), "classNames" )
LULog:debug( LUClass:classWithName( "LUObject" ) )
LULog:debug( LUClass( LUObject ):methodNames() )
LULog:debug( LUClass( LUClass ) )
LULog:debug( LUBundle( LUBundle ):path() )

local aBundle = LUBundle:bundleWithName( "MyClass" )

LULog:debug( LUBundle:bundleNames(), "bundleNames" )

LULog:trace( aBundle:fileWithName( "picture", "png", "Images", "en-us" ) )
LULog:debug( aBundle:fileWithName( "picture", "png", "Images" ) )
LULog:debug( aBundle:fileWithName( "picture", "png" ) )
LULog:warning( aBundle:fileWithName( "picture" ) )
LULog:error( aBundle:fileWithName() )

LULog:debug( LUDate() )
LULog:debug( LUDate():utcDate() )
LULog:debug( LUDate():time() )
LULog:debug( LUDate():utc() )
LULog:debug( LUDate():date() )
LULog:debug( LUDate:timeZone() )
LULog:debug( "timeZoneOffset", LUDate:timeZoneOffset() )
LULog:debug( LUDate:dateWithValues( { year = 1970, month = 1, day = 1 } ) )

local someClassNames = LUClass:classNames()

LULog:debug( someClassNames )

for anIndex, aClassName in someClassNames:iterator() do
        local aClass = LUClass:classWithName( aClassName )
        local anInstance = aClass:entity()()
        
        if anInstance ~= nil then
                LULog:debug( LUClass:classWithObject( anInstance ) )
        end
                
        LULog:debug( LUClass:classWithObject( aClass:entity()) )
        LULog:debug( aClass:name() )
        LULog:debug( aClass:superClass() )
        LULog:debug( aClass:methodNames() )
end

LULog:debug( os.getenv( "USER" ) )

require( "posix" )

LULog:debug( posix.uname() )
LULog:debug( posix.getcwd() )
LULog:debug( posix.getprocessid() )
LULog:debug( os.getenv( "USER" ) )
-- LULog:debug( posix.sleep( 1 ) )

require( "random" )

local aRandom = random.new( os.time() )

LULog:debug( aRandom:value(), "random" )
LULog:debug( aRandom:value() )
LULog:debug( aRandom:value() )
LULog:debug( aRandom:value() )

require( "lfs" )

LULog:debug( lfs.currentdir() )

require( "uuid" )

local anUUID = uuid.new( "time" )

LULog:debug( "uuid", anUUID, os.date( "%x", uuid.time( anUUID ) ) )
LULog:debug( "uuid", uuid.new() )
LULog:debug( "uuidmd5", md5.digest( uuid.new() ) )

require( "md5" )

LULog:debug( "md5", md5.digest( "1" ) )

require( "crc" )

local anHash = crc.calc( "1" )

LULog:debug( "crc", ( "%x" ):format( crc.calc( "1" ) ) )

LULog:debug( "random", ( "%x" ):format( random.new( 1 ):value() * 1000000 ) )

local aFile = LFSFile:currentDirectory()

LULog:debug( aFile:name() )
LULog:debug( aFile:directory() )
LULog:debug( aFile:path() )
LULog:debug( aFile:exists() )
LULog:debug( aFile:isFile() )
LULog:debug( aFile:isDirectory() )
LULog:debug( aFile:attributes() )

local aFilter = function( aDirectory, aFileName )
        if aFileName:find( ".lua" ) ~= nil then
                return true
        end
        
        return false
end

LULog:debug( "****" )
LULog:debug( aFile:list( aFilter ) )
LULog:debug( LFSFile( nil, LUList( aFile:list( aFilter ) ):last() ) )
LULog:debug( LFSFile( nil, LUList( aFile:list( aFilter ) ):last() ):size() )
LULog:debug( LFSFile( nil, LUList( aFile:list( aFilter ) ):last() ):attributes() )
LULog:debug( aFile:path() )
LULog:debug( aFile:pathComponents() )
LULog:debug( aFile:parentDirectory() )
LULog:debug( aFile:isAbsolute() )

while true do
        
        LULog:debug( aFile )
        
        if aFile:parentDirectory() ~= nil then
                aFile = LUFile( aFile:parentDirectory() )
        else
                break
        end
end

LULog:debug( LUFile:tmpDir() )
LULog:debug( LUFile:tmpName( "prefix", "suffix" ) )
LULog:debug( LUFile:tmpName( "prefix" ) )
LULog:debug( LUFile:tmpName( nil, "suffix" ) )
LULog:debug( LUFile:tmpName() )
LULog:debug( LUFile:tmpFile() )
LULog:debug( LUFile:tmpFile():isAbsolute() )

LULog:debug( LUConfig:name() )
LULog:debug( LUConfig:path() )
LULog:debug( LUFile( LUConfig:path() ):isAbsolute() )
LULog:debug( LUConfig:configWithName() )

local aDBMap = DBMap():load( "./gdbm.db" )

aDBMap:putAll( { [ "AUG" ] = "August", [ "SEP" ] = "September" } )
aDBMap:put( "OCT", "October" )
aDBMap:put( "NOV", "November" )
aDBMap:put( "DEC", "December" )

LULog:debug( aDBMap )
LULog:debug( aDBMap:path() )
LULog:debug( aDBMap:db() )
LULog:debug( aDBMap:size() )
LULog:debug( aDBMap:keys():sort() )
LULog:debug( aDBMap:values():sort() )
LULog:debug( aDBMap:get( "DEC" ) )
LULog:debug( aDBMap:hasKey( "DEC" ) )
LULog:debug( aDBMap:hasValue( "December" ) )


aDBMap:store()
aDBMap:optimize()
aDBMap:close()

local aClass, aStatus = LUClass:classWithName( "asdfasdfasd" )

LULog:debug( aClass )
LULog:debug( aStatus )

local aList = LUList( { 1, 2, 3, 4, 5, 6, 7, 8, 9 } )

LULog:debug( aList )
LULog:debug( aList:reverse() )
LULog:debug( aList:reverse() )

LULog:debug( aList:having( function( aValue ) if aValue < 5 then return true end return false end ) )
LULog:debug( aList:range( 5, 9 ) )
LULog:debug( 1, aList:sort():shuffle() )
LULog:debug( 2, aList:sort():shuffle() )
LULog:debug( 3, aList:sort():shuffle() )
LULog:debug( 4, aList:sort():shuffle() )
LULog:debug( 5, aList:sort():shuffle() )
LULog:debug( 6, aList:sort():shuffle() )
LULog:debug( 7, aList:sort():shuffle() )
LULog:debug( 8, aList:sort():shuffle() )
LULog:debug( 9, aList:sort():shuffle() )
LULog:debug( aList:sort() )

local anInputStream = LUInputStream( "abc-def" )

for aValue in anInputStream:iterator( true ) do
        LULog:debug( "read", ( "%q" ):format( aValue ) )
        LULog:debug( "string", ( "%q" ):format( anInputStream:toString() ) )
end

LULog:debug( LULocale:default() )
LULog:debug( LULocale:default():countryName() )
LULog:debug( LULocale:default():languageName() )
LULog:debug( LULocale:default():currency() )
LULog:debug( LULocale:default():currencyName() )
LULog:debug( LULocale:default():days() )
LULog:debug( LULocale:default():shortDays() )
LULog:debug( LULocale:default():months() )
LULog:debug( LULocale:default():shortMonths() )
LULog:debug( LULocale:default():areas() )
LULog:debug( LULocale:default():locations() )
LULog:debug( LULocale:default():zones() )
LULog:debug( "allCountries", LULocale:allCountries():size() )
LULog:debug( "allCurrencies", LULocale:allCurrencies():size() )
LULog:debug( "allLanguages", LULocale:allLanguages():size() )
LULog:debug( "allZones", LULocale:allZones():size() )

local someModules = LUModule:moduleNames()

for anIndex, aName in someModules:iterator() do
        local aModule = LUModule:moduleWithName( aName )
        
        LULog:debug( aModule, aModule:version() )
        LULog:debug( aModule:functionNames() )
        LULog:debug( aModule:attributeNames() )
end

LULog:debug( LUModule:moduleWithName( "_G" ), LUModule:moduleWithName( "_G" ):version() )
LULog:debug( LUModule:moduleWithName( "_G" ):functionNames() )
LULog:debug( LUModule:moduleWithName( "_G" ):attributeNames() )

local zlib = require( "zlib" )

local aCompressedValue = zlib.compress( "hello! hello! hello!" )

LULog:debug( "zlib", LUString:encode( aCompressedValue ) )

local anUncompressedValue = zlib.decompress( aCompressedValue )

LULog:debug( "zlib", anUncompressedValue )

LUTimer( ATask(), 1, true ):start()
LUTimer( ATask(), 2, true ):start()

-- LURunLoop:default():start()

require( "crypto" )

local aFish = crypto.blowfish( "password" )
local aString = "secret"
local anEncryptedString = aFish( aString )
local aDecryptedString = aFish( anEncryptedString, true )

LULog:debug( aString, LUString:encode( anEncryptedString ), aDecryptedString )

local aKey = md5.digest( random.new( os.time() ):value() )
local anUUID = uuid.new()
local aFish = crypto.blowfish( aKey )
local aString = aFish( anUUID )

LULog:debug( aKey, anUUID, LUString:encode( aString ) )
LULog:debug( aString == LUString:decode( LUString:encode( aString ) ) )

LULog:debug( LUCrypto:value() )
LULog:debug( uuid.new( "random" ))
LULog:debug( uuid.new( "time" ))
LULog:debug( LUFile:tmpName() )
LULog:debug( collectgarbage( "count" ) )
LULog:debug( {} )

aKey = LUCrypto:key()
aString = LUCrypto:key()

LULog:debug( aKey:len(), aKey )

local aSignature = LUCrypto:sign( aKey, aString )

LULog:debug( aSignature:len(), aSignature, LUCrypto:verify( aKey, aString, aSignature ) )