Author: buildbot
Date: Wed Feb 19 23:02:47 2020
New Revision: 1056741
Log:
Staging update by buildbot for jena
Modified:
websites/staging/jena/trunk/content/ (props changed)
websites/staging/jena/trunk/content/tutorials/rdf_api_pt.html
Propchange: websites/staging/jena/trunk/content/
------------------------------------------------------------------------------
--- cms:source-revision (original)
+++ cms:source-revision Wed Feb 19 23:02:47 2020
@@ -1 +1 @@
-1874232
+1874233
Modified: websites/staging/jena/trunk/content/tutorials/rdf_api_pt.html
==============================================================================
--- websites/staging/jena/trunk/content/tutorials/rdf_api_pt.html (original)
+++ websites/staging/jena/trunk/content/tutorials/rdf_api_pt.html Wed Feb 19
23:02:47 2020
@@ -227,15 +227,20 @@ Literais são exibidas em retângulo
<p>O código para criar este grafo, ou modelo, é simples:</p>
-<p><pre>// some definitions
+<pre>// some definitions
static String personURI = "http://somewhere/JohnSmith";;
-static String fullName = "John Smith";</p>
-<p>// create an empty Model
-Model model = ModelFactory.createDefaultModel();</p>
-<p>// create the resource
-Resource johnSmith = model.createResource(personURI);</p>
-<p>// add the property
- johnSmith.addProperty(VCARD.FN, fullName);</pre></p>
+static String fullName = "John Smith";
+
+// create an empty Model
+Model model = ModelFactory.createDefaultModel();
+
+// create the resource
+Resource johnSmith = model.createResource(personURI);
+
+// add the property
+johnSmith.addProperty(VCARD.FN, fullName);
+</pre>
+
<p>Ele começa com algumas definições de constantes e então cria um Model
vazio, usando o método <code>createDefaultModel()</code> de
<code>ModelFactory</code>
para criar um modelo na memória. Jena possui outras implementações da
interface Model, e.g. uma que usa banco de dados relacionais: esses tipos de
modelo são também disponibilizados a partir de ModelFactory.</p>
@@ -243,9 +248,11 @@ para criar um modelo na memória. Jena
<p>O código para criar o recurso e adicionar a propriedade pode ser escrito
de forma mais compacta usando um estilo cascata:</p>
-<p><pre>Resource johnSmith =
- model.createResource(personURI)
- .addProperty(VCARD.FN, fullName);</pre></p>
+<pre>Resource johnSmith =
+ model.createResource(personURI)
+ .addProperty(VCARD.FN, fullName);
+</pre>
+
<p>Os códigos desse exemplo podem ser encontrados no diretório /src-examples
no pacote de distribuição do Jena como <a
href="https://github.com/apache/jena/tree/master/jena-core/src-examples/jena/examples/rdf/Tutorial01.java";>tutorial
1</a>. Como exercÃcio, pegue este código e modifique-o para criar um
próprio VCARD para você.</p>
<p>Agora vamos adicionar mais detalhes ao vcard, explorando mais recursos de
RDF e Jena.</p>
@@ -259,14 +266,16 @@ para criar um modelo na memória. Jena
<p>O código Jena para construir este exemplo é, novamente, muito simples.
Primeiro algumas declarações e a criação do modelo vazio.</p>
-<p><pre>// some definitions
+<pre>// some definitions
String personURI = "http://somewhere/JohnSmith";;
String givenName = "John";
String familyName = "Smith";
-String fullName = givenName + " " + familyName;</p>
-<p>// create an empty Model
-Model model = ModelFactory.createDefaultModel();</p>
-<p>// create the resource
+String fullName = givenName + " " + familyName;
+
+// create an empty Model
+Model model = ModelFactory.createDefaultModel();
+
+// create the resource
// and add the properties cascading style
Resource johnSmith
= model.createResource(personURI)
@@ -274,7 +283,9 @@ Resource johnSmith
.addProperty(VCARD.N,
model.createResource()
.addProperty(VCARD.Given, givenName)
- .addProperty(VCARD.Family, familyName));</pre></p>
+ .addProperty(VCARD.Family, familyName));
+</pre>
+
<p>Os códigos desse exemplo podem ser encontrados no diretório /src-examples
no pacote de distribuição do Jena como <a
href="https://github.com/apache/jena/tree/master/jena-core/src-examples/jena/examples/rdf/Tutorial02.java";>tutorial
2</a>.</p>
<h2><a id="ch-Statements">Sentenças</a></h2>
@@ -319,7 +330,8 @@ while (iter.hasNext()) {
}
System.out.println(" .");
-} </pre>
+}
+</pre>
<p>Já que o objeto de uma sentença pode ser tanto um recurso quanto uma
literal, o método
<code>getObject()</code> retorna um objeto do tipo <code>RDFNode</code>, que
é uma superclasse comum de ambos <code>Resource</code> e <code>Literal</code>.
O objeto em si é do tipo apropriado, então o código usa
<code>instanceof</code> para determinar qual e processá-lo de acordo.</p>
@@ -329,7 +341,9 @@ while (iter.hasNext()) {
<pre>http://somewhere/JohnSmith http://www.w3.org/2001/vcard-rdf/3.0#N
anon:14df86:ecc3dee17b:-7fff .
anon:14df86:ecc3dee17b:-7fff http://www.w3.org/2001/vcard-rdf/3.0#Family
"Smith" .
anon:14df86:ecc3dee17b:-7fff http://www.w3.org/2001/vcard-rdf/3.0#Given
"John" .
-http://somewhere/JohnSmith http://www.w3.org/2001/vcard-rdf/3.0#FN "John
Smith" .</pre>
+http://somewhere/JohnSmith http://www.w3.org/2001/vcard-rdf/3.0#FN "John
Smith"
+.
+</pre>
<p></p>
@@ -377,37 +391,43 @@ model.write(System.out);</pre></p>
<p>Jena possui uma interface extensÃvel que permite novos escritores para
diferentes linguagens de serialização RDF. Jena possuem também um escritor
RDF/XML mais sofisticado que pode ser invocado ao especificar outro argumento Ã
chamada de método
<code>write()</code>:</p>
-<p><pre>// now write the model in XML form to a file
+<pre>// now write the model in XML form to a file
model.write(System.out, "RDF/XML-ABBREV");
- </pre></p>
+ </pre>
+
<p>Este escritor, chamado também de PrettyWriter, ganha vantagem ao usar as
particularidades da sintaxe abreviada de RDF/XML ao criar um modelo mais
compacto. Ele também é capaz de preservar os blank nodes onde é possÃvel.
Entretanto, não é recomendável para escrever modelos muito grandes, já que
sua desempenho deixa a desejar. Para escrever grandes arquivos e preservar os
blank nodes, escreva no formato de N-Triplas:</p>
-<p><pre>// now write the model in XML form to a file
+<pre>// now write the model in XML form to a file
model.write(System.out, "N-TRIPLE");
- </pre></p>
+</pre>
+
<p>Isso produzirá uma saÃda similar à do tutorial 3, que está em
conformidade com a especificação de N-Triplas.</p>
<h2><a id="ch-Reading-RDF">Leitura de RDF</a></h2>
<p><a
href="https://github.com/apache/jena/tree/master/jena-core/src-examples/jena/examples/rdf/Tutorial05.java";>Tutorial
5</a> demonstra a leitura num modelo de sentenças gravadas num RDF XML. Com
este tutorial, nós teremos criado uma pequena base de dados de vcards na forma
RDF/XML. O código a seguir fará leitura e escrita. <em>Note que para esta
aplicação rodar, o arquivo de entrada precisa estar no diretório da
aplicação.</em></p>
-<p><pre>
- // create an empty model
- Model model = ModelFactory.createDefaultModel();</p>
-<p>// use the FileManager to find the input file
- InputStream in = FileManager.get().open( inputFileName );
+<pre>
+// create an empty model
+Model model = ModelFactory.createDefaultModel();
+
+// use the FileManager to find the input file
+InputStream in = FileManager.get().open( inputFileName );
if (in == null) {
throw new IllegalArgumentException(
"File: " + inputFileName + " not found");
-}</p>
-<p>// read the RDF/XML file
-model.read(in, null);</p>
-<p>// write it to standard out
+}
+
+// read the RDF/XML file
+model.read(in, null);
+
+// write it to standard out
model.write(System.out);
- </pre></p>
+</pre>
+
<p>O segundo argumento da chamada de método <code>read()</code> é a URI que
será usada para resolver URIs relativas. Como não há referências URI
relativas no arquivo de teste, ele pode ser vazio. Quando executado, <a
href="https://github.com/apache/jena/tree/master/jena-core/src-examples/jena/examples/rdf/Tutorial05.java";>
tutorial 5</a> produzirá uma saÃda XML como esta:</p>
-<p><pre><rdf:RDF
+<pre><rdf:RDF
xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'
xmlns:vcard='http://www.w3.org/2001/vcard-rdf/3.0#'
>
@@ -443,7 +463,8 @@ model.write(System.out);
<vcard:FN>Becky Smith</vcard:FN>
<vcard:N rdf:nodeID="A3"/>
</rdf:Description>
-</rdf:RDF></pre></p>
+</rdf:RDF></pre>
+
<h2 id="ch-Prefixes">Controlando prefixos</h2>
<h3>Definições explÃcitas de prefixos</h3>
@@ -451,7 +472,6 @@ model.write(System.out);
<p>Na sessão anterior, nós vimos que a saÃda XML declarou um prefixo
namespace<br />
<code>vcard</code> e o usou para abreviar URIs. Enquanto que RDF usa somente
URIs completas, e não sua forma encurtada, Jena provê formas de controlar
namespaces usados na saÃda com seu mapeamento de prefixos. Aqui vai um exemplo
simples.</p>
<pre>
-<code>
Model m = ModelFactory.createDefaultModel();
String nsA = "http://somewhere/else#";;
String nsB = "http://nowhere/else#";;
@@ -470,12 +490,10 @@ model.write(System.out);
System.out.println( "# -- nsA and cat defined" );
m.setNsPrefix( "cat", nsB );
m.write( System.out );
-</code>
</pre>
<p>A saÃda deste fragmento são três blocos de RDF/XML, com três diferentes
mapeamentos de prefixos. Primeiro o padrão, sem prefixos diferentes dos
padrões:</p>
<pre>
-<code>
# -- no special prefixes defined
<rdf:RDF
@@ -490,7 +508,6 @@ model.write(System.out);
<j.0:Q rdf:resource="http://somewhere/else#z"/>
</rdf:Description>
</rdf:RDF>
-</code>
</pre>
<p>Nós vimos que o namespace rdf é declarado automaticamente, já que são
requeridos para tags como <code><RDF:rdf></code> e
<code><rdf:resource></code>. Declarações de namespace são também
necessárias para o uso das duas propriedades P e Q, mas já que seus
namespaces não foram introduzidos no modelo, eles recebem nomes namespaces
inventados <code>j.0</code> e <code>j.1</code>.</p>
@@ -500,7 +517,6 @@ declara que o namespace da <code>URI</co
<pre>
-<code>
# -- nsA defined
<rdf:RDF
@@ -515,7 +531,6 @@ declara que o namespace da <code>URI</co
<j.0:Q rdf:resource="http://somewhere/else#z"/>
</rdf:Description>
</rdf:RDF>
-</code>
</pre>
@@ -523,7 +538,6 @@ O outro namespace ainda recebe o nome cr
<pre>
-<code>
# -- nsA and cat defined
<rdf:RDF
@@ -538,7 +552,6 @@ O outro namespace ainda recebe o nome cr
<cat:Q rdf:resource="http://somewhere/else#z"/>
</rdf:Description>
</rdf:RDF>
-</code>
</pre>
@@ -552,11 +565,9 @@ Assim como as declarações de prefi
<pre>
-<code>
Model m2 = ModelFactory.createDefaultModel();
m2.read( "file:/tmp/fragment.rdf" );
m2.write( System.out );
-</code>
</pre>
@@ -585,23 +596,24 @@ Você verá que os prefixos da entra
<p> Dada a URI de um recurso, o objeto do recurso pode ser recuperado de um
modelo usando o método <code>Model.getResource(String uri)</code>. Este
método é definido para retornar um objeto Resource se ele existir no modelo,
ou, caso contrário, criar um novo. Por exemplo, para recuperar o recurso Adam
Smith do modelo lido a partir do arquivo no tutorial 5:</p>
- <pre>// retrieve the John Smith vcard resource from the model
-Resource vcard = model.getResource(johnSmithURI);</code>
- </pre>
+<pre>// retrieve the John Smith vcard resource from the model
+Resource vcard = model.getResource(johnSmithURI);
+</pre>
<p>A interface Resource define numerosos métodos para acessar as propriedades
de um recurso. O método <code>Resource.getProperty(Property p)</code> acessa
uma propriedade do recurso. Este método não segue a convenção usual de Java
de acesso já que o tipo do objeto retorna é <code>Statement,</code> e não
<code>Property</code> como era de se esperar. Retornando toda a sentença
permite à aplicação acessar o valor da propriedade usando um de seus
métodos de acesso que retornam o objeto da sentença. Por exemplo, para
recuperar o recurso que é o valor da propriedade <code>vcard:N</code></p>
- <pre>// retrieve the value of the N property
+<pre>// retrieve the value of the N property
Resource name = (Resource) vcard.getProperty(VCARD.N)
- .getObject();</pre>
+ .getObject();
+</pre>
<p>De modo geral, o objeto de uma sentença pode ser um recurso ou uma
literal, então a aplicação, sabendo que o valor precisar ser um recurso, faz
o cast do objeto retornado. Uma das coisas que Jena tenta fazer é fornecer
tipos especÃficos de métodos, então a aplicação não tem que fazer cast, e
checagem de tipos pode ser feita em tempo de compilação. O fragmento de
código acima poderia ser mais convenientemente escrito assim:</p>
- <pre>// retrieve the value of the FN property
+<pre>// retrieve the value of the FN property
Resource name = vcard.getProperty(VCARD.N)
.getResource();</pre>
@@ -609,7 +621,7 @@ Resource name = vcard.getProperty(VCARD.
<p>Similarmente, o valor literal de uma propriedade pode ser recuperado:</p>
- <pre>// retrieve the given name property
+<pre>// retrieve the given name property
String fullName = vcard.getProperty(VCARD.FN)
.getString();</pre>
@@ -617,7 +629,7 @@ String fullName = vcard.getProperty(VCAR
<p>Neste exemplo, o recurso vcard possui somente as propriedades
<code>vcard:FN</code> e <code>vcard:N</code>. RDF permite a um recurso repetir
uma propriedade; por exemplo, Adam pode ter mais de um apelido. Vamos dar dois
apelidos a ele:</p>
- <pre>// add two nickname properties to vcard
+<pre>// add two nickname properties to vcard
vcard.addProperty(VCARD.NICKNAME, "Smithy")
.addProperty(VCARD.NICKNAME, "Adman");</pre>
@@ -627,7 +639,7 @@ vcard.addProperty(VCARD.NICKNAME, "Smith
<p>Se for possÃvel que uma propriedade ocorra mais de uma vez, então o
método Resource.listProperties(Property p) pode ser usado para retornar um
iterador para lista-las. Este método retorna um iterador que retorna objetos
do tipo <code>Statement</code>. Nós podemos listar os apelidos assim:</p>
- <pre>// set up the output
+<pre>// set up the output
System.out.println("The nicknames of \""
+ fullName + "\" are:");
// list the nicknames
@@ -636,16 +648,18 @@ while (iter.hasNext()) {
System.out.println(" " + iter.nextStatement()
.getObject()
.toString());
-}</pre>
+}
+</pre>
<p>Esse código pode ser encontrado em <a
href="https://github.com/apache/jena/tree/master/jena-core/src-examples/jena/examples/rdf/Tutorial06.java";>
tutorial 6</a>. O iterador <code>iter</code> reproduz todas as sentenças com
sujeito <code>vcard</code> e predicado <code>VCARD.NICKNAME</code>, então,
iterar sobre ele permite recuperar cada sentença usando
<code>nextStatement()</code>, pegar o campo do objeto, e convertê-lo para
string. O código produz a seguinte saÃda quando executado:</p>
- <pre>The nicknames of "John Smith" are:
- Smithy
- Adman</pre>
+<pre>The nicknames of "John Smith" are:
+ Smithy
+ Adman
+</pre>
<p>Todas as propriedades de um recurso podem ser listadas usando o método
@@ -675,23 +689,20 @@ while (iter.hasNext()) {
<p>Todos esses métodos de consulta são acuçar sintático sobre o método
primitivo de consulta <code>model.listStatements(Selector s)</code>. Esse
método retorna um iterador sobre todas as sentenças no modelo 'selecionado'
por <code>s</code>. A interface de selector foi feita para ser extensÃvel, mas
por hora, só há uma implementação dela, a classe
<code>SimpleSelector</code> do pacote <code>org.apache.jena.rdf.model</code>.
Usar <code>SimpleSelector </code> é uma das raras ocasiões em Jena onde é
necessário usar uma classe especifica em vez de uma interface. O construtor de
<code>SimpleSelector</code> recebe três argumentos:</p>
- <pre>Selector selector = new SimpleSelector(subject, predicate, object)
- </pre>
+<pre>Selector selector = new SimpleSelector(subject, predicate, object)</pre>
<p>Esse selector vai selecionar todas as sentenças em que o sujeito casa com
<code>subject</code>, um predicado que casa com <code>predicate</code> e um
objeto que casa com <code>object</code>. Se <code>null</code> é passado para
algum dos argumentos, ele vai casar com qualquer coisa, caso contrário, ele
vai casar com os recursos ou literais correspondentes. (Dois recursos são
iguais se eles possuem o mesmo URI ou são o mesmo blank node; dois literais
são iguais se todos os seus componentes forem iguais.) Assim:</p>
- <pre>Selector selector = new SimpleSelector(null, null, null);
- </pre>
+ <pre>Selector selector = new SimpleSelector(null, null, null);</pre>
<p>vai selecionar todas as sentenças do modelo.</p>
- <pre>Selector selector = new SimpleSelector(null, VCARD.FN, null);
- </pre>
+ <pre>Selector selector = new SimpleSelector(null, VCARD.FN, null);</pre>
<p>vai selecionar todas as sentenças com o predicado VCARD.FN, independente
do sujeito ou objeto. Como um atalho especial,
@@ -712,7 +723,7 @@ O código a seguir, que pode ser encon
href="https://github.com/apache/jena/tree/master/jena-core/src-examples/jena/examples/rdf/Tutorial07.java";>tutorial
7</a> que lista os nomes completos de todos os vcards do banco de dados.</p>
- <pre>// select all the resources with a VCARD.FN property
+<pre>// select all the resources with a VCARD.FN property
ResIterator iter = model.listSubjectsWithProperty(VCARD.FN);
if (iter.hasNext()) {
System.out.println("The database contains vcards for:");
@@ -724,18 +735,18 @@ if (iter.hasNext()) {
} else {
System.out.println("No vcards were found in the database");
}
- </pre>
+</pre>
<p>Isso deve produzir uma saÃda similar a:</p>
- <pre>The database contains vcards for:
+<pre>The database contains vcards for:
Sarah Jones
John Smith
Matt Jones
Becky Smith
- </pre>
+</pre>
<p>Seu próximo exercÃcio é modificar o código para usar
<code>SimpleSelector
@@ -764,13 +775,12 @@ StmtIterator iter = model.listStatements
John Smith
Becky Smith</pre>
-
<p></p>
<p>Você pode imaginar que:</p>
- <pre>// do all filtering in the selects method
+<pre>// do all filtering in the selects method
StmtIterator iter = model.listStatements(
new
SimpleSelector(null, null, (RDFNode) null) {
@@ -780,7 +790,8 @@ StmtIterator iter = model.listStatements
&& (object == null ||
s.getObject().equals(object))
}
}
- });</pre>
+ });
+</pre>
<p>é equivalente a:</p>
@@ -811,7 +822,7 @@ StmtIterator iter = model.listStatements
href="https://github.com/apache/jena/tree/master/jena-core/src-examples/jena/examples/rdf/Tutorial09.java";>tutorial
9</a>) e ver o que acontece.</p>
- <pre>// read the RDF/XML files
+<pre>// read the RDF/XML files
model1.read(new InputStreamReader(in1), "");
model2.read(new InputStreamReader(in2), "");
@@ -825,7 +836,7 @@ model.write(system.out, "RDF/XML-ABBREV"
<p>A saÃda produzida pelo PrettyWriter se assemelha a:</p>
- <pre><rdf:RDF
+<pre><rdf:RDF
xmlns:rdf="<a
href="http://www.w3.org/1999/02/22-rdf-syntax-ns#";>http://www.w3.org/1999/02/22-rdf-syntax-ns#</a>"
xmlns:vcard="http://www.w3.org/2001/vcard-rdf/3.0#">
<rdf:Description rdf:about="http://somewhere/JohnSmith/">
@@ -840,8 +851,8 @@ model.write(system.out, "RDF/XML-ABBREV"
</vcard:N>
<vcard:FN>John Smith</vcard:FN>
</rdf:Description>
-</rdf:RDF></pre>
- <pre> </pre>
+</rdf:RDF>
+</pre>
<p>Mesmo que você não seja familiarizado com os detalhes da sintaxe
RDF/XML, deve ser relativamente claro que os modelos foram unidos como esperado
A interseção e a diferença de modelos podem ser computados de maneira
semelhante, usando os métodos <code>.intersection(Model)</code> e
@@ -877,7 +888,7 @@ para mais detalhes.
<p align="left">Vamos modificar o tutorial 8 para criar essa bag:</p>
- <pre>// create a bag
+<pre>// create a bag
Bag smiths = model.createBag();
// select all the resources with a VCARD.FN property
@@ -891,12 +902,11 @@ StmtIterator iter = model.listStatements
// add the Smith's to the bag
while (iter.hasNext()) {
smiths.add(iter.nextStatement().getSubject());
-}</pre>
-
+}
+</pre>
<p>Se nós imprimirmos esse modelo, vamos obter algo do tipo:</p>
-
<pre><rdf:RDF
xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'
xmlns:vcard='http://www.w3.org/2001/vcard-rdf/3.0#'
@@ -915,7 +925,7 @@ while (iter.hasNext()) {
<p>A interface do container fornece um iterador para listar o conteúdo do
container:</p>
- <pre>// print out the members of the bag
+<pre>// print out the members of the bag
NodeIterator iter2 = smiths.iterator();
if (iter2.hasNext()) {
System.out.println("The bag contains:");
@@ -927,13 +937,14 @@ if (iter2.hasNext()) {
}
} else {
System.out.println("The bag is empty");
-}</pre>
+}
+</pre>
<p>que produz a seguinte saÃda:</p>
- <pre>The bag contains:
+<pre>The bag contains:
John Smith
Becky Smith</pre>
@@ -952,7 +963,7 @@ tutorial 10</a>, que coloca esses fragme
<p>Em Jena, esses atributos de uma literal podem ser setados quando a literal
é construÃda, e.g. no <a
href="https://github.com/apache/jena/tree/master/jena-core/src-examples/jena/examples/rdf/Tutorial11.java";>tutorial
11</a>:</p>
- <pre>// create the resource
+<pre>// create the resource
Resource r = model.createResource();
// add the property
@@ -967,7 +978,7 @@ model.write(system.out);</pre>
<p>produz</p>
- <pre><rdf:RDF
+<pre><rdf:RDF
xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'
xmlns:rdfs='http://www.w3.org/2000/01/rdf-schema#'
>
@@ -984,7 +995,7 @@ model.write(system.out);</pre>
<p>As interfaces de Jena também suportam literais tipadas. A maneira antiga
(mostrada abaixo) trata literais tipadas como atalhos para strings: valores
tipados são convertidos por Java em strings, e essas strings são armazenadas
no modelo. Por exemplo, tente (observando que para literais simples, nós
podemos omitir a chamada code>model.createLiteral</code>(...)):</p>
- <pre>// create the resource
+<pre>// create the resource
Resource r = model.createResource();
// add the property
@@ -992,7 +1003,8 @@ r.addProperty(RDFS.label, "11")
.addProperty(RDFS.label, 11);
// write out the Model
-model.write(system.out, "N-TRIPLE");</pre>
+model.write(system.out, "N-TRIPLE");
+</pre>
<p>A saÃda produzida é:</p>
@@ -1005,7 +1017,7 @@ model.write(system.out, "N-TRIPLE");</pr
<p>O RDFCore WG definiu mecanismos para suportar datatypes em RDF. Jena os
suporta usando mecanismos de <i>literais tipadas</i>; isso não é discutido
neste tutorial.</p>
-<h2 id="ch-gGlossary">Glossário</h2>
+<h2 id="ch-Glossary">Glossário</h2>
<dl>
