Class System

[Anderl]

Hello

Eu fiz eu sistema de classes à um tempo atraz e decidi publicar ele aqui para vocês.

Aqui tem uma explicação do que é uma classe:

http://pt.wikipedia.org/wiki/Classe_(pr ... %A7%C3%A3o)

As funções do sistema de classes são as seguintes:

-- Funções locais ( não edite nem remova elas, e também não as use se não souber o que está fazendo ): 
  
bool register ( class c ); 
  
bool unregister ( class c ); 
  
bool isRegistered ( class c ); 
  
-- Funções públicas: 
  
void class ( init ); 
  
bool isclass ( class c ); 
  
bool class_exists ( class c ); 
  
bool class_remove ( class c ); 

Exemplo:

class 'core'; 
  
function core:load( ) 
    self.print( 'Oi Oi Oi' ); 
end 
  
function core.print( s ) 
    if( type( s ) == 'string' ) then 
        _G['print']( s ); 
    end 
end 
  
print( isclass( core ) ); -- true; 
print( class_exists( core ) ); -- true; 
  
class_remove( core ); -- true; 
  
core:load(); -- Attempt to index global 'core' (a nil value) 
core.print(); -- Attempt to index global 'core' (a nil value) 
  
print( isclass( core ) ); -- false; 
print( class_exists( core ) ); -- false; 
  

Então, o código está aqui:

--[[ 
  
    Classlib ver.3-20494b 
    Written by Anderl 
  
]]-- 
  
Class = { } 
local registered = { } 
  
--register new class 
local function register( c ) 
    if ( registered[c.__name] ) then 
        return false; 
    end 
  
    registered[c.__name] = true; 
    return true; 
end 
  
--unregister class if exists 
local function unregister( c ) 
    if ( not registered[c.__name] ) then 
        return false; 
    end 
  
    registered[c.__name] = nil; 
    return true; 
end 
  
--check if class exists 
local function isRegistered( c ) 
    if ( type( c ) ~= 'table' ) then 
        return false; 
    end 
  
    if ( registered[c.__name] ) then 
        return true; 
    else 
        return false; 
    end 
end 
  
--create new class 
function class( init ) 
    if ( not init ) then 
        assert ( false, 'Attempt to create class [no init]' ); 
    end 
  
    loadstring( init .. ' = { __type = "class", __name = init }; c = '..init )( ); 
  
    setmetatable ( c, Class ); 
    register( c ); 
end 
  
--check if is class, return string or false 
function isclass( c ) 
    return type( c ) == 'table' and c.__type and c.__type == 'class' or false; 
end 
  
--return boolean, check if class exists 
function class_exists( c ) 
    return isRegistered( c ); 
end 
  
--remove class, return false if class doesn't exists 
function class_remove( c ) 
    if ( type( c ) ~= 'table' ) then 
        return false; 
    end 
  
    if ( isRegistered( c ) ) then 
        unregister( c ) 
        c = nil; 
        return true; 
    else 
        return false; 
    end 
end 
  

Aproveite e organize seu código com isso.

P.S. - Só para não vir falar "Qem é esse Anderl?", "Você esqueceu de roubar os créditos no ficheiro :lol:".. Eu sou o Anderl, tendeu?

[DNL291]

Poucos usuarios, realmente poucos vão entender para qual finalidade será util, já que também não foi explicado, e também não entendem sobre Class, enfim, bom trabalho!

[Anderl]

Eu botei uma explicação da Wikipedia no post..

http://pt.wikipedia.org/wiki/Classe_(pr ... %A7%C3%A3o)

[yMassai]

Eu n intendi isto realmente eu tenho que aprender, poderia me dizer se a sua portagem foi uma nota explicatória ou foi um pequeno tutorial?

Seria bem interessante você criar um tutorial a respeito.

[Anderl]

Então, basicamente uma classe é uma estrutura com vários membros, neste caso funções, que estão "inter-ligadas" entre si.

Você pode chamar outras funções da mesma classe usando a "variável" self, igual em C++ this.

Como LUA é orientada a funções e não a objetos, existem as metatabelas, que basicamente fazem o mesmo trabalho.

Uma classe define o "comportamente" de seus membros ( objectos da classe ) através de métodos,

Aqui um exemplo de um método:

myClass = { } 
myClass.__index = myClass; 
  
function myClass:init( ) --> método 
    -- instruçoes 
end 

Aqui um exemplo de um sistema de banco, parecido com o do site da linguagem LUA:

account = { } -- cria uma tabela que sera nossa classe 
  
-- declara o metodo 'new' que retorna uma instance da nossa conta 
function account:new( balance ) 
    -- se nenhum balanço for passado cria uma nova tabela com balanço 0 
    b = balance or { balance = 0 } 
    -- define a metatabela da nossa conta para account 
    setmetatable(b,account); 
    -- retorna a nossa conta 
    return b; 
end 
  
-- declara o metodo 'withdraw' que retorna o balanço da conta se nenhum balanço for passado 
function account:withdraw( self, balance ) 
    -- se nenhum balanço for passado 
    if( not balance ) then 
        -- retorna o balanço da conta 
        return self.balance; 
    end 
    
    -- se a conta tiver grana suficiente 
    if( self.balance >= balance ) then 
        -- retira a grana da conta 
        self.balance = self.balance - balance; 
    end 
    -- retorna o balanço da conta se nada for retornado, eu poderia ter usado 'else' tambem para o statement acima 
    return self.balance; 
end 

Agora:

acc = account:new( ) -- return object of ur acc 
  
acc:withdraw( 20 ); -- retorna o balanço da conta 
  
account.withdraw( acc, 20 ) -- isto faz o mesmo mas sem objecto 

Aí, tava sem nada pra fazer, então fiz um sistema de classes que torna tudo mais fácil em códigos muito grandes:

class 'account'; 
  
function account:new( balance ) 
    b = balance or { balance = 0 } 
    setmetatable(b,account); 
    return b; 
end 
  
function account:withdraw( self, balance ) 
    if( not balance ) then 
        return self.balance; 
    end 
     
    if( self.balance >= balance ) then 
        self.balance = self.balance - balance; 
    end 
    return self.balance; 
end 
  
if( class_exists( account ) ) then 
    acc = account:new( 500 ); 
    acc:withdraw( 20 ); -- retorna o balanço da conta 
    account.withdraw( acc, 20 ) -- isto faz o mesmo mas sem objecto 
end 
  
class_remove( account ); 
  
print( class_exists( account ) and 'true' or 'false' ); -- false; 

E o código fica muito melhor.

Não sei se é isto que você pretende, se não for, avise

[Anderl]

Update do sistema de classes, alguns bugs na criação da classe ( chaves __type e __name não estavam funcionando corretamente ):

--[[ 
  
    Classlib ver.4-20494b 
    Written by Anderl 
  
]]-- 
  
Class = { } 
local registered = { } 
  
--register new class 
local function register( c ) 
    if ( registered[c.__name] ) then 
        return false; 
    end 
  
    registered[c.__name] = true; 
    return true; 
end 
  
--unregister class if exists 
local function unregister( c ) 
    if ( not registered[c.__name] ) then 
        return false; 
    end 
  
    registered[c.__name] = nil; 
    return true; 
end 
  
--check if class exists 
local function isregistered( c ) 
    if ( type( c ) ~= 'table' ) then 
        return false; 
    end 
  
    if ( registered[c.__name] ) then 
        return true; 
    else 
        return false; 
    end 
end 
  
--create new class 
function class( init ) 
    if ( not init ) then 
        assert ( false, 'Attempt to create class [no init]' ); 
    end 
  
    loadstring( init .. ' = { }; c = '.. init )( ); 
  
    c.__type = "class"; 
    c.__name = t.init; 
    setmetatable ( c, Class ); 
    register( c ); 
end 
  
--check if is class, return string or false 
function isclass( c ) 
    return type( c ) == 'table' and c.__type == 'class' or false; 
end 
  
--return boolean, check if class exists 
function class_exists( c ) 
    return isregistered( c ); 
end 
  
--remove class, return false if class doesn't exists 
function class_remove( c ) 
    if ( type( c ) ~= 'table' ) then 
        return false; 
    end 
  
    if ( isregistered( c ) ) then 
        unregister( c ) 
        c = nil; 
        return true; 
    else 
        return false; 
    end 
end