Question

I have a list of boost::tuple. I want to expose this tuple list to Java bindings through SWIG. But when I try to compile mt wrap.cxx, generated by SWIG, I get following errors:

d:\xyz\...\vector.h(115) : error C2678: binary '==' : no operator found which takes a left-hand operand of type 'const boost::tuples::tuple<T0,T1>' (or there is no acceptable conversion)
        with
        [
            T0=std::string,
            T1=std::string
        ]
        c:\program files\microsoft visual studio 8\vc\platformsdk\include\guiddef.h(192): or 'int operator ==(const GUID &,const GUID &)'
        while trying to match the argument list '(const boost::tuples::tuple<T0,T1>, const MyTuple)'
        with
        [
            T0=std::string,
            T1=std::string
        ]
        d:\xyz\...\vector.h(111) : while compiling class template member function 'int Vector<T>::index(const T &) const'
        with
        [
            T=MyTuple
        ]
        d:\xyz\...\MyTuple_wrap.cxx(17731) : see reference to class template instantiation 'Vector<T>' being compiled
        with
        [
            T=MyTuple
        ]

Can anyone tell me what I should do to resolve this issue?

Answer 1

It is unclear how you arrived at the error you’ve shown. boost::tuple is tricky to wrap by default and there doesn’t seem to be any standard interface to it included with SWIG. In my tests I couldn’t get close to the error you were seeing without manually writing an interface file.

I did however succeeded in wrapping boost’s tuples using the following interface file:

%{
#include <boost/tuple/tuple.hpp>
%}

namespace boost {
  template <typename T1=void, typename T2=void, typename T3=void> 
  struct tuple;

  template <>
  struct tuple<void,void,void> {
  };

  template <typename T1>
  struct tuple<T1, void, void> {
    tuple(T1);
    %extend {
      T1 first() const {
        return boost::get<0>(*$self);
      }
    }
  };

  template <typename T1, typename T2>
  struct tuple <T1, T2, void> {
    tuple(T1,T2);
    %extend {
      T1 first() const {
        return boost::get<0>(*$self);
      }
      T2 second() const { 
        return boost::get<1>(*$self);
      }
    }
  };

  template <typename T1, typename T2, typename T3> 
  struct tuple <T1,T2,T3> {
    tuple(T1,T2,T3);
    %extend {
      T1 first() const {
        return boost::get<0>(*$self);
      }
      T2 second() const {
        return boost::get<1>(*$self);
      }
      T3 third() const {
        return boost::get<2>(*$self);
      }
    }
  };
}

Basically all it does is add accessor functions to each of the specialisations of tuple you might care about. It’s sufficient to make it minimally useful in Java or some other language. You would want to expand on this to cover larger tuples. You probably want to make the member functions get/set if your tuples aren’t intended to be immutable.

I was able to test this with a SWIG module:

%module test

%include "boost_tuple.i"

%template(TestTuple) boost::tuple<int, double, char>;

%template(SingleTuple) boost::tuple<char>;

%inline %{
boost::tuple<int, double, char> func1() {
  return boost::make_tuple(3, 2.0, '1');
}

void test1(boost::tuple<int, double, char>) {
}

%}

Which worked as expected with the following Java:

public class run {
  public static void main(String[] argv) {
    System.loadLibrary("test");
    TestTuple t = test.func1();
    System.out.println("1: " + t.first() + " 2: " + t.second() + " 3: " + t.third());
    test.test1(test.func1());
    test.test1(new TestTuple(0, 0.0, '0'));
  }
}