My previous posts on this topic part 1 and part 2 were posted about half a year ago. Since then SWIG version 1.3.40 has been released and it includes several enhancements in the C# wrapper for std::vector and std::map based on the work that I did, but with several great improvements implemented by William Fulton, the person in charge of the C# wrappers in SWIG.
Since version 1.3.40 wrapping std::vector and std::map in C# is extremely simple. I’ll give a quick overview:
Wrapping std::vector
Lets assume you have a C++ class called MyClass with a method std::vector<int> GetIntVector(); You want to wrap MyClass from C++ to C# and have the GetIntVector method return an IList<int> in C#. In order to do this, your swig interface file (the .i file) should look something like this:
/* File : MyProject.i */
%module MyProject%{
#include “MyClass.h”
%}%include “std_vector.i”
%include “MyClass.h”%template(Int_Vector) std::vector<int>;
The C# class Int_Vector will implement the IList<int> interface as desired.
Now lets make things a bit trickier by introducing a new class called MyItem and lets add a method to MyClass with the following signature: std::vector<MyItem> GetItems(); In this case you’ll want the C# method to return an IList<MyItem>. One important issue that should be mentioned here is that any class being used in the IList<> generic must overload the == operator. Otherwise, it is only possible to use the IEnumerable<> generic interface.
So if MyItem doesn’t overload the == operator, and you’re content with having the C# method return an IEnumerable<MyItem>, then your swig interface file will look something like this:
/* File : MyProject.i */
%module MyProject%{
#include “MyClass.h”
#include “MyItem.h”
%}%include “std_vector.i”
%include “MyClass.h”
%include “MyItem.h”%template(Int_Vector) std::vector<int>;
%template(Item_Vector) std::vector<MyItem>;
The C# class Item_Vector will implement the IEnumerable<MyItem> interface.
If, however, MyItem overloads the == operator, then you can have the C# Item_Vector implement the IList<MyItem> interface. You’ll need to tell swig that your class can be used with the IList<> interface by using the SWIG_STD_VECTOR_ENHANCED macro. Your swig interface file will look something like this:
/* File : MyProject.i */
%module MyProject%{
#include “MyClass.h”
#include “MyItem.h”
%}%include “std_vector.i”
%include “MyClass.h”
%include “MyItem.h”%template(Int_Vector) std::vector<int>;
SWIG_STD_VECTOR_ENHANCED(MyItem)
%template(Item_Vector) std::vector<MyItem>;
Now the C# class Item_Vector will implement the IList<MyItem> interface.
Wrapping std::map
Thanks to some nifty features added to the SWIG core, it is now possible to wrap C++ std::maps into C# IDictionary<> generic classes very easily.
Lets assume you have a C++ class called MyClass with a method std::map<std::string, int> GetMap(); You want to wrap MyClass from C++ to C# and have the GetMap method return an IDictionary<string,int> in C#. In order to do this, your swig interface file should look something like this:
/* File : MyProject.i */
%module MyProject%{
#include “MyClass.h”
%}%include “std_string.i”
%include “std_vector.i”
%include “MyClass.h”%template(String_Int_Map) std::map<std::string, int>;
The C# class String_Int_Map will implement the IDictionary<string,int> interface as desired. It’s that simple. No need for any specialization macros or anything.
