4

我需要用 SWIG 包装一个 C++ 库才能将它与 Java 一起使用。

我已经有一些方法可以工作，但是我遇到了一种我不知道如何解决的情况。

我有几个这样的方法：

void method1(std::string & name, std::string & result);

bool method2(std::string & name, std::string & alias, std::string & resurnValue, std::string & returnType);

注意：实际上这是一个名为 MyClass 的类的成员方法。

我可以将第一个方法更改为返回 astd::string而不是 being void，这应该可以；但我不知道如何处理最后两个参数是输出参数的第二种方法。我已经看到了几个关于char *输出参数的问题（使用 Swig/Python 在 C 中传递多个参数和分配字符串），但在我的情况下应该是 astd::string并且 SWIG 的文档没有提到这种情况，请在此处输入链接描述。此外，我可能会遇到更多返回 3 个或更多输出参数的方法，可能具有不同的类型。

最后，我对接口有了一点控制，我还在开发一个作为库入口点的类，但它只是将调用传递给真正的实现。

例如，通过这个我已经设法改变了一个方法method3(std::string & s)，method3(const std::string & s)所以我可以从 Java 中使用它String。

所以稍微修改方法签名是可能的，但如果一个本地方法返回 n 个输出参数，我应该返回所有参数（我不能创建新方法来返回每个参数）。

更新： 我一直在研究 Flexo 提供的解决方案并且效果很好，但是我正在考虑做一个类来包装 std::string 并使用它与返回的字符串进行交互，这是与 Flexo 的第二种解决方案非常相似的方法，但是使用这个 StringWrapper 而不是使用 java String 数组，基本上看起来像这样：

/*
* 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"

所以我想知道，从性能的角度来看，witch 更好，结构解决方案（通过 Flexo），通过 Flexo 的字符串数组或这个指针（就像只有一个成员的结构。

4

3 回答 3

7

假设您想在不修改现有头文件的情况下包装它，可以想到两种方法。鉴于我用于测试的头文件：

#include <string>

inline bool method2(const std::string & name, const std::string & alias, std::string & resurnValue, std::string & returnType) {
  resurnValue = name;
  returnType = alias;
  return true;
}

包装它的最简单方法是使用%inline创建一个重载，将所有输出包装为一种类型：

%module test

%include <std_string.i>

%{
#include "test.h"
%}

%inline %{
  struct Method2Result {
    bool b;
    std::string s1;
    std::string s2;
  };

  Method2Result method2(const std::string& in1, const std::string& in2) {
    Method2Result ret;
    ret.b = method2(in1,in2,ret.s1,ret.s2);
    return ret;
  }
%}

// Optional: don't wrap the original form of method2 at all:
%ignore method2;

%include "test.h"

这适用于：

public class run {
  public static void main(String[] args) {
    System.loadLibrary("test");
    Method2Result ret = test.method2("foo", "bar");
    System.out.println(ret.getB() + " - " + ret.getS1() + ", " + ret.getS2());
  }
}

您可以使用std::pairor boost::tuple，%template但我怀疑包装boost::tuple不是微不足道的，并且像这样您可以将成员命名为您的库用户将理解的适当名称，而不仅仅是firstand second，而不使用%rename它变得更加冗长，而不仅仅是在其中编写自定义结构%inline.

或者，SWIG 提供了 OUTPUT 类型映射，您可以使用它%apply来创建输出 argumnet。这些被包装为一个包含 1 个元素的数组——传递数组的语义与输出参数的语义相匹配。不幸的是std::string，typemaps.i 中没有 for，所以我们必须自己编写。理想情况下，我会重用该OUTPUT_TYPEMAP文件中的宏并稍微修改 argout 类型映射，但它会在#undef没有可能的情况下被限制。幸运的是，在这种情况下复制和修改是相当简单的：

%module test

%{
#include "test.h"
%}

%typemap(jstype) std::string& OUTPUT "String[]"
%typemap(jtype) std::string& OUTPUT "String[]"
%typemap(jni) std::string& OUTPUT "jobjectArray"
%typemap(javain)  std::string& OUTPUT "$javainput"
%typemap(in) std::string& OUTPUT (std::string temp) {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (JCALL1(GetArrayLength, jenv, $input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
  }
  $1 = &temp;
}
%typemap(argout) std::string& OUTPUT {
  jstring jvalue = JCALL1(NewStringUTF, jenv, temp$argnum.c_str()); 
  JCALL3(SetObjectArrayElement, jenv, $input, 0, jvalue);
}

%apply  std::string& OUTPUT { std::string & resurnValue }
%apply  std::string& OUTPUT { std::string & returnType }

%include "test.h"

这可以像这样使用：

public class run {
  public static void main(String[] args) {
    String[] out1 = new String[1];
    String[] out2 = new String[1];
    boolean retb = test.method2("foo", "bar", out1, out2);
    System.out.println(retb + " - " + out1[0] + ", " + out2[0]);
  }
}

这两个都经过测试并在我的系统上运行。对于这种情况，我喜欢这种%inline方法。（如果它是您将使用的成员函数%extend）。在一般情况下，可以在不编写任何额外代码的情况下应用 OUTPUT 类型映射。

于 2012-08-15T10:36:32.327 回答
3

如果你有 C++11 支持，你可以返回一个std::tuple of bool,std::string和std::string.

否则，您可以创建嵌套的std::pairs。

于 2012-08-14T15:48:27.433 回答
3

只是为了好玩，这就是我们使用 JavaCPP 的方法：

public static native boolean method2(@StdString String name,
        @StdString @Cast("char*") BytePointer alias,
        @StdString @Cast("char*") BytePointer returnValue,
        @StdString @Cast("char*") BytePointer returnType);

public static void main(String[] args) {
    BytePointer alias = new BytePointer();
    BytePointer returnValue = new BytePointer();
    BytePointer returnType = new BytePointer();
    method2("Unknown", alias, returnValue, returnType);
    alias.getString();
    returnValue.getString();
    returnType.getString();
}

我很想听听 SWIG 如何成为更好的解决方案！

于 2012-09-01T04:56:46.977 回答