← Back to branch summary

~sharpie/geos/3.3.2

« back to all changes in this revision

Viewing changes to swig/ruby/ruby.i

  • Committer: Bazaar Package Importer
  • Author(s): Fabio Tranchitella
  • Date: 2006-11-06 21:35:52 UTC
  • mfrom: (3.1.3 feisty)
  • Revision ID: james.westby@ubuntu.com-20061106213552-m03o92ggj1na737b
Tags: 2.2.3-3
debian/control: move doxygen from build-depends-indep to build-depends.

Show diffs side-by-side

added added

removed removed

Lines of Context:
swig/ruby/ruby.i
 
1
/* =========================================================================
 
2
 * $Id: ruby.i,v 1.4.2.1 2006/04/04 09:50:17 strk Exp $
 
3
 *
 
4
 * ruby.i
 
5
 * 
 
6
 * Copyright 2005 Charlie Savage, cfis@interserv.com
 
7
 *
 
8
 * Interface for a SWIG generated geos module.
 
9
 *
 
10
 * This is free software; you can redistribute and/or modify it under
 
11
 * the terms of the GNU Lesser General Public Licence as published
 
12
 * by the Free Software Foundation. 
 
13
 * See the COPYING file for more information.
 
14
 *
 
15
 * ========================================================================= */
 
16
 
 
17
%{ 
 
18
#include <sstream>
 
19
%}
 
20
 
 
21
/* Next conflicts with a Ruby keyword */
 
22
%rename(next_) geos::GeometryCollectionIterator::next();
 
23
 
 
24
/* Need to deal with these ignores by renaming them */
 
25
%rename("build_geometry!") geos::GeometryFactory::buildGeometry(vector<Geometry * > *) const;
 
26
%rename("create_geometry_collection!") geos::GeometryFactory::createGeometryCollection(vector<Geometry * > *) const;
 
27
%rename("create_linear_ring!") geos::GeometryFactory::createLinearRing(CoordinateSequence *) const;
 
28
%rename("create_line_string!") geos::GeometryFactory::createLineString(CoordinateSequence *) const;
 
29
%rename("create_multi_line_string!") geos::GeometryFactory::createMultiLineString(vector<Geometry * > *) const;
 
30
%rename("create_multi_point!") geos::GeometryFactory::createMultiPoint(vector<Geometry * > *) const;
 
31
%rename("create_multi_polygon!") geos::GeometryFactory::createMultiPolygon(vector<Geometry * > *) const;
 
32
%rename("create_point!") geos::GeometryFactory::createPoint(CoordinateSequence *) const;
 
33
%rename("create_polygon!") geos::GeometryFactory::createPolygon(LinearRing *,vector<Geometry * > *) const;
 
34
 
 
35
/* All these classes do not follow the Ruby naming convention */
 
36
%rename("PlanarGraphComponent") geos::planarGraphComponent;
 
37
%rename("PlanarDirectedEdge") geos::planarDirectedEdge;
 
38
%rename("PlanarDirectedEdgeStar") geos::planarDirectedEdgeStar;
 
39
%rename("PlanarNode") geos::planarNode;
 
40
%rename("PlanarEdge") geos::planarEdge;
 
41
%rename("PlanarCoordLT") geos::planarCoordLT;
 
42
%rename("PlanarNodeMap") geos::planarNodeMap;
 
43
%rename("PlanarPlanarGraph") geos::planarPlanarGraph;
 
44
 
 
45
 
 
46
/* Ruby defines a macro called select in its win32.h header file.  However,
 
47
   the object geos::MonotoneChainSelectAction also defines a select method,
 
48
   thus causing compilation problems.  So #undef the macro. */
 
49
%runtime %{
 
50
#undef select
 
51
%}
 
52
 
 
53
 
 
54
namespace geos {
 
55
 
 
56
%extend Coordinate {
 
57
        std::string to_s()
 
58
        {
 
59
                std::ostringstream os;
 
60
                os << "<Coordinate ";
 
61
                os << self->toString();
 
62
                os << ">";
 
63
                return os.str();
 
64
        }
 
65
};
 
66
 
 
67
%extend CoordinateSequence {
 
68
        std::string to_s()
 
69
        {
 
70
                std::ostringstream os;
 
71
                os << "<CoordinateSequence ";
 
72
                os << self->toString();
 
73
                os << ">";
 
74
                return os.str();
 
75
        }
 
76
};
 
77
 
 
78
%extend Envelope {
 
79
        std::string to_s()
 
80
        {
 
81
                std::ostringstream os;
 
82
                os << "<Envelope ";
 
83
                os << self->toString();
 
84
                os << ">";
 
85
                return os.str();
 
86
        }
 
87
};
 
88
 
 
89
 
 
90
%extend Geometry {
 
91
  std::string to_s()
 
92
        {
 
93
                std::ostringstream os;
 
94
                os << "<Geometry ";
 
95
                os << self->toString();
 
96
                os << ">";
 
97
                return os.str();
 
98
        }
 
99
};
 
100
} // namespace geos
 
101
 
 
102
 
 
103
/* Geos uses vectors of pointers to pass around geometries.  These will be 
 
104
         wrapped by SWIG - but we have to be careful.  The problem is
 
105
   if we put a C++ object into the vector that a Ruby object owns, when
 
106
   that Ruby object goes out of scope the C++ object will be freed.  Thus
 
107
   the pointer inside the vector becomes corrupt.  To stop this from happening
 
108
   we have to implement a Ruby mark function, which in turn requires turning
 
109
   on SWIG Ruby Object tracking for these containers.*/
 
110
 
 
111
// First declare mark functions for the containers
 
112
%markfunc std::vector<geos::Geometry *> "mark_GeometryVector";
 
113
%markfunc std::vector<geos::LineString *> "mark_LineStringVector";
 
114
%markfunc std::vector<geos::Polygon *> "mark_PolygonVector";
 
115
 
 
116
// Manually rename methods on vector to get around SWIG 1.3.29 bug
 
117
%rename(__len__) std::vector<geos::Geometry *>::size;
 
118
%rename("empty?") std::vector<geos::Geometry *>::empty;
 
119
%rename(push) std::vector<geos::Geometry *>::push_back;
 
120
 
 
121
%rename(__len__) std::vector<geos::LineString *>::size;
 
122
%rename("empty?") std::vector<geos::LineString *>::empty;
 
123
%rename(push) std::vector<geos::LineString *>::push_back;
 
124
 
 
125
%rename(__len__) std::vector<geos::Polygon *>::size;
 
126
%rename("empty?") std::vector<geos::Polygon *>::empty;
 
127
%rename(push) std::vector<geos::Polygon *>::push_back;
 
128
 
 
129
// Now define the containers
 
130
%template("GeometryVector") std::vector<geos::Geometry *>;
 
131
%template("LineStringVector") std::vector<geos::LineString *>;
 
132
%template("PolygonVector") std::vector<geos::Polygon *>;
 
133
 
 
134
 
 
135
// Now track the objects that go go into the containers, which
 
136
// is Geometry or any class inherited from Geometry
 
137
%trackobjects geos::Geometry;
 
138
%trackobjects geos::Point;
 
139
%trackobjects geos::LineString;
 
140
%trackobjects geos::LinearRing;
 
141
%trackobjects geos::Polygon;
 
142
%trackobjects geos::GeometryCollection;
 
143
%trackobjects geos::MultiPoint;
 
144
%trackobjects geos::MultiLineString;
 
145
%trackobjects geos::MultiPolygon;
 
146
 
 
147
// Last define the mark functions
 
148
%header %{
 
149
        static void mark_GeometryVector(void* ptr)
 
150
        {
 
151
          typedef std::vector<geos::Geometry *> GeometryVector;
 
152
          typedef GeometryVector::iterator GeometryVectorIter;
 
153
          
 
154
          GeometryVector *vec = reinterpret_cast<GeometryVector*>(ptr);
 
155
          GeometryVectorIter iter = vec->begin();
 
156
          GeometryVectorIter last = vec->end();
 
157
          
 
158
                for(; iter != last; ++iter)
 
159
                {
 
160
                        geos::Geometry *geometry = *iter;
 
161
                        VALUE object = SWIG_RubyInstanceFor(geometry);
 
162
                        if (object != Qnil)
 
163
                        {
 
164
                                rb_gc_mark(object);
 
165
                        }
 
166
                        else
 
167
                        {
 
168
                                // This should not happen
 
169
                                rb_raise(rb_eRuntimeError, "Unknown object stored in vector");
 
170
                        }
 
171
                }
 
172
        }
 
173
 
 
174
        static void mark_LineStringVector(void* ptr)
 
175
        {
 
176
          typedef std::vector<geos::LineString *> LineStringVector;
 
177
          typedef LineStringVector::iterator LineStringVectorIter;
 
178
          
 
179
          LineStringVector *vec = reinterpret_cast<LineStringVector*>(ptr);
 
180
          LineStringVectorIter iter = vec->begin();
 
181
          LineStringVectorIter last = vec->end();
 
182
          
 
183
                for(; iter != last; ++iter)
 
184
                {
 
185
                        geos::LineString *geometry = *iter;
 
186
                        VALUE object = SWIG_RubyInstanceFor(geometry);
 
187
                        if (object != Qnil)
 
188
                        {
 
189
                                rb_gc_mark(object);
 
190
                        }
 
191
                        else
 
192
                        {
 
193
                                // This should not happen
 
194
                                rb_raise(rb_eRuntimeError, "Unknown object stored in vector");
 
195
                        }
 
196
                }
 
197
        }
 
198
 
 
199
        static void mark_PolygonVector(void* ptr)
 
200
        {
 
201
          typedef std::vector<geos::Polygon *> PolygonVector;
 
202
          typedef PolygonVector::iterator PolygonVectorIter;
 
203
          
 
204
          PolygonVector *vec = reinterpret_cast<PolygonVector*>(ptr);
 
205
          PolygonVectorIter iter = vec->begin();
 
206
          PolygonVectorIter last = vec->end();
 
207
          
 
208
                for(; iter != last; ++iter)
 
209
                {
 
210
                        geos::Polygon *geometry = *iter;
 
211
                        VALUE object = SWIG_RubyInstanceFor(geometry);
 
212
                        if (object != Qnil)
 
213
                        {
 
214
                                rb_gc_mark(object);
 
215
                        }
 
216
                        else
 
217
                        {
 
218
                                // This should not happen
 
219
                                rb_raise(rb_eRuntimeError, "Unknown object stored in vector");
 
220
                        }
 
221
                }
 
222
        }
 
223
%}