I have following c++ functions for which i am making Java wrapper
void label(const std::string &label) { // wrapper correctly built
...
}
void label(const boost::none_t t) { // generating SWIGTYPE_p_boost__none_t
...
}
How can i correctly wrap boost::none_t in Java. I m new to SWIG. Any help is appreciated
Depending on quite what this function actually does you probably want something like:
%{
#include <boost/none.hpp>
%}
%typemap(in,numinputs=0) boost::none_t %{
$1 = boost::none;
%}
void label(const boost::none_t t);
Which then generates the following Java:
public static void label()
The argument is omitted in Java and automatically filled out with boost::none via an assignment before the function gets called.
Related
I have following header file.
#include <string>
namespace A {
namespace B {
struct Msg {
std::string id;
std::string msg;
Msg(std::string new_id, std::string new_msg)
: id(new_id), msg(new_msg)
{
}
};
template<bool HAS_ID>
class ID {
public:
template<typename TOBJ>
auto get(TOBJ parent) -> decltype(parent.id()) {
return parent.id();
}
};
} // namespace B
} // namespace A
When i swig it, it gives me an error
Error: Syntax error in input(3). at line 20 pointing to line
auto get(TOBJ parent) -> decltype(parent.id())
Target language is Java
How can i fix this problem? I only want to create wrapper for Msg struct and for nothing else in the header. As this looks like a Swig parser error, using %ignore directive does not seem to work.
Thank you
Although SWIG 3.x added limited decltype support it looks like the case you have is unsupported currently. (See decltype limitations)
I think the best you'll get for now is to surround the offending code in preprocessor macros to hide it, e.g.:
#include <string>
namespace A {
namespace B {
struct Msg {
std::string id;
std::string msg;
Msg(std::string new_id, std::string new_msg)
: id(new_id), msg(new_msg)
{
}
};
template<bool HAS_ID>
class ID {
public:
#ifndef SWIG
template<typename TOBJ>
auto get(TOBJ parent) -> decltype(parent.id()) {
return parent.id();
}
#endif
};
} // namespace B
} // namespace A
If you can't edit the file like that for whatever reason there are two options:
Don't use %include with the header file that doesn't parse. Instead write something like:
%{
#include "header.h" // Not parsed by SWIG here though
%}
namespace A {
namespace B {
struct Msg {
std::string id;
std::string msg;
Msg(std::string new_id, std::string new_msg)
: id(new_id), msg(new_msg)
{
}
};
} // namespace B
} // namespace A
in your .i file, which simply tells SWIG about the type you want to wrap and glosses over the one that doesn't work.
Alternatively get creative with the pre-processor and find a way to hide it using a bodge, inside your .i file you could write something like:
#define auto // \
void ignore_me();
%ignore ignore_me;
Another similar bodge would be to hide the contents of decltype with:
#define decltype(x) void*
Which just tells SWIG to assume all decltype usage is a void pointer. (Needs SWIG 3.x and could be combined with %ignore which ought to do the ignore, or a typemap to really fix it)
(This is a question I asked yesterday, but I simplified it)
I've created a class, of which I want two objects as output arguments of a function (called Test below). But when I run the swig command swig -c++ -python swigtest.i I'm getting the error "Warning 453: Can't apply (MyClass &OUTPUT). No typemaps are defined." I tried adding typemaps, but that doesn't help. I also tried using pointers, pointers to pointers and references to pointers, that doesn't help either.
I feel like I've overlooked something simple, because this should be quite a common thing to do. Or do I need to write a complex typemap, like I've seen around but don't understand (yet)?
Below is my code:
MyClass.h (simplified to make it understandable, so switching to just int doesn't help):
class MyClass
{
int x;
public:
int get() const
{
return x;
}
};
void Test(MyClass &obj1, MyClass &obj2);
swigtest.i:
%module swigtest
%include typemaps.i
%{
#define SWIG_FILE_WITH_INIT
%}
%{
#include "MyClass.h"
%}
%include "MyClass.h"
%apply (MyClass& OUTPUT) { MyClass &obj1 }
%apply (MyClass& OUTPUT) { MyClass &obj2 }
As noted in my previous comment, the %apply OUTPUT trick only works for a limited set of POD types.
For future Swiggers, this solution worked for me (in C# bindings):
%typemap(cstype) CustomType* "out CustomType"
%typemap(csin,
pre=" $csclassname temp$csinput = new $csclassname();",
post=" $csinput = temp$csinput;"
) CustomType* "$csclassname.getCPtr(temp$csinput)"
This generates a public interface with an "out" param for CustomType passed by pointer. The internal P/Invoke interface (csim) is left as raw pointers. The "csin" typemap creates a temp variable and assigns to the output parameter.
Also worth noting that in C#, if MyCustomType is already a reference type, you may not need this, however it's strange to have an API that modifies the parameter value without declaring it as "out" (this actually works for my type, but I prefer the explicit out param).
Try:
%module swigtest
%{
#define SWIG_FILE_WITH_INIT
#include "MyClass.h"
%}
%include "typemaps.i"
%apply MyClass *OUTPUT { MyClass &obj1, MyClass &obj2 };
%include "MyClass.h"
You could also create a wrapper that returns a std::list:
%include "std_list.i"
%ignore Test;
%rename(Test) TestWrap;
%inline %{
std::list<MyClass> TestWrap() {
MyClass obj1, obj2;
Test(obj1, obj2);
std::list<MyClass> tempList;
tempList.push_back(obj1);
tempList.push_back(obj2);
return tempList;
}
%}
I settled for adding extra Python code in swigtest.i that wraps the test function, so that I can write obj1, obj2 = Test2(). I still think there must be an easier solution,
// swigtest.i:
%module swigtest
%{
#define SWIG_FILE_WITH_INIT
#include "MyClass.h"
%}
%include "MyClass.h"
%insert("python") %{
def Test2():
obj1 = swigtest.MyClass()
obj2 = swigtest.MyClass()
swigtest.Test(obj1, obj2)
return obj1, obj2
%}
I read here how to wrap this macro FOOBAR in SWIG:
class foobar {
public:
static void method() {}
};
#define FOOBAR() foobar().method()
The solution is to include this in SWIG interface:
void FOOBAR();
However, suppose I drop () so that my macro is
#define FOOBAR foobar().method()
This is still perfectly legitimate macro I can use in C++. How do I wrap this, so I can say on Python command line:
>>>FOOBAR
To clarify, since this seems to be confusing. I purposely chose the method to return nothing. I did that, so that the irrelevant question of "what is it supposed to return" is not considered. However, people still seem to want to consider it.
OK then, in C++, FOOBAR has meaning - it is a certain object, I can call FOOBAR.someMethod(). I want that on Python command line, it also be an object (the equivalent one), which will behave the same, I also want to call FOOBAR.someMethod() and have it behave the same as in C++.
I am sorry, but I assumed, that in the context of SWIG, the above explanation is obvious and unnecessary, and is contained in the abbreviation "wrap".
%pythoncode may be what you want. Example:
%module x
%inline %{
class foobar {
public:
static void method() {}
};
#define FOOBAR foobar().method()
%}
%pythoncode %{
FOOBAR = foobar().method
%}
Result:
>>> from x import *
>>> FOOBAR
<built-in function foobar_method>
I'm making a wrapper of a C++ library so it can be used from Java, I'm doing this with Swig.
What I'm facing is that i have a Class SomeClass, which has some overloaded methods (someMethod). Of this overloaded methods some receive complex data that i don't want to export to the wrapper, and some simple ones which i do want then exported.
I'm trying to use the %rename("$ignore") directive but either i get all methods exported or none. I have another two types of Classes SimpleData and ComplexData, one of them in namespace ns1 and the other in ns2, SomeClass is in namespace ''ns3`.
The class SimpleData:
#ifndef SIMPLEDATA_H_
#define SIMPLEDATA_H_
namespace ns1 {
class SimpleData {
public:
SimpleData(){}
virtual ~SimpleData(){}
};
} /* namespace ns1 */
#endif /* SIMPLEDATA_H_ */
The class ComplexData:
#ifndef COMPLEXDATA_H_
#define COMPLEXDATA_H_
namespace ns2 {
class ComplexData {
public:
ComplexData(){}
virtual ~ComplexData(){}
};
} /* namespace ns2 */
#endif /* COMPLEXDATA_H_ */
The class SomeClass:
#ifndef SOMECLASS_H_
#define SOMECLASS_H_
#include "SimpleData.h"
#include "ComplexData.h"
namespace ns3 {
class SomeClass {
public:
SomeClass(){}
bool someMethod(const ns1::SimpleData & data){return true;}
bool someMethod(const ns2::ComplexData & data){return true;}
bool someMethod(const int & data){return true;}
bool anotherMethod();
virtual ~SomeClass(){}
};
} /* namespace ns3 */
#endif /* SOMECLASS_H_ */
The i file snippet looks like this:
%rename ("$ignore", fullname=1) "ns3::SomeClass::someMethod(const ns2::ComplexData&)";
But that isn't working. Which one is the correct way of ignoring some specific overload of a method?
The full .i file:
%module libSomeClass
%{
#include "../src/SomeClass.h"
%}
%pragma(java) jniclasscode=%{
static {
try {
System.loadLibrary("SWIG_C++");
} catch (UnsatisfiedLinkError e) {
System.err.println("Native code library failed to load. \n" + e);
System.exit(1);
}
}
%}
// SimpleData
%include "../src/SimpleData.h"
//removes too much
//%rename ("$ignore", fullname=1) "ns3::SomeClass::someMethod";
//does not work
%rename ("$ignore", fullname=1) "ns3::SomeClass::someMethod(const ns2::ComplexData &)";
%rename ("renamedMethod", fullname=1) "ns3::SomeClass::anotherMethod";
%include "../src/SomeClass.h"
Note: I don't think it actually has nothing to do but just in case, those methods actually throw a exception.
Note2: I also don't think is relevant, but the target language is Java and the source language is C++.
Have you tried using just the %ignore directive, http://www.swig.org/Doc1.3/SWIG.html#SWIG_rename_ignore? Check out http://www.swig.org/Doc1.3/SWIGPlus.html#ambiguity_resolution_renaming to see how to best match the function you want to ignore.
Also note that "The placement of the %rename directive is arbitrary as long as it appears before the declarations to be renamed", is your %rename before the function?
(In your example you are missing the class name, I assume that is just a typo right?)
The solution is to not use quotes with the method signature.
%rename ("$ignore", fullname=1) ns3::SomeClass::someMethod(const ns2::ComplexData &);
I did put quotes in the first place because I always have and always worked for me, for example:
%rename ("renamedMethod", fullname=1) "ns3::SomeClass::anotherMethod";
The full .i file for reference:
%module libSomeClass
%{
#include "../src/SomeClass.h"
%}
%pragma(java) jniclasscode=%{
static {
try {
System.loadLibrary("SWIG_C++");
} catch (UnsatisfiedLinkError e) {
System.err.println("Native code library failed to load. \n" + e);
System.exit(1);
}
}
%}
// SimpleData
%include "../src/SimpleData.h"
%rename ("$ignore", fullname=1) ns3::SomeClass::someMethod(const ns2::ComplexData &);
%ignore ns3::SomeClass::someMethod(const int &);
%rename ("renamedMethod", fullname=1) "ns3::SomeClass::anotherMethod";
%include "../src/SomeClass.h"
I found this question, but the one answer was basically, you wouldn't want to do that: Is it possible to add code to an existing method when using Swig to build a C# wrapper for C++ code?
I actually agree with it in the case as described, where the OP was trying to insert code in a way that could be fragile. In my case I am doing exactly what the answer suggested: renaming the method and using %typemap(javacode) to implement the wrapping method.
But I've written this as a macro, and I want to override several methods, so I end up calling %typecode(javacode) multiple times, and only the last wrapping method javacode typemap is active.
The details of the macro are complicated, since it uses variable args to express the signature.
But demonstrating the issue:
%define WRAP(CLASS,METHOD)
%rename(method ## _internal,fullname=1) CLASS::METHOD;
%typemap(javamethodmodifiers) CLASS::METHOD "private";
%typemap(javacode) {
public void METHOD() {
METHOD ## _internal(); // delegate to original
// extra code here
}
} // (note: dont use %{ %} -- need macro evaluation)
%enddef
WRAP(Foo,bar)
WRAP(Foo,baz)
class Foo {
void bar();
void baz();
}
Only the public void baz() { baz_internal(); ... } gets generated.
The problem here is that the %rename and %typemap(javamethodmodifiers) are unique since the scope to CLASS::METHOD, but the %typemap(javacode) applies to the whole class. If syntax like
%typemap(javacode,append=true) { // code }
were supported, then this would solve the problem. Is there some technique that could accomplish this? This could make sense for typemaps like javacode or javaimports, whose defaults are empty.
I can make a SWIG macro that generates the code you're looking for. It's a bit of a bodge, but it works. The trick was abusing the javaout (with noblock=1) typemap instead of javacode so that it gets applied once per function rather than once per class:
%module test
%define WRAP(CLASS,METHOD)
%rename(METHOD ## _internal,fullname=1) CLASS::METHOD;
%javamethodmodifiers CLASS::METHOD "private";
%typemap(javaout,noblock=1) void CLASS::METHOD {
{
$jnicall;
}
public void METHOD() {
METHOD ## _internal();
// some other bits
}
}
%enddef
WRAP(Foo,bar)
WRAP(Foo,baz)
class Foo {
public:
void bar();
void baz();
};
This generates exactly the code you're looking for, but I suspect you could skip the %rename entirely and do it all from the javaout typemap. This approach works with SWIG 1.3 and upwards.
I did try another approach with $typemap and copying typemaps around, but this didn't work out in the end.
If you want to support methods which return things too you'll want to add a third macro argument:
%define WRAP(CLASS,METHOD,RETURN)
%rename(METHOD ## _internal,fullname=1) CLASS::METHOD;
%javamethodmodifiers CLASS::METHOD "private";
%typemap(javaout,noblock=1) RETURN CLASS::METHOD {
$typemap(javaout,RETURN)
public $typemap(jstype,RETURN) METHOD() {
RETURN result = METHOD ## _internal();
// some other bits
return result;
}
}
%enddef
$typemap there is used to refer to the default, less specialised typemaps to avoid having to duplicate a lot of code for non-primitive/special case returns.
Below are three solutions. Change the definition of SOLUTION to either 1, 2 or 3 to try out each of them.
SOLUTION 1 uses the %proxycode feature added in SWIG-3.0.12, specifically to solve this problem.
SOLUTION 2 uses a copy/paste/modify of the default typemap approach. This is pretty much the whole purpose of typemaps, that is, taking an existing one and customizing it to get the generated code you want.
SOLUTION 3 re-uses the contents of another (the default) typemap in the user typemap.
%module example
#define SOLUTION 1
#if SOLUTION==1
%define WRAP(CLASS,METHOD)
%rename(METHOD ## _internal) CLASS::METHOD;
%typemap(javamethodmodifiers) CLASS::METHOD "private";
//%typemap(javacode) {
%extend CLASS {
%proxycode %{
public void METHOD() {
METHOD ## _internal(); // delegate to original
// extra code here
System.out.println("extra code in " + #METHOD + " SOLUTION 1");
}
%}
}
%enddef
#elif SOLUTION==2
%define WRAP(CLASS,METHOD)
%typemap(javaout) void CLASS::METHOD {
// Next line is copied from java.swg: %typemap(javaout) void
$jnicall;
// extra code here
System.out.println("extra code in " + #METHOD + " SOLUTION 2");
}
%enddef
#elif SOLUTION==3
%define WRAP(CLASS,METHOD)
%typemap(javaout) void CLASS::METHOD {
// Next line re-uses/includes the typemap in java.swg: %typemap(javaout) void
$typemap(javaout, void);
// extra code here
System.out.println("extra code in " + #METHOD + " SOLUTION 3");
}
%enddef
#else
#error "Bad SOLUTION"
#endif
WRAP(Foo,bar)
WRAP(Foo,baz)
%inline %{
class Foo {
public:
void bar();
void baz();
};
%}
%{
#include <iostream>
void Foo::bar() { std::cout << "Foo::bar " << std::endl; }
void Foo::baz() { std::cout << "Foo::baz " << std::endl; }
%}