Controles de Conectividade NEW

O HarbourBuilder fornece 9 controles de interoperabilidade de linguagens que permitem chamar codigo escrito em Python, Swift, Go, Node.js, Rust, Java, .NET, Lua e Ruby diretamente das suas aplicacoes Harbour. Os 9 controles herdam da classe base TInteropRuntime, que fornece uma API unificada para chamadas entre linguagens.

Linguagens Suportadas

Requisitos de Runtime

Cada componente de conectividade requer a respetiva toolchain instalada na maquina host. O componente auto-deteta o binario procurando em caminhos comuns; cRuntimePath sobrepoe a detecao se estiver definido.

Modelo de Execucao

Linguagens compiladas (Rust, Go, Java, .NET, Swift) seguem um pipeline compilar-depois-executar: fonte → binario em diretorio temporario → execucao como subprocesso. As interpretadas (Node, Ruby, Lua) saltam o build. Python usa libpython embutido para chamadas in-process diretas (menor overhead).

Eventos Comuns

Metodos API Comuns

Classe Base TInteropRuntime

Os 9 controles de conectividade herdam de TInteropRuntime, uma classe base abstrata que define a interface comum para comunicacao entre linguagens. Este design garante que mudar entre linguagens requer apenas alterar o nome da classe do componente — a API permanece identica.

Propriedades Herdadas

Metodos Abstratos

Cada classe filha deve implementar estes metodos internos, que sao chamados pela API publica:

Padrao de API Comun

Estes metodos sao definidos em TInteropRuntime e herdados por todos os controles de conectividade:

Exemplo de Integracao Python

O componente TPython e o mais comumente usado entre os controles de conectividade. Ele incorpora um interpretador Python completo na sua aplicacao Harbour:

#include "hbbuilder.ch"

function Main()

   local oPython, cResult, aData

   // Inicializar runtime Python
   oPython := TPython():New()
   oPython:Init()

   // Executar codigo Python
   oPython:Eval( "import math" )
   cResult := oPython:Call( "math.sqrt", 144 )
   ? "sqrt(144) =", cResult  // 12.0

   // Chamar uma funcao Python de um arquivo de script
   oPython:Eval( ;
      "def greet(name):\n" + ;
      "    return f'Hello, {name} from Python!'\n" + ;
      "def process_list(items):\n" + ;
      "    return [x**2 for x in items]" )

   cResult := oPython:Call( "greet", "Harbour" )
   ? cResult  // "Hello, Harbour from Python!"

   aData := oPython:Call( "process_list", { 1, 2, 3, 4, 5 } )
   // aData = {1, 4, 9, 16, 25}

   oPython:Shutdown()

return nil

Exemplo de Integracao Node.js

oNode := TNode():New()
oNode:Init()

// Executar um snippet JavaScript
cResult := oNode:Eval( ;
   "const os = require('os');" + ;
   "JSON.stringify({ platform: os.platform(), arch: os.arch() })" )

? cResult  // {"platform":"darwin","arch":"arm64"}

oNode:Shutdown()

Exemplo de Integracao Lua

oLua := TLua():New()
oLua:Init()

// Definir uma variavel Harbour visivel no Lua
oLua:SetVar( "app_name", "HarbourBuilder" )

// Executar codigo Lua que acessa a variavel
oLua:Eval( "result = 'Hello from ' .. app_name" )

? oLua:GetVar( "result" )  // "Hello from HarbourBuilder"

oLua:Shutdown()

Exemplo de Integracao Go

Compile um pacote Go como biblioteca compartilhada:

// Fonte Go (golib.go)
// export Double
func Double(n C.int) C.int {
    return n * 2
}

// Build: go build -buildmode=c-shared -o golib.so golib.go

oGo := TGo():New()
oGo:cLibPath := "./golib.so"
oGo:Init()

? oGo:Call( "Double", 21 )  // 42

oGo:Shutdown()

Exemplo de Integracao Rust

Compile Rust com cdylib e extern "C":

// Fonte Rust (src/lib.rs)
#[no_mangle]
pub extern "C" fn hash_string(s: *const c_char) -> *mut c_char {
    let input = unsafe { CStr::from_ptr(s).to_str().unwrap() };
    let hash = format!("{:x}", md5::compute(input));
    CString::new(hash).unwrap().into_raw()
}

// Build: cargo build --release

oRust := TRust():New()
oRust:cLibPath := "./target/release/libmylib.so"
oRust:Init()

? oRust:Call( "hash_string", "hello" )  // "5d41402abc4b2a76b9719d911017c592"

oRust:Shutdown()

Arquitetura

Consideracoes de Desempenho