UNIVERSIDADE FEDERAL DE SANTA CATARINA Aliando

Propaganda
UNIVERSIDADE FEDERAL DE SANTA CATARINA
Aliando Performance e Produtividade
no Desenvolvimento de Jogos
Fábio Luís Stange
Florianópolis
2005/1UNIVERSIDADE FEDERAL DE SANTA CATARINA
DEPARTAMENTO DE INFORMÁTICA E ESTATÍSTICA
BACHARELADO EM CIÊNCIAS DA COMPUTAÇÃO
Aliando Performance e Produtividade
no Desenvolvimento de Jogos
Fábio Luís Stange
Trabalho de conclusão de curso apresentado como
parte dos requisitos para obtenção do grau de
Bachareu em Ciências da Computação
Florianópolis
2005/1Fábio Luís Stange
Aliando Performance e Produtividade
no Desenvolvimento de jogos
Trabalho de conclusão de curso apresentado como parte dos requisitos para obtenção do
grau de Bachareu em Ciências da Computação.
Orientador:
________________________________
Eng. Marcelo A. Camelo
[email protected]
Co-orientador:
________________________________
Prof. Mst. Renato Cislaghi
[email protected]
Banca Examinadora:
_______________________________
Bel. Guilherme Bertoni Machado
[email protected]
________________________________
Bel. Bruno da Silva Oliveira
[email protected]
“Make it as simple as possible. But no simpler.”
Albert Einstein
Sumário
Lista de Figuras .................................................................................................. 1
Lista de Reduções .............................................................................................. 3
Resumo .............................................................................................................. 5
Abstract .............................................................................................................. 7
1. Introducao ......................................................................................................
9
1.1. Os limites da tecnologia .................................................................... 10
1.2. A indústria de jogos ........................................................................... 11
1.3. Nem tudo está perdido ...................................................................... 13
1.4. Cavando um pouco mais fundo ......................................................... 14
1.5. Line Printator Tabajara ...................................................................... 15
2. Estudo de caso: Taikodom ............................................................................. 17
2.1. Taikodom .......................................................................................... 18
2.2. Arquitetura ........................................................................................ 19
2.3. O que dizem os números .................................................................
21
3. Integrando Linguagens .................................................................................... X
3.1. A integração no braço ....................................................................... X
3.2. As opções ......................................................................................... X
3.3. some_lib: Uma biblioteca didática .................................................... X
4. SWIG – Simplified Wrapper and Interface Generator .................................... X
4.1. Hello SWIG ....................................................................................... X
4.2. Integrando some_lib ......................................................................... X
4.3. Testando ..........................................................................................
X
5. Boost Python .................................................................................................. X
5.1. Hello Boost.Python ........................................................................... X
5.2. Integrando some_lib ......................................................................... X
5.3. Testando ..........................................................................................
X
6. Apocalypse ..................................................................................................... X
6.1. Comparando estratégias num projeto real........................................
X
6.2. SWIG ................................................................................................ X
6.3. Pyste ................................................................................................. X
7. Conclusão ......................................................................................................
X
7.1. SWIG x Pyste+Boost.Python ...........................................................
X
7.2. Apocalypse – PostMortem ...............................................................
X
7.3. Botando as cartas na mesa .............................................................
X
8. Referências Bibliográficas .............................................................................
X
9. Anexos ...........................................................................................................
X
9.1. Código fonte: some_lib ..................................................................... X
9.2. Interface SWIG para some_lib .........................................................
X
9.3. Código fonte: testes de some_lib em python ...................................
X
9.4. Código fonte: testes de some_lib em java .......................................
X
9.5. Resultados dos testes de some_lib em python ................................ X
9.6. Resultados dos testes de some_lib em java .................................... X
9.7. Interface Pyste + Boost.Python para some_lib ................................. X
9.8. Código fonte: testes de some_lib com Boost.Python ....................... X
9.9. Resultado dos testes de some_lib com Boost.Python ....................... X
9.10. Apocalypse – Source Code ............................................................ X
9.11. Apocalypse – Interface SWIG ......................................................... X
9.12. Apocalypse – Interface Pyste + Boost.Python ................................ X
9.13. The Zen of Python ........................................................................... X
10. Artigo ............................................................................................................. X
Resumo
“A designer knows that he has achieved
perfection not when there is nothing left to add,
but when there is nothing left to take away”
Antoine de St-ExpureyResumo
blah
Abstract
“However beautiful the strategy, you should occasionally
look at the results.”
Winston ChurchillAbstract
blah
Listas de Siglas e Abreviações
“I believe that a scientist looking at nonscientific problems is just as dumb as the next guy”
Richard FeynmanListas de Siglas e Abreviações
API: Application Programming Interface
CVS: Concurrent Version System
GUI: Graphic User Interface
IGDA: International Game Developers Association
IDE: Integrated Development Environment
MMOG: Massive Multiplayer Online Game
SWIG: Simplified Wrapper and Interface Generator
UML: Unified Modeling Language
WYSIWYG: What You See Is What You Get
Listas de Figuras
“There are two ways of constructing a software design:
one way is to make it so simple that there are obviously no
deficiencies, and the other way is to make it so
complicated that there are no obvious deficiencies. The
first method is far more difficult”
C.A.R. HoareLista de Figuras
Figura 2.1: Taikodom – Histórico de código .................................................................. X
Figura 2.2: Taikodom – Arquitetura de código .............................................................. X
Figura 4.1: Sistema SWIG completo ............................................................................. X
Figura 5.1: Sistema Pyste + Boost.Python completo ..................................................... X
1. Introdução
“The conceptual floor is littered with the
virtual carcasses of people who let
their desire for high machine efficiency
override other considerations, things
like programmer and user productivity.”
Karl Lehenbauer
1.1. Os limites da tecnologia
A tecnologia disponível para a construção de softwares vem avançando a passos
largos nas ultimas décadas. Linguagens de programação de alto nível, IDEs, ferramentas
auxiliares de todo tipo, UML...
Olhando especificamente para as linguagens de programação, existem diversas
opções, com os mais diferentes focos e paradigmas imagináveis. Variando da hoje
comum Orientação a Objetos e da Programação Estruturada à Programação Lógica e
Programação Funcional, passando por outras formas de pensar diferentes, algumas
surpreendentes, outras de valor prático questionável. Cada paradigma destes por sua vez
pode dar luz a uma varidade de linguagens de programação.
No entanto, é comum que cada uma dessas diferentes linguagens de programação
tenha severos pontos fracos. Algumas pessoas que defendem determinadas linguagens
com afinco religioso parecem pensar diferente. A vida seria bem mais fácil se elas
estivessem certas...
Uma dessas desvantagens é uma absurda valorização da performance do
software, contra a produtividade do seu programador, pela vasta maioria das linguagens
comerciais de hoje, apesar de ser fato bem conhecido que uma quantidade mínima de
código é responsável por uma grande quantidade do tempo total de execução de um
programa. (TODO: referencia sobre isso)
Para aqueles que aceitam a afirmação de que todas as linguagens tem severos
pontos fracos como verdadeira, este trabalho visa procurar e sugerir soluções práticas
que nos permitam focalizar nas maiores vantagens de diferentes linguagens, ao mesmo
tempo em que nos permitam fugir das suas desvantagens.
1.2. A indústria de jogos
Em Novembro de 2004, apenas o primeiro dia de vendas do jogo Halo 2
movimentou mais de 125 milhoes de dólares, o maior dia de abertura da toda indústria de
entretenimento (incluindo a do cinema). A mídia vem dizendo que a indústria de jogos
movimenta mais dólares do que a indústria do cinema. Independentemente de essa
informação ser verdadeira ou não, é fato que a indústria de jogos movimenta bilhôes. Os
custos milionários para se desenvolver um jogo de ponta já quase se equiparam a
produções de Hollywood.
A complexidade e escalas enormes desses sistemas, os diversos desafios
tecnológicos envolvidos e o fascínio que a indústria de jogos parece ter sobre
desenvolvedores fazem com que a indústria de jogos concentre bons profissionais da
indústria de software, talvez os melhores.
Se a indústria de jogos movimenta bilhôes de dólares e dispõe dos melhores
profissionais, seria razoável concluirmos que consequentemente a construção do software
de um jogo, por dispor de mão de obra de qualidade e dinheiro, é um processo
relativamente indolor e sem solavancos.
No entanto, nessa indústria, com uma frequencia muito maior do que esperada,
novos títulos são lançados com vários anos de atraso, e muitas vezes com qualidade
questionável. E pior que isso: a indústria de jogos é bem conhecida pelas condições
extremas de trabalho, com funcionários trabalhando semanas de 60-80+ horas sendo
mais uma regra do que uma exceção.
Num episódio que ficou conhecido como “EA Spouse”, e que está chacoalhando as
fundações do mercado de trabalho da indústria de jogos, a esposa de um funcionário da
Eletronic Arts – maior distrubuidora de jogos do mundo – conta o sofrimento por que
passa a sua família e descreve as condições quase desumanas em que seu marido
trabalha.
(http://www.livejournal.com/users/ea_spouse/).
Pouco tempo depois, a IDGA publicou em seu site uma carta aberta com suas
preocupações com a qualidade de vida dos trabalhadores da indústria de jogos
(http://www.igda.org/qol/open_letter.php).
Demonstrações
semelhantes
de
descontentamento aconteceram após este episódio e continuam a acontecer em diversas
partes do mundo.
A indústria de jogos sofre muito com a falta de veteranos entre seus funcionários,
pois poucas pessoas conseguem trabalhar mais de 5 anos nessas condições. Talvez por
isso a indústria acredita que precise cobrar tanto de cada funcionário, entrando num triste
ciclo vicioso. Citando Francois Dominic Laramee: “Making fun and games isn't all fun and
games. It's serious work, harder than most”.
Independente dos motivos que levaram a indústria a chegar neste ponto, os fatos
acima deixam claro que a indústria de jogos precisa desesperadamente de um alto nível
de produtividade para seus desenvolvedores. Que ela também precisa de altos níveis de
performance é inquestionável e bem conhecido. Talves por isso mesmo ainda não tenha
encontrado soluções satisfatorias para o problema da produtividade: a busca incançável
por performance disfarça o caminho para a produtividade.
Os conceitos apresentados neste trabalho podem ser aplicados em quaisquer tipos
de software. No entanto, pelas razões mencionadas acima, e pela experiências do autor
na área, este trabalho se focaliza mais na aplicação desses conceitos no desenvolvimento
de jogos.
1.3. Nem tudo está perdido
Como resolver o dilema de aliar performance e produtividade, duas características
aparentemente antagônicas? O primeiro passo é entender que existe sim um certo
antagonismo entre esses dois conceitos, mas apenas se estivermos analizando seus
extremos, e dentro de uma mesma linguagem de programação.
Ainda está para existir uma linguagem de programação que consiga aliar
satisfatoriamente estes dois conceitos. Apesar de exitir pessoas que pensem em
contrário, volto a repetir que o mundo seria mais colorido se elas realmente estivessem
certas. Espero que um dia elas estejam.
Mas enquanto este dia não chega, há algo que podemos fazer, e neste caso é
olhar para mais de uma linguagem de programação. Olhar com olhos críticos, deixar de
lado os preconceitos e preferências, e encontrar as vantagens e desvantagens de cada
uma para os requisitos que se tem em mãos.
Para o caso da performance, a escolha não é difícil e geralmente se baseia em
C++. Para a produtividade, a escolha é bem mais difícil, e existem várias linguagens que
levam a produtividade do programador experiente a níveis bem superiores àqueles
obtidos por programadores experientes em C++ resolvendo os mesmos problemas.
Não estou me referindo á utilização de linguagens de script. Existem diversos
artigos cobrindo a utilização de scripts para auxiliar o desenvolvimento de jogos, e
praticamente todas as companhias de jogos os utilizam hoje. Estou me referindo dar um
passo a mais, ir mais além, e utilizar uma linguagem poderosa, que não seja
necessariamente C++, para desenvolver toda a parte do jogo que não seja de
performance crítica, e não apenas scripts.
1.4. Cavando um pouco mais fundo
Para aqueles que me perguntam sobre o desenvolvimento de jogos, parece existir
um conceito de que a grande maioria do desenvolvimento de um jogo gira em torno de
renderização e física. Este conceito não está muito longe de estar correto se o que está
sendo analizado é tempo de execução. Mas a regra dos 10% / 90% para quantidade de
código / tempo de execução.também é válida no desenvolvimento de jogos, o que
significa que cerca de 90% de todo o código de um jogo roda apenas cerca de 10% do
tempo total de execução deste, e quando roda, geralmente não necessita de alta
performance.
Idealmente, a física e a renderização não deveriam ocupar muito tempo de
desenvolvimento, já que são tecnologias conhecidas, e tempo gasto nelas é tempo gasto
melhorando a tecnologia atual, ou reinventando a roda. Na verdade adaptando a roda às
evoluções tecnológicas, ou à necessidades específicas.
Os outros 90% do código é aquilo que dá ao jogo a sua indentidade, é aquilo que
entretêm as pessoas, e é aquilo que não precisa rodar absurdamente rápido. Transações
financeiras, iterações entre os usuários, sistema de danos, sistema de comunicação, de
transporte, enfim, um sem fim de requisitos que vão muito além da simulação física e da
renderização. Requisitos estes que geralmente podem ser implementados outra
linguagem, mas que geralmente são implementados em C++ por estarem colados nas
partes que precisam de performance.
É prática comum no desenvolvimento de jogos utilizar linguagens mais produtivas
para a realização de tarefas mais independentes, como uma subrotina de inteligencia
artificial, que toma como entrada todos os dados de que precisa, e retorna todos os dados
a serem utilizados. (TODO: Referencias sobre scripts)
O foco aqui é bem diferente. Podemos desenvolver praticamente todo o jogo em
uma linguagem de alto nível, e não apenas scripts. Cerca de 90% do nosso código roda
10% do tempo, esperando para ser implementado em outra linguagem, melhorar nossa
produtividade e nos dar mais tempo. E tempo é dinheiro.1.5. Line Printator Tabajara
Para demonstrar o quanto a programação em uma linguagem de alto-nível pode
fazer diferença, vou ilustrar um problema comum na programação, abrir um arquivo,
percorrer as suas linhas fazendo alguma coisa com elas. Neste caso, vou apenas gerar
um aplicativo que vai imprimir todas as linhas de um arquivo passado por linha de
comando, mostrando o código em Python e o código em C que executa esta tarefa.
TODO: Ver o código em C++ que faz isso com streams
Line Printator Tabajara, em Python:
# Line Printator - linguagem de alto nivel
import sys
arquivo = file(sys.argv[0])
for linha in arquivo.readlines():
print linha
arquivo.close()
Line Printator Tabajara, em C:
// Line Printator - linguagem nao tao alto nivel assim...
#include <stdio.h>
int main(int argc, char *argv[])
{
char linha[1024];
FILE *arquivo = fopen(argv[1], "r");
while(fgets(linha, 1024, arquivo))
{
printf("%s\n", linha);
}
fclose(arquivo);
return 0;
}
Não se faz necessário tecer comentários sobre as vantagens que o primeiro código
apresenta sob a lente da produtividade. Como muitas pessoas tem uma pulga na orelha
com relação à performance de linguagens interpretadas, foi feita uma rápida análise:
ambos os programas foram rodados lendo um arquivo fonte C++ com 800 linhas e 32Kb,
com a mesma janela de console. O programa em C++ rodou em 5,5 segundos. O
programa em Python rodou em 5,5 segundos.
Nesse momento o leitor me xinga e pensa: “Mas esse exemplo é injusto, o gargalo
está no IO e na renderização do console!”. Exatamente! Se sabemos de ante-mão onde
estão nossos gargalos e sabemos que o processamento não é um deles, não existe
nenhuma necessidade de implementarmos em C++. Se por outro lado o processamento é
um dos gargalos (com frequencia é), mas não temos extrema necessidade de que esse
processamento termine em um período extremamente curto de tempo, também não
precisamos implementar em C++ (o usuário não acharia ruim se uma transação financeira
demorasse meio segundo ao invéz de 400 milisegundos, por exemplo)
Se no exemplo dado, o programa em Python tivesse rodado em 6 segundos, ele
ainda estaria fazendo seu serviço satisfatoriamente. Nâo tão satisfatoriamente como
aquele em C++, é verdade, mas o tempo (e consequentemente o dinheiro) que
economizamos para fazê-lo em Python pode significar a diferença entre atingir ou não um
prazo determinado, que pode por muitas vezes determinar o sucesso ou o fracasso de um
projeto. O perfeccionismo é um dos maiores impecilhos para que um desenvolvedor
melhore a sua produtividade. Citando Steve Pavlina: “Realize that an imperfect job
completed today is always superior to the perfect job delayed indefinitely”
Se o leitor sobreviveu até aqui, são boas as chances de que os preconceitos não
estão muito enraizados em sua mente. Aprender a utilizar o melhor que cada linguagem
nos tem a oferecer ao invéz de defender apenas uma com unhas e dentes só nos traz
vantagens. Abra a sua mente e siga em frente.
2. Estudo de caso: Taikodom
“Making fun and games isn't all fun and games.
It's serious work, harder than most.”
Francois Dominic Laramee
2. Estudo de caso: Taikodom
Em Janeiro de 2004, fui contratado pela Hoplon Infotainment, empresa que
desenvolve jogos online. Durante todo o ano de 2004 trabalhei no principal projeto da
empresa, um MMOG espacial, chamado Taikodom. Os conceitos e o conhecimento
adquiridos durante este período acabaram por mudar o foco deste trabalho para onde ele
se encontra hoje. (TODO: como falar isso em terceira pessoa?)
Taikodom é um projeto ambicioso, e seu sucesso depende, dentre muitos outros
fatores, de que a equipe de desenvolvimento implemente muitas funcionalidades em
muito pouco tempo. Aliado à falta de experiênia da maioria da equipe no desenvolvimento
comercial de jogos, essa era uma grande barreira a ser transposta.
Um ano se passou, e hoje mesmo antes de seu lançamento o projeto já tem
milhares de fãs e grande interesse da mídia especializada, que aguardam o seu
lançamento com espectativa. Eu acredito que para termos chegado até aqui, a utilização
de diferentes linguagens para diferentes partes da implementação foi de fundamental
importância.
Vale salientar que o futuro sucesso ou fracasso comercial deste projeto não reforça
ou diminui o valor dos conceitos apresentados neste trabalho, já que muitas outras
variáveis estão presentes na equação do sucesso comercial. Para maiores informações
sobre o projeto Taikodom: www.taikodom.com.br
2.1. Arquitetura
A figura 2.1 diagrama os componentes da arquitetura de código do Taikodom. Este
diagrama não tem nenhuma relação com a arquitetura do software como costumamos nos
referir a ela, ele apenas mostra a inter-relação entre as diferentes linguagens utilizadas no
projeto.
Figura 2.1: Taikodom – arquitetura de código
Podemos ver que a maioria do cliente é implementada em Python e a maioria do
servidor é implementada em Java. A escolha de Python no cliente foi baseada na maior
produtividade que o desenvolvimento nesta linguagem proporciona, na opinião da nossa
equipe.
Já a escolha de Java no servidor adveio da maior disponibilidade de APIs prontas
para funcionalidades que precisáva-mos. No nosso caso específico, JGROUPS para a
lógica de grupos de rede, e HYBERNATE para abstrações de persistência com banco de
dados. O ganho em produtividade de uma implementação em Python não justificaria o
tempo gasto com a implementação destas funcionalidades num cenário de médio prazo.
Foi cogitada a utilização das 3 linguagens no servidor, mas a manutenção das interfaces
numa configuração complexa como esta nos pareceu arriscada demais.
Já a parte comum a ambos, como a hierarquia básica dos objetos de jogo,
simulação física, protocolo de rede, classes base de configuração e logging, etc., são
implementadas em C++, para evitar o custo, principalmente de manutenção, de se
implementar uma funcionalidade em duas linguagens diferentes.
Existem também funcionalidades específicas somente para o cliente ou para o
servidor que são implementadas em C++ pela necessidade de que estas rodem o mais
rápido possível. A mais notória destas funcionalidades é a parte de renderização 3D, mas
outras funcionalidades que são identificadas de ante-mão como sendo de alta
performance também são implementadas em C++. A simulação física também entra
nessa categoria apesar de já ter sido identificada como comum anteriormente.
Existe ainda um grupo de funcionalidades que são inicialmente implementadas em
Python ou Java, mas que por profilling (TODO - traducao) percebemos como sendo
gargalos, e são traduzidas para C++. Muitos advogam esta característica como sendo
uma desvantagem que torna o uso de outras linguagens impraticável. Mas na verdade a
porcentagem de funcionalidades que necessitam de reimplementação é muito pequena, e
portanto o tempo perdido traduzindo uma funcionalidade para C++ é ínfimo perto do
tempo ganho em produtividade na implementação de todas as outras funcionalidades.
Por fim, o SWIG faz a 'cola' para que os códigos em Python e em Java consigam
conversar com o código implementado em C++. Veremos como ele funciona mais tarde.
2.2. O que dizem os números
A figura 2.2 apresenta o número de linhas de código das diferentes linguagens
utilizadas no projeto Taikodom.
As amostras foram tiradas dos dias 1, 8, 15 e 22 de cada mês, do tronco (HEAD)
do repositório, desde que começamos a utilizar o CVS até o fim de 2004. Não foram
computadas linhas de comentários, linhas em branco, e linhas com apenas um caracter
além dos brancos (geralmente abertura ou fechamento de bloco)
Figura 2.2: Taikodom – Histórico de código
TODO: Ver porcentagem do Java que eh gerado pelo hybernate
TODO: Ver total de código depois de rodado os scripts de geração
Podemos ver pelo gráfico que nos primeiros meses de desenvolvimento a
curva de crescimento do código C++ é mais acentuada que a curva de crescimento das
outras linguagens, mas a partir do terceiro mês, a taxa de crescimento das outras
linguagens ultrapassa a taxa de crescimento do C++, e nos últimos meses o total de
linhas de código de ambas as linguagens ultrapassa a contagem do C++.
Isso se deve ao fato de que no início do projeto, é necessária a implementação de
toda a infra-estrutura a ser utilizada pelos outros componentes a serem implementados
posteriormente. A física e a renderização também tiveram a maioria de sua
implementação realizada nestes primeiros meses. Apenas depois de que este alicerce em
C++ estava pronto, a implementação do resto do sistema em outras linguagens teve base
para se expandir.
A tendência é que a curva de crescimento de C++ se transforme em uma reta com
derivada zero conforme avançamos mais no tempo, e esse decréscimo seja transformado
em crescimento nas outras linguagens. Jogos online, como é o caso do Taikodom, podem
se beneficiar bastante deste cenário, já que a sua implementação continua mesmo após o
seu lançamento, geralmente incrementando o produto por toda a sua vida útil enquanto
este estiver online.
Jogos que não necessitem de uma arquitetura cliente-servidor, ou onde o cliente e
servidor serão implementados na mesma linguagem, poderiam se beneficiar mais ainda
de uma implementação em uma linguagem de alto nível aliada ao C++, pois não
necessitariam ter o código comum ao cliente e ao servidor implementado em C++.
3. Integrando Linguagens
“If knowledge can create problems, it is not
through ignorance that we can solve them.”
Isaac Asimov3.1. A integração no braço
Praticamente todas as linguagens de programação oferecem algum tipo de API que
permite ao programador integrar programas escritos nestas linguagens com código nativo
escrito em outra linguagem – como C.
No entanto, a maioria destas APIs são complexas, e implementar métodos
envoltórios, que permitam que métodos já prontos em código nativo sejam chamados a
partir da linguagem alvo, é geralmente um processo difícil e penoso, completamente
imcompatível com a premissa básica de ganho de produtividade que queremos alcançar.
Para ilustrar, a segue um trecho de uma função envotória que utiliza JNI (gerada
automaticamente pelo SWIG, pode ser simplificada), que nos permite chamar a função
looseFunction() em java:
JNIEXPORT jint JNICALL
Java_some_1package_some_1lib_1javaJNI_looseFunction(JNIEnv *jenv, jclass jcls) {
jint jresult = 0 ;
int result;
(void)jenv;
(void)jcls;
result = (int)looseFunction();
jresult = (jint)result;
return jresult;
}
E isto não é tudo, existem ainda algumas declarações que precisam ser feitas em
java para que afim possamos chamar a função nativa looseFunction em java.
Mas não vamos nos aprofundar em JNI ou em nenhuma outra API de acesso
nativo, já se produtividade é a meta, a última coisa que queremos ver é código feio e
confuso como esse.
3.2. As opções
A ferramenta mais amplamente utilizada para a integração entre linguagens de alto
nível e código nativo é o SWIG (Simplified Wrapper and Interface Generator). SWIG pode
conectar código escrito em C ou C++ com 13 linguagens diferentes: Python, Java, Perl,
PHP, Tcl, C#, Chicken, Ruby, Allegro CL, Guile, Modula-3, Mzscheme e OCAML.
SWIG é atualmente a solução mais genérica e mais abrangente para a
programação hídrida. Isso não faz dela necessariamente a melhor solução. Soluções
mais específicas, que se destinam a integrar apenas uma linguagem de alto-nível a
código nativo, podem se beneficiar desta especialização para serem mais simples, mais
eficientes, e/ou mais completas, no ambiente específico a que se destinam.
Uma destas soluções específicas é a Boost.Python, parte da biblioteca Boost, e
que se destina a integrar especificamente Python com C/C++. A análize de uma solução
específica para python se deve ao fato de que a linguagem python sempre perseguiu a
produtividade do desenvolvedor como prioridade, mesmo quando isso possa impactar
negativamente a performance do software ou a compatibilidade com versões antigas da
linguagem.
Vale lembrar que nem todas as funcionalidades providas pelo C++ podem estar
presentes na linguagem alvo, e nesses caso a interface deve sempre que possível prover
mecanismos para que essa funcionalidade possa ser utilizada na linguagem alvo, mesmo
que com restrições ou por caminhos não usuais.
Existem ainda outras soluções para programação hídriba, inclusive para outras
linguagens que não aquelas suportadas pelo SWIG, mas elas não serão analizadas neste
estudo.
3.1. some_lib: uma biblioteca didática
Para testar as duas alternativas escolhidas, foi criada uma bibliteca hipotética –
some_lib. Uma espécie de 'Hello World' bombado, esta biblioteca contém apenas código
extremamente simples, mas se utiliza de uma extensa gama de funcionalidades providas
por C e C++. Desta forma, podemos testar praticamente tudo que pode-se querer
disponibilizar para uso em uma linguagem de alto nível, enquanto mantendo o código o
mais simples possível.
A biblioteca também foi estruturada de maneira a se assemelhar de um caso real
de utilização de uma biblioteca já pronta que queira se exportar – ao invéz de conter todo
o código em um único arquivo, some_lib tem uma estrutura semelhante à de uma
biblioteca distribuida online:
+ some_lib
+ include
# diretorio raiz
# diretorio com os arquivos de interface
- some_lib.h
+ src
# diretorio com os arquivos fonte
- some_lib.cpp
+ lib
# diretorio com arquivos .lib binários
- some_lib.lib
+ vc7
# diretorio[s] com arquivos de projeto para cada plataforma
- some_lib.vcproj
Funcionalidades presentes em some_lib que serão testadas em outras linguagens:
Acesso a variáveis e funções globais, utilização de constantes (#defines e enums),
estruturas e classes, métodos públicos e privados, de instância e de classe, herança,
classes abstratas, polimorfismo, referencias por valor, ponteiro ou referência, argumentos
padrão e argumentos múltiplos, utilização de callbacks, sobrecarga de operadores,
exceções, templates, herança múltipla, e utilização de classes da Standard Library.
Todas as funcionalidades estão presentes de forma simples em some_lib. O código
completo da biblioteca está no Anexo 1. (TODO: e pode ser baixado em
www.inf.ufsc.br/~petrucio/tcc_src.zip)
4. SWIG – Simplified Wrapper
and Interface Generator
“Very often, people confuse simple with simplistic.
The nuance is lost on most."
Clement Mok, Chief Creative Officer, Sapient.4.1. Hello SWIG
“SWIG é uma ferramenta de desenvolvimento de software para a construção de
interfaces entre linguagens de scripting e programas C e C++” [TODO]. A meta do SWIG
é fazer com que a integração de linguagens de alto-nível com C/C++ seja o mais
transparente e indolor possível, permitindo que o programador não perca tempo com a
tediosa e complexa tarefa de fazer as duas linguagens conversarem entre si. SWIG é uma
ferramenta gratuita, inclusive para uso comercial, e pode ser baixada de www.swig.org.
A figura 4.1 ilustra o funcionamento completo de um sistema híbrido em C++ com
uma linguagem de script, utilizando SWIG para criação das interfaces. Todas as partes
apresentadas nesta figura estão presentes em um sistema híbrido utilizando SWIG,
mesmo um simples 'Hello World'.
Pode parecer intimidante a princípio, mas se torna simples com a utlização e a
prática. Não se pode ganhar todas, e no caso da construção de um sistema híbrido, existe
sempre um custo inicial para a integração de todas as partes envolvidas, e um custo de
criação e manutenção das interfaces.
As fontes da biblioteca e os cabeçalhos da biblioteca são previamente conhecidos,
e compõe o código C/C++ que queremos exportar para uma linguagem de alto nível. A
sua interação com o compilador e a geração dos binários da biblioteca não são novidade.
Para o nosso exemplo em some_lib, os fontes estão no arquivo some_lib.cpp, os
cabeçalhos em some_lib.h, e os binários no arquivo some_lib.lib.
Se estivermos exportando uma biblioteca pronta para a qual não temos os arquivos
fontes, em teoria apenas os arquivo de cabeçalho e os binários pré-compilados da
biblioteca já deveriam nos ser suficientes. Em alguns casos, podem ser necessárias
modificações no código fonte C/C++, ou a criação de código envoltório que adapte o
código da biblioteca às limitações do SWIG ou da linguagem alvo.
Figura 4.1: Sistema SWIG completo
As interfaces do SWIG (ver fig. 4.1) são o coração
da integração em um sistema híbrido utilizando SWIG. O arquivo de interface (geralmente
com extensão .i) é dividido em duas seções: a primeira com as declarações de tudo o que
o SWIG precisa conhecer sobre o código C++, e a segunda com declarações de tudo
aquilo que deseja-se exportar.
Vejamos como seria um arquivo de interface SWIG simples para um exemplo 'Hello
World':
%module hello_module
%{
// Declarações daquilo que o SWIG precisa conhecer
void printHello();
%}
// Declarações daquilo que o SWIG deve exportar
void printHello();
Em casos bem comportados, como no exemplo acima, boa parte, senão todas as
declarações feitas na primeira seção serão as mesmas declarações que queremos
exportar na segunda seção. As diferentes seções são necessárias no entanto em casos
mais complexos, como veremos mais adiante. Para arquivos de cabeçalho bem
comportados, podemos simplesmente incluir o arquivo de cabeçalho em ambas as seções
e exportar tudo que está declarado dentro dele:
%module hello_module
%{
#include “hello_lib.h”
%}
%include “hello_lib.h”
Se rodarmos o SWIG passando-lhe este arquivo de interface, ele irá nos gerar os
arquivos C/C++ necessários para gerar uma biblioteca que contenha todos os métodos
envoltórios para chamarmos a função printHello na linguagem target. Exemplo de uma
chamada de SWIG para a geração de envoltórios python:
$ swig -python -c++ -o output_file.cpp hello_module.i
Esse comando irá gerar o arquivo fonte envoltório 'output_file.cpp' e o arquivo de
acesso 'hello_module.py'. O arquivo fonte envoltório deve ser compilado e linkado junto
com os binários da biblioteca, para gerar uma biblioteca dinâmica chamada
'_hello_module.dll'. O arquivo de acesso é implementado na linguagem alvo, e existe para
realizar algumas adaptações sobre a biblioteca exportada para prover uma API que seja
mais natural à linguagem alvo.
De posse do arquivo de acesso e da biblioteca dinâmica adaptada, pode-se
chamar as funções implementadas em C++ de dentro da linguagem alvo:
$ python
Python 2.4c1 (#59, Nov 18 2004, 18:54:56) [MSC v.1310 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import hello_module
# Isso importa o arquivo de acesso hello_module.py, que
por sua vez carrega a biblioteca dinâmica _hello_module.dll
>>> dir(hello_module)
# Imprime todos os membros de hello_module
['printHello', ...]
>>> hello_module.printHello()
Hello World!
4.2. Integrando some_lib
Como o SWIG nos permite a integração com várias linguagens, seria interessante
que um teste dele fizesse integração com mais de uma linguagem. Foram escolhidas as
linguagens python e java para este estudo.
Como vamos realizar a integração com duas linguagens, os arquivos de interface
foram separados em três, com um arquivo de interface comum contendo as declarações
pertinentes a ambas as linguagens, e com um arquivo específico para cada linguagem,
para tratar das peculiaridades de cada uma.
Segue a árvore de diretórios e arquivos relevantes do nosso diretório de testes do
SWIG. Arquivos envoltos por parênteses são gerados automaticamente.
+ SWIG
# diretorio raiz
- some_lib_swig_interface.i
# Arquivo de interface comum
- some_lib_swig_python_interface.i
# Arquivo de interface python
- some_lib_swig_java_interface.i
# Arquivo de interface java
- swig_run.sh
# script que roda o SWIG
+ some_lib_python_wrappers
# fontes e projeto dos envoltórios python
- some_lib_python_wrappers.vcproj # projeto do visual studio
- (some_lib_python_wrappers.cpp)
# Código gerado pelo SWIG
- (some_lib_python_wrappers.h)
# Código gerado pelo SWIG
+ some_lib_java_wrappers
# fontes e projeto dos envoltórios java
- some_lib_java_wrappers.vcproj
# projeto do visual studio
- (some_lib_java_wrappers.cpp)
# Código gerado pelo SWIG
+ python_tests
- (some_lib_python.py)
# Código de acesso gerado pelo SWIG
- (_some_lib_python.dll)
# Resultado da compilacao dos envoltorios
- some_lib_python_tests.py
# Testes em python
+ java_tests
+ some_package
# Diretorio com o pacote de acesso
- (...)
# Classes de acesso geradas pelo SWIG
- (some_lib_java.dll)
# Resultado da compilacao dos envoltorios
- some_lib_JavaTests.java
# Testes em java
Todos os arquivos de interface e o script para rodar o SWIG estão no Anexo 9.2.
O arquivo de interface comum - some_lib_swig_interface.i - inclue o arquivo
some_lib.h na primeira seção para que o SWIG conheça toda a interface da biblioteca, e
inclue some_lib.h na segunda seção, para que o SWIG exporte tudo aquilo que for
possível de ser exportado sem maior interação. Em situações normais, isso pode
geralmente ser suficiente. No nosso caso, o arquivo de interface pode parecer grande e
complexo,
mas
como
o
arquivo
some_lib.h
contém
intencionalmente
muitas
funcionalidades diferentes a serem exportadas, o arquivo de interface acaba sendo
grande.
Comparando os arquivos de interface utilizados para python e para java, percebese que o arquivo específico para java é bem maior do que o arquivo para python. Isso
porque java não possui conceitos como sobrecarga de operadores e herança múltipla, e
portanto precisamos realizar algumas manobras para utilizar esses conceitos em java.
Quando mais completa for uma linguagem - na verdade quanto mais conceitos
encontrados em C++ também existirem na linguagem alvo - maior será a facilidade de se
implementar um sistema híbrido usando essa linguagem.
Dentre as funcionalidades presentes em some_lib, algumas precisaram de
alterações específicas nos arquivos de interface e serão detalhadas a seguir. Os itens a
seguir são tópicos avançados, e o leitor que não tenha bons conhecimentos em C++ pode
avançar para o item 4.3. Vale lembrar que a complexidade dos tópicos apresentados aqui
não devem afastar o leitor de tentar utilizar o SWIG, porque a maioria deles não
precisarão ser utilizados em uma situação de uso real, mas eles são tratados aqui para
verificarmos a completude da ferramenta.
4.2.1. Callbacks e polimorfismo inter-linguagens:
Callbacks costumam ser pouco utilizados em programas comuns, no entanto são
importantes no desenvolvimento de jogos, então vamos nos aprofundar um pouco na sua
utilização inter-linguagens.
Não é possível implementar uma função na linguagem alvo e utilizá-la como uma
função de callback em C++. Para passar funções de callbacks para código em C++,
podemos implementar as funções em C++ , ou usar uma solução de callback polimórfico.
Na primeira solução, implementa-se um função de callback em C++ que seja
linkada junto com a biblioteca. No nosso exemplo, a função foi implementada dentro do
próprio arquivo de interface. Então temos uma função em C++ que recebe como
parâmetro uma função de callback:
void
setCallback(float (*callback)(float));
E uma função, também em C, que implementa uma função de callback:
float increment_callback(float value);
Declarando no arquivo de interface some_lib_swig_interface.i:
%constant float increment_callback(float);
Fazemos com que a nossa função seja tratada como um ponteiro para função na
linguagem alvo.
Finalmente, podemos ligar as pontas na linguagem alvo:
setCallback(some_lib_python.increment_callback);
Isso no entanto pode não ser suficiente, porque talvez seja necessário que a
função que callback necessite acessar dados disponíveis apenas na linguagem alvo.
Poderíamos implementar funções para alimentar esses dados para o C++, mas se
precisarmos implementar muitos callbacks, isso não vai ser nada produtivo. Neste caso, a
melhor solução pode ser utilizar um esquema de callback polimórfico.
Um callback polimórfico consiste em definir uma classe de callback com um
método virtual que será chamado como função de callback. Diferentes callbacks seriam
sub-classes desta, com diferentes implementações do método virtual. No entanto, o
método que requisita o callback irá agora requisitar uma instância dessa classe, e não
mais um ponteiro para função, o que nos obriga a modificar o código da biblioteca, e
portanto nos impede de utilizar esse tipo de solução se não pudermos modificar o código
da biblioteca.
Exemplo:
Classe de callback virtual em C++:
class Callable {
public:
virtual float call(float parm) { return 0; }
};
Subclasse implementada na linguagem alvo:
class PythonCallable(some_lib_python.Callable):
def __init__(self):
some_lib_python.Callable.__init__(self)
def call(self, parm):
return parm + 0.2
Passando instância de Callable na linguagem alvo:
python_callback = PythonCallable()
setPolyCallback(python_callback)
Para que essa solução funcione, precisamos informar o SWIG para habilitar
polimorphismo inter-linguagens, habilitando os 'directors' nos arquivo de interface:
%module(directors="1") some_lib_python
%{
%}%feature("director");
4.2.2. Arrays e ponteiros para tipos básicos
O SWIG tem alguns arquivos de interface pré definidos para exportar algumas
funcionalidades comuns. O arquivo 'carrays.i' contém mapeaentos de tipos para parmitir a
utilização de arrays C como se fossem arrays nativos na linguagem alvo.
No nosso caso, definimos uma classe envoltória para um array de inteiros chamada
INT_ARRAY com o seguinte trecho no arquivo de interface:
%include "carrays.i"
%array_class(int, INT_ARRAY);
Podemos então utilizar um array de C++ como se fosse um array nativo da
linguagem alvo criando uma instância dessa classe com o método de classe
'from_pointer':
array = some_lib_python.INT_ARRAY_frompointer(some_lib_python.cvar.int_array)
Utilizando o array como um array qualquer da linguagem alvo:
from item in array: print item
Já o arquivo 'typemaps.i' nos permite passar tipos básicos da linguagem alvo como
sendo ponteiros ou referências para os mesmos tipos básicos em C++. Vale lembrar que
para a maioria das linguagens de alto-nível, não existe nenhuma diferença entre
parâmetros por valor, por ponteiro, ou por referência, como existe em C++.
Com as seguintes linhas no arquivo de interface comum, definimos que parâmetros
recebendo ponteiros ou referências para inteiros poderão receber inteiros nativos à
linguagem alvo como parâmetros, e serem considerados como parâmetro de saída (que
terão seus valores modificados pela função):
%include "typemaps.i"
%apply int *INOUT { int *a };
%apply int &INOUT { int &a };
Como algumas linguagens alvo não possuem o conceito de parâmetros de saída –
como python – a chamada de uma função que receba um parâmetro desse tipo terá o
valor que teria modificado o parâmetro em questão adicionado ao retorno da função.
Como exemplo, uma função que retorne um inteiro, se tiver como parâmetro um
ponteiro para inteiro, retornaria em uma linguagem alvo sem suporte a parâmetros de
saída uma tupla (no caso de python) ou lista, com o valor do parâmetro adicionado ao
resultado:
Assinaturas em C++:
int resetInt_Value
(int
value);
// Zera valor e retorna 8
int resetInt_Pointer(int *value);
// Zera valor e retorna 8
Chamadas em Python:
>>> some_lib_python.resetInt_Value(5);
8
>>> some_lib_python.resetInt_Pointer(5);
(8,0)
4.2.3. Argumentos variáveis
A maioria das linguagens de alto-nível não tem o conceito de funções com número
variável de argumentos. Mesmo em C/C++, elas são muito pouco utilizadas. Se
quisermos chamar funções com argumentos variáveis na linguagem alvo, precisamos
implementar 'instâncias' dessas funções com argumentos bem conhecidos.
Exemplo:
Temos em C++ uma função 'average' com um número variável de argumentos que
queremos chamar na linguagem alvo:
double AdvancedClass::average(double value1, ...) ;
No arquivo de interface, podemos criar funções envoltórias que recebem um número fixo
de argumentos conhecidos e repassem para esta função:
%extend AdvancedClass {
static double wrap_average(double a) {
return AdvancedClass::average(a, -1.0);
}
// ... - Definições com outro número de argumentos
};
4.2.4. Templates e a biblioteca std
Como o conceito de templates não existe nas linguagens de auto-nível, se
quisermos utilizar classes com templates nessas linguagens, precisamos exportar
'instâncias' com tipos definidos para cada template.
Isso é bastantante simples em SWIG, com o seguinte comando, criamos na
linguagem alvo uma classe 'TemplatedClass_int', que tem os tipos que uma classe
TemplatedClass<int> teria em C++:
%template(TemplatedClass_int) TemplatedClass<int>;
Utilizar classes da biblioteca std é também simples e segue um processo
semelhante, mas antes precisamos incluir os arquivos de interface já prontos que fazem o
mapeamento dos tipos da std para a linguagem alvo:
%include "std_vector.i"
%include "std_map.i"
%include "std_string.i"
Agora basta exportar as 'instâncias' das classes std que queremos utilizar na
linguagem alvo:
%template(FloatVector)
std::vector<float>;
%template(Float2StrMap) std::map<float, string>;
Utilizando na linguagem alvo:
>>> dict = some_lib_python.Float2StrMap();
>>> dict[123.4] = 'Hello'
>>> dict.keys()
[123.40000152587891]
>>> dict.values()
['Hello']
>>> dict[123.4]
'Hello'
4.3. Testando
De posse dos arquivos envoltórios gerados pelo SWIG no passo anterior, basta
compilá-los para gerar a biblioteca adaptada que utilizaremos para os testes. A utilização
da biblioteca na linguagem alvo depende um pouco da linguagem sendo utilizada.
Para python, assumindo que a dll adaptada está no mesmo diretório que o arquivo
de acesso, basta importar o pacote de acesso – ele por sua vez irá importar a dll
automaticamente – e utilizá-lo normalmente:
>>> import some_lib_python
>>> hex(some_lib_python.RED)
'0xff0000'
Em java, precisamos carregar explicitamente a dll, e importar cada classe de
acesso que queremos utilizar:
import some_package.SomeClass;
public class testClass {
public static void main(String[] args) {
System.loadLibrary("some_lib_java");
SomeClass someInstance = new SomeClass();
// ...
}
}
Métodos e variáveis globais são colocados como membros de classe de uma
classe com o mesmo nome do módulo, já que java não tem o conceito de 'global':
import some_package.some_lib_java;
// ...
some_lib_java.looseFunction();
// Funcao estática da classe some_lib_java
Para testar some_lib nas linguagens alvo, foi criado um script python e uma
aplicação java, que executam diversos testes semelhantes sobre as funções exportadas
em some_lib. O código fonte de ambas está no anexo 9.3 e 9.4.
Os resultados dos testes são auto explicativos, detalhados pelas strings impressas
pelos aplicativos de teste. O resultado completo de ambos os testes estão no Anexo 9.5 e
9.6.
Os testes com python foram muito bem sucedidos, com todos os testes rodando
bem sucedidos após algumas alterações que foram sendo feitas no arquivo de interface,
até chegarmos ao arquivo de interface atual, que consegue passar em todos em testes
em python.
Algumas modificações foram feitas diretamente no código de some_lib ao longo
das iterações de testes. Se não pudéssemos modificar o código da bibliteca sendo
exportada, essas alterações geralmente poderiam ser feitas em um arquivo envoltório
dedicado a este fim que seria compilado e linkado junto com os envoltórios do SWIG, ou
adicionadas ao próprio arquivo de interface. No entanto, se temos acesso ao arquivo de
interface, e as modificações a serem feitas para facilitar a exportação da biblioteca não
causam grande impacto em código existente que utiliza a biblioteca, alterar diretamente o
fonte desta pode ser mais simples, e ajuda a manter a interface enxuta.
Os testes em java não tiveram tanto êxito. A maioria dos testes funcionou bem, no
entanto alguns testes falharam:
- A tentativa de criação de uma instância de classe abstrata não gerou nenhuma exceção,
e uma tentativa futura de chamar algum membro da instãncia bastarda causa crash da
aplicação.
- O mapeamento de std::string não ficou completo. Apesar de que a função que pede
uma std::string como argumento foi corretamente mapeada para pedir uma String
nativa de java, a função que retornava uma
std::string retornou um tipo
SWIGTYPE_p_string , que não era tratado como uma string pelo java.
- O poliforfismo inter-linguagens não funcionou corretamente, e a chamada para a função
de callback polimórfico chamou a implementação padrão em C++, e não aquela que tinha
sido extendida em java.
As duas últimas situações descritas acima são utilizadas com sucesso no projeto
Taikodom, o que mostra que o SWIG as suporta, porém me faltou tempo para debuggálas e definir o que está errado – ou, mais provavelmente, faltando – nos arquivos de
interface java.
5. Boost Python
"Any intelligent fool can make things bigger, more
complex, and more violent. It takes a touch of genius -and a lot of courage -- to movein the opposite direction."
Albert Einstein5.1. Hello Boost.Python
Boost.Python é “uma biblioteca que permite a interoperability transparente entre
C++ e a linguagem de programação Python” [3]. A Boost.Python é parte da biblioteca
Boost, que é também gratuita para quaisquer fins e pode ser baixada em www.boost.org.
Diferentemente do SWIG, a Boost.Python não se destina a oferecer a
interoperability com C++ a várias linguagens, mas se especializa unicamente em Python.
Isso permite que o desenvolvimento da biblioteca seja mais focado, já que os
desenvolvedores não dispersam esforços entre várias frentes. Isso também pode fazer
com que o aprendizado completo seja mais rápido – uma olhada na diferença de tamanho
entre os dois manuais é um indício disso, apesar de que a instalação a utilização do
SWIG pela primeira vez é mais simples do que para a Boost.Python.
A filosofia de utilização da Boost.Python também é completamente diferente do
SWIG. Ao invéz de parsear um arquivo com sintaxe própria para gerar os arquivos
envoltórios com código feio para serem compilados, a criação das interfaces a serem
exportadas se dá em C++ mesmo, e será o mesmo código que será compilado para gerar
a biblioteca adaptada. A utilização de macros e funções disponíveis na Boost.Python
torna possível a criação dos envoltórios em C++ sem deixar o código absurdamente feio
como vimos anteriormente.
Exemplo:
Suponhamos que temos uma função printHello() que queremos exportar, como no
exemplo do capítulo anterioir. O código envoltório seria:
#include <boost/python.hpp>
using namespace boost::python;
BOOST_PYTHON_MODULE(hello_module)
{
def("print_hello", printHello);
}
Não existe a necessidade de passar o arquivo de interface por uma ferramenta
para gerar os arquivos que serão compilados, pois este é ao mesmo tempo o arquivo de
interface e o arquivo que será compilado. Também não são criados arquivos de acesso,
basta importar a dll gerada e chamar as funções dela diretamente.
$ python
>>> import hello_module
# Importa a biblioteca hello_module.dll
>>> dir(hello_module)
# Imprime todos os membros de hello_module
['print_hello', ...]
>>> hello_module.print_hello()
Hello World!
Apesar de parecer mais simples a princípio por não precisar de um passo extra por
uma ferramenta e de arquivos de acesso, a sintaxe C++ que precisa ser utilizada para a
exportação de membros de uma biblioteca, apesar de ser apenas a sintaxe normal de
C++, tem poucas semelhanças com a sintaxe C++ de uso comum, e pode ser bem mais
difícil de digerir do que a sintaxe utilizada pelo SWIG. Além disso, a Boost.Python não faz
parsing dos arquivos de interface a serem exportados, e portanto não se pode exportar
todo o conteúdo de um arquivo de cabeçalho como fizemos com o SWIG, deve-se
explicitar um a um todos os membros a serem exportados.
Essas duas desvantagens sozinhas são suficientes para que eu desconside a
utilização da Boost.Python sozinha para aumentar a produtividade no desenvolvimento de
um jogo. Mas existe uma ferramenta chamada Pyste, também gratuita, desenvolvida por
Bruno da Silva de Oliveira, bacharel em Ciências da Computação recém formado pela
Universidade Federal de Santa Catarina, que pode resolver os dois problemas.
A utilização do Pyste em conjunto com a Boost.Python torna o funcionamento desta
solução muito parecido com a utilização do SWIG, de forma que o Pyste roda sobre um
arquivo de interface, gerando código envoltório, que por sua vez será compilado para
gerar a biblioteca adaptada para uso em Python, como mostra a figura 5.1
A utilização de Pyste + Boost.Python como solução de integração Python-C++ está
sendo cada vez mais utilizada para o desenvolvimento de jogos; o jogo Civilization IV, um
dos jogos mais esperados do ano, sequência de uma das séries de jogos de PC mais
bem sucedidas de todos os tempos, está sendo desenvolvido utilizando Pyste +
Boost.Python. Atualmente o Pyste já vem incluído na distribuição padrão da
Boost.Python.Figura 4.1: Sistema PYSTE + Boost.Python completo5.2. Integrando
some_lib
Segue a árvore de diretórios e arquivos relevantes do nosso diretório de testes de
Pyste + Boost.Python. Arquivos envoltos por parênteses são gerados automaticamente.
+ Boost.Python
# diretorio raiz
- some_lib_boost_interface.pyste
# Arquivo de interface pyste unico
- pyste_run.sh
# script que roda o Pyste
- some_lib_adapter_code.h
# Codigo adaptador auxiliar
+ some_lib_wrappers
# fontes e projeto dos envoltórios
- some_lib_wrappers.vcproj
# projeto do visual studio
- (some_lib_boost_wrapper.cpp)
# Código Boost.Python gerado pelo Pyste
+ tests
- boost_python_debug.dll
# Biblioteca dinamica da Boost.Python
- (some_lib_boost.dll)
# Resultado da compilacao dos envoltorios
- some_lib_boost_tests.py
# Testes de some_lib usando Boost
Todos os arquivos de interface, o script para rodar o Pyste, e o fonte do código
adaptador estão no Anexo 9.7.
O arquivo some_lib_boost_interface.pyste é o núcleo da nossa interface. Ao
invéz de declarar um arquivo de cabeçalho como fizemos em Python, declaramos as
classes, estruturas e funções a serem exportadas, e em qual arquivo se encontra a sua
declaração.
Variáveis globais são exportadas como somente-leitura, então é necessário fazer
funções de acesso a elas em C++ para utilizá-las para leitura e escrita. O arquivo
some_lib_adapter_code.h faz esse tipo de adaptação.
Os problemas discutidos no capítulo anterior relacionados a argumentos multiplos e
templates acontecem da mesma maneira utilizando Boost.Python, e são solucionados de
maneira semelhante.
Funções envoltório foram criadas no arquivo de adaptação com um número fixo de
argumentos para resolver o problema dos argumentos multiplos, semelhante a solução
adotada com o SWIG.
Com uma solução também semelhante à utilizada no SWIG, para exportar
templates, cria-se no Pyste um tipo 'Template' com a classe de template que queremos
exportar, e cria-se 'instâncias' com tipos definidos que serão exportadas:
T = Template("TemplatedClass", "some_lib.h")
T('int', 'TemplatedClass_int')
5.2.1. Políticas de chamada
Em C++, é difícil determinar a semântica de argumentos e retornos por ponteiros e
referência, principalmente na definição de quem é o 'dono' do objeto – o responsável por
removê-lo. Um método que retorne um char *, por exemplo, pode ter alocado espaço para
a string e espera que quem chame a função desaloque este espaço, pode estar
retornando o endereço de algo que foi passado por parâmetro, pode estar retornando o
endereço de um recurso fixo, etc.
Nesse contexto, imagine que temos uma simples funcao em C++, foobar:
ClassA &foobar(classB &b) {
return b.a;
}
Utilizar essa função sem maiores cuidados em Python pode ser fatal:
>>> a = foobar(b)
>>> del b
>>> a.some_method() # CRASH!
Isso acontece porque a vida de a está atrelada a vida de b, e quando deletamos b,
a passou a ser uma referência 'suspensa', já que essa semãntica de política de chamada
não tem como ser deduzida pela assinatura do método foobar.
Para funções que retornam ponteiros ou referências, a semântica de retorno
precisa ser explicidamente definida como fizemos no nosso arquivo de interface. Maiores
detalhes sobre o funcionamento e tipos de políticas de chamadas podem ser encontrados
no tutorial da Boost.Python5.3. Testando
De modo análogo aos testes realizados com SWIG no capítulo anterior, criamos
um cript para realizar testes com a bibliteca criada utilizando Boost.Python. O código fonte
dos testes e o resultado destes estão nos Anexos 9.8 e 9.9, respectivamente.
TODO:
Resolver alguns pepinos com os testes usando Pyste + Boost.Python:
- Acessar char* como string nativa
- Acessar C array como lista nativa
- Passar valores para funções C++ que pedem ponteiros pra tipos básicos tipo int* e int&
- O Pyste se perde se deixarmos os includes da std em some_lib.h
- Operator overload nao ta rolando [TODO – levantar mais dados]
- Passar funcao de callback definida em C++ nao ta rolando
Ver se tem como fazer isso:
- Exportar #defines tipo o nosso RED
- Levantar exceção se o cara tentar escrever em variável global somente-leitura
6. Apocalypse
“No matter how beautiful, no matter
how cool your interface, it would be
better if there were less of it."
Alan Cooper6.1. Comparando estratégias num projeto real
Apocalypse é um jogo que vem sendo desenvolvido pelo autor deste trabalho, e
está cerca de 70% concluído. Para comparar a utilização prática das duas soluções
discutidas anteriormente, iremos utilizar o Apocalypse como plataforma de testes,
exportando partes da base de código utilizada atualmente para uma linguagem de autonível, permitindo que parte dos 30% restantes, e possíveis modificações futuras, sejam
implemendadas com maior rapidez utilizando uma linguagem de alto-nível.
Durante todo o desenvolvimento do jogo, uma das partes que foi mais adiada foi a
criação das diversas GUIs que compõe o jogo – apesar de a interface principal do jogo ter
sido criada, as interfaces que permeiam o jogo e que também são essenciais para o seu
funcionamento completo ainda não foram criadas, como: menu principal, menu de
opções, menu de criação de jogo, entre outros. Isso se deve ao fato de que a API de
rotinas de baixo nível utilizada (Allegro), é pouco ergonômica para a criação de GUIs, e
também ao fato de que ao criar uma interface em C++, sem a disponibilidade de um editor
WYSIWYG, ficamos presos ao ciclo codificar-compilar-testar, que é extremamente penoso
para a contrução de interfaces onde é preciso modificar o código inúmeras vezes para
verificar os resultados de pequenas modificações nas estruturas da interface.
Exportando uma interface que permita a criação das interfaces em Python,
podemos cortar a compilação do ciclo de cada iteração de teste, além de poder adaptar
as estruturas feias providas pela Allegro a um ambiente de construção de interfaces mais
limpo e rápido.
Começaremos definindo uma interface em C++ para o nosso sistema de interface a
ser exportada, e implementando em C++ a lógica que conversa com a Allegro. Depois de
implementada, essa interface será exportada para Python, utilizando tanto o SWIG quanto
o Pyste + Boost.Python. A solução que se mostrar mais apta para resolver o nosso
problema será mantida, e por fim implementaremos algumas das interfaces do
Apocalypse em Python, comparando o tempo de desenvolvimento e as dificultades
encontradas para a sua construção com os seus equivalentes para as interfaces que já
foram construídas anteriormente em C++.6.2. SWIG
blah blah
6.3. Pyste
blah blah
7. Conclusão
“When the solution is simple,
God is anwering”
Albert Eintein7. Conclusão
blah blah
7.1. SWIG x Pyste+Boost.Python
blah blah
7.2. Apocalypse – Post Mortem
blah blah
7.3. Botando as cartas na mesa
blah blah
8. Referências Bibliográficas
“In the face of ambiguity,
refuse the temptation to guess.”
Tim Peters (The Zen of Python)
8. Referências Bibliográficas
[1] A Conversation with Bruce Eckel. Disponível em:
<http://www.artima.com/intv/aboutme.html> (Part I). Acesso em: 21/11/04.
<http://www.artima.com/intv/prodperf.html> (Part II). Acesso em: 21/11/04.
[2] SWIG, Presentations, and Papers. Disponível em:
<http://www.swig.org/doc.html>. Acesso em: 22/11/04
[3] Boost.Python. Disponível em:
<http://www.boost.org/libs/python/doc/>. Acesso em: 22/11/04
[4] Java Native Interface Tutorial. Disponível em:
<http://java.sun.com/docs/books/tutorial/native1.1/>. Acesso em: 24/04/05
[5] Pyste Documentation. Disponível em:
<http://www.boost.org/libs/python/pyste/>. Acesso em: 15/05/2005
[6] Boost.Python Tutorial. Disponível em:
<http://www.boost.org/libs/python/doc/tutorial/doc/html/index.html> Acesso em 15/05/2005
9. Anexos
“The programmer, like the poet, works only slightly
removed from pure thought-stuff. He builds his castles in
the air, from air, creating by exertion of the imagination.
Few media of creation are so flexible, so easy to polish
and rework, so readily capable of realizing grand
conceptual structures.”
Frederick P Brooks Jr
9.1. Código fonte: some_lib
9.1.1. some_lib.h
/*******************************************************************************
* Arquivo: some_lib.h
* Autor: Petrucio - [email protected]
*
* Interface de some_lib - biblioteca didatica para programacao hibrida
******************************************************************************/
#ifndef _SOMELIB_H_
#define _SOMELIB_H_
#include <vector>
#include <string>
#include <map>
using namespace std;
/***
* Basic Concepts
******************************************************************************/
// 1- Global variables:
extern int
base_int;
extern float base_float;
extern double base_double;
extern char
base_char;
extern char
base_string[2];
extern int
int_array[5];
// 2- Constants:
extern const int const_int;
#define RED
0xFF0000
#define GREEN 0x00FF00
#define BLUE 0x0000FF
enum size { small, medium, big };
extern size some_size;
// 3- Loose Functions:
int looseFunction();
// 4- Structs:
struct SomeStruct {
SomeStruct():
struct_member(4) {}
int struct_member;
};
/***
* Object Oriented Concepts
******************************************************************************/
// 5- Classes:
class SomeClass {
public:
SomeClass();
// Functions:
float getFoo();
void setFoo(float foo);
// Instance Variables:
float foo;
// Class Members:
static int getBar();
// Private members:
private:
static int bar;
int getPrivate();
int private_member;
};
// 6- Inheritance
class OtherClass: public SomeClass {
public:
OtherClass() {}
float getFoo();
};
// Pure virtual methods (Abstract classes)
class AbstractClass {
public:
virtual float getFloat() = 0;
};
// 7- Virtual methods (Polimorphism)
class RealClassCpp: public AbstractClass {
public:
RealClassCpp() {}
virtual float getFloat();
};
// Calling target code from C++ throught Polimorphism:
float callGetFloat(AbstractClass &abstractClassInstance);
/***
* Advanced Concepts
******************************************************************************/
class Callable {
public:
Callable() {}
virtual float call(float parm) { return 0; }
};
class AdvancedClass {
public:
AdvancedClass (float value);
void setValue(float value);
float getValue();
// 8- Reference types:
static int resetInt_Value
(int a);
static int resetInt_Pointer (int *a);
static int resetInt_Reference(int &a);
// 9- Default arguments:
static void print_(const char *string = "
Hello World");
// Multiple arguments:
static double average(double a, ...);
// 10- Callbacks:
void setCallback(float (*callback)(float));
float callCallback();
void setPolyCallback(Callable *callbackInstance);
float callPolyCallback();
// 11- Operator Overloading:
AdvancedClass * operator + (AdvancedClass other);
private:
float value;
float (*callback)(float);
Callable *callbackInstance;
};
// 12- Templates:
template <class T>
class TemplatedClass {
public:
TemplatedClass() {}
void setValue(T value) { this->some_value = value; }
T getValue() { return this->some_value; }
private:
T some_value;
};
// Multiple inheritance:
class MultipleClass: public SomeClass, public RealClassCpp {
public:
MultipleClass() {}
};
// Std functions
class StdClass {
public:
StdClass() {
float_vector.reserve(10);
}
// Using std::vectors, strings, and dictionaries
vector<float>
float_vector;
map
<float, string> float2str_map;
// Hack pra adicionar valores em java
void addFloat(float value) {
float_vector.push_back(value);
}
};
#endif
9.1.2. some_lib.cpp
/*******************************************************************************
* Arquivo: some_lib.cpp
* Autor: Petrucio - [email protected]
*
* some_lib - biblioteca didatica para programacao hibrida
******************************************************************************/
#include "../include/some_lib.h"
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
/***
* Base types
******************************************************************************/
int
base_int
= 1;
float
base_float
= 1.0f;
double base_double
= 1.0;
char
base_char
= '1';
char
base_string[2] = "1";
int
int_array[5]
= { 1, 2, 3, 4, 5 };
const int const_int = 2;
size some_size = big;
int looseFunction() {
return 3;
}
/***
* SomeClass
******************************************************************************/
SomeClass::SomeClass():
foo(5),
private_member(5) {
}
float SomeClass::getFoo() {
return this->foo;
}
void SomeClass::setFoo(float foo) {
this->foo = foo;
}
int SomeClass::getBar() {
return SomeClass::bar;
}
int SomeClass::bar = 5;
int SomeClass::getPrivate() {
return this->private_member;
}
/***
* OtherClass
******************************************************************************/
float OtherClass::getFoo() {
return this->foo + 1;
}
/***
* Virtuals:
******************************************************************************/
float RealClassCpp::getFloat() {
return 7.0f;
}
float callGetFloat(AbstractClass &abstractClassInstance) {
return abstractClassInstance.getFloat();
}
/***
* AdvancedClass
******************************************************************************/
AdvancedClass::AdvancedClass(float p_value):
value(p_value),
callback(NULL),
callbackInstance(NULL) {
}
void AdvancedClass::setValue(float value) {
this->value = value;
}
float AdvancedClass::getValue() {
return this->value;
}
// ResetInts
int AdvancedClass::resetInt_Value(int a) {
a = 0;
return 8;
}
int AdvancedClass::resetInt_Pointer(int *a) {
*a = 0;
return 8;
}
int AdvancedClass::resetInt_Reference(int &a) {
a = 0;
return 8;
}
// Arguments
void AdvancedClass::print_(const char *string) {
printf("%s\n", string);
fflush(0);
}
double AdvancedClass::average(double a, ...) {
int count = 0;
double sum = 0, i = a;
va_list
args;
va_start(args, a);
while(i != -1.0) {
sum += i;
count++;
i = va_arg(args, double);
}
va_end(args);
return(sum ? (sum / count) : 0);
}
// Callbacks
void AdvancedClass::setCallback(float (*callback)(float)) {
this->callback = callback;
}
float AdvancedClass::callCallback() {
return this->callback(this->value);
}
void AdvancedClass::setPolyCallback(Callable *callbackInstance) {
this->callbackInstance = callbackInstance;
}
float AdvancedClass::callPolyCallback() {
return this->callbackInstance->call(this->value);
}
// Operator
AdvancedClass* AdvancedClass::operator+ (AdvancedClass other) {
return new AdvancedClass(this->getValue() + other.getValue());
}
9.2. Interface SWIG para some_lib
9.2.1. some_lib_swig_interface.i
// Some_lib common interface file
%{
// Implementing a callback
float increment_callback(float value) {
return value + 0.1f;
}
// Needed headers:
#include <some_lib.h>
%}
// Enable all Cross language polimorphysm:
%feature("director");
// Setting the callback as a function pointer in target language:
%constant float increment_callback(float);
// Using c arrays as arrays in the target language:
%include "carrays.i"
%array_class(int, INT_ARRAY);
// Passing base pointers as input or output:
%include "typemaps.i"
%apply int *INOUT { int *a };
%apply int &INOUT { int &a };
// Create 'instances' of variable arguments functions:
%extend AdvancedClass {
static double wrapped_average(double a)
{ return AdvancedClass::average(a, -1.0); }
static double wrapped_average(double a, double b)
{ return AdvancedClass::average(a, b, -1.0); }
static double wrapped_average(double a, double b, double c)
{ return AdvancedClass::average(a, b, c, -1.0); }
static double wrapped_average(double a, double b, double c, double d)
{ return AdvancedClass::average(a, b, c, d, -1.0); }
};
// Exposing std::strings, vectors and maps:
%include "std_vector.i"
%include "std_map.i"
%include "std_string.i"
// Create 'instances' of used std::vectors and maps
%template(FloatVector) std::vector<float>;
%template(Float2StrMap) std::map<float, string>;
// Exposed headers:
%include <some_lib.h>
// Export template 'instances'
%template(TemplatedClass_int) TemplatedClass<int>;
9.2.2. some_lib_swig_interface_python.i
// Some_lib interface file - python specifics:
%module(directors="1") some_lib_python
%{
%}
%include "some_lib_swig_interface.i"
9.2.3. some_lib_swig_interface_java.i
// Some_lib interface file - java specifics:
%module(directors="1") some_lib_java
%{
// Wrapping multiple inheritance with an aggreate:
#include <some_lib.h>
class WrappedMultipleClass: public MultipleClass {
public: RealClassCpp aggregate;
};
%}
// seeing arrays transparently:
%include "arrays_java.i"
// To avoid getter and setter name clashes:
%rename foo foo_attr;
// To be able to use operators in java:
%rename(add) AdvancedClass::operator+;
%include "some_lib_swig_interface.i"
// Exporting our multiple inheritance wrapper
class WrappedMultipleClass: public MultipleClass {
public: RealClassCpp aggregate;
};
9.2.4. swig_run.sh
SOME_LIB_DIR=C:/Projetos/Relatorio/some_lib
INCLUDE_DIRS=${SOME_LIB_DIR}/include
PYTHON_INTERFACE_FILE=some_lib_swig_interface_python.i
JAVA_INTERFACE_FILE=some_lib_swig_interface_java.i
PYTHON_OUTPUT_FILE=some_lib_python_wrappers.cpp
PYTHON_OUTPUT_DIR=some_lib_python_wrappers
PYTHON_TEST_DIR=python_tests
JAVA_OUTPUT_FILE=some_lib_java_wrappers.cpp
JAVA_OUTPUT_DIR=some_lib_java_wrappers
JAVA_TEST_DIR=java_tests
JAVA_PACKAGE=some_package
EXCLUDE_WARNS=-w514,813
echo "Creating python wrapper code"
swig -python -c++ ${EXCLUDE_WARNS} -o ${PYTHON_OUTPUT_FILE} -I${INCLUDE_DIRS}
${PYTHON_INTERFACE_FILE}
mv *.cpp *.h ${PYTHON_OUTPUT_DIR}
mv *.py ${PYTHON_TEST_DIR}
echo "Creating java
swig -java
wrapper code"
-c++ ${EXCLUDE_WARNS} -package ${JAVA_PACKAGE} -o
${JAVA_OUTPUT_FILE} -I${INCLUDE_DIRS} ${JAVA_INTERFACE_FILE}
mv *.cpp
${JAVA_OUTPUT_DIR}
rm ${JAVA_TEST_DIR}/${JAVA_PACKAGE}/*.java
${JAVA_TEST_DIR}/${JAVA_PACKAGE}/*.class -rf
mv *.java ${JAVA_TEST_DIR}/${JAVA_PACKAGE}
echo "Done"
9.3. Código fonte: testes de some_lib em python
9.3.1. some_lib_python_tests.py
#*******************************************************************************
# File: some_lib_python_tests.py
# Testa em python as funcionalidades de some_lib exportadas pelo SWIG
# Ver arquivo de interface some_lib_swig_interface.i
#*******************************************************************************
import some_lib_python
#*******************************************************************************
# Imprime todos os membros de root, comecando com identacao ident, percorrendo
# a arvore ateh o nivel indicado por sub_lvel.
# Ignora membros que iniciem por '_', ou terminem com 'Ptr'
# Os nos folha sao impressos na mesma linha
#*******************************************************************************
def print_tree(root, ident, sub_level):
if sub_level == 1:
str = ''
for entry in dir(root):
if entry.startswith('_') or entry.endswith('Ptr'):
str += entry + ', '
if len(str) > 0:
print' ' * ident + ' - ' + str
return
for entry in dir(root):
if entry.startswith('_') or entry.endswith('Ptr'):
print ' ' * ident, '+', entry
entry = getattr(root, entry)
print_tree(entry, ident + 2, sub_level - 1)
continue
continue
#*******************************************************************************
# Helper printing functions
#*******************************************************************************
def print_header(string):
print
print
'===============================================================================
='
print string
print '-------------------------------------------------------------------------------'
def print_footer():
print
'===============================================================================
='
def print_spearator():
print
print
'_______________________________________________________________________________
_'
print
#*******************************************************************************
# Imprime cabecalho e a arvore dos membros exportados de some_lib
#*******************************************************************************
def print_start():
print
print 'some_lib_swig_tests.py'
print 'Testa em python as funcionalidades de some_lib exportadas pelo SWIG'
print
print 'Na maioria dos casos, um teste eh considerado bem sucedido se o valor'
print 'impresso for igual ao numero do teste sendo realizado, as vezes com'
print 'incrementos sucessivos de 0.1 entre sub-testes'
print 'Outros, pela sua natureza, sao bem sucedidos quanto algum erro'
print 'acontece durante o teste, como tentar modificar uma constante'
print_header('Arvore dos membros exportados:')
print_tree(some_lib_python, 2, 2)
print_footer()
print
#*******************************************************************************
# Testa leitura e escrita em variaveis globais de some_lib, com tipos variados
# de dados
# Nota: Variaveis globais sao acessadas atraves de modulo.cvar
# Nota: Para acessar array, inclua carrays.i no arquivo de interface, e defina
# %array_class(TYPE, NAME), onde TYPE eh o tipo do array e NAME eh um nome
# qualquer a ser dado ao array. Crie um array em pytohn usando a funcao da
# classe NAME frompointer, como mostra o exemplo a seguir
#*******************************************************************************
def test_globals():
print_header('Teste 1: Testando leitura e escrita em variaveis C' +
' globais de diferentes tipos')
print 'Lendo variavel inteira
some_lib_python.cvar.base_int
print 'Lendo variavel ponto flutuante simples
some_lib_python.cvar.base_float
print 'Lendo variavel ponto flutuante double
some_lib_python.cvar.base_double
print 'Lendo variavel caracter
some_lib_python.cvar.base_char
print 'Lendo string (null terminated chars)
some_lib_python.cvar.base_string
base_int:
', \
base_float:
', \
base_double: ', \
base_char:
', \
base_string: ', \
array = some_lib_python.INT_ARRAY_frompointer(some_lib_python.cvar.int_array)
print 'Lendo array de inteiros
int_array:
', \
array[0], array[1], array[2], array[3], array[4]
print
print 'Alterando valor de base_float para 1.1'
some_lib_python.cvar.base_float = 1.1
print 'Lendo variavel ponto flutuante simples base_float:
some_lib_python.cvar.base_float
print_footer()
', \
#*******************************************************************************
# Testa leitura de #defines e enums, e acesso ilegal a constantes
#*******************************************************************************
def test_constants():
print_header('Teste 2: Testando leitura de #defines e enums,' +
' e acesso ilegal a constantes')
print 'Lendo enum size some_size:
', some_lib_python.cvar.some_size,'(big)'
print 'Lendo constante #define RED: ', hex(some_lib_python.RED)
print 'Testando escrita ilegal em constante const_int:'
try:
some_lib_python.cvar.const_int = 2
except TypeError, value:
print ' TypeError:', value
print_footer()
#*******************************************************************************
# Testa chamadas a funcoes
#*******************************************************************************
def test_functions():
print_header('Teste 3: Testando chamadas a funcoes C')
print 'Chamando funcao looseFunction: ', some_lib_python.looseFunction()
print_footer()
#*******************************************************************************
# Testa uso de structs
#*******************************************************************************
def test_structs():
print_header('Teste 4: Testando utilizacao de structs')
struct = some_lib_python.SomeStruct()
print 'Criando struct SomeStruct e acessando membro struct_member: ', \
struct.struct_member
print_footer()
#*******************************************************************************
# Testa uso de classes:
# Funcoes e atributos, de instancia e de classe, publicos e privados
#*******************************************************************************
def test_classes():
print_header('Teste 5: Testando utilizacao de classes: ' +
'\n\t Funcoes e atributos, de instancia e de classe, publicos e privados')
print 'Criando instancia de SomeClass - some_instance'
some_instance = some_lib_python.SomeClass()
print 'Chamando funcao
some_instance.getFoo():
', \
some_instance.getFoo()
print 'Alterando foo para 5.1 chamando some_instance.setFoo(5.1)'
some_instance.setFoo(5.1)
print 'Lendo atributo publico
some_instance.foo:
', \
some_instance.foo
print
print 'Chamando funcao de classe
SomeClass_getBar():
', \
some_lib_python.SomeClass_getBar()
try:
print 'Chamando funcao privada
some_instance.getPrivate():', \
some_instance.getPrivate()
except AttributeError, value:
print '\n AttributeError:', value
print_footer()
#*******************************************************************************
# Testa conceitos basicos de heranca
#*******************************************************************************
def test_inheritance():
print_header('Teste 6: Testando conceitos basicos de heranca')
print 'Criando instancia de OtherClass (subclasse de SomeClass)'
other_instance = some_lib_python.OtherClass()
print 'Lendo antiga variavel nao modificada other_instance.foo:
', \
other_instance.foo
print 'Chamando funcao reimplementada
other_instance.getFoo():', \
other_instance.getFoo()
print_footer()
#*******************************************************************************
# Testa classes abstratas e polimorfismo
# Nota: Atravez do polimorfismo pode-se chamar codigo python a partir de C++,
# como eh feito neste exemplo
#*******************************************************************************
def test_polimorphysm():
print_header('Teste 7: Testando classes abstratas e polimorfismo')
print 'Criando instancia de classe abstrata AbstractClass:'
try:
abstract_instance = some_lib_python.AbstractClass()
except RuntimeError, value:
print ' RuntimeError:', value
print
print 'Definindo RealClassPython (subclasse de RealClassCpp) em python'
class RealClassPython(some_lib_python.RealClassCpp):
def __init__(self):
some_lib_python.RealClassCpp.__init__(self)
def getFloat(self):
return some_lib_python.RealClassCpp.getFloat(self) + 0.1
print 'Criando instancias de subclasses RealClassCpp e RealClassPython'
real_instance_cpp
= some_lib_python.RealClassCpp()
real_instance_python = RealClassPython()
print 'callGetFloat => funcao em C++,',\
'chama getFloat de uma instancia de AbstractClass'
print
print 'Chamando callGetFloat(real_instance_cpp):
', \
some_lib_python.callGetFloat(real_instance_cpp)
print 'Chamando callGetFloat(real_instance_python):', \
some_lib_python.callGetFloat(real_instance_python)
print_footer()
#*******************************************************************************
# Testa diferentes tipos de referencia
# NOTA: Em python nao existe o conceito de argumentos como saida, portanto
# variaveis que tenham sido definidas como saida no arquivo de inteface (como
# neste caso), terao seus valores adicionados a lista de retorno.
# NOTA: Tipos basicos adicionam complexidade em se tratando se referencias ou
# ponteiros. Ja uma instancia de uma classe poderia ser passada para C++, tanto
# para funcoes pedindo parametros por valor, como por referencia ou ponteiro.
#*******************************************************************************
def test_references():
print_header('Teste 8: Testando diferentes tipos de referencia' +
'\n\t (por valor, ponteiro ou referencia)')
print 'Criando variavel inteira com valor 8'
int_var = 8
print 'Chamando funcao que tenta zerar variavel por valor'
print 'Retorno da chamada de AdvancedClass_resetInt_Value(int_var):
some_lib_python.AdvancedClass_resetInt_Value(int_var)
print
print 'Criando variavel inteira com valor 8'
int_var = 8
print 'Chamando funcao que tenta zerar variavel por ponteiro'
print 'Retorno da chamada de AdvancedClass_resetInt_Pointer(int_var):
some_lib_python.AdvancedClass_resetInt_Pointer(int_var)
', \
', \
print
print 'Criando variavel inteira com valor 8'
int_var = 8
print 'Chamando funcao que tenta zerar variavel por referencia'
print 'Retorno da chamada de AdvancedClass_resetInt_Reference(int_var):', \
some_lib_python.AdvancedClass_resetInt_Reference(int_var)
print_footer()
#*******************************************************************************
# Testa argumentos padroes e argumentos multiplos
# NOTA: Python nao usa o conceito de argumentos variaveis porque usa tuplas,
# entao funcoes com varios argumentos deve ter 'instancias' com um
# numero pre-determinado de argumentos e tipos exportados, como no nosso exemplo
#*******************************************************************************
def test_arguments():
print_header('Teste 9: Testando argumentos padroes e argumentos multiplos')
print 'Chamando funcao print_ com argumento " Teste 9":'
some_lib_python.AdvancedClass_print_(" Teste 9")
print 'Chamando funcao print_ sem argumentos:'
some_lib_python.AdvancedClass_print_()
print
print 'Chamando wrapped_average(1, 2):
', \
some_lib_python.AdvancedClass_wrapped_average(1, 2)
print 'Chamando wrapped_average(1, 2, 3, 4): ', \
some_lib_python.AdvancedClass_wrapped_average(1, 2, 3, 4)
try:
print 'Chamando wrapped_average(1, 2, 3, 4, 5, 6) - nao exportada:', \
some_lib_python.AdvancedClass_wrapped_average(1, 2, 3, 4, 5, 6)
except TypeError, value:
print '\n TypeError:', value
print_footer()
#*******************************************************************************
# Testa o uso de callbacks
# NOTA: Callbacks podem ser feitos em C++, dentro da propria interface,
# ou pode-se utilizar Polimorfismo para chama-los em Python. Este exemplo mostra
# as duas alternativas
#*******************************************************************************
def test_callbacks():
print_header('Teste 10: Testando o uso de callbacks')
print 'Criando instancia de advanced class com valor 10'
advanced_instance = some_lib_python.AdvancedClass(10)
print 'Definindo callback como sendo funcao C++ definida no arquivo .i'
advanced_instance.setCallback(some_lib_python.increment_callback)
print 'Requisitando chamada aa funcao de callback:', \
advanced_instance.callCallback()
print
print 'Definindo classe PythonCallable (subclasse de Callable) em python'
class PythonCallable(some_lib_python.Callable):
def __init__(self):
some_lib_python.Callable.__init__(self)
def call(self, parm):
return parm + 0.2
print 'Definindo o callback polimorfico como sendo', \
'uma instancia de PythonCallable'
python_callback = PythonCallable()
advanced_instance.setPolyCallback(python_callback)
print 'Requisitando chamada aa funcao de callback polimorfico:', \
advanced_instance.callPolyCallback()
print_footer()
#*******************************************************************************
# Testa o uso de sobrecarga de operadores
#*******************************************************************************
def test_operators():
print_header('Teste 11: Testando o uso de sobrecarga de operadores')
print 'Criando uma instancia de AdvancedClass com valor 5 e outra com 6'
advanced_instance_5 = some_lib_python.AdvancedClass(5)
advanced_instance_6 = some_lib_python.AdvancedClass(6)
print 'advanced_result = advanced_instance_5 + advanced_instance_6'
advanced_result = advanced_instance_5 + advanced_instance_6
print 'Valor de advanced_result.getValue():', advanced_result.getValue()
print_footer()
#*******************************************************************************
# Testa o uso de templates
# NOTA: Como nao existe o conceito de templates em python, precisamos criar
# 'instancias' de templates, como neste exemplo
#*******************************************************************************
def test_templates():
print_header('Teste 12: Testando o uso de templates')
print 'Criando instancia de TemplatedClass<int>'
templated_instance = some_lib_python.TemplatedClass_int()
templated_instance.setValue(12)
print 'Definindo valor inteiro 12 e lendo:', templated_instance.getValue()
print 'Criando instancia de TemplatedClass<float> - nao exportada'
try:
templated_instance = some_lib_python.TemplatedClass_float()
except AttributeError, value:
print ' AttributeError:', value
print_footer()
#*******************************************************************************
# Testa heranca multipla
#*******************************************************************************
def test_multiple_inheritance():
print_header('Teste 13: Testando heranca multipla')
print 'Criando instancia de MultipleClass',\
' - subclasse de SomeClass e de RealClassCpp'
multiple_instance = some_lib_python.MultipleClass()
print 'Chamando funcao herdada de SomeClass
em 5:' + \
' multiple_instance.getFoo(): ', multiple_instance.getFoo()
print 'Chamando funcao herdada de RealClassCpp em 7:' + \
' multiple_instance.getFloat():', multiple_instance.getFloat()
print_footer()
#*******************************************************************************
# Testa uso de std::vectors e std::maps
# como listas e dicionarios nativos de python
#*******************************************************************************
def test_std():
print_header('Teste 14: Testando std::vectors e maps' +\
' como listas e mapas nativos de python')
print 'Criando instancia de StdClass' + \
' - contendo membros std::vector e std::map'
std_instance = some_lib_python.StdClass()
print
print 'Adicionando valores 14.0 e 14.1 ao std::vector de C++,', \
'com sintaxe python'
std_instance.float_vector.append(14.0)
std_instance.float_vector.append(14.1)
print 'Percorrendo vetor com sintaxe python:'
print ' for item in std_instance.float_vector: print item'
for item in std_instance.float_vector: print item
print
print 'Adicionando ao std::map com sintaxe python:'
print ' map[14.2] = "Hello 14.2"'
print ' map[14.3] = "Hello 14.3"'
std_instance.float2str_map[14.2] = 'Hello 14.2'
std_instance.float2str_map[14.3] = 'Hello 14.3'
print 'Imprimindo items() do mapa - como em um dicionario python:'
print std_instance.float2str_map.items()
print_footer()
#*******************************************************************************
# MAIN
#*******************************************************************************
print_start()
print_spearator()
print_header('Testando conceitos basicos de C estruturado:' +
'\nVariaveis globais, funcoes, structs, etc.')
test_globals()
test_constants()
test_functions()
test_structs()
print_spearator()
print_header('Testando conceitos basicos de C++ orientado a objetos:' +
'\nClasses, heranca, polimorfismo, etc.')
test_classes()
test_inheritance()
test_polimorphysm()
print_spearator()
print_header('Testando conceitos avancados:' +
'\nTemplates, heranca multipla, callbacks, operadores, etc...')
test_references()
test_arguments()
test_callbacks()
test_operators()
test_templates()
test_multiple_inheritance()
test_std()
9.4. Código fonte: testes de some_lib em java
9.4.1. some_lib_JavaTests.java
/*
*******************************************************************************
* File: some_lib_JavaTests.java
* Testa em java as funcionalidades de some_lib exportadas pelo SWIG
* Ver arquivo de interface some_lib_swig_interface.i
******************************************************************************/
import
import
import
import
import
import
import
import
import
some_package.AdvancedClass;
some_package.OtherClass;
some_package.RealClassCpp;
some_package.SomeClass;
some_package.SomeStruct;
some_package.StdClass;
some_package.TemplatedClass_int;
some_package.WrappedMultipleClass;
some_package.some_lib_java;
public class some_lib_JavaTests {
/*
****************************************************************************
* Helper printing functions
***************************************************************************/
private static void print(String string)
{ System.out.println(string); }
private static void print(String string, int aint)
{ System.out.println(string + aint); }
private static void print(String string, char achar)
{ System.out.println(string + achar); }
private static void print(String string, float afloat)
{ System.out.println(string + afloat); }
private static void print(String string, double adouble)
{ System.out.println(string + adouble); }
private static void print(String string, String str2)
{ System.out.println(string + str2); }
private static void printHeader(String string) {
print("");
print("=========================================================================
=======");
print(string);
print("-------------------------------------------------------------------------------");
}
private static void printFooter() {
print("=========================================================================
=======");
}
private static void printSeparator() {
print("");
print("_________________________________________________________________________
_______");
print("");
}
/*
****************************************************************************
* Imprime cabecalho e a arvore dos membros exportados de some_lib
***************************************************************************/
public void printStart() {
print("");
print("some_lib_JavaTests.java");
print("Testa em java funcionalidades de some_lib exportadas pelo SWIG");
print("");
print("Na maioria dos casos, um teste eh considerado bem sucedido se o");
print("valor impresso for igual ao numero do teste sendo realizado,");
print("as vezes com incrementos sucessivos de 0.1 entre sub-testes");
print("Outros, pela sua natureza, sao bem sucedidos quanto algum erro");
print("acontece durante o teste, como tentar modificar uma constante");
printFooter();
}
/*
****************************************************************************
* MAIN
* Nota: Alguns erros que foram testados em python dinamicamente (como
* escrita em constante, tentativa de instanciacao de classe abstrata, entre
* outros) sao detectados em Java em compile-time, e nao foram testados aqui
* como foram em python.
***************************************************************************/
public static void main(String[] args) {
System.loadLibrary("some_lib_java");
some_lib_JavaTests tester = new some_lib_JavaTests();
tester.printStart();
printSeparator();
printHeader("Testando conceitos basicos de C estruturado:" +
"\nVariaveis globais, funcoes, structs, etc.");
tester.testGlobals();
tester.testConstants();
tester.testFunctions();
tester.testStructs();
printSeparator();
printHeader("Testando conceitos basicos de C++ orientado a objetos:" +
"\nClasses, heranca, polimorfismo, etc.");
tester.testClasses();
tester.testInheritance();
tester.testPolimorphysm();
printSeparator();
printHeader("Testando conceitos avancados:" +
"\nTemplates, heranca multipla, callbacks, operadores, etc.");
tester.testReferences();
tester.testArguments();
tester.testCallbacks();
tester.testOperators();
tester.testTemplates();
tester.testMultipleInheritance();
tester.testStd();
}
/*
****************************************************************************
* Testa leitura e escrita em variaveis globais de some_lib,
* com tipos variados
* Nota: Variaveis globais sao acessadas atraves de getters e setters,
* metodos de classe de uma classe wrapper com o nome do modulo exportado.
* Nota: Para acessar arrays em java de forma transparente, incluir
* arrays_java.i no arquivo de interface.
***************************************************************************/
private void testGlobals() {
printHeader("Teste 1: Testando leitura e escrita em variaveis C" +
" globais de diferentes tipos");
print("Lendo variavel inteira
some_lib_java.getBase_int());
print("Lendo variavel ponto flutuante simples
some_lib_java.getBase_float());
print("Lendo variavel ponto flutuante double
some_lib_java.getBase_double());
print("Lendo variavel caracter
some_lib_java.getBase_char());
print("Lendo string (null terminated chars)
some_lib_java.getBase_string());
base_int:
",
base_float:
",
base_double: ",
base_char:
",
base_string: ",
int[] intArray = some_lib_java.getInt_array();
System.out.println("Lendo array de inteiros
int_array:
intArray[0] + " " + intArray[1] + " " +
intArray[2] + " " + intArray[3] + " " + intArray[4]);
print("");
print("Alterando valor de base_float para 1.1");
some_lib_java.setBase_float(1.1f);
print("Lendo variavel ponto flutuante simples base_float:
some_lib_java.getBase_float());
"+
",
printFooter();
}
/*
****************************************************************************
* Testa leitura de #defines e enums
***************************************************************************/
private void testConstants() {
printHeader("Teste 2: Testando leitura de #defines e enums," +
" e acesso ilegal a constantes");
System.out.println("Lendo enum size some_size:
" +
some_lib_java.getSome_size()
+ " (big)");
print("Lendo constante #define RED: " +
Integer.toHexString(some_lib_java.RED));
printFooter();
}
/*
****************************************************************************
* Testa chamadas a funcoes
***************************************************************************/
private void testFunctions() {
printHeader("Teste 3: Testando chamadas a funcoes C");
print("Chamando funcao looseFunction: ", some_lib_java.looseFunction());
printFooter();
}
/*
****************************************************************************
* Testa uso de structs
***************************************************************************/
private void testStructs() {
printHeader("Teste 4: Testando utilizacao de structs");
SomeStruct struct = new SomeStruct();
print("Criando struct SomeStruct e acessando membro struct_member: ",
struct.getStruct_member());
printFooter();
}
/*
****************************************************************************
* Testa uso de classes
* Nota: Ao gerar wrappers para Java, o SWIG sempre cria getters e setters
* para os attributos ao invez de deixa-los publicos, seguindo o padrao Beans
* Por isso o acesso direto ao atributo foo nao eh feito neste teste como
* foi feito em python.
***************************************************************************/
private void testClasses() {
printHeader("Teste 5: Testando utilizacao de classes");
print("Criando instancia de SomeClass - some_instance");
SomeClass someInstance = new SomeClass();
print("Chamando funcao
some_instance.getFoo():
someInstance.getFoo());
print("Alterando foo para 5.1 chamando some_instance.setFoo(5.1):
someInstance.setFoo(5.1f);
print("Lendo atributo publico
some_instance.getFoo_attr():
someInstance.getFoo());
print("");
print("Chamando funcao de classe
SomeClass.getBar():
SomeClass.getBar());
printFooter();
}
/*
",
");
",
",
****************************************************************************
* Testa conceitos basicos de heranca
***************************************************************************/
private void testInheritance() {
printHeader("Teste 6: Testando conceitos basicos de heranca");
print("Criando instancia de OtherClass (subclasse de SomeClass)");
OtherClass otherInstance = new OtherClass();
print("Lendo antiga variavel nao modificada otherInstance.getFoo_attr():",
otherInstance.getFoo_attr());
print("Chamando funcao reimplementada
otherInstance.getFoo():
",
otherInstance.getFoo());
printFooter();
}
/*
****************************************************************************
* Testa polimorfismo
* Nota: Atravez do polimorfismo pode-se chamar codigo Java a partir de C++,
* como eh feito neste exemplo
***************************************************************************/
private void testPolimorphysm() {
printHeader("Teste 7: Testando classes abstratas e polimorfismo");
// NOTA: A criacao de instancia de classe abstrata nao gerou erro em Java,
// no entanto tentar acessar algum metodo dessa instancia gerou um acesso
// ilegal e matou o programa.
print("Criando instancia de classe abstrata AbstractClass:");
AbstractClass abstractInstance = new AbstractClass();
print("float: ", abstractInstance.getFloat());
//
//
//
print("");
print("Criando instancias de subclasses RealClassCpp e RealClassJava");
RealClassCpp realInstanceCpp = new RealClassCpp();
RealClassJava realInstanceJava = new RealClassJava();
print("callGetFloat => funcao em C++," +
" chama getFloat de uma instancia de AbstractClass");
print("");
print("Chamando callGetFloat(realInstanceCpp): ",
some_lib_java.callGetFloat(realInstanceCpp));
// TODO: not working:
print("Chamando callGetFloat(realInstanceJava): ",
some_lib_java.callGetFloat(realInstanceJava));
printFooter();
}
/*
****************************************************************************
* Testa diferentes tipos de referencia
* NOTA: Tipos basicos adicionam complexidade em se tratando se referencias
* ou ponteiros. Ja uma instancia de uma classe poderia ser passada para C++,
* tanto para funcoes pedindo parametros por valor,
* como por referencia ou ponteiro.
* NOTA: Funcoes em C++ com argumentos referencia ou ponteiro para tipo
* basico esperam receber um array, como fazemos neste exemplo.
***************************************************************************/
private void testReferences() {
printHeader("Teste 8: Testando diferentes tipos de referencia" +
"\n\t (por valor, ponteiro ou referencia)");
print("Criando um array de apenas um inteiro com valor 8");
int [] intArray = new int[1];
intArray[0] = 8;
print("Chamando funcao que tenta zerar variavel por valor");
AdvancedClass.resetInt_Value(intArray[0]);
print("Valor de intArray[0]: ", intArray[0]);
print("");
print("Criando um array de apenas um inteiro com valor 8");
intArray[0] = 8;
print("Chamando funcao que tenta zerar variavel por ponteiro");
AdvancedClass.resetInt_Pointer(intArray);
print("Valor de intArray[0]: ", intArray[0]);
print("");
print("Criando um array de apenas um inteiro com valor 8");
intArray[0] = 8;
print("Chamando funcao que tenta zerar variavel por referencia");
AdvancedClass.resetInt_Reference(intArray);
print("Valor de intArray[0]: ", intArray[0]);
printFooter();
}
/*
****************************************************************************
* Testa argumentos padroes e argumentos multiplos
* NOTA: Java nao usa o conceito de argumentos variaveis,
* entao funcoes com varios argumentos deve ter 'instancias' com um
* numero pre-determinado de argumentos e tipos exportados,
* como no nosso exemplo.
***************************************************************************/
private void testArguments() {
printHeader("Teste 9: Testando argumentos padrao e argumentos multiplos");
print("Chamando funcao print_ com argumento \" Teste 9\":");
AdvancedClass.print_(" Teste 9");
print("Funcao print_ sem argumentos indisponivel em java");
print("");
print("Chamando wrapped_average(1, 2):
",
AdvancedClass.wrapped_average(1, 2));
print("Chamando wrapped_average(1, 2, 3, 4): ",
AdvancedClass.wrapped_average(1, 2, 3, 4));
print("Funcao wrapped_average(1, 2, 3, 4, 5, 6) nao disponivel em java");
printFooter();
}
/*
****************************************************************************
* Testa o uso de callbacks
* NOTA: Callbacks podem ser feitos em C++, dentro da propria interface,
* ou pode-se utilizar Polimorfismo para chama-los em Java.. Este exemplo
* mostra as duas alternativas
***************************************************************************/
private void testCallbacks() {
printHeader("Teste 10: Testando o uso de callbacks");
print("Criando instancia de advanced class com valor 10");
AdvancedClass advancedInstance = new AdvancedClass(10);
print("Definindo callback como sendo funcao C++ definida no arquivo .i");
advancedInstance.setCallback(some_lib_java.increment_callback);
print("Requisitando chamada aa funcao de callback:
",
advancedInstance.callCallback());
print("");
print("Definindo o callback polimorfico como sendo" +
" uma instancia de JavaCallable");
JavaCallable javaCallback = new JavaCallable();
advancedInstance.setPolyCallback(javaCallback);
// TODO: This is not working
print("Requisitando chamada aa funcao de callback polimorfico: ",
advancedInstance.callPolyCallback());
printFooter();
}
/*
****************************************************************************
* Testa o uso de sobrecarga de operadores
***************************************************************************/
private void testOperators() {
printHeader("Teste 11: Testando o uso de sobrecarga de operadores");
print("Criando uma instancia de AdvancedClass com valor 5 e outra com 6");
AdvancedClass advancedInstance_5 = new AdvancedClass(5);
AdvancedClass advancedInstance_6 = new AdvancedClass(6);
print("advancedResult = advanced_instance_5 + advanced_instance_6" +
" (using renamed add)");
AdvancedClass advancedResult = advancedInstance_5.add(advancedInstance_6);
print("Valor de advancedResult.getValue(): ", advancedResult.getValue());
printFooter();
}
/*
****************************************************************************
* Testa o uso de templates
* NOTA: Como nao existe o conceito de templates em java, precisamos criar
* 'instancias' de templates, como neste exemplo
***************************************************************************/
private void testTemplates() {
printHeader("Teste 13: Testando o uso de templates");
print("Criando instancia de TemplatedClass<int>");
TemplatedClass_int templatedInstance = new TemplatedClass_int();
templatedInstance.setValue(13);
print("Definindo valor inteiro 13 e lendo: ",
templatedInstance.getValue());
print("Classe TemplatedClass<float> nao disponivel em java");
printFooter();
}
/*
****************************************************************************
* Testa heranca multipla
***************************************************************************/
private void testMultipleInheritance() {
printHeader("Teste 14: Testando heranca multipla");
print("Criando instancia de MultipleClass" +
" - subclasse de SomeClass e de RealClassCpp");
WrappedMultipleClass multipleInstance = new WrappedMultipleClass();
print("Chamando funcao herdada de SomeClass
em 5:" +
"\n multipleInstance.getFoo():
",
multipleInstance.getFoo());
print("Chamando funcao agregada de RealClassCpp em 7:" +
"\n multipleInstance.getAggregate().getFloat(): ",
multipleInstance.getAggregate().getFloat());
printFooter();
}
/*
****************************************************************************
* Testa uso de std::vectors e std::maps como listas
* e dicionarios nativos de java
* NOTA: A funcao add do vetor aparentemente nao estava alocando espaço,
* causando a funcao set(index, value) a gerar IndexOutOfRange. Foi feito
* um 'hack' em some_lib adicionando uma funcao em C++ addFloat(float)
* para resolver esse problema
***************************************************************************/
private void testStd() {
printHeader("Teste 15: Testando uso std::vectors e maps em java");
print("Criando instancia de StdClass" +
" - contendo membros std::vector e std::map");
StdClass stdInstance = new StdClass();
print("");
print("Adicionando valores 15.0 e 15.1 ao std::vector de C++," +
" usando 'hack' addFloat()");
stdInstance.addFloat(15.1f);
stdInstance.addFloat(15.2f);
print("Percorrendo vetor com size() e get():");
for (int i = 0; i < stdInstance.getFloat_vector().size(); i++) {
System.out.println(stdInstance.getFloat_vector().get(i));
}
print("");
print("Adicionando 15.2->\"Hello 15.2\" e
" usando set()");
stdInstance.getFloat2str_map().set(15.2f,
stdInstance.getFloat2str_map().set(15.3f,
print("Imprimindo os items do mapa usando
15.3->\"Hello 15.3\"," +
"Hello 15.2");
"Hello 15.3");
get()");
// TODO: std::strings nao estao sendo traduzidas corretamente (Oh, the pain!)
System.out.println(stdInstance.getFloat2str_map().get(15.2f));
System.out.println(stdInstance.getFloat2str_map().get(15.3f));
printFooter();
}
}
9.4.2. RealClassJava.java
import some_package.RealClassCpp;
/**
* SubClasse de RealClassCpp implementando metodo polimorfico a ser chamado
* de C++
*/
public class RealClassJava extends RealClassCpp {
public float getFloat() {
return ((RealClassCpp)this).getFloat() + 0.1f;
}
}
9.4.2. JavaCallable.java
import some_package.Callable;
/**
* SubClasse de Callable implementando classe polimorfica com metodo de callback
* a ser chamado a partir do C++
*/
public class JavaCallable extends Callable {
public float call(float parm) {
return parm + 0.2f;
}
}
9.5. Resultado dos testes de some_lib em python
some_lib_swig_tests.py
Testa em python as funcionalidades de some_lib exportadas pelo SWIG
Na maioria dos casos, um teste eh considerado bem sucedido se o valor
impresso for igual ao numero do teste sendo realizado, as vezes com
incrementos sucessivos de 0.1 entre sub-testes
Outros, pela sua natureza, sao bem sucedidos quanto algum erro
acontece durante o teste, como tentar modificar uma constante
================================================================================
Arvore dos membros exportados:
-------------------------------------------------------------------------------+ AbstractClass
- getFloat,
+ AdvancedClass
- average, callCallback, callPolyCallback, getValue, print_,
resetInt_Pointer, resetInt_Reference, resetInt_Value,
setCallback, setPolyCallback, setValue, throwException, wrapped_average,
+ AdvancedClass_average
+ AdvancedClass_print_
+ AdvancedClass_resetInt_Pointer
+ AdvancedClass_resetInt_Reference
+ AdvancedClass_resetInt_Value
+ AdvancedClass_wrapped_average
+ BLUE
+ Callable
- call,
+ Float2StrMap
- clear, has_key, items, keys, values,
+ FloatVector
- append, clear, pop,
+ GREEN
+ INT_ARRAY
- cast, frompointer,
+ INT_ARRAY_frompointer
+ MultipleClass
- foo, getBar, getFloat, getFoo, setFoo,
+ OtherClass
- foo, getBar, getFoo, setFoo,
+ RED
+ RealClassCpp
- getFloat,
+ SomeClass
- foo, getBar, getFoo, setFoo,
+ SomeClass_getBar
+ SomeException
- str,
+ SomeStruct
- struct_member,
+ StdClass
- float2str_map, float_vector,
+ TemplatedClass_int
- getValue, setValue,
+ big
+ callGetFloat
+ const_int
+ cvar
+ increment_callback
- capitalize, center, count, decode, encode, endswith, expandtabs, find,
index, isalnum, isalpha, isdigit, islower,
isspace, istitle, isupper, join, ljust, lower, lstrip, replace, rfind, rindex,
rjust, rsplit, rstrip, split, splitlines
, startswith, strip, swapcase, title, translate, upper, zfill,
+ looseFunction
+ medium
+ small
+ types
- BooleanType, BufferType, BuiltinFunctionType, BuiltinMethodType,
ClassType, CodeType, ComplexType, DictProxyType,
DictType, DictionaryType, EllipsisType, FileType, FloatType, FrameType,
FunctionType, GeneratorType, InstanceType, IntT
ype, LambdaType, ListType, LongType, MethodType, ModuleType, NoneType,
NotImplementedType, ObjectType, SliceType, String
Type, StringTypes, TracebackType, TupleType, TypeType, UnboundMethodType,
UnicodeType, XRangeType,
+ weakref_proxy
================================================================================
________________________________________________________________________________
================================================================================
Testando conceitos basicos de C estruturado:
Variaveis globais, funcoes, structs, etc.
-------------------------------------------------------------------------------================================================================================
Teste 1: Testando leitura e escrita em variaveis C globais de diferentes tipos
--------------------------------------------------------------------------------
Lendo
Lendo
Lendo
Lendo
Lendo
Lendo
variavel inteira
variavel ponto flutuante simples
variavel ponto flutuante double
variavel caracter
string (null terminated chars)
array de inteiros
base_int:
base_float:
base_double:
base_char:
base_string:
int_array:
1
1.0
1.0
1
1
1 2 3 4 5
Alterando valor de base_float para 1.1
Lendo variavel ponto flutuante simples base_float:
1.10000002384
================================================================================
================================================================================
Teste 2: Testando leitura de #defines e enums, e acesso ilegal a constantes
-------------------------------------------------------------------------------Lendo enum size some_size:
2 (big)
Lendo constante #define RED: 0xff0000
Testando escrita ilegal em constante const_int:
TypeError: Variable const_int is read-only.
================================================================================
================================================================================
Teste 3: Testando chamadas a funcoes C
-------------------------------------------------------------------------------Chamando funcao looseFunction: 3
================================================================================
================================================================================
Teste 4: Testando utilizacao de structs
-------------------------------------------------------------------------------Criando struct SomeStruct e acessando membro struct_member: 4
================================================================================
________________________________________________________________________________
================================================================================
Testando conceitos basicos de C++ orientado a objetos:
Classes, heranca, polimorfismo, etc.
-------------------------------------------------------------------------------================================================================================
Teste 5: Testando utilizacao de classes:
Funcoes e atributos, de instancia e de classe, publicos e privados
-------------------------------------------------------------------------------Criando instancia de SomeClass - some_instance
Chamando funcao
some_instance.getFoo():
5.0
Alterando foo para 5.1 chamando some_instance.setFoo(5.1)
Lendo atributo publico
some_instance.foo:
5.09999990463
Chamando funcao de classe
SomeClass_getBar():
5
Chamando funcao privada
some_instance.getPrivate():
AttributeError: getPrivate
================================================================================
================================================================================
Teste 6: Testando conceitos basicos de heranca
-------------------------------------------------------------------------------Criando instancia de OtherClass (subclasse de SomeClass) - other_instance
Lendo antiga variavel nao modificada other_instance.foo:
5.0
Chamando funcao reimplementada
other_instance.getFoo(): 6.0
================================================================================
================================================================================
Teste 7: Testando classes abstratas e polimorfismo
-------------------------------------------------------------------------------Criando instancia de classe abstrata AbstractClass:
RuntimeError: No constructor defined
Definindo RealClassPython (subclasse de RealClassCpp) em python
Criando instancias de subclasses RealClassCpp e RealClassPython
callGetFloat => funcao em C++, chama getFloat de uma instancia de AbstractClass
Chamando callGetFloat(real_instance_cpp):
7.0
Chamando callGetFloat(real_instance_python): 7.09999990463
================================================================================
________________________________________________________________________________
================================================================================
Testando conceitos avancados:
Templates, heranca multipla, callbacks, operadores, etc...
-------------------------------------------------------------------------------================================================================================
Teste 8: Testando diferentes tipos de referencia
(por valor, ponteiro ou referencia)
-------------------------------------------------------------------------------Criando variavel inteira com valor 8
Chamando funcao que tenta zerar variavel por valor
Retorno da chamada de AdvancedClass_resetInt_Value(int_var):
8
Criando variavel inteira com valor 8
Chamando funcao que tenta zerar variavel por ponteiro
Retorno da chamada de AdvancedClass_resetInt_Pointer(int_var):
(8, 0)
Criando variavel inteira com valor 8
Chamando funcao que tenta zerar variavel por referencia
Retorno da chamada de AdvancedClass_resetInt_Reference(int_var): (8, 0)
================================================================================
================================================================================
Teste 9: Testando argumentos padroes e argumentos multiplos
-------------------------------------------------------------------------------Chamando funcao print_ com argumento " Teste 9":
Teste 9
Chamando funcao print_ sem argumentos:
Hello World
Chamando wrapped_average(1, 2):
1.5
Chamando wrapped_average(1, 2, 3, 4): 2.5
Chamando wrapped_average(1, 2, 3, 4, 5, 6) - nao exportada:
TypeError: No matching function for overloaded 'AdvancedClass_wrapped_average'
================================================================================
================================================================================
Teste 10: Testando o uso de callbacks
-------------------------------------------------------------------------------Criando instancia de advanced class com valor 10
Definindo callback como sendo funcao C++ definida no arquivo .i
Requisitando chamada aa funcao de callback: 10.1000003815
Definindo classe PythonCallable (subclasse de Callable) em python
Definindo o callback polimorfico como sendo uma instancia de PythonCallable
Requisitando chamada aa funcao de callback polimorfico: 10.1999998093
================================================================================
================================================================================
Teste 11: Testando o uso de sobrecarga de operadores
-------------------------------------------------------------------------------Criando uma instancia de AdvancedClass com valor 5 e outra com 6
advanced_result = advanced_instance_5 + advanced_instance_6
Valor de advanced_result.getValue(): 11.0
================================================================================
================================================================================
Teste 12: Testando o uso de excecoes
-------------------------------------------------------------------------------Forcando SomeException a ser jogada em C++, para trata-la em python:
StandardError catched: new_AdvancedClass() takes exactly 1 argument (0 given)
================================================================================
================================================================================
Teste 13: Testando o uso de templates
-------------------------------------------------------------------------------Criando instancia de TemplatedClass<int>
Definindo valor inteiro 13 e lendo: 13
Criando instancia de TemplatedClass<float> - nao exportada
AttributeError: 'module' object has no attribute 'TemplatedClass_float'
================================================================================
================================================================================
Teste 14: Testando heranca multipla
-------------------------------------------------------------------------------Criando instancia de MultipleClass - subclasse de SomeClass e de RealClassCpp
Chamando funcao herdada de SomeClass
em 5: multiple_instance.getFoo():
5.0
Chamando funcao herdada de RealClassCpp em 7: multiple_instance.getFloat(): 7.0
================================================================================
================================================================================
Teste 15: Testando std::vectors e maps como listas e mapas nativos de python
-------------------------------------------------------------------------------Criando instancia de StdClass - contendo membros std::vector e std::map
Adicionando valores 15.0 e 15.1 ao std::vector de C++, com sintaxe python
Percorrendo vetor com sintaxe python:
for item in std_instance.float_vector: print item
15.0
15.1000003815
Adicionando ao std::map com sintaxe python:
map[15.2] = "Hello 15.2"
map[15.3] = "Hello 15.3"
Imprimindo items() do mapa - como em um dicionario python:
[(15.199999809265137, 'Hello 15.2'), (15.300000190734863, 'Hello 15.3')]
================================================================================
9.6. Resultado dos testes de some_lib em java
some_lib_JavaTests.java
Testa em java funcionalidades de some_lib exportadas pelo SWIG
Na maioria dos casos, um teste eh considerado bem sucedido se o
valor impresso for igual ao numero do teste sendo realizado,
as vezes com incrementos sucessivos de 0.1 entre sub-testes
Outros, pela sua natureza, sao bem sucedidos quanto algum erro
acontece durante o teste, como tentar modificar uma constante
================================================================================
________________________________________________________________________________
================================================================================
Testando conceitos basicos de C estruturado:
Variaveis globais, funcoes, structs, etc.
-------------------------------------------------------------------------------================================================================================
Teste 1: Testando leitura e escrita em variaveis C globais de diferentes tipos
-------------------------------------------------------------------------------Lendo variavel inteira
base_int:
Lendo variavel ponto flutuante simples base_float:
1
1.0
Lendo variavel ponto flutuante double
base_double: 1.0
Lendo variavel caracter
base_char:
Lendo string (null terminated chars)
base_string: 1
Lendo array de inteiros
int_array:
1
1 2 3 4 5
Alterando valor de base_float para 1.1
Lendo variavel ponto flutuante simples base_float:
1.1
================================================================================
================================================================================
Teste 2: Testando leitura de #defines e enums, e acesso ilegal a constantes
-------------------------------------------------------------------------------Lendo enum size some_size:
2 (big)
Lendo constante #define RED: ff0000
================================================================================
================================================================================
Teste 3: Testando chamadas a funcoes C
-------------------------------------------------------------------------------Chamando funcao looseFunction: 3
================================================================================
================================================================================
Teste 4: Testando utilizacao de structs
-------------------------------------------------------------------------------Criando struct SomeStruct e acessando membro struct_member: 4
================================================================================
________________________________________________________________________________
================================================================================
Testando conceitos basicos de C++ orientado a objetos:
Classes, heranca, polimorfismo, etc.
-------------------------------------------------------------------------------================================================================================
Teste 5: Testando utilizacao de classes
-------------------------------------------------------------------------------Criando instancia de SomeClass - some_instance
Chamando funcao
some_instance.getFoo():
5.0
Alterando foo para 5.1 chamando some_instance.setFoo(5.1):
Lendo atributo publico
some_instance.getFoo_attr(): 5.1
Chamando funcao de classe
SomeClass.getBar():
5
================================================================================
================================================================================
Teste 6: Testando conceitos basicos de heranca
-------------------------------------------------------------------------------Criando instancia de OtherClass (subclasse de SomeClass)
Lendo antiga variavel nao modificada otherInstance.getFoo_attr():5.0
Chamando funcao reimplementada
otherInstance.getFoo():
6.0
================================================================================
================================================================================
Teste 7: Testando classes abstratas e polimorfismo
-------------------------------------------------------------------------------Criando instancias de subclasses RealClassCpp e RealClassJava
callGetFloat => funcao em C++, chama getFloat de uma instancia de AbstractClass
Chamando callGetFloat(realInstanceCpp):
7.0
Chamando callGetFloat(realInstanceJava): 7.0
================================================================================
________________________________________________________________________________
================================================================================
Testando conceitos avancados:
Templates, heranca multipla, callbacks, operadores, etc.
-------------------------------------------------------------------------------================================================================================
Teste 8: Testando diferentes tipos de referencia
(por valor, ponteiro ou referencia)
-------------------------------------------------------------------------------Criando um array de apenas um inteiro com valor 8
Chamando funcao que tenta zerar variavel por valor
Valor de intArray[0]: 8
Criando um array de apenas um inteiro com valor 8
Chamando funcao que tenta zerar variavel por ponteiro
Valor de intArray[0]: 0
Criando um array de apenas um inteiro com valor 8
Chamando funcao que tenta zerar variavel por referencia
Valor de intArray[0]: 0
================================================================================
================================================================================
Teste 9: Testando argumentos padrao e argumentos multiplos
-------------------------------------------------------------------------------Chamando funcao print_ com argumento "
Teste 9":
Teste 9
Funcao print_ sem argumentos indisponivel em java
Chamando wrapped_average(1, 2):
1.5
Chamando wrapped_average(1, 2, 3, 4): 2.5
Funcao wrapped_average(1, 2, 3, 4, 5, 6) nao disponivel em java
================================================================================
================================================================================
Teste 10: Testando o uso de callbacks
-------------------------------------------------------------------------------Criando instancia de advanced class com valor 10
Definindo callback como sendo funcao C++ definida no arquivo .i
Requisitando chamada aa funcao de callback:
10.1
Definindo o callback polimorfico como sendo uma instancia de JavaCallable
Requisitando chamada aa funcao de callback polimorfico: 0.0
================================================================================
================================================================================
Teste 11: Testando o uso de sobrecarga de operadores
-------------------------------------------------------------------------------Criando uma instancia de AdvancedClass com valor 5 e outra com 6
advancedResult = advanced_instance_5 + advanced_instance_6 (using renamed add)
Valor de advancedResult.getValue(): 11.0
================================================================================
================================================================================
Teste 12: Testando o uso de excecoes
-------------------------------------------------------------------------------Forcando SomeException a ser jogada em C++, tratando-a em java:
================================================================================
================================================================================
Teste 13: Testando o uso de templates
-------------------------------------------------------------------------------Criando instancia de TemplatedClass<int>
Definindo valor inteiro 13 e lendo: 13
Classe TemplatedClass<float> nao disponivel em java
================================================================================
================================================================================
Teste 14: Testando heranca multipla
--------------------------------------------------------------------------------
Criando instancia de MultipleClass - subclasse de SomeClass e de RealClassCpp
Chamando funcao herdada
de SomeClass
em 5:
multipleInstance.getFoo():
5.0
Chamando funcao agregada de RealClassCpp em 7:
multipleInstance.getAggregate().getFloat(): 7.0
================================================================================
================================================================================
Teste 15: Testando uso std::vectors e maps em java
-------------------------------------------------------------------------------Criando instancia de StdClass - contendo membros std::vector e std::map
Adicionando valores 15.0 e 15.1 ao std::vector de C++, usando 'hack' addFloat()
Percorrendo vetor com size() e get():
15.1
15.2
Adicionando 15.2->"Hello 15.2" e 15.3->"Hello 15.3", usando set()
Imprimindo os items do mapa usando get()
[email protected]
[email protected]
================================================================================
9.7. Interface Pyste + Boost.Python para some_lib
9.7.1. some_lib_boost_interface.pyste
# TODO: acessar arrays como python lists
#int_array = Var('int_array', 'some_lib.h')
# Exporting global wrappers:
Function('set_base_int',
'some_lib_adapter_code.h')
Function('get_base_int',
'some_lib_adapter_code.h')
Function('set_base_float', 'some_lib_adapter_code.h')
Function('get_base_float', 'some_lib_adapter_code.h')
Function('set_base_double', 'some_lib_adapter_code.h')
Function('get_base_double', 'some_lib_adapter_code.h')
Function('set_base_char',
'some_lib_adapter_code.h')
Function('get_base_char',
'some_lib_adapter_code.h')
# Functions returning pointers must have explicit policy defined:
Function('set_base_string', 'some_lib_adapter_code.h')
f = Function('get_base_string', 'some_lib_adapter_code.h')
set_policy(f, return_value_policy(return_opaque_pointer))
Enum('size',
'some_lib.h')
Var ('some_size', 'some_lib.h')
Var ('const_int', 'some_lib.h')
Function('looseFunction', 'some_lib.h')
Function('callGetFloat', 'some_lib.h')
Class('SomeStruct',
Class('SomeClass',
Class('OtherClass',
Class('AbstractClass',
Class('RealClassCpp',
Class('Callable',
Class('MultipleClass',
Class('StdClass',
'some_lib.h')
'some_lib.h')
'some_lib.h')
'some_lib.h')
'some_lib.h')
'some_lib.h')
'some_lib.h')
'some_lib.h')
c = Class('AdvancedClass', 'some_lib.h')
exclude(c.average)
# Wrapper went nuts with variable arguments...
# TODO: Try to get callbacks working
exclude(c.setCallback)
Function('wrapped_average',
'some_lib_adapter_code.h')
Function('increment_callback', 'some_lib_adapter_code.h')
T = Template("TemplatedClass", "some_lib.h")
T('int', 'TemplatedClass_int')
9.7.2. some_lib_adapter_code.h
/*******************************************************************************
* File: some_lib_adapter_code.py
* Codigo adaptador para exportar as funcionalidades de some_lib, contornando
* as limitacoes da Boost.Python ou do Pyste.
******************************************************************************/
#include <string.h>
#include <some_lib.h>
int
get_base_int
()
float get_base_float ()
double get_base_double()
char
get_base_char ()
char *get_base_string()
void
void
void
void
void
{
{
{
{
{
return
return
return
return
return
base_int;
base_float;
base_double;
base_char;
base_string;
set_base_int
(int
value)
set_base_float (float value)
set_base_double(double value)
set_base_char (char
value)
set_base_string(char *value)
{
{
{
{
{
}
}
}
}
}
base_int
= value; }
base_float = value; }
base_double = value; }
base_char
= value; }
strcpy(base_string, value); }
double wrapped_average(double a) {
return AdvancedClass::average(a, -1.0); }
double wrapped_average(double a, double b) {
return AdvancedClass::average(a, b, -1.0); }
double wrapped_average(double a, double b, double c) {
return AdvancedClass::average(a, b, c, -1.0); }
double wrapped_average(double a, double b, double c, double d) {
return AdvancedClass::average(a, b, c, d, -1.0); }
float increment_callback(float value) { return value + 0.1f; }
9.7.3. pyste_run.sh
SOME_LIB_DIR=C:/Projetos/Relatorio/some_lib
INCLUDE_DIRS=${SOME_LIB_DIR}/include
INTERFACE_FILE=some_lib_boost_interface.pyste
OUTPUT_FILE=some_lib_boost_wrapper.cpp
OUTPUT_DIR=some_lib_wrappers
echo "Creating python boost wrapper code"
python C:\\Python24\\Scripts\\pyste.py --module=some_lib_boost -out=${OUTPUT_FILE} -I ${INCLUDE_DIRS} ${INTERFACE_FILE}
mv *.cpp ${OUTPUT_DIR}
echo "Done"
9.7.2. some_lib_boost_wrapper.cpp
// Boost Includes ==============================================================
#include <boost/python.hpp>
#include <boost/cstdint.hpp>
// Includes ====================================================================
#include <some_lib.h>
#include <some_lib_adapter_code.h>
// Using =======================================================================
using namespace boost::python;
// Declarations ================================================================
BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID(char)
namespace
{
struct AbstractClass_Wrapper: AbstractClass
{
float getFloat() {
return call_method< float >(py_self, "getFloat");
}
PyObject* py_self;
};
struct RealClassCpp_Wrapper: RealClassCpp
{
RealClassCpp_Wrapper(PyObject* py_self_):
RealClassCpp(), py_self(py_self_) {}
float getFloat() {
return call_method< float >(py_self, "getFloat");
}
float default_getFloat() {
return RealClassCpp::getFloat();
}
PyObject* py_self;
};
struct Callable_Wrapper: Callable
{
Callable_Wrapper(PyObject* py_self_):
Callable(), py_self(py_self_) {}
float call(float p0) {
return call_method< float >(py_self, "call", p0);
}
float default_call(float p0) {
return Callable::call(p0);
}
PyObject* py_self;
};
BOOST_PYTHON_FUNCTION_OVERLOADS(AdvancedClass_print_overloads_0_1,
AdvancedClass::print_, 0, 1)
}// namespace
// Module ======================================================================
BOOST_PYTHON_MODULE(some_lib_boost)
{
def("set_base_int", &set_base_int);
def("get_base_int", &get_base_int);
def("set_base_float", &set_base_float);
def("get_base_float", &get_base_float);
def("set_base_double", &set_base_double);
def("get_base_double", &get_base_double);
def("set_base_char", &set_base_char);
def("get_base_char", &get_base_char);
def("set_base_string", &set_base_string);
def("get_base_string", &get_base_string, return_value_policy<
return_opaque_pointer >());
enum_< size >("size")
.value("small", small)
.value("big", big)
.value("medium", medium)
;
scope().attr("some_size") = some_size;
scope().attr("const_int") = const_int;
def("looseFunction", &looseFunction);
def("callGetFloat", &callGetFloat);
class_< SomeStruct, boost::noncopyable >("SomeStruct", init<
>())
.def_readwrite("struct_member", &SomeStruct::struct_member)
;
class_< SomeClass, boost::noncopyable >("SomeClass", init<
>())
.def_readwrite("foo", &SomeClass::foo)
.def("getFoo", &SomeClass::getFoo)
.def("setFoo", &SomeClass::setFoo)
.def("getBar", &SomeClass::getBar)
.staticmethod("getBar")
;
class_< OtherClass, bases< SomeClass > , boost::noncopyable >("OtherClass",
init<
>())
.def("getFoo", &OtherClass::getFoo)
;
class_< AbstractClass, boost::noncopyable, AbstractClass_Wrapper
>("AbstractClass", no_init)
.def("getFloat", pure_virtual(&AbstractClass::getFloat))
;
class_< RealClassCpp, bases< AbstractClass > , boost::noncopyable,
RealClassCpp_Wrapper >("RealClassCpp", init<
>())
.def("getFloat", (float (RealClassCpp::*)() )&RealClassCpp::getFloat,
(float (RealClassCpp_Wrapper::*)())&RealClassCpp_Wrapper::default_getFloat)
;
class_< Callable, boost::noncopyable, Callable_Wrapper >("Callable", init<
>())
.def("call", &Callable::call, &Callable_Wrapper::default_call)
;
class_< MultipleClass, bases< SomeClass, RealClassCpp > , boost::noncopyable
>("MultipleClass", init<
>())
;
class_< StdClass, boost::noncopyable >("StdClass", init<
>())
;
class_< AdvancedClass, boost::noncopyable >("AdvancedClass", init< float
>())
.def("setValue", &AdvancedClass::setValue)
.def("getValue", &AdvancedClass::getValue)
.def("resetInt_Value", &AdvancedClass::resetInt_Value)
.def("resetInt_Pointer", &AdvancedClass::resetInt_Pointer)
.def("resetInt_Reference", &AdvancedClass::resetInt_Reference)
.def("print_", &AdvancedClass::print_,
AdvancedClass_print_overloads_0_1())
.def("callCallback", &AdvancedClass::callCallback)
.def("setPolyCallback", &AdvancedClass::setPolyCallback)
.def("callPolyCallback", &AdvancedClass::callPolyCallback)
.def("throwException", &AdvancedClass::throwException)
.staticmethod("resetInt_Value")
.staticmethod("resetInt_Reference")
.staticmethod("print_")
.staticmethod("resetInt_Pointer")
.def( self + self )
;
def("wrapped_average", (double (*)(double))&wrapped_average);
def("wrapped_average", (double (*)(double, double))&wrapped_average);
def("wrapped_average", (double (*)(double, double,
double))&wrapped_average);
def("wrapped_average", (double (*)(double, double, double,
double))&wrapped_average);
def("increment_callback", &increment_callback);
class_< TemplatedClass<int>, boost::noncopyable >("TemplatedClass_int",
init<
>())
.def("setValue", &TemplatedClass<int>::setValue)
.def("getValue", &TemplatedClass<int>::getValue)
;
}
9.8. Código fonte: testes de some_lib com Boost.Python
9.8.1. some_lib_boost_tests.py
#*******************************************************************************
# File: some_lib_boost_tests.py
# Testa em python as funcionalidades de some_lib exportadas pelo SWIG
# Ver arquivo de interface some_lib_swig_interface.i
#*******************************************************************************
import some_lib_boost
#*******************************************************************************
# Imprime todos os membros de root, comecando com identacao ident, percorrendo
# a arvore ateh o nivel indicado por sub_lvel.
# Ignora membros que iniciem por '_', ou terminem com 'Ptr'
# Os nos folha sao impressos na mesma linha
#*******************************************************************************
def print_tree(root, ident, sub_level):
if sub_level == 1:
str = ''
for entry in dir(root):
if (entry.startswith('_')
or
entry.startswith('func_') or
entry.endswith('Ptr')):
continue
str += entry + ', '
if len(str) > 0:
print' ' * ident + ' - ' + str
return
for entry in dir(root):
if entry.startswith('_') or entry.endswith('Ptr'):
continue
print ' ' * ident, '+', entry
entry = getattr(root, entry)
print_tree(entry, ident + 2, sub_level - 1)
#*******************************************************************************
# Helper printing functions
#*******************************************************************************
def print_header(string):
print
print
'===============================================================================
='
print string
print '-------------------------------------------------------------------------------'
def print_footer():
print
'===============================================================================
='
def print_spearator():
print
print
'_______________________________________________________________________________
_'
print
#*******************************************************************************
# Imprime cabecalho e a arvore dos membros exportados de some_lib
#*******************************************************************************
def print_start():
print
print 'some_lib_tests.py'
print 'Testa as funcionalidades de some_lib exportadas pela Boost.Python'
print
print 'Na maioria dos casos, um teste eh considerado bem sucedido se o valor'
print 'impresso for igual ao numero do teste sendo realizado, as vezes com'
print 'incrementos sucessivos de 0.1 entre sub-testes'
print 'Outros, pela sua natureza, sao bem sucedidos quanto algum erro'
print 'acontece durante o teste, como tentar modificar uma constante'
print_header('Arvore dos membros exportados:')
print_tree(some_lib_boost, 2, 2)
print_footer()
print
#*******************************************************************************
# Testa leitura e escrita em variaveis globais de some_lib, com tipos variados
# de dados
# Nota: Variaveis globais exportadas pela Boost sao somente leitura.
# Modificacoes em seu valor serao vistas em python mas nao em C++. Se for
# necessario modifica-las em C++, exportar funcoes de acesso, como fizemos aqui.
#*******************************************************************************
def test_globals():
print_header('Teste 1: Testando leitura e escrita em variaveis C' +
' globais de diferentes tipos')
print 'Lendo variavel inteira
base_int:
', \
some_lib_boost.get_base_int()
print 'Lendo variavel ponto flutuante simples base_float:
', \
some_lib_boost.get_base_float()
print 'Lendo variavel ponto flutuante double
base_double: ', \
some_lib_boost.get_base_double()
print 'Lendo variavel caracter
base_char:
', \
some_lib_boost.get_base_char()
# TODO: Tentar acessar C char* como python string
print 'Lendo string (null terminated chars)
base_string: ', \
some_lib_boost.get_base_string()
# TODO: Tentar acessar C array como python list
#
array = some_lib_boost.int_array
#
print 'Lendo array de inteiros
#
int_array:
array[0], array[1], array[2], array[3], array[4]
print
print 'Alterando valor de base_float para 1.1'
some_lib_boost.set_base_float(1.1)
', \
print 'Lendo variavel ponto flutuante simples base_float:
', \
some_lib_boost.get_base_float()
print_footer()
#*******************************************************************************
# Testa leitura de #defines e enums, e acesso ilegal a constantes
#*******************************************************************************
def test_constants():
print_header('Teste 2: Testando leitura de #defines e enums,' +
' e acesso ilegal a constantes')
print 'Lendo enum size some_size:
', some_lib_boost.some_size
# TODO: check if this can be exported
#
print 'Lendo constante #define RED: ', hex(some_lib_boost.RED)
print 'Testando escrita ilegal em constante const_int:'
try:
# TODO: Ver se nao teria como levantar uma excecao com isso
some_lib_boost.const_int = 2
print '
Escrita em const realizada em python, mas nao propagada para C++'
except TypeError, value:
print '
TypeError:', value
print_footer()
#*******************************************************************************
# Testa chamadas a funcoes
#*******************************************************************************
def test_functions():
print_header('Teste 3: Testando chamadas a funcoes C')
print 'Chamando funcao looseFunction: ', some_lib_boost.looseFunction()
print_footer()
#*******************************************************************************
# Testa uso de structs
# NOTA: Construtores de structs e classes nao sao exportados automaticamente
# pelo Pyste, eh necessario criar o construtor explicitamente,
# ou fazer uma classe wrapper se nao for possivel mexer no
# codigo original da lib sendo exportada
#*******************************************************************************
def test_structs():
print_header('Teste 4: Testando utilizacao de structs')
struct = some_lib_boost.SomeStruct()
print 'Criando struct SomeStruct e acessando membro struct_member: ', \
struct.struct_member
print_footer()
#*******************************************************************************
# Testa uso de classes:
# Funcoes e atributos, de instancia e de classe, publicos e privados
#*******************************************************************************
def test_classes():
print_header('Teste 5: Testando utilizacao de classes: ' +
'\n\t Funcoes e atributos, de instancia e de classe, publicos e privados')
print 'Criando instancia de SomeClass - some_instance'
some_instance = some_lib_boost.SomeClass()
print 'Chamando funcao
some_instance.getFoo():
', \
some_instance.getFoo()
print 'Alterando foo para 5.1 chamando some_instance.setFoo(5.1)'
some_instance.setFoo(5.1)
print 'Lendo atributo publico
some_instance.foo:
', \
SomeClass.getBar():
', \
some_instance.foo
print
print 'Chamando funcao de classe
some_lib_boost.SomeClass.getBar()
try:
print 'Chamando funcao privada
some_instance.getPrivate():', \
some_instance.getPrivate()
except AttributeError, value:
print '\n
AttributeError:', value
print_footer()
#*******************************************************************************
# Testa conceitos basicos de heranca
#*******************************************************************************
def test_inheritance():
print_header('Teste 6: Testando conceitos basicos de heranca')
print 'Criando instancia de OtherClass (subclasse de SomeClass)'
other_instance = some_lib_boost.OtherClass()
print 'Lendo antiga variavel nao modificada other_instance.foo:
', \
other_instance.foo
print 'Chamando funcao reimplementada
other_instance.getFoo():', \
other_instance.getFoo()
print_footer()
#*******************************************************************************
# Testa classes abstratas e polimorfismo
# Nota: Atravez do polimorfismo pode-se chamar codigo python a partir de C++,
# como eh feito neste exemplo
#*******************************************************************************
def test_polimorphysm():
print_header('Teste 7: Testando classes abstratas e polimorfismo')
print 'Criando instancia de classe abstrata AbstractClass:'
try:
abstract_instance = some_lib_boost.AbstractClass()
except RuntimeError, value:
print '
RuntimeError:', value
print
print 'Definindo RealClassPython (subclasse de RealClassCpp) em python'
class RealClassPython(some_lib_boost.RealClassCpp):
def __init__(self):
some_lib_boost.RealClassCpp.__init__(self)
def getFloat(self):
return some_lib_boost.RealClassCpp.getFloat(self) + 0.1
print 'Criando instancias de subclasses RealClassCpp e RealClassPython'
real_instance_cpp
= some_lib_boost.RealClassCpp()
real_instance_python = RealClassPython()
print 'callGetFloat => funcao em C++,',\
'chama getFloat de uma instancia de AbstractClass'
print
print 'Chamando callGetFloat(real_instance_cpp):
', \
some_lib_boost.callGetFloat(real_instance_cpp)
print 'Chamando callGetFloat(real_instance_python):', \
some_lib_boost.callGetFloat(real_instance_python)
print_footer()
#*******************************************************************************
# Testa diferentes tipos de referencia
#*******************************************************************************
def test_references():
print_header('Teste 8: Testando diferentes tipos de referencia' +
'\n\t (por valor, ponteiro ou referencia)')
print 'Criando variavel inteira com valor 8'
int_var = 8
print 'Chamando funcao que tenta zerar variavel por valor'
print 'Retorno da chamada de AdvancedClass.resetInt_Value(int_var):
', \
some_lib_boost.AdvancedClass.resetInt_Value(int_var)
# TODO: How to access int* and int& # Boost.Python.ArgumentError:
#
Python argument types in AdvancedClass.resetInt_Pointer(int)
# did not match C++ signature: resetInt_Pointer(int *)
print
print 'Criando variavel inteira com valor 8'
int_var = 8
print 'Chamando funcao que tenta zerar variavel por ponteiro'
#
#
print 'Retorno da chamada de AdvancedClass.resetInt_Pointer(int_var):
', \
some_lib_boost.AdvancedClass.resetInt_Pointer(int_var)
print
print 'Criando variavel inteira com valor 8'
int_var = 8
print 'Chamando funcao que tenta zerar variavel por referencia'
#
#
print 'Retorno da chamada de AdvancedClass.resetInt_Reference(int_var):', \
some_lib_boost.AdvancedClass.resetInt_Reference(int_var)
print_footer()
#*******************************************************************************
# Testa argumentos padroes e argumentos multiplos
# NOTA: Python nao usa o conceito de argumentos variaveis porque usa tuplas,
# entao funcoes com varios argumentos deve ter 'instancias' com um
# numero pre-determinado de argumentos e tipos exportados, como no nosso
exemplo.
#*******************************************************************************
def test_arguments():
print_header('Teste 9: Testando argumentos padroes e argumentos multiplos')
print 'Chamando funcao print_ com argumento "
some_lib_boost.AdvancedClass.print_("
Teste 9":'
Teste 9")
print 'Chamando funcao print_ sem argumentos:'
some_lib_boost.AdvancedClass.print_()
print
print 'Chamando wrapped_average(1, 2):
', \
some_lib_boost.wrapped_average(1, 2)
print 'Chamando wrapped_average(1, 2, 3, 4): ', \
some_lib_boost.wrapped_average(1, 2, 3, 4)
try:
print 'hamando wrapped_average(1, 2, 3, 4, 5, 6) - nao exportada:', \
some_lib_boost.wrapped_average(1, 2, 3, 4, 5, 6)
except TypeError, value:
print '\n
TypeError:', value
print_footer()
#*******************************************************************************
# Testa o uso de callbacks
# NOTA: Callbacks podem
ser feitos em C++, dentro da propria interface,
# ou pode-se utilizar Polimorfismo para chama-los em Python. Este exemplo mostra
# as duas alternativas
#*******************************************************************************
def test_callbacks():
print_header('Teste 10: Testando o uso de callbacks')
print 'Criando instancia de advanced class com valor 10'
advanced_instance = some_lib_boost.AdvancedClass(10)
print 'Definindo callback como sendo funcao C++ definida no arquivo .i'
# TODO: Try to fix callbacks calling
#
advanced_instance.setCallback(some_lib_boost.increment_callback)
#
print 'Requisitando chamada aa funcao de callback:',
#
advanced_instance.callCallback()
print
print 'Definindo classe PythonCallable (subclasse de Callable) em python'
class PythonCallable(some_lib_boost.Callable):
def __init__(self):
some_lib_boost.Callable.__init__(self)
def call(self, parm):
return parm + 0.2
print 'Definindo o callback polimorfico como sendo', \
'uma instancia de PythonCallable'
python_callback = PythonCallable()
advanced_instance.setPolyCallback(python_callback)
print 'Requisitando chamada aa funcao de callback polimorfico:', \
advanced_instance.callPolyCallback()
print_footer()
#*******************************************************************************
# Testa o uso de sobrecarga de operadores
#*******************************************************************************
def test_operators():
print_header('Teste 11: Testando o uso de sobrecarga de operadores')
print 'Criando uma instancia de AdvancedClass com valor 5 e outra com 6'
advanced_instance_5 = some_lib_boost.AdvancedClass(5)
advanced_instance_6 = some_lib_boost.AdvancedClass(6)
print 'advanced_result = advanced_instance_5 + advanced_instance_6'
# TODO: Not working - try to fix operator overload
try:
advanced_result = advanced_instance_5 + advanced_instance_6
print 'Valor de advanced_result.getValue():', advanced_result.getValue()
except:
print '
Error calling overloaded operator +'
print_footer()
#*******************************************************************************
# Testa o uso de templates
# NOTA: Como nao existe o conceito de templates em python, precisamos criar
# 'instancias' de templates, como neste exemplo
#*******************************************************************************
def test_templates():
print_header('Teste 12: Testando o uso de templates')
print 'Criando instancia de TemplatedClass<int>'
templated_instance = some_lib_boost.TemplatedClass_int()
templated_instance.setValue(12)
print 'Definindo valor inteiro 12 e lendo:', templated_instance.getValue()
print 'Criando instancia de TemplatedClass<float> - nao exportada'
try:
templated_instance = some_lib_boost.TemplatedClass_float()
except AttributeError, value:
print '
AttributeError:', value
print_footer()
#*******************************************************************************
# Testa heranca multipla
#*******************************************************************************
def test_multiple_inheritance():
print_header('Teste 13: Testando heranca multipla')
print 'Criando instancia de MultipleClass',\
' - subclasse de SomeClass e de RealClassCpp'
multiple_instance = some_lib_boost.MultipleClass()
print 'Chamando funcao herdada de SomeClass
' multiple_instance.getFoo():
em 5:' + \
', multiple_instance.getFoo()
print 'Chamando funcao herdada de RealClassCpp em 7:' + \
' multiple_instance.getFloat():', multiple_instance.getFloat()
print_footer()
#*******************************************************************************
# Testa uso de std::vectors e std::maps
# como listas e dicionarios nativos de python
#*******************************************************************************
def test_std():
print_header('Teste 14: Testando std::vectors e maps' +\
' como listas e mapas nativos de python')
print 'Criando instancia de StdClass' + \
' - contendo membros std::vector e std::map'
std_instance = some_lib_boost.StdClass()
print
print 'Adicionando valores 14.0 e 14.1 ao std::vector de C++,', \
'com sintaxe python'
# TODO: Compilacao do wrapper se perde se deixarmos std headers em some_lib.h
#
std_instance.float_vector.append(14.0)
#
std_instance.float_vector.append(14.1)
print 'Percorrendo vetor com sintaxe python:'
print '
#
for item in std_instance.float_vector: print item'
for item in std_instance.float_vector: print item
print
print 'Adicionando ao std::map com sintaxe python:'
print '
map[14.2] = "Hello 14.2"'
print '
map[14.3] = "Hello 14.3"'
#
std_instance.float2str_map[14.2] = 'Hello 14.2'
#
std_instance.float2str_map[14.3] = 'Hello 14.3'
print 'Imprimindo items() do mapa - como em um dicionario python:'
#
print std_instance.float2str_map.items()
print_footer()
#*******************************************************************************
# MAIN
#*******************************************************************************
print_start()
print_spearator()
print_header('Testando conceitos basicos de C estruturado:' +
'\nVariaveis globais, funcoes, structs, etc.')
test_globals()
test_constants()
test_functions()
test_structs()
print_spearator()
print_header('Testando conceitos basicos de C++ orientado a objetos:' +
'\nClasses, heranca, polimorfismo, etc.')
test_classes()
test_inheritance()
test_polimorphysm()
print_spearator()
print_header('Testando conceitos avancados:' +
'\nTemplates, heranca multipla, callbacks, operadores, etc...')
test_references()
test_arguments()
test_callbacks()
test_operators()
test_templates()
test_multiple_inheritance()
test_std()
9.9. Resultado dos testes de some_lib com Boost.Python
some_lib_tests.py
Testa as funcionalidades de some_lib exportadas pela Boost.Python
Na maioria dos casos, um teste eh considerado bem sucedido se o valor
impresso for igual ao numero do teste sendo realizado, as vezes com
incrementos sucessivos de 0.1 entre sub-testes
Outros, pela sua natureza, sao bem sucedidos quanto algum erro
acontece durante o teste, como tentar modificar uma constante
================================================================================
Arvore dos membros exportados:
-------------------------------------------------------------------------------+ AbstractClass
- getFloat,
+ AdvancedClass
- callCallback, callPolyCallback, getValue, print_, resetInt_Pointer,
resetInt_Reference, resetInt_Value, setPolyCa
llback, setValue,
+ Callable
- call,
+ MultipleClass
- foo, getBar, getFloat, getFoo, setFoo,
+ OtherClass
- foo, getBar, getFoo, setFoo,
+ RealClassCpp
- getFloat,
+ SomeClass
- foo, getBar, getFoo, setFoo,
+ SomeStruct
- struct_member,
+ StdClass
+ TemplatedClass_int
- getValue, setValue,
+ callGetFloat
+ const_int
+ get_base_char
+ get_base_double
+ get_base_float
+ get_base_int
+ get_base_string
+ increment_callback
+ looseFunction
+ set_base_char
+ set_base_double
+ set_base_float
+ set_base_int
+ set_base_string
+ size
- big, medium, name, small, values,
+ some_size
- big, medium, name, small, values,
+ wrapped_average
================================================================================
________________________________________________________________________________
================================================================================
Testando conceitos basicos de C estruturado:
Variaveis globais, funcoes, structs, etc.
--------------------------------------------------------------------------------
================================================================================
Teste 1: Testando leitura e escrita em variaveis C globais de diferentes tipos
-------------------------------------------------------------------------------Lendo variavel inteira
base_int:
1
Lendo variavel ponto flutuante simples base_float:
1.0
Lendo variavel ponto flutuante double
base_double:
1.0
Lendo variavel caracter
base_char:
1
Lendo string (null terminated chars)
base_string:
<char * object at
0x0099D040>
Alterando valor de base_float para 1.1
Lendo variavel ponto flutuante simples base_float:
1.10000002384
================================================================================
================================================================================
Teste 2: Testando leitura de #defines e enums, e acesso ilegal a constantes
-------------------------------------------------------------------------------Lendo enum size some_size:
big
Testando escrita ilegal em constante const_int:
Escrita em const realizada em python, mas nao propagada para C++
================================================================================
================================================================================
Teste 3: Testando chamadas a funcoes C
-------------------------------------------------------------------------------Chamando funcao looseFunction:
3
================================================================================
================================================================================
Teste 4: Testando utilizacao de structs
-------------------------------------------------------------------------------Criando struct SomeStruct e acessando membro struct_member:
4
================================================================================
________________________________________________________________________________
================================================================================
Testando conceitos basicos de C++ orientado a objetos:
Classes, heranca, polimorfismo, etc.
--------------------------------------------------------------------------------
================================================================================
Teste 5: Testando utilizacao de classes:
Funcoes e atributos, de instancia e de classe, publicos e privados
-------------------------------------------------------------------------------Criando instancia de SomeClass - some_instance
Chamando funcao
some_instance.getFoo():
5.0
Alterando foo para 5.1 chamando some_instance.setFoo(5.1)
Lendo atributo publico
some_instance.foo:
5.09999990463
Chamando funcao de classe
SomeClass.getBar():
5
Chamando funcao privada
some_instance.getPrivate():
AttributeError: 'SomeClass' object has no attribute 'getPrivate'
================================================================================
================================================================================
Teste 6: Testando conceitos basicos de heranca
-------------------------------------------------------------------------------Criando instancia de OtherClass (subclasse de SomeClass)
Lendo antiga variavel nao modificada other_instance.foo:
Chamando funcao reimplementada
5.0
other_instance.getFoo(): 6.0
================================================================================
================================================================================
Teste 7: Testando classes abstratas e polimorfismo
-------------------------------------------------------------------------------Criando instancia de classe abstrata AbstractClass:
RuntimeError: This class cannot be instantiated from Python
Definindo RealClassPython (subclasse de RealClassCpp) em python
Criando instancias de subclasses RealClassCpp e RealClassPython
callGetFloat => funcao em C++, chama getFloat de uma instancia de AbstractClass
Chamando callGetFloat(real_instance_cpp):
7.0
Chamando callGetFloat(real_instance_python): 7.09999990463
================================================================================
________________________________________________________________________________
================================================================================
Testando conceitos avancados:
Templates, heranca multipla, callbacks, operadores, etc...
-------------------------------------------------------------------------------================================================================================
Teste 8: Testando diferentes tipos de referencia
(por valor, ponteiro ou referencia)
-------------------------------------------------------------------------------Criando variavel inteira com valor 8
Chamando funcao que tenta zerar variavel por valor
Retorno da chamada de AdvancedClass.resetInt_Value(int_var):
8
Criando variavel inteira com valor 8
Chamando funcao que tenta zerar variavel por ponteiro
Criando variavel inteira com valor 8
Chamando funcao que tenta zerar variavel por referencia
================================================================================
================================================================================
Teste 9: Testando argumentos padroes e argumentos multiplos
-------------------------------------------------------------------------------Chamando funcao print_ com argumento "
Teste 9":
Teste 9
Chamando funcao print_ sem argumentos:
Hello World
Chamando wrapped_average(1, 2):
1.5
Chamando wrapped_average(1, 2, 3, 4):
2.5
hamando wrapped_average(1, 2, 3, 4, 5, 6) - nao exportada:
TypeError: Python argument types in
some_lib_boost.wrapped_average(int, int, int, int, int, int)
did not match C++ signature:
wrapped_average(double, double, double, double)
wrapped_average(double, double, double)
wrapped_average(double, double)
wrapped_average(double)
================================================================================
================================================================================
Teste 10: Testando o uso de callbacks
-------------------------------------------------------------------------------Criando instancia de advanced class com valor 10
Definindo callback como sendo funcao C++ definida no arquivo .i
Definindo classe PythonCallable (subclasse de Callable) em python
Definindo o callback polimorfico como sendo uma instancia de PythonCallable
Requisitando chamada aa funcao de callback polimorfico: 10.1999998093
================================================================================
================================================================================
Teste 11: Testando o uso de sobrecarga de operadores
-------------------------------------------------------------------------------Criando uma instancia de AdvancedClass com valor 5 e outra com 6
advanced_result = advanced_instance_5 + advanced_instance_6
Error calling overloaded operator +
================================================================================
================================================================================
Teste 12: Testando o uso de templates
-------------------------------------------------------------------------------Criando instancia de TemplatedClass<int>
Definindo valor inteiro 12 e lendo: 12
Criando instancia de TemplatedClass<float> - nao exportada
AttributeError: 'module' object has no attribute 'TemplatedClass_float'
================================================================================
================================================================================
Teste 13: Testando heranca multipla
-------------------------------------------------------------------------------Criando instancia de MultipleClass
- subclasse de SomeClass e de RealClassCpp
Chamando funcao herdada de SomeClass
em 5: multiple_instance.getFoo():
5.0
Chamando funcao herdada de RealClassCpp em 7: multiple_instance.getFloat(): 7.0
================================================================================
================================================================================
Teste 14: Testando std::vectors e maps como listas e mapas nativos de python
-------------------------------------------------------------------------------Criando instancia de StdClass - contendo membros std::vector e std::map
Adicionando valores 14.0 e 14.1 ao std::vector de C++, com sintaxe python
Percorrendo vetor com sintaxe python:
for item in std_instance.float_vector: print item
Adicionando ao std::map com sintaxe python:
map[14.2] = "Hello 14.2"
map[14.3] = "Hello 14.3"
Imprimindo items() do mapa - como em um dicionario python:
================================================================================
9.10. Apocalypse - Source Code
Blah blah
9.11. Apocalypse – Interface SWIG
Blah blah
9.12. Apocalypse – Interface Pyste + Boost.Python
Blah blah
9.13. The Zen of Python
The Zen of Python, by Tim Peters:
1. Beautiful is better than ugly.
2. Explicit is better than implicit.
3. Simple is better than complex.
4. Complex is better than complicated.
5. Flat is better than nested.
6. Sparse is better than dense.
7. Readability counts.
8. Special cases aren't special enough to break the rules.
9. Although practicality beats purity.
10. Errors should never pass silently.
11. Unless explicitly silenced.
12. In the face of ambiguity, refuse the temptation to guess.
13. There should be one-- and preferably only one --obvious way to do it.
14. Although that way may not be obvious at first unless you're Dutch.
15. Now is better than never.
16. Although never is often better than right now.
17. If the implementation is hard to explain, it's a bad idea.
18. If the implementation is easy to explain, it may be a good idea.
19. NameSpaces are one honking great idea -- let's do more of those!
10. Artigo
"Duas retas paralelas se encontram no inferno"
Julio SzeremetaAliando Performance e Produtividade no Desenvolvimento de
Jogos
Fábio Luís Stange
Ciências da Computação, 2005
Departamento de Informática e Estatística – INE
Universidade Federal de Santa Catarina – UFSC, Brasil, 88040-900
[email protected]
Resumo
Blah
Palavras-chave: blah, blah.
Abstract
Bleh
Key-words: bleh, bleh.
Introdução
Blah
Download
Random flashcards
Anamnese

2 Cartões oauth2_google_3d715a2d-c2e6-4bfb-b64e-c9a45261b2b4

A Jornada do Herói

6 Cartões filipe.donner

Estudo Duda✨

5 Cartões oauth2_google_f1dd3b00-71ac-4806-b90b-c8cd7d861ecc

Estudo Duda✨

5 Cartões oauth2_google_f1dd3b00-71ac-4806-b90b-c8cd7d861ecc

Criar flashcards