C std :: string como parámetros de salida en Java con SWIG [duplicado]
Esta pregunta ya tiene una respuesta aquí:
SWIG: Cómo ajustar std :: string & (std :: string pasado por referencia) 1 respuestaNecesito envolver una biblioteca de C ++ con SWIG para usarla con Java.
Ya tengo algunos métodos funcionando pero me he encontrado con una situación que no sé cómo resolverla.
Tengo un par de métodos como este:
void method1(std::string & name, std::string & result);
bool method2(std::string & name, std::string & alias, std::string & resurnValue, std::string & returnType);
Nota: En realidad, estos son métodos de miembros de una clase llamada MyClass.
Podría cambiar el primer método para devolver unstd::string
en vez de servoid
, y eso debería funcionar; pero no tengo idea de cómo manejar el segundo método donde los dos últimos parámetros son parámetros de salida. He visto un par de preguntas arbitrando achar *
params de salida (Pasando múltiples parámetros y asignando cadenas en C usando Swig / Python), pero en mi caso debería ser unstd::string
y la Documentación de SWIG no menciona esta situación.introduzca la descripción del enlace aquí. También es probable que encuentre más métodos que devuelven 3 o más parámetros de salida, probablemente con diferentes tipos.
Finalmente, tengo un poco de control sobre la interfaz, también estoy desarrollando una clase que actúa como un punto de entrada a la biblioteca, pero solo pasa a la implementación real.
Por ejemplo, con esto he logrado cambiar un método comomethod3(std::string & s)
amethod3(const std::string & s)
, así que podría usarlo desde Java con un normalString
.
Por lo tanto, es posible modificar un poco las firmas de los métodos, pero si un método nativo devuelve n parámetros de salida, debería devolverlos todos (no puedo crear nuevos métodos para devolver cada uno).
Actualizar: He estado buscando la solución dada por Flexo y funciona muy bien, sin embargo, estoy considerando hacer una clase para ajustar std :: string y usarla para interactuar con las cadenas devueltas, es un enfoque muy similar a la segunda solución de Flexo, pero usando este StringWrapper en lugar de usar una matriz de cadenas Java, básicamente se ve así:
/*
* The MyClass.i file
*/
%module example
%include "std_string.i"
%{
class StringPtr{
private:
stdString str;
public:
StringPtr(){
}
StringPtr(const stdString & str){
this->str = stdString(str);
}
stdString & getStrRef(){
return (this->str);
}
stdString getStrVal(){
return stdString(this->str);
}
~StringPtr(){
}
};
%}
/////////////////// Export StringPtr to Java
class StringPtr{
public:
StringPtr();
StringPtr(const stdString & str);
stdString getStrVal();
~StringPtr();
};
// I think this is nor necessary
%rename ("$ignore", fullname=1) "StringPtr::getStrRef";
%extend MyClass {
void method1(cons std::string & name, StringPtr & result){
$self->method1(name, result.getStrRef());
}
bool method2(cons std::string & name, cons std::string & alias, StringPtr & returnValue, StringPtr & returnType){
$self->method2(name, alias, returnValue.getStrRef(), returnType.getStrRef());
}
};
%rename ("$ignore", fullname=1) "MyClass::method1";
%rename ("$ignore", fullname=1) "MyClass::method2";
%include "MyClass.h"
Así que me pregunto, desde el punto de vista del rendimiento, qué mejor es la solución de estructuras (por Flexo), la matriz de cadenas de Flexo o este puntero (como una estructura con un solo miembro).