PDF Exporter Purchase

You are using an UNLICENSED copy of Scroll PDF Exporter for Confluence.
Do you find Scroll PDF Exporter useful? Consider purchasing it today: https://www.k15t.com/software/scroll-pdf-exporter
TOTVSTEC
Exported on 07/08/2022

O que há de novo ... Recursos
TOTVSTEC – O que há de novo ... Recursos
You are using an UNLICENSED copy of Scroll PDF Exporter for Confluence. Do you find Scroll PDF Exporter useful? Consider purchasing it today: https://www.k15t.com/software/scroll-pdf-exporter
Table of Contents
1 Encapsulamento - Modificador de Acesso...................................................... 13
2 Expressões Regulares (RegEx)......................................................................... 14
3 Interface ........................................................................................................... 15
4 Json................................................................................................................... 16
5 Método Estático ............................................................................................... 17
6 Namespace....................................................................................................... 18
7 Nomes longos................................................................................................... 19
8 Reflection e Annotation ................................................................................... 20
9 Representational State Transfer (REST) ......................................................... 21
10 Sobrecarga de Operadores.............................................................................. 22
11 TGetData e TGetMethods................................................................................. 23
12 Tipagem em TL++............................................................................................. 24
13 Try...Catch ........................................................................................................ 25
14 Encapsulamento - Modificador de Acesso...................................................... 26
15 Expressões Regulares (RegEx)......................................................................... 28
16 Interface ........................................................................................................... 29
17 Json................................................................................................................... 30
17.1 Exemplo 2: ............................................................................................................................. 30
18 Método Estático ............................................................................................... 33
19 Namespace....................................................................................................... 35
19.1 Funções dentro de namespace: ........................................................................................... 35
19.1.1 Exemplo:.............................................................................................................................................................. 35
19.2 Classes dentro de namespace:............................................................................................. 36
19.2.1 Exemplo:.............................................................................................................................................................. 36
20 Nomes longos................................................................................................... 38
21 Reflection e Annotation ................................................................................... 39
– 2
21.1 Novas funções disponíveis para uso juntamente com o recurso de Annotation, as funções
foram disponibilizadas dentro do namespace Reflection: ................................................. 40

21.2 Classe Attribute ..................................................................................................................... 40
21.2.1 Propriedades ....................................................................................................................................................... 40
21.2.2 Métodos ............................................................................................................................................................... 40
21.2.3 Exemplos ............................................................................................................................................................. 41
21.2.4 Retorno do exemplo ........................................................................................................................................... 42
21.2.5 Classe Attribute - Métodos.................................................................................................................................. 42
21.2.5.1 Attribute:Assign................................................................................................................................................... 42
21.2.5.2 Attribute:GetValue .............................................................................................................................................. 43
21.2.5.3 Attribute:toString................................................................................................................................................ 45
21.2.6 Classe Attribute - Propriedades.......................................................................................................................... 46
21.2.6.1 Propriedade Attribute:cAttributeName ............................................................................................................. 46
21.2.6.2 Propriedade Attribute:cAttributeType............................................................................................................... 46
21.3 Classe Method ....................................................................................................................... 47
21.3.1 Propriedades ....................................................................................................................................................... 47
21.3.2 Métodos ............................................................................................................................................................... 47
21.3.3 Exemplos ............................................................................................................................................................. 47
21.3.4 Retorno do exemplo ........................................................................................................................................... 48
21.3.5 Classe Method - Métodos.................................................................................................................................... 49
21.3.5.1 Method:Execute .................................................................................................................................................. 49
21.3.5.2 Method:toString .................................................................................................................................................. 51
21.3.6 Classe Method - Propriedades............................................................................................................................ 52
21.3.6.1 Method:aParameters .......................................................................................................................................... 52
21.3.6.2 Method:cMethodName ....................................................................................................................................... 52
21.4 Classe Class ........................................................................................................................... 53
21.4.1 Propriedades ....................................................................................................................................................... 53
21.4.2 Métodos ............................................................................................................................................................... 53
21.4.3 Exemplos ............................................................................................................................................................. 53
21.4.4 Classe Class - Métodos ........................................................................................................................................ 54
21.4.4.1 Class:CreateInstance .......................................................................................................................................... 54
21.4.4.2 Class:toString ...................................................................................................................................................... 55
21.4.5 Classe Class - Propriedades................................................................................................................................ 56
21.4.5.1 Propriedade Class:cClassName.......................................................................................................................... 56
21.4.5.2 Propriedade Class:cProgramName.................................................................................................................... 56
– 3
21.5 Reflection.getAttributesByAnnotation ................................................................................ 56

21.5.1 Sintaxe ................................................................................................................................................................. 56

21.5.2 Parâmetros.......................................................................................................................................................... 57
21.5.3 Retorno ................................................................................................................................................................ 57
21.5.4 Exemplos ............................................................................................................................................................. 57
21.5.5 Resultado do Exemplo........................................................................................................................................ 58
21.5.6 Abrangência ........................................................................................................................................................ 58
21.5.7 Veja também ....................................................................................................................................................... 58
21.6 Reflection.getClassAnnotation............................................................................................. 58
21.6.1 Sintaxe ................................................................................................................................................................. 58
21.6.2 Parâmetros.......................................................................................................................................................... 58
21.6.3 Retorno ................................................................................................................................................................ 59
21.6.4 Exemplos ............................................................................................................................................................. 59
21.6.6 Abrangência ........................................................................................................................................................ 59
21.6.7 Veja também ....................................................................................................................................................... 59
21.7 Reflection.getClassAnnotationList....................................................................................... 59
21.7.1 Sintaxe ................................................................................................................................................................. 60
21.7.2 Parâmetros.......................................................................................................................................................... 60
21.7.3 Retorno ................................................................................................................................................................ 60
21.7.4 Exemplos ............................................................................................................................................................. 60
21.7.6 Abrangência ........................................................................................................................................................ 61
21.7.7 Veja também ....................................................................................................................................................... 61
21.8 Reflection.getDataAnnotation ............................................................................................. 61
21.8.1 Sintaxe ................................................................................................................................................................. 61
21.8.2 Parâmetros.......................................................................................................................................................... 61
21.8.3 Retorno ................................................................................................................................................................ 62
21.8.4 Exemplos ............................................................................................................................................................. 62
21.8.6 Abrangência ........................................................................................................................................................ 62
21.8.7 Veja também ....................................................................................................................................................... 63
21.9 Reflection.getClassesByAnnotation..................................................................................... 63
21.9.1 Sintaxe ................................................................................................................................................................. 63
– 4
21.9.2 Parâmetros.......................................................................................................................................................... 63
21.9.3 Retorno ................................................................................................................................................................ 63

21.9.4 Exemplos ............................................................................................................................................................. 63
21.9.6 Abrangência ........................................................................................................................................................ 64
21.9.7 Veja também ....................................................................................................................................................... 64
21.10 Reflection.getDataAnnotationList ....................................................................................... 65
21.10.1 Sintaxe ................................................................................................................................................................. 65
21.10.2 Parâmetros.......................................................................................................................................................... 65
21.10.3 Retorno ................................................................................................................................................................ 65
21.10.4 Exemplos ............................................................................................................................................................. 65
21.10.6 Abrangência ........................................................................................................................................................ 66
21.10.7 Veja também ....................................................................................................................................................... 66
21.11 Reflection.getDataValue ....................................................................................................... 66
21.11.1 Sintaxe ................................................................................................................................................................. 66
21.11.2 Parâmetros.......................................................................................................................................................... 67
21.11.3 Retorno ................................................................................................................................................................ 67
21.11.4 Exemplos ............................................................................................................................................................. 67
21.11.6 Abrangência ........................................................................................................................................................ 67
21.11.7 Veja também ....................................................................................................................................................... 68
21.12 Reflection.getDeclaredFields ............................................................................................... 68
21.12.1 Sintaxe ................................................................................................................................................................. 68
21.12.2 Parâmetros.......................................................................................................................................................... 68
21.12.3 Retorno ................................................................................................................................................................ 68
21.12.4 Exemplos ............................................................................................................................................................. 68
21.12.6 Abrangência ........................................................................................................................................................ 69
21.12.7 Veja também ....................................................................................................................................................... 69
21.13 Reflection.getFunctionAnnotation ...................................................................................... 69
21.13.1 Sintaxe ................................................................................................................................................................. 69
21.13.2 Parâmetros.......................................................................................................................................................... 69
21.13.3 Retorno ................................................................................................................................................................ 70
21.13.4 Exemplos ............................................................................................................................................................. 70
– 5

21.13.6 Abrangência ........................................................................................................................................................ 70

21.13.7 Veja também ....................................................................................................................................................... 70
21.14 Reflection.getFunctionAnnotationList ................................................................................ 71
21.14.1 Sintaxe ................................................................................................................................................................. 71
21.14.2 Parâmetros.......................................................................................................................................................... 71
21.14.3 Retorno ................................................................................................................................................................ 71
21.14.4 Exemplos ............................................................................................................................................................. 71
21.14.6 Abrangência ........................................................................................................................................................ 72
21.14.7 Veja também ....................................................................................................................................................... 72
21.15 Reflection.getFunctionParamAnnotation ........................................................................... 72
21.15.1 Sintaxe ................................................................................................................................................................. 72
21.15.2 Parâmetros.......................................................................................................................................................... 72
21.15.3 Retorno ................................................................................................................................................................ 73
21.15.4 Exemplos ............................................................................................................................................................. 73
21.15.6 Abrangência ........................................................................................................................................................ 74
21.15.7 Veja também ....................................................................................................................................................... 74
21.16 Reflection.getFunctionParmsByAnnotation ....................................................................... 74
21.16.1 Sintaxe ................................................................................................................................................................. 74
21.16.2 Parâmetros.......................................................................................................................................................... 74
21.16.3 Retorno ................................................................................................................................................................ 75
21.16.4 Exemplos ............................................................................................................................................................. 75
21.16.6 Abrangência ........................................................................................................................................................ 75
21.16.7 Veja também ....................................................................................................................................................... 75
21.17 Reflection.getFunctionsByAnnotation ................................................................................ 75
21.17.1 Sintaxe ................................................................................................................................................................. 76
21.17.2 Parâmetros.......................................................................................................................................................... 76
21.17.3 Retorno ................................................................................................................................................................ 76
21.17.4 Exemplos ............................................................................................................................................................. 76
21.17.6 Abrangência ........................................................................................................................................................ 77
21.17.7 Veja também ....................................................................................................................................................... 77
– 6
21.18 Reflection.getMethodAnnotation ........................................................................................ 77

21.18.1 Sintaxe ................................................................................................................................................................. 77

21.18.2 Parâmetros.......................................................................................................................................................... 77
21.18.3 Retorno ................................................................................................................................................................ 78
21.18.4 Exemplos ............................................................................................................................................................. 78
21.18.6 Abrangência ........................................................................................................................................................ 79
21.18.7 Veja também ....................................................................................................................................................... 79
21.19 Reflection.getMethodAnnotationList .................................................................................. 79
21.19.1 Sintaxe ................................................................................................................................................................. 79
21.19.2 Parâmetros.......................................................................................................................................................... 79
21.19.3 Retorno ................................................................................................................................................................ 79
21.19.4 Exemplos ............................................................................................................................................................. 80
21.19.6 Abrangência ........................................................................................................................................................ 80
21.19.7 Veja também ....................................................................................................................................................... 80
21.20 Reflection.getMethodParmAnnotation ............................................................................... 81
21.20.1 Sintaxe ................................................................................................................................................................. 81
21.20.2 Parâmetros.......................................................................................................................................................... 81
21.20.3 Retorno ................................................................................................................................................................ 81
21.20.4 Exemplos ............................................................................................................................................................. 81
21.20.6 Abrangência ........................................................................................................................................................ 82
21.20.7 Veja também ....................................................................................................................................................... 82
21.21 Reflection.getMethodParmsByAnnotation ......................................................................... 82
21.21.1 Sintaxe ................................................................................................................................................................. 82
21.21.2 Parâmetros.......................................................................................................................................................... 83
21.21.3 Retorno ................................................................................................................................................................ 83
21.21.4 Exemplos ............................................................................................................................................................. 83
21.21.6 Abrangência ........................................................................................................................................................ 84
21.21.7 Veja também ....................................................................................................................................................... 84
21.22 Reflection.getMethodsByAnnotation .................................................................................. 84
21.22.1 Sintaxe ................................................................................................................................................................. 84
– 7
21.22.2 Parâmetros.......................................................................................................................................................... 84
21.22.3 Retorno ................................................................................................................................................................ 85

21.22.4 Exemplos ............................................................................................................................................................. 85
21.22.6 Abrangência ........................................................................................................................................................ 86
21.22.7 Veja também ....................................................................................................................................................... 86
21.23 Reflection.getMethodsObjectByAnnotation ....................................................................... 86
21.23.1 Sintaxe ................................................................................................................................................................. 86
21.23.2 Parâmetros.......................................................................................................................................................... 87
21.23.3 Retorno ................................................................................................................................................................ 87
21.23.4 Exemplos ............................................................................................................................................................. 87
21.23.6 Abrangência ........................................................................................................................................................ 88
21.23.7 Veja também ....................................................................................................................................................... 88
21.24 Reflection.getObjectAnnotation .......................................................................................... 88
21.24.1 Sintaxe ................................................................................................................................................................. 88
21.24.2 Parâmetros.......................................................................................................................................................... 89
21.24.3 Retorno ................................................................................................................................................................ 89
21.24.4 Exemplos ............................................................................................................................................................. 89
21.24.6 Abrangência ........................................................................................................................................................ 90
21.24.7 Veja também ....................................................................................................................................................... 90
21.25 Reflection.getProgramFunctionsByAnnotation.................................................................. 90
21.25.1 Sintaxe ................................................................................................................................................................. 90
21.25.2 Parâmetros.......................................................................................................................................................... 90
21.25.3 Retorno ................................................................................................................................................................ 90
21.25.4 Exemplos ............................................................................................................................................................. 91
21.25.6 Abrangência ........................................................................................................................................................ 91
21.25.7 Veja também ....................................................................................................................................................... 91
21.26 Reflection.isAnnotationDataPresent ................................................................................... 91
21.26.1 Sintaxe ................................................................................................................................................................. 91
21.26.2 Parâmetros.......................................................................................................................................................... 92
21.26.3 Retorno ................................................................................................................................................................ 92
21.26.4 Exemplos ............................................................................................................................................................. 92
– 8

21.26.6 Abrangência ........................................................................................................................................................ 93

21.26.7 Veja também ....................................................................................................................................................... 93
21.27 Reflection.isAnnotationFunctionPresent ............................................................................ 93
21.27.1 Sintaxe ................................................................................................................................................................. 93
21.27.2 Parâmetros.......................................................................................................................................................... 93
21.27.3 Retorno ................................................................................................................................................................ 94
21.27.4 Exemplos ............................................................................................................................................................. 94
21.27.6 Abrangência ........................................................................................................................................................ 94
21.27.7 Veja também ....................................................................................................................................................... 94
21.28 Reflection.isAnnotationMethodPresent .............................................................................. 94
21.28.1 Sintaxe ................................................................................................................................................................. 95
21.28.2 Parâmetros.......................................................................................................................................................... 95
21.28.3 Retorno ................................................................................................................................................................ 95
21.28.4 Exemplos ............................................................................................................................................................. 95
21.28.6 Abrangência ........................................................................................................................................................ 96
21.28.7 Veja também ....................................................................................................................................................... 96
21.29 Reflection.isAnnotationObjectPresent ................................................................................ 96
21.29.1 Sintaxe ................................................................................................................................................................. 96
21.29.2 Parâmetros.......................................................................................................................................................... 96
21.29.3 Retorno ................................................................................................................................................................ 97
21.29.4 Exemplos ............................................................................................................................................................. 97
21.29.6 Abrangência ........................................................................................................................................................ 97
21.29.7 Veja também ....................................................................................................................................................... 97
21.30 Reflection.isAnnottationFunctionParamPresent................................................................ 97
21.30.1 Sintaxe ................................................................................................................................................................. 98
21.30.2 Parâmetros.......................................................................................................................................................... 98
21.30.3 Retorno ................................................................................................................................................................ 98
21.30.4 Exemplos ............................................................................................................................................................. 98
21.30.6 Abrangência ........................................................................................................................................................ 99
21.30.7 Veja também ....................................................................................................................................................... 99
– 9
21.31 Reflection.isAnnottationMethodParamPresent.................................................................. 99
21.31.1 Sintaxe ................................................................................................................................................................. 99

21.31.2 Parâmetros.......................................................................................................................................................... 99
21.31.3 Retorno .............................................................................................................................................................. 100
21.31.4 Exemplos ........................................................................................................................................................... 100
21.31.5 Resultado do Exemplo...................................................................................................................................... 100
21.31.6 Abrangência ...................................................................................................................................................... 101
21.31.7 Veja também ..................................................................................................................................................... 101
21.32 Reflection.getClassByName ............................................................................................... 101
21.32.1 Sintaxe ............................................................................................................................................................... 101
21.32.2 Parâmetros........................................................................................................................................................ 101
21.32.3 Retorno .............................................................................................................................................................. 101
21.32.4 Exemplos ........................................................................................................................................................... 102
21.32.5 Resultado do Exemplo...................................................................................................................................... 103
21.32.6 Veja também ..................................................................................................................................................... 103
22 Representational State Transfer (REST) ....................................................... 104

23 Sobrecarga de Operadores............................................................................ 105
23.1 Resultado do Exemplo........................................................................................................ 107
23.2 Abrangência ........................................................................................................................ 107
24 TGetData e TGetMethods............................................................................... 108
25 Tipagem em TL++........................................................................................... 110
25.1 Introdução........................................................................................................................... 110
25.2 Requisitos ............................................................................................................................ 110
25.3 Tipos Nativos....................................................................................................................... 110
25.4 Tipando Variáveis................................................................................................................ 113
25.5 Tipando Propriedades ........................................................................................................ 113
25.6 Tipando Funções................................................................................................................. 114
25.7 Tipando Métodos ................................................................................................................ 115
25.8 Tipando Parâmetros ........................................................................................................... 116
25.8.1 Variadic .............................................................................................................................................................. 118
25.9 Inicialização Default............................................................................................................ 119
25.10 Regras de Tipagem.............................................................................................................. 119
– 10
25.10.1 Tabela Verdade ................................................................................................................................................. 119

25.10.2 Atribuição .......................................................................................................................................................... 120

25.10.3 Operações Aditivas ........................................................................................................................................... 121
25.10.4 Operações Multiplicativas ................................................................................................................................ 122
25.10.5 Operações Comparativas ................................................................................................................................. 123
25.10.6 Operação "Contido em ..."................................................................................................................................ 126
25.10.7 Operações Lógicas ............................................................................................................................................ 127
25.10.8 Expressão com Sinal ......................................................................................................................................... 129
25.10.9 Expressões de Incremento ............................................................................................................................... 130
25.10.10 IF e While............................................................................................................................................................ 131
25.10.11 Comando For..................................................................................................................................................... 132
25.10.12 IF Ternário ......................................................................................................................................................... 133
25.10.13 Acesso a Array ................................................................................................................................................... 134
25.10.14 Acesso a Json .................................................................................................................................................... 135
26 Try...Catch ...................................................................................................... 136

26.1 01. SINTAXE ......................................................................................................................... 136
26.2 02. PARÂMETROS ................................................................................................................ 136
26.3 03. EXEMPLOS ..................................................................................................................... 137
26.4 04. ABRANGÊNCIA ............................................................................................................... 142
26.5 05. VEJA TAMBÉM ................................................................................................................ 142
– 11
Aqui você irá encontrar todos os recursos da linguagem TL++
– 12
1 Encapsulamento - Modificador de Acesso
Encapsulamento - Modificador de Acesso – 13

2 Expressões Regulares (RegEx)
Expressões Regulares (RegEx) – 14

3 Interface
Interface – 15
4 Json
Json – 16
5 Método Estático
Método Estático – 17
6 Namespace
Namespace – 18
7 Nomes longos
Nomes longos – 19
8 Reflection e Annotation
• Classe Attribute(see page 40)

• Classe Attribute - Métodos(see page 42)
• Attribute:Assign(see page 42)
• Attribute:GetValue(see page 43)
• Attribute:toString(see page 45)
• Classe Attribute - Propriedades(see page 46)
• Propriedade Attribute:cAttributeName(see page 46)
• Propriedade Attribute:cAttributeType(see page 46)
• Classe Method(see page 47)
• Classe Method - Métodos(see page 49)
• Method:Execute(see page 49)
• Method:toString(see page 51)
• Classe Method - Propriedades(see page 52)
• Method:aParameters(see page 52)
• Method:cMethodName(see page 52)
• Classe Class(see page 53)
• Classe Class - Métodos(see page 54)
• Class:CreateInstance(see page 54)
• Class:toString(see page 55)
• Classe Class - Propriedades(see page 56)
• Propriedade Class:cClassName(see page 56)
• Propriedade Class:cProgramName(see page 56)
• Reflection.getAttributesByAnnotation(see page 56)
• Reflection.getClassAnnotation(see page 58)
• Reflection.getClassAnnotationList(see page 59)
• Reflection.getDataAnnotation(see page 61)
• Reflection.getClassesByAnnotation(see page 63)
• Reflection.getDataAnnotationList(see page 65)
• Reflection.getDataValue(see page 66)
• Reflection.getDeclaredFields(see page 68)
• Reflection.getFunctionAnnotation(see page 69)
• Reflection.getFunctionAnnotationList(see page 71)
• Reflection.getFunctionParamAnnotation(see page 72)
• Reflection.getFunctionParmsByAnnotation(see page 74)
• Reflection.getFunctionsByAnnotation(see page 75)
• Reflection.getMethodAnnotation(see page 77)
• Reflection.getMethodAnnotationList(see page 79)
• Reflection.getMethodParmAnnotation(see page 81)
• Reflection.getMethodParmsByAnnotation(see page 82)
• Reflection.getMethodsByAnnotation(see page 84)
• Reflection.getMethodsObjectByAnnotation(see page 86)
• Reflection.getObjectAnnotation(see page 88)
• Reflection.getProgramFunctionsByAnnotation(see page 90)
• Reflection.isAnnotationDataPresent(see page 91)
• Reflection.isAnnotationFunctionPresent(see page 93)
• Reflection.isAnnotationMethodPresent(see page 94)
• Reflection.isAnnotationObjectPresent(see page 96)
• Reflection.isAnnottationFunctionParamPresent(see page 97)
• Reflection.isAnnottationMethodParamPresent(see page 99)
• Reflection.getClassByName(see page 101)
Reflection e Annotation – 20
9 Representational State Transfer (REST)
Representational State Transfer (REST) – 21

10 Sobrecarga de Operadores
Sobrecarga de Operadores – 22
11 TGetData e TGetMethods
TGetData e TGetMethods – 23
12 Tipagem em TL++
• Introdução(see page 110)

• Requisitos(see page 110)
• Tipos Nativos(see page 110)
• Tipando Variáveis(see page 113)
• Tipando Propriedades(see page 113)
• Tipando Funções(see page 114)
• Tipando Métodos(see page 115)
• Tipando Parâmetros(see page 116)
• Variadic(see page 118)
• Inicialização Default(see page 119)
• Regras de Tipagem(see page 119)
• Tabela Verdade(see page 119)
• Atribuição(see page 120)
• Operações Aditivas(see page 121)
• Operações Multiplicativas(see page 122)
• Operações Comparativas(see page 123)
• Operação "Contido em ..."(see page 126)
• Operações Lógicas(see page 127)
• Expressão com Sinal(see page 129)
• Expressões de Incremento(see page 130)
• IF e While(see page 131)
• Comando For(see page 132)
• IF Ternário(see page 133)
• Acesso a Array(see page 134)
• Acesso a Json(see page 135)
Tipagem em TL++ – 24
13 Try...Catch
Try...Catch – 25
14 Encapsulamento - Modificador de Acesso

Abrangência
Versão 17.3.0.0 e superiores
A partir da versão 17.3.0.0 o recurso de modificador de acesso está disponível no TL++ e no ADVPL.
É necessário utilizar este include atualizado: msobject.ch
O nível do modificador padrão é PRIVATE, no ADVPL padrão essa funcionalidade também está disponível, porém o
padrão é PUBLIC.
Os níveis de modificadores são:
NÍVEIS
PRIVATE O método ou a propriedade estarão acessíveis apenas de dentro da

classe.
PROTECTED O método ou a propriedade estarão acessíveis apenas de dentro da

classe e das classes herdadas dela.
PUBLIC O método ou a propriedade estarão acessíveis de qualquer lugar.
Exemplo
class EscopeMethod
private data oComp1
public data oComp2
protected data oComp3
data oComp4
public method new()
private method teste1()
public method teste2()
protected method teste3()
endclass
method new() class EscopeMethod
return self
method teste1() class EscopeMethod
conout("teste1")
return self
self:oComp1 := 1
self:oComp2 := 2
self:oComp3 := 3
self:teste1()
conout("teste2")
self:teste3()
return self



conout("teste3")
return self

user function escope
local myObj := EscopeMethod():New()
myObj:oComp2 := 2
conout("myObj:oComp2", myObj:oComp2)
/*myObj:oComp1 := 1
conout("myObj:oComp1", myObj:oComp1)*/ //não é possível descomentar esse trecho de código pois o atributo
oComp1 é private e causará um erro de execução.
/*myObj:oComp3 := 3
conout("myObj:oComp3", myObj:oComp3)*/ //não é possível descomentar esse trecho de código pois o atributo
oComp3 é protected e causará um erro de execução.
//myObj:teste1() - não é possível descomentar esse trecho de código pois o método teste1 é private e
causará um erro de execução.
myObj:teste2()
//myObj:teste3() - não é possível descomentar esse trecho de código pois o método teste3 é protected e
causará um erro de execução.
return

15 Expressões Regulares (RegEx)

A documentação dessa funcionalidade está na área "Produtos do tlppCore"
https://tdn.totvs.com/display/tec/RegEx(see page 28)

Clique no link acima se você não for redirecionado automaticamente em 5 segundos.
Expressões Regulares (RegEx) – 28

16 Interface
Abrangência
A partir da versão 17.3.0.0 será possível a definição de interface e a utilização da mesma na definição das classes.
Uma classe pode implementar uma ou mais interfaces, todas tem que estar definidas no mesmo fonte ou em um
include desse fonte.
Interface.tlpp
1 #include "protheus.ch"
2 //A definição da interface deverá estar no mesmo fonte em que está a classe, mas poderá estar
dentro de um include também.
3 Interface FWTEST
4 Method run()
5 EndInterface
6
7
8 Class MeuTest implements FWTEST
9 Method run()
10 EndClass
11
12 Method run() Class MeuTest
13 Return
14
15
16 //erro de compilação pois não tem a implementação do método run que está definido na interface
FWTEST
17 Class MeuTest2 implements FWTEST
18 Method run2()
19 EndClass
20
21
22 Method run2() Class MeuTest2
23 Return
Interface – 29
17 Json
Abrangência
A partir da versão 17.3.0.7 será possível definir um objeto Json dentro do fonte TL++.
A sintaxe é similar a do Objeto Json1:
{ "chave" : "valor" }
Exemplo 1:
JsonObject.tlpp
1 #include "tlpp-core.th"
2
3 user function jsonObject_exemplo1()
4
5 local varJson := { "teste" : { "var1" : "oioi", "var2": "oioi2", "var3": "oioi3" }} as json
6 local varJson2 := { "teste" : 123} as json
7 local varJson3 := { "teste" : { "var1" : varJson['teste']['var1'], "var2": "oioi2" }} as json
8
9 conout(varJson['teste']['var1']) //"oioi"
10 conout(varJson['teste']['var2']) //"oioi2"
11 conout(varJson['teste']['var3']) //"oioi3"
12 conout(varJson2['teste']) //123
13 conout(varJson3['teste']['var1'])//"oioi"
14 conout(varJson3['teste']['var2'])//"oioi2"
15
16 return
17.1 Exemplo 2:
Json.tlpp
1 #include "tlpp-core.th"
2
3 user function jsonObject_exemplo2()
4 local aPropriedades as array
5 local oJson1 as json
8 local cVar as character
9 local cRet as character
10 local lRet as logical
11 local nIdx as numeric
12
1 https://tdn.totvs.com/display/tec/Classe+JsonObject
Json – 30
13 //Utilizar https://jsonlint.com para mostrar estrutura

14 //Character com conteudo json - ainda nao eh objeto json

15 cVar := '{' +;
16 '"ID_01": {"ID": 1,"Name": "TOTVS S.A.","CNPJ": "00.000.000/0001-00"},' +;
17 '"ID_02": {"ID": 2,"Name": "TOTVS Techfin","CNPJ": "00.000.000/0001-00"}' +;
18 '}'
19
20 //Duas formas de atribuir ao objeto json
21 //1) Cria um objeto JSON e faz atribuição a partir de uma variavel tipo character
22 oJson1 := JsonObject():New()
23 cRet := oJson1:FromJson(cVar)
24
25 if (valType(cRet) == "U")
26 conout("JsonObject populado com sucesso")
27 else
28 conout("Falha ao popular JsonObject. Erro: " + cRet)
29 endif
30
31 //2) Cria um objeto JSON dinamicamente
32 oJson2 := {"chave":"valor"}
33 oJson2["propriedade"] := "valor da sua propriedade"
34
35 //Pode atribuir outros tipos na propriedade: numeric, logical e json
36 oJson2["numeric"] := 1
37 oJson2["logical"] := .T.
38 oJson2["object"] := {"chave": "valor"}
39
40 //objeto:toJson - Permite exportar o objeto JSON para um character em formato JSON.
41 conout("Exemplo 1: " + oJson1:toJson())
42 //sera impresso: Exemplo 1: {"ID_01":
{"ID":1,"Name":"TOTVSS.A.","CNPJ":"00.000.000/0001-00"},"ID_02":
{"ID":2,"Name":"TOTVSTechfin","CNPJ":"00.000.000/0001-00"}}
43
45 //sera impresso: Exemplo 2: {"chave":"valor","propriedade":"valor da sua
propriedade","numeric":1,"logical":true,"object":{"chave":"valor"}}
46
47
48 //objeto:delName - Permite remover uma propriedade e seu valor do json
49 lRet := oJson2:delName("object")
50
51 if (lRet == .T.)
52 conout("Removeu propriedade com sucesso")
53 else
54 conout("Nao removeu propriedade")
55 endif
56
58 //Espera-se que tenha executado a linha do IF
propriedade","numeric":1,"logical":true}
60 //veja que a propriedade object foi removida
61
62 //Pode-se alterar o valor de uma propriedade diretamente
63 oJson2["numeric"] := 0
Json – 31

propriedade","numeric":0,"logical":true}
66 //veja que a propriedade numeric teve seu valor alterado de 1 para 0
67
68 //objeto:hasProperty - Verifica se o json possui uma chave
69 conout("linha 1: " + cValToChar(oJson1:hasProperty("ID_01"))) //linha 1
72 //sera impresso: .T. para as linhas 1 e 2, e .F. para a linha 3
73
74
75 //objeto:GetJsonText - retorna o valor de uma propriedade do json
76 conout("Exemplo 5: " + oJson1:GetJsonText("Name"))
77 //sera impresso: Exemplo 5: NULL, pois a propriedade Name esta dentro de um outro objeto
78
79 conout("Exemplo 6: " + oJson1:GetJsonText("ID_01"))
80 //sera impresso: Exemplo 6: {"ID":1,"Name":"TOTVS S.A.","CNPJ":"00.000.000/0001-00"}
81
82 conout("Exemplo 7: " + oJson1["ID_01"]["Name"])
83 //sera impresso: Exemplo 7: TOTVS S.A.
84
85 conout("Exemplo 8: " + oJson2:GetJsonText("numeric"))
86 //sera impresso: Exemplo 8: 0
87
88 //objeto:getJsonObject - retorna um objeto json - contido dentro de uma propriedade
89 oJson3 := oJson1:GetJsonObject("ID_01")
91 //sera impresso: Exemplo 9: {"ID":1,"Name":"TOTVS S.A.","CNPJ":"00.000.000/0001-00"}
92
93 //objeto:getNames() - retorna um array com todas propriedades do json - exceto propriedades que
contem tipo json
94 aPropriedades := oJson2:GetNames()
95 for nIdx := 1 to len(aPropriedades)
96 conout("aPropriedades[" + cValToChar(nIdx) + "]: " + cValToChar(aPropriedades[nIdx]))
97 next
98 //sera impresso: aPropriedades[1]: chave
99 // aPropriedades[2]: propriedade
100 // aPropriedades[3]: numeric
101 // aPropriedades[4]: logical
102
103 //limpa da memoria os objetos criados
104 FreeObj(oJson1)
105 FreeObj(oJson2)
106 FreeObj(oJson2)
107 return .T.
Saiba mais sobre a classe JsonObject:

Classe JsonObject2
2 https://tdn.totvs.com/display/tec/Classe+JsonObject
Json – 32
18 Método Estático
Abrangência
A partir da versão 17.3.0.0 métodos estáticos estão disponíveis para TL++.
Métodos estáticos são por padrão públicos.
MetodoEstatico.tlpp
2
3 class StaticMethod
4 method new()
5 static method staticExample()
6 method teste2()
7 data dataI
8 endclass
9
10
11 method new() class ForWithProperty
12
13 return self
14
15
16 method staticExample() class StaticMethod
17 conout("exemplo")
18 /* conout(::dataI) //C9904 Cannot access data nor methods of class from a static method */
19 /* conout(::teste2()) //C9904 Cannot access data nor methods of class from a static method */
20 return
21
22 method teste2() class StaticMethod
23 return
24
25 main function tteci_142
26 StaticMethod():staticExample()
27 return
#include "protheus.ch3"
class StaticMethod
3 http://protheus.ch
method new()
static method staticExample()

data dataI
endclass
method new() class ForWithProperty
return self
method staticExample() class StaticMethod

conout("oizinho")
return
main function tteci_142

StaticMethod():staticExample()
return
19 Namespace
Disponível em: 17.3.0.0 para a linguagem TL++

O recurso de namespace foi liberado na versão 17.3.0.0 e tem como benefício a melhor organização do código.
O nome do namespace pode ser um nome simples ou um nome que contenha "." como separador.
Importante ressaltar que todo nome de namespace iniciado com "tlpp." está reservado ao TLPP-CORE. Desse
modo, qualquer tentativa de uso fora desse domínio, será bloqueada em tempo de compilação.
Uma vez utilizado o recurso namespace no 'main' da sua aplicação, é necessário que o explicite utilizando o
separador "."
Exemplo: -p myN(see page 35)amespace.InitialFunction(see page 35) em vez de -p InitialFunction(see page 35)
19.1 Funções dentro de namespace:
19.1.1 Exemplo:
exemplo1.tlpp
1 namespace exemplo
2
3 main function testeNamespace
4 conout("testeNamespace")
5 testeNamespace2() //a função testeNamespace2 poderá ser chamada sem explicitar o namespace nem
utilizar using porque estão no mesmo fonte
6 return
7
8 function testeNamespace2
9 conout("testeNamespace2")
10 return
Para chamar uma função que está declarada dentro de um namespace de um outro fonte é necessário que o
explicite, o separador utilizado para isso é o "." conforme exemplo a seguir:
exemplo2.tlpp
1 user function exemplo2

2 exemplo.testeNamespace2()
3 return
Outra opção para chamar uma função que está declarada dentro de um namespace é utilizar a instrução "using
namespace" conforme o exemplo a seguir:
exemplo3.tlpp
1 using namespace exemplo

2 user function exemplo3
3 testeNamespace2() //nesse caso como não há uma função com esse nome neste fonte, ele irá
executar a função que está no fonte exemplo1.tlpp porque o namespace exemplo está definido.
Namespace – 35
4 return
19.2 Classes dentro de namespace:
19.2.1 Exemplo:
exemplo4.tlpp
2 namespace exemplo2.1
3
4 class ClassWithNamespace
5 method new()
6 data dataI
7 endclass
8
9
10 method new() class ClassWithNamespace
11 conout("construtor do ClassWithNamespace no namespace exemplo2")
12 return self
13
14
15 main function exemplo4()
16 local obj := exemplo2.1.ClassWithNamespace():new() //nesse caso está explícito o namespace e o
objeto será criado da classe ClassWithNamespace que está no namespace exemplo2
17 local obj2 := exemplo.ClassWithNamespace():new() //nesse caso está explícito o namespace e o
objeto será criado da classe ClassWithNamespace que está no namespace exemplo
18 local obj3 := ClassWithNamespace():new() //nesse caso não está explícito, mas há uma classe
com esse nome definido nesse fonte, estão essa será utilizada.
19 return
Para utilizar uma classe que está declarada dentro de um namespace de um outro fonte é necessário que o
explicite, o separador utilizado para isso é o "." conforme exemplo a seguir:
exemplo5.tlpp
1 user function exemplo5()

2 Local o1 := exemplo2.1.ClassWithNamespace():New()
3 Return
Outra opção para utilizar uma classe que está declarada dentro de um namespace de um outro fonte é utilizar a
instrução "using namespace" conforme o exemplo a seguir:
exemplo6.tlpp
1 using namespace exemplo2.1

2 user function exemplo6()
3 Local o1 := ClassWithNamespace():New()
Namespace – 36
4
Return
Namespace – 37
20 Nomes longos
Abrangência
A partir da versão 17.3.0.0 o nome longo está disponível para o TL++.
Qualquer fonte escrito e utilizando com a extensão tlpp o limite do tamanho de variáveis, funções, classes,
propriedades e métodos é de 255 caracteres.
Tipagem.tlpp
1 #include 'tlpp-core.th'
2
3 Function u_teste_de_nome_longo()
4 local variavel_com_nome_longo_1
7
8 variavel_com_nome_longo_1:= 'var1'
11
12 ConOut(variavel_com_nome_longo_1)
15
16 u_esta_funcao_tem_nome_longo_1()
19 Return
20
21 Function u_esta_funcao_tem_nome_longo_1()
22 ConOut("u_esta_funcao_tem_nome_longo_1")
23 Return
24
27 Return
28
31 Return
Nomes longos – 38
21 Reflection e Annotation
O recurso de annotation foi liberado na versão 17.3.0.3 e o objetivo é possibilitar a declaração de metadados nas
nossas classes, métodos e funções, isto é, as configurações deles podem ficar dentro do mesmo código fonte.
Definição da annotation, a sugestão é que ela seja colocada em CH que pode ser utilizado em vários fontes.
exemplo1.ch
1 @annotation ExemploDeAnnotation
2 property1 as char
3 property2 as numeric default 1
4 @end
Uso da annotation em definição de classe:
exemplo1.tlpp
1 @ExemploDeAnnotation(property1 = "MeuObject")
2 class meuObj
3 public Data data1
4 public method new()
5 EndClass
Uso da annotation em definição de método:
exemplo2.tlpp
1 class meuObj
2 public Data data1
3 @ExemploDeAnnotation(property1 = "MetodoNew")
5 EndClass
Uso da annotation em definição de propriedade:
exemplo3.tlpp
1 class meuObj
2 @ExemploDeAnnotation(property1 = "PropertyData", property2 = 456)
3 public Data data1
4 EndClass
Uso da annotation em definição de função:
exemplo4.tlpp
1 @ExemploDeAnnotation(property1 = "FunctionTeste", property2 = 123)

2 main Function teste()
3 conout("annotationTest")
4 Return
21.1 Novas funções disponíveis para uso juntamente com o recurso de

Annotation, as funções foram disponibilizadas dentro do
namespace Reflection:
• Reflection.isAnnotationObjectPresent(advplObject,cAnnotationName)(see page 96)
• Reflection.getObjectAnnotation(advplObject,cAnnotationName)(see page 96)
• Reflection.isAnnotationDataPresent(advplObject,cData, cAnnotationName)(see page 91)
• Reflection.getDataAnnotation(advplObject,cData, cAnnotationName)(see page 61)
• Reflection.isAnnotationFunctionPresent(cSourceName,cFunctionName,cAnnotationName)(see page 93)
• Reflection.getFunctionAnnotation(cSourceName,cFunctionName,cAnnotationName)(see page 69)
• Reflection.isAnnotationMethodPresent(advplObject, cMethodName,cAnnotationName)(see page 94)
• Reflection.getMethodAnnotation(advplObject,cMethodName,cAnnotationName)(see page 77)
• Reflection.getClassesByAnnotation(cAnnotationName,[cClassNameFilter])(see page 63)
• Reflection.getFunctionsByAnnotation(cAnnotationName,[cFuncNameFilter])(see page 75)
• Reflection.getDeclaredFields(oAdvplObject)(see page 68)
• Reflection.getDataValue(oObj,cFieldName)(see page 66)
• Reflection.isAnnottationFunctionParamPresent(cSourceName, cFunctionName, nParmPos,
cAnnotationName)(see page 97)
• Reflection.getFunctionParamAnnotation(cSourceName, cFunctionName, nParmPos, cAnnotationName)(see
page 72)
• Reflection.isAnnottationMethodParamPresent(oObject, cFunctionName, nParmPos, cAnnotationName)(see
page 99)
• Reflection.getMethodParmAnnotation(oObject, cFunctionName, nParmPos, cAnnotationName)(see page 81)
• Reflection.getFunctionParmsByAnnotation(cSourceName, cFunctionName, aListParms, cAnnotationName)4
• Reflection.getMethodParmsByAnnotation(oObject, cFunctionName, aListParms, cAnnotationName)5
• Reflection.getProgramFunctionsByAnnotation(cProgramName, cAnnotationName)6
21.2 Classe Attribute

Classe que representa atributos presentes em determinada Classe
21.2.1 Propriedades
21.2.2 Métodos
4 http://tdn.totvs.com/display/tec/Reflection.getFunctionParmsByAnnotation
5 http://tdn.totvs.com/display/tec/Reflection.getMethodParmsByAnnotation
6 http://tdn.totvs.com/display/tec/Reflection.getProgramFunctionsByAnnotation
21.2.3 Exemplos
Exemplo1.tlpp
1 //Definicoes das annotation, deve estar num fonte

2 #include "tlpp-object.th"
3
4 @annotation classe
5 @end
6
7 @annotation attr
8 @end
9
10 @classe()
11 Class NovaClasse
12
13 @attr()
14 Public Data TesteAttr as char
15
16 Public Method MetodoTeste()
17
18 Public Method New(str)
19 endclass
20
21 Method New(str) class NovaClasse
22 ::TesteAttr := str
23 return self
24
25 Method MetodoTeste() class NovaClasse
26 Conout(::TesteAttr)
27 return "Banana"
28
29
30 Main Function testeNovo()
31 local AttrA
32 local obj1 := NovaClasse():New("Instancia 1")
34
35
36 Conout("-----------------------")
37 AttrA := Reflection.getAttributesByAnnotation(obj1, "attr")
38 Conout(AttrA[1]:GetValue(obj1))
39 AttrA[1]:Assign(obj1, "Banana1")
40 Conout(AttrA[1]:cAttributeName)
41 Conout(AttrA[1]:cAttributeType)
42 Conout(obj1:TesteAttr)
43 Conout("-----------------------")
44 Conout("-----------------------")
48 Conout(AttrA[1]:cAttributeName)
49 Conout(AttrA[1]:cAttributeType)
51 Conout("-----------------------")
52
53 return
21.2.4 Retorno do exemplo

-----------------------
Instancia 1
TESTEATTR
CHAR
Banana1
-----------------------
-----------------------
Instancia 2
TESTEATTR
CHAR
Banana2
-----------------------
Observações:
Disponível a partir da build 17.3.0.7.
21.2.5 Classe Attribute - Métodos

A classe expõe os seguintes métodos:
21.2.5.1 Attribute:Assign
Executa o método dentro da instância do objeto desejada.
Sintaxe
Attribute:Assign(oObj, oValue)
Parametros
Nome Tipo Descrição Obrigató Referên

rio cia
oObj objeto Indica a instância do atributo em que ocorrerá o assign. X
oValue qualq Valor a ser inserida no atributo. X

uer
Exemplo
Exemplo1.tlpp

3
5 @end
6
7 @annotation attr
8 @end
9
10 @classe()
11 Class NovaClasse
12
13 @attr()
15
17 endclass
18
21 return self
22
23
24 User Function testeNovo()
25 local AttrA
27 Conout("-----------------------")
31 Conout("-----------------------")
32
33 return
Resultado do Exemplo
-----------------------
Banana2
-----------------------
21.2.5.2 Attribute:GetValue
Retorna o valor da propriedade definida no objeto desejado.
Sintaxe
Attribute:GetValue(oObj)
Parametros

rio cia
oObj objeto Indica a instância do objeto em que o atributo está. X
Retorno
Nome Tipo Descrição
oRet qualquer Valor do atributo.
Exemplo
Exemplo1.tlpp

3
5 @end
6
7 @annotation attr
8 @end
9
10 @classe()
11 Class NovaClasse
12
13 @attr()
15
17 endclass
18
21 return self
22
23
25 local AttrA


28 Conout("-----------------------")
32 Conout("-----------------------")
33
34 return
-----------------------
Instancia 1
Instancia 2
-----------------------
21.2.5.3 Attribute:toString
Retorna uma representação em String do objeto.
Sintaxe
Attribute:toString()
Retorno
cRet caractere Retorna uma representação em String do objeto.
Exemplo
Exemplo1.tlpp

3
4
6 @end
7
8 @annotation attr
9 @end
10
11 @classe()
12 Class NovaClasse
13
14 @attr()
16
18 endclass
19
22 return self
23
24
26 local AttrA
28 Conout("-----------------------")
30 Conout(AttrA[1]:toString())
31 Conout("-----------------------")
32
33 return
-----------------------
{ cAttributeName: TESTEATTR, cAttributeType: CHAR }
-----------------------
21.2.6 Classe Attribute - Propriedades
21.2.6.1 Propriedade Attribute:cAttributeName
Indica o nome do atributo.
Tipo Valor Padrão Somente Leitura
char N/A N
21.2.6.2 Propriedade Attribute:cAttributeType
Indica o tipo do atributo.
char N/A N
21.3 Classe Method

Classe que representa métodos presentes em uma determinada Classe
21.3.1 Propriedades
21.3.2 Métodos
21.3.3 Exemplos
Exemplo1.tlpp

3
4
5 @annotation metodo
6 @end
7
8 @annotation metodoComParametro
9 @end
10
11 @annotation classeMetodo
12 @end
13
14 @classeMetodo()
15 Class NovaClasseMetodo
16
17 Public Data TesteAttr
18
19 @metodo()
21
22 @metodoComParametro()
23 Public Method MetodoTesteComParametros(param1, param2)
24
26 endclass
27
28
29 Method New(str) class NovaClasseMetodo
31 return self
32
33 Method MetodoTeste() class NovaClasseMetodo
34 Conout("Instancia executada: " + ::TesteAttr)
35 return "Banana"
36
37 Method MetodoTesteComParametros(param1, param2) class NovaClasseMetodo

38 Conout("-----------------------------------")
39 Conout("Instancia:")
40 Conout(::TesteAttr)
41 Conout("Parametros")
42 Conout(param1)
43 Conout(param2)
44 Conout("-----------------------------------")
45 return "Banana"
46
47
48 Main Function testeMetodo()
49 local ObjMethod
50 local classes
51 local obj1
52 local obj2
53 local ret
54
55 classes := Reflection.getClassesByAnnotation("classeMetodo", "") // vazio para pegar todas as
classes do repositorio
56
57 obj1 := classes[1]:CreateInstance("Instancia 1")
59
60 ObjMethod := Reflection.getMethodsObjectByAnnotation(obj1, "metodo")
61 ret := ObjMethod[1]:Execute(obj1)
62 conout("Nome do Metodo: " + ObjMethod[1]:cMethodName)
63 conout("Retorno do metodo: " + ret)
64
66 ret := ObjMethod[1]:Execute(obj2)
69
70 ObjMethod := Reflection.getMethodsObjectByAnnotation(obj1, "metodoComParametro")
72 ret := ObjMethod[1]:Execute(obj1, "parametro 1", "parametro 2")
74
75 ObjMethod := Reflection.getMethodsObjectByAnnotation(obj2, "metodoComParametro")
77 ret := ObjMethod[1]:Execute(obj2, "parametro 1", "parametro 2")
79
80 return
21.3.4 Retorno do exemplo

Instancia executada: Instancia 1
Nome do Metodo: METODOTESTE
Retorno do metodo: Banana
Instancia executada: Instancia 2

Nome do Metodo: METODOTESTECOMPARAMETROS

-----------------------------------
Instancia:
Instancia 1
Parametros
parametro 1
parametro 2
-----------------------------------
Nome do Metodo: METODOTESTECOMPARAMETROS
-----------------------------------
Instancia:
Instancia 2
Parametros
parametro 1
parametro 2
-----------------------------------
Observações:
21.3.5 Classe Method - Métodos
21.3.5.1 Method:Execute
Executa o método dentro da instância do objeto desejada.
Sintaxe
Method:Execute(oObj, param1, param2, ...)
Parametros

rio cia
oObj objeto Indica a instância do objeto em que o método será X

executado.
param1 qualq Parâmetro a ser passado para o método.

uer
Retorno
oRet qualquer Valor do retorno do método executado.
Exemplo
Exemplo1.tlpp

3
5 @end
6
8 @end
9
10 @classeMetodo()
12
13 @metodo()
14 Public Method MetodoTeste(param1)
15
16 Public Method New()
17 endclass
18
19
20 Method New() class NovaClasseMetodo
21
22 return self
23
24 Method MetodoTeste(param1) class NovaClasseMetodo
25 local novaString := "{ " + param1 + " }"
26 return novaString
27
29 local ObjMethod
30 local classes
31 local obj1
32 local ret
33
36
38 ret := ObjMethod[1]:Execute(obj1, "Teste Parametro")
39 Conout(ret)
40 return
"{ Teste Parametro }"
21.3.5.2 Method:toString
Cria uma instância da classe descrita.
Sintaxe
Method:toString()
Retorno
cRet caractere Retorna uma representação em String do objeto.
Exemplo
Exemplo1.tlpp

3
5 @end
6
8 @end
9
10 @classeMetodo()
12
13
14 @metodo()
16
17 Public Method New()
18 endclass
19
20
21 Method New() class NovaClasseMetodo
22
23 return self
24

26
27 return
28
30 local ObjMethod
31 local classes
32 local obj1
33
35
36 obj1 := classes[1]:CreateInstance()
37
39 conout(ObjMethod[1]:toString())
40
41 return
"{ cMethodName: METODOTESTE, aParameters:[ ] }"
21.3.6 Classe Method - Propriedades
21.3.6.1 Method:aParameters
Array de informações sobre os parâmetros do método.
Array NIL S
21.3.6.2 Method:cMethodName
Indica o nome do método.
char N/A N
21.4 Classe Class

Instâncias da classe Class representam classes definidas em uma aplicação em TL++.
21.4.1 Propriedades
21.4.2 Métodos
21.4.3 Exemplos
Exemplo1.tlpp

2 #include "msobject.ch"
3 namespace exemplo
4 @annotation AnnotationExemplo
5 nickname as char
6 @end
7
8
9 @AnnotationExemplo(nickname = "MeuObject")
10 class Obj1
12 EndClass
13
14 @AnnotationExemplo(nickname = "10")
15 class Obj2
17 EndClass
18
19
20 method new() class Obj2
21 return self
22
24 return self
25
26
27 Main Function Exemplo()
28 retVar := Reflection.getClassesByAnnotation("AnnotationExemplo", "exemplo.*") //procura por
todas as classes do namespace exemplo e retorna um array de objetos do tipo Class
29 conout(retVar[1]:cClassName)
30 conout(retVar[1]:cProgramName)
33
34 Return cJson
Observações:
21.4.4 Classe Class - Métodos

A classe expõe os seguintes métodos:
21.4.4.1 Class:CreateInstance
Cria uma instância da classe descrita.
Sintaxe
Class:CreateInstance()
Retorno
oRet caractere Retorna um objeto do tipo da Classe descrita.
Exemplo
Exemplo1.tlpp

3 namespace exemplo
4
5
7 nickname as char
8 @end
9
10
12 class Obj1
13 public data teste
15 EndClass
16
17

19 return self
20
21
23 local oRet
24 local retVar := Reflection.getClassesByAnnotation("AnnotationExemplo", "exemplo.*") //procura
por todas as classes do namespace exemplo
25 oRet := retVar1:CreateInstance()
26 oRet:teste := "teste"
27 conout(oRet:teste)
28 Return
"teste"
21.4.4.2 Class:toString
Retorna uma string com o conteúdo do objeto Class.
Sintaxe
Class:toString()
Retorno
cRet caractere Retorna uma string com o conteúdo do objeto Class.
Exemplo
Exemplo1.tlpp

3 namespace exemplo
4
5
7 nickname as char
8 @end
9
10
12 class Obj1
14 EndClass
15
16
18 return self
19
20
todas as classes do namespace exemplo
23 conout(retVar1:toString())
24 Return cJson
ClassName:OBJ1;ProgramName:EXEMPLO1.TLPP
21.4.5 Classe Class - Propriedades
21.4.5.1 Propriedade Class:cClassName
Indica o nome da classe.
char N/A N
21.4.5.2 Propriedade Class:cProgramName
Indica o nome do fonte que está definido a classe.
char N/A N
21.5 Reflection.getAttributesByAnnotation
Retorna um array com o objeto Attribute de cada um dos atributos que possuem a annotation no objeto enviado.
21.5.1 Sintaxe
Reflection.getAttributesByAnnotation( oObj,cAnnotationName )
21.5.2 Parâmetros
Nome Tipo Descrição Obrig Refer
atório ência
oObj obje Objeto na qual a busca será realizada X

to
cAnnota cara Nome da annotation a ser procurada X

tionNam cter
e e
21.5.3 Retorno
aRet Array Retorna um array com o os objetos Attribute.
21.5.4 Exemplos
exemplo1.tlpp
2
3 @annotation attr
4 @end
5
6 Class NovaClasse
7
8 @attr()
9 Public Data TesteAttr as character
10
12 EndClass
13
16 Return self
17
18 Function u_testeNovo()
19 local AttrA
21
22 ConOut("-----------------------")
24 ConOut(AttrA[1]:cAttributeName)
25 ConOut(AttrA[1]:cAttributeType)
26 ConOut("-----------------------")
27
28 Return
21.5.5 Resultado do Exemplo

-----------------------
TESTEATTR
CHARACTER
-----------------------
21.5.6 Abrangência
17.3.0.3
21.5.7 Veja também

• Reflection e Annotation(see page 39)
21.6 Reflection.getClassAnnotation
Procura e retorna uma Annotation em um objeto.
21.6.1 Sintaxe
Reflection.getClassAnnotation( oObj, cAnnotationName )
21.6.2 Parâmetros
rio cia
cClassName caract Indica o nome da classe onde será procurado a X

ere Annotation.
cAnnotatio caract Indica o nome da Annotation que será procurada. X

nName ere
21.6.3 Retorno
jRet JsonObject Retorna o object Json caso encontre a Annotation no

objeto passado e NIL caso não encontre.
21.6.4 Exemplos
exemplo1.tlpp
1 @interface AnnotationExemplo
2 nickname as char
3 @end
4
5 @AnnotationExemplo(nickname = "Company")
6 class MeuObjeto
7 public data data1
9 EndClass
10
11
12 main function usoDeAnnotation()
13 local oObj := MeuObjeto():New()
14 local jRet
15 jRet := Reflection.getClassAnnotation("MeuObjeto","AnnotationExemplo")
16 conout(jRet["NICKNAME"])
17 return

Company
21.6.6 Abrangência
17.3.0.3
21.6.7 Veja também

21.7 Reflection.getClassAnnotationList
Retorna todas as anotações utilizadas na classe.
21.7.1 Sintaxe
Reflection.getClassAnnotationList( cClassName)
21.7.2 Parâmetros
rio cia
cClassName caract INome da classe cujas anotações serão retornadas X

ere
21.7.3 Retorno
jRet Array de JsonObject Retorna um array que contém, em cada posição, um

objeto Json que represente a Annotation. Seu valor será
NIL caso nenhuma annotation seja encontrada.
21.7.4 Exemplos
exemplo1.tlpp
1 @interface AnnotationUm
2 nickname as char
3 @end
4
5
6 @interface AnnotationDois
7 tipo as char
8 @end
9
10
11 @AnnotationUm(nickname = "Company")
12 @AnnotationDois(tipo = "Teste Lista")
13 class MeuObjeto
14 public data data1
16 EndClass
17
18 Method new() Class MeuObjeto
19 return self
20
21 main function AnnotationList()


23 local jRet
24
25 jRet := Reflection.getClassAnnotationList("MeuObjeto")
26 conout(jRet[1]["nickname"])
27 conout(jRet[2]["tipo"])
28 return

Company
Teste Lista
21.7.6 Abrangência
17.3.0.3
21.7.7 Veja também

21.8 Reflection.getDataAnnotation
Procura e retorna uma Annotation em uma propriedade de um objeto.
21.8.1 Sintaxe
Reflection.getDataAnnotation( oObj, cPropertyName, cAnnotationName )
21.8.2 Parâmetros
rio cia
oObj objeto Indica o objeto onde será procurado a Annotation. X
cPropertyN caract Indica o nome da propriedade onde será procurada a X

ame ere Annotation

rio cia

nName ere
21.8.3 Retorno
jRet JsonObject Retorna o object Json caso encontre a Annotation na

propriedade do objeto passado e NIL caso não encontre.
21.8.4 Exemplos
exemplo1.tlpp
2 nickname as char
3 @end
4
5 class MeuObjeto
7 public data data1
9 EndClass
10
11
14 local jRet
15 if (Reflection.isAnnotationDataPresent(oObj,"data1", "AnnotationExemplo"))
16 jRet := Reflection.getDataAnnotation(oObj,"data1","AnnotationExemplo")
18 endif
19
20 return

Company
21.8.6 Abrangência
17.3.0.3
21.8.7 Veja também

21.9 Reflection.getClassesByAnnotation
Retorna um array com objetos do tipo Class das classes que tem uma determinada annotation.
21.9.1 Sintaxe
Reflection.getClassesByAnnotation( cAnnotationName,[cClassNameFilter]) )
21.9.2 Parâmetros
atório ência
cAnnota cara Indica o nome da annotation que será procurada em todas as classes X
tionNam cter que estão no repositório
e e
cClassN cara Indica uma expressão regular para os nomes das classes X
ameFilt cter
er e
21.9.3 Retorno
aRet Array Retorna um array com o nome de todas as classes que tem uma
determinada annotation.
21.9.4 Exemplos
exemplo1.tlpp

3 namespace exemplo
5 nickname as char
6 @end
7
8
10 class Obj1
12 EndClass
13
14 @AnnotationExemplo(nickname = "10")
15 class Obj2
17 EndClass
18
19
21 return self
22
24 return self
25
26
33
34 Return cJson

EXEMPLO.OBJ1
EXEMPLO1.TLPP
EXEMPLO.OBJ2
EXEMPLO1.TLPP
21.9.6 Abrangência
17.3.0.3
21.9.7 Veja também

• Classe Class7
7 http://tdn.totvs.com/display/tec/Classe+Class
21.10 Reflection.getDataAnnotationList
Retorna um array contendo as anotações usadas em uma propriedade de um objeto.
21.10.1 Sintaxe
Reflection.getDataAnnotationList( oObj, cPropertyName )
21.10.2 Parâmetros
rio cia

ame ere Annotation
21.10.3 Retorno
jRet Array de JsonObject Caso encontre as anotações na propriedade do objeto

passado, retorna um array onde cada posição contém
um object Json. Se nenhuma anotação for encontrada
retorna NIL.
21.10.4 Exemplos
exemplo1.tlpp
1 @annotation AnnotationUm
2 teste1 as char
3 @end
4
5 @annotation AnnotationDois
6 teste2 as char
7 @end
8
9 class MeuObjeto
10
11 @AnnotationUm(teste = "Primeira Annotation")

12 @AnnotationDois(teste = "Segunda Annotation")

14
16 EndClass
17
18
21 local jRet
22
23 jRet := Reflection.getDataAnnotationList(oObj,"data1")
24 conout(Len(jRet))
25 conout(jRet[1]["teste"])
27
28
29 return

2
Primeira Annotation
Segunda Annotation
21.10.6 Abrangência
17.3.0.3
21.10.7 Veja também

21.11 Reflection.getDataValue
Retorna o conteudo da propriedade do objeto.
21.11.1 Sintaxe
Reflection.getDataValue(oObj,cFieldName)
21.11.2 Parâmetros
rio cia
oObj objeto Indica o objeto que será retornado as propriedades X
cFieldName caract Nome da propriedade que será retornada X

ere
21.11.3 Retorno
ret tipo da propriedade Retorna o conteúdo da propriedade do objeto.
21.11.4 Exemplos
exemplo1.tlpp
1 class MeuObjeto
2 public data data1
3 public data data2
4 public data data3
6 EndClass
7
8
11 oObj:data1 := "exemplo"
12 conout(Reflection.getDataValue(oObj, "data1"))
13 return

exemplo
17.3.0.3

21.12 Reflection.getDeclaredFields
Retorna as propriedade de um objeto.
21.12.1 Sintaxe
Reflection.getDeclaredFields( oObj )
21.12.2 Parâmetros
rio cia
oObj objeto Indica o objeto que será retornado as propriedades X
21.12.3 Retorno
aRet array Retorna um array com todas as propriedades do objeto.
21.12.4 Exemplos
exemplo1.tlpp
1 class MeuObjeto
2 public data data1
3 public data data2
4 public data data3
6 EndClass
7
8
11 local aRet := Reflection.getDeclaredFields(oObj)
12 varinfo("aRet",aRet)
13 return

data1
data2
data3
17.3.0.3

21.13 Reflection.getFunctionAnnotation
21.13.1 Sintaxe
Reflection.getFunctionAnnotation( cSourceName, cFunctionName, cAnnotationName )
21.13.2 Parâmetros
Nome Tipo Descrição Obriga Refer
tório ência
cSourceN cara Indica o nome do fonte onde está a função que será procurado a X
ame ctere Annotation.
cPropert cara Indica o nome da função onde será procurada a Annotation. X

yName ctere
cAnnotat cara Indica o nome da Annotation que será procurada. X

ionName ctere
21.13.3 Retorno

função e NIL caso não encontre.
21.13.4 Exemplos
exemplo1.tlpp
2 nickname as char
3 @end
4
5
7 function exemploAnnotation()
8 return
9
10
13 local jRet
14 if (Reflection.isAnnotationFunctionPresent("exemplo1.tlpp", "exemploAnnotation",
"AnnotationExemplo"))
15 jRet := Reflection.getFunctionAnnotation("exemplo1.tlpp", "exemploAnnotation","AnnotationE
xemplo")
17 endif
18
19 return

Company
17.3.0.3

21.14 Reflection.getFunctionAnnotationList
Retorna um array com as annotations utilizadas em uma função.
21.14.1 Sintaxe
Reflection.getFunctionAnnotationList(cSourceName, cFunctionName )
21.14.2 Parâmetros
tório ência
cSourceN cara Nome do fonte onde está a função X

ame ctere
cPropert cara Nome da função cujas anotações serão retornadas X

yName ctere
21.14.3 Retorno
jRet Array de JsonObject Se não encontrar anotação alguma, retorna NIL. Caso
contrário retorna um array onde cada posição é um
object Json representando uma annotation.
21.14.4 Exemplos
exemplo1.tlpp
2 teste as char
3 @end
5 teste as char
6 @end
7
8 @AnnotationUm(teste = "Primeira Annotation da Funcao")
9 @AnnotationDois(teste = "Segunda Annotation da Funcao")
11 return
12
13
15 local jRet
16
17 jRet := Reflection.getFunctionAnnotationList("exemplo1.tlpp", "exemploAnnotation")
21
22 return

2
Primeira Annotation da Funcao
Segunda Annotation da Funcao
17.3.0.3

21.15 Reflection.getFunctionParamAnnotation
Retornar a Annotation de um determinado parâmetro de uma função
21.15.1 Sintaxe
Reflection.getFunctionParamAnnotation( cSourceName, cFunctionName, nParmPos, cAnnotationName)
21.15.2 Parâmetros
tório ência

tório ência

yName ctere
nParmPos num Indica a posição do parâmetro onde será procurada a Annotation X

érico

ionName ctere
21.15.3 Retorno

parâmetro da função e NIL caso não encontre.
21.15.4 Exemplos
exemplo1.tlpp
2 nickname as char
3 @end
4
5 User function testeAnnotation(@AnnotationExemplo("valor parm1") parm1, @AnnotationExemplo("valor
parm2") parm2)
6 conout("funcaoTesteAnnotation")
7 return
9 local jRet := Reflection.getFunctionParamAnnotation("exemplo1.tlpp", "u_testeAnnotation", 1,
"AnnotationExemplo")
10 conout(jRet["nickname"])
11 return

valor parm1
17.3.0.3

21.16 Reflection.getFunctionParmsByAnnotation
Retorna se encontrou a Annotation em qualquer parâmetro de uma função.
21.16.1 Sintaxe
Reflection.getFunctionParmsByAnnotation( cSourceName, cFunctionName, aListParms, cAnnotationName)
21.16.2 Parâmetros
tório ência

yName ctere
aListPar array Retorna a lista de parâmetros que contém a Annotation X X

ms

ionName ctere
21.16.3 Retorno
lRet lógico Retorna .T. caso encontre algum parâmetro que tenha a
Annotation e .F. caso não tenha
21.16.4 Exemplos
exemplo1.tlpp
2 nickname as char
3 @end
4
5 User function testeAnnotation(@AnnotationExemplo("valor parm1") parm1, @AnnotationExemplo("valor
parm2") parm2)
7 return
9 local aRet
10 local jRet := Reflection.getFunctionParmsByAnnotation("exemplo1.tlpp", "u_testeAnnotation",
aRet, "AnnotationExemplo")
11 conout(jRet)
12 conout(aRet[1]) //porque tem a annotation no parâmetro 1
13 conout(aRet[2]) //porque tem a annotation no parâmetro 2
14 return

.T.
1
2
17.3.0.3

21.17 Reflection.getFunctionsByAnnotation
Retorna um array com o nome de todas as funções que tem uma determinada annotation.
21.17.1 Sintaxe
Reflection.getFunctionsByAnnotation( cAnnotationName,[cFunctionNameFilter]) )
21.17.2 Parâmetros
atório ência
e e
cFuncti cara Indica uma expressão regular para os nomes das classes X
onNameF cter
ilter e
21.17.3 Retorno
aRet Array Retorna um array de arrays com o nome dos fontes e das funções
que tem uma determinada annotation.
21.17.4 Exemplos
exemplo1.tlpp

3 namespace exemplo
5 nickname as char
6 @end
7
8
10 main Function AnnotationTeste()
11 conout("AnnotationTeste")
12 Return
13

15 retVar := Reflection.getFunctionsByAnnotation("AnnotationExemplo", "exemplo.*") //procura por

16 varinfo("retVar", retVar)
17
18 Return cJson

retVar -> ARRAY ( 2) [...]
retVar[1] -> ARRAY ( 2) [...]
retVar[1][1] C ( 12) [EXEMPLO.TLPP]
retVar[1][2] C ( 12) [EXEMPLO.OBJ1]
retVar[2] -> ARRAY ( 2) [...]
retVar[2][1] C ( 12) [EXEMPLO.TLPP]
retVar[2][2] C ( 12) [EXEMPLO.OBJ2]
17.3.0.3

21.18 Reflection.getMethodAnnotation
21.18.1 Sintaxe
Reflection.getMethodAnnotation( oObj, cMethodName, cAnnotationName )
21.18.2 Parâmetros
rio cia

rio cia
cMethodNam caract Indica o nome da propriedade onde será procurada a X

e ere Annotation

nName ere
21.18.3 Retorno

propriedade do objeto passado e NIL caso não encontre.
21.18.4 Exemplos
exemplo1.tlpp
2 nickname as char
3 @end
4
5 class MeuObjeto
6 public data data1
9 public method exemplo()
10 EndClass
11
14 local jRet
15 if (Reflection.isAnnotationcMethodPresent(oObj,"exemplo", "AnnotationExemplo"))
16 jRet := Reflection.getMethodAnnotation(oObj,"exemplo","AnnotationExemplo")
18 endif
19
20 return

Company
17.3.0.3

21.19 Reflection.getMethodAnnotationList
Procura e retorna quais anotações estão associadas a um determinado método.
21.19.1 Sintaxe
Reflection.getMethodAnnotationList( oObj, cMethodName)
21.19.2 Parâmetros
rio cia
oObj objeto Objeto onde está definido o método cujas anotações serão X
retornadas
cMethodNam caract Nome do método onde serão procuradas as anotações X

e ere
21.19.3 Retorno
jRet Array de JsonObject Caso não encontre annotation alguma, retorna NIL.
Senão, retorna um array onde cada posição é um Json
Object representando uma Annotation encontrada.
21.19.4 Exemplos
exemplo1.tlpp
2 teste as char
3 @end
4
6 teste as char
7 @end
8
9
10 class MeuObjeto
13 @AnnotationUm(teste = "Company")
14 @AnnotationDois(teste = "TOTVS")
16 EndClass
17
20 local jRet
21
22 jRet := Reflection.getMethodAnnotationList(oObj,"exemplo")
26
27 return

2
Company
TOTVS
17.3.0.3

21.20 Reflection.getMethodParmAnnotation
Retornar a Annotation de um determinado parâmetro de uma função
21.20.1 Sintaxe
Reflection.getMethodParmAnnotation( oObject, cFunctionName, nParmPos, cAnnotationName)
21.20.2 Parâmetros
tório ência
oObject objet Indica o objeto onde está o método que será procurado a X
o Annotation.
cPropert cara Indica o nome do método onde será procurada a Annotation. X

yName ctere

érico

ionName ctere
21.20.3 Retorno

parâmetro do método e NIL caso não encontre.
21.20.4 Exemplos
exemplo1.tlpp
2 NICKNAME as char
3 @end
4
5 class MeuObjeto
6 public data data1
8 public method teste(@AnnotationExemplo("valor parm1") parm1, @AnnotationExemplo("valor parm2")
parm2)
9 EndClass
10
11
14 local jRet
15 jRet := Reflection.getMethodParmAnnotation(oObj,"teste", 1, "AnnotationExemplo")
17 jRet := Reflection.getMethodParmAnnotation(oObj,"teste", 2, "AnnotationExemplo")
19 return

valor parm1
valor parm2
17.3.0.3

21.21 Reflection.getMethodParmsByAnnotation
Retorna se encontrou a Annotation em qualquer parâmetro de um método.
21.21.1 Sintaxe
Reflection.getMethodParmsByAnnotation( oObject, cFunctionName, aListParms, cAnnotationName)
21.21.2 Parâmetros
tório ência
o Annotation.
cPropert cara Indica o nome do método onde será procurada a Annotation. X

yName ctere
aListPar array Retorna a lista de parâmetros que contém a Annotation X X

ms

ionName ctere
21.21.3 Retorno
lRet lógico Retorna .T. caso encontre algum parâmetro que tenha a
Annotation e .F. caso não tenha.
21.21.4 Exemplos
exemplo1.tlpp
2 NICKNAME as char
3 @end
4
5 class MeuObjeto
6 public data data1
parm2)
9 EndClass
10
11
14 local jRet
15 jRet := Reflection.getMethodParmsByAnnotation(oObj,"teste", aRet, "AnnotationExemplo")
16 conout(jRet)
17 conout(aRet[1])
18 conout(aRet[2])
19 return

.T.
1
2
17.3.0.3

21.22 Reflection.getMethodsByAnnotation
Retorna um array com o nome de todos os métodos que possuem a annotation passada como argumento
21.22.1 Sintaxe
Reflection.getMethodsByAnnotation( oObj,cAnnotationName )
21.22.2 Parâmetros
atório ência

to

tionNam cter
e e
21.22.3 Retorno
aRet Array Retorna um array com o nome de todos os métodos da classe

que possuem esta annotation.
21.22.4 Exemplos
exemplo1.tlpp
1 #INCLUDE "MsObject.CH"
2
3 NAMESPACE TesteReflection
4 MAIN FUNCTION Teste()
5 ClasseTeste():New()
6 RETURN
7
8 @annotation AnnotationMethod
9 property1 as char
10 @end
11
12 @annotation AnnotationClass
13 property1 as char
14 @end
15
16 @AnnotationClass("testeClass")
17 class ClasseUm
18
19 public method New()
20
21 @AnnotationMethod("testeMethod")
22 public method testeMethod()
23
24 endclass
25
26 METHOD NEW() CLASS ClasseUm
27 return self
28
29 method testeMethod() CLASS ClasseUm
30 conout("Teste de metodo")
31 return
32
33 CLASS ClasseTeste
34 PUBLIC METHOD NEW()
35 ENDCLASS
36
37
38 METHOD NEW() CLASS ClasseTeste
39
40 local classes := {}
41 local methods := {}
42 local instance
43
44 // Pego todas as classes que possuem a annotation "AnnotationClass"
45 classes := Reflection.getClassesByAnnotation("AnnotationClass", "TesteReflection.*")
46
47 conout(classes[1])
48
49 // Instancio um novo objeto desta classe
50 instance := &(classes [1] + "():New()")
51
52 // Pego todos os metodos dentro da classe que possuem a annotation "AnnotationMethod"
53 methods := Reflection.getMethodsByAnnotation(instance, "AnnotationMethod")
54
55 conout(methods[1])
56
57 // Executo o metodo encontrado
58 &("instance:" + methods[1] + "()")
59
60 RETURN self

TESTEREFLECTION.CLASSEUM
TESTEMETHOD
Teste de metodo
17.3.0.3

21.23 Reflection.getMethodsObjectByAnnotation
Retorna um array com o objeto Method de cada um dos métodos que possuem a annotation no objeto enviado.
21.23.1 Sintaxe
Reflection.getMethodsObjectByAnnotation( oObj,cAnnotationName )
21.23.2 Parâmetros
atório ência

to

tionNam cter
e e
21.23.3 Retorno
aRet Array Retorna um array com o os objetos Method.
21.23.4 Exemplos
exemplo1.tlpp

3
4
6 @end
7
9 @end
10
11 @classeMetodo()
13
14 Public Data TesteAttr
15
16 @metodo()
18
20 endclass
21
22
23 Method New(str) class NovaClasseMetodo
25 return self
26
28 Conout("Instancia executada: " + ::TesteAttr)
29 return "Banana"
30
31
32 User Function testeMetodo()
33 local ObjMethod
34 local classes
35 local obj1
36
38
40
43
44 return

17.3.0.3

21.24 Reflection.getObjectAnnotation
Procura e retorna uma Annotation em um objeto.
21.24.1 Sintaxe
Reflection.getObjectAnnotation( oObj, cAnnotationName )
21.24.2 Parâmetros
rio cia

nName ere
21.24.3 Retorno

objeto passado e NIL caso não encontre.
21.24.4 Exemplos
exemplo1.tlpp
2 nickname as char
3 @end
4
6 class MeuObjeto
7 public data data1
9 EndClass
10
11
14 local jRet
15 if (Reflection.isAnnotationObjectPresent(oObj,"AnnotationExemplo"))
16 jRet := Reflection.getObjectAnnotation(oObj,"AnnotationExemplo")
18 endif
19
20 return

Company
17.3.0.3

21.25 Reflection.getProgramFunctionsByAnnotation
Retorna um array com o nome de todas as funções que tem uma determinada annotation.
21.25.1 Sintaxe
Reflection.getProgramFunctionsByAnnotation(cProgramName, cAnnotationName)
21.25.2 Parâmetros
atório ência
cProgra cara Indica o nome do programa onde serão procuradas funções que X
mName cter contenham a annotation
e
e e
21.25.3 Retorno
aRet Array Retorna um array com o nome das funções que tem uma
determinada annotation.
21.25.4 Exemplos
exemplo1.tlpp

3 namespace exemplo
5 nickname as char
6 @end
7
8
10 main Function AnnotationTeste()
11 conout("AnnotationTeste")
12 Return
13
15 retVar := Reflection.getProgramFunctionsByAnnotation("exemplo1.tlpp", "AnnotationExemplo")
16 conout(retVar[1])
17 Return cJson

AnnotationTeste
17.3.0.3

21.26 Reflection.isAnnotationDataPresent
Procura uma Annotation em uma propriedade de um objeto.
21.26.1 Sintaxe
Reflection.isAnnotationDataPresent( oObj, cPropertyName, cAnnotationName )
21.26.2 Parâmetros
rio cia

ame ere Annotation.

nName ere
21.26.3 Retorno
lRet lógico Retorna .T. caso encontre a Annotation e .F. caso não
encontre.
21.26.4 Exemplos
exemplo1.tlpp
2 nickname as char
3 @end
4
5
6 class MeuObjeto
8 public data data1
10 EndClass
11
12
15 conout(Reflection.isAnnotationDataPresent(oObj, "data1", "AnnotationExemplo"))
16 conout(Reflection.isAnnotationDataPresent(oObj, "data1", "Teste"))
17 return

.T.
.F.
17.3.0.3

21.27 Reflection.isAnnotationFunctionPresent
Procura uma Annotation em uma função ADVPL.
21.27.1 Sintaxe
Reflection.isAnnotationFunctionPresent( cSourceName, cFunctionName, cAnnotationName )
21.27.2 Parâmetros
Nome Tipo Descrição Obrigat Referê
ório ncia
cSourceNa carac Indica o nome do fonte onde está a função que será procurado X
me tere a Annotation.
cProperty carac Indica o nome da função onde será procurada a Annotation. X

Name tere
cAnnotati carac Indica o nome da Annotation que será procurada. X

onName tere
21.27.3 Retorno
lRet numérico Retorna .T. caso encontre a Annotation e .F. caso não
encontre.
21.27.4 Exemplos
exemplo1.tlpp
2 nickname as char
3 @end
4
5
8 return
9
10
12 conout(Reflection.isAnnotationFunctionPresent("exemplo1.tlpp", "exemploAnnotation",
13 conout(Reflection.isAnnotationFunctionPresent("exemplo1.tlpp", "exemploAnnotation", "Teste"))
14 return

.T.
.F.
17.3.0.3

21.28 Reflection.isAnnotationMethodPresent
Procura uma Annotation em uma propriedade de um objeto.
21.28.1 Sintaxe
Reflection.isAnnotationMethodPresent( oObj, cMethodName, cAnnotationName )
21.28.2 Parâmetros
rio cia
cMethodNam caract Indica o nome do método onde será procurada a X

e ere Annotation.

nName ere
21.28.3 Retorno
lRet numérico Retorna .T. caso encontre a Annotation e .F. caso não
encontre.
21.28.4 Exemplos
exemplo1.tlpp
2 nickname as char
3 @end
4
5
6 class MeuObjeto
7 public data data1
11 EndClass
12
13


16 conout(Reflection.isAnnotationMethodPresent(oObj, "exemplo", "AnnotationExemplo"))
17 conout(Reflection.isAnnotationMethodPresent(oObj, "exemplo", "Teste"))
18 return

.T.
.F.
17.3.0.3

21.29 Reflection.isAnnotationObjectPresent
Procura uma Annotation em um objeto.
21.29.1 Sintaxe
Reflection.isAnnotationObjectPresent( oObj, cAnnotationName )
21.29.2 Parâmetros
rio cia

nName ere
21.29.3 Retorno
lRet numérico Retorna .T. caso encontre a Annotation no objeto passado

e .F. caso não encontre.
21.29.4 Exemplos
exemplo1.tlpp
2 nickname as char
3 @end
4
6 class MeuObjeto
7 public data data1
9 EndClass
10
11
14 conout(Reflection.isAnnotationObjectPresent(oObj,"AnnotationExemplo"))
15 conout(Reflection.isAnnotationObjectPresent(oObj,"Teste"))
16 return

.T.
.F.
17.3.0.3

21.30 Reflection.isAnnottationFunctionParamPresent
Verifica se existe uma Annotation para um determinado parâmetro de uma função
21.30.1 Sintaxe
Reflection.isAnnottationFunctionParamPresent( cSourceName, cFunctionName, nParmPos, cAnnotationName)
21.30.2 Parâmetros
tório ência

yName ctere

érico

ionName ctere
21.30.3 Retorno
encontre.
21.30.4 Exemplos
exemplo1.tlpp
2 nickname as char
3 @end
4
5 User function testeAnnotation(@AnnotationExemplo("oioi") parm1, @AnnotationExemplo("oioi") parm2)
7 return
9 conout(Reflection.isAnnottationFunctionParamPresent("exemplo1.tlpp", "u_testeAnnotation", 1,
"AnnotationNaoEncontrada"))
12 return

.T.
.F.
.F.
17.3.0.3

21.31 Reflection.isAnnottationMethodParamPresent
Verifica se existe uma Annotation para um determinado parâmetro de uma função
21.31.1 Sintaxe
Reflection.isAnnottationMethodParamPresent( oObject, cFunctionName, nParmPos, cAnnotationName)
21.31.2 Parâmetros
tório ência
o Annotation.

yName ctere

tório ência

érico

ionName ctere
21.31.3 Retorno
encontre.
21.31.4 Exemplos
exemplo1.tlpp
2 NICKNAME as char
3 @end
4
5 class MeuObjeto
6 public data data1
parm2)
9 EndClass
10
11
14 local jRet
15 conout(Reflection.isAnnottationMethodParamPresent(oObj,"teste", 1, "AnnotationExemplo"))
16 conout(Reflection.isAnnottationMethodParamPresent(oObj,"teste", 2, "AnnotationExemplo"))
17 conout(Reflection.isAnnottationMethodParamPresent(oObj,"teste", 2, "AnnotationExemploErro"))
18 return

.T.
.F.

.F.
17.3.0.3

21.32 Reflection.getClassByName
Retorna uma instância da classe solicitada de maneira dinâmica.
21.32.1 Sintaxe
Reflection.getClassByClass( cName, [cClassNameFilter]) )
21.32.2 Parâmetros
atório ência
cName cara Indica o nome da classe que será instanciada, caso a mesma exista no X
cter no repositório.
e
cClassN cara Indica uma expressão regular para os nomes das classes X
ameFilt cter
er e
21.32.3 Retorno
oRet Object Instancia da classe solicita, caso a mesma exista no repositório.

Caso contrário retorna NIL

21.32.4 Exemplos
exemplo1.tlpp

3 namespace exemplo.teste
4
5 class Obj1
6 public data cTeste as char
8 EndClass
9
10
12
13 cTeste := "instancia classe Obj1"
14 return self
15
16 class Obj2
17 public data cTeste as char
19 EndClass
21 cTeste := "instancia classe Obj2"
22 return self
23
24
26 local cNome := "Obj"
27 local oClass := Reflection.getClassByName( cNome + "1", "exemplo.teste")
28
29
30 conout(oClass:cTeste)
31
32
33 oClass := Reflection.getClassByName( cNome + "2", "exemplo.teste")
34
35
36 conout(oClass:cTeste)
37
38
39 oClass := Reflection.getClassByName( cNome + "Naoexiste", "exemplo.teste")
40
41 if oClass == NIL
42 conout("Instancia invalida")
43 endif
44
45 conout(oClass:cTeste) // Gera erro ao acessar "atributo de NIL"
46 Return


instancia classe Obj1
instancia classe Obj2
"Instancia invalida"
Abrangência
17.3.0.3

• Classe Class8
8 http://tdn.totvs.com/display/tec/Classe+Class

22 Representational State Transfer (REST)

A documentação dessa funcionalidade está na área "Produtos do tlppCore"
https://tdn.totvs.com/display/tec/REST(see page 104)

Clique no link acima se você não for redirecionado automaticamente em 5 segundos.
Representational State Transfer (REST) – 104

23 Sobrecarga de Operadores
A partir da versão 19.3.1.0 será possível sobrecarregar operadores. Isso é na definição da sua classe você poderá
sobrecarregar o comportamento da Soma (ADD), da Subtração (SUB), da Multiplicação (MULT), da Divisão (DIV), da
Comparação (COMPARE) e da Conversão para String (TOSTRING).
Não é permitido declarar operadores que não sejam os citados acima, ou seja, os tokens add, sub, mult, div,
compare e tostring fazem parte da linguagem e só eles poderão ser utilizados.
Não é permitido declarar métodos cujo nome inicie com "operator".
Sobrecarga.tlpp
2 class ComplexNumber
3 public data a
4 public data b
6 public method create(parm1, parm2)
7 public OPERATOR Add (parm1)
8 public OPERATOR Sub(parm1)
9 public OPERATOR Mult(parm1)
10 public OPERATOR Div(parm1)
11 public OPERATOR Compare(parm1)
12 public OPERATOR ToString()
13 endclass
14
15 method new() class ComplexNumber
16
17 return self
18
19 method create(parm1, parm2) class ComplexNumber
20 self:a := parm1
21 self:b := parm2
22 return self
23
24
25 //esse será o método invocado ao executar a soma de um objeto do tipo ComplexNumber com qualquer
outro tipo
26 operator Add(parm1) class ComplexNumber
27 local ret := ComplexNumber():New()
28 ret:a := self:a + parm1:a
29 ret:b := self:b + parm1:b
30 return ret
31
32 operator Sub(parm1) class ComplexNumber
34 ret:a := self:a - parm1:a
35 ret:b := self:b - parm1:b
36 return ret
37

38
39 operator Mult(parm1) class ComplexNumber

41 ret:a := self:a * parm1:a - (self:b * parm1:b)
42 ret:b := (self:a * parm1:b) + (self:b * parm1:a)
43 return ret
44
45 operator Div(parm1) class ComplexNumber
46 local conj := ComplexNumber():New()
48
49
50 // Conjugado do denominador
51 conj:a := parm1:a
52 conj:b := - parm1:b
53
54
55 // Multipica numerador e denominador pelo conjugado
56 ret := self * conj
57 conj := parm1 * conj
58
59
60 // Divide o resultado da multiplicacao do numerador pela parte real do denominador
61 ret:a := ret:a / conj:a
62 ret:b := ret:b / conj:a
63 return ret
64 operator Compare(parm1) class ComplexNumber
65 //retorna -1 se for menor, 0 se for igual e 1 se for maior
66 if (self:a > parm1:a)
67 return 1
68 endif
69 if (self:a < parm1:a)
70 return -1
71 endif
72 if (self:b > parm1:b)
73 return 1
74 endif
75 if (self:b < parm1:b)
76 return -1
77 endif
78 return 0
79
80 operator ToString() class ComplexNumber
81 return cValtoChar(self:a) + " + " + cValToChar(self:b) + "i"
82
83 user function exemploComplex()
84 local obj := ComplexNumber():Create(1, 2)
85 local obj2 := ComplexNumber():Create(3, 4)
86 local objRet
87 objRet := obj + obj2
88 conout(objRet)
89 objRet := obj - obj2
90 conout(objRet)
91 objRet := obj * obj2
92 conout(objRet)
93 objRet := obj / obj2

94 conout(objRet)
95
96 if (obj < obj2)
97 conout("é menor")
98 endif
99 return
23.1 Resultado do Exemplo

4 + 6i
-2 + -2i
-5 + 10i
0.44 + 0.08i
É menor
23.2 Abrangência
19.3.1.0

24 TGetData e TGetMethods
Abrangência
A partir da versão 17.3.0.0 será possível obter o retorno dos métodos e atributos de uma classe sem instanciá-la.
Interface.tlpp
2
3 Class TesteReflection
5 protected method func1()
6 private method func2()
7 public data data1
8 private data data2
9 protected data data3
10 EndClass
11
12 method new() class TesteReflection
13 Return self
14 method func1() class TesteReflection
15 Return self
16 method func2() class TesteReflection
17 Return self
18
19 Function u_test_getClass
20 local retMethods := TesteReflection():TGetMethods()
21 local retData := TesteReflection():TGetData()
22 conout("### methods:")
23 conout(retMethods[1])
26 conout("### data:")
27 conout(retData[1])
30 Return
Resultado:
### methods:
FUNC1
FUNC2
NEW
### data:
DATA1

DATA3
DATA2

25 Tipagem em TL++
Esta documentação apresenta a tipagem de dados na linguagem TLPP.

Visite a seção de introdução(see page 110) e tome ciência das novidades.
25.1 Introdução
Novidades O que eu ganho?
Estão chegando muitas novidades em relação à Agora, o desenvolvedor TL++ poderá ter um código de muito
tipagem de dados na linguagem TL++, o que a mais qualidade, pois muitos erros de type mismatch que eram
direciona para um nível de competitividade muito somente identificados em tempo de execução (com o sistema
próximo de importantes linguagens de mercado, em produção), poderão ser antecipados para o tempo de
tais como Java e Type Script. desenvolvimento, compilação ou expedição.
Perco o legado?
Não, você não perderá o legado, pois o seu fonte de extensão

"prw" poderá ser migrado para extensão "tlpp" (extensão do TL+
+) de forma muito automática e provavelmente sem necessidade
de refatoração de código.
Como os novos recursos de TL++ são realmente significativos,
incluindo, claro, a consistente tipagem de dados, você poderá ir
adaptando os seus fontes com o tempo, de modo a aproveitar
todo esse novo potencial.
25.2 Requisitos
Como posso usar o TLPP Tipado? • Fonte TLPP
• é preciso estar com desenvolvimento
Por estar nativo na linguagem TL++, o seu uso é descomplicado alinhado com o TL++;
e rápido: • o fonte precisa ter extensão "tlpp".
• AppServer
• Disponível a partir da versão 20.3.0.x9
do Application Server (Harpia)
25.3 Tipos Nativos

A linguagem TL++ já disponibiliza vários tipos nativos, que podem ser utilizados na declaração de variáveis,
propriedades de classes, funções, métodos e parâmetros.
O nome do tipo, sua descrição e o seu caractere indicador estão relacionados abaixo.
9 https://tdn.totvs.com/display/tec/Application+Server+-+20.3.y.z

Tipo Descrição Valor Tipo na Tipo a

padrão iniciali pós
na zação iniciali
inicializ ( zado
ação VALTYP (
sem atri E10) VALTYP
buir E11)
num Use para valores numéricos de ponto flutuante, positivos ou 0 N N

eric negativos. Este é o tipo numérico padrão do Protheus, continue (zero)
usando ele para os seus programas de cálculos para precisam
fazer ajuste de precisão.
Local nNum1 as numeric
Local nNum2 := 3 as numeric
integ Use para valores numéricos inteiros, positivos ou negativos. Vai 0 N N

er fazer um "for" ou criar um contador sequencial ... use ele. (zero)
Local iInt1 as integer
Local iInt2 := 7 as integer
doub Use para valores numéricos de ponto flutuante, positivos ou 0 N N

le negativos. (zero)
Local eDbl1 as double
Local eDbl2 := 32.79 as double
deci Use para valores numéricos de alta precisão, essenciais para Nil U F
mal tratamentos monetários. (DEC_CREATE12)
Local fDec1 as decimal
Local fDec2 := DEC_CREATE( 7233.759119, 21, 20 ) as Decimal
char Use para valores textuais (alfanuméricos, pontuação, "" C C

acter especiais, ...) (caracter
vazio)
Local cStr1 as character
Local cStr2 := "TotvsTec" as character
logic Utilizado para valores lógicos, verdadeiro (.T.) ou falso (.F.) .F. L L
al (falso)
Local lBol1 as logical
Local lBol2 := .T. as logical
10 https://tdn.totvs.com/pages/viewpage.action?pageId=27677583
12 https://tdn.totvs.com/display/tec/DEC_CREATE

date Utilize para armazenar datas 31/12/18 D D

99
Local dDte1 as date
Local dDte2 := CToD("08/29/2021") as date
array Use para armazenar uma matriz n-dimensional de valores Nil U A

Local aArr1 as array
Local aArr2 := {1, 2, 3} as array
objec Use para se referir a objetos de interface ou classes Nil U O

t
Local oObj1 as object
Local oObj2 := MyClass():New() as object
json Use para criar um objeto json Nil U J

Local jJsn1 as json
Local jJsn2 := JsonObject():New() as Json
code Use para declarar que é um bloco de código Nil U B

block
Local bBlk1 as codeblock
Local bBlk2 := {|r,l|r*l} as CodeBlock
varia Utilizado para dizer que é um tipo variante e auto polimórfico, Nil U Confor
nt podendo assumir qualquer dos tipos disponíveis me o
tipo atr
Local xVar1 as variant
ibuído
Local xVar2 := 4 as variant
Local xVar3 := "Texto" as variant
varia Utilizado na declaração de funções para indicar passagem de H H

dic parâmetros com quantidade variável.
Não pode ser usado para instanciar uma variável.
"sem Se não for declarado nenhum dos tipos, a variável será tratada Nil U Confor
tipo como "variant" me o
defin tipo
Local xVar1
ido" atribuí
Local xVar2 := .T. do
Local xVar3 := Date()
Obs. Em TL++, as variáveis de tipo numeric, character e date não devem ser comparados com Nil. Segue um
exemplo:

Local nNum as numeric

If (nNum == Nil)
...
EndIf
No exemplo acima, dará erro de compilação, pois a variável nNum é igual a 'N' e já tem o valor default 0 (zero).
Caso precise fazer esta comparação com Nil, o tipo de nNum deve ser modificado para Variant.
Veja também:
VALTYPE13
DEC_CREATE14
25.4 Tipando Variáveis

Qual a forma na Posso deixar uma É permitido dar
básica de me Type: Numeric, Exemplo variável sem Exempl valor inicial Exemplo
declarar uma as Character, Array, - definição de tipo? o - Duas para variáveis - Variável
variável Ty Object, entre outros Declaraç Sim, uma variável formas tipadas? tipada
tipada? pe (veja Tipos Nativos(see ão básica pode ficar sem tipo. de Sim, basta com
page 110)). de Na prática, ela declara colocar a valor
variáveis assume o tipo r atribuição logo inicial
tipadas Variant
variant. depois do nome
da variável. Local
Local Local nVar :=
nVar as xVar1 10 as
Numeric Local Numeric
Private xVar2 Local
cVar as as cVar :=
Characte Varian "I Love
r t TLPP" as
Static Characte
dVar as r
Array
Public
oVar as
Object
25.5 Tipando Propriedades
14 https://tdn.totvs.com/display/tec/DEC_CREATE

Qual a forma básica de Data Posso deixar uma propriedade sem definição
declarar uma propriedade name as Exemplo - Declaração de tipo ou dar um tipo de objeto específico?
tipada? Type básica de propriedades Sim, de maneira idêntica ao que se faz com uma
tipadas variável (veja Tipando Variáveis(see page 113)).
Private Data nVar as

Numeric
Public Data cVar as
Character
25.6 Tipando Funções

Qual a Funct No atual O Eo
forma ion Visite estágio, Static Exe compilador Ex Exemplo - compilador Exemplo - Função
básica name os Function, Main mpl checa se o e Função com também vai com retorno
de (para Tipo Function e o- retorno da m retorno olhar as incompatível
declara mete s Function Decl função é pl incompatív chamadas
r uma rs) as Nativ podem ser araç compatível o- el de funções? Function
função Type os tipadas, sem ão com o seu Fu Sim, o typedFunc() as
bási nç
tipada? (see restrições. tipo Function compilador Numeric
ca ão typedFunc( Local nVar := 10
page A tipagem para declarado? também vai
de co ) as as Numeric
110). User Function (e Sim, o ficar atento a
pro m Numeric Return nVar
possivelmente compilador isso.
prie ret Local
outras formas) verifica e está Chamadas
dad or cVar := "I Function
ainda está em es
bem atento a no
de funções
Love TLPP" typedTest() as
processo de tipa isso. co declaradas
Return Logical
validação. das A seguir, m cVar //
no mesmo Local cVar := "I
observe uma pa ERRO DE
fonte Love TLPP" as
Fun função sem tív COMPILAÇÃO passam pela Character
cti erros de el (Função checagem de Local cResult as
on compilação e Numeric tipos. Character
typ outra com Fu tentando cResult := cVar +
edF erro de nc retornar typedFunc() //
unc retorno. ti um ERRO DE
() on Character) COMPILAÇÃO
as ty (typedFunc é
Num pe Numeric e,
eri dF portanto, não
c un pode ser somada a
c( cVar, que é
) Character.
as Return .T.
Nu
me
ri
c
Lo
ca
l
nV
ar

:
=
10
as
Nu
me
ri
c
Re
tu
rn
nV
ar
25.7 Tipando Métodos

Qual a forma básica de Sugere- A checagem de • se o retorno do método é Recomen
declarar um método se visitar Exemp métodos está no compatível com o tipo da-se
tipado? os Tipos lo - mesmo estágio que declarado; visitar
Nativos Métod a checagem de • se as chamadas àquele Tipando
Deve-se mencionar o tipo (see page o funções? método, quando conhecido Funções
na parte declarativa 110). Tipado Sim, hoje o estaticamente o seu "Self", (see page
(estrutura da classe) e compilador são compatíveis com a 114).
também na implementação #inclu apresenta as expressão em que a
do método, conforme de mesmas tratativas chamada faz parte.
"tlpp-
exemplo seguinte. de checagem de
object
tipos para funções
.th"
ou métodos.
Class
Isso quer dizer que
tMyCla
ele vai olhar:
ss
Public
Method
New()
as
Object
Public
Method
myMeth
od ()
as
Numeri
c
EndCla
ss

Method
New()
as
Object
class

tMyCla
ss
Return
Self

Method
myMeth
od ()
as
Numeri
c
class
tMyCla
ss
Return
10
25.8 Tipando Parâmetros

Qual a Function Quais 1. Em tempo Agora, No exemplo anterior, o
forma name Visit Exemp são as de Exem considere Exemp runtime faz-se valer da
básica (parm1 e lo - checage compilação plo - uma lo - tipagem dos
de dar as os Declar ns feitas a. verifi Checa função f2 Checa parâmetros para
tipos type1, Tipo ação em ca se gem declarada gem acusar erro na
aos parm2 ass de relação a de em um de segunda chamada a f2.
parâmtype2 Nati parâm aos quant Parâm fonte Parâm É importante frisar que
etros etros etros
etros? , ..., vos parâmet idade diferente esse erro acontece no
tipado em em
parmN (see ros? de de ato da chamada da
s Temp Tempo
as page Existem argu Function função, podendo
o de de
typeN) 110). dois ment Test. antecipar problemas
Funct Compi Execuç
moment os Admita que só viriam à tona
ion lação ão
os em passa ainda que em um nível mais
typed
que a dos é a Function profundo da stack de
Func( Funct Funct
parm1
consistên coere ion
f2 tenha a ion
execução.
as
cia dos nte; typed
seguinte Test(
Numer parâmetr b. verific Func( linha )
ic, os é a se nVar declarativ Local
parm2 checada: os as a: dVar
as tipos Numer :=
Chara dos ic, Function date(
cter) argu cVar f2(nVar as ) as
as ment as Date) Date
Varia os Chara Local
nt passa cter) cVar
dos as :=
são Logic dtos(
comp al dVar)
atívei as
s com
os

tipos Local Chara

decla lVar cter

rados as f2(dV
. Logic ar)
al //
lVar Ok,
2. Em tempo
de execução := sem
IIF(c probl
a. realiz
Var emas
a os
== f2(cV
mes
"TLPP ar)
mos " // Va
trata , .T. lendo
ment , .F. -se
os de ) da
temp lVar tipag
o de := em,
comp lVar dará
ilação .AND. erro
; (nVar em
b. tem o == 1) tempo
poten Retur de
cial n execu
de lVar ção.
olhar Retur
tamb Funct n .T.

ion
ém
funçõ Test(
)Loca
es ou
l
méto
lVar
dos
as
que Logic
foram al
defini lVar
dos :=
em typed
outro Func(
s 2,
fonte "TLPP
s. ")
//
Compi
lação
OK
lVar
:=
typed
Func(
"TLPP
", 2)
//
Erro
de

Compi
lação
lVar
:=
typed
Func(
1)
//
Erro
de
Compi
lação
Retur
n .T.
25.8.1 Variadic
Abrangência
A partir da versão 17.3.0.0 o recurso de parâmetro do tipo variadic está disponível no TL++.
Variadic é um tipo de dado para ser utilizado em funções que necessitam receber uma quantidade variável de
parâmetros.
Para sua correta utilização, a função deve estar com os tipos de todos os parâmetros devidamente definidos, além
disso, o parâmetro Variadic deve aparecer apenas uma vez e sempre na última posição da lista de parâmetros.
Para saber a quantidade de parâmetros que foram passados em uma chamada de função que utiliza o Variadic,
basta acessar a propriedade :vCount.
Para acessar os parâmetros propriamente ditos, deve-se acessar a propriedade :vArgs[<posição do parâmetro>].
Para ilustrar a utilização, no exemplo a seguir temos uma função que recebe uma quantidade variável de
parâmetros e imprime todos os valores recebidos:
Variadic.tlpp
1 function exemploVariadic( parm as Variadic )

2
3 local nIndex := 0
4
5 if ( valtype( parm ) == "U" )
6 conout( " sem parametros variadic!" )
7 else
8 for nIndex := 1 to parm:vCount
9 conout(" Parametro variadic '" + cValToChar(nIndex) + "': " +
cValToChar(parm:vArgs[nIndex]) )
10 next
11 endif
12
13 return

 Caso não seja passado nenhum valor na posição definida como parâmetro Variadic, a variável interna da
função estará com valor Nil, sendo então necessário sempre a verificação antes de acessar as
propriedades de Variadic.
25.9 Inicialização Default

Para simplificar o desenvolvimento em TLPP, ao declarar um tipo nativo (veja Tipos Nativos(see page 110)) para uma
variável ou propriedade de classe, um valor inicial default já é automaticamente atribuído. O quadro abaixo
apresenta o indicador inicial e o valor default para cada tipo. Note que os tipos integer e double, por questões de
legado, vão ser iniciados com o tipo 'N'.
Tipo Indicador Valor Default Inicial
integer N 0
double N 0
numeric N 0
character C ""
logical L .F.
date D 31/12/1899
25.10 Regras de Tipagem

É muito importante que o desenvolvedor TLPP conheça os tratamentos e os comportamentos aplicados às diversas
estruturas de código da linguagem.
O objetivo desta seção é detalhar todos estes tratamentos de tipagem, a fim de tornar cada vez mais eficiente o
desenvolvimento de produtos em TLPP.
25.10.1 Tabela Verdade

Grande parte das regras que serão documentadas a seguir, fará se valer da estrutura da tabela-verdade seguinte.

A B C D F H I J L N O U
Essa tabela-verdade combina o produto cartesiano entre os tipos nativos definidos na linguagem TLPP, conforme
apresentado na seção Tipos Nativos(see page 110).
Quando houver compatibilidade entre os tipos, haverá uma marcação com o símbolo , como ilustrado no
cruzamento N x U ou U x U.
Não estando marcado, significará que há um erro de tipagem.
25.10.2 Atribuição
A linguagem TLPP disponibiliza três formatos de atribuição:
• Atribuição padrão: VAR := EXPRESSION
• Atribuição simples: VAR = EXPRESSION
• Atribuição composta: VAR1 := VAR2 := ... := VARN := EXPRESSION
Em qualquer dos formatos, seja VAR uma variável de escopo ou propriedade de objeto, a atribuição segue as regras
da tabela verdade seguinte.

VAR está nas linhas da tabela.

EXPRESSION está nas colunas.
25.10.3 Operações Aditivas

Considere os seguintes operadores:
+ - += -=
Formatos:
• EXPR1 + EXPR2
• EXPR1 - EXPR2
• VAR += EXPR
• VAR -= EXPR

Nos dois primeiros formatos, temos EXPR1 nas linhas e EXPR2 nas colunas da tabela.
Nos dois últimos, VAR está nas linhas e EXPR nas colunas.
25.10.4 Operações Multiplicativas

* / % ^ << >> *= /=
Formatos:
• EXPR1 * EXPR2
• EXPR1 / EXPR2
• EXPR1 % EXPR2

• EXPR1 ^ EXPR2
• EXPR1 << EXPR2

• EXPR1 >> EXPR2
• VAR *= EXPR
• VAR /= EXPR
Nos primeiros formatos, temos EXPR1 nas linhas e EXPR2 nas colunas da tabela.
Nos dois últimos, VAR está nas linhas e EXPR nas colunas.
25.10.5 Operações Comparativas

Aqui, vamos dividir as regras em dois grupos.
GRUPO 1

< > <= >=
Formatos:
• EXPR1 < EXPR2
• EXPR1 > EXPR2
• EXPR1 <= EXPR2
• EXPR1 >= EXPR2
EXPR1 está nas linhas da tabela e EXPR2 está nas colunas.

GRUPO 2
== <>
Formatos:
• EXPR1 == EXPR2
• EXPR1 <> EXPR2

25.10.6 Operação "Contido em ..."

Considere o operador:
Formato:
• EXPR1 $ EXPR2

25.10.7 Operações Lógicas

Aqui, vamos dividir as regras em dois grupos.
GRUPO 1
Considere os operadores:
.OR. .AND.
Formatos:
• EXPR1 .OR. EXPR2
• EXPR1 .AND. EXPR2

!
J
F
A
C
B
D
U
N
A
A
GRUPO 2
Formato:
• ! EXPR
B
B
C
C
Considere o operador:
D
D
F
F
H
H
I
I
EXPR restringe-se a tipos de natureza lógica.
J
J
L
L
N
N
O
O
U
U

25.10.8 Expressão com Sinal

+ -
Formatos:
• - EXPR
• + EXPR
EXPR está restrito a expressões com característica numérica.

25.10.9 Expressões de Incremento

++ --
Formatos:
• ++EXPR
• --EXPR
• EXPR++
• EXPR--
EXPR está restrito a expressões com característica numérica.

25.10.10 IF e While
A expressão condicional formadora de um bloco If ou While é analisada e deve corresponder a um valor lógico.
Formatos:
• if (EXPR)
• while (EXPR)
EXPR está restrito a expressões com característica lógica.

25.10.11 Comando For

O comando for admite a seguinte construção sintática:
For firstValue to lastValue [ step value ]
Formatos:
• For VAR := EXPR1 to EXPR2
• For VAR := EXPR1 to EXPR2 step EXPR3
Em qualquer dos formatos, EXPR1, EXPR2 e EXPR3 estão restritas a terem característica numérica.

25.10.12 IF Ternário
O IF ternário obedece a seguinte sintaxe:
IIF ( EXPR1, EXPR2, EXPR3 )
Formatos:
• if ( EXPR1, EXPR2, EXPR3 )
• iif ( EXPR1, EXPR2, EXPR3 )
A EXPR1 deve ser tratada da mesma for que a expressão condicional de If e While (veja IF e While(see page 131))
A EXPR2 e a EXPR3 devem ser compatíveis entre si. Por exemplo, não é permitido que a EXPR2 seja Character e
a EXPR3 seja Numeric. No entanto, sendo as duas Character ou as duas Numeric, a compatibilidade é garantida.
A EXPR2 está nas linhas da tabela e a EXPR3 está nas colunas.

25.10.13 Acesso a Array

Formato Típico:
VAR [ INDEX ]
Regras:
1. Sendo VAR uma variável de tipo Array, INDEX poderá ser Integer, Numeric ou Variant;
2. Sendo VAR uma variável de tipo Variant, INDEX poderá ser Integer, Numeric, Character ou Variant;
3. Sendo VAR uma variável de tipo Json, visite a seção Acesso a Json(see page 135)para entender o
tratamento;
4. Para qualquer outro tipo de VAR, será gerado um erro de compilação.

25.10.14 Acesso a Json

Formato Típico:
VAR [ KEY ]
Regras:
1. Sendo VAR uma variável de tipo Json, KEY poderá ser Character ou Variant;
2. Sendo VAR uma variável de tipo Array ou Variant, visite a seção Acesso a Array(see page 134) para entender
melhor;
3. Sendo VAR de qualquer outro tipo, será gerado um erro de compilação.

26 Try...Catch
Um bloco de código entre as expressões Try...Catch são testados e caso de um erro implícito no código (uma
exceção), ou erro explicito declarado no programa, tem seu fluxo desviado para o bloco de tratamento de erro em
catch.
Diferente do BEGIN SEQUENCE ... END SEQUENCE, onde o código dispara o bloco de erros e pode continuar sua
execução sem cair no RECOVER, apenas mediante ao comando o BREAK, uma exceção no código, mesmo que de
forma implícita (por exemplo, a utilização de uma classe não definida), irá imediatamente desviar o fluxo de código
para o bloco de tratamento de erro.
Outra diferença é que a captura do erro ocorre via a classe ErrorClass(), que pode ou não ter sido definida durante a
execução do programa, e conterá em seus parâmetros o conteúdo do erro informado.
 Apesar do TRY...CATCH só estar disponível no TLPP, ainda é possível realizar um THROW, implícito ou
explicito a partir de uma chamada para uma função em advpl dentro de seu bloco de código.
26.1 01. SINTAXE
TRY ...
< instruções >
...
[ THROW [ < expressão > ] ]
...
< instruções >
...
[ RECOVER [ USING < variável > ] ]
...
< instruções >
...
CATCH
< instruções >
FINALLY
< instruções >
ENDTRY
26.2 02. PARÂMETROS
Nome Tipo Descrição Obrigatório Referência
TRY Expressão Define o inicio do bloco de código Sim Não

contendo o controle de erro
Try...Catch – 136
Nome Tipo Descrição Obrigatório Referência
THROW [ < expressão Expressão Define um desvio explicito para o Não Sim
>] tratamento de erro
CATCH Expressão Define um ponto de tratamento Sim Não

de erro e/ou recuperação que
será o ponto de desvio em caso
de erro no bloco do TRY
FINALLY Expressão Define um bloco de código que Não Não

será executado de qualquer
maneira(se tiver ou não tiver
exceção lançada)
ENDTRY Expressão Define o fim do bloco de Sim Não

sequência
26.3 03. EXEMPLOS
Um dos modelos mais simples de exemplo que temos, é onde realizamos um throw explicito em nosso programa.
Isso faz com que, indifente do nível do stack onde estamos no nosso programa, ele vai mudar imediatamente o
fluxo do programa para o CATCH, e informar a ultima descrição de erro erro (varError:description) informada:
function u_fTryT01()
conout("funcao que cria o errorclass")
varError := ErrorClass():New() //sempre a exceção lançada deve ser uma instância da classe ErrorClass
ou de uma classe que herda de ErrorClass
varError:genCode := 15461
varError:description := "ERRO designado no ErrorClass do u_fTryT01"
throw varError //lançamento da exceção com objeto de erro
conout("NÃO PODE PASSAR NUNCA") //nunca passará nesse trecho de código porque tem uma exceção lançada
na linha anterior
return

User Function TryC001
Local x
Local y := "TryTest"
TRY
//ErrorClass pode ou não ser declarado no mesmo nível
//Local oError := ErrorClass():New()
u_fTryT01()
conout("essa linha NÃO deve ser executada (throw explicito dentro do u_fTryT01())")
x := &y.(,)
CATCH oError
ConOut( oError:description )
ENDTRY
Try...Catch – 137
Return( NIL )
Uma observação importante ao declarar a ErrorClass em outro nível de stack, é o seu escopo. Observe o exemplo
abaixo:
function u_fTryT02p()
conout("funcao que cria o errorclass como publica (vai funcionar)")
public varError := ErrorClass():New() //sempre a exceção lançada deve ser uma instância da classe
ErrorClass ou de uma classe que herda de ErrorClass
varError:description := "ERRO DO u_fTryT02p"
return

TRY
//se eu declarar como local, e nao public, vai dar erro no varerror dentro do catch..
u_fTryT02p()
throw varError
conout("NÃO PODE PASSAR NUNCA") //nunca passará nesse trecho de código porque tem uma exceção
lançada na linha anterior
CATCH varError
//ConOut( ProcName() + " " + Str(ProcLine()) + " " + e:description )
ConOut( varError:description )
ENDTRY
Return( NIL )
Nesse caso o throw explicito foi realizado em outro nivel de stack onde ocorreu a declaração da instancia da
ErrorClass. Porem como foi declarado como publica, não houve problema. Diferentemente do exemplo abaixo:
function u_fTryT02()
conout("funcao que cria o errorclass como local (NÃO vai funcionar)")
varError := ErrorClass():New() //sempre a exceção lançada deve ser uma instância da classe ErrorClass
ou de uma classe que herda de ErrorClass
varError:description := "ERRO DO u_fTryT02"
return

TRY
//se eu declarar como local, e nao public, vai dar erro no varerror dentro do catch..
u_fTryT02()
throw varError
CATCH varError
conout("conout aqui vai mostrar errado, como 'varError nao existe', e nao como 'ERRO DO u_fTryT02'")
ENDTRY
Try...Catch – 138
Return( NIL )
Aqui o erro capturado será na linha do THROW varError, e não a informação declarada no stack anterior, ja que
nesse ponto do stack a instancia varError não existe.
Outro exemplo simples de utilização é com a captura de erros de forma implícita, por conta de exceções na
linguagem. Veja o exemplo onde a função TryTest não existe em nosso RPO:
Local x
TRY
u_fTryT02p()
x := &y.(,)
CATCH oError
ENDTRY
Return( NIL )
Nesse exemplo mesmo com a classe declarada varError na função , o conout da oError será "Macro FC: cannot find
function :TryTest". Observe também que apesar de não existir a instancia declara de oError, mesmo assim a
chamada de CATCH a essa instancia foi preenchida com a instancia padrão de ErrorClass() que existe no AppServer,
isso considerando que o erro foi implícito, e não explicito como na chamada de THROW varError de um exemplo
anterior.
Para ficar claro a questão de erros explicitos e implicitos, observe no proximo exemplo onde mesmo informando
uma descrição a instancia oError, a informação do conout é do erro implícito:
Local x
TRY
oError := ErrorClass():New()
oError:genCode := 15461
oError:description := "ERRO designado no ErrorClass do u_TryC0003"
x := &y.(,)
CATCH oError
ENDTRY
Return( NIL )
Try...Catch – 139
Quanto a utilização da instancia da classe ErrorClass, atenção a esse comportamento já citado sobre a instancia
que existe nativamente do Appserver. Nesse exemplo, a instancia de oSample2 é a ErrorClass, e a instancia do
oSample de uma classe que nao existe. No catch foi utilizado a instancia errada, mas como ela não existe, foi criado
nela a referencia para a ErrorClass nativa do Appserver. Então teremos dois conouts, o do oSample2 da nossa
classe ErrorClass (que não tem nada), e o oSample com a instancia do ErrorClass nativo do Appserver, com a
descrição "invalid class NAOEXISTE":
Function u_TryC005

local val2 := 2
oSample2 := ErrorClass():New()
try
//conout("2" + val2)
oSample := naoexiste():New()
ConOut("isso NÃO deve executar...")
catch oSample //errado, mas como o objeto nao existe, ele recebe o ErrorClass nativo do Appserver
ConOut("Estou no Catch...")
ConOut( oSample2:description )
conout( oSample:description)
conout("atencao para a confusao entre as classes... o oSample2 (que é a classe correta) mas o catch
que esta com a instancia errada, funcionou")
endtry
Return
Veja um outro exemplo com a classe corretamente informada:
Function u_TryC0005
oSample2 := ErrorClass():New()
conout("atencao para a confusao entre as classes...")
try
oSample := Sample2Class():New() //SampleClassChild():New()
//conout("2" + 2)
ConOut("Estou no Try...")
throw oSample
catch oSample2 //as SampleClass
ConOut("Estou no Catch...")
ConOut( oSample2:description )
endtry
Return
Outra forma de setar na instancia da ErrorClass() nativa do Appserver, é utilizar a função UserException15:
user function TryC010()

try
UserException("qualquer erro para mostrar a questao do throw implicito funcionar via UserException
(sem instancia de classe de erro e sem throw explicito)")
conout("isso NÃO deve executar")
catch e //no catch eh possível nomear a exceção lançada para acessar no corpo do catch
15 https://tdn.totvs.com/display/tec/UserException
Try...Catch – 140
conout(e:description)
conout(e:genCode)
finally //o finally é opcional e será executado de qualquer maneira(se tiver ou não tiver exceção
lançada)
conout("finally")
endtry
return
Outro exemplo importante é que é perfeitamente possivel cruzar a utilização do Comando BEGIN SEQUENCE ...
END16 com o Try..Catch:
function u_fErrBfun03( )

conout("errorblock foi acionado com break")
break

return

Function u_TryCTLPP0002

Local oError
Local e
TRY
//se eu declarar como local, e nao public, vai dar erro no varerror dentro do catch.. deveria
resgatar?
u_fTryT02p()

oError := ErrorBlock( { | e | u_fErrBfun03() } )

Begin Sequence
var := var+1 // variavel não existe
conout("Isto jamais deve ser executado" )
return .T.
Recover
conout("Recover, passar aqui")
End Sequence
conout("terminou o begin..end")

throw varError
conout( "Isto jamais deve ser executado" ) //nunca passará nesse trecho de código porque tem uma
exceção lançada na linha anterior
CATCH varError
conout("entrou no catch")
ENDTRY
Return
16 https://tdn.totvs.com/display/framework/BEGIN+SEQUENCE+...+END
Try...Catch – 141
26.4 04. ABRANGÊNCIA
Application Server 20.3.0.0
26.5 05. VEJA TAMBÉM

• BEGIN SEQUENCE ... END17
17 https://tdn.totvs.com/display/framework/BEGIN+SEQUENCE+...+END
Try...Catch – 142

PDF Exporter Purchase

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

PDF Exporter Purchase

Enviado por

Direitos autorais:

Formatos disponíveis

You are using an UNLICENSED copy of Scroll PDF Exporter for Confluence.

Exported on 07/08/2022

foram disponibilizadas dentro do namespace Reflection: ................................................. 40

21.5 Reflection.getAttributesByAnnotation ................................................................................ 56

21.5.1 Sintaxe ................................................................................................................................................................. 56

21.9.3 Retorno ................................................................................................................................................................ 63

21.13.5 Resultado do Exemplo........................................................................................................................................ 70

21.13.6 Abrangência ........................................................................................................................................................ 70

21.18 Reflection.getMethodAnnotation ........................................................................................ 77

21.18.1 Sintaxe ................................................................................................................................................................. 77

21.22.3 Retorno ................................................................................................................................................................ 85

21.26.5 Resultado do Exemplo........................................................................................................................................ 93

21.26.6 Abrangência ........................................................................................................................................................ 93

21.31.1 Sintaxe ................................................................................................................................................................. 99

22 Representational State Transfer (REST) ....................................................... 104

25.10.1 Tabela Verdade ................................................................................................................................................. 119

25.10.2 Atribuição .......................................................................................................................................................... 120

26 Try...Catch ...................................................................................................... 136

Aqui você irá encontrar todos os recursos da linguagem TL++

1 Encapsulamento - Modificador de Acesso

Encapsulamento - Modificador de Acesso – 13

2 Expressões Regulares (RegEx)

Expressões Regulares (RegEx) – 14

• Classe Attribute(see page 40)

9 Representational State Transfer (REST)

Representational State Transfer (REST) – 21

• Introdução(see page 110)

14 Encapsulamento - Modificador de Acesso

Os níveis de modificadores são:

PRIVATE O método ou a propriedade estarão acessíveis apenas de dentro da

PROTECTED O método ou a propriedade estarão acessíveis apenas de dentro da

PUBLIC O método ou a propriedade estarão acessíveis de qualquer lugar.

Encapsulamento - Modificador de Acesso – 26

method teste3() class EscopeMethod

Encapsulamento - Modificador de Acesso – 27

15 Expressões Regulares (RegEx)

A documentação dessa funcionalidade está na área "Produtos do tlppCore"

https://tdn.totvs.com/display/tec/RegEx(see page 28)

Expressões Regulares (RegEx) – 28

13 //Utilizar https://jsonlint.com para mostrar estrutura

14 //Character com conteudo json - ainda nao eh objeto json

65 //sera impresso: Exemplo 4: {"chave":"valor","propriedade":"valor da sua

Saiba mais sobre a classe JsonObject:

static method staticExample()

method new() class ForWithProperty

method staticExample() class StaticMethod

main function tteci_142

Disponível em: 17.3.0.0 para a linguagem TL++

19.1 Funções dentro de namespace:

1 user function exemplo2

1 using namespace exemplo

19.2 Classes dentro de namespace:

1 user function exemplo5()

1 using namespace exemplo2.1

Uso da annotation em definição de classe:

Uso da annotation em definição de método:

Uso da annotation em definição de propriedade:

Uso da annotation em definição de função:

1 @ExemploDeAnnotation(property1 = "FunctionTeste", property2 = 123)

21.1 Novas funções disponíveis para uso juntamente com o recurso de

21.2 Classe Attribute

1 //Definicoes das annotation, deve estar num fonte