Re: [Swig-user] SWIG multiple modules + typemaps

[Joris G. <Jor...@me...>]

Hi again,

As it turns out, the answer was right in the pseudo code I typed out to demonstrate my problem.

Our code really had
%template(FooVector)  std::vector<Foo>;

while
%template()  std::vector<Foo>;
is the exact answer I was looking for.

Only stumbled upon this while skimming through the historical changelist. I obviously overlooked the statement in the manual.

Regards,
    Joris Gillis


________________________________________
From: Joris Gillis [Jor...@me...]
Sent: Thursday, August 25, 2011 9:18 PM
To: Swi...@li...
Subject: [Swig-user] SWIG multiple modules + typemaps

Hi everyone,

We have been happily applying SWIG to our C++ project for quite some time now.
As the project grow, so does the SWIG generated wrapper code.

We managed to split our *.i files into separate modules, have them compile separately and have them loaded in the interfaced languages (Python & Octave).

However, the generated wrapper code size & the compiling and linking times of the separate modules do not compare favorably with the original single-module approach.

I seek your wisdom on how to do the modularization properly.



Our project has the following structure:

* A set of heavily interdependent classes Foo, Bar, Baz. Call them 'primitives'
* A whole bunch of little interdependent classes and methods that do work on these primitives and their vector-counterparts.
 A typical function might look like E.g.      somefunction(const Foo &a, const std::vector<Bar> &c, const std::vector< std::vector <Baz>> &c)

The modularization I tried was to have one module wrapper for the primitives and one for the other bunch.

We've got typemaps for all primitives and their vector-counterparts, and we wish them to work for the second module as well.

So the *.i code for the second module starts off with a replication of all template instantiation commands and all typemaps of the first module:

%template()  std::vector<Foo>;
%template()  std::vector< std::vector<Foo>>;
... and much more...
... and a bunch of typemaps...

So while we didn't %include Foo  in the second module, the amount of code generated is still significant:
we end up with FooVector, FooVectorVector ... spread all over _both_ module's generated wrapper codes.



Is there a way to make "std::vector<Foo>" typemaps work in the second module without the overhead of generating a FooVector wrapper by a mere "%template()  std::vector<Foo>;"?
After all, these wrappers are already available from the first module...


Much obliged for any possible comments,
        Joris Gillis


------------------------------------------------------------------------------
EMC VNX: the world's simplest storage, starting under $10K
The only unified storage solution that offers unified management
Up to 160% more powerful than alternatives and 25% more efficient.
Guaranteed. http://p.sf.net/sfu/emc-vnx-dev2dev
_______________________________________________
Swig-user mailing list
Swi...@li...
https://lists.sourceforge.net/lists/listinfo/swig-user