CLASSES DE OBJETO EM xHarbour

b4stiv · Mensagem por **b4stiv** » 29 Abr 2005 16:55

Ola galera tudo bom

Eu gostaria de saber como que consigo uma documentação que possa me orientar na criação de CLASSES DE OBJETO para xHarbour.

Eu necessito criar classes de objeto assim como o Class(y) faz para o clipper pois tenho varias classes escritas utilizando a lib Class(y) e gostaria de converte-las para xHarbour.

Se alguem puder me ajudar eu agradeco muinto.

Abraços
STIV

PS: O amigo Wagner Nunes andou convertendo algumas libs para xHarbour sera que não seria possivel fazer o mesmo com a Class(y).LIB

culik · Mensagem por **culik** » 04 Mai 2005 06:39

Ola

vc pode usar o mesmo codigo fonte atual
apenas troque o include classy.ch para hbclass.ch

veja tambem http://www.xharbour.info

sugiro usar tambem news://news.xharbour.org/xharbour.spanish.portuguese por ser a news oficial do xharbur

[]s
Luiz

b4stiv · Mensagem por **b4stiv** » 04 Mai 2005 08:36

Ola culik

Muito obrigado pela sua resposta porem ainda tive alguns problemas eu fiz o que vc mandou ou seja subistitui o CLASS(Y).CH pelo HBCLASS.CH funcionou porem eu uso variaveis locais dentros dos metodos e eu obtive a seguinte mensagem de erro:

O meu sistema usa muitas classes desenvolvidas utilizando o Class(y) inclusive minha empresa esta terminando de desenvolver uma FRAMEWORK de widgets em modo texto para clipper tudo orientado a objetos, para poder portar o meu sistema para o xHarbour eu preciso de ajuda na conversão destas classes.

Se vc puder me ajudar nos temos a intenção de documentar e tornar esta FRAMEWORK FREE para xHarbour desde que eu consiga usar todos os recursos que o Class(y) me proporciona no xHarbour como Herança etc...

Desde ja agradeço sua atenção.

Obrigado

STIV

D:\HBTeste\estoque>harbour EDIBASE.PRG
xHarbour Compiler build 0.99.4 (SimpLex)
Copyright 1999-2005, http://www.xharbour.org http://www.harbour-project.org/
Compiling 'EDIBASE.PRG'...
EDIBASE.PRG(128) Error E0004 LOCAL declaration follows executable statement
EDIBASE.PRG(157) Error E0004 LOCAL declaration follows executable statement
EDIBASE.PRG(181) Error E0004 LOCAL declaration follows executable statement
EDIBASE.PRG(263) Error E0004 LOCAL declaration follows executable statement
EDIBASE.PRG(332) Error E0004 LOCAL declaration follows executable statement
EDIBASE.PRG(333) Error E0004 LOCAL declaration follows executable statement
EDIBASE.PRG(334) Error E0004 LOCAL declaration follows executable statement
EDIBASE.PRG(402) Error E0004 LOCAL declaration follows executable statement
EDIBASE.PRG(403) Error E0004 LOCAL declaration follows executable statement
EDIBASE.PRG(441) Error E0004 LOCAL declaration follows executable statement
EDIBASE.PRG(442) Error E0004 LOCAL declaration follows executable statement
11 errors

O codigo fonte esta aqui:

Código: Selecionar todos

/*
 *  EDIBASE.PRG
 *  Classe EDIBasico().
 *
 *  (c) 2004, Base4 Sistemas
 *  Daniel Goncalves
 *
 *  $Id: EDIBASE.PRG,v 1.1.1.1 2005/03/05 19:10:29 daniel Exp $
 */

#include "hbclass.ch"
#include "logging.ch"

#define CONFIG_FILE      "EDI.CFG"
#define MAX_SEARCH_KEYS  9999

CREATE CLASS EDIBasico
   
   VAR objLog   /* Logging() object... */
   
   VAR arTable  TYPE ARRAY
   VAR arMap    TYPE ARRAY
   VAR baseDir  TYPE CHARACTER
   
   METHOD _mapcfg
   METHOD _log
   METHOD _mapvars
   
   EXPORT:
      METHOD init CONSTRUCTOR
      METHOD getMap
      METHOD getMaps
      METHOD getSender
      METHOD getReceiver
   
   END CLASS

METHOD init( cBaseDir, oLog )
   
   /*
    *  verifica os argumentos...
    */
   IF ( oLog != NIL )
      IF ( oLog:isKindOf( Logging() ) )
         ::objLog := oLog
      ENDIF
   ENDIF
   
   ::_log( "Nova instancia..." )
   
   IF ( cBaseDir == NIL )
      ::baseDir := ".\"
      
   ELSE
      IF ( VALTYPE( cBaseDir ) # "C" )
         ::_log( "Argumento <baseDir> deve ser um argumento caracter.", LOG_FATAL )
         ALERT( ::className + "():init() / Argumento <baseDir> deve ser " + ;
                "um argumento do tipo CHARACTER." )
         QUIT
      ENDIF
      
      IF ( RIGHT( cBaseDir, 1 ) # "\" ) ; cBaseDir += "\" ; ENDIF
      
      IF ( !FILE( cBaseDir ) )
         ::_log( "O diretorio base <baseDir> nao existe " + ["] + ;
                 cBaseDir + ["...], LOG_WARNING )
         ::_log( "Sera usado o diretorio base " + [".\"...], LOG_WARNING )
         ::baseDir := ".\"
      ELSE
         ::baseDir := cBaseDir
      ENDIF
      
   ENDIF
   
   /*
    *  mapeia as configuracoes do arquivo de configuracoes...
    */
   ::_log( "BaseDir = " + ::baseDir )
   
   ::arMap := {}
   
   IF ( !FILE( ::baseDir + CONFIG_FILE ) )
      ::_log( "Arquivo de configuracoes (" + CONFIG_FILE + ") nao encontrado...", LOG_WARNING )
   ELSE
      ::_log( "Mapeando configuracoes de " + CONFIG_FILE + "..." )
      ::_mapcfg()
   ENDIF
   
   /*
    *  cria a tabela de referencia para obtencao dos objetos sender e
    *  receiver...
    */
   ::arTable := { { "USINARUETE",            1 /* EDI0001S.PRG/EDI0001R.PRG */ }, ;
                  { "USINACATANDUVA",        2 /* EDI0002S.PRG/EDI0002R.PRG */ }, ;
                  { "AGROPECNSCARMO",        3 /* EDI0003S.PRG/EDI0003R.PRG */ }, ;
                  { "COLOMBOAENCO",          4 /* EDI0004S.PRG/EDI0004R.PRG */ }, ;
                  { "COLOMBOCOTRAMI",        5 /* EDI0005S.PRG/EDI0005R.PRG */ }, ;
                  { "COLOMBOMIAC",           6 /* EDI0006S.PRG/EDI0006R.PRG */ }, ;
                  { "COLOMBOFUNDICAO",       7 /* EDI0007S.PRG/EDI0007R.PRG */ }, ;
                  { "COLOMBOFUNCIONARIOS",   8 /* EDI0008S.PRG/EDI0008R.PRG */ }, ;
                  { "COLOMBOINCOMAC",        9 /* EDI0009S.PRG/EDI0009R.PRG */ }, ;
                  { "COLOMBOSISTEC",        10 /* EDI0010S.PRG/EDI0010R.PRG */ }, ;
                  { "COLOMBOINTERNACIONAL", 11 /* EDI0011S.PRG/EDI0011R.PRG */ }, ;
                  { "COLOMBOSOCIOS",        12 /* EDI0012S.PRG/EDI0012R.PRG */ }, ;
                  { "USINASAODOMINGOS",     13 /* EDI0013S.PRG/EDI0013R.PRG */ }, ;
                  { "UCCERRADINHO",         14 /* EDI0014S.PRG/EDI0014R.PRG */ }, ;
                  { "UCNEIDESANCHES",       15 /* EDI0015S.PRG/EDI0015R.PRG */ }, ;
                  { "UCCASADOCE",           16 /* EDI0016S.PRG/EDI0016R.PRG */ }, ;
                  { "UCIKHAYA",             17 /* EDI0017S.PRG/EDI0017R.PRG */ }, ;
                  { "UC4CENTAOII",          18 /* EDI0018S.PRG/EDI0018R.PRG */ }, ;
                  { "UCPOSTONOVAIS",        19 /* EDI0019S.PRG/EDI0019R.PRG */ }, ;
                  { "UC4CENTAOPLUS",        20 /* EDI0020S.PRG/EDI0020R.PRG */ }  ;
                }
   
   RETURN ( self )

/*
 *  getMap() -> EDIMapping()
 *
 *  Retorna um objeto EDIMapping() cujo argumento possa ser localizado
 *  dentro dos mapeamentos (obtidos das configuracoes). O argumento deve
 *  ser um valor CHARACTER ou INTEGER, para que a busca pelo mapeamento
 *  seja feita pela chave ou pelo id, respectivamente.
 *
 *  Se o mapeamento nao puder ser localizado, o metodo retornara NIL.
 */
METHOD getMap( uParm )
   LOCAL nItem
   
   IF ( VALTYPE( uParm ) == "C" )
   
      FOR nItem := 1 TO LEN( ::arMap )
          IF ( UPPER( ::arMap[ nItem ]:key ) == UPPER( uParm ) )
             RETURN ( ::arMap[ nItem ]:deepCopy() )
          ENDIF
      NEXT
   
   ELSEIF ( VALTYPE( uParm ) == "N" )
      
      FOR nItem := 1 TO LEN( ::arMap )
          IF ( ::arMap[ nItem ]:id == uParm )
             RETURN ( ::arMap[ nItem ]:deepCopy() )
          ENDIF
      NEXT
   
   ENDIF
   
   RETURN ( NIL )

/*
 *  getMaps() -> Array
 *  
 *  Retorna todos os mapeamentos conhecidos como um array de
 *  objetos EDIMapping().
 */
METHOD getMaps()
   LOCAL n, aReturn := {}
   
   FOR n := 1 TO LEN( ::arMap )
       AADD( aReturn, ::arMap[ n ]:deepCopy() )
   NEXT
   
   RETURN ( aReturn )
   
/*
 *  getSender() -> EDIxxxxS()
 *
 *  Retorna um objeto EDIxxxxS() (1..9999) que seja capaz de executar
 *  a operacao de envio (processamento/criacao) de um arquivo de troca
 *  eletronica de dados em um determinado formato especifico.
 *
 *  O metodo sera capaz de decidir qual instancia de objeto retornar
 *  baseado no argumento EDIParmTo().
 *
 *  O metodo retorna NIL caso nao seja possivel encontrar uma
 *  implementacao especifica para o argumento.
 *
 *  Para mais comentarios, veja o fonte EDIxxxxS.PRG.
 */
METHOD getSender( oParm )
   LOCAL nImplID, n, bBlock, oProp, arVars, nVar
   
   IF ( !oParm:isKindOf( EDIParmTo() ) )
      ::_log( "Argumento <parm> deve ser um objeto da classe EDIParmTo().", LOG_FATAL )
      ALERT( ::className + "():getSender() / Argumento <parm> deve ser " + ;
             "um objeto da classe EDIParmTo()." )
      QUIT
   ENDIF
   
   nImplID := -1
   
   FOR n := 1 TO LEN( ::arTable )
       
       IF ( UPPER( ::arTable[ n ][ 1 ] ) == UPPER( oParm:targetKey ) )
          nImplID := ::arTable[ n ][ 2 ]
          EXIT
       ENDIF
   
   NEXT
   
   IF ( nImplID == -1 )
      ::_log( "Implementacao [" + oParm:targetKey + "] nao encontrada...", LOG_WARNING )
      RETURN ( NIL )
   ENDIF
   
   ::_log( [Obtendo SENDER para chave "] + oParm:targetKey + ["...] )
   
   oProp := ::_mapvars( oParm:targetKey )
   arVars := oProp:listKeys( "*" )
   
   ::_log( "Variaveis particulares: " )
   
   FOR nVar := 1 TO LEN( arVars )
       ::_log( SPACE( 4 ) + arVars[ nVar ] + [ = "] + ;
               oProp:asCharacter( arVars[ nVar ] ) + ["] )
   NEXT
   
   DO CASE
   CASE ( nImplID ==  1 ) ; RETURN ( EDI0001S():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID ==  2 ) ; RETURN ( EDI0002S():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID ==  3 ) ; RETURN ( EDI0003S():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID ==  4 ) ; RETURN ( EDI0004S():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID ==  5 ) ; RETURN ( EDI0005S():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID ==  6 ) ; RETURN ( EDI0006S():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID ==  7 ) ; RETURN ( EDI0007S():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID ==  8 ) ; RETURN ( EDI0008S():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID ==  9 ) ; RETURN ( EDI0009S():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID == 10 ) ; RETURN ( EDI0010S():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID == 11 ) ; RETURN ( EDI0011S():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID == 12 ) ; RETURN ( EDI0012S():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID == 13 ) ; RETURN ( EDI0013S():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID == 14 ) ; RETURN ( EDI0014S():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID == 15 ) ; RETURN ( EDI0015S():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID == 16 ) ; RETURN ( EDI0016S():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID == 17 ) ; RETURN ( EDI0017S():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID == 18 ) ; RETURN ( EDI0018S():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID == 19 ) ; RETURN ( EDI0019S():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID == 20 ) ; RETURN ( EDI0020S():new( oParm, ::objLog, oProp ) )
   
   ENDCASE
   
   ::_log( [Nenhuma implementacao conhecida para a chave "] + ;
           oParm:targetKey + "]...", LOG_ERROR )
   
   RETURN ( NIL )   

/*
 *  getReceiver() -> EDIxxxxR()
 *
 *  Retorna um objeto EDIxxxxR() (1..9999) que seja capaz de executar
 *  a operacao de retorno (processamento) de um arquivo de troca
 *  eletronica de dados de um determinado formato especifico.
 *
 *  O metodo sera capaz de decidir qual instancia de objeto retornar
 *  baseado no argumento EDIParmFrom().
 *
 *  O metodo retorna NIL caso nao seja possivel encontrar uma
 *  implementacao especifica para o argumento.
 *
 *  Para mais comentarios, veja o fonte EDIxxxxR.PRG.
 */
METHOD getReceiver( oParm )
   LOCAL nImplID, n, bBlock, oProp, arVars, nVar
   
   IF ( !oParm:isKindOf( EDIParmFrom() ) )
      ::_log( "Argumento <parm> deve ser um objeto da classe EDIParmFrom().", LOG_FATAL )
      ALERT( ::className + "():getSender() / Argumento <parm> deve ser " + ;
             "um objeto da classe EDIParmFrom()." )
      QUIT
   ENDIF
   
   nImplID := -1
   
   FOR n := 1 TO LEN( ::arTable )
       
       IF ( UPPER( ::arTable[ n ][ 1 ] ) == UPPER( oParm:sourceKey ) )
          nImplID := ::arTable[ n ][ 2 ]
          EXIT
       ENDIF
   
   NEXT
   
   IF ( nImplID == -1 )
      ::_log( "Implementacao [" + oParm:sourceKey + "] nao encontrada...", LOG_WARNING )
      RETURN ( NIL )
   ENDIF
   
   ::_log( [Obtendo RECEIVER para chave "] + oParm:sourceKey + ["...] )
   
   oProp := ::_mapvars( oParm:sourceKey )
   arVars := oProp:listKeys( "*" )
   
   ::_log( "Variaveis particulares: " )
   
   FOR nVar := 1 TO LEN( arVars )
       ::_log( SPACE( 4 ) + arVars[ nVar ] + [ = "] + ;
               oProp:asCharacter( arVars[ nVar ] ) + ["] )
   NEXT
   
   DO CASE
   CASE ( nImplID ==  1 ) ; RETURN ( EDI0001R():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID ==  2 ) ; RETURN ( EDI0002R():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID ==  3 ) ; RETURN ( EDI0003R():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID == 13 ) ; RETURN ( EDI0013R():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID == 14 ) ; RETURN ( EDI0014R():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID == 15 ) ; RETURN ( EDI0015R():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID == 16 ) ; RETURN ( EDI0016R():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID == 17 ) ; RETURN ( EDI0017R():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID == 18 ) ; RETURN ( EDI0018R():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID == 19 ) ; RETURN ( EDI0019R():new( oParm, ::objLog, oProp ) )
   CASE ( nImplID == 20 ) ; RETURN ( EDI0020R():new( oParm, ::objLog, oProp ) )
   ENDCASE
   
   ::_log( [Nenhuma implementacao conhecida para a chave "] + ;
           oParm:sourceKey + "]...", LOG_ERROR )
   
   RETURN ( NIL )
   
   
/*  ///////////////////////////////////////////////////// 
    //
    //  metodos hidden
    //
    */
    
/*
 *  _mapcfg() -> NIL
 *
 *
 */
METHOD _mapcfg()
   LOCAL nKey, oProp
   LOCAL cKey, nKeyId, cKeyPath, cKeyToFile, cKeyFromFile, lAccept
   LOCAL oMap
   
   IF FILE( (::baseDir + CONFIG_FILE) )
      oProp := Properties():new( ::baseDir + CONFIG_FILE )
   ELSE
      oProp := Properties():new()   
   ENDIF
   
   ::arMap := {}
   
   FOR nKey := 1 TO MAX_SEARCH_KEYS
       
       lAccept := .T.
       cKey := oProp:asCharacter( "convenio.key" + ALLTRIM( STR( nKey ) ) )
       ::_log( "Chave " + ALLTRIM( STR( nKey ) ) + " = [" + cKey + "]..." )
       
       IF ( EMPTY( cKey ) ) ; EXIT ; ENDIF
       
       nKeyId       := oProp:asInteger( "convenio." + cKey + ".id" )
       cKeyPath     := oProp:asCharacter( "convenio." + cKey + ".repositorio" )
       cKeyToFile   := oProp:asCharacter( "convenio." + cKey + ".arquivo.enviar" )
       cKeyFromFile := oProp:asCharacter( "convenio." + cKey + ".arquivo.receber" )
       
       /*
        *  valida a chave...
        */
       IF ( nKeyId <= 0 )
          ::_log( "Chave [" + cKey + "] id=" + ALLTRIM( STR( nKeyId ) ) + " invalido!", LOG_WARNING )
          ::_log( "Chave [" + cKey + "] REJEITADA..." )
          lAccept := .F.
       ENDIF
       
       IF ( EMPTY( cKeyPath ) )
          ::_log( "Chave [" + cKey + "] repositorio/path=(empty)" )
       ENDIF
       
       IF ( EMPTY( cKeyToFile ) )
          ::_log( "Chave [" + cKey + "] arquivo.enviar=(empty)" )
       ENDIF
       
       IF ( EMPTY( cKeyFromFile ) )
          ::_log( "Chave [" + cKey + "] arquivo.receber=(empty)" )
       ENDIF
       
       IF ( lAccept )
          oMap := EDIMapping():new()
          oMap:key      := cKey
          oMap:id       := nKeyId
          oMap:path     := cKeyPath
          oMap:toFile   := cKeyToFile
          oMap:fromFile := cKeyFromFile
          
          ::_log( "Mapeado: " + oMap:toString() )
          AADD( ::arMap, oMap:deepCopy() )
       ENDIF
   
   NEXT
   
   ::_log( "Mapeamento concluido!" )
   
   RETURN ( NIL )

/*
 *  _mapvars() -> Properties()
 *
 *
 */
METHOD _mapvars( cKey )
   LOCAL nKey, oProp
   LOCAL aArray, oReturn, cNewKey, cPattern
   
   IF FILE( ::baseDir + CONFIG_FILE )
      oProp := Properties():new( ::baseDir + CONFIG_FILE )
   ELSE
      oProp := Properties():new()   
   ENDIF
   
   cPattern := "convenio." + cKey + ".propriedade.*"
   aArray   := oProp:listKeys( cPattern )
   oReturn  := Properties():new()
   
   ::_log( "Mapping vars/pattern=" + CHR( 34 ) + ;
           cPattern + CHR( 34 ) + "..." )
   
   IF ( LEN( aArray ) # 0 )
   
      FOR nKey := 1 TO LEN( aArray )
          cNewKey := RIGHT( aArray[ nKey ], ;
                     LEN( aArray[ nKey ] ) - ( LEN( cPattern ) - 1 ) )
          oReturn:set( cNewKey, oProp:asCharacter( aArray[ nKey ] ) )
          ::_log( "Var mapped: " + CHR( 34 ) + ;
                  cNewKey + CHR( 34 ) + "..." )
      NEXT
   
   ELSE
      ::_log( "No one vars mapped!" )
      
   ENDIF
   
   RETURN ( oReturn )

/*
 *  _log() -> NIL
 *
 *  Envia uma mensagem para ser escrita no log.
 */
METHOD _log( cMsg, nLevel )
   LOCAL cCaller := PROCNAME( 1 ) + "(" + ALLTRIM( STR( PROCLINE( 1 ) ) ) + ")"
   LOCAL nLogLevel := LOG_NORMAL
   
   IF ( ::objLog == NIL ) ; RETURN ( NIL ) ; ENDIF
   IF ( nLevel # NIL ) ; nLogLevel := nLevel ; ENDIF
   ::objLog:write( ::className + "(): " + cCaller + " / " + LTRIM( cMsg ), ;
                   nLogLevel )
   
   RETURN ( NIL )

culik · Mensagem por **culik** » 09 Mai 2005 07:02

Ola

E muito simples de resolver

em cada metodo declarado na classe coloque no fina

se tinha method xxx que e parte da classe yyy coloque

method xxx class yyy

sugiro a partir de agora postar preferencialmente em news://news.xharbour.org/xharbour.spanish.portuguese

[]s
Luiz
www.xharbour.com.br