← Back to branch summary

~ubuntu-branches/debian/sid/gdal/sid

« back to all changes in this revision

Viewing changes to swig/ruby/ogr_wrap.cpp

  • Committer: Package Import Robot
  • Author(s): Francesco Paolo Lovergine
  • Date: 2012-05-07 15:04:42 UTC
  • mfrom: (5.5.16 experimental)
  • Revision ID: package-import@ubuntu.com-20120507150442-2eks97loeh6rq005
Tags: 1.9.0-1
* Ready for sid, starting transition.
* All symfiles updated to latest builds.
* Added dh_numpy call in debian/rules to depend on numpy ABI.
* Policy bumped to 3.9.3, no changes required.

Show diffs side-by-side

added added

removed removed

Lines of Context:
swig/ruby/ogr_wrap.cpp
1
 
/* ----------------------------------------------------------------------------
2
 
 * This file was automatically generated by SWIG (http://www.swig.org).
3
 
 * Version 1.3.29
4
 
 * 
5
 
 * This file is not intended to be easily readable and contains a number of 
6
 
 * coding conventions designed to improve portability and efficiency. Do not make
7
 
 * changes to this file unless you know what you are doing--modify the SWIG 
8
 
 * interface file instead. 
9
 
 * ----------------------------------------------------------------------------- */
10
 
 
11
 
#define SWIGRUBY
12
 
 
13
 
#ifdef __cplusplus
14
 
template<class T> class SwigValueWrapper {
15
 
    T *tt;
16
 
public:
17
 
    SwigValueWrapper() : tt(0) { }
18
 
    SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19
 
    SwigValueWrapper(const T& t) : tt(new T(t)) { }
20
 
    ~SwigValueWrapper() { delete tt; } 
21
 
    SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22
 
    operator T&() const { return *tt; }
23
 
    T *operator&() { return tt; }
24
 
private:
25
 
    SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26
 
};
27
 
#endif
28
 
 
29
 
/* -----------------------------------------------------------------------------
30
 
 *  This section contains generic SWIG labels for method/variable
31
 
 *  declarations/attributes, and other compiler dependent labels.
32
 
 * ----------------------------------------------------------------------------- */
33
 
 
34
 
/* template workaround for compilers that cannot correctly implement the C++ standard */
35
 
#ifndef SWIGTEMPLATEDISAMBIGUATOR
36
 
# if defined(__SUNPRO_CC)
37
 
#   if (__SUNPRO_CC <= 0x560)
38
 
#     define SWIGTEMPLATEDISAMBIGUATOR template
39
 
#   else
40
 
#     define SWIGTEMPLATEDISAMBIGUATOR 
41
 
#   endif
42
 
# else
43
 
#   define SWIGTEMPLATEDISAMBIGUATOR 
44
 
# endif
45
 
#endif
46
 
 
47
 
/* inline attribute */
48
 
#ifndef SWIGINLINE
49
 
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
50
 
#   define SWIGINLINE inline
51
 
# else
52
 
#   define SWIGINLINE
53
 
# endif
54
 
#endif
55
 
 
56
 
/* attribute recognised by some compilers to avoid 'unused' warnings */
57
 
#ifndef SWIGUNUSED
58
 
# if defined(__GNUC__)
59
 
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
60
 
#     define SWIGUNUSED __attribute__ ((__unused__)) 
61
 
#   else
62
 
#     define SWIGUNUSED
63
 
#   endif
64
 
# elif defined(__ICC)
65
 
#   define SWIGUNUSED __attribute__ ((__unused__)) 
66
 
# else
67
 
#   define SWIGUNUSED 
68
 
# endif
69
 
#endif
70
 
 
71
 
#ifndef SWIGUNUSEDPARM
72
 
# ifdef __cplusplus
73
 
#   define SWIGUNUSEDPARM(p)
74
 
# else
75
 
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
76
 
# endif
77
 
#endif
78
 
 
79
 
/* internal SWIG method */
80
 
#ifndef SWIGINTERN
81
 
# define SWIGINTERN static SWIGUNUSED
82
 
#endif
83
 
 
84
 
/* internal inline SWIG method */
85
 
#ifndef SWIGINTERNINLINE
86
 
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
87
 
#endif
88
 
 
89
 
/* exporting methods */
90
 
#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
91
 
#  ifndef GCC_HASCLASSVISIBILITY
92
 
#    define GCC_HASCLASSVISIBILITY
93
 
#  endif
94
 
#endif
95
 
 
96
 
#ifndef SWIGEXPORT
97
 
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
98
 
#   if defined(STATIC_LINKED)
99
 
#     define SWIGEXPORT
100
 
#   else
101
 
#     define SWIGEXPORT __declspec(dllexport)
102
 
#   endif
103
 
# else
104
 
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
105
 
#     define SWIGEXPORT __attribute__ ((visibility("default")))
106
 
#   else
107
 
#     define SWIGEXPORT
108
 
#   endif
109
 
# endif
110
 
#endif
111
 
 
112
 
/* calling conventions for Windows */
113
 
#ifndef SWIGSTDCALL
114
 
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
115
 
#   define SWIGSTDCALL __stdcall
116
 
# else
117
 
#   define SWIGSTDCALL
118
 
# endif 
119
 
#endif
120
 
 
121
 
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
122
 
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
123
 
# define _CRT_SECURE_NO_DEPRECATE
124
 
#endif
125
 
 
126
 
/* -----------------------------------------------------------------------------
127
 
 *  This section contains generic SWIG labels for method/variable
128
 
 *  declarations/attributes, and other compiler dependent labels.
129
 
 * ----------------------------------------------------------------------------- */
130
 
 
131
 
/* template workaround for compilers that cannot correctly implement the C++ standard */
132
 
#ifndef SWIGTEMPLATEDISAMBIGUATOR
133
 
# if defined(__SUNPRO_CC)
134
 
#   if (__SUNPRO_CC <= 0x560)
135
 
#     define SWIGTEMPLATEDISAMBIGUATOR template
136
 
#   else
137
 
#     define SWIGTEMPLATEDISAMBIGUATOR 
138
 
#   endif
139
 
# else
140
 
#   define SWIGTEMPLATEDISAMBIGUATOR 
141
 
# endif
142
 
#endif
143
 
 
144
 
/* inline attribute */
145
 
#ifndef SWIGINLINE
146
 
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
147
 
#   define SWIGINLINE inline
148
 
# else
149
 
#   define SWIGINLINE
150
 
# endif
151
 
#endif
152
 
 
153
 
/* attribute recognised by some compilers to avoid 'unused' warnings */
154
 
#ifndef SWIGUNUSED
155
 
# if defined(__GNUC__)
156
 
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
157
 
#     define SWIGUNUSED __attribute__ ((__unused__)) 
158
 
#   else
159
 
#     define SWIGUNUSED
160
 
#   endif
161
 
# elif defined(__ICC)
162
 
#   define SWIGUNUSED __attribute__ ((__unused__)) 
163
 
# else
164
 
#   define SWIGUNUSED 
165
 
# endif
166
 
#endif
167
 
 
168
 
#ifndef SWIGUNUSEDPARM
169
 
# ifdef __cplusplus
170
 
#   define SWIGUNUSEDPARM(p)
171
 
# else
172
 
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
173
 
# endif
174
 
#endif
175
 
 
176
 
/* internal SWIG method */
177
 
#ifndef SWIGINTERN
178
 
# define SWIGINTERN static SWIGUNUSED
179
 
#endif
180
 
 
181
 
/* internal inline SWIG method */
182
 
#ifndef SWIGINTERNINLINE
183
 
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
184
 
#endif
185
 
 
186
 
/* exporting methods */
187
 
#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
188
 
#  ifndef GCC_HASCLASSVISIBILITY
189
 
#    define GCC_HASCLASSVISIBILITY
190
 
#  endif
191
 
#endif
192
 
 
193
 
#ifndef SWIGEXPORT
194
 
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
195
 
#   if defined(STATIC_LINKED)
196
 
#     define SWIGEXPORT
197
 
#   else
198
 
#     define SWIGEXPORT __declspec(dllexport)
199
 
#   endif
200
 
# else
201
 
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
202
 
#     define SWIGEXPORT __attribute__ ((visibility("default")))
203
 
#   else
204
 
#     define SWIGEXPORT
205
 
#   endif
206
 
# endif
207
 
#endif
208
 
 
209
 
/* calling conventions for Windows */
210
 
#ifndef SWIGSTDCALL
211
 
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
212
 
#   define SWIGSTDCALL __stdcall
213
 
# else
214
 
#   define SWIGSTDCALL
215
 
# endif 
216
 
#endif
217
 
 
218
 
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
219
 
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
220
 
# define _CRT_SECURE_NO_DEPRECATE
221
 
#endif
222
 
 
223
 
/* -----------------------------------------------------------------------------
224
 
 * swigrun.swg
225
 
 *
226
 
 * This file contains generic CAPI SWIG runtime support for pointer
227
 
 * type checking.
228
 
 * ----------------------------------------------------------------------------- */
229
 
 
230
 
/* This should only be incremented when either the layout of swig_type_info changes,
231
 
   or for whatever reason, the runtime changes incompatibly */
232
 
#define SWIG_RUNTIME_VERSION "2"
233
 
 
234
 
/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
235
 
#ifdef SWIG_TYPE_TABLE
236
 
# define SWIG_QUOTE_STRING(x) #x
237
 
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
238
 
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
239
 
#else
240
 
# define SWIG_TYPE_TABLE_NAME
241
 
#endif
242
 
 
243
 
/*
244
 
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
245
 
  creating a static or dynamic library from the swig runtime code.
246
 
  In 99.9% of the cases, swig just needs to declare them as 'static'.
247
 
  
248
 
  But only do this if is strictly necessary, ie, if you have problems
249
 
  with your compiler or so.
250
 
*/
251
 
 
252
 
#ifndef SWIGRUNTIME
253
 
# define SWIGRUNTIME SWIGINTERN
254
 
#endif
255
 
 
256
 
#ifndef SWIGRUNTIMEINLINE
257
 
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
258
 
#endif
259
 
 
260
 
/*  Generic buffer size */
261
 
#ifndef SWIG_BUFFER_SIZE
262
 
# define SWIG_BUFFER_SIZE 1024
263
 
#endif
264
 
 
265
 
/* Flags for pointer conversions */
266
 
#define SWIG_POINTER_DISOWN        0x1
267
 
 
268
 
/* Flags for new pointer objects */
269
 
#define SWIG_POINTER_OWN           0x1
270
 
 
271
 
 
272
 
/* 
273
 
   Flags/methods for returning states.
274
 
   
275
 
   The swig conversion methods, as ConvertPtr, return and integer 
276
 
   that tells if the conversion was successful or not. And if not,
277
 
   an error code can be returned (see swigerrors.swg for the codes).
278
 
   
279
 
   Use the following macros/flags to set or process the returning
280
 
   states.
281
 
   
282
 
   In old swig versions, you usually write code as:
283
 
 
284
 
     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
285
 
       // success code
286
 
     } else {
287
 
       //fail code
288
 
     }
289
 
 
290
 
   Now you can be more explicit as:
291
 
 
292
 
    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
293
 
    if (SWIG_IsOK(res)) {
294
 
      // success code
295
 
    } else {
296
 
      // fail code
297
 
    }
298
 
 
299
 
   that seems to be the same, but now you can also do
300
 
 
301
 
    Type *ptr;
302
 
    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
303
 
    if (SWIG_IsOK(res)) {
304
 
      // success code
305
 
      if (SWIG_IsNewObj(res) {
306
 
        ...
307
 
        delete *ptr;
308
 
      } else {
309
 
        ...
310
 
      }
311
 
    } else {
312
 
      // fail code
313
 
    }
314
 
    
315
 
   I.e., now SWIG_ConvertPtr can return new objects and you can
316
 
   identify the case and take care of the deallocation. Of course that
317
 
   requires also to SWIG_ConvertPtr to return new result values, as
318
 
 
319
 
      int SWIG_ConvertPtr(obj, ptr,...) {         
320
 
        if (<obj is ok>) {                             
321
 
          if (<need new object>) {                     
322
 
            *ptr = <ptr to new allocated object>; 
323
 
            return SWIG_NEWOBJ;                
324
 
          } else {                                     
325
 
            *ptr = <ptr to old object>;        
326
 
            return SWIG_OLDOBJ;                
327
 
          }                                    
328
 
        } else {                                       
329
 
          return SWIG_BADOBJ;                  
330
 
        }                                              
331
 
      }
332
 
 
333
 
   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
334
 
   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
335
 
   swig errors code.
336
 
 
337
 
   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
338
 
   allows to return the 'cast rank', for example, if you have this
339
 
 
340
 
       int food(double)
341
 
       int fooi(int);
342
 
 
343
 
   and you call
344
 
 
345
 
      food(1)   // cast rank '1'  (1 -> 1.0)
346
 
      fooi(1)   // cast rank '0'
347
 
 
348
 
   just use the SWIG_AddCast()/SWIG_CheckState()
349
 
 
350
 
 
351
 
 */
352
 
#define SWIG_OK                    (0) 
353
 
#define SWIG_ERROR                 (-1)
354
 
#define SWIG_IsOK(r)               (r >= 0)
355
 
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)  
356
 
 
357
 
/* The CastRankLimit says how many bits are used for the cast rank */
358
 
#define SWIG_CASTRANKLIMIT         (1 << 8)
359
 
/* The NewMask denotes the object was created (using new/malloc) */
360
 
#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
361
 
/* The TmpMask is for in/out typemaps that use temporal objects */
362
 
#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
363
 
/* Simple returning values */
364
 
#define SWIG_BADOBJ                (SWIG_ERROR)
365
 
#define SWIG_OLDOBJ                (SWIG_OK)
366
 
#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
367
 
#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
368
 
/* Check, add and del mask methods */
369
 
#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
370
 
#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
371
 
#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
372
 
#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
373
 
#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
374
 
#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
375
 
 
376
 
 
377
 
/* Cast-Rank Mode */
378
 
#if defined(SWIG_CASTRANK_MODE)
379
 
#  ifndef SWIG_TypeRank
380
 
#    define SWIG_TypeRank             unsigned long
381
 
#  endif
382
 
#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
383
 
#    define SWIG_MAXCASTRANK          (2)
384
 
#  endif
385
 
#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
386
 
#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
387
 
SWIGINTERNINLINE int SWIG_AddCast(int r) { 
388
 
  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
389
 
}
390
 
SWIGINTERNINLINE int SWIG_CheckState(int r) { 
391
 
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; 
392
 
}
393
 
#else /* no cast-rank mode */
394
 
#  define SWIG_AddCast
395
 
#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
396
 
#endif
397
 
 
398
 
 
399
 
 
400
 
 
401
 
#include <string.h>
402
 
 
403
 
#ifdef __cplusplus
404
 
extern "C" {
405
 
#endif
406
 
 
407
 
typedef void *(*swig_converter_func)(void *);
408
 
typedef struct swig_type_info *(*swig_dycast_func)(void **);
409
 
 
410
 
/* Structure to store inforomation on one type */
411
 
typedef struct swig_type_info {
412
 
  const char             *name;                 /* mangled name of this type */
413
 
  const char             *str;                  /* human readable name of this type */
414
 
  swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
415
 
  struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
416
 
  void                   *clientdata;           /* language specific type data */
417
 
  int                    owndata;               /* flag if the structure owns the clientdata */
418
 
} swig_type_info;
419
 
 
420
 
/* Structure to store a type and conversion function used for casting */
421
 
typedef struct swig_cast_info {
422
 
  swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
423
 
  swig_converter_func     converter;            /* function to cast the void pointers */
424
 
  struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
425
 
  struct swig_cast_info  *prev;                 /* pointer to the previous cast */
426
 
} swig_cast_info;
427
 
 
428
 
/* Structure used to store module information
429
 
 * Each module generates one structure like this, and the runtime collects
430
 
 * all of these structures and stores them in a circularly linked list.*/
431
 
typedef struct swig_module_info {
432
 
  swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
433
 
  size_t                 size;                  /* Number of types in this module */
434
 
  struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
435
 
  swig_type_info         **type_initial;        /* Array of initially generated type structures */
436
 
  swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
437
 
  void                    *clientdata;          /* Language specific module data */
438
 
} swig_module_info;
439
 
 
440
 
/* 
441
 
  Compare two type names skipping the space characters, therefore
442
 
  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
443
 
 
444
 
  Return 0 when the two name types are equivalent, as in
445
 
  strncmp, but skipping ' '.
446
 
*/
447
 
SWIGRUNTIME int
448
 
SWIG_TypeNameComp(const char *f1, const char *l1,
449
 
                  const char *f2, const char *l2) {
450
 
  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
451
 
    while ((*f1 == ' ') && (f1 != l1)) ++f1;
452
 
    while ((*f2 == ' ') && (f2 != l2)) ++f2;
453
 
    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
454
 
  }
455
 
  return (l1 - f1) - (l2 - f2);
456
 
}
457
 
 
458
 
/*
459
 
  Check type equivalence in a name list like <name1>|<name2>|...
460
 
  Return 0 if not equal, 1 if equal
461
 
*/
462
 
SWIGRUNTIME int
463
 
SWIG_TypeEquiv(const char *nb, const char *tb) {
464
 
  int equiv = 0;
465
 
  const char* te = tb + strlen(tb);
466
 
  const char* ne = nb;
467
 
  while (!equiv && *ne) {
468
 
    for (nb = ne; *ne; ++ne) {
469
 
      if (*ne == '|') break;
470
 
    }
471
 
    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
472
 
    if (*ne) ++ne;
473
 
  }
474
 
  return equiv;
475
 
}
476
 
 
477
 
/*
478
 
  Check type equivalence in a name list like <name1>|<name2>|...
479
 
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
480
 
*/
481
 
SWIGRUNTIME int
482
 
SWIG_TypeCompare(const char *nb, const char *tb) {
483
 
  int equiv = 0;
484
 
  const char* te = tb + strlen(tb);
485
 
  const char* ne = nb;
486
 
  while (!equiv && *ne) {
487
 
    for (nb = ne; *ne; ++ne) {
488
 
      if (*ne == '|') break;
489
 
    }
490
 
    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
491
 
    if (*ne) ++ne;
492
 
  }
493
 
  return equiv;
494
 
}
495
 
 
496
 
 
497
 
/* think of this as a c++ template<> or a scheme macro */
498
 
#define SWIG_TypeCheck_Template(comparison, ty)         \
499
 
  if (ty) {                                             \
500
 
    swig_cast_info *iter = ty->cast;                    \
501
 
    while (iter) {                                      \
502
 
      if (comparison) {                                 \
503
 
        if (iter == ty->cast) return iter;              \
504
 
        /* Move iter to the top of the linked list */   \
505
 
        iter->prev->next = iter->next;                  \
506
 
        if (iter->next)                                 \
507
 
          iter->next->prev = iter->prev;                \
508
 
        iter->next = ty->cast;                          \
509
 
        iter->prev = 0;                                 \
510
 
        if (ty->cast) ty->cast->prev = iter;            \
511
 
        ty->cast = iter;                                \
512
 
        return iter;                                    \
513
 
      }                                                 \
514
 
      iter = iter->next;                                \
515
 
    }                                                   \
516
 
  }                                                     \
517
 
  return 0
518
 
 
519
 
/*
520
 
  Check the typename
521
 
*/
522
 
SWIGRUNTIME swig_cast_info *
523
 
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
524
 
  SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
525
 
}
526
 
 
527
 
/* Same as previous function, except strcmp is replaced with a pointer comparison */
528
 
SWIGRUNTIME swig_cast_info *
529
 
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
530
 
  SWIG_TypeCheck_Template(iter->type == from, into);
531
 
}
532
 
 
533
 
/*
534
 
  Cast a pointer up an inheritance hierarchy
535
 
*/
536
 
SWIGRUNTIMEINLINE void *
537
 
SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
538
 
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
539
 
}
540
 
 
541
 
/* 
542
 
   Dynamic pointer casting. Down an inheritance hierarchy
543
 
*/
544
 
SWIGRUNTIME swig_type_info *
545
 
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
546
 
  swig_type_info *lastty = ty;
547
 
  if (!ty || !ty->dcast) return ty;
548
 
  while (ty && (ty->dcast)) {
549
 
    ty = (*ty->dcast)(ptr);
550
 
    if (ty) lastty = ty;
551
 
  }
552
 
  return lastty;
553
 
}
554
 
 
555
 
/*
556
 
  Return the name associated with this type
557
 
*/
558
 
SWIGRUNTIMEINLINE const char *
559
 
SWIG_TypeName(const swig_type_info *ty) {
560
 
  return ty->name;
561
 
}
562
 
 
563
 
/*
564
 
  Return the pretty name associated with this type,
565
 
  that is an unmangled type name in a form presentable to the user.
566
 
*/
567
 
SWIGRUNTIME const char *
568
 
SWIG_TypePrettyName(const swig_type_info *type) {
569
 
  /* The "str" field contains the equivalent pretty names of the
570
 
     type, separated by vertical-bar characters.  We choose
571
 
     to print the last name, as it is often (?) the most
572
 
     specific. */
573
 
  if (!type) return NULL;
574
 
  if (type->str != NULL) {
575
 
    const char *last_name = type->str;
576
 
    const char *s;
577
 
    for (s = type->str; *s; s++)
578
 
      if (*s == '|') last_name = s+1;
579
 
    return last_name;
580
 
  }
581
 
  else
582
 
    return type->name;
583
 
}
584
 
 
585
 
/* 
586
 
   Set the clientdata field for a type
587
 
*/
588
 
SWIGRUNTIME void
589
 
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
590
 
  swig_cast_info *cast = ti->cast;
591
 
  /* if (ti->clientdata == clientdata) return; */
592
 
  ti->clientdata = clientdata;
593
 
  
594
 
  while (cast) {
595
 
    if (!cast->converter) {
596
 
      swig_type_info *tc = cast->type;
597
 
      if (!tc->clientdata) {
598
 
        SWIG_TypeClientData(tc, clientdata);
599
 
      }
600
 
    }    
601
 
    cast = cast->next;
602
 
  }
603
 
}
604
 
SWIGRUNTIME void
605
 
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
606
 
  SWIG_TypeClientData(ti, clientdata);
607
 
  ti->owndata = 1;
608
 
}
609
 
  
610
 
/*
611
 
  Search for a swig_type_info structure only by mangled name
612
 
  Search is a O(log #types)
613
 
  
614
 
  We start searching at module start, and finish searching when start == end.  
615
 
  Note: if start == end at the beginning of the function, we go all the way around
616
 
  the circular list.
617
 
*/
618
 
SWIGRUNTIME swig_type_info *
619
 
SWIG_MangledTypeQueryModule(swig_module_info *start, 
620
 
                            swig_module_info *end, 
621
 
                            const char *name) {
622
 
  swig_module_info *iter = start;
623
 
  do {
624
 
    if (iter->size) {
625
 
      register size_t l = 0;
626
 
      register size_t r = iter->size - 1;
627
 
      do {
628
 
        /* since l+r >= 0, we can (>> 1) instead (/ 2) */
629
 
        register size_t i = (l + r) >> 1; 
630
 
        const char *iname = iter->types[i]->name;
631
 
        if (iname) {
632
 
          register int compare = strcmp(name, iname);
633
 
          if (compare == 0) {       
634
 
            return iter->types[i];
635
 
          } else if (compare < 0) {
636
 
            if (i) {
637
 
              r = i - 1;
638
 
            } else {
639
 
              break;
640
 
            }
641
 
          } else if (compare > 0) {
642
 
            l = i + 1;
643
 
          }
644
 
        } else {
645
 
          break; /* should never happen */
646
 
        }
647
 
      } while (l <= r);
648
 
    }
649
 
    iter = iter->next;
650
 
  } while (iter != end);
651
 
  return 0;
652
 
}
653
 
 
654
 
/*
655
 
  Search for a swig_type_info structure for either a mangled name or a human readable name.
656
 
  It first searches the mangled names of the types, which is a O(log #types)
657
 
  If a type is not found it then searches the human readable names, which is O(#types).
658
 
  
659
 
  We start searching at module start, and finish searching when start == end.  
660
 
  Note: if start == end at the beginning of the function, we go all the way around
661
 
  the circular list.
662
 
*/
663
 
SWIGRUNTIME swig_type_info *
664
 
SWIG_TypeQueryModule(swig_module_info *start, 
665
 
                     swig_module_info *end, 
666
 
                     const char *name) {
667
 
  /* STEP 1: Search the name field using binary search */
668
 
  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
669
 
  if (ret) {
670
 
    return ret;
671
 
  } else {
672
 
    /* STEP 2: If the type hasn't been found, do a complete search
673
 
       of the str field (the human readable name) */
674
 
    swig_module_info *iter = start;
675
 
    do {
676
 
      register size_t i = 0;
677
 
      for (; i < iter->size; ++i) {
678
 
        if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
679
 
          return iter->types[i];
680
 
      }
681
 
      iter = iter->next;
682
 
    } while (iter != end);
683
 
  }
684
 
  
685
 
  /* neither found a match */
686
 
  return 0;
687
 
}
688
 
 
689
 
/* 
690
 
   Pack binary data into a string
691
 
*/
692
 
SWIGRUNTIME char *
693
 
SWIG_PackData(char *c, void *ptr, size_t sz) {
694
 
  static const char hex[17] = "0123456789abcdef";
695
 
  register const unsigned char *u = (unsigned char *) ptr;
696
 
  register const unsigned char *eu =  u + sz;
697
 
  for (; u != eu; ++u) {
698
 
    register unsigned char uu = *u;
699
 
    *(c++) = hex[(uu & 0xf0) >> 4];
700
 
    *(c++) = hex[uu & 0xf];
701
 
  }
702
 
  return c;
703
 
}
704
 
 
705
 
/* 
706
 
   Unpack binary data from a string
707
 
*/
708
 
SWIGRUNTIME const char *
709
 
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
710
 
  register unsigned char *u = (unsigned char *) ptr;
711
 
  register const unsigned char *eu = u + sz;
712
 
  for (; u != eu; ++u) {
713
 
    register char d = *(c++);
714
 
    register unsigned char uu;
715
 
    if ((d >= '0') && (d <= '9'))
716
 
      uu = ((d - '0') << 4);
717
 
    else if ((d >= 'a') && (d <= 'f'))
718
 
      uu = ((d - ('a'-10)) << 4);
719
 
    else 
720
 
      return (char *) 0;
721
 
    d = *(c++);
722
 
    if ((d >= '0') && (d <= '9'))
723
 
      uu |= (d - '0');
724
 
    else if ((d >= 'a') && (d <= 'f'))
725
 
      uu |= (d - ('a'-10));
726
 
    else 
727
 
      return (char *) 0;
728
 
    *u = uu;
729
 
  }
730
 
  return c;
731
 
}
732
 
 
733
 
/* 
734
 
   Pack 'void *' into a string buffer.
735
 
*/
736
 
SWIGRUNTIME char *
737
 
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
738
 
  char *r = buff;
739
 
  if ((2*sizeof(void *) + 2) > bsz) return 0;
740
 
  *(r++) = '_';
741
 
  r = SWIG_PackData(r,&ptr,sizeof(void *));
742
 
  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
743
 
  strcpy(r,name);
744
 
  return buff;
745
 
}
746
 
 
747
 
SWIGRUNTIME const char *
748
 
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
749
 
  if (*c != '_') {
750
 
    if (strcmp(c,"NULL") == 0) {
751
 
      *ptr = (void *) 0;
752
 
      return name;
753
 
    } else {
754
 
      return 0;
755
 
    }
756
 
  }
757
 
  return SWIG_UnpackData(++c,ptr,sizeof(void *));
758
 
}
759
 
 
760
 
SWIGRUNTIME char *
761
 
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
762
 
  char *r = buff;
763
 
  size_t lname = (name ? strlen(name) : 0);
764
 
  if ((2*sz + 2 + lname) > bsz) return 0;
765
 
  *(r++) = '_';
766
 
  r = SWIG_PackData(r,ptr,sz);
767
 
  if (lname) {
768
 
    strncpy(r,name,lname+1);
769
 
  } else {
770
 
    *r = 0;
771
 
  }
772
 
  return buff;
773
 
}
774
 
 
775
 
SWIGRUNTIME const char *
776
 
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
777
 
  if (*c != '_') {
778
 
    if (strcmp(c,"NULL") == 0) {
779
 
      memset(ptr,0,sz);
780
 
      return name;
781
 
    } else {
782
 
      return 0;
783
 
    }
784
 
  }
785
 
  return SWIG_UnpackData(++c,ptr,sz);
786
 
}
787
 
 
788
 
#ifdef __cplusplus
789
 
}
790
 
#endif
791
 
 
792
 
/*  Errors in SWIG */
793
 
#define  SWIG_UnknownError         -1 
794
 
#define  SWIG_IOError              -2 
795
 
#define  SWIG_RuntimeError         -3 
796
 
#define  SWIG_IndexError           -4 
797
 
#define  SWIG_TypeError            -5 
798
 
#define  SWIG_DivisionByZero       -6 
799
 
#define  SWIG_OverflowError        -7 
800
 
#define  SWIG_SyntaxError          -8 
801
 
#define  SWIG_ValueError           -9 
802
 
#define  SWIG_SystemError          -10
803
 
#define  SWIG_AttributeError       -11
804
 
#define  SWIG_MemoryError          -12 
805
 
#define  SWIG_NullReferenceError   -13
806
 
 
807
 
 
808
 
 
809
 
#include <ruby.h>
810
 
 
811
 
/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
812
 
#ifndef NUM2LL
813
 
#define NUM2LL(x) NUM2LONG((x))
814
 
#endif
815
 
#ifndef LL2NUM
816
 
#define LL2NUM(x) INT2NUM((long) (x))
817
 
#endif
818
 
#ifndef ULL2NUM
819
 
#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
820
 
#endif
821
 
 
822
 
/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
823
 
#ifndef NUM2ULL
824
 
#ifdef HAVE_LONG_LONG
825
 
#define NUM2ULL(x) rb_num2ull((x))
826
 
#else
827
 
#define NUM2ULL(x) NUM2ULONG(x)
828
 
#endif
829
 
#endif
830
 
 
831
 
/*
832
 
 * Need to be very careful about how these macros are defined, especially
833
 
 * when compiling C++ code or C code with an ANSI C compiler.
834
 
 *
835
 
 * VALUEFUNC(f) is a macro used to typecast a C function that implements
836
 
 * a Ruby method so that it can be passed as an argument to API functions
837
 
 * like rb_define_method() and rb_define_singleton_method().
838
 
 *
839
 
 * VOIDFUNC(f) is a macro used to typecast a C function that implements
840
 
 * either the "mark" or "free" stuff for a Ruby Data object, so that it
841
 
 * can be passed as an argument to API functions like Data_Wrap_Struct()
842
 
 * and Data_Make_Struct().
843
 
 */
844
 
 
845
 
#ifdef __cplusplus
846
 
#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
847
 
#    define PROTECTFUNC(f) ((VALUE (*)()) f)
848
 
#    define VALUEFUNC(f) ((VALUE (*)()) f)
849
 
#    define VOIDFUNC(f)  ((void (*)()) f)
850
 
#  else
851
 
#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
852
 
#      define PROTECTFUNC(f) ((VALUE (*)()) f)
853
 
#      define VALUEFUNC(f) ((VALUE (*)()) f)
854
 
#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
855
 
#    else /* These definitions should work for Ruby 1.7+ */
856
 
#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
857
 
#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
858
 
#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
859
 
#    endif
860
 
#  endif
861
 
#else
862
 
#  define VALUEFUNC(f) (f)
863
 
#  define VOIDFUNC(f) (f)
864
 
#endif
865
 
 
866
 
/* Don't use for expressions have side effect */
867
 
#ifndef RB_STRING_VALUE
868
 
#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
869
 
#endif
870
 
#ifndef StringValue
871
 
#define StringValue(s) RB_STRING_VALUE(s)
872
 
#endif
873
 
#ifndef StringValuePtr
874
 
#define StringValuePtr(s) RSTRING(RB_STRING_VALUE(s))->ptr
875
 
#endif
876
 
#ifndef StringValueLen
877
 
#define StringValueLen(s) RSTRING(RB_STRING_VALUE(s))->len
878
 
#endif
879
 
#ifndef SafeStringValue
880
 
#define SafeStringValue(v) do {\
881
 
    StringValue(v);\
882
 
    rb_check_safe_str(v);\
883
 
} while (0)
884
 
#endif
885
 
 
886
 
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
887
 
#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
888
 
#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
889
 
#endif
890
 
 
891
 
 
892
 
/* -----------------------------------------------------------------------------
893
 
 * error manipulation
894
 
 * ----------------------------------------------------------------------------- */
895
 
 
896
 
 
897
 
/* Define some additional error types */
898
 
#define SWIG_ObjectPreviouslyDeletedError  -100
899
 
 
900
 
 
901
 
/* Define custom exceptions for errors that do not map to existing Ruby
902
 
   exceptions.  Note this only works for C++ since a global cannot be
903
 
   initialized by a funtion in C.  For C, fallback to rb_eRuntimeError.*/
904
 
 
905
 
SWIGINTERN VALUE 
906
 
getNullReferenceError(void) {
907
 
  static int init = 0;
908
 
  static VALUE rb_eNullReferenceError ;
909
 
  if (!init) {
910
 
    init = 1;
911
 
    rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
912
 
  }
913
 
  return rb_eNullReferenceError;
914
 
} 
915
 
 
916
 
SWIGINTERN VALUE 
917
 
getObjectPreviouslyDeletedError(void) {
918
 
  static int init = 0;
919
 
  static VALUE rb_eObjectPreviouslyDeleted ;
920
 
  if (!init) {
921
 
    init = 1;
922
 
    rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
923
 
  }
924
 
  return rb_eObjectPreviouslyDeleted;
925
 
} 
926
 
 
927
 
 
928
 
SWIGINTERN VALUE
929
 
SWIG_Ruby_ErrorType(int SWIG_code) {
930
 
  VALUE type;
931
 
  switch (SWIG_code) {
932
 
  case SWIG_MemoryError:
933
 
    type = rb_eNoMemError;
934
 
    break;
935
 
  case SWIG_IOError:
936
 
    type = rb_eIOError;
937
 
    break;
938
 
  case SWIG_RuntimeError:
939
 
    type = rb_eRuntimeError;
940
 
    break;
941
 
  case SWIG_IndexError:
942
 
    type = rb_eIndexError;
943
 
    break;
944
 
  case SWIG_TypeError:
945
 
    type = rb_eTypeError;
946
 
    break;
947
 
  case SWIG_DivisionByZero:
948
 
    type = rb_eZeroDivError;
949
 
    break;
950
 
  case SWIG_OverflowError:
951
 
    type = rb_eRangeError;
952
 
    break;
953
 
  case SWIG_SyntaxError:
954
 
    type = rb_eSyntaxError;
955
 
    break;
956
 
  case SWIG_ValueError:
957
 
    type = rb_eArgError;
958
 
    break;
959
 
  case SWIG_SystemError:
960
 
    type = rb_eFatal;
961
 
    break;
962
 
  case SWIG_AttributeError:
963
 
    type = rb_eRuntimeError;
964
 
    break;
965
 
  case SWIG_NullReferenceError:
966
 
    type = getNullReferenceError();
967
 
    break;
968
 
  case SWIG_ObjectPreviouslyDeletedError:
969
 
    type = getObjectPreviouslyDeletedError();
970
 
    break;
971
 
  case SWIG_UnknownError:
972
 
    type = rb_eRuntimeError;
973
 
    break;
974
 
  default:
975
 
    type = rb_eRuntimeError;
976
 
  }
977
 
  return type;
978
 
}
979
 
 
980
 
 
981
 
 
982
 
 
983
 
/* -----------------------------------------------------------------------------
984
 
 * See the LICENSE file for information on copyright, usage and redistribution
985
 
 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
986
 
 *
987
 
 * rubytracking.swg
988
 
 *
989
 
 * This file contains support for tracking mappings from 
990
 
 * Ruby objects to C++ objects.  This functionality is needed
991
 
 * to implement mark functions for Ruby's mark and sweep
992
 
 * garbage collector.
993
 
 * ----------------------------------------------------------------------------- */
994
 
 
995
 
#ifdef __cplusplus
996
 
extern "C" {
997
 
#endif
998
 
 
999
 
 
1000
 
/* Global Ruby hash table to store Trackings from C/C++
1001
 
   structs to Ruby Objects. */
1002
 
static VALUE swig_ruby_trackings;
1003
 
 
1004
 
/* Global variable that stores a reference to the ruby
1005
 
   hash table delete function. */
1006
 
static ID swig_ruby_hash_delete = 0;
1007
 
 
1008
 
/* Setup a Ruby hash table to store Trackings */
1009
 
SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
1010
 
  /* Create a ruby hash table to store Trackings from C++ 
1011
 
     objects to Ruby objects.  Also make sure to tell
1012
 
     the garabage collector about the hash table. */
1013
 
  swig_ruby_trackings = rb_hash_new();
1014
 
  rb_gc_register_address(&swig_ruby_trackings);
1015
 
  
1016
 
  /* Now store a reference to the hash table delete function
1017
 
     so that we only have to look it up once.*/
1018
 
  swig_ruby_hash_delete = rb_intern("delete");
1019
 
}
1020
 
 
1021
 
/* Get a Ruby number to reference a pointer */
1022
 
SWIGRUNTIME VALUE SWIG_RubyPtrToReference(void* ptr) {
1023
 
  /* We cast the pointer to an unsigned long
1024
 
     and then store a reference to it using
1025
 
     a Ruby number object. */
1026
 
 
1027
 
  /* Convert the pointer to a Ruby number */
1028
 
  unsigned long value = (unsigned long) ptr;
1029
 
  return LONG2NUM(value);
1030
 
}
1031
 
 
1032
 
/* Get a Ruby number to reference an object */
1033
 
SWIGRUNTIME VALUE SWIG_RubyObjectToReference(VALUE object) {
1034
 
  /* We cast the object to an unsigned long
1035
 
     and then store a reference to it using
1036
 
     a Ruby number object. */
1037
 
 
1038
 
  /* Convert the Object to a Ruby number */
1039
 
  unsigned long value = (unsigned long) object;
1040
 
  return LONG2NUM(value);
1041
 
}
1042
 
 
1043
 
/* Get a Ruby object from a previously stored reference */
1044
 
SWIGRUNTIME VALUE SWIG_RubyReferenceToObject(VALUE reference) {
1045
 
  /* The provided Ruby number object is a reference
1046
 
     to the Ruby object we want.*/
1047
 
 
1048
 
  /* First convert the Ruby number to a C number */
1049
 
  unsigned long value = NUM2LONG(reference);
1050
 
  return (VALUE) value;
1051
 
}
1052
 
 
1053
 
/* Add a Tracking from a C/C++ struct to a Ruby object */
1054
 
SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
1055
 
  /* In a Ruby hash table we store the pointer and
1056
 
     the associated Ruby object.  The trick here is
1057
 
     that we cannot store the Ruby object directly - if
1058
 
     we do then it cannot be garbage collected.  So
1059
 
     instead we typecast it as a unsigned long and
1060
 
     convert it to a Ruby number object.*/
1061
 
 
1062
 
  /* Get a reference to the pointer as a Ruby number */
1063
 
  VALUE key = SWIG_RubyPtrToReference(ptr);
1064
 
 
1065
 
  /* Get a reference to the Ruby object as a Ruby number */
1066
 
  VALUE value = SWIG_RubyObjectToReference(object);
1067
 
 
1068
 
  /* Store the mapping to the global hash table. */
1069
 
  rb_hash_aset(swig_ruby_trackings, key, value);
1070
 
}
1071
 
 
1072
 
/* Get the Ruby object that owns the specified C/C++ struct */
1073
 
SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
1074
 
  /* Get a reference to the pointer as a Ruby number */
1075
 
  VALUE key = SWIG_RubyPtrToReference(ptr);
1076
 
 
1077
 
  /* Now lookup the value stored in the global hash table */
1078
 
  VALUE value = rb_hash_aref(swig_ruby_trackings, key);
1079
 
        
1080
 
  if (value == Qnil) {
1081
 
    /* No object exists - return nil. */
1082
 
    return Qnil;
1083
 
  }
1084
 
  else {
1085
 
    /* Convert this value to Ruby object */
1086
 
    return SWIG_RubyReferenceToObject(value);
1087
 
  }
1088
 
}
1089
 
 
1090
 
/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
1091
 
   is very important to remove objects once they are destroyed
1092
 
   since the same memory address may be reused later to create
1093
 
   a new object. */
1094
 
SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
1095
 
  /* Get a reference to the pointer as a Ruby number */
1096
 
  VALUE key = SWIG_RubyPtrToReference(ptr);
1097
 
 
1098
 
  /* Delete the object from the hash table by calling Ruby's
1099
 
     do this we need to call the Hash.delete method.*/
1100
 
  rb_funcall(swig_ruby_trackings, swig_ruby_hash_delete, 1, key);
1101
 
}
1102
 
 
1103
 
/* This is a helper method that unlinks a Ruby object from its
1104
 
   underlying C++ object.  This is needed if the lifetime of the
1105
 
   Ruby object is longer than the C++ object */
1106
 
SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
1107
 
  VALUE object = SWIG_RubyInstanceFor(ptr);
1108
 
 
1109
 
  if (object != Qnil) {
1110
 
    DATA_PTR(object) = 0;
1111
 
  }
1112
 
}
1113
 
 
1114
 
 
1115
 
#ifdef __cplusplus
1116
 
}
1117
 
#endif
1118
 
 
1119
 
/* -----------------------------------------------------------------------------
1120
 
 * Ruby API portion that goes into the runtime
1121
 
 * ----------------------------------------------------------------------------- */
1122
 
 
1123
 
#ifdef __cplusplus
1124
 
extern "C" {
1125
 
#endif
1126
 
 
1127
 
SWIGINTERN VALUE
1128
 
SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
1129
 
  if (NIL_P(target)) {
1130
 
    target = o;
1131
 
  } else {
1132
 
    if (TYPE(target) != T_ARRAY) {
1133
 
      VALUE o2 = target;
1134
 
      target = rb_ary_new();
1135
 
      rb_ary_push(target, o2);
1136
 
    }
1137
 
    rb_ary_push(target, o);
1138
 
  }
1139
 
  return target;
1140
 
}
1141
 
 
1142
 
#ifdef __cplusplus
1143
 
}
1144
 
#endif
1145
 
 
1146
 
 
1147
 
/* -----------------------------------------------------------------------------
1148
 
 * See the LICENSE file for information on copyright, usage and redistribution
1149
 
 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
1150
 
 *
1151
 
 * rubyrun.swg
1152
 
 *
1153
 
 * This file contains the runtime support for Ruby modules
1154
 
 * and includes code for managing global variables and pointer
1155
 
 * type checking.
1156
 
 * ----------------------------------------------------------------------------- */
1157
 
 
1158
 
/* For backward compatibility only */
1159
 
#define SWIG_POINTER_EXCEPTION  0
1160
 
 
1161
 
/* for raw pointers */
1162
 
#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1163
 
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1164
 
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
1165
 
#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
1166
 
#define swig_owntype                                    ruby_owntype
1167
 
 
1168
 
/* for raw packed data */
1169
 
#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
1170
 
#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
1171
 
 
1172
 
/* for class or struct pointers */
1173
 
#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
1174
 
#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
1175
 
 
1176
 
/* for C or C++ function pointers */
1177
 
#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
1178
 
#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
1179
 
 
1180
 
/* for C++ member pointers, ie, member methods */
1181
 
#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
1182
 
#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
1183
 
 
1184
 
 
1185
 
/* Runtime API */
1186
 
 
1187
 
#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule()   
1188
 
#define SWIG_SetModule(clientdata, pointer)             SWIG_Ruby_SetModule(pointer)
1189
 
 
1190
 
 
1191
 
/* Error manipulation */
1192
 
 
1193
 
#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
1194
 
#define SWIG_Error(code, msg)                           rb_raise(SWIG_Ruby_ErrorType(code), msg)
1195
 
#define SWIG_fail                                       goto fail                                
1196
 
 
1197
 
 
1198
 
/* Ruby-specific SWIG API */
1199
 
 
1200
 
#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
1201
 
#define SWIG_define_class(ty)                           SWIG_Ruby_define_class(ty)
1202
 
#define SWIG_NewClassInstance(value, ty)                SWIG_Ruby_NewClassInstance(value, ty)
1203
 
#define SWIG_MangleStr(value)                           SWIG_Ruby_MangleStr(value)                
1204
 
#define SWIG_CheckConvert(value, ty)                    SWIG_Ruby_CheckConvert(value, ty)         
1205
 
 
1206
 
 
1207
 
/* -----------------------------------------------------------------------------
1208
 
 * pointers/data manipulation
1209
 
 * ----------------------------------------------------------------------------- */
1210
 
 
1211
 
#ifdef __cplusplus
1212
 
extern "C" {
1213
 
#if 0
1214
 
} /* cc-mode */
1215
 
#endif
1216
 
#endif
1217
 
 
1218
 
typedef struct {
1219
 
  VALUE klass;
1220
 
  VALUE mImpl;
1221
 
  void  (*mark)(void *);
1222
 
  void  (*destroy)(void *);
1223
 
  int trackObjects;
1224
 
} swig_class;
1225
 
 
1226
 
 
1227
 
static VALUE _mSWIG = Qnil;
1228
 
static VALUE _cSWIG_Pointer = Qnil;
1229
 
static VALUE swig_runtime_data_type_pointer = Qnil;
1230
 
 
1231
 
SWIGRUNTIME VALUE 
1232
 
getExceptionClass(void) {
1233
 
  static int init = 0;
1234
 
  static VALUE rubyExceptionClass ;
1235
 
  if (!init) {
1236
 
    init = 1;
1237
 
    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
1238
 
  }
1239
 
  return rubyExceptionClass;
1240
 
} 
1241
 
 
1242
 
/* This code checks to see if the Ruby object being raised as part
1243
 
   of an exception inherits from the Ruby class Exception.  If so,
1244
 
   the object is simply returned.  If not, then a new Ruby exception
1245
 
   object is created and that will be returned to Ruby.*/
1246
 
SWIGRUNTIME VALUE
1247
 
SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
1248
 
  VALUE exceptionClass = getExceptionClass();
1249
 
  if (rb_obj_is_kind_of(obj, exceptionClass)) {
1250
 
    return obj;
1251
 
  }  else {
1252
 
    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
1253
 
  }
1254
 
}
1255
 
 
1256
 
/* Initialize Ruby runtime support */
1257
 
SWIGRUNTIME void
1258
 
SWIG_Ruby_InitRuntime(void)
1259
 
{
1260
 
  if (_mSWIG == Qnil) {
1261
 
    _mSWIG = rb_define_module("SWIG");
1262
 
  }
1263
 
}
1264
 
 
1265
 
/* Define Ruby class for C type */
1266
 
SWIGRUNTIME void
1267
 
SWIG_Ruby_define_class(swig_type_info *type)
1268
 
{
1269
 
  VALUE klass;
1270
 
  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
1271
 
  sprintf(klass_name, "TYPE%s", type->name);
1272
 
  if (NIL_P(_cSWIG_Pointer)) {
1273
 
    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
1274
 
    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
1275
 
  }
1276
 
  klass = rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
1277
 
  free((void *) klass_name);
1278
 
}
1279
 
 
1280
 
/* Create a new pointer object */
1281
 
SWIGRUNTIME VALUE
1282
 
SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
1283
 
{
1284
 
  int own =  flags & SWIG_POINTER_OWN; 
1285
 
  
1286
 
  char *klass_name;
1287
 
  swig_class *sklass;
1288
 
  VALUE klass;
1289
 
  VALUE obj;
1290
 
  
1291
 
  if (!ptr)
1292
 
    return Qnil;
1293
 
  
1294
 
  if (type->clientdata) {
1295
 
    sklass = (swig_class *) type->clientdata;
1296
 
                
1297
 
    /* Are we tracking this class and have we already returned this Ruby object? */
1298
 
    if (sklass->trackObjects) {
1299
 
      obj = SWIG_RubyInstanceFor(ptr);
1300
 
      
1301
 
      /* Check the object's type and make sure it has the correct type.
1302
 
        It might not in cases where methods do things like 
1303
 
        downcast methods. */
1304
 
      if (obj != Qnil) {
1305
 
        VALUE value = rb_iv_get(obj, "__swigtype__");
1306
 
        char* type_name = RSTRING(value)->ptr;
1307
 
                                
1308
 
        if (strcmp(type->name, type_name) == 0) {
1309
 
          return obj;
1310
 
        }
1311
 
      }
1312
 
    }
1313
 
 
1314
 
    /* Create a new Ruby object */
1315
 
    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), (own ? VOIDFUNC(sklass->destroy) : 0), ptr);
1316
 
 
1317
 
    /* If tracking is on for this class then track this object. */
1318
 
    if (sklass->trackObjects) {
1319
 
      SWIG_RubyAddTracking(ptr, obj);
1320
 
    }
1321
 
  } else {
1322
 
    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
1323
 
    sprintf(klass_name, "TYPE%s", type->name);
1324
 
    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
1325
 
    free((void *) klass_name);
1326
 
    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
1327
 
  }
1328
 
  rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
1329
 
  
1330
 
  return obj;
1331
 
}
1332
 
 
1333
 
/* Create a new class instance (always owned) */
1334
 
SWIGRUNTIME VALUE
1335
 
SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
1336
 
{
1337
 
  VALUE obj;
1338
 
  swig_class *sklass = (swig_class *) type->clientdata;
1339
 
  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
1340
 
  rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
1341
 
  return obj;
1342
 
}
1343
 
 
1344
 
/* Get type mangle from class name */
1345
 
SWIGRUNTIMEINLINE char *
1346
 
SWIG_Ruby_MangleStr(VALUE obj)
1347
 
{
1348
 
  VALUE stype = rb_iv_get(obj, "__swigtype__");
1349
 
  return StringValuePtr(stype);
1350
 
}
1351
 
 
1352
 
/* Acquire a pointer value */
1353
 
typedef void (*ruby_owntype)(void*);
1354
 
 
1355
 
SWIGRUNTIME ruby_owntype
1356
 
SWIG_Ruby_AcquirePtr(VALUE obj, ruby_owntype own) {
1357
 
  if (obj) {
1358
 
    ruby_owntype oldown = RDATA(obj)->dfree;
1359
 
    RDATA(obj)->dfree = own;
1360
 
    return oldown;
1361
 
  } else {
1362
 
    return 0;
1363
 
  }
1364
 
}
1365
 
 
1366
 
/* Convert a pointer value */
1367
 
SWIGRUNTIME int
1368
 
SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, ruby_owntype *own)
1369
 
{
1370
 
  char *c;
1371
 
  swig_cast_info *tc;
1372
 
  void *vptr = 0;
1373
 
 
1374
 
  /* Grab the pointer */
1375
 
  if (NIL_P(obj)) {
1376
 
    *ptr = 0;
1377
 
    return SWIG_OK;
1378
 
  } else {
1379
 
    if (TYPE(obj) != T_DATA) {
1380
 
      return SWIG_ERROR;
1381
 
    }
1382
 
    Data_Get_Struct(obj, void, vptr);
1383
 
  }
1384
 
  
1385
 
  if (own) *own = RDATA(obj)->dfree;
1386
 
    
1387
 
  /* Check to see if the input object is giving up ownership
1388
 
     of the underlying C struct or C++ object.  If so then we
1389
 
     need to reset the destructor since the Ruby object no 
1390
 
     longer owns the underlying C++ object.*/ 
1391
 
  if (flags & SWIG_POINTER_DISOWN) {
1392
 
    /* Is tracking on for this class? */
1393
 
    int track = 0;
1394
 
    if (ty && ty->clientdata) {
1395
 
      swig_class *sklass = (swig_class *) ty->clientdata;
1396
 
      track = sklass->trackObjects;
1397
 
    }
1398
 
                
1399
 
    if (track) {
1400
 
      /* We are tracking objects for this class.  Thus we change the destructor
1401
 
       * to SWIG_RubyRemoveTracking.  This allows us to
1402
 
       * remove the mapping from the C++ to Ruby object
1403
 
       * when the Ruby object is garbage collected.  If we don't
1404
 
       * do this, then it is possible we will return a reference 
1405
 
       * to a Ruby object that no longer exists thereby crashing Ruby. */
1406
 
      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
1407
 
    } else {    
1408
 
      RDATA(obj)->dfree = 0;
1409
 
    }
1410
 
  }
1411
 
 
1412
 
  /* Do type-checking if type info was provided */
1413
 
  if (ty) {
1414
 
    if (ty->clientdata) {
1415
 
      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
1416
 
        if (vptr == 0) {
1417
 
          /* The object has already been deleted */
1418
 
          return SWIG_ObjectPreviouslyDeletedError;
1419
 
        }
1420
 
        *ptr = vptr;
1421
 
        return SWIG_OK;
1422
 
      }
1423
 
    }
1424
 
    if ((c = SWIG_MangleStr(obj)) == NULL) {
1425
 
      return SWIG_ERROR;
1426
 
    }
1427
 
    tc = SWIG_TypeCheck(c, ty);
1428
 
    if (!tc) {
1429
 
      return SWIG_ERROR;
1430
 
    }
1431
 
    *ptr = SWIG_TypeCast(tc, vptr);
1432
 
  } else {
1433
 
    *ptr = vptr;
1434
 
  }
1435
 
  
1436
 
  return SWIG_OK;
1437
 
}
1438
 
 
1439
 
/* Check convert */
1440
 
SWIGRUNTIMEINLINE int
1441
 
SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
1442
 
{
1443
 
  char *c = SWIG_MangleStr(obj);
1444
 
  if (!c) return 0;
1445
 
  return SWIG_TypeCheck(c,ty) != 0;
1446
 
}
1447
 
 
1448
 
SWIGRUNTIME VALUE
1449
 
SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
1450
 
  char result[1024];
1451
 
  char *r = result;
1452
 
  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
1453
 
  *(r++) = '_';
1454
 
  r = SWIG_PackData(r, ptr, sz);
1455
 
  strcpy(r, type->name);
1456
 
  return rb_str_new2(result);
1457
 
}
1458
 
 
1459
 
/* Convert a packed value value */
1460
 
SWIGRUNTIME int
1461
 
SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
1462
 
  swig_cast_info *tc;
1463
 
  const char  *c;
1464
 
 
1465
 
  if (TYPE(obj) != T_STRING) goto type_error;
1466
 
  c = StringValuePtr(obj);
1467
 
  /* Pointer values must start with leading underscore */
1468
 
  if (*c != '_') goto type_error;
1469
 
  c++;
1470
 
  c = SWIG_UnpackData(c, ptr, sz);
1471
 
  if (ty) {
1472
 
    tc = SWIG_TypeCheck(c, ty);
1473
 
    if (!tc) goto type_error;
1474
 
  }
1475
 
  return SWIG_OK;
1476
 
 
1477
 
 type_error:
1478
 
  return SWIG_ERROR;
1479
 
}
1480
 
 
1481
 
SWIGRUNTIME swig_module_info *
1482
 
SWIG_Ruby_GetModule(void)
1483
 
{
1484
 
  VALUE pointer;
1485
 
  swig_module_info *ret = 0;
1486
 
  VALUE verbose = rb_gv_get("VERBOSE");
1487
 
 
1488
 
 /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
1489
 
  rb_gv_set("VERBOSE", Qfalse);
1490
 
  
1491
 
  /* first check if pointer already created */
1492
 
  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
1493
 
  if (pointer != Qnil) {
1494
 
    Data_Get_Struct(pointer, swig_module_info, ret);
1495
 
  }
1496
 
 
1497
 
  /* reinstate warnings */
1498
 
  rb_gv_set("VERBOSE", verbose);
1499
 
  return ret;
1500
 
}
1501
 
 
1502
 
SWIGRUNTIME void 
1503
 
SWIG_Ruby_SetModule(swig_module_info *pointer)
1504
 
{
1505
 
  /* register a new class */
1506
 
  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
1507
 
  /* create and store the structure pointer to a global variable */
1508
 
  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
1509
 
  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
1510
 
}
1511
 
 
1512
 
#ifdef __cplusplus
1513
 
#if 0
1514
 
{ /* cc-mode */
1515
 
#endif
1516
 
}
1517
 
#endif
1518
 
 
1519
 
 
1520
 
 
1521
 
#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
1522
 
 
1523
 
#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
1524
 
 
1525
 
 
1526
 
 
1527
 
  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) 
1528
 
 
1529
 
 
1530
 
/* -------- TYPES TABLE (BEGIN) -------- */
1531
 
 
1532
 
#define SWIGTYPE_p_GIntBig swig_types[0]
1533
 
#define SWIGTYPE_p_OGRDataSourceShadow swig_types[1]
1534
 
#define SWIGTYPE_p_OGRDriverShadow swig_types[2]
1535
 
#define SWIGTYPE_p_OGRFeatureDefnShadow swig_types[3]
1536
 
#define SWIGTYPE_p_OGRFeatureShadow swig_types[4]
1537
 
#define SWIGTYPE_p_OGRFieldDefnShadow swig_types[5]
1538
 
#define SWIGTYPE_p_OGRGeometryShadow swig_types[6]
1539
 
#define SWIGTYPE_p_OGRLayerShadow swig_types[7]
1540
 
#define SWIGTYPE_p_OSRCoordinateTransformationShadow swig_types[8]
1541
 
#define SWIGTYPE_p_OSRSpatialReferenceShadow swig_types[9]
1542
 
#define SWIGTYPE_p_char swig_types[10]
1543
 
#define SWIGTYPE_p_double swig_types[11]
1544
 
#define SWIGTYPE_p_int swig_types[12]
1545
 
#define SWIGTYPE_p_p_char swig_types[13]
1546
 
static swig_type_info *swig_types[15];
1547
 
static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
1548
 
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1549
 
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1550
 
 
1551
 
/* -------- TYPES TABLE (END) -------- */
1552
 
 
1553
 
#define SWIG_init    Init_ogr
1554
 
#define SWIG_name    "Gdal::Ogr"
1555
 
 
1556
 
static VALUE mOgr;
1557
 
 
1558
 
#define SWIGVERSION 0x010329 
1559
 
 
1560
 
 
1561
 
#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
1562
 
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
1563
 
 
1564
 
 
1565
 
#include <stdexcept>
1566
 
 
1567
 
 
1568
 
#include <iostream>
1569
 
using namespace std;
1570
 
 
1571
 
#include "ogr_api.h"
1572
 
#include "ogr_core.h"
1573
 
#include "cpl_port.h"
1574
 
#include "cpl_string.h"
1575
 
 
1576
 
typedef void OSRSpatialReferenceShadow;
1577
 
typedef void OGRDriverShadow;
1578
 
typedef void OGRDataSourceShadow;
1579
 
typedef void OGRLayerShadow;
1580
 
typedef void OGRFeatureShadow;
1581
 
typedef void OGRFeatureDefnShadow;
1582
 
typedef void OGRGeometryShadow;
1583
 
typedef void OSRCoordinateTransformationShadow;
1584
 
typedef void OGRFieldDefnShadow;
1585
 
 
1586
 
 
1587
 
#include <limits.h>
1588
 
#ifndef LLONG_MIN
1589
 
# define LLONG_MIN      LONG_LONG_MIN
1590
 
#endif
1591
 
#ifndef LLONG_MAX
1592
 
# define LLONG_MAX      LONG_LONG_MAX
1593
 
#endif
1594
 
#ifndef ULLONG_MAX
1595
 
# define ULLONG_MAX     ULONG_LONG_MAX
1596
 
#endif
1597
 
 
1598
 
 
1599
 
  #define SWIG_From_long   LONG2NUM 
1600
 
 
1601
 
 
1602
 
SWIGINTERNINLINE VALUE
1603
 
SWIG_From_int  (int value)
1604
 
{    
1605
 
  return SWIG_From_long  (value);
1606
 
}
1607
 
 
1608
 
 
1609
 
SWIGINTERN swig_type_info*
1610
 
SWIG_pchar_descriptor()
1611
 
{
1612
 
  static int init = 0;
1613
 
  static swig_type_info* info = 0;
1614
 
  if (!init) {
1615
 
    info = SWIG_TypeQuery("_p_char");
1616
 
    init = 1;
1617
 
  }
1618
 
  return info;
1619
 
}
1620
 
 
1621
 
 
1622
 
SWIGINTERNINLINE VALUE 
1623
 
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1624
 
{
1625
 
  if (carray) {
1626
 
    if (size > LONG_MAX) {
1627
 
      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1628
 
      return pchar_descriptor ? 
1629
 
        SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : Qnil;
1630
 
    } else {
1631
 
      return rb_str_new(carray, static_cast< long >(size));
1632
 
    }
1633
 
  } else {
1634
 
    return Qnil;
1635
 
  }
1636
 
}
1637
 
 
1638
 
 
1639
 
SWIGINTERNINLINE VALUE 
1640
 
SWIG_FromCharPtr(const char *cptr)
1641
 
{ 
1642
 
  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
1643
 
}
1644
 
 
1645
 
 
1646
 
#ifdef __cplusplus
1647
 
extern "C" {
1648
 
#endif
1649
 
#include "rubyio.h"
1650
 
#ifdef __cplusplus
1651
 
}
1652
 
#endif
1653
 
 
1654
 
 
1655
 
#ifdef __cplusplus
1656
 
extern "C" {
1657
 
#endif
1658
 
#ifdef HAVE_SYS_TIME_H
1659
 
# include <sys/time.h>
1660
 
struct timeval rb_time_timeval(VALUE);
1661
 
#endif
1662
 
#ifdef __cplusplus
1663
 
}
1664
 
#endif
1665
 
 
1666
 
 
1667
 
 
1668
 
static char const *
1669
 
OGRErrMessages( int rc ) {
1670
 
  switch( rc ) {
1671
 
  case 0:
1672
 
    return "OGR Error: None";
1673
 
  case 1:
1674
 
    return "OGR Error: Not enough data";
1675
 
  case 2:
1676
 
    return "OGR Error: Not enough memory";
1677
 
  case 3:
1678
 
    return "OGR Error: Unsupported geometry type";
1679
 
  case 4:
1680
 
    return "OGR Error: Unsupported operation";
1681
 
  case 5:
1682
 
    return "OGR Error: Corrupt data";
1683
 
  case 6:
1684
 
    return "OGR Error: General Error";
1685
 
  case 7:
1686
 
    return "OGR Error: Unsupported SRS";
1687
 
  default:
1688
 
    return "OGR Error: Unknown";
1689
 
  }
1690
 
}
1691
 
 
1692
 
 
1693
 
void VeryQuiteErrorHandler(CPLErr eclass, int code, const char *msg ) {
1694
 
  /* If the error class is CE_Fatal, we want to have a message issued
1695
 
     because the CPL support code does an abort() before any exception
1696
 
     can be generated */
1697
 
  if (eclass == CE_Fatal ) {
1698
 
    CPLDefaultErrorHandler(eclass, code, msg );
1699
 
  }
1700
 
}
1701
 
 
1702
 
 
1703
 
void UseExceptions() {
1704
 
  CPLSetErrorHandler( (CPLErrorHandler) VeryQuiteErrorHandler );
1705
 
}
1706
 
 
1707
 
void DontUseExceptions() {
1708
 
  CPLSetErrorHandler( CPLDefaultErrorHandler );
1709
 
}
1710
 
 
1711
 
 
1712
 
SWIGINTERN int
1713
 
SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
1714
 
{
1715
 
  if (TYPE(obj) == T_STRING) {
1716
 
    
1717
 
 
1718
 
 
1719
 
    char *cstr = STR2CSTR(obj);
1720
 
    
1721
 
    size_t size = RSTRING(obj)->len + 1;
1722
 
    if (cptr)  {
1723
 
      if (alloc) {
1724
 
        if (*alloc == SWIG_NEWOBJ) {
1725
 
          *cptr = reinterpret_cast< char* >(memcpy((new char[size]), cstr, sizeof(char)*(size)));
1726
 
        } else {
1727
 
          *cptr = cstr;
1728
 
          *alloc = SWIG_OLDOBJ;
1729
 
        }
1730
 
      }
1731
 
    }
1732
 
    if (psize) *psize = size;
1733
 
    return SWIG_OK;
1734
 
  } else {
1735
 
    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1736
 
    if (pchar_descriptor) {
1737
 
      void* vptr = 0;
1738
 
      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
1739
 
        if (cptr) *cptr = (char *)vptr;
1740
 
        if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
1741
 
        if (alloc) *alloc = SWIG_OLDOBJ;
1742
 
        return SWIG_OK;
1743
 
      }
1744
 
    }
1745
 
  }  
1746
 
  return SWIG_TypeError;
1747
 
}
1748
 
 
1749
 
 
1750
 
 
1751
 
 
1752
 
SWIGINTERN OGRDataSourceShadow *OGRDriverShadow_CreateDataSource(OGRDriverShadow *self,char const *name,char **options=0){
1753
 
    OGRDataSourceShadow *ds = (OGRDataSourceShadow*) OGR_Dr_CreateDataSource( self, name, options);
1754
 
    return ds;
1755
 
  }
1756
 
SWIGINTERN OGRDataSourceShadow *OGRDriverShadow_CopyDataSource(OGRDriverShadow *self,OGRDataSourceShadow *copy_ds,char const *name,char **options=0){
1757
 
    OGRDataSourceShadow *ds = (OGRDataSourceShadow*) OGR_Dr_CopyDataSource(self, copy_ds, name, options);
1758
 
    return ds;
1759
 
  }
1760
 
 
1761
 
SWIGINTERN VALUE
1762
 
SWIG_ruby_failed(void)
1763
 
{
1764
 
  return Qnil;
1765
 
} 
1766
 
 
1767
 
 
1768
 
/*@SWIG:%ruby_aux_method@*/
1769
 
SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
1770
 
{
1771
 
  VALUE obj = args[0];
1772
 
  VALUE type = TYPE(obj);
1773
 
  long *res = (long *)(args[1]);
1774
 
  *res = type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj);
1775
 
  return obj;
1776
 
}
1777
 
/*@SWIG@*/
1778
 
 
1779
 
SWIGINTERN int
1780
 
SWIG_AsVal_long (VALUE obj, long* val)
1781
 
{
1782
 
  VALUE type = TYPE(obj);
1783
 
  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
1784
 
    long v;
1785
 
    VALUE a[2];
1786
 
    a[0] = obj;
1787
 
    a[1] = (VALUE)(&v);
1788
 
    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
1789
 
      if (val) *val = v;
1790
 
      return SWIG_OK;
1791
 
    }
1792
 
  }
1793
 
  return SWIG_TypeError;
1794
 
}
1795
 
 
1796
 
 
1797
 
SWIGINTERN int
1798
 
SWIG_AsVal_int (VALUE obj, int *val)
1799
 
{
1800
 
  long v;
1801
 
  int res = SWIG_AsVal_long (obj, &v);
1802
 
  if (SWIG_IsOK(res)) {
1803
 
    if ((v < INT_MIN || v > INT_MAX)) {
1804
 
      return SWIG_OverflowError;
1805
 
    } else {
1806
 
      if (val) *val = static_cast< int >(v);
1807
 
    }
1808
 
  }  
1809
 
  return res;
1810
 
}
1811
 
 
1812
 
SWIGINTERN OGRDataSourceShadow *OGRDriverShadow_Open(OGRDriverShadow *self,char const *name,int update=0){
1813
 
    OGRDataSourceShadow* ds = (OGRDataSourceShadow*) OGR_Dr_Open(self, name, update);
1814
 
    return ds;
1815
 
  }
1816
 
SWIGINTERN int OGRDriverShadow_DeleteDataSource(OGRDriverShadow *self,char const *name){
1817
 
    return OGR_Dr_DeleteDataSource( self, name );
1818
 
  }
1819
 
SWIGINTERN bool OGRDriverShadow_TestCapability(OGRDriverShadow *self,char const *cap){
1820
 
    return OGR_Dr_TestCapability(self, cap);
1821
 
  }
1822
 
 
1823
 
SWIGINTERNINLINE VALUE
1824
 
SWIG_From_bool  (bool value)
1825
 
{
1826
 
  return value ? Qtrue : Qfalse;
1827
 
}
1828
 
 
1829
 
SWIGINTERN char const *OGRDriverShadow_GetName(OGRDriverShadow *self){
1830
 
    return OGR_Dr_GetName( self );
1831
 
  }
1832
 
SWIGINTERN int OGRDataSourceShadow_GetRefCount(OGRDataSourceShadow *self){
1833
 
    return OGR_DS_GetRefCount(self);
1834
 
  }
1835
 
SWIGINTERN int OGRDataSourceShadow_GetSummaryRefCount(OGRDataSourceShadow *self){
1836
 
    return OGR_DS_GetSummaryRefCount(self);
1837
 
  }
1838
 
SWIGINTERN int OGRDataSourceShadow_GetLayerCount(OGRDataSourceShadow *self){
1839
 
    return OGR_DS_GetLayerCount(self);
1840
 
  }
1841
 
SWIGINTERN OGRDriverShadow *OGRDataSourceShadow_GetDriver(OGRDataSourceShadow *self){
1842
 
    OGRDriverShadow* driver;
1843
 
    OGRDataSourceShadow* ds;
1844
 
    ds = (OGRDataSourceShadow*)OGROpen((const char *) OGR_DS_GetName(self),0,&driver);
1845
 
    OGRReleaseDataSource(ds);
1846
 
    return driver;
1847
 
  }
1848
 
SWIGINTERN char const *OGRDataSourceShadow_GetName(OGRDataSourceShadow *self){
1849
 
    return OGR_DS_GetName(self);
1850
 
  }
1851
 
SWIGINTERN OGRErr OGRDataSourceShadow_DeleteLayer(OGRDataSourceShadow *self,int index){
1852
 
    return OGR_DS_DeleteLayer(self, index);
1853
 
  }
1854
 
SWIGINTERN OGRLayerShadow *OGRDataSourceShadow_CreateLayer(OGRDataSourceShadow *self,char const *name,OSRSpatialReferenceShadow *reference=NULL,OGRwkbGeometryType geom_type=wkbUnknown,char **options=0){
1855
 
    OGRLayerShadow* layer = (OGRLayerShadow*) OGR_DS_CreateLayer( self,
1856
 
                                                        name,
1857
 
                                                        reference,
1858
 
                                                        geom_type,
1859
 
                                                        options);
1860
 
    return layer;
1861
 
  }
1862
 
SWIGINTERN OGRLayerShadow *OGRDataSourceShadow_CopyLayer(OGRDataSourceShadow *self,OGRLayerShadow *src_layer,char const *new_name,char **options=0){
1863
 
    OGRLayerShadow* layer = (OGRLayerShadow*) OGR_DS_CopyLayer( self,
1864
 
                                                      src_layer,
1865
 
                                                      new_name,
1866
 
                                                      options);
1867
 
    return layer;
1868
 
  }
1869
 
SWIGINTERN bool OGRDataSourceShadow_TestCapability(OGRDataSourceShadow *self,char const *cap){
1870
 
    return OGR_DS_TestCapability(self, cap);
1871
 
  }
1872
 
SWIGINTERN OGRLayerShadow *OGRDataSourceShadow_ExecuteSQL(OGRDataSourceShadow *self,char const *statement,OGRGeometryShadow *geom=NULL,char const *dialect=""){
1873
 
    OGRLayerShadow* layer = (OGRLayerShadow*) OGR_DS_ExecuteSQL((OGRDataSourceShadow*)self,
1874
 
                                                      statement,
1875
 
                                                      geom,
1876
 
                                                      dialect);
1877
 
    return layer;
1878
 
  }
1879
 
SWIGINTERN void OGRDataSourceShadow_ReleaseResultSet(OGRDataSourceShadow *self,OGRLayerShadow *layer){
1880
 
    OGR_DS_ReleaseResultSet(self, layer);
1881
 
  }
1882
 
SWIGINTERN OGRLayerShadow *OGRDataSourceShadow_GetLayer(OGRDataSourceShadow *self,VALUE whichLayer){
1883
 
                // get field index
1884
 
                switch (TYPE(whichLayer)) {
1885
 
                        case T_STRING: {
1886
 
                                char* name = StringValuePtr(whichLayer);
1887
 
                                return OGR_DS_GetLayerByName(self, name);
1888
 
                                break;
1889
 
                        }
1890
 
                        case T_FIXNUM: {
1891
 
                                int index = NUM2INT(whichLayer);
1892
 
                                return OGR_DS_GetLayer(self, index);
1893
 
                                break;
1894
 
                        }
1895
 
                        default:
1896
 
                                SWIG_exception(SWIG_TypeError, "Value must be a string or integer.");
1897
 
                }
1898
 
        }
1899
 
SWIGINTERN int OGRLayerShadow_GetRefCount(OGRLayerShadow *self){
1900
 
    return OGR_L_GetRefCount(self);
1901
 
  }
1902
 
SWIGINTERN void OGRLayerShadow_SetSpatialFilter(OGRLayerShadow *self,OGRGeometryShadow *filter){
1903
 
    OGR_L_SetSpatialFilter (self, filter);
1904
 
  }
1905
 
 
1906
 
/*@SWIG:%ruby_aux_method@*/
1907
 
SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE *args)
1908
 
{
1909
 
  VALUE obj = args[0];
1910
 
  VALUE type = TYPE(obj);
1911
 
  double *res = (double *)(args[1]);
1912
 
  *res = (type == T_FLOAT ? NUM2DBL(obj) : (type == T_FIXNUM ? (double) FIX2INT(obj) : rb_big2dbl(obj)));
1913
 
  return obj;
1914
 
}
1915
 
/*@SWIG@*/
1916
 
 
1917
 
SWIGINTERN int
1918
 
SWIG_AsVal_double (VALUE obj, double *val)
1919
 
{
1920
 
  VALUE type = TYPE(obj);
1921
 
  if ((type == T_FLOAT) || (type == T_FIXNUM) || (type == T_BIGNUM)) {
1922
 
    double v;
1923
 
    VALUE a[2];
1924
 
    a[0] = obj;
1925
 
    a[1] = (VALUE)(&v);
1926
 
    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2DBL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
1927
 
      if (val) *val = v;
1928
 
      return SWIG_OK;
1929
 
    }
1930
 
  }
1931
 
  return SWIG_TypeError;
1932
 
}
1933
 
 
1934
 
SWIGINTERN void OGRLayerShadow_SetSpatialFilterRect(OGRLayerShadow *self,double minx,double miny,double maxx,double maxy){
1935
 
    OGR_L_SetSpatialFilterRect(self, minx, miny, maxx, maxy);                          
1936
 
  }
1937
 
SWIGINTERN OGRGeometryShadow *OGRLayerShadow_GetSpatialFilter(OGRLayerShadow *self){
1938
 
    return (OGRGeometryShadow *) OGR_L_GetSpatialFilter(self);
1939
 
  }
1940
 
SWIGINTERN OGRErr OGRLayerShadow_SetAttributeFilter(OGRLayerShadow *self,char *filter_string){
1941
 
    return OGR_L_SetAttributeFilter((OGRLayerShadow*)self, filter_string);
1942
 
  }
1943
 
SWIGINTERN void OGRLayerShadow_ResetReading(OGRLayerShadow *self){
1944
 
    OGR_L_ResetReading(self);
1945
 
  }
1946
 
SWIGINTERN char const *OGRLayerShadow_GetName(OGRLayerShadow *self){
1947
 
    return OGR_FD_GetName(OGR_L_GetLayerDefn(self));
1948
 
  }
1949
 
SWIGINTERN OGRFeatureShadow *OGRLayerShadow_GetFeature(OGRLayerShadow *self,long fid){
1950
 
    return (OGRFeatureShadow*) OGR_L_GetFeature(self, fid);
1951
 
  }
1952
 
SWIGINTERN OGRFeatureShadow *OGRLayerShadow_GetNextFeature(OGRLayerShadow *self){
1953
 
    return (OGRFeatureShadow*) OGR_L_GetNextFeature(self);
1954
 
  }
1955
 
SWIGINTERN OGRErr OGRLayerShadow_SetNextByIndex(OGRLayerShadow *self,long new_index){
1956
 
    return OGR_L_SetNextByIndex(self, new_index);
1957
 
  }
1958
 
SWIGINTERN OGRErr OGRLayerShadow_SetFeature(OGRLayerShadow *self,OGRFeatureShadow *feature){
1959
 
    return OGR_L_SetFeature(self, feature);
1960
 
  }
1961
 
SWIGINTERN OGRErr OGRLayerShadow_CreateFeature(OGRLayerShadow *self,OGRFeatureShadow *feature){
1962
 
    return OGR_L_CreateFeature(self, feature);
1963
 
  }
1964
 
SWIGINTERN OGRErr OGRLayerShadow_DeleteFeature(OGRLayerShadow *self,long fid){
1965
 
    return OGR_L_DeleteFeature(self, fid);
1966
 
  }
1967
 
SWIGINTERN OGRErr OGRLayerShadow_SyncToDisk(OGRLayerShadow *self){
1968
 
    return OGR_L_SyncToDisk(self);
1969
 
  }
1970
 
SWIGINTERN OGRFeatureDefnShadow *OGRLayerShadow_GetLayerDefn(OGRLayerShadow *self){
1971
 
    return (OGRFeatureDefnShadow*) OGR_L_GetLayerDefn(self);
1972
 
  }
1973
 
SWIGINTERN int OGRLayerShadow_GetFeatureCount(OGRLayerShadow *self,int force=1){
1974
 
    return OGR_L_GetFeatureCount(self, force);
1975
 
  }
1976
 
SWIGINTERN OGRErr OGRLayerShadow_GetExtent(OGRLayerShadow *self,double argout[4],int force=1){
1977
 
    return OGR_L_GetExtent(self, (OGREnvelope*)argout, force);
1978
 
  }
1979
 
SWIGINTERN bool OGRLayerShadow_TestCapability(OGRLayerShadow *self,char const *cap){
1980
 
    return OGR_L_TestCapability(self, cap);
1981
 
  }
1982
 
SWIGINTERN OGRErr OGRLayerShadow_CreateField(OGRLayerShadow *self,OGRFieldDefnShadow *field_def,int approx_ok=1){
1983
 
    return OGR_L_CreateField(self, field_def, approx_ok);
1984
 
  }
1985
 
SWIGINTERN OGRErr OGRLayerShadow_StartTransaction(OGRLayerShadow *self){
1986
 
    return OGR_L_StartTransaction(self);
1987
 
  }
1988
 
SWIGINTERN OGRErr OGRLayerShadow_CommitTransaction(OGRLayerShadow *self){
1989
 
    return OGR_L_CommitTransaction(self);
1990
 
  }
1991
 
SWIGINTERN OGRErr OGRLayerShadow_RollbackTransaction(OGRLayerShadow *self){
1992
 
    return OGR_L_RollbackTransaction(self);
1993
 
  }
1994
 
SWIGINTERN OSRSpatialReferenceShadow *OGRLayerShadow_GetSpatialRef(OGRLayerShadow *self){
1995
 
    return (OSRSpatialReferenceShadow*) OGR_L_GetSpatialRef(self);
1996
 
  }
1997
 
SWIGINTERN GIntBig OGRLayerShadow_GetFeatureRead(OGRLayerShadow *self){
1998
 
    return OGR_L_GetFeaturesRead(self);
1999
 
  }
2000
 
SWIGINTERN void OGRLayerShadow_each(OGRLayerShadow *self){
2001
 
                OGRFeatureShadow* feature = NULL;
2002
 
 
2003
 
                while (feature = (OGRFeatureShadow*) OGR_L_GetNextFeature(self))
2004
 
                {
2005
 
                        /* Convert the pointer to a Ruby object.  Note we set the flag
2006
 
                   to one manually to show this is a new object */
2007
 
                        VALUE object = SWIG_NewPointerObj((void *) feature, SWIGTYPE_p_OGRFeatureShadow, SWIG_POINTER_OWN);                     
2008
 
 
2009
 
                        /* Now invoke the block specified for this method. */
2010
 
                        rb_yield(object);
2011
 
                }
2012
 
  }
2013
 
SWIGINTERN OGRFeatureShadow *new_OGRFeatureShadow(OGRFeatureDefnShadow *feature_def=0){
2014
 
    return (OGRFeatureShadow*) OGR_F_Create( feature_def );
2015
 
  }
2016
 
SWIGINTERN OGRFeatureDefnShadow *OGRFeatureShadow_GetDefnRef(OGRFeatureShadow *self){
2017
 
    return (OGRFeatureDefnShadow*) OGR_F_GetDefnRef(self);
2018
 
  }
2019
 
SWIGINTERN OGRErr OGRFeatureShadow_SetGeometry(OGRFeatureShadow *self,OGRGeometryShadow *geom){
2020
 
    return OGR_F_SetGeometry(self, geom);
2021
 
  }
2022
 
SWIGINTERN OGRErr OGRFeatureShadow_SetGeometryDirectly(OGRFeatureShadow *self,OGRGeometryShadow *geom){
2023
 
    return OGR_F_SetGeometryDirectly(self, geom);
2024
 
  }
2025
 
SWIGINTERN OGRGeometryShadow *OGRFeatureShadow_GetGeometryRef(OGRFeatureShadow *self){
2026
 
    return (OGRGeometryShadow*) OGR_F_GetGeometryRef(self);
2027
 
  }
2028
 
SWIGINTERN OGRFeatureShadow *OGRFeatureShadow_Clone(OGRFeatureShadow *self){
2029
 
    return (OGRFeatureShadow*) OGR_F_Clone(self);
2030
 
  }
2031
 
SWIGINTERN bool OGRFeatureShadow_Equal(OGRFeatureShadow *self,OGRFeatureShadow *feature){
2032
 
    return OGR_F_Equal(self, feature);
2033
 
  }
2034
 
SWIGINTERN int OGRFeatureShadow_GetFieldCount(OGRFeatureShadow *self){
2035
 
    return OGR_F_GetFieldCount(self);
2036
 
  }
2037
 
SWIGINTERN OGRFieldDefnShadow *OGRFeatureShadow_GetFieldDefnRef__SWIG_0(OGRFeatureShadow *self,int id){
2038
 
    return (OGRFieldDefnShadow *) OGR_F_GetFieldDefnRef(self, id);
2039
 
  }
2040
 
SWIGINTERN OGRFieldDefnShadow *OGRFeatureShadow_GetFieldDefnRef__SWIG_1(OGRFeatureShadow *self,char const *name){
2041
 
    if (name == NULL)
2042
 
        CPLError(CE_Failure, 1, "Undefined field name in GetFieldDefnRef");
2043
 
    else {
2044
 
        int i = OGR_F_GetFieldIndex(self, name);
2045
 
        if (i == -1)
2046
 
            CPLError(CE_Failure, 1, "No such field: '%s'", name);
2047
 
        else
2048
 
            return (OGRFieldDefnShadow *) OGR_F_GetFieldDefnRef(self, i);
2049
 
    }
2050
 
    return NULL;
2051
 
  }
2052
 
SWIGINTERN char const *OGRFeatureShadow_GetFieldAsString__SWIG_0(OGRFeatureShadow *self,int id){
2053
 
    return (const char *) OGR_F_GetFieldAsString(self, id);
2054
 
  }
2055
 
SWIGINTERN char const *OGRFeatureShadow_GetFieldAsString__SWIG_1(OGRFeatureShadow *self,char const *name){
2056
 
    if (name == NULL)
2057
 
        CPLError(CE_Failure, 1, "Undefined field name in GetFieldAsString");
2058
 
    else {
2059
 
        int i = OGR_F_GetFieldIndex(self, name);
2060
 
        if (i == -1)
2061
 
            CPLError(CE_Failure, 1, "No such field: '%s'", name);
2062
 
        else
2063
 
            return (const char *) OGR_F_GetFieldAsString(self, i);
2064
 
    }
2065
 
    return NULL;
2066
 
  }
2067
 
SWIGINTERN int OGRFeatureShadow_GetFieldAsInteger__SWIG_0(OGRFeatureShadow *self,int id){
2068
 
    return OGR_F_GetFieldAsInteger(self, id);
2069
 
  }
2070
 
SWIGINTERN int OGRFeatureShadow_GetFieldAsInteger__SWIG_1(OGRFeatureShadow *self,char const *name){
2071
 
    if (name == NULL)
2072
 
        CPLError(CE_Failure, 1, "Undefined field name in GetFieldAsInteger");
2073
 
    else {
2074
 
        int i = OGR_F_GetFieldIndex(self, name);
2075
 
        if (i == -1)
2076
 
            CPLError(CE_Failure, 1, "No such field: '%s'", name);
2077
 
        else
2078
 
            return OGR_F_GetFieldAsInteger(self, i);
2079
 
    }
2080
 
    return 0;
2081
 
  }
2082
 
SWIGINTERN double OGRFeatureShadow_GetFieldAsDouble__SWIG_0(OGRFeatureShadow *self,int id){
2083
 
    return OGR_F_GetFieldAsDouble(self, id);
2084
 
  }
2085
 
 
2086
 
  #define SWIG_From_double   rb_float_new 
2087
 
 
2088
 
SWIGINTERN double OGRFeatureShadow_GetFieldAsDouble__SWIG_1(OGRFeatureShadow *self,char const *name){
2089
 
    if (name == NULL)
2090
 
        CPLError(CE_Failure, 1, "Undefined field name in GetFieldAsDouble");
2091
 
    else {
2092
 
        int i = OGR_F_GetFieldIndex(self, name);
2093
 
        if (i == -1)
2094
 
            CPLError(CE_Failure, 1, "No such field: '%s'", name);
2095
 
        else
2096
 
            return OGR_F_GetFieldAsDouble(self, i);
2097
 
    }
2098
 
    return 0;
2099
 
  }
2100
 
SWIGINTERN bool OGRFeatureShadow_IsFieldSet__SWIG_0(OGRFeatureShadow *self,int id){
2101
 
    return OGR_F_IsFieldSet(self, id);
2102
 
  }
2103
 
SWIGINTERN bool OGRFeatureShadow_IsFieldSet__SWIG_1(OGRFeatureShadow *self,char const *name){
2104
 
    if (name == NULL)
2105
 
        CPLError(CE_Failure, 1, "Undefined field name in IsFieldSet");
2106
 
    else {
2107
 
        int i = OGR_F_GetFieldIndex(self, name);
2108
 
        if (i == -1)
2109
 
            CPLError(CE_Failure, 1, "No such field: '%s'", name);
2110
 
        else
2111
 
            return OGR_F_IsFieldSet(self, i);
2112
 
    }
2113
 
    return (bool)0;
2114
 
  }
2115
 
SWIGINTERN int OGRFeatureShadow_GetFieldIndex(OGRFeatureShadow *self,char const *name){
2116
 
    if (name == NULL)
2117
 
        CPLError(CE_Failure, 1, "Undefined field name in GetFieldIndex");
2118
 
    else
2119
 
        return OGR_F_GetFieldIndex(self, name);
2120
 
    return 0;
2121
 
  }
2122
 
SWIGINTERN int OGRFeatureShadow_GetFID(OGRFeatureShadow *self){
2123
 
    return OGR_F_GetFID(self);
2124
 
  }
2125
 
SWIGINTERN OGRErr OGRFeatureShadow_SetFID(OGRFeatureShadow *self,int fid){
2126
 
    return OGR_F_SetFID(self, fid);
2127
 
  }
2128
 
SWIGINTERN void OGRFeatureShadow_DumpReadable(OGRFeatureShadow *self){
2129
 
    OGR_F_DumpReadable(self, NULL);
2130
 
  }
2131
 
SWIGINTERN void OGRFeatureShadow_UnsetField__SWIG_0(OGRFeatureShadow *self,int id){
2132
 
    OGR_F_UnsetField(self, id);
2133
 
  }
2134
 
SWIGINTERN void OGRFeatureShadow_UnsetField__SWIG_1(OGRFeatureShadow *self,char const *name){
2135
 
    if (name == NULL)
2136
 
        CPLError(CE_Failure, 1, "Undefined field name in UnsetField");
2137
 
    else {
2138
 
        int i = OGR_F_GetFieldIndex(self, name);
2139
 
        if (i == -1)
2140
 
            CPLError(CE_Failure, 1, "No such field: '%s'", name);
2141
 
        else
2142
 
            OGR_F_UnsetField(self, i);
2143
 
    }
2144
 
  }
2145
 
SWIGINTERN void OGRFeatureShadow_SetField__SWIG_0(OGRFeatureShadow *self,int id,char const *value){
2146
 
    OGR_F_SetFieldString(self, id, value);
2147
 
  }
2148
 
SWIGINTERN void OGRFeatureShadow_SetField__SWIG_1(OGRFeatureShadow *self,char const *name,char const *value){
2149
 
    if (name == NULL)
2150
 
        CPLError(CE_Failure, 1, "Undefined field name in SetField");
2151
 
    else {
2152
 
        int i = OGR_F_GetFieldIndex(self, name);
2153
 
        if (i == -1)
2154
 
            CPLError(CE_Failure, 1, "No such field: '%s'", name);
2155
 
        else
2156
 
            OGR_F_SetFieldString(self, i, value);
2157
 
    }
2158
 
  }
2159
 
SWIGINTERN OGRErr OGRFeatureShadow_SetFrom(OGRFeatureShadow *self,OGRFeatureShadow *other,int forgiving=1){
2160
 
    return OGR_F_SetFrom(self, other, forgiving);
2161
 
  }
2162
 
SWIGINTERN char const *OGRFeatureShadow_GetStyleString(OGRFeatureShadow *self){
2163
 
    return (const char*) OGR_F_GetStyleString(self);
2164
 
  }
2165
 
SWIGINTERN void OGRFeatureShadow_SetStyleString(OGRFeatureShadow *self,char const *the_string){
2166
 
    OGR_F_SetStyleString(self, the_string);
2167
 
  }
2168
 
SWIGINTERN OGRFieldType OGRFeatureShadow_GetFieldType__SWIG_0(OGRFeatureShadow *self,int id){
2169
 
    return (OGRFieldType) OGR_Fld_GetType( OGR_F_GetFieldDefnRef( self, id));
2170
 
  }
2171
 
SWIGINTERN OGRFieldType OGRFeatureShadow_GetFieldType__SWIG_1(OGRFeatureShadow *self,char const *name){
2172
 
    if (name == NULL) {
2173
 
        CPLError(CE_Failure, 1, "Undefined field name in GetFieldType");
2174
 
        return (OGRFieldType)0;
2175
 
    } else {
2176
 
        int i = OGR_F_GetFieldIndex(self, name);
2177
 
        if (i == -1) {
2178
 
            CPLError(CE_Failure, 1, "No such field: '%s'", name);
2179
 
            return (OGRFieldType)0;
2180
 
        } else
2181
 
            return (OGRFieldType) OGR_Fld_GetType( 
2182
 
                            OGR_F_GetFieldDefnRef( self,  i )
2183
 
                                          );
2184
 
    }
2185
 
  }
2186
 
SWIGINTERN VALUE OGRFeatureShadow_GetField(OGRFeatureShadow *self,VALUE object){
2187
 
                VALUE result;
2188
 
 
2189
 
                int index;
2190
 
 
2191
 
                // get field index
2192
 
                switch (TYPE(object)) {
2193
 
                        case T_STRING:
2194
 
                                index = OGR_F_GetFieldIndex(self, StringValuePtr(object));
2195
 
                                break;
2196
 
                        case T_FIXNUM:
2197
 
                                index = NUM2INT(object);
2198
 
                                break;
2199
 
                        default:
2200
 
                                SWIG_exception(SWIG_TypeError, "Value must be a string or integer.");
2201
 
                }
2202
 
                
2203
 
                int count = OGR_F_GetFieldCount(self);
2204
 
                
2205
 
                if (index < 0 || index > count) {
2206
 
                        SWIG_exception(SWIG_IndexError, "Illegal field requested.");
2207
 
                }
2208
 
 
2209
 
                // is the field unset?
2210
 
          if (!OGR_F_IsFieldSet(self, index)) {
2211
 
                result = Qnil;
2212
 
                return result;
2213
 
          }
2214
 
          
2215
 
          // get field type
2216
 
    OGRFieldType field_type = (OGRFieldType) OGR_Fld_GetType(OGR_F_GetFieldDefnRef( self, index));
2217
 
 
2218
 
                switch (field_type) {
2219
 
                        case OFTInteger: {
2220
 
                                const int value = OGR_F_GetFieldAsInteger(self, index);
2221
 
                                result = INT2NUM(value);
2222
 
                                break;
2223
 
                        }
2224
 
 
2225
 
                        case OFTIntegerList: {
2226
 
                                int len = 0;
2227
 
                                const int* list = OGR_F_GetFieldAsIntegerList(self, index, &len);
2228
 
                                
2229
 
                                result = rb_ary_new2(len);
2230
 
                                
2231
 
                    for ( int i = 0; i < len; ++i, ++list ) {
2232
 
                                        VALUE item = INT2NUM(*list);
2233
 
                      rb_ary_store(result, item, i);
2234
 
                    }
2235
 
                    break;
2236
 
                        }
2237
 
 
2238
 
                        case OFTReal: {
2239
 
                                const double value = OGR_F_GetFieldAsDouble(self, index);
2240
 
                                return rb_float_new(value);
2241
 
                                break;
2242
 
                        }
2243
 
 
2244
 
                        case OFTRealList: {
2245
 
                                int len = 0;
2246
 
                                const double* list = OGR_F_GetFieldAsDoubleList(self, index, &len);
2247
 
                                
2248
 
                                result = rb_ary_new2(len);
2249
 
                                
2250
 
                    for ( int i = 0; i < len; ++i, ++list ) {
2251
 
                                        VALUE item = rb_float_new(*list);
2252
 
                      rb_ary_store(result, item, i);
2253
 
                    }
2254
 
                    break;
2255
 
                        }
2256
 
 
2257
 
                        case OFTString: {
2258
 
                                const char* value = (const char *) OGR_F_GetFieldAsString(self, index);
2259
 
                                return rb_str_new2(value);
2260
 
                                break;
2261
 
                        }
2262
 
 
2263
 
                        case OFTStringList:
2264
 
/*                              int len3 = 0;
2265
 
                                const char** string_list = OGR_F_GetFieldAsStringList(self, index, &len);
2266
 
                                
2267
 
                                result = rb_ary_new2(len3);
2268
 
                                
2269
 
                    for ( int i = 0; i < len; ++i, ++string_list ) {
2270
 
                                        VALUE item = rb_str_new2(*string_list);
2271
 
                      rb_ary_store(result, item, i);
2272
 
                    }*/
2273
 
                    result = Qnil;
2274
 
                    break;
2275
 
                        default:
2276
 
                                SWIG_exception(SWIG_TypeError, "Unsupported field type.");
2277
 
                }
2278
 
        
2279
 
                return result;          
2280
 
        }
2281
 
SWIGINTERN OGRFeatureDefnShadow *new_OGRFeatureDefnShadow(char const *name=NULL){
2282
 
    return (OGRFeatureDefnShadow* )OGR_FD_Create(name);
2283
 
  }
2284
 
SWIGINTERN char const *OGRFeatureDefnShadow_GetName(OGRFeatureDefnShadow *self){
2285
 
    return OGR_FD_GetName(self);
2286
 
  }
2287
 
SWIGINTERN int OGRFeatureDefnShadow_GetFieldCount(OGRFeatureDefnShadow *self){
2288
 
    return OGR_FD_GetFieldCount(self);
2289
 
  }
2290
 
SWIGINTERN OGRFieldDefnShadow *OGRFeatureDefnShadow_GetFieldDefn(OGRFeatureDefnShadow *self,int i){
2291
 
    return (OGRFieldDefnShadow*) OGR_FD_GetFieldDefn(self, i);
2292
 
  }
2293
 
SWIGINTERN int OGRFeatureDefnShadow_GetFieldIndex(OGRFeatureDefnShadow *self,char const *name){
2294
 
    if (name == NULL) {
2295
 
        CPLError(CE_Failure, 1, "Undefined field name in GetFieldIndex");
2296
 
        return 0;
2297
 
    } else
2298
 
        return OGR_FD_GetFieldIndex(self, name);
2299
 
  }
2300
 
SWIGINTERN void OGRFeatureDefnShadow_AddFieldDefn(OGRFeatureDefnShadow *self,OGRFieldDefnShadow *defn){
2301
 
    OGR_FD_AddFieldDefn(self, defn);
2302
 
  }
2303
 
SWIGINTERN OGRwkbGeometryType OGRFeatureDefnShadow_GetGeomType(OGRFeatureDefnShadow *self){
2304
 
    return (OGRwkbGeometryType) OGR_FD_GetGeomType(self);
2305
 
  }
2306
 
SWIGINTERN void OGRFeatureDefnShadow_SetGeomType(OGRFeatureDefnShadow *self,OGRwkbGeometryType geom_type){
2307
 
    OGR_FD_SetGeomType(self, geom_type);
2308
 
  }
2309
 
SWIGINTERN int OGRFeatureDefnShadow_GetReferenceCount(OGRFeatureDefnShadow *self){
2310
 
    return OGR_FD_GetReferenceCount(self);
2311
 
  }
2312
 
SWIGINTERN OGRFieldDefnShadow *new_OGRFieldDefnShadow(char const *name="unnamed",OGRFieldType field_type=OFTString){
2313
 
    return (OGRFieldDefnShadow*) OGR_Fld_Create(name, field_type);
2314
 
  }
2315
 
SWIGINTERN char const *OGRFieldDefnShadow_GetName(OGRFieldDefnShadow *self){
2316
 
    return (const char *) OGR_Fld_GetNameRef(self);
2317
 
  }
2318
 
SWIGINTERN char const *OGRFieldDefnShadow_GetNameRef(OGRFieldDefnShadow *self){
2319
 
    return (const char *) OGR_Fld_GetNameRef(self);
2320
 
  }
2321
 
SWIGINTERN void OGRFieldDefnShadow_SetName(OGRFieldDefnShadow *self,char const *name){
2322
 
    OGR_Fld_SetName(self, name);
2323
 
  }
2324
 
SWIGINTERN OGRFieldType OGRFieldDefnShadow_GetType(OGRFieldDefnShadow *self){
2325
 
    return OGR_Fld_GetType(self);
2326
 
  }
2327
 
SWIGINTERN void OGRFieldDefnShadow_SetType(OGRFieldDefnShadow *self,OGRFieldType type){
2328
 
    OGR_Fld_SetType(self, type);
2329
 
  }
2330
 
SWIGINTERN OGRJustification OGRFieldDefnShadow_GetJustify(OGRFieldDefnShadow *self){
2331
 
    return OGR_Fld_GetJustify(self);
2332
 
  }
2333
 
SWIGINTERN void OGRFieldDefnShadow_SetJustify(OGRFieldDefnShadow *self,OGRJustification justify){
2334
 
    OGR_Fld_SetJustify(self, justify);
2335
 
  }
2336
 
SWIGINTERN int OGRFieldDefnShadow_GetWidth(OGRFieldDefnShadow *self){
2337
 
    return OGR_Fld_GetWidth(self);
2338
 
  }
2339
 
SWIGINTERN void OGRFieldDefnShadow_SetWidth(OGRFieldDefnShadow *self,int width){
2340
 
    OGR_Fld_SetWidth(self, width);
2341
 
  }
2342
 
SWIGINTERN int OGRFieldDefnShadow_GetPrecision(OGRFieldDefnShadow *self){
2343
 
    return OGR_Fld_GetPrecision(self);
2344
 
  }
2345
 
SWIGINTERN void OGRFieldDefnShadow_SetPrecision(OGRFieldDefnShadow *self,int precision){
2346
 
    OGR_Fld_SetPrecision(self, precision);
2347
 
  }
2348
 
SWIGINTERN char const *OGRFieldDefnShadow_GetFieldTypeName(OGRFieldDefnShadow *self,OGRFieldType type){
2349
 
    return OGR_GetFieldTypeName(type);
2350
 
  }
2351
 
 
2352
 
  OGRGeometryShadow* CreateGeometryFromWkb( int len, char *bin_string, 
2353
 
                                            OSRSpatialReferenceShadow *reference=NULL ) {
2354
 
    void *geom;
2355
 
    OGRErr err = OGR_G_CreateFromWkb( (unsigned char *) bin_string,
2356
 
                                      reference,
2357
 
                                      &geom,
2358
 
                                      len );
2359
 
    if (err != 0 ) {
2360
 
       CPLError(CE_Failure, err, "%s", OGRErrMessages(err));
2361
 
       return NULL;
2362
 
    }
2363
 
    return (OGRGeometryShadow*) geom;
2364
 
  }
2365
 
 
2366
 
 
2367
 
 
2368
 
  OGRGeometryShadow* CreateGeometryFromWkt( char **val, 
2369
 
                                      OSRSpatialReferenceShadow *reference=NULL ) {
2370
 
    void *geom;
2371
 
    OGRErr err = OGR_G_CreateFromWkt(val,
2372
 
                                      reference,
2373
 
                                      &geom);
2374
 
    if (err != 0 ) {
2375
 
       CPLError(CE_Failure, err, "%s", OGRErrMessages(err));
2376
 
       return NULL;
2377
 
    }
2378
 
    return (OGRGeometryShadow*) geom;
2379
 
  }
2380
 
 
2381
 
 
2382
 
 
2383
 
  OGRGeometryShadow *CreateGeometryFromGML( const char * input_string ) {
2384
 
    OGRGeometryShadow* geom = (OGRGeometryShadow*)OGR_G_CreateFromGML(input_string);
2385
 
    return geom;
2386
 
  }
2387
 
 
2388
 
 
2389
 
SWIGINTERN OGRGeometryShadow *new_OGRGeometryShadow(OGRwkbGeometryType type=wkbUnknown,char *wkt=0,int wkb=0,char *wkb_buf=0,char *gml=0){
2390
 
    if (type != wkbUnknown ) {
2391
 
      return (OGRGeometryShadow*) OGR_G_CreateGeometry( type );
2392
 
    }
2393
 
    else if ( wkt != 0 ) {
2394
 
      return CreateGeometryFromWkt( &wkt );
2395
 
    }
2396
 
    else if ( wkb != 0 ) {
2397
 
      return CreateGeometryFromWkb( wkb, wkb_buf );
2398
 
    }
2399
 
    else if ( gml != 0 ) {
2400
 
      return CreateGeometryFromGML( gml );
2401
 
    }
2402
 
    // throw?
2403
 
    else return 0;
2404
 
  }
2405
 
 
2406
 
#define output_helper SWIG_Ruby_AppendOutput
2407
 
 
2408
 
SWIGINTERN OGRErr OGRGeometryShadow_ExportToWkt(OGRGeometryShadow *self,char **argout){
2409
 
    return OGR_G_ExportToWkt(self, argout);
2410
 
  }
2411
 
SWIGINTERN OGRErr OGRGeometryShadow_ExportToWkb(OGRGeometryShadow *self,int *nLen,char **pBuf,OGRwkbByteOrder byte_order=wkbXDR){
2412
 
    *nLen = OGR_G_WkbSize( self );
2413
 
    *pBuf = (char *) malloc( *nLen * sizeof(unsigned char) );
2414
 
    return OGR_G_ExportToWkb(self, byte_order, (unsigned char*) *pBuf );
2415
 
  }
2416
 
SWIGINTERN char const *OGRGeometryShadow_ExportToGML(OGRGeometryShadow *self){
2417
 
    return (const char *) OGR_G_ExportToGML(self);
2418
 
  }
2419
 
SWIGINTERN void OGRGeometryShadow_AddPoint(OGRGeometryShadow *self,double x,double y,double z=0){
2420
 
    OGR_G_AddPoint( self, x, y, z );
2421
 
  }
2422
 
SWIGINTERN OGRErr OGRGeometryShadow_AddGeometryDirectly(OGRGeometryShadow *self,OGRGeometryShadow *other){
2423
 
    return OGR_G_AddGeometryDirectly( self, other );
2424
 
  }
2425
 
SWIGINTERN OGRErr OGRGeometryShadow_AddGeometry(OGRGeometryShadow *self,OGRGeometryShadow *other){
2426
 
    return OGR_G_AddGeometry( self, other );
2427
 
  }
2428
 
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Clone(OGRGeometryShadow *self){
2429
 
    return (OGRGeometryShadow*) OGR_G_Clone(self);
2430
 
  }
2431
 
SWIGINTERN OGRwkbGeometryType OGRGeometryShadow_GetGeometryType(OGRGeometryShadow *self){
2432
 
    return (OGRwkbGeometryType) OGR_G_GetGeometryType(self);
2433
 
  }
2434
 
SWIGINTERN char const *OGRGeometryShadow_GetGeometryName(OGRGeometryShadow *self){
2435
 
    return (const char *) OGR_G_GetGeometryName(self);
2436
 
  }
2437
 
SWIGINTERN double OGRGeometryShadow_GetArea(OGRGeometryShadow *self){
2438
 
    return OGR_G_GetArea(self);
2439
 
  }
2440
 
SWIGINTERN int OGRGeometryShadow_GetPointCount(OGRGeometryShadow *self){
2441
 
    return OGR_G_GetPointCount(self);
2442
 
  }
2443
 
SWIGINTERN double OGRGeometryShadow_GetX(OGRGeometryShadow *self,int point=0){
2444
 
    return OGR_G_GetX(self, point);
2445
 
  }
2446
 
SWIGINTERN double OGRGeometryShadow_GetY(OGRGeometryShadow *self,int point=0){
2447
 
    return OGR_G_GetY(self, point);
2448
 
  }
2449
 
SWIGINTERN double OGRGeometryShadow_GetZ(OGRGeometryShadow *self,int point=0){
2450
 
    return OGR_G_GetZ(self, point);
2451
 
  }
2452
 
SWIGINTERN int OGRGeometryShadow_GetGeometryCount(OGRGeometryShadow *self){
2453
 
    return OGR_G_GetGeometryCount(self);
2454
 
  }
2455
 
SWIGINTERN void OGRGeometryShadow_SetPoint(OGRGeometryShadow *self,int point,double x,double y,double z=0){
2456
 
    OGR_G_SetPoint(self, point, x, y, z);
2457
 
  }
2458
 
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_GetGeometryRef(OGRGeometryShadow *self,int geom){
2459
 
    return (OGRGeometryShadow*) OGR_G_GetGeometryRef(self, geom);
2460
 
  }
2461
 
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_GetBoundary(OGRGeometryShadow *self){
2462
 
    return (OGRGeometryShadow*) OGR_G_GetBoundary(self);
2463
 
  }
2464
 
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_ConvexHull(OGRGeometryShadow *self){
2465
 
    return (OGRGeometryShadow*) OGR_G_ConvexHull(self);
2466
 
  }
2467
 
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Buffer(OGRGeometryShadow *self,double distance,int quadsecs=30){
2468
 
    return (OGRGeometryShadow*) OGR_G_Buffer( self, distance, quadsecs );
2469
 
  }
2470
 
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Intersection(OGRGeometryShadow *self,OGRGeometryShadow *other){
2471
 
    return (OGRGeometryShadow*) OGR_G_Intersection( self, other );
2472
 
  }
2473
 
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Union(OGRGeometryShadow *self,OGRGeometryShadow *other){
2474
 
    return (OGRGeometryShadow*) OGR_G_Union( self, other );
2475
 
  }
2476
 
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Difference(OGRGeometryShadow *self,OGRGeometryShadow *other){
2477
 
    return (OGRGeometryShadow*) OGR_G_Difference( self, other );
2478
 
  }
2479
 
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_SymmetricDifference(OGRGeometryShadow *self,OGRGeometryShadow *other){
2480
 
    return (OGRGeometryShadow*) OGR_G_SymmetricDifference( self, other );
2481
 
  }
2482
 
SWIGINTERN double OGRGeometryShadow_Distance(OGRGeometryShadow *self,OGRGeometryShadow *other){
2483
 
    return OGR_G_Distance(self, other);
2484
 
  }
2485
 
SWIGINTERN void OGRGeometryShadow_Empty(OGRGeometryShadow *self){
2486
 
    OGR_G_Empty(self);
2487
 
  }
2488
 
SWIGINTERN bool OGRGeometryShadow_Intersect(OGRGeometryShadow *self,OGRGeometryShadow *other){
2489
 
    return OGR_G_Intersect(self, other);
2490
 
  }
2491
 
SWIGINTERN bool OGRGeometryShadow_Equal(OGRGeometryShadow *self,OGRGeometryShadow *other){
2492
 
    return OGR_G_Equal(self, other);
2493
 
  }
2494
 
SWIGINTERN bool OGRGeometryShadow_Disjoint(OGRGeometryShadow *self,OGRGeometryShadow *other){
2495
 
    return OGR_G_Disjoint(self, other);
2496
 
  }
2497
 
SWIGINTERN bool OGRGeometryShadow_Touches(OGRGeometryShadow *self,OGRGeometryShadow *other){
2498
 
    return OGR_G_Touches(self, other);
2499
 
  }
2500
 
SWIGINTERN bool OGRGeometryShadow_Crosses(OGRGeometryShadow *self,OGRGeometryShadow *other){
2501
 
    return OGR_G_Crosses(self, other);
2502
 
  }
2503
 
SWIGINTERN bool OGRGeometryShadow_Within(OGRGeometryShadow *self,OGRGeometryShadow *other){
2504
 
    return OGR_G_Within(self, other);
2505
 
  }
2506
 
SWIGINTERN bool OGRGeometryShadow_Contains(OGRGeometryShadow *self,OGRGeometryShadow *other){
2507
 
    return OGR_G_Contains(self, other);
2508
 
  }
2509
 
SWIGINTERN bool OGRGeometryShadow_Overlaps(OGRGeometryShadow *self,OGRGeometryShadow *other){
2510
 
    return OGR_G_Overlaps(self, other);
2511
 
  }
2512
 
SWIGINTERN OGRErr OGRGeometryShadow_TransformTo(OGRGeometryShadow *self,OSRSpatialReferenceShadow *reference){
2513
 
    return OGR_G_TransformTo(self, reference);
2514
 
  }
2515
 
SWIGINTERN OGRErr OGRGeometryShadow_Transform(OGRGeometryShadow *self,OSRCoordinateTransformationShadow *trans){
2516
 
    return OGR_G_Transform(self, trans);
2517
 
  }
2518
 
SWIGINTERN OSRSpatialReferenceShadow *OGRGeometryShadow_GetSpatialReference(OGRGeometryShadow *self){
2519
 
    return (OSRSpatialReferenceShadow*)OGR_G_GetSpatialReference(self);
2520
 
  }
2521
 
SWIGINTERN void OGRGeometryShadow_AssignSpatialReference(OGRGeometryShadow *self,OSRSpatialReferenceShadow *reference){
2522
 
    OGR_G_AssignSpatialReference(self, reference);
2523
 
  }
2524
 
SWIGINTERN void OGRGeometryShadow_CloseRings(OGRGeometryShadow *self){
2525
 
    OGR_G_CloseRings(self);
2526
 
  }
2527
 
SWIGINTERN void OGRGeometryShadow_FlattenTo2D(OGRGeometryShadow *self){
2528
 
    OGR_G_FlattenTo2D(self);
2529
 
  }
2530
 
SWIGINTERN void OGRGeometryShadow_GetEnvelope(OGRGeometryShadow *self,double argout[4]){
2531
 
    OGR_G_GetEnvelope(self, (OGREnvelope*)argout);
2532
 
  }
2533
 
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Centroid(OGRGeometryShadow *self){
2534
 
    OGRGeometryShadow *pt = new_OGRGeometryShadow( wkbPoint );
2535
 
    OGR_G_Centroid( self, pt );
2536
 
    return pt;
2537
 
  }
2538
 
SWIGINTERN int OGRGeometryShadow_WkbSize(OGRGeometryShadow *self){
2539
 
    return OGR_G_WkbSize(self);
2540
 
  }
2541
 
SWIGINTERN int OGRGeometryShadow_GetCoordinateDimension(OGRGeometryShadow *self){
2542
 
    return OGR_G_GetCoordinateDimension(self);
2543
 
  }
2544
 
SWIGINTERN void OGRGeometryShadow_SetCoordinateDimension(OGRGeometryShadow *self,int dimension){
2545
 
    OGR_G_SetCoordinateDimension(self, dimension);
2546
 
  }
2547
 
SWIGINTERN int OGRGeometryShadow_GetDimension(OGRGeometryShadow *self){
2548
 
    return OGR_G_GetDimension(self);
2549
 
  }
2550
 
 
2551
 
char const *OGRDriverShadow_get_name( OGRDriverShadow *h ) {
2552
 
  return OGR_Dr_GetName( h );
2553
 
}
2554
 
 
2555
 
char const *OGRDataSourceShadow_get_name( OGRDataSourceShadow *h ) {
2556
 
  return OGR_DS_GetName( h );
2557
 
}
2558
 
 
2559
 
char const *OGRDriverShadow_name_get( OGRDriverShadow *h ) {
2560
 
  return OGR_Dr_GetName( h );
2561
 
}
2562
 
 
2563
 
char const *OGRDataSourceShadow_name_get( OGRDataSourceShadow *h ) {
2564
 
  return OGR_DS_GetName( h );
2565
 
}
2566
 
 
2567
 
 
2568
 
  OGRDataSourceShadow* GetOpenDS(int ds_number) {
2569
 
    OGRDataSourceShadow* layer = (OGRDataSourceShadow*) OGRGetOpenDS(ds_number);
2570
 
    return layer;
2571
 
  }
2572
 
 
2573
 
 
2574
 
  OGRDataSourceShadow* Open( const char *filename, int update =0 ) {
2575
 
    OGRDataSourceShadow* ds = (OGRDataSourceShadow*)OGROpen(filename,update,NULL);
2576
 
    return ds;
2577
 
  }
2578
 
 
2579
 
 
2580
 
  OGRDataSourceShadow* OpenShared( const char *filename, int update =0 ) {
2581
 
    OGRDataSourceShadow* ds = (OGRDataSourceShadow*)OGROpenShared(filename,update,NULL);
2582
 
    return ds;
2583
 
  }
2584
 
 
2585
 
 
2586
 
OGRDriverShadow* GetDriverByName( char const *name ) {
2587
 
  return (OGRDriverShadow*) OGRGetDriverByName( name );
2588
 
}
2589
 
 
2590
 
OGRDriverShadow* GetDriver(int driver_number) {
2591
 
  return (OGRDriverShadow*) OGRGetDriver(driver_number);
2592
 
}
2593
 
 
2594
 
SWIGINTERN VALUE
2595
 
_wrap_use_exceptions(int argc, VALUE *argv, VALUE self) {
2596
 
  if ((argc < 0) || (argc > 0)) {
2597
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2598
 
  }
2599
 
  UseExceptions();
2600
 
  return Qnil;
2601
 
fail:
2602
 
  return Qnil;
2603
 
}
2604
 
 
2605
 
 
2606
 
SWIGINTERN VALUE
2607
 
_wrap_dont_use_exceptions(int argc, VALUE *argv, VALUE self) {
2608
 
  if ((argc < 0) || (argc > 0)) {
2609
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2610
 
  }
2611
 
  DontUseExceptions();
2612
 
  return Qnil;
2613
 
fail:
2614
 
  return Qnil;
2615
 
}
2616
 
 
2617
 
 
2618
 
swig_class cDriver;
2619
 
 
2620
 
SWIGINTERN VALUE
2621
 
_wrap_Driver_name_get(int argc, VALUE *argv, VALUE self) {
2622
 
  OGRDriverShadow *arg1 = (OGRDriverShadow *) 0 ;
2623
 
  char *result = 0 ;
2624
 
  void *argp1 = 0 ;
2625
 
  int res1 = 0 ;
2626
 
  VALUE vresult = Qnil;
2627
 
  
2628
 
  if ((argc < 0) || (argc > 0)) {
2629
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2630
 
  }
2631
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRDriverShadow, 0 |  0 );
2632
 
  if (!SWIG_IsOK(res1)) {
2633
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "name" "', argument " "1"" of type '" "OGRDriverShadow *""'"); 
2634
 
  }
2635
 
  arg1 = reinterpret_cast< OGRDriverShadow * >(argp1);
2636
 
  {
2637
 
    CPLErrorReset();
2638
 
    result = (char *)OGRDriverShadow_name_get(arg1);
2639
 
    CPLErr eclass = CPLGetLastErrorType();
2640
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
2641
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
2642
 
      
2643
 
    }
2644
 
  }
2645
 
  vresult = SWIG_FromCharPtr(result);
2646
 
  return vresult;
2647
 
fail:
2648
 
  return Qnil;
2649
 
}
2650
 
 
2651
 
 
2652
 
SWIGINTERN VALUE
2653
 
_wrap_Driver_create_data_source(int argc, VALUE *argv, VALUE self) {
2654
 
  OGRDriverShadow *arg1 = (OGRDriverShadow *) 0 ;
2655
 
  char *arg2 = (char *) 0 ;
2656
 
  char **arg3 = (char **) 0 ;
2657
 
  OGRDataSourceShadow *result = 0 ;
2658
 
  void *argp1 = 0 ;
2659
 
  int res1 = 0 ;
2660
 
  int res2 ;
2661
 
  char *buf2 = 0 ;
2662
 
  int alloc2 = 0 ;
2663
 
  char *kwnames[] = {
2664
 
    "self","name","options", NULL 
2665
 
  };
2666
 
  VALUE vresult = Qnil;
2667
 
  
2668
 
  if ((argc < 1) || (argc > 2)) {
2669
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2670
 
  }
2671
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRDriverShadow, 0 |  0 );
2672
 
  if (!SWIG_IsOK(res1)) {
2673
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateDataSource" "', argument " "1"" of type '" "OGRDriverShadow *""'"); 
2674
 
  }
2675
 
  arg1 = reinterpret_cast< OGRDriverShadow * >(argp1);
2676
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
2677
 
  if (!SWIG_IsOK(res2)) {
2678
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CreateDataSource" "', argument " "2"" of type '" "char const *""'");
2679
 
  }
2680
 
  arg2 = buf2;
2681
 
  if (argc > 1) {
2682
 
    {
2683
 
      /* %typemap(in) char **options */
2684
 
      
2685
 
      /* Check if is a list */
2686
 
      Check_Type(argv[1], T_ARRAY);
2687
 
      
2688
 
      int size = RARRAY(argv[1])->len;
2689
 
      for (int i = 0; i < size; i++) {
2690
 
        VALUE item = rb_ary_entry(argv[1], i);
2691
 
        char *pszItem = StringValuePtr(item);
2692
 
        arg3 = CSLAddString( arg3, pszItem );
2693
 
      }
2694
 
    }
2695
 
  }
2696
 
  {
2697
 
    CPLErrorReset();
2698
 
    result = (OGRDataSourceShadow *)OGRDriverShadow_CreateDataSource(arg1,(char const *)arg2,arg3);
2699
 
    CPLErr eclass = CPLGetLastErrorType();
2700
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
2701
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
2702
 
      
2703
 
    }
2704
 
  }
2705
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRDataSourceShadow, SWIG_POINTER_OWN |  0 );
2706
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2707
 
  {
2708
 
    /* %typemap(freearg) char **options */
2709
 
    
2710
 
    CSLDestroy( arg3 );
2711
 
  }
2712
 
  return vresult;
2713
 
fail:
2714
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2715
 
  {
2716
 
    /* %typemap(freearg) char **options */
2717
 
    
2718
 
    CSLDestroy( arg3 );
2719
 
  }
2720
 
  return Qnil;
2721
 
}
2722
 
 
2723
 
 
2724
 
SWIGINTERN VALUE
2725
 
_wrap_Driver_copy_data_source(int argc, VALUE *argv, VALUE self) {
2726
 
  OGRDriverShadow *arg1 = (OGRDriverShadow *) 0 ;
2727
 
  OGRDataSourceShadow *arg2 = (OGRDataSourceShadow *) 0 ;
2728
 
  char *arg3 = (char *) 0 ;
2729
 
  char **arg4 = (char **) 0 ;
2730
 
  OGRDataSourceShadow *result = 0 ;
2731
 
  void *argp1 = 0 ;
2732
 
  int res1 = 0 ;
2733
 
  void *argp2 = 0 ;
2734
 
  int res2 = 0 ;
2735
 
  int res3 ;
2736
 
  char *buf3 = 0 ;
2737
 
  int alloc3 = 0 ;
2738
 
  char *kwnames[] = {
2739
 
    "self","copy_ds","name","options", NULL 
2740
 
  };
2741
 
  VALUE vresult = Qnil;
2742
 
  
2743
 
  if ((argc < 2) || (argc > 3)) {
2744
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
2745
 
  }
2746
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRDriverShadow, 0 |  0 );
2747
 
  if (!SWIG_IsOK(res1)) {
2748
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CopyDataSource" "', argument " "1"" of type '" "OGRDriverShadow *""'"); 
2749
 
  }
2750
 
  arg1 = reinterpret_cast< OGRDriverShadow * >(argp1);
2751
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRDataSourceShadow, 0 |  0 );
2752
 
  if (!SWIG_IsOK(res2)) {
2753
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CopyDataSource" "', argument " "2"" of type '" "OGRDataSourceShadow *""'"); 
2754
 
  }
2755
 
  arg2 = reinterpret_cast< OGRDataSourceShadow * >(argp2);
2756
 
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
2757
 
  if (!SWIG_IsOK(res3)) {
2758
 
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CopyDataSource" "', argument " "3"" of type '" "char const *""'");
2759
 
  }
2760
 
  arg3 = buf3;
2761
 
  if (argc > 2) {
2762
 
    {
2763
 
      /* %typemap(in) char **options */
2764
 
      
2765
 
      /* Check if is a list */
2766
 
      Check_Type(argv[2], T_ARRAY);
2767
 
      
2768
 
      int size = RARRAY(argv[2])->len;
2769
 
      for (int i = 0; i < size; i++) {
2770
 
        VALUE item = rb_ary_entry(argv[2], i);
2771
 
        char *pszItem = StringValuePtr(item);
2772
 
        arg4 = CSLAddString( arg4, pszItem );
2773
 
      }
2774
 
    }
2775
 
  }
2776
 
  {
2777
 
    CPLErrorReset();
2778
 
    result = (OGRDataSourceShadow *)OGRDriverShadow_CopyDataSource(arg1,arg2,(char const *)arg3,arg4);
2779
 
    CPLErr eclass = CPLGetLastErrorType();
2780
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
2781
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
2782
 
      
2783
 
    }
2784
 
  }
2785
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRDataSourceShadow, SWIG_POINTER_OWN |  0 );
2786
 
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
2787
 
  {
2788
 
    /* %typemap(freearg) char **options */
2789
 
    
2790
 
    CSLDestroy( arg4 );
2791
 
  }
2792
 
  return vresult;
2793
 
fail:
2794
 
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
2795
 
  {
2796
 
    /* %typemap(freearg) char **options */
2797
 
    
2798
 
    CSLDestroy( arg4 );
2799
 
  }
2800
 
  return Qnil;
2801
 
}
2802
 
 
2803
 
 
2804
 
SWIGINTERN VALUE
2805
 
_wrap_Driver_open(int argc, VALUE *argv, VALUE self) {
2806
 
  OGRDriverShadow *arg1 = (OGRDriverShadow *) 0 ;
2807
 
  char *arg2 = (char *) 0 ;
2808
 
  int arg3 = (int) 0 ;
2809
 
  OGRDataSourceShadow *result = 0 ;
2810
 
  void *argp1 = 0 ;
2811
 
  int res1 = 0 ;
2812
 
  int res2 ;
2813
 
  char *buf2 = 0 ;
2814
 
  int alloc2 = 0 ;
2815
 
  int val3 ;
2816
 
  int ecode3 = 0 ;
2817
 
  char *kwnames[] = {
2818
 
    "self","name","update", NULL 
2819
 
  };
2820
 
  VALUE vresult = Qnil;
2821
 
  
2822
 
  if ((argc < 1) || (argc > 2)) {
2823
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2824
 
  }
2825
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRDriverShadow, 0 |  0 );
2826
 
  if (!SWIG_IsOK(res1)) {
2827
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Open" "', argument " "1"" of type '" "OGRDriverShadow *""'"); 
2828
 
  }
2829
 
  arg1 = reinterpret_cast< OGRDriverShadow * >(argp1);
2830
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
2831
 
  if (!SWIG_IsOK(res2)) {
2832
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Open" "', argument " "2"" of type '" "char const *""'");
2833
 
  }
2834
 
  arg2 = buf2;
2835
 
  if (argc > 1) {
2836
 
    ecode3 = SWIG_AsVal_int(argv[1], &val3);
2837
 
    if (!SWIG_IsOK(ecode3)) {
2838
 
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Open" "', argument " "3"" of type '" "int""'");
2839
 
    } 
2840
 
    arg3 = static_cast< int >(val3);
2841
 
  }
2842
 
  {
2843
 
    CPLErrorReset();
2844
 
    result = (OGRDataSourceShadow *)OGRDriverShadow_Open(arg1,(char const *)arg2,arg3);
2845
 
    CPLErr eclass = CPLGetLastErrorType();
2846
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
2847
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
2848
 
      
2849
 
    }
2850
 
  }
2851
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRDataSourceShadow, SWIG_POINTER_OWN |  0 );
2852
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2853
 
  return vresult;
2854
 
fail:
2855
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2856
 
  return Qnil;
2857
 
}
2858
 
 
2859
 
 
2860
 
SWIGINTERN VALUE
2861
 
_wrap_Driver_delete_data_source(int argc, VALUE *argv, VALUE self) {
2862
 
  OGRDriverShadow *arg1 = (OGRDriverShadow *) 0 ;
2863
 
  char *arg2 = (char *) 0 ;
2864
 
  int result;
2865
 
  void *argp1 = 0 ;
2866
 
  int res1 = 0 ;
2867
 
  int res2 ;
2868
 
  char *buf2 = 0 ;
2869
 
  int alloc2 = 0 ;
2870
 
  VALUE vresult = Qnil;
2871
 
  
2872
 
  if ((argc < 1) || (argc > 1)) {
2873
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2874
 
  }
2875
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRDriverShadow, 0 |  0 );
2876
 
  if (!SWIG_IsOK(res1)) {
2877
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeleteDataSource" "', argument " "1"" of type '" "OGRDriverShadow *""'"); 
2878
 
  }
2879
 
  arg1 = reinterpret_cast< OGRDriverShadow * >(argp1);
2880
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
2881
 
  if (!SWIG_IsOK(res2)) {
2882
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeleteDataSource" "', argument " "2"" of type '" "char const *""'");
2883
 
  }
2884
 
  arg2 = buf2;
2885
 
  {
2886
 
    CPLErrorReset();
2887
 
    result = (int)OGRDriverShadow_DeleteDataSource(arg1,(char const *)arg2);
2888
 
    CPLErr eclass = CPLGetLastErrorType();
2889
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
2890
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
2891
 
      
2892
 
    }
2893
 
  }
2894
 
  vresult = SWIG_From_int(static_cast< int >(result));
2895
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2896
 
  return vresult;
2897
 
fail:
2898
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2899
 
  return Qnil;
2900
 
}
2901
 
 
2902
 
 
2903
 
SWIGINTERN VALUE
2904
 
_wrap_Driver_test_capability(int argc, VALUE *argv, VALUE self) {
2905
 
  OGRDriverShadow *arg1 = (OGRDriverShadow *) 0 ;
2906
 
  char *arg2 = (char *) 0 ;
2907
 
  bool result;
2908
 
  void *argp1 = 0 ;
2909
 
  int res1 = 0 ;
2910
 
  int res2 ;
2911
 
  char *buf2 = 0 ;
2912
 
  int alloc2 = 0 ;
2913
 
  VALUE vresult = Qnil;
2914
 
  
2915
 
  if ((argc < 1) || (argc > 1)) {
2916
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2917
 
  }
2918
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRDriverShadow, 0 |  0 );
2919
 
  if (!SWIG_IsOK(res1)) {
2920
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestCapability" "', argument " "1"" of type '" "OGRDriverShadow *""'"); 
2921
 
  }
2922
 
  arg1 = reinterpret_cast< OGRDriverShadow * >(argp1);
2923
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
2924
 
  if (!SWIG_IsOK(res2)) {
2925
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TestCapability" "', argument " "2"" of type '" "char const *""'");
2926
 
  }
2927
 
  arg2 = buf2;
2928
 
  {
2929
 
    CPLErrorReset();
2930
 
    result = (bool)OGRDriverShadow_TestCapability(arg1,(char const *)arg2);
2931
 
    CPLErr eclass = CPLGetLastErrorType();
2932
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
2933
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
2934
 
      
2935
 
    }
2936
 
  }
2937
 
  vresult = SWIG_From_bool(static_cast< bool >(result));
2938
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2939
 
  return vresult;
2940
 
fail:
2941
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
2942
 
  return Qnil;
2943
 
}
2944
 
 
2945
 
 
2946
 
SWIGINTERN VALUE
2947
 
_wrap_Driver_get_name(int argc, VALUE *argv, VALUE self) {
2948
 
  OGRDriverShadow *arg1 = (OGRDriverShadow *) 0 ;
2949
 
  char *result = 0 ;
2950
 
  void *argp1 = 0 ;
2951
 
  int res1 = 0 ;
2952
 
  VALUE vresult = Qnil;
2953
 
  
2954
 
  if ((argc < 0) || (argc > 0)) {
2955
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2956
 
  }
2957
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRDriverShadow, 0 |  0 );
2958
 
  if (!SWIG_IsOK(res1)) {
2959
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetName" "', argument " "1"" of type '" "OGRDriverShadow *""'"); 
2960
 
  }
2961
 
  arg1 = reinterpret_cast< OGRDriverShadow * >(argp1);
2962
 
  {
2963
 
    CPLErrorReset();
2964
 
    result = (char *)OGRDriverShadow_GetName(arg1);
2965
 
    CPLErr eclass = CPLGetLastErrorType();
2966
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
2967
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
2968
 
      
2969
 
    }
2970
 
  }
2971
 
  vresult = SWIG_FromCharPtr(result);
2972
 
  return vresult;
2973
 
fail:
2974
 
  return Qnil;
2975
 
}
2976
 
 
2977
 
 
2978
 
swig_class cDataSource;
2979
 
 
2980
 
SWIGINTERN VALUE
2981
 
_wrap_DataSource_name_get(int argc, VALUE *argv, VALUE self) {
2982
 
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
2983
 
  char *result = 0 ;
2984
 
  void *argp1 = 0 ;
2985
 
  int res1 = 0 ;
2986
 
  VALUE vresult = Qnil;
2987
 
  
2988
 
  if ((argc < 0) || (argc > 0)) {
2989
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2990
 
  }
2991
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRDataSourceShadow, 0 |  0 );
2992
 
  if (!SWIG_IsOK(res1)) {
2993
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "name" "', argument " "1"" of type '" "OGRDataSourceShadow *""'"); 
2994
 
  }
2995
 
  arg1 = reinterpret_cast< OGRDataSourceShadow * >(argp1);
2996
 
  {
2997
 
    CPLErrorReset();
2998
 
    result = (char *)OGRDataSourceShadow_name_get(arg1);
2999
 
    CPLErr eclass = CPLGetLastErrorType();
3000
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3001
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3002
 
      
3003
 
    }
3004
 
  }
3005
 
  vresult = SWIG_FromCharPtr(result);
3006
 
  return vresult;
3007
 
fail:
3008
 
  return Qnil;
3009
 
}
3010
 
 
3011
 
 
3012
 
SWIGINTERN void delete_OGRDataSourceShadow(OGRDataSourceShadow *self){
3013
 
    OGRReleaseDataSource(self);
3014
 
  }
3015
 
SWIGINTERN void
3016
 
free_OGRDataSourceShadow(OGRDataSourceShadow *arg1) {
3017
 
    delete_OGRDataSourceShadow(arg1);
3018
 
}
3019
 
 
3020
 
SWIGINTERN VALUE
3021
 
_wrap_DataSource_get_ref_count(int argc, VALUE *argv, VALUE self) {
3022
 
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
3023
 
  int result;
3024
 
  void *argp1 = 0 ;
3025
 
  int res1 = 0 ;
3026
 
  VALUE vresult = Qnil;
3027
 
  
3028
 
  if ((argc < 0) || (argc > 0)) {
3029
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3030
 
  }
3031
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRDataSourceShadow, 0 |  0 );
3032
 
  if (!SWIG_IsOK(res1)) {
3033
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetRefCount" "', argument " "1"" of type '" "OGRDataSourceShadow *""'"); 
3034
 
  }
3035
 
  arg1 = reinterpret_cast< OGRDataSourceShadow * >(argp1);
3036
 
  {
3037
 
    CPLErrorReset();
3038
 
    result = (int)OGRDataSourceShadow_GetRefCount(arg1);
3039
 
    CPLErr eclass = CPLGetLastErrorType();
3040
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3041
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3042
 
      
3043
 
    }
3044
 
  }
3045
 
  vresult = SWIG_From_int(static_cast< int >(result));
3046
 
  return vresult;
3047
 
fail:
3048
 
  return Qnil;
3049
 
}
3050
 
 
3051
 
 
3052
 
SWIGINTERN VALUE
3053
 
_wrap_DataSource_get_summary_ref_count(int argc, VALUE *argv, VALUE self) {
3054
 
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
3055
 
  int result;
3056
 
  void *argp1 = 0 ;
3057
 
  int res1 = 0 ;
3058
 
  VALUE vresult = Qnil;
3059
 
  
3060
 
  if ((argc < 0) || (argc > 0)) {
3061
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3062
 
  }
3063
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRDataSourceShadow, 0 |  0 );
3064
 
  if (!SWIG_IsOK(res1)) {
3065
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetSummaryRefCount" "', argument " "1"" of type '" "OGRDataSourceShadow *""'"); 
3066
 
  }
3067
 
  arg1 = reinterpret_cast< OGRDataSourceShadow * >(argp1);
3068
 
  {
3069
 
    CPLErrorReset();
3070
 
    result = (int)OGRDataSourceShadow_GetSummaryRefCount(arg1);
3071
 
    CPLErr eclass = CPLGetLastErrorType();
3072
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3073
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3074
 
      
3075
 
    }
3076
 
  }
3077
 
  vresult = SWIG_From_int(static_cast< int >(result));
3078
 
  return vresult;
3079
 
fail:
3080
 
  return Qnil;
3081
 
}
3082
 
 
3083
 
 
3084
 
SWIGINTERN VALUE
3085
 
_wrap_DataSource_get_layer_count(int argc, VALUE *argv, VALUE self) {
3086
 
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
3087
 
  int result;
3088
 
  void *argp1 = 0 ;
3089
 
  int res1 = 0 ;
3090
 
  VALUE vresult = Qnil;
3091
 
  
3092
 
  if ((argc < 0) || (argc > 0)) {
3093
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3094
 
  }
3095
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRDataSourceShadow, 0 |  0 );
3096
 
  if (!SWIG_IsOK(res1)) {
3097
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetLayerCount" "', argument " "1"" of type '" "OGRDataSourceShadow *""'"); 
3098
 
  }
3099
 
  arg1 = reinterpret_cast< OGRDataSourceShadow * >(argp1);
3100
 
  {
3101
 
    CPLErrorReset();
3102
 
    result = (int)OGRDataSourceShadow_GetLayerCount(arg1);
3103
 
    CPLErr eclass = CPLGetLastErrorType();
3104
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3105
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3106
 
      
3107
 
    }
3108
 
  }
3109
 
  vresult = SWIG_From_int(static_cast< int >(result));
3110
 
  return vresult;
3111
 
fail:
3112
 
  return Qnil;
3113
 
}
3114
 
 
3115
 
 
3116
 
SWIGINTERN VALUE
3117
 
_wrap_DataSource_get_driver(int argc, VALUE *argv, VALUE self) {
3118
 
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
3119
 
  OGRDriverShadow *result = 0 ;
3120
 
  void *argp1 = 0 ;
3121
 
  int res1 = 0 ;
3122
 
  VALUE vresult = Qnil;
3123
 
  
3124
 
  if ((argc < 0) || (argc > 0)) {
3125
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3126
 
  }
3127
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRDataSourceShadow, 0 |  0 );
3128
 
  if (!SWIG_IsOK(res1)) {
3129
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetDriver" "', argument " "1"" of type '" "OGRDataSourceShadow *""'"); 
3130
 
  }
3131
 
  arg1 = reinterpret_cast< OGRDataSourceShadow * >(argp1);
3132
 
  {
3133
 
    CPLErrorReset();
3134
 
    result = (OGRDriverShadow *)OGRDataSourceShadow_GetDriver(arg1);
3135
 
    CPLErr eclass = CPLGetLastErrorType();
3136
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3137
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3138
 
      
3139
 
    }
3140
 
  }
3141
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRDriverShadow, 0 |  0 );
3142
 
  return vresult;
3143
 
fail:
3144
 
  return Qnil;
3145
 
}
3146
 
 
3147
 
 
3148
 
SWIGINTERN VALUE
3149
 
_wrap_DataSource_get_name(int argc, VALUE *argv, VALUE self) {
3150
 
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
3151
 
  char *result = 0 ;
3152
 
  void *argp1 = 0 ;
3153
 
  int res1 = 0 ;
3154
 
  VALUE vresult = Qnil;
3155
 
  
3156
 
  if ((argc < 0) || (argc > 0)) {
3157
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3158
 
  }
3159
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRDataSourceShadow, 0 |  0 );
3160
 
  if (!SWIG_IsOK(res1)) {
3161
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetName" "', argument " "1"" of type '" "OGRDataSourceShadow *""'"); 
3162
 
  }
3163
 
  arg1 = reinterpret_cast< OGRDataSourceShadow * >(argp1);
3164
 
  {
3165
 
    CPLErrorReset();
3166
 
    result = (char *)OGRDataSourceShadow_GetName(arg1);
3167
 
    CPLErr eclass = CPLGetLastErrorType();
3168
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3169
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3170
 
      
3171
 
    }
3172
 
  }
3173
 
  vresult = SWIG_FromCharPtr(result);
3174
 
  return vresult;
3175
 
fail:
3176
 
  return Qnil;
3177
 
}
3178
 
 
3179
 
 
3180
 
SWIGINTERN VALUE
3181
 
_wrap_DataSource_delete_layer(int argc, VALUE *argv, VALUE self) {
3182
 
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
3183
 
  int arg2 ;
3184
 
  OGRErr result;
3185
 
  void *argp1 = 0 ;
3186
 
  int res1 = 0 ;
3187
 
  int val2 ;
3188
 
  int ecode2 = 0 ;
3189
 
  VALUE vresult = Qnil;
3190
 
  
3191
 
  if ((argc < 1) || (argc > 1)) {
3192
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3193
 
  }
3194
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRDataSourceShadow, 0 |  0 );
3195
 
  if (!SWIG_IsOK(res1)) {
3196
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeleteLayer" "', argument " "1"" of type '" "OGRDataSourceShadow *""'"); 
3197
 
  }
3198
 
  arg1 = reinterpret_cast< OGRDataSourceShadow * >(argp1);
3199
 
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
3200
 
  if (!SWIG_IsOK(ecode2)) {
3201
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DeleteLayer" "', argument " "2"" of type '" "int""'");
3202
 
  } 
3203
 
  arg2 = static_cast< int >(val2);
3204
 
  {
3205
 
    CPLErrorReset();
3206
 
    result = (OGRErr)OGRDataSourceShadow_DeleteLayer(arg1,arg2);
3207
 
    CPLErr eclass = CPLGetLastErrorType();
3208
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3209
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3210
 
      
3211
 
    }
3212
 
  }
3213
 
  {
3214
 
    /* %typemap(out) OGRErr */
3215
 
    if (result != 0) {
3216
 
      rb_raise(rb_eRuntimeError, OGRErrMessages(result));
3217
 
    }
3218
 
  }
3219
 
  {
3220
 
    /* %typemap(ret) OGRErr */
3221
 
    if (vresult == Qnil) {
3222
 
      vresult = INT2NUM(0);
3223
 
    }
3224
 
  }    return vresult;
3225
 
fail:
3226
 
  return Qnil;
3227
 
}
3228
 
 
3229
 
 
3230
 
SWIGINTERN VALUE
3231
 
_wrap_DataSource_create_layer(int argc, VALUE *argv, VALUE self) {
3232
 
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
3233
 
  char *arg2 = (char *) 0 ;
3234
 
  OSRSpatialReferenceShadow *arg3 = (OSRSpatialReferenceShadow *) NULL ;
3235
 
  OGRwkbGeometryType arg4 = (OGRwkbGeometryType) wkbUnknown ;
3236
 
  char **arg5 = (char **) 0 ;
3237
 
  OGRLayerShadow *result = 0 ;
3238
 
  void *argp1 = 0 ;
3239
 
  int res1 = 0 ;
3240
 
  int res2 ;
3241
 
  char *buf2 = 0 ;
3242
 
  int alloc2 = 0 ;
3243
 
  void *argp3 = 0 ;
3244
 
  int res3 = 0 ;
3245
 
  char *kwnames[] = {
3246
 
    "self","name","reference","geom_type","options", NULL 
3247
 
  };
3248
 
  VALUE vresult = Qnil;
3249
 
  
3250
 
  if ((argc < 1) || (argc > 4)) {
3251
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3252
 
  }
3253
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRDataSourceShadow, 0 |  0 );
3254
 
  if (!SWIG_IsOK(res1)) {
3255
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateLayer" "', argument " "1"" of type '" "OGRDataSourceShadow *""'"); 
3256
 
  }
3257
 
  arg1 = reinterpret_cast< OGRDataSourceShadow * >(argp1);
3258
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
3259
 
  if (!SWIG_IsOK(res2)) {
3260
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CreateLayer" "', argument " "2"" of type '" "char const *""'");
3261
 
  }
3262
 
  arg2 = buf2;
3263
 
  if (argc > 1) {
3264
 
    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 |  0 );
3265
 
    if (!SWIG_IsOK(res3)) {
3266
 
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CreateLayer" "', argument " "3"" of type '" "OSRSpatialReferenceShadow *""'"); 
3267
 
    }
3268
 
    arg3 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp3);
3269
 
  }
3270
 
  if (argc > 2) {
3271
 
    {
3272
 
      /* %typemap(in) CPLErr */
3273
 
      arg4 = (OGRwkbGeometryType) NUM2INT(argv[2]);
3274
 
    }
3275
 
  }
3276
 
  if (argc > 3) {
3277
 
    {
3278
 
      /* %typemap(in) char **options */
3279
 
      
3280
 
      /* Check if is a list */
3281
 
      Check_Type(argv[3], T_ARRAY);
3282
 
      
3283
 
      int size = RARRAY(argv[3])->len;
3284
 
      for (int i = 0; i < size; i++) {
3285
 
        VALUE item = rb_ary_entry(argv[3], i);
3286
 
        char *pszItem = StringValuePtr(item);
3287
 
        arg5 = CSLAddString( arg5, pszItem );
3288
 
      }
3289
 
    }
3290
 
  }
3291
 
  {
3292
 
    CPLErrorReset();
3293
 
    result = (OGRLayerShadow *)OGRDataSourceShadow_CreateLayer(arg1,(char const *)arg2,arg3,arg4,arg5);
3294
 
    CPLErr eclass = CPLGetLastErrorType();
3295
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3296
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3297
 
      
3298
 
    }
3299
 
  }
3300
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
3301
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3302
 
  {
3303
 
    /* %typemap(freearg) char **options */
3304
 
    
3305
 
    CSLDestroy( arg5 );
3306
 
  }
3307
 
  return vresult;
3308
 
fail:
3309
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3310
 
  {
3311
 
    /* %typemap(freearg) char **options */
3312
 
    
3313
 
    CSLDestroy( arg5 );
3314
 
  }
3315
 
  return Qnil;
3316
 
}
3317
 
 
3318
 
 
3319
 
SWIGINTERN VALUE
3320
 
_wrap_DataSource_copy_layer(int argc, VALUE *argv, VALUE self) {
3321
 
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
3322
 
  OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
3323
 
  char *arg3 = (char *) 0 ;
3324
 
  char **arg4 = (char **) 0 ;
3325
 
  OGRLayerShadow *result = 0 ;
3326
 
  void *argp1 = 0 ;
3327
 
  int res1 = 0 ;
3328
 
  void *argp2 = 0 ;
3329
 
  int res2 = 0 ;
3330
 
  int res3 ;
3331
 
  char *buf3 = 0 ;
3332
 
  int alloc3 = 0 ;
3333
 
  char *kwnames[] = {
3334
 
    "self","src_layer","new_name","options", NULL 
3335
 
  };
3336
 
  VALUE vresult = Qnil;
3337
 
  
3338
 
  if ((argc < 2) || (argc > 3)) {
3339
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
3340
 
  }
3341
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRDataSourceShadow, 0 |  0 );
3342
 
  if (!SWIG_IsOK(res1)) {
3343
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CopyLayer" "', argument " "1"" of type '" "OGRDataSourceShadow *""'"); 
3344
 
  }
3345
 
  arg1 = reinterpret_cast< OGRDataSourceShadow * >(argp1);
3346
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
3347
 
  if (!SWIG_IsOK(res2)) {
3348
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CopyLayer" "', argument " "2"" of type '" "OGRLayerShadow *""'"); 
3349
 
  }
3350
 
  arg2 = reinterpret_cast< OGRLayerShadow * >(argp2);
3351
 
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
3352
 
  if (!SWIG_IsOK(res3)) {
3353
 
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CopyLayer" "', argument " "3"" of type '" "char const *""'");
3354
 
  }
3355
 
  arg3 = buf3;
3356
 
  if (argc > 2) {
3357
 
    {
3358
 
      /* %typemap(in) char **options */
3359
 
      
3360
 
      /* Check if is a list */
3361
 
      Check_Type(argv[2], T_ARRAY);
3362
 
      
3363
 
      int size = RARRAY(argv[2])->len;
3364
 
      for (int i = 0; i < size; i++) {
3365
 
        VALUE item = rb_ary_entry(argv[2], i);
3366
 
        char *pszItem = StringValuePtr(item);
3367
 
        arg4 = CSLAddString( arg4, pszItem );
3368
 
      }
3369
 
    }
3370
 
  }
3371
 
  {
3372
 
    CPLErrorReset();
3373
 
    result = (OGRLayerShadow *)OGRDataSourceShadow_CopyLayer(arg1,arg2,(char const *)arg3,arg4);
3374
 
    CPLErr eclass = CPLGetLastErrorType();
3375
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3376
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3377
 
      
3378
 
    }
3379
 
  }
3380
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
3381
 
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
3382
 
  {
3383
 
    /* %typemap(freearg) char **options */
3384
 
    
3385
 
    CSLDestroy( arg4 );
3386
 
  }
3387
 
  return vresult;
3388
 
fail:
3389
 
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
3390
 
  {
3391
 
    /* %typemap(freearg) char **options */
3392
 
    
3393
 
    CSLDestroy( arg4 );
3394
 
  }
3395
 
  return Qnil;
3396
 
}
3397
 
 
3398
 
 
3399
 
SWIGINTERN VALUE
3400
 
_wrap_DataSource_test_capability(int argc, VALUE *argv, VALUE self) {
3401
 
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
3402
 
  char *arg2 = (char *) 0 ;
3403
 
  bool result;
3404
 
  void *argp1 = 0 ;
3405
 
  int res1 = 0 ;
3406
 
  int res2 ;
3407
 
  char *buf2 = 0 ;
3408
 
  int alloc2 = 0 ;
3409
 
  VALUE vresult = Qnil;
3410
 
  
3411
 
  if ((argc < 1) || (argc > 1)) {
3412
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3413
 
  }
3414
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRDataSourceShadow, 0 |  0 );
3415
 
  if (!SWIG_IsOK(res1)) {
3416
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestCapability" "', argument " "1"" of type '" "OGRDataSourceShadow *""'"); 
3417
 
  }
3418
 
  arg1 = reinterpret_cast< OGRDataSourceShadow * >(argp1);
3419
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
3420
 
  if (!SWIG_IsOK(res2)) {
3421
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TestCapability" "', argument " "2"" of type '" "char const *""'");
3422
 
  }
3423
 
  arg2 = buf2;
3424
 
  {
3425
 
    CPLErrorReset();
3426
 
    result = (bool)OGRDataSourceShadow_TestCapability(arg1,(char const *)arg2);
3427
 
    CPLErr eclass = CPLGetLastErrorType();
3428
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3429
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3430
 
      
3431
 
    }
3432
 
  }
3433
 
  vresult = SWIG_From_bool(static_cast< bool >(result));
3434
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3435
 
  return vresult;
3436
 
fail:
3437
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3438
 
  return Qnil;
3439
 
}
3440
 
 
3441
 
 
3442
 
SWIGINTERN VALUE
3443
 
_wrap_DataSource_execute_sql(int argc, VALUE *argv, VALUE self) {
3444
 
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
3445
 
  char *arg2 = (char *) 0 ;
3446
 
  OGRGeometryShadow *arg3 = (OGRGeometryShadow *) NULL ;
3447
 
  char *arg4 = (char *) "" ;
3448
 
  OGRLayerShadow *result = 0 ;
3449
 
  void *argp1 = 0 ;
3450
 
  int res1 = 0 ;
3451
 
  int res2 ;
3452
 
  char *buf2 = 0 ;
3453
 
  int alloc2 = 0 ;
3454
 
  void *argp3 = 0 ;
3455
 
  int res3 = 0 ;
3456
 
  int res4 ;
3457
 
  char *buf4 = 0 ;
3458
 
  int alloc4 = 0 ;
3459
 
  char *kwnames[] = {
3460
 
    "self","statement","geom","dialect", NULL 
3461
 
  };
3462
 
  VALUE vresult = Qnil;
3463
 
  
3464
 
  if ((argc < 1) || (argc > 3)) {
3465
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3466
 
  }
3467
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRDataSourceShadow, 0 |  0 );
3468
 
  if (!SWIG_IsOK(res1)) {
3469
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExecuteSQL" "', argument " "1"" of type '" "OGRDataSourceShadow *""'"); 
3470
 
  }
3471
 
  arg1 = reinterpret_cast< OGRDataSourceShadow * >(argp1);
3472
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
3473
 
  if (!SWIG_IsOK(res2)) {
3474
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExecuteSQL" "', argument " "2"" of type '" "char const *""'");
3475
 
  }
3476
 
  arg2 = buf2;
3477
 
  if (argc > 1) {
3478
 
    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
3479
 
    if (!SWIG_IsOK(res3)) {
3480
 
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ExecuteSQL" "', argument " "3"" of type '" "OGRGeometryShadow *""'"); 
3481
 
    }
3482
 
    arg3 = reinterpret_cast< OGRGeometryShadow * >(argp3);
3483
 
  }
3484
 
  if (argc > 2) {
3485
 
    res4 = SWIG_AsCharPtrAndSize(argv[2], &buf4, NULL, &alloc4);
3486
 
    if (!SWIG_IsOK(res4)) {
3487
 
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ExecuteSQL" "', argument " "4"" of type '" "char const *""'");
3488
 
    }
3489
 
    arg4 = buf4;
3490
 
  }
3491
 
  {
3492
 
    CPLErrorReset();
3493
 
    result = (OGRLayerShadow *)OGRDataSourceShadow_ExecuteSQL(arg1,(char const *)arg2,arg3,(char const *)arg4);
3494
 
    CPLErr eclass = CPLGetLastErrorType();
3495
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3496
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3497
 
      
3498
 
    }
3499
 
  }
3500
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRLayerShadow, SWIG_POINTER_OWN |  0 );
3501
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3502
 
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
3503
 
  return vresult;
3504
 
fail:
3505
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3506
 
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
3507
 
  return Qnil;
3508
 
}
3509
 
 
3510
 
 
3511
 
SWIGINTERN VALUE
3512
 
_wrap_DataSource_release_result_set(int argc, VALUE *argv, VALUE self) {
3513
 
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
3514
 
  OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
3515
 
  void *argp1 = 0 ;
3516
 
  int res1 = 0 ;
3517
 
  int res2 = 0 ;
3518
 
  
3519
 
  if ((argc < 1) || (argc > 1)) {
3520
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3521
 
  }
3522
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRDataSourceShadow, 0 |  0 );
3523
 
  if (!SWIG_IsOK(res1)) {
3524
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReleaseResultSet" "', argument " "1"" of type '" "OGRDataSourceShadow *""'"); 
3525
 
  }
3526
 
  arg1 = reinterpret_cast< OGRDataSourceShadow * >(argp1);
3527
 
  res2 = SWIG_ConvertPtr(argv[0], SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_OGRLayerShadow, SWIG_POINTER_DISOWN |  0 );
3528
 
  if (!SWIG_IsOK(res2)) {
3529
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReleaseResultSet" "', argument " "2"" of type '" "OGRLayerShadow *""'");
3530
 
  }
3531
 
  {
3532
 
    CPLErrorReset();
3533
 
    OGRDataSourceShadow_ReleaseResultSet(arg1,arg2);
3534
 
    CPLErr eclass = CPLGetLastErrorType();
3535
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3536
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3537
 
      
3538
 
    }
3539
 
  }
3540
 
  return Qnil;
3541
 
fail:
3542
 
  return Qnil;
3543
 
}
3544
 
 
3545
 
 
3546
 
SWIGINTERN VALUE
3547
 
_wrap_DataSource_get_layer(int argc, VALUE *argv, VALUE self) {
3548
 
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
3549
 
  VALUE arg2 = (VALUE) 0 ;
3550
 
  OGRLayerShadow *result = 0 ;
3551
 
  void *argp1 = 0 ;
3552
 
  int res1 = 0 ;
3553
 
  VALUE vresult = Qnil;
3554
 
  
3555
 
  if ((argc < 1) || (argc > 1)) {
3556
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3557
 
  }
3558
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRDataSourceShadow, 0 |  0 );
3559
 
  if (!SWIG_IsOK(res1)) {
3560
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetLayer" "', argument " "1"" of type '" "OGRDataSourceShadow *""'"); 
3561
 
  }
3562
 
  arg1 = reinterpret_cast< OGRDataSourceShadow * >(argp1);
3563
 
  arg2 = argv[0];
3564
 
  {
3565
 
    CPLErrorReset();
3566
 
    result = (OGRLayerShadow *)OGRDataSourceShadow_GetLayer(arg1,arg2);
3567
 
    CPLErr eclass = CPLGetLastErrorType();
3568
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3569
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3570
 
      
3571
 
    }
3572
 
  }
3573
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
3574
 
  return vresult;
3575
 
fail:
3576
 
  return Qnil;
3577
 
}
3578
 
 
3579
 
 
3580
 
swig_class cLayer;
3581
 
 
3582
 
SWIGINTERN VALUE
3583
 
_wrap_Layer_get_ref_count(int argc, VALUE *argv, VALUE self) {
3584
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3585
 
  int result;
3586
 
  void *argp1 = 0 ;
3587
 
  int res1 = 0 ;
3588
 
  VALUE vresult = Qnil;
3589
 
  
3590
 
  if ((argc < 0) || (argc > 0)) {
3591
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3592
 
  }
3593
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
3594
 
  if (!SWIG_IsOK(res1)) {
3595
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetRefCount" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
3596
 
  }
3597
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
3598
 
  {
3599
 
    CPLErrorReset();
3600
 
    result = (int)OGRLayerShadow_GetRefCount(arg1);
3601
 
    CPLErr eclass = CPLGetLastErrorType();
3602
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3603
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3604
 
      
3605
 
    }
3606
 
  }
3607
 
  vresult = SWIG_From_int(static_cast< int >(result));
3608
 
  return vresult;
3609
 
fail:
3610
 
  return Qnil;
3611
 
}
3612
 
 
3613
 
 
3614
 
SWIGINTERN VALUE
3615
 
_wrap_Layer_set_spatial_filter(int argc, VALUE *argv, VALUE self) {
3616
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3617
 
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
3618
 
  void *argp1 = 0 ;
3619
 
  int res1 = 0 ;
3620
 
  void *argp2 = 0 ;
3621
 
  int res2 = 0 ;
3622
 
  
3623
 
  if ((argc < 1) || (argc > 1)) {
3624
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3625
 
  }
3626
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
3627
 
  if (!SWIG_IsOK(res1)) {
3628
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetSpatialFilter" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
3629
 
  }
3630
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
3631
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
3632
 
  if (!SWIG_IsOK(res2)) {
3633
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetSpatialFilter" "', argument " "2"" of type '" "OGRGeometryShadow *""'"); 
3634
 
  }
3635
 
  arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
3636
 
  {
3637
 
    CPLErrorReset();
3638
 
    OGRLayerShadow_SetSpatialFilter(arg1,arg2);
3639
 
    CPLErr eclass = CPLGetLastErrorType();
3640
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3641
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3642
 
      
3643
 
    }
3644
 
  }
3645
 
  return Qnil;
3646
 
fail:
3647
 
  return Qnil;
3648
 
}
3649
 
 
3650
 
 
3651
 
SWIGINTERN VALUE
3652
 
_wrap_Layer_set_spatial_filter_rect(int argc, VALUE *argv, VALUE self) {
3653
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3654
 
  double arg2 ;
3655
 
  double arg3 ;
3656
 
  double arg4 ;
3657
 
  double arg5 ;
3658
 
  void *argp1 = 0 ;
3659
 
  int res1 = 0 ;
3660
 
  double val2 ;
3661
 
  int ecode2 = 0 ;
3662
 
  double val3 ;
3663
 
  int ecode3 = 0 ;
3664
 
  double val4 ;
3665
 
  int ecode4 = 0 ;
3666
 
  double val5 ;
3667
 
  int ecode5 = 0 ;
3668
 
  
3669
 
  if ((argc < 4) || (argc > 4)) {
3670
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
3671
 
  }
3672
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
3673
 
  if (!SWIG_IsOK(res1)) {
3674
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetSpatialFilterRect" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
3675
 
  }
3676
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
3677
 
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
3678
 
  if (!SWIG_IsOK(ecode2)) {
3679
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SetSpatialFilterRect" "', argument " "2"" of type '" "double""'");
3680
 
  } 
3681
 
  arg2 = static_cast< double >(val2);
3682
 
  ecode3 = SWIG_AsVal_double(argv[1], &val3);
3683
 
  if (!SWIG_IsOK(ecode3)) {
3684
 
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SetSpatialFilterRect" "', argument " "3"" of type '" "double""'");
3685
 
  } 
3686
 
  arg3 = static_cast< double >(val3);
3687
 
  ecode4 = SWIG_AsVal_double(argv[2], &val4);
3688
 
  if (!SWIG_IsOK(ecode4)) {
3689
 
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SetSpatialFilterRect" "', argument " "4"" of type '" "double""'");
3690
 
  } 
3691
 
  arg4 = static_cast< double >(val4);
3692
 
  ecode5 = SWIG_AsVal_double(argv[3], &val5);
3693
 
  if (!SWIG_IsOK(ecode5)) {
3694
 
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SetSpatialFilterRect" "', argument " "5"" of type '" "double""'");
3695
 
  } 
3696
 
  arg5 = static_cast< double >(val5);
3697
 
  {
3698
 
    CPLErrorReset();
3699
 
    OGRLayerShadow_SetSpatialFilterRect(arg1,arg2,arg3,arg4,arg5);
3700
 
    CPLErr eclass = CPLGetLastErrorType();
3701
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3702
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3703
 
      
3704
 
    }
3705
 
  }
3706
 
  return Qnil;
3707
 
fail:
3708
 
  return Qnil;
3709
 
}
3710
 
 
3711
 
 
3712
 
SWIGINTERN VALUE
3713
 
_wrap_Layer_get_spatial_filter(int argc, VALUE *argv, VALUE self) {
3714
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3715
 
  OGRGeometryShadow *result = 0 ;
3716
 
  void *argp1 = 0 ;
3717
 
  int res1 = 0 ;
3718
 
  VALUE vresult = Qnil;
3719
 
  
3720
 
  if ((argc < 0) || (argc > 0)) {
3721
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3722
 
  }
3723
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
3724
 
  if (!SWIG_IsOK(res1)) {
3725
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetSpatialFilter" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
3726
 
  }
3727
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
3728
 
  {
3729
 
    CPLErrorReset();
3730
 
    result = (OGRGeometryShadow *)OGRLayerShadow_GetSpatialFilter(arg1);
3731
 
    CPLErr eclass = CPLGetLastErrorType();
3732
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3733
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3734
 
      
3735
 
    }
3736
 
  }
3737
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
3738
 
  return vresult;
3739
 
fail:
3740
 
  return Qnil;
3741
 
}
3742
 
 
3743
 
 
3744
 
SWIGINTERN VALUE
3745
 
_wrap_Layer_set_attribute_filter(int argc, VALUE *argv, VALUE self) {
3746
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3747
 
  char *arg2 = (char *) 0 ;
3748
 
  OGRErr result;
3749
 
  void *argp1 = 0 ;
3750
 
  int res1 = 0 ;
3751
 
  int res2 ;
3752
 
  char *buf2 = 0 ;
3753
 
  int alloc2 = 0 ;
3754
 
  VALUE vresult = Qnil;
3755
 
  
3756
 
  if ((argc < 1) || (argc > 1)) {
3757
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3758
 
  }
3759
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
3760
 
  if (!SWIG_IsOK(res1)) {
3761
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetAttributeFilter" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
3762
 
  }
3763
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
3764
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
3765
 
  if (!SWIG_IsOK(res2)) {
3766
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetAttributeFilter" "', argument " "2"" of type '" "char *""'");
3767
 
  }
3768
 
  arg2 = buf2;
3769
 
  {
3770
 
    CPLErrorReset();
3771
 
    result = (OGRErr)OGRLayerShadow_SetAttributeFilter(arg1,arg2);
3772
 
    CPLErr eclass = CPLGetLastErrorType();
3773
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3774
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3775
 
      
3776
 
    }
3777
 
  }
3778
 
  {
3779
 
    /* %typemap(out) OGRErr */
3780
 
    if (result != 0) {
3781
 
      rb_raise(rb_eRuntimeError, OGRErrMessages(result));
3782
 
    }
3783
 
  }
3784
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3785
 
  {
3786
 
    /* %typemap(ret) OGRErr */
3787
 
    if (vresult == Qnil) {
3788
 
      vresult = INT2NUM(0);
3789
 
    }
3790
 
  }    return vresult;
3791
 
fail:
3792
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
3793
 
  return Qnil;
3794
 
}
3795
 
 
3796
 
 
3797
 
SWIGINTERN VALUE
3798
 
_wrap_Layer_reset_reading(int argc, VALUE *argv, VALUE self) {
3799
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3800
 
  void *argp1 = 0 ;
3801
 
  int res1 = 0 ;
3802
 
  
3803
 
  if ((argc < 0) || (argc > 0)) {
3804
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3805
 
  }
3806
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
3807
 
  if (!SWIG_IsOK(res1)) {
3808
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResetReading" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
3809
 
  }
3810
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
3811
 
  {
3812
 
    CPLErrorReset();
3813
 
    OGRLayerShadow_ResetReading(arg1);
3814
 
    CPLErr eclass = CPLGetLastErrorType();
3815
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3816
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3817
 
      
3818
 
    }
3819
 
  }
3820
 
  return Qnil;
3821
 
fail:
3822
 
  return Qnil;
3823
 
}
3824
 
 
3825
 
 
3826
 
SWIGINTERN VALUE
3827
 
_wrap_Layer_get_name(int argc, VALUE *argv, VALUE self) {
3828
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3829
 
  char *result = 0 ;
3830
 
  void *argp1 = 0 ;
3831
 
  int res1 = 0 ;
3832
 
  VALUE vresult = Qnil;
3833
 
  
3834
 
  if ((argc < 0) || (argc > 0)) {
3835
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3836
 
  }
3837
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
3838
 
  if (!SWIG_IsOK(res1)) {
3839
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetName" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
3840
 
  }
3841
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
3842
 
  {
3843
 
    CPLErrorReset();
3844
 
    result = (char *)OGRLayerShadow_GetName(arg1);
3845
 
    CPLErr eclass = CPLGetLastErrorType();
3846
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3847
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3848
 
      
3849
 
    }
3850
 
  }
3851
 
  vresult = SWIG_FromCharPtr(result);
3852
 
  return vresult;
3853
 
fail:
3854
 
  return Qnil;
3855
 
}
3856
 
 
3857
 
 
3858
 
SWIGINTERN VALUE
3859
 
_wrap_Layer_get_feature(int argc, VALUE *argv, VALUE self) {
3860
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3861
 
  long arg2 ;
3862
 
  OGRFeatureShadow *result = 0 ;
3863
 
  void *argp1 = 0 ;
3864
 
  int res1 = 0 ;
3865
 
  long val2 ;
3866
 
  int ecode2 = 0 ;
3867
 
  VALUE vresult = Qnil;
3868
 
  
3869
 
  if ((argc < 1) || (argc > 1)) {
3870
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3871
 
  }
3872
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
3873
 
  if (!SWIG_IsOK(res1)) {
3874
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetFeature" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
3875
 
  }
3876
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
3877
 
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
3878
 
  if (!SWIG_IsOK(ecode2)) {
3879
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetFeature" "', argument " "2"" of type '" "long""'");
3880
 
  } 
3881
 
  arg2 = static_cast< long >(val2);
3882
 
  {
3883
 
    CPLErrorReset();
3884
 
    result = (OGRFeatureShadow *)OGRLayerShadow_GetFeature(arg1,arg2);
3885
 
    CPLErr eclass = CPLGetLastErrorType();
3886
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3887
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3888
 
      
3889
 
    }
3890
 
  }
3891
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFeatureShadow, SWIG_POINTER_OWN |  0 );
3892
 
  return vresult;
3893
 
fail:
3894
 
  return Qnil;
3895
 
}
3896
 
 
3897
 
 
3898
 
SWIGINTERN VALUE
3899
 
_wrap_Layer_get_next_feature(int argc, VALUE *argv, VALUE self) {
3900
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3901
 
  OGRFeatureShadow *result = 0 ;
3902
 
  void *argp1 = 0 ;
3903
 
  int res1 = 0 ;
3904
 
  VALUE vresult = Qnil;
3905
 
  
3906
 
  if ((argc < 0) || (argc > 0)) {
3907
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3908
 
  }
3909
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
3910
 
  if (!SWIG_IsOK(res1)) {
3911
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetNextFeature" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
3912
 
  }
3913
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
3914
 
  {
3915
 
    CPLErrorReset();
3916
 
    result = (OGRFeatureShadow *)OGRLayerShadow_GetNextFeature(arg1);
3917
 
    CPLErr eclass = CPLGetLastErrorType();
3918
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3919
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3920
 
      
3921
 
    }
3922
 
  }
3923
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFeatureShadow, SWIG_POINTER_OWN |  0 );
3924
 
  return vresult;
3925
 
fail:
3926
 
  return Qnil;
3927
 
}
3928
 
 
3929
 
 
3930
 
SWIGINTERN VALUE
3931
 
_wrap_Layer_set_next_by_index(int argc, VALUE *argv, VALUE self) {
3932
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3933
 
  long arg2 ;
3934
 
  OGRErr result;
3935
 
  void *argp1 = 0 ;
3936
 
  int res1 = 0 ;
3937
 
  long val2 ;
3938
 
  int ecode2 = 0 ;
3939
 
  VALUE vresult = Qnil;
3940
 
  
3941
 
  if ((argc < 1) || (argc > 1)) {
3942
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3943
 
  }
3944
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
3945
 
  if (!SWIG_IsOK(res1)) {
3946
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetNextByIndex" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
3947
 
  }
3948
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
3949
 
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
3950
 
  if (!SWIG_IsOK(ecode2)) {
3951
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SetNextByIndex" "', argument " "2"" of type '" "long""'");
3952
 
  } 
3953
 
  arg2 = static_cast< long >(val2);
3954
 
  {
3955
 
    CPLErrorReset();
3956
 
    result = (OGRErr)OGRLayerShadow_SetNextByIndex(arg1,arg2);
3957
 
    CPLErr eclass = CPLGetLastErrorType();
3958
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
3959
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
3960
 
      
3961
 
    }
3962
 
  }
3963
 
  {
3964
 
    /* %typemap(out) OGRErr */
3965
 
    if (result != 0) {
3966
 
      rb_raise(rb_eRuntimeError, OGRErrMessages(result));
3967
 
    }
3968
 
  }
3969
 
  {
3970
 
    /* %typemap(ret) OGRErr */
3971
 
    if (vresult == Qnil) {
3972
 
      vresult = INT2NUM(0);
3973
 
    }
3974
 
  }    return vresult;
3975
 
fail:
3976
 
  return Qnil;
3977
 
}
3978
 
 
3979
 
 
3980
 
SWIGINTERN VALUE
3981
 
_wrap_Layer_set_feature(int argc, VALUE *argv, VALUE self) {
3982
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3983
 
  OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
3984
 
  OGRErr result;
3985
 
  void *argp1 = 0 ;
3986
 
  int res1 = 0 ;
3987
 
  void *argp2 = 0 ;
3988
 
  int res2 = 0 ;
3989
 
  VALUE vresult = Qnil;
3990
 
  
3991
 
  if ((argc < 1) || (argc > 1)) {
3992
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3993
 
  }
3994
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
3995
 
  if (!SWIG_IsOK(res1)) {
3996
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetFeature" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
3997
 
  }
3998
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
3999
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
4000
 
  if (!SWIG_IsOK(res2)) {
4001
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetFeature" "', argument " "2"" of type '" "OGRFeatureShadow *""'"); 
4002
 
  }
4003
 
  arg2 = reinterpret_cast< OGRFeatureShadow * >(argp2);
4004
 
  {
4005
 
    CPLErrorReset();
4006
 
    result = (OGRErr)OGRLayerShadow_SetFeature(arg1,arg2);
4007
 
    CPLErr eclass = CPLGetLastErrorType();
4008
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4009
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4010
 
      
4011
 
    }
4012
 
  }
4013
 
  {
4014
 
    /* %typemap(out) OGRErr */
4015
 
    if (result != 0) {
4016
 
      rb_raise(rb_eRuntimeError, OGRErrMessages(result));
4017
 
    }
4018
 
  }
4019
 
  {
4020
 
    /* %typemap(ret) OGRErr */
4021
 
    if (vresult == Qnil) {
4022
 
      vresult = INT2NUM(0);
4023
 
    }
4024
 
  }    return vresult;
4025
 
fail:
4026
 
  return Qnil;
4027
 
}
4028
 
 
4029
 
 
4030
 
SWIGINTERN VALUE
4031
 
_wrap_Layer_create_feature(int argc, VALUE *argv, VALUE self) {
4032
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
4033
 
  OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
4034
 
  OGRErr result;
4035
 
  void *argp1 = 0 ;
4036
 
  int res1 = 0 ;
4037
 
  void *argp2 = 0 ;
4038
 
  int res2 = 0 ;
4039
 
  VALUE vresult = Qnil;
4040
 
  
4041
 
  if ((argc < 1) || (argc > 1)) {
4042
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4043
 
  }
4044
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
4045
 
  if (!SWIG_IsOK(res1)) {
4046
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateFeature" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
4047
 
  }
4048
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
4049
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
4050
 
  if (!SWIG_IsOK(res2)) {
4051
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CreateFeature" "', argument " "2"" of type '" "OGRFeatureShadow *""'"); 
4052
 
  }
4053
 
  arg2 = reinterpret_cast< OGRFeatureShadow * >(argp2);
4054
 
  {
4055
 
    CPLErrorReset();
4056
 
    result = (OGRErr)OGRLayerShadow_CreateFeature(arg1,arg2);
4057
 
    CPLErr eclass = CPLGetLastErrorType();
4058
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4059
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4060
 
      
4061
 
    }
4062
 
  }
4063
 
  {
4064
 
    /* %typemap(out) OGRErr */
4065
 
    if (result != 0) {
4066
 
      rb_raise(rb_eRuntimeError, OGRErrMessages(result));
4067
 
    }
4068
 
  }
4069
 
  {
4070
 
    /* %typemap(ret) OGRErr */
4071
 
    if (vresult == Qnil) {
4072
 
      vresult = INT2NUM(0);
4073
 
    }
4074
 
  }    return vresult;
4075
 
fail:
4076
 
  return Qnil;
4077
 
}
4078
 
 
4079
 
 
4080
 
SWIGINTERN VALUE
4081
 
_wrap_Layer_delete_feature(int argc, VALUE *argv, VALUE self) {
4082
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
4083
 
  long arg2 ;
4084
 
  OGRErr result;
4085
 
  void *argp1 = 0 ;
4086
 
  int res1 = 0 ;
4087
 
  long val2 ;
4088
 
  int ecode2 = 0 ;
4089
 
  VALUE vresult = Qnil;
4090
 
  
4091
 
  if ((argc < 1) || (argc > 1)) {
4092
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4093
 
  }
4094
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
4095
 
  if (!SWIG_IsOK(res1)) {
4096
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeleteFeature" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
4097
 
  }
4098
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
4099
 
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
4100
 
  if (!SWIG_IsOK(ecode2)) {
4101
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DeleteFeature" "', argument " "2"" of type '" "long""'");
4102
 
  } 
4103
 
  arg2 = static_cast< long >(val2);
4104
 
  {
4105
 
    CPLErrorReset();
4106
 
    result = (OGRErr)OGRLayerShadow_DeleteFeature(arg1,arg2);
4107
 
    CPLErr eclass = CPLGetLastErrorType();
4108
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4109
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4110
 
      
4111
 
    }
4112
 
  }
4113
 
  {
4114
 
    /* %typemap(out) OGRErr */
4115
 
    if (result != 0) {
4116
 
      rb_raise(rb_eRuntimeError, OGRErrMessages(result));
4117
 
    }
4118
 
  }
4119
 
  {
4120
 
    /* %typemap(ret) OGRErr */
4121
 
    if (vresult == Qnil) {
4122
 
      vresult = INT2NUM(0);
4123
 
    }
4124
 
  }    return vresult;
4125
 
fail:
4126
 
  return Qnil;
4127
 
}
4128
 
 
4129
 
 
4130
 
SWIGINTERN VALUE
4131
 
_wrap_Layer_sync_to_disk(int argc, VALUE *argv, VALUE self) {
4132
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
4133
 
  OGRErr result;
4134
 
  void *argp1 = 0 ;
4135
 
  int res1 = 0 ;
4136
 
  VALUE vresult = Qnil;
4137
 
  
4138
 
  if ((argc < 0) || (argc > 0)) {
4139
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4140
 
  }
4141
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
4142
 
  if (!SWIG_IsOK(res1)) {
4143
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SyncToDisk" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
4144
 
  }
4145
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
4146
 
  {
4147
 
    CPLErrorReset();
4148
 
    result = (OGRErr)OGRLayerShadow_SyncToDisk(arg1);
4149
 
    CPLErr eclass = CPLGetLastErrorType();
4150
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4151
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4152
 
      
4153
 
    }
4154
 
  }
4155
 
  {
4156
 
    /* %typemap(out) OGRErr */
4157
 
    if (result != 0) {
4158
 
      rb_raise(rb_eRuntimeError, OGRErrMessages(result));
4159
 
    }
4160
 
  }
4161
 
  {
4162
 
    /* %typemap(ret) OGRErr */
4163
 
    if (vresult == Qnil) {
4164
 
      vresult = INT2NUM(0);
4165
 
    }
4166
 
  }    return vresult;
4167
 
fail:
4168
 
  return Qnil;
4169
 
}
4170
 
 
4171
 
 
4172
 
SWIGINTERN VALUE
4173
 
_wrap_Layer_get_layer_defn(int argc, VALUE *argv, VALUE self) {
4174
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
4175
 
  OGRFeatureDefnShadow *result = 0 ;
4176
 
  void *argp1 = 0 ;
4177
 
  int res1 = 0 ;
4178
 
  VALUE vresult = Qnil;
4179
 
  
4180
 
  if ((argc < 0) || (argc > 0)) {
4181
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4182
 
  }
4183
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
4184
 
  if (!SWIG_IsOK(res1)) {
4185
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetLayerDefn" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
4186
 
  }
4187
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
4188
 
  {
4189
 
    CPLErrorReset();
4190
 
    result = (OGRFeatureDefnShadow *)OGRLayerShadow_GetLayerDefn(arg1);
4191
 
    CPLErr eclass = CPLGetLastErrorType();
4192
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4193
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4194
 
      
4195
 
    }
4196
 
  }
4197
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFeatureDefnShadow, 0 |  0 );
4198
 
  return vresult;
4199
 
fail:
4200
 
  return Qnil;
4201
 
}
4202
 
 
4203
 
 
4204
 
SWIGINTERN VALUE
4205
 
_wrap_Layer_get_feature_count(int argc, VALUE *argv, VALUE self) {
4206
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
4207
 
  int arg2 = (int) 1 ;
4208
 
  int result;
4209
 
  void *argp1 = 0 ;
4210
 
  int res1 = 0 ;
4211
 
  int val2 ;
4212
 
  int ecode2 = 0 ;
4213
 
  char *kwnames[] = {
4214
 
    "self","force", NULL 
4215
 
  };
4216
 
  VALUE vresult = Qnil;
4217
 
  
4218
 
  if ((argc < 0) || (argc > 1)) {
4219
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4220
 
  }
4221
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
4222
 
  if (!SWIG_IsOK(res1)) {
4223
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetFeatureCount" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
4224
 
  }
4225
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
4226
 
  if (argc > 0) {
4227
 
    ecode2 = SWIG_AsVal_int(argv[0], &val2);
4228
 
    if (!SWIG_IsOK(ecode2)) {
4229
 
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetFeatureCount" "', argument " "2"" of type '" "int""'");
4230
 
    } 
4231
 
    arg2 = static_cast< int >(val2);
4232
 
  }
4233
 
  {
4234
 
    CPLErrorReset();
4235
 
    result = (int)OGRLayerShadow_GetFeatureCount(arg1,arg2);
4236
 
    CPLErr eclass = CPLGetLastErrorType();
4237
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4238
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4239
 
      
4240
 
    }
4241
 
  }
4242
 
  vresult = SWIG_From_int(static_cast< int >(result));
4243
 
  return vresult;
4244
 
fail:
4245
 
  return Qnil;
4246
 
}
4247
 
 
4248
 
 
4249
 
SWIGINTERN VALUE
4250
 
_wrap_Layer_get_extent(int argc, VALUE *argv, VALUE self) {
4251
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
4252
 
  double *arg2 ;
4253
 
  int arg3 = (int) 1 ;
4254
 
  OGRErr result;
4255
 
  void *argp1 = 0 ;
4256
 
  int res1 = 0 ;
4257
 
  double argout2[4] ;
4258
 
  int val3 ;
4259
 
  int ecode3 = 0 ;
4260
 
  char *kwnames[] = {
4261
 
    "self","force", NULL 
4262
 
  };
4263
 
  VALUE vresult = Qnil;
4264
 
  
4265
 
  {
4266
 
    /* %typemap(in,numinputs=0) (double argout2[ANY]) */
4267
 
    arg2 = argout2;
4268
 
  }
4269
 
  if ((argc < 0) || (argc > 1)) {
4270
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4271
 
  }
4272
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
4273
 
  if (!SWIG_IsOK(res1)) {
4274
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetExtent" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
4275
 
  }
4276
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
4277
 
  if (argc > 0) {
4278
 
    ecode3 = SWIG_AsVal_int(argv[0], &val3);
4279
 
    if (!SWIG_IsOK(ecode3)) {
4280
 
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetExtent" "', argument " "3"" of type '" "int""'");
4281
 
    } 
4282
 
    arg3 = static_cast< int >(val3);
4283
 
  }
4284
 
  {
4285
 
    CPLErrorReset();
4286
 
    result = (OGRErr)OGRLayerShadow_GetExtent(arg1,arg2,arg3);
4287
 
    CPLErr eclass = CPLGetLastErrorType();
4288
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4289
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4290
 
      
4291
 
    }
4292
 
  }
4293
 
  {
4294
 
    /* %typemap(out) OGRErr */
4295
 
    if (result != 0) {
4296
 
      rb_raise(rb_eRuntimeError, OGRErrMessages(result));
4297
 
    }
4298
 
  }
4299
 
  {
4300
 
    /* %typemap(argout) (double argout[ANY]) */
4301
 
    VALUE outArr = rb_ary_new();
4302
 
    
4303
 
    for(int i=0; i<4; i++)
4304
 
    {
4305
 
      VALUE value = rb_float_new((arg2)[i]);
4306
 
      rb_ary_push(outArr, value);
4307
 
    }
4308
 
    
4309
 
    /* Add the output to the result */
4310
 
    vresult = SWIG_Ruby_AppendOutput(vresult, outArr);  
4311
 
  }
4312
 
  {
4313
 
    /* %typemap(ret) OGRErr */
4314
 
    if (vresult == Qnil) {
4315
 
      vresult = INT2NUM(0);
4316
 
    }
4317
 
  }    return vresult;
4318
 
fail:
4319
 
  return Qnil;
4320
 
}
4321
 
 
4322
 
 
4323
 
SWIGINTERN VALUE
4324
 
_wrap_Layer_test_capability(int argc, VALUE *argv, VALUE self) {
4325
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
4326
 
  char *arg2 = (char *) 0 ;
4327
 
  bool result;
4328
 
  void *argp1 = 0 ;
4329
 
  int res1 = 0 ;
4330
 
  int res2 ;
4331
 
  char *buf2 = 0 ;
4332
 
  int alloc2 = 0 ;
4333
 
  VALUE vresult = Qnil;
4334
 
  
4335
 
  if ((argc < 1) || (argc > 1)) {
4336
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4337
 
  }
4338
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
4339
 
  if (!SWIG_IsOK(res1)) {
4340
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TestCapability" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
4341
 
  }
4342
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
4343
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
4344
 
  if (!SWIG_IsOK(res2)) {
4345
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TestCapability" "', argument " "2"" of type '" "char const *""'");
4346
 
  }
4347
 
  arg2 = buf2;
4348
 
  {
4349
 
    CPLErrorReset();
4350
 
    result = (bool)OGRLayerShadow_TestCapability(arg1,(char const *)arg2);
4351
 
    CPLErr eclass = CPLGetLastErrorType();
4352
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4353
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4354
 
      
4355
 
    }
4356
 
  }
4357
 
  vresult = SWIG_From_bool(static_cast< bool >(result));
4358
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4359
 
  return vresult;
4360
 
fail:
4361
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
4362
 
  return Qnil;
4363
 
}
4364
 
 
4365
 
 
4366
 
SWIGINTERN VALUE
4367
 
_wrap_Layer_create_field(int argc, VALUE *argv, VALUE self) {
4368
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
4369
 
  OGRFieldDefnShadow *arg2 = (OGRFieldDefnShadow *) 0 ;
4370
 
  int arg3 = (int) 1 ;
4371
 
  OGRErr result;
4372
 
  void *argp1 = 0 ;
4373
 
  int res1 = 0 ;
4374
 
  void *argp2 = 0 ;
4375
 
  int res2 = 0 ;
4376
 
  int val3 ;
4377
 
  int ecode3 = 0 ;
4378
 
  char *kwnames[] = {
4379
 
    "self","field_def","approx_ok", NULL 
4380
 
  };
4381
 
  VALUE vresult = Qnil;
4382
 
  
4383
 
  if ((argc < 1) || (argc > 2)) {
4384
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4385
 
  }
4386
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
4387
 
  if (!SWIG_IsOK(res1)) {
4388
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateField" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
4389
 
  }
4390
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
4391
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRFieldDefnShadow, 0 |  0 );
4392
 
  if (!SWIG_IsOK(res2)) {
4393
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CreateField" "', argument " "2"" of type '" "OGRFieldDefnShadow *""'"); 
4394
 
  }
4395
 
  arg2 = reinterpret_cast< OGRFieldDefnShadow * >(argp2);
4396
 
  if (argc > 1) {
4397
 
    ecode3 = SWIG_AsVal_int(argv[1], &val3);
4398
 
    if (!SWIG_IsOK(ecode3)) {
4399
 
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CreateField" "', argument " "3"" of type '" "int""'");
4400
 
    } 
4401
 
    arg3 = static_cast< int >(val3);
4402
 
  }
4403
 
  {
4404
 
    CPLErrorReset();
4405
 
    result = (OGRErr)OGRLayerShadow_CreateField(arg1,arg2,arg3);
4406
 
    CPLErr eclass = CPLGetLastErrorType();
4407
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4408
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4409
 
      
4410
 
    }
4411
 
  }
4412
 
  {
4413
 
    /* %typemap(out) OGRErr */
4414
 
    if (result != 0) {
4415
 
      rb_raise(rb_eRuntimeError, OGRErrMessages(result));
4416
 
    }
4417
 
  }
4418
 
  {
4419
 
    /* %typemap(ret) OGRErr */
4420
 
    if (vresult == Qnil) {
4421
 
      vresult = INT2NUM(0);
4422
 
    }
4423
 
  }    return vresult;
4424
 
fail:
4425
 
  return Qnil;
4426
 
}
4427
 
 
4428
 
 
4429
 
SWIGINTERN VALUE
4430
 
_wrap_Layer_start_transaction(int argc, VALUE *argv, VALUE self) {
4431
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
4432
 
  OGRErr result;
4433
 
  void *argp1 = 0 ;
4434
 
  int res1 = 0 ;
4435
 
  VALUE vresult = Qnil;
4436
 
  
4437
 
  if ((argc < 0) || (argc > 0)) {
4438
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4439
 
  }
4440
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
4441
 
  if (!SWIG_IsOK(res1)) {
4442
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StartTransaction" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
4443
 
  }
4444
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
4445
 
  {
4446
 
    CPLErrorReset();
4447
 
    result = (OGRErr)OGRLayerShadow_StartTransaction(arg1);
4448
 
    CPLErr eclass = CPLGetLastErrorType();
4449
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4450
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4451
 
      
4452
 
    }
4453
 
  }
4454
 
  {
4455
 
    /* %typemap(out) OGRErr */
4456
 
    if (result != 0) {
4457
 
      rb_raise(rb_eRuntimeError, OGRErrMessages(result));
4458
 
    }
4459
 
  }
4460
 
  {
4461
 
    /* %typemap(ret) OGRErr */
4462
 
    if (vresult == Qnil) {
4463
 
      vresult = INT2NUM(0);
4464
 
    }
4465
 
  }    return vresult;
4466
 
fail:
4467
 
  return Qnil;
4468
 
}
4469
 
 
4470
 
 
4471
 
SWIGINTERN VALUE
4472
 
_wrap_Layer_commit_transaction(int argc, VALUE *argv, VALUE self) {
4473
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
4474
 
  OGRErr result;
4475
 
  void *argp1 = 0 ;
4476
 
  int res1 = 0 ;
4477
 
  VALUE vresult = Qnil;
4478
 
  
4479
 
  if ((argc < 0) || (argc > 0)) {
4480
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4481
 
  }
4482
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
4483
 
  if (!SWIG_IsOK(res1)) {
4484
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommitTransaction" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
4485
 
  }
4486
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
4487
 
  {
4488
 
    CPLErrorReset();
4489
 
    result = (OGRErr)OGRLayerShadow_CommitTransaction(arg1);
4490
 
    CPLErr eclass = CPLGetLastErrorType();
4491
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4492
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4493
 
      
4494
 
    }
4495
 
  }
4496
 
  {
4497
 
    /* %typemap(out) OGRErr */
4498
 
    if (result != 0) {
4499
 
      rb_raise(rb_eRuntimeError, OGRErrMessages(result));
4500
 
    }
4501
 
  }
4502
 
  {
4503
 
    /* %typemap(ret) OGRErr */
4504
 
    if (vresult == Qnil) {
4505
 
      vresult = INT2NUM(0);
4506
 
    }
4507
 
  }    return vresult;
4508
 
fail:
4509
 
  return Qnil;
4510
 
}
4511
 
 
4512
 
 
4513
 
SWIGINTERN VALUE
4514
 
_wrap_Layer_rollback_transaction(int argc, VALUE *argv, VALUE self) {
4515
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
4516
 
  OGRErr result;
4517
 
  void *argp1 = 0 ;
4518
 
  int res1 = 0 ;
4519
 
  VALUE vresult = Qnil;
4520
 
  
4521
 
  if ((argc < 0) || (argc > 0)) {
4522
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4523
 
  }
4524
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
4525
 
  if (!SWIG_IsOK(res1)) {
4526
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RollbackTransaction" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
4527
 
  }
4528
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
4529
 
  {
4530
 
    CPLErrorReset();
4531
 
    result = (OGRErr)OGRLayerShadow_RollbackTransaction(arg1);
4532
 
    CPLErr eclass = CPLGetLastErrorType();
4533
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4534
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4535
 
      
4536
 
    }
4537
 
  }
4538
 
  {
4539
 
    /* %typemap(out) OGRErr */
4540
 
    if (result != 0) {
4541
 
      rb_raise(rb_eRuntimeError, OGRErrMessages(result));
4542
 
    }
4543
 
  }
4544
 
  {
4545
 
    /* %typemap(ret) OGRErr */
4546
 
    if (vresult == Qnil) {
4547
 
      vresult = INT2NUM(0);
4548
 
    }
4549
 
  }    return vresult;
4550
 
fail:
4551
 
  return Qnil;
4552
 
}
4553
 
 
4554
 
 
4555
 
SWIGINTERN VALUE
4556
 
_wrap_Layer_get_spatial_ref(int argc, VALUE *argv, VALUE self) {
4557
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
4558
 
  OSRSpatialReferenceShadow *result = 0 ;
4559
 
  void *argp1 = 0 ;
4560
 
  int res1 = 0 ;
4561
 
  VALUE vresult = Qnil;
4562
 
  
4563
 
  if ((argc < 0) || (argc > 0)) {
4564
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4565
 
  }
4566
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
4567
 
  if (!SWIG_IsOK(res1)) {
4568
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetSpatialRef" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
4569
 
  }
4570
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
4571
 
  {
4572
 
    CPLErrorReset();
4573
 
    result = (OSRSpatialReferenceShadow *)OGRLayerShadow_GetSpatialRef(arg1);
4574
 
    CPLErr eclass = CPLGetLastErrorType();
4575
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4576
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4577
 
      
4578
 
    }
4579
 
  }
4580
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OSRSpatialReferenceShadow, 0 |  0 );
4581
 
  return vresult;
4582
 
fail:
4583
 
  return Qnil;
4584
 
}
4585
 
 
4586
 
 
4587
 
SWIGINTERN VALUE
4588
 
_wrap_Layer_get_feature_read(int argc, VALUE *argv, VALUE self) {
4589
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
4590
 
  GIntBig result;
4591
 
  void *argp1 = 0 ;
4592
 
  int res1 = 0 ;
4593
 
  VALUE vresult = Qnil;
4594
 
  
4595
 
  if ((argc < 0) || (argc > 0)) {
4596
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4597
 
  }
4598
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
4599
 
  if (!SWIG_IsOK(res1)) {
4600
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetFeatureRead" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
4601
 
  }
4602
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
4603
 
  {
4604
 
    CPLErrorReset();
4605
 
    result = OGRLayerShadow_GetFeatureRead(arg1);
4606
 
    CPLErr eclass = CPLGetLastErrorType();
4607
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4608
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4609
 
      
4610
 
    }
4611
 
  }
4612
 
  vresult = SWIG_NewPointerObj((new GIntBig(static_cast< const GIntBig& >(result))), SWIGTYPE_p_GIntBig, SWIG_POINTER_OWN |  0 );
4613
 
  return vresult;
4614
 
fail:
4615
 
  return Qnil;
4616
 
}
4617
 
 
4618
 
 
4619
 
SWIGINTERN VALUE
4620
 
_wrap_Layer_each(int argc, VALUE *argv, VALUE self) {
4621
 
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
4622
 
  void *argp1 = 0 ;
4623
 
  int res1 = 0 ;
4624
 
  
4625
 
  if ((argc < 0) || (argc > 0)) {
4626
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4627
 
  }
4628
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRLayerShadow, 0 |  0 );
4629
 
  if (!SWIG_IsOK(res1)) {
4630
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "each" "', argument " "1"" of type '" "OGRLayerShadow *""'"); 
4631
 
  }
4632
 
  arg1 = reinterpret_cast< OGRLayerShadow * >(argp1);
4633
 
  {
4634
 
    CPLErrorReset();
4635
 
    OGRLayerShadow_each(arg1);
4636
 
    CPLErr eclass = CPLGetLastErrorType();
4637
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4638
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4639
 
      
4640
 
    }
4641
 
  }
4642
 
  return Qnil;
4643
 
fail:
4644
 
  return Qnil;
4645
 
}
4646
 
 
4647
 
 
4648
 
swig_class cFeature;
4649
 
 
4650
 
SWIGINTERN void delete_OGRFeatureShadow(OGRFeatureShadow *self){
4651
 
    OGR_F_Destroy(self);
4652
 
  }
4653
 
SWIGINTERN void
4654
 
free_OGRFeatureShadow(OGRFeatureShadow *arg1) {
4655
 
    delete_OGRFeatureShadow(arg1);
4656
 
}
4657
 
 
4658
 
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
4659
 
SWIGINTERN VALUE
4660
 
_wrap_Feature_allocate(VALUE self) {
4661
 
#else
4662
 
  SWIGINTERN VALUE
4663
 
  _wrap_Feature_allocate(int argc, VALUE *argv, VALUE self) {
4664
 
#endif
4665
 
    
4666
 
    
4667
 
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OGRFeatureShadow);
4668
 
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
4669
 
    rb_obj_call_init(vresult, argc, argv);
4670
 
#endif
4671
 
    return vresult;
4672
 
  }
4673
 
  
4674
 
 
4675
 
SWIGINTERN VALUE
4676
 
_wrap_new_Feature(int argc, VALUE *argv, VALUE self) {
4677
 
  OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
4678
 
  OGRFeatureShadow *result = 0 ;
4679
 
  void *argp1 = 0 ;
4680
 
  int res1 = 0 ;
4681
 
  char *kwnames[] = {
4682
 
    "feature_def", NULL 
4683
 
  };
4684
 
  
4685
 
  if ((argc < 0) || (argc > 1)) {
4686
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4687
 
  }
4688
 
  if (argc > 0) {
4689
 
    res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 |  0 );
4690
 
    if (!SWIG_IsOK(res1)) {
4691
 
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OGRFeatureShadow" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'"); 
4692
 
    }
4693
 
    arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
4694
 
  }
4695
 
  {
4696
 
    CPLErrorReset();
4697
 
    result = (OGRFeatureShadow *)new_OGRFeatureShadow(arg1);DATA_PTR(self) = result;
4698
 
    
4699
 
    CPLErr eclass = CPLGetLastErrorType();
4700
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4701
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4702
 
      
4703
 
    }
4704
 
  }
4705
 
  return self;
4706
 
fail:
4707
 
  return Qnil;
4708
 
}
4709
 
 
4710
 
 
4711
 
SWIGINTERN VALUE
4712
 
_wrap_Feature_get_defn_ref(int argc, VALUE *argv, VALUE self) {
4713
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4714
 
  OGRFeatureDefnShadow *result = 0 ;
4715
 
  void *argp1 = 0 ;
4716
 
  int res1 = 0 ;
4717
 
  VALUE vresult = Qnil;
4718
 
  
4719
 
  if ((argc < 0) || (argc > 0)) {
4720
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4721
 
  }
4722
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
4723
 
  if (!SWIG_IsOK(res1)) {
4724
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetDefnRef" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
4725
 
  }
4726
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
4727
 
  {
4728
 
    CPLErrorReset();
4729
 
    result = (OGRFeatureDefnShadow *)OGRFeatureShadow_GetDefnRef(arg1);
4730
 
    CPLErr eclass = CPLGetLastErrorType();
4731
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4732
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4733
 
      
4734
 
    }
4735
 
  }
4736
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFeatureDefnShadow, 0 |  0 );
4737
 
  return vresult;
4738
 
fail:
4739
 
  return Qnil;
4740
 
}
4741
 
 
4742
 
 
4743
 
SWIGINTERN VALUE
4744
 
_wrap_Feature_set_geometry(int argc, VALUE *argv, VALUE self) {
4745
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4746
 
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
4747
 
  OGRErr result;
4748
 
  void *argp1 = 0 ;
4749
 
  int res1 = 0 ;
4750
 
  void *argp2 = 0 ;
4751
 
  int res2 = 0 ;
4752
 
  VALUE vresult = Qnil;
4753
 
  
4754
 
  if ((argc < 1) || (argc > 1)) {
4755
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4756
 
  }
4757
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
4758
 
  if (!SWIG_IsOK(res1)) {
4759
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetGeometry" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
4760
 
  }
4761
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
4762
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
4763
 
  if (!SWIG_IsOK(res2)) {
4764
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetGeometry" "', argument " "2"" of type '" "OGRGeometryShadow *""'"); 
4765
 
  }
4766
 
  arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
4767
 
  {
4768
 
    CPLErrorReset();
4769
 
    result = (OGRErr)OGRFeatureShadow_SetGeometry(arg1,arg2);
4770
 
    CPLErr eclass = CPLGetLastErrorType();
4771
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4772
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4773
 
      
4774
 
    }
4775
 
  }
4776
 
  {
4777
 
    /* %typemap(out) OGRErr */
4778
 
    if (result != 0) {
4779
 
      rb_raise(rb_eRuntimeError, OGRErrMessages(result));
4780
 
    }
4781
 
  }
4782
 
  {
4783
 
    /* %typemap(ret) OGRErr */
4784
 
    if (vresult == Qnil) {
4785
 
      vresult = INT2NUM(0);
4786
 
    }
4787
 
  }    return vresult;
4788
 
fail:
4789
 
  return Qnil;
4790
 
}
4791
 
 
4792
 
 
4793
 
SWIGINTERN VALUE
4794
 
_wrap_Feature_set_geometry_directly(int argc, VALUE *argv, VALUE self) {
4795
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4796
 
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
4797
 
  OGRErr result;
4798
 
  void *argp1 = 0 ;
4799
 
  int res1 = 0 ;
4800
 
  int res2 = 0 ;
4801
 
  VALUE vresult = Qnil;
4802
 
  
4803
 
  if ((argc < 1) || (argc > 1)) {
4804
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4805
 
  }
4806
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
4807
 
  if (!SWIG_IsOK(res1)) {
4808
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetGeometryDirectly" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
4809
 
  }
4810
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
4811
 
  res2 = SWIG_ConvertPtr(argv[0], SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_DISOWN |  0 );
4812
 
  if (!SWIG_IsOK(res2)) {
4813
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetGeometryDirectly" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
4814
 
  }
4815
 
  {
4816
 
    CPLErrorReset();
4817
 
    result = (OGRErr)OGRFeatureShadow_SetGeometryDirectly(arg1,arg2);
4818
 
    CPLErr eclass = CPLGetLastErrorType();
4819
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4820
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4821
 
      
4822
 
    }
4823
 
  }
4824
 
  {
4825
 
    /* %typemap(out) OGRErr */
4826
 
    if (result != 0) {
4827
 
      rb_raise(rb_eRuntimeError, OGRErrMessages(result));
4828
 
    }
4829
 
  }
4830
 
  {
4831
 
    /* %typemap(ret) OGRErr */
4832
 
    if (vresult == Qnil) {
4833
 
      vresult = INT2NUM(0);
4834
 
    }
4835
 
  }    return vresult;
4836
 
fail:
4837
 
  return Qnil;
4838
 
}
4839
 
 
4840
 
 
4841
 
SWIGINTERN VALUE
4842
 
_wrap_Feature_get_geometry_ref(int argc, VALUE *argv, VALUE self) {
4843
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4844
 
  OGRGeometryShadow *result = 0 ;
4845
 
  void *argp1 = 0 ;
4846
 
  int res1 = 0 ;
4847
 
  VALUE vresult = Qnil;
4848
 
  
4849
 
  if ((argc < 0) || (argc > 0)) {
4850
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4851
 
  }
4852
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
4853
 
  if (!SWIG_IsOK(res1)) {
4854
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetGeometryRef" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
4855
 
  }
4856
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
4857
 
  {
4858
 
    CPLErrorReset();
4859
 
    result = (OGRGeometryShadow *)OGRFeatureShadow_GetGeometryRef(arg1);
4860
 
    CPLErr eclass = CPLGetLastErrorType();
4861
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4862
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4863
 
      
4864
 
    }
4865
 
  }
4866
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
4867
 
  return vresult;
4868
 
fail:
4869
 
  return Qnil;
4870
 
}
4871
 
 
4872
 
 
4873
 
SWIGINTERN VALUE
4874
 
_wrap_Feature_clone(int argc, VALUE *argv, VALUE self) {
4875
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4876
 
  OGRFeatureShadow *result = 0 ;
4877
 
  void *argp1 = 0 ;
4878
 
  int res1 = 0 ;
4879
 
  VALUE vresult = Qnil;
4880
 
  
4881
 
  if ((argc < 0) || (argc > 0)) {
4882
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4883
 
  }
4884
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
4885
 
  if (!SWIG_IsOK(res1)) {
4886
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clone" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
4887
 
  }
4888
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
4889
 
  {
4890
 
    CPLErrorReset();
4891
 
    result = (OGRFeatureShadow *)OGRFeatureShadow_Clone(arg1);
4892
 
    CPLErr eclass = CPLGetLastErrorType();
4893
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4894
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4895
 
      
4896
 
    }
4897
 
  }
4898
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFeatureShadow, SWIG_POINTER_OWN |  0 );
4899
 
  return vresult;
4900
 
fail:
4901
 
  return Qnil;
4902
 
}
4903
 
 
4904
 
 
4905
 
SWIGINTERN VALUE
4906
 
_wrap_Feature_equal(int argc, VALUE *argv, VALUE self) {
4907
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4908
 
  OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
4909
 
  bool result;
4910
 
  void *argp1 = 0 ;
4911
 
  int res1 = 0 ;
4912
 
  void *argp2 = 0 ;
4913
 
  int res2 = 0 ;
4914
 
  VALUE vresult = Qnil;
4915
 
  
4916
 
  if ((argc < 1) || (argc > 1)) {
4917
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4918
 
  }
4919
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
4920
 
  if (!SWIG_IsOK(res1)) {
4921
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Equal" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
4922
 
  }
4923
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
4924
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
4925
 
  if (!SWIG_IsOK(res2)) {
4926
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Equal" "', argument " "2"" of type '" "OGRFeatureShadow *""'"); 
4927
 
  }
4928
 
  arg2 = reinterpret_cast< OGRFeatureShadow * >(argp2);
4929
 
  {
4930
 
    CPLErrorReset();
4931
 
    result = (bool)OGRFeatureShadow_Equal(arg1,arg2);
4932
 
    CPLErr eclass = CPLGetLastErrorType();
4933
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4934
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4935
 
      
4936
 
    }
4937
 
  }
4938
 
  vresult = SWIG_From_bool(static_cast< bool >(result));
4939
 
  return vresult;
4940
 
fail:
4941
 
  return Qnil;
4942
 
}
4943
 
 
4944
 
 
4945
 
SWIGINTERN VALUE
4946
 
_wrap_Feature_get_field_count(int argc, VALUE *argv, VALUE self) {
4947
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4948
 
  int result;
4949
 
  void *argp1 = 0 ;
4950
 
  int res1 = 0 ;
4951
 
  VALUE vresult = Qnil;
4952
 
  
4953
 
  if ((argc < 0) || (argc > 0)) {
4954
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4955
 
  }
4956
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
4957
 
  if (!SWIG_IsOK(res1)) {
4958
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetFieldCount" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
4959
 
  }
4960
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
4961
 
  {
4962
 
    CPLErrorReset();
4963
 
    result = (int)OGRFeatureShadow_GetFieldCount(arg1);
4964
 
    CPLErr eclass = CPLGetLastErrorType();
4965
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
4966
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
4967
 
      
4968
 
    }
4969
 
  }
4970
 
  vresult = SWIG_From_int(static_cast< int >(result));
4971
 
  return vresult;
4972
 
fail:
4973
 
  return Qnil;
4974
 
}
4975
 
 
4976
 
 
4977
 
SWIGINTERN VALUE
4978
 
_wrap_Feature_get_field_defn_ref__SWIG_0(int argc, VALUE *argv, VALUE self) {
4979
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4980
 
  int arg2 ;
4981
 
  OGRFieldDefnShadow *result = 0 ;
4982
 
  void *argp1 = 0 ;
4983
 
  int res1 = 0 ;
4984
 
  int val2 ;
4985
 
  int ecode2 = 0 ;
4986
 
  VALUE vresult = Qnil;
4987
 
  
4988
 
  if ((argc < 1) || (argc > 1)) {
4989
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4990
 
  }
4991
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
4992
 
  if (!SWIG_IsOK(res1)) {
4993
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetFieldDefnRef" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
4994
 
  }
4995
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
4996
 
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
4997
 
  if (!SWIG_IsOK(ecode2)) {
4998
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetFieldDefnRef" "', argument " "2"" of type '" "int""'");
4999
 
  } 
5000
 
  arg2 = static_cast< int >(val2);
5001
 
  {
5002
 
    CPLErrorReset();
5003
 
    result = (OGRFieldDefnShadow *)OGRFeatureShadow_GetFieldDefnRef__SWIG_0(arg1,arg2);
5004
 
    CPLErr eclass = CPLGetLastErrorType();
5005
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5006
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5007
 
      
5008
 
    }
5009
 
  }
5010
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFieldDefnShadow, 0 |  0 );
5011
 
  return vresult;
5012
 
fail:
5013
 
  return Qnil;
5014
 
}
5015
 
 
5016
 
 
5017
 
SWIGINTERN VALUE
5018
 
_wrap_Feature_get_field_defn_ref__SWIG_1(int argc, VALUE *argv, VALUE self) {
5019
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5020
 
  char *arg2 = (char *) 0 ;
5021
 
  OGRFieldDefnShadow *result = 0 ;
5022
 
  void *argp1 = 0 ;
5023
 
  int res1 = 0 ;
5024
 
  int res2 ;
5025
 
  char *buf2 = 0 ;
5026
 
  int alloc2 = 0 ;
5027
 
  VALUE vresult = Qnil;
5028
 
  
5029
 
  if ((argc < 1) || (argc > 1)) {
5030
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5031
 
  }
5032
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
5033
 
  if (!SWIG_IsOK(res1)) {
5034
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetFieldDefnRef" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
5035
 
  }
5036
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
5037
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
5038
 
  if (!SWIG_IsOK(res2)) {
5039
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetFieldDefnRef" "', argument " "2"" of type '" "char const *""'");
5040
 
  }
5041
 
  arg2 = buf2;
5042
 
  {
5043
 
    CPLErrorReset();
5044
 
    result = (OGRFieldDefnShadow *)OGRFeatureShadow_GetFieldDefnRef__SWIG_1(arg1,(char const *)arg2);
5045
 
    CPLErr eclass = CPLGetLastErrorType();
5046
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5047
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5048
 
      
5049
 
    }
5050
 
  }
5051
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFieldDefnShadow, 0 |  0 );
5052
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5053
 
  return vresult;
5054
 
fail:
5055
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5056
 
  return Qnil;
5057
 
}
5058
 
 
5059
 
 
5060
 
SWIGINTERN VALUE _wrap_Feature_get_field_defn_ref(int nargs, VALUE *args, VALUE self) {
5061
 
  int argc;
5062
 
  VALUE argv[3];
5063
 
  int ii;
5064
 
  
5065
 
  argc = nargs + 1;
5066
 
  argv[0] = self;
5067
 
  if (argc > 3) SWIG_fail;
5068
 
  for (ii = 1; (ii < argc); ii++) {
5069
 
    argv[ii] = args[ii-1];
5070
 
  }
5071
 
  if (argc == 2) {
5072
 
    int _v;
5073
 
    void *vptr = 0;
5074
 
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
5075
 
    _v = SWIG_CheckState(res);
5076
 
    if (_v) {
5077
 
      {
5078
 
        int res = SWIG_AsVal_int(argv[1], NULL);
5079
 
        _v = SWIG_CheckState(res);
5080
 
      }
5081
 
      if (_v) {
5082
 
        return _wrap_Feature_get_field_defn_ref__SWIG_0(nargs, args, self);
5083
 
      }
5084
 
    }
5085
 
  }
5086
 
  if (argc == 2) {
5087
 
    int _v;
5088
 
    void *vptr = 0;
5089
 
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
5090
 
    _v = SWIG_CheckState(res);
5091
 
    if (_v) {
5092
 
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
5093
 
      _v = SWIG_CheckState(res);
5094
 
      if (_v) {
5095
 
        return _wrap_Feature_get_field_defn_ref__SWIG_1(nargs, args, self);
5096
 
      }
5097
 
    }
5098
 
  }
5099
 
  
5100
 
fail:
5101
 
  rb_raise(rb_eArgError, "No matching function for overloaded 'Feature_get_field_defn_ref'");
5102
 
  return Qnil;
5103
 
}
5104
 
 
5105
 
 
5106
 
SWIGINTERN VALUE
5107
 
_wrap_Feature_get_field_as_string__SWIG_0(int argc, VALUE *argv, VALUE self) {
5108
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5109
 
  int arg2 ;
5110
 
  char *result = 0 ;
5111
 
  void *argp1 = 0 ;
5112
 
  int res1 = 0 ;
5113
 
  int val2 ;
5114
 
  int ecode2 = 0 ;
5115
 
  VALUE vresult = Qnil;
5116
 
  
5117
 
  if ((argc < 1) || (argc > 1)) {
5118
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5119
 
  }
5120
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
5121
 
  if (!SWIG_IsOK(res1)) {
5122
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetFieldAsString" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
5123
 
  }
5124
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
5125
 
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
5126
 
  if (!SWIG_IsOK(ecode2)) {
5127
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetFieldAsString" "', argument " "2"" of type '" "int""'");
5128
 
  } 
5129
 
  arg2 = static_cast< int >(val2);
5130
 
  {
5131
 
    CPLErrorReset();
5132
 
    result = (char *)OGRFeatureShadow_GetFieldAsString__SWIG_0(arg1,arg2);
5133
 
    CPLErr eclass = CPLGetLastErrorType();
5134
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5135
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5136
 
      
5137
 
    }
5138
 
  }
5139
 
  vresult = SWIG_FromCharPtr(result);
5140
 
  return vresult;
5141
 
fail:
5142
 
  return Qnil;
5143
 
}
5144
 
 
5145
 
 
5146
 
SWIGINTERN VALUE
5147
 
_wrap_Feature_get_field_as_string__SWIG_1(int argc, VALUE *argv, VALUE self) {
5148
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5149
 
  char *arg2 = (char *) 0 ;
5150
 
  char *result = 0 ;
5151
 
  void *argp1 = 0 ;
5152
 
  int res1 = 0 ;
5153
 
  int res2 ;
5154
 
  char *buf2 = 0 ;
5155
 
  int alloc2 = 0 ;
5156
 
  VALUE vresult = Qnil;
5157
 
  
5158
 
  if ((argc < 1) || (argc > 1)) {
5159
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5160
 
  }
5161
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
5162
 
  if (!SWIG_IsOK(res1)) {
5163
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetFieldAsString" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
5164
 
  }
5165
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
5166
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
5167
 
  if (!SWIG_IsOK(res2)) {
5168
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetFieldAsString" "', argument " "2"" of type '" "char const *""'");
5169
 
  }
5170
 
  arg2 = buf2;
5171
 
  {
5172
 
    CPLErrorReset();
5173
 
    result = (char *)OGRFeatureShadow_GetFieldAsString__SWIG_1(arg1,(char const *)arg2);
5174
 
    CPLErr eclass = CPLGetLastErrorType();
5175
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5176
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5177
 
      
5178
 
    }
5179
 
  }
5180
 
  vresult = SWIG_FromCharPtr(result);
5181
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5182
 
  return vresult;
5183
 
fail:
5184
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5185
 
  return Qnil;
5186
 
}
5187
 
 
5188
 
 
5189
 
SWIGINTERN VALUE _wrap_Feature_get_field_as_string(int nargs, VALUE *args, VALUE self) {
5190
 
  int argc;
5191
 
  VALUE argv[3];
5192
 
  int ii;
5193
 
  
5194
 
  argc = nargs + 1;
5195
 
  argv[0] = self;
5196
 
  if (argc > 3) SWIG_fail;
5197
 
  for (ii = 1; (ii < argc); ii++) {
5198
 
    argv[ii] = args[ii-1];
5199
 
  }
5200
 
  if (argc == 2) {
5201
 
    int _v;
5202
 
    void *vptr = 0;
5203
 
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
5204
 
    _v = SWIG_CheckState(res);
5205
 
    if (_v) {
5206
 
      {
5207
 
        int res = SWIG_AsVal_int(argv[1], NULL);
5208
 
        _v = SWIG_CheckState(res);
5209
 
      }
5210
 
      if (_v) {
5211
 
        return _wrap_Feature_get_field_as_string__SWIG_0(nargs, args, self);
5212
 
      }
5213
 
    }
5214
 
  }
5215
 
  if (argc == 2) {
5216
 
    int _v;
5217
 
    void *vptr = 0;
5218
 
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
5219
 
    _v = SWIG_CheckState(res);
5220
 
    if (_v) {
5221
 
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
5222
 
      _v = SWIG_CheckState(res);
5223
 
      if (_v) {
5224
 
        return _wrap_Feature_get_field_as_string__SWIG_1(nargs, args, self);
5225
 
      }
5226
 
    }
5227
 
  }
5228
 
  
5229
 
fail:
5230
 
  rb_raise(rb_eArgError, "No matching function for overloaded 'Feature_get_field_as_string'");
5231
 
  return Qnil;
5232
 
}
5233
 
 
5234
 
 
5235
 
SWIGINTERN VALUE
5236
 
_wrap_Feature_get_field_as_integer__SWIG_0(int argc, VALUE *argv, VALUE self) {
5237
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5238
 
  int arg2 ;
5239
 
  int result;
5240
 
  void *argp1 = 0 ;
5241
 
  int res1 = 0 ;
5242
 
  int val2 ;
5243
 
  int ecode2 = 0 ;
5244
 
  VALUE vresult = Qnil;
5245
 
  
5246
 
  if ((argc < 1) || (argc > 1)) {
5247
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5248
 
  }
5249
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
5250
 
  if (!SWIG_IsOK(res1)) {
5251
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetFieldAsInteger" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
5252
 
  }
5253
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
5254
 
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
5255
 
  if (!SWIG_IsOK(ecode2)) {
5256
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetFieldAsInteger" "', argument " "2"" of type '" "int""'");
5257
 
  } 
5258
 
  arg2 = static_cast< int >(val2);
5259
 
  {
5260
 
    CPLErrorReset();
5261
 
    result = (int)OGRFeatureShadow_GetFieldAsInteger__SWIG_0(arg1,arg2);
5262
 
    CPLErr eclass = CPLGetLastErrorType();
5263
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5264
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5265
 
      
5266
 
    }
5267
 
  }
5268
 
  vresult = SWIG_From_int(static_cast< int >(result));
5269
 
  return vresult;
5270
 
fail:
5271
 
  return Qnil;
5272
 
}
5273
 
 
5274
 
 
5275
 
SWIGINTERN VALUE
5276
 
_wrap_Feature_get_field_as_integer__SWIG_1(int argc, VALUE *argv, VALUE self) {
5277
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5278
 
  char *arg2 = (char *) 0 ;
5279
 
  int result;
5280
 
  void *argp1 = 0 ;
5281
 
  int res1 = 0 ;
5282
 
  int res2 ;
5283
 
  char *buf2 = 0 ;
5284
 
  int alloc2 = 0 ;
5285
 
  VALUE vresult = Qnil;
5286
 
  
5287
 
  if ((argc < 1) || (argc > 1)) {
5288
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5289
 
  }
5290
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
5291
 
  if (!SWIG_IsOK(res1)) {
5292
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetFieldAsInteger" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
5293
 
  }
5294
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
5295
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
5296
 
  if (!SWIG_IsOK(res2)) {
5297
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetFieldAsInteger" "', argument " "2"" of type '" "char const *""'");
5298
 
  }
5299
 
  arg2 = buf2;
5300
 
  {
5301
 
    CPLErrorReset();
5302
 
    result = (int)OGRFeatureShadow_GetFieldAsInteger__SWIG_1(arg1,(char const *)arg2);
5303
 
    CPLErr eclass = CPLGetLastErrorType();
5304
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5305
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5306
 
      
5307
 
    }
5308
 
  }
5309
 
  vresult = SWIG_From_int(static_cast< int >(result));
5310
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5311
 
  return vresult;
5312
 
fail:
5313
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5314
 
  return Qnil;
5315
 
}
5316
 
 
5317
 
 
5318
 
SWIGINTERN VALUE _wrap_Feature_get_field_as_integer(int nargs, VALUE *args, VALUE self) {
5319
 
  int argc;
5320
 
  VALUE argv[3];
5321
 
  int ii;
5322
 
  
5323
 
  argc = nargs + 1;
5324
 
  argv[0] = self;
5325
 
  if (argc > 3) SWIG_fail;
5326
 
  for (ii = 1; (ii < argc); ii++) {
5327
 
    argv[ii] = args[ii-1];
5328
 
  }
5329
 
  if (argc == 2) {
5330
 
    int _v;
5331
 
    void *vptr = 0;
5332
 
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
5333
 
    _v = SWIG_CheckState(res);
5334
 
    if (_v) {
5335
 
      {
5336
 
        int res = SWIG_AsVal_int(argv[1], NULL);
5337
 
        _v = SWIG_CheckState(res);
5338
 
      }
5339
 
      if (_v) {
5340
 
        return _wrap_Feature_get_field_as_integer__SWIG_0(nargs, args, self);
5341
 
      }
5342
 
    }
5343
 
  }
5344
 
  if (argc == 2) {
5345
 
    int _v;
5346
 
    void *vptr = 0;
5347
 
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
5348
 
    _v = SWIG_CheckState(res);
5349
 
    if (_v) {
5350
 
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
5351
 
      _v = SWIG_CheckState(res);
5352
 
      if (_v) {
5353
 
        return _wrap_Feature_get_field_as_integer__SWIG_1(nargs, args, self);
5354
 
      }
5355
 
    }
5356
 
  }
5357
 
  
5358
 
fail:
5359
 
  rb_raise(rb_eArgError, "No matching function for overloaded 'Feature_get_field_as_integer'");
5360
 
  return Qnil;
5361
 
}
5362
 
 
5363
 
 
5364
 
SWIGINTERN VALUE
5365
 
_wrap_Feature_get_field_as_double__SWIG_0(int argc, VALUE *argv, VALUE self) {
5366
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5367
 
  int arg2 ;
5368
 
  double result;
5369
 
  void *argp1 = 0 ;
5370
 
  int res1 = 0 ;
5371
 
  int val2 ;
5372
 
  int ecode2 = 0 ;
5373
 
  VALUE vresult = Qnil;
5374
 
  
5375
 
  if ((argc < 1) || (argc > 1)) {
5376
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5377
 
  }
5378
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
5379
 
  if (!SWIG_IsOK(res1)) {
5380
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetFieldAsDouble" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
5381
 
  }
5382
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
5383
 
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
5384
 
  if (!SWIG_IsOK(ecode2)) {
5385
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetFieldAsDouble" "', argument " "2"" of type '" "int""'");
5386
 
  } 
5387
 
  arg2 = static_cast< int >(val2);
5388
 
  {
5389
 
    CPLErrorReset();
5390
 
    result = (double)OGRFeatureShadow_GetFieldAsDouble__SWIG_0(arg1,arg2);
5391
 
    CPLErr eclass = CPLGetLastErrorType();
5392
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5393
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5394
 
      
5395
 
    }
5396
 
  }
5397
 
  vresult = SWIG_From_double(static_cast< double >(result));
5398
 
  return vresult;
5399
 
fail:
5400
 
  return Qnil;
5401
 
}
5402
 
 
5403
 
 
5404
 
SWIGINTERN VALUE
5405
 
_wrap_Feature_get_field_as_double__SWIG_1(int argc, VALUE *argv, VALUE self) {
5406
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5407
 
  char *arg2 = (char *) 0 ;
5408
 
  double result;
5409
 
  void *argp1 = 0 ;
5410
 
  int res1 = 0 ;
5411
 
  int res2 ;
5412
 
  char *buf2 = 0 ;
5413
 
  int alloc2 = 0 ;
5414
 
  VALUE vresult = Qnil;
5415
 
  
5416
 
  if ((argc < 1) || (argc > 1)) {
5417
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5418
 
  }
5419
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
5420
 
  if (!SWIG_IsOK(res1)) {
5421
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetFieldAsDouble" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
5422
 
  }
5423
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
5424
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
5425
 
  if (!SWIG_IsOK(res2)) {
5426
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetFieldAsDouble" "', argument " "2"" of type '" "char const *""'");
5427
 
  }
5428
 
  arg2 = buf2;
5429
 
  {
5430
 
    CPLErrorReset();
5431
 
    result = (double)OGRFeatureShadow_GetFieldAsDouble__SWIG_1(arg1,(char const *)arg2);
5432
 
    CPLErr eclass = CPLGetLastErrorType();
5433
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5434
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5435
 
      
5436
 
    }
5437
 
  }
5438
 
  vresult = SWIG_From_double(static_cast< double >(result));
5439
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5440
 
  return vresult;
5441
 
fail:
5442
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5443
 
  return Qnil;
5444
 
}
5445
 
 
5446
 
 
5447
 
SWIGINTERN VALUE _wrap_Feature_get_field_as_double(int nargs, VALUE *args, VALUE self) {
5448
 
  int argc;
5449
 
  VALUE argv[3];
5450
 
  int ii;
5451
 
  
5452
 
  argc = nargs + 1;
5453
 
  argv[0] = self;
5454
 
  if (argc > 3) SWIG_fail;
5455
 
  for (ii = 1; (ii < argc); ii++) {
5456
 
    argv[ii] = args[ii-1];
5457
 
  }
5458
 
  if (argc == 2) {
5459
 
    int _v;
5460
 
    void *vptr = 0;
5461
 
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
5462
 
    _v = SWIG_CheckState(res);
5463
 
    if (_v) {
5464
 
      {
5465
 
        int res = SWIG_AsVal_int(argv[1], NULL);
5466
 
        _v = SWIG_CheckState(res);
5467
 
      }
5468
 
      if (_v) {
5469
 
        return _wrap_Feature_get_field_as_double__SWIG_0(nargs, args, self);
5470
 
      }
5471
 
    }
5472
 
  }
5473
 
  if (argc == 2) {
5474
 
    int _v;
5475
 
    void *vptr = 0;
5476
 
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
5477
 
    _v = SWIG_CheckState(res);
5478
 
    if (_v) {
5479
 
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
5480
 
      _v = SWIG_CheckState(res);
5481
 
      if (_v) {
5482
 
        return _wrap_Feature_get_field_as_double__SWIG_1(nargs, args, self);
5483
 
      }
5484
 
    }
5485
 
  }
5486
 
  
5487
 
fail:
5488
 
  rb_raise(rb_eArgError, "No matching function for overloaded 'Feature_get_field_as_double'");
5489
 
  return Qnil;
5490
 
}
5491
 
 
5492
 
 
5493
 
SWIGINTERN VALUE
5494
 
_wrap_Feature_is_field_set__SWIG_0(int argc, VALUE *argv, VALUE self) {
5495
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5496
 
  int arg2 ;
5497
 
  bool result;
5498
 
  void *argp1 = 0 ;
5499
 
  int res1 = 0 ;
5500
 
  int val2 ;
5501
 
  int ecode2 = 0 ;
5502
 
  VALUE vresult = Qnil;
5503
 
  
5504
 
  if ((argc < 1) || (argc > 1)) {
5505
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5506
 
  }
5507
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
5508
 
  if (!SWIG_IsOK(res1)) {
5509
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IsFieldSet" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
5510
 
  }
5511
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
5512
 
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
5513
 
  if (!SWIG_IsOK(ecode2)) {
5514
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IsFieldSet" "', argument " "2"" of type '" "int""'");
5515
 
  } 
5516
 
  arg2 = static_cast< int >(val2);
5517
 
  {
5518
 
    CPLErrorReset();
5519
 
    result = (bool)OGRFeatureShadow_IsFieldSet__SWIG_0(arg1,arg2);
5520
 
    CPLErr eclass = CPLGetLastErrorType();
5521
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5522
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5523
 
      
5524
 
    }
5525
 
  }
5526
 
  vresult = SWIG_From_bool(static_cast< bool >(result));
5527
 
  return vresult;
5528
 
fail:
5529
 
  return Qnil;
5530
 
}
5531
 
 
5532
 
 
5533
 
SWIGINTERN VALUE
5534
 
_wrap_Feature_is_field_set__SWIG_1(int argc, VALUE *argv, VALUE self) {
5535
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5536
 
  char *arg2 = (char *) 0 ;
5537
 
  bool result;
5538
 
  void *argp1 = 0 ;
5539
 
  int res1 = 0 ;
5540
 
  int res2 ;
5541
 
  char *buf2 = 0 ;
5542
 
  int alloc2 = 0 ;
5543
 
  VALUE vresult = Qnil;
5544
 
  
5545
 
  if ((argc < 1) || (argc > 1)) {
5546
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5547
 
  }
5548
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
5549
 
  if (!SWIG_IsOK(res1)) {
5550
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IsFieldSet" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
5551
 
  }
5552
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
5553
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
5554
 
  if (!SWIG_IsOK(res2)) {
5555
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IsFieldSet" "', argument " "2"" of type '" "char const *""'");
5556
 
  }
5557
 
  arg2 = buf2;
5558
 
  {
5559
 
    CPLErrorReset();
5560
 
    result = (bool)OGRFeatureShadow_IsFieldSet__SWIG_1(arg1,(char const *)arg2);
5561
 
    CPLErr eclass = CPLGetLastErrorType();
5562
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5563
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5564
 
      
5565
 
    }
5566
 
  }
5567
 
  vresult = SWIG_From_bool(static_cast< bool >(result));
5568
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5569
 
  return vresult;
5570
 
fail:
5571
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5572
 
  return Qnil;
5573
 
}
5574
 
 
5575
 
 
5576
 
SWIGINTERN VALUE _wrap_Feature_is_field_set(int nargs, VALUE *args, VALUE self) {
5577
 
  int argc;
5578
 
  VALUE argv[3];
5579
 
  int ii;
5580
 
  
5581
 
  argc = nargs + 1;
5582
 
  argv[0] = self;
5583
 
  if (argc > 3) SWIG_fail;
5584
 
  for (ii = 1; (ii < argc); ii++) {
5585
 
    argv[ii] = args[ii-1];
5586
 
  }
5587
 
  if (argc == 2) {
5588
 
    int _v;
5589
 
    void *vptr = 0;
5590
 
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
5591
 
    _v = SWIG_CheckState(res);
5592
 
    if (_v) {
5593
 
      {
5594
 
        int res = SWIG_AsVal_int(argv[1], NULL);
5595
 
        _v = SWIG_CheckState(res);
5596
 
      }
5597
 
      if (_v) {
5598
 
        return _wrap_Feature_is_field_set__SWIG_0(nargs, args, self);
5599
 
      }
5600
 
    }
5601
 
  }
5602
 
  if (argc == 2) {
5603
 
    int _v;
5604
 
    void *vptr = 0;
5605
 
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
5606
 
    _v = SWIG_CheckState(res);
5607
 
    if (_v) {
5608
 
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
5609
 
      _v = SWIG_CheckState(res);
5610
 
      if (_v) {
5611
 
        return _wrap_Feature_is_field_set__SWIG_1(nargs, args, self);
5612
 
      }
5613
 
    }
5614
 
  }
5615
 
  
5616
 
fail:
5617
 
  rb_raise(rb_eArgError, "No matching function for overloaded 'Feature_is_field_set'");
5618
 
  return Qnil;
5619
 
}
5620
 
 
5621
 
 
5622
 
SWIGINTERN VALUE
5623
 
_wrap_Feature_get_field_index(int argc, VALUE *argv, VALUE self) {
5624
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5625
 
  char *arg2 = (char *) 0 ;
5626
 
  int result;
5627
 
  void *argp1 = 0 ;
5628
 
  int res1 = 0 ;
5629
 
  int res2 ;
5630
 
  char *buf2 = 0 ;
5631
 
  int alloc2 = 0 ;
5632
 
  VALUE vresult = Qnil;
5633
 
  
5634
 
  if ((argc < 1) || (argc > 1)) {
5635
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5636
 
  }
5637
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
5638
 
  if (!SWIG_IsOK(res1)) {
5639
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetFieldIndex" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
5640
 
  }
5641
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
5642
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
5643
 
  if (!SWIG_IsOK(res2)) {
5644
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetFieldIndex" "', argument " "2"" of type '" "char const *""'");
5645
 
  }
5646
 
  arg2 = buf2;
5647
 
  {
5648
 
    CPLErrorReset();
5649
 
    result = (int)OGRFeatureShadow_GetFieldIndex(arg1,(char const *)arg2);
5650
 
    CPLErr eclass = CPLGetLastErrorType();
5651
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5652
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5653
 
      
5654
 
    }
5655
 
  }
5656
 
  vresult = SWIG_From_int(static_cast< int >(result));
5657
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5658
 
  return vresult;
5659
 
fail:
5660
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5661
 
  return Qnil;
5662
 
}
5663
 
 
5664
 
 
5665
 
SWIGINTERN VALUE
5666
 
_wrap_Feature_get_fid(int argc, VALUE *argv, VALUE self) {
5667
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5668
 
  int result;
5669
 
  void *argp1 = 0 ;
5670
 
  int res1 = 0 ;
5671
 
  VALUE vresult = Qnil;
5672
 
  
5673
 
  if ((argc < 0) || (argc > 0)) {
5674
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5675
 
  }
5676
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
5677
 
  if (!SWIG_IsOK(res1)) {
5678
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetFID" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
5679
 
  }
5680
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
5681
 
  {
5682
 
    CPLErrorReset();
5683
 
    result = (int)OGRFeatureShadow_GetFID(arg1);
5684
 
    CPLErr eclass = CPLGetLastErrorType();
5685
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5686
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5687
 
      
5688
 
    }
5689
 
  }
5690
 
  vresult = SWIG_From_int(static_cast< int >(result));
5691
 
  return vresult;
5692
 
fail:
5693
 
  return Qnil;
5694
 
}
5695
 
 
5696
 
 
5697
 
SWIGINTERN VALUE
5698
 
_wrap_Feature_set_fid(int argc, VALUE *argv, VALUE self) {
5699
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5700
 
  int arg2 ;
5701
 
  OGRErr result;
5702
 
  void *argp1 = 0 ;
5703
 
  int res1 = 0 ;
5704
 
  int val2 ;
5705
 
  int ecode2 = 0 ;
5706
 
  VALUE vresult = Qnil;
5707
 
  
5708
 
  if ((argc < 1) || (argc > 1)) {
5709
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5710
 
  }
5711
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
5712
 
  if (!SWIG_IsOK(res1)) {
5713
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetFID" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
5714
 
  }
5715
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
5716
 
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
5717
 
  if (!SWIG_IsOK(ecode2)) {
5718
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SetFID" "', argument " "2"" of type '" "int""'");
5719
 
  } 
5720
 
  arg2 = static_cast< int >(val2);
5721
 
  {
5722
 
    CPLErrorReset();
5723
 
    result = (OGRErr)OGRFeatureShadow_SetFID(arg1,arg2);
5724
 
    CPLErr eclass = CPLGetLastErrorType();
5725
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5726
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5727
 
      
5728
 
    }
5729
 
  }
5730
 
  {
5731
 
    /* %typemap(out) OGRErr */
5732
 
    if (result != 0) {
5733
 
      rb_raise(rb_eRuntimeError, OGRErrMessages(result));
5734
 
    }
5735
 
  }
5736
 
  {
5737
 
    /* %typemap(ret) OGRErr */
5738
 
    if (vresult == Qnil) {
5739
 
      vresult = INT2NUM(0);
5740
 
    }
5741
 
  }    return vresult;
5742
 
fail:
5743
 
  return Qnil;
5744
 
}
5745
 
 
5746
 
 
5747
 
SWIGINTERN VALUE
5748
 
_wrap_Feature_dump_readable(int argc, VALUE *argv, VALUE self) {
5749
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5750
 
  void *argp1 = 0 ;
5751
 
  int res1 = 0 ;
5752
 
  
5753
 
  if ((argc < 0) || (argc > 0)) {
5754
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5755
 
  }
5756
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
5757
 
  if (!SWIG_IsOK(res1)) {
5758
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DumpReadable" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
5759
 
  }
5760
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
5761
 
  {
5762
 
    CPLErrorReset();
5763
 
    OGRFeatureShadow_DumpReadable(arg1);
5764
 
    CPLErr eclass = CPLGetLastErrorType();
5765
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5766
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5767
 
      
5768
 
    }
5769
 
  }
5770
 
  return Qnil;
5771
 
fail:
5772
 
  return Qnil;
5773
 
}
5774
 
 
5775
 
 
5776
 
SWIGINTERN VALUE
5777
 
_wrap_Feature_unset_field__SWIG_0(int argc, VALUE *argv, VALUE self) {
5778
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5779
 
  int arg2 ;
5780
 
  void *argp1 = 0 ;
5781
 
  int res1 = 0 ;
5782
 
  int val2 ;
5783
 
  int ecode2 = 0 ;
5784
 
  
5785
 
  if ((argc < 1) || (argc > 1)) {
5786
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5787
 
  }
5788
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
5789
 
  if (!SWIG_IsOK(res1)) {
5790
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsetField" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
5791
 
  }
5792
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
5793
 
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
5794
 
  if (!SWIG_IsOK(ecode2)) {
5795
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsetField" "', argument " "2"" of type '" "int""'");
5796
 
  } 
5797
 
  arg2 = static_cast< int >(val2);
5798
 
  {
5799
 
    CPLErrorReset();
5800
 
    OGRFeatureShadow_UnsetField__SWIG_0(arg1,arg2);
5801
 
    CPLErr eclass = CPLGetLastErrorType();
5802
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5803
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5804
 
      
5805
 
    }
5806
 
  }
5807
 
  return Qnil;
5808
 
fail:
5809
 
  return Qnil;
5810
 
}
5811
 
 
5812
 
 
5813
 
SWIGINTERN VALUE
5814
 
_wrap_Feature_unset_field__SWIG_1(int argc, VALUE *argv, VALUE self) {
5815
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5816
 
  char *arg2 = (char *) 0 ;
5817
 
  void *argp1 = 0 ;
5818
 
  int res1 = 0 ;
5819
 
  int res2 ;
5820
 
  char *buf2 = 0 ;
5821
 
  int alloc2 = 0 ;
5822
 
  
5823
 
  if ((argc < 1) || (argc > 1)) {
5824
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5825
 
  }
5826
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
5827
 
  if (!SWIG_IsOK(res1)) {
5828
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsetField" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
5829
 
  }
5830
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
5831
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
5832
 
  if (!SWIG_IsOK(res2)) {
5833
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnsetField" "', argument " "2"" of type '" "char const *""'");
5834
 
  }
5835
 
  arg2 = buf2;
5836
 
  {
5837
 
    CPLErrorReset();
5838
 
    OGRFeatureShadow_UnsetField__SWIG_1(arg1,(char const *)arg2);
5839
 
    CPLErr eclass = CPLGetLastErrorType();
5840
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5841
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5842
 
      
5843
 
    }
5844
 
  }
5845
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5846
 
  return Qnil;
5847
 
fail:
5848
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5849
 
  return Qnil;
5850
 
}
5851
 
 
5852
 
 
5853
 
SWIGINTERN VALUE _wrap_Feature_unset_field(int nargs, VALUE *args, VALUE self) {
5854
 
  int argc;
5855
 
  VALUE argv[3];
5856
 
  int ii;
5857
 
  
5858
 
  argc = nargs + 1;
5859
 
  argv[0] = self;
5860
 
  if (argc > 3) SWIG_fail;
5861
 
  for (ii = 1; (ii < argc); ii++) {
5862
 
    argv[ii] = args[ii-1];
5863
 
  }
5864
 
  if (argc == 2) {
5865
 
    int _v;
5866
 
    void *vptr = 0;
5867
 
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
5868
 
    _v = SWIG_CheckState(res);
5869
 
    if (_v) {
5870
 
      {
5871
 
        int res = SWIG_AsVal_int(argv[1], NULL);
5872
 
        _v = SWIG_CheckState(res);
5873
 
      }
5874
 
      if (_v) {
5875
 
        return _wrap_Feature_unset_field__SWIG_0(nargs, args, self);
5876
 
      }
5877
 
    }
5878
 
  }
5879
 
  if (argc == 2) {
5880
 
    int _v;
5881
 
    void *vptr = 0;
5882
 
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
5883
 
    _v = SWIG_CheckState(res);
5884
 
    if (_v) {
5885
 
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
5886
 
      _v = SWIG_CheckState(res);
5887
 
      if (_v) {
5888
 
        return _wrap_Feature_unset_field__SWIG_1(nargs, args, self);
5889
 
      }
5890
 
    }
5891
 
  }
5892
 
  
5893
 
fail:
5894
 
  rb_raise(rb_eArgError, "No matching function for overloaded 'Feature_unset_field'");
5895
 
  return Qnil;
5896
 
}
5897
 
 
5898
 
 
5899
 
SWIGINTERN VALUE
5900
 
_wrap_Feature_set_field__SWIG_0(int argc, VALUE *argv, VALUE self) {
5901
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5902
 
  int arg2 ;
5903
 
  char *arg3 = (char *) 0 ;
5904
 
  void *argp1 = 0 ;
5905
 
  int res1 = 0 ;
5906
 
  int val2 ;
5907
 
  int ecode2 = 0 ;
5908
 
  int res3 ;
5909
 
  char *buf3 = 0 ;
5910
 
  int alloc3 = 0 ;
5911
 
  
5912
 
  if ((argc < 2) || (argc > 2)) {
5913
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
5914
 
  }
5915
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
5916
 
  if (!SWIG_IsOK(res1)) {
5917
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetField" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
5918
 
  }
5919
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
5920
 
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
5921
 
  if (!SWIG_IsOK(ecode2)) {
5922
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SetField" "', argument " "2"" of type '" "int""'");
5923
 
  } 
5924
 
  arg2 = static_cast< int >(val2);
5925
 
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
5926
 
  if (!SWIG_IsOK(res3)) {
5927
 
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SetField" "', argument " "3"" of type '" "char const *""'");
5928
 
  }
5929
 
  arg3 = buf3;
5930
 
  {
5931
 
    CPLErrorReset();
5932
 
    OGRFeatureShadow_SetField__SWIG_0(arg1,arg2,(char const *)arg3);
5933
 
    CPLErr eclass = CPLGetLastErrorType();
5934
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5935
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5936
 
      
5937
 
    }
5938
 
  }
5939
 
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
5940
 
  return Qnil;
5941
 
fail:
5942
 
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
5943
 
  return Qnil;
5944
 
}
5945
 
 
5946
 
 
5947
 
SWIGINTERN VALUE
5948
 
_wrap_Feature_set_field__SWIG_1(int argc, VALUE *argv, VALUE self) {
5949
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5950
 
  char *arg2 = (char *) 0 ;
5951
 
  char *arg3 = (char *) 0 ;
5952
 
  void *argp1 = 0 ;
5953
 
  int res1 = 0 ;
5954
 
  int res2 ;
5955
 
  char *buf2 = 0 ;
5956
 
  int alloc2 = 0 ;
5957
 
  int res3 ;
5958
 
  char *buf3 = 0 ;
5959
 
  int alloc3 = 0 ;
5960
 
  
5961
 
  if ((argc < 2) || (argc > 2)) {
5962
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
5963
 
  }
5964
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
5965
 
  if (!SWIG_IsOK(res1)) {
5966
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetField" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
5967
 
  }
5968
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
5969
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
5970
 
  if (!SWIG_IsOK(res2)) {
5971
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetField" "', argument " "2"" of type '" "char const *""'");
5972
 
  }
5973
 
  arg2 = buf2;
5974
 
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
5975
 
  if (!SWIG_IsOK(res3)) {
5976
 
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SetField" "', argument " "3"" of type '" "char const *""'");
5977
 
  }
5978
 
  arg3 = buf3;
5979
 
  {
5980
 
    CPLErrorReset();
5981
 
    OGRFeatureShadow_SetField__SWIG_1(arg1,(char const *)arg2,(char const *)arg3);
5982
 
    CPLErr eclass = CPLGetLastErrorType();
5983
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
5984
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
5985
 
      
5986
 
    }
5987
 
  }
5988
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5989
 
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
5990
 
  return Qnil;
5991
 
fail:
5992
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5993
 
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
5994
 
  return Qnil;
5995
 
}
5996
 
 
5997
 
 
5998
 
SWIGINTERN VALUE _wrap_Feature_set_field(int nargs, VALUE *args, VALUE self) {
5999
 
  int argc;
6000
 
  VALUE argv[4];
6001
 
  int ii;
6002
 
  
6003
 
  argc = nargs + 1;
6004
 
  argv[0] = self;
6005
 
  if (argc > 4) SWIG_fail;
6006
 
  for (ii = 1; (ii < argc); ii++) {
6007
 
    argv[ii] = args[ii-1];
6008
 
  }
6009
 
  if (argc == 3) {
6010
 
    int _v;
6011
 
    void *vptr = 0;
6012
 
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
6013
 
    _v = SWIG_CheckState(res);
6014
 
    if (_v) {
6015
 
      {
6016
 
        int res = SWIG_AsVal_int(argv[1], NULL);
6017
 
        _v = SWIG_CheckState(res);
6018
 
      }
6019
 
      if (_v) {
6020
 
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
6021
 
        _v = SWIG_CheckState(res);
6022
 
        if (_v) {
6023
 
          return _wrap_Feature_set_field__SWIG_0(nargs, args, self);
6024
 
        }
6025
 
      }
6026
 
    }
6027
 
  }
6028
 
  if (argc == 3) {
6029
 
    int _v;
6030
 
    void *vptr = 0;
6031
 
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
6032
 
    _v = SWIG_CheckState(res);
6033
 
    if (_v) {
6034
 
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
6035
 
      _v = SWIG_CheckState(res);
6036
 
      if (_v) {
6037
 
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
6038
 
        _v = SWIG_CheckState(res);
6039
 
        if (_v) {
6040
 
          return _wrap_Feature_set_field__SWIG_1(nargs, args, self);
6041
 
        }
6042
 
      }
6043
 
    }
6044
 
  }
6045
 
  
6046
 
fail:
6047
 
  rb_raise(rb_eArgError, "No matching function for overloaded 'Feature_set_field'");
6048
 
  return Qnil;
6049
 
}
6050
 
 
6051
 
 
6052
 
SWIGINTERN VALUE
6053
 
_wrap_Feature_set_from(int argc, VALUE *argv, VALUE self) {
6054
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
6055
 
  OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
6056
 
  int arg3 = (int) 1 ;
6057
 
  OGRErr result;
6058
 
  void *argp1 = 0 ;
6059
 
  int res1 = 0 ;
6060
 
  void *argp2 = 0 ;
6061
 
  int res2 = 0 ;
6062
 
  int val3 ;
6063
 
  int ecode3 = 0 ;
6064
 
  char *kwnames[] = {
6065
 
    "self","other","forgiving", NULL 
6066
 
  };
6067
 
  VALUE vresult = Qnil;
6068
 
  
6069
 
  if ((argc < 1) || (argc > 2)) {
6070
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6071
 
  }
6072
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
6073
 
  if (!SWIG_IsOK(res1)) {
6074
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetFrom" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
6075
 
  }
6076
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
6077
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
6078
 
  if (!SWIG_IsOK(res2)) {
6079
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetFrom" "', argument " "2"" of type '" "OGRFeatureShadow *""'"); 
6080
 
  }
6081
 
  arg2 = reinterpret_cast< OGRFeatureShadow * >(argp2);
6082
 
  if (argc > 1) {
6083
 
    ecode3 = SWIG_AsVal_int(argv[1], &val3);
6084
 
    if (!SWIG_IsOK(ecode3)) {
6085
 
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SetFrom" "', argument " "3"" of type '" "int""'");
6086
 
    } 
6087
 
    arg3 = static_cast< int >(val3);
6088
 
  }
6089
 
  {
6090
 
    CPLErrorReset();
6091
 
    result = (OGRErr)OGRFeatureShadow_SetFrom(arg1,arg2,arg3);
6092
 
    CPLErr eclass = CPLGetLastErrorType();
6093
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6094
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6095
 
      
6096
 
    }
6097
 
  }
6098
 
  {
6099
 
    /* %typemap(out) OGRErr */
6100
 
    if (result != 0) {
6101
 
      rb_raise(rb_eRuntimeError, OGRErrMessages(result));
6102
 
    }
6103
 
  }
6104
 
  {
6105
 
    /* %typemap(ret) OGRErr */
6106
 
    if (vresult == Qnil) {
6107
 
      vresult = INT2NUM(0);
6108
 
    }
6109
 
  }    return vresult;
6110
 
fail:
6111
 
  return Qnil;
6112
 
}
6113
 
 
6114
 
 
6115
 
SWIGINTERN VALUE
6116
 
_wrap_Feature_get_style_string(int argc, VALUE *argv, VALUE self) {
6117
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
6118
 
  char *result = 0 ;
6119
 
  void *argp1 = 0 ;
6120
 
  int res1 = 0 ;
6121
 
  VALUE vresult = Qnil;
6122
 
  
6123
 
  if ((argc < 0) || (argc > 0)) {
6124
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6125
 
  }
6126
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
6127
 
  if (!SWIG_IsOK(res1)) {
6128
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetStyleString" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
6129
 
  }
6130
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
6131
 
  {
6132
 
    CPLErrorReset();
6133
 
    result = (char *)OGRFeatureShadow_GetStyleString(arg1);
6134
 
    CPLErr eclass = CPLGetLastErrorType();
6135
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6136
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6137
 
      
6138
 
    }
6139
 
  }
6140
 
  vresult = SWIG_FromCharPtr(result);
6141
 
  return vresult;
6142
 
fail:
6143
 
  return Qnil;
6144
 
}
6145
 
 
6146
 
 
6147
 
SWIGINTERN VALUE
6148
 
_wrap_Feature_set_style_string(int argc, VALUE *argv, VALUE self) {
6149
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
6150
 
  char *arg2 = (char *) 0 ;
6151
 
  void *argp1 = 0 ;
6152
 
  int res1 = 0 ;
6153
 
  int res2 ;
6154
 
  char *buf2 = 0 ;
6155
 
  int alloc2 = 0 ;
6156
 
  
6157
 
  if ((argc < 1) || (argc > 1)) {
6158
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6159
 
  }
6160
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
6161
 
  if (!SWIG_IsOK(res1)) {
6162
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetStyleString" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
6163
 
  }
6164
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
6165
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
6166
 
  if (!SWIG_IsOK(res2)) {
6167
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetStyleString" "', argument " "2"" of type '" "char const *""'");
6168
 
  }
6169
 
  arg2 = buf2;
6170
 
  {
6171
 
    CPLErrorReset();
6172
 
    OGRFeatureShadow_SetStyleString(arg1,(char const *)arg2);
6173
 
    CPLErr eclass = CPLGetLastErrorType();
6174
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6175
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6176
 
      
6177
 
    }
6178
 
  }
6179
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6180
 
  return Qnil;
6181
 
fail:
6182
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6183
 
  return Qnil;
6184
 
}
6185
 
 
6186
 
 
6187
 
SWIGINTERN VALUE
6188
 
_wrap_Feature_get_field_type__SWIG_0(int argc, VALUE *argv, VALUE self) {
6189
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
6190
 
  int arg2 ;
6191
 
  OGRFieldType result;
6192
 
  void *argp1 = 0 ;
6193
 
  int res1 = 0 ;
6194
 
  int val2 ;
6195
 
  int ecode2 = 0 ;
6196
 
  VALUE vresult = Qnil;
6197
 
  
6198
 
  if ((argc < 1) || (argc > 1)) {
6199
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6200
 
  }
6201
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
6202
 
  if (!SWIG_IsOK(res1)) {
6203
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetFieldType" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
6204
 
  }
6205
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
6206
 
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
6207
 
  if (!SWIG_IsOK(ecode2)) {
6208
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetFieldType" "', argument " "2"" of type '" "int""'");
6209
 
  } 
6210
 
  arg2 = static_cast< int >(val2);
6211
 
  {
6212
 
    CPLErrorReset();
6213
 
    result = (OGRFieldType)OGRFeatureShadow_GetFieldType__SWIG_0(arg1,arg2);
6214
 
    CPLErr eclass = CPLGetLastErrorType();
6215
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6216
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6217
 
      
6218
 
    }
6219
 
  }
6220
 
  vresult = SWIG_From_int(static_cast< int >(result));
6221
 
  return vresult;
6222
 
fail:
6223
 
  return Qnil;
6224
 
}
6225
 
 
6226
 
 
6227
 
SWIGINTERN VALUE
6228
 
_wrap_Feature_get_field_type__SWIG_1(int argc, VALUE *argv, VALUE self) {
6229
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
6230
 
  char *arg2 = (char *) 0 ;
6231
 
  OGRFieldType result;
6232
 
  void *argp1 = 0 ;
6233
 
  int res1 = 0 ;
6234
 
  int res2 ;
6235
 
  char *buf2 = 0 ;
6236
 
  int alloc2 = 0 ;
6237
 
  VALUE vresult = Qnil;
6238
 
  
6239
 
  if ((argc < 1) || (argc > 1)) {
6240
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6241
 
  }
6242
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
6243
 
  if (!SWIG_IsOK(res1)) {
6244
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetFieldType" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
6245
 
  }
6246
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
6247
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
6248
 
  if (!SWIG_IsOK(res2)) {
6249
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetFieldType" "', argument " "2"" of type '" "char const *""'");
6250
 
  }
6251
 
  arg2 = buf2;
6252
 
  {
6253
 
    CPLErrorReset();
6254
 
    result = (OGRFieldType)OGRFeatureShadow_GetFieldType__SWIG_1(arg1,(char const *)arg2);
6255
 
    CPLErr eclass = CPLGetLastErrorType();
6256
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6257
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6258
 
      
6259
 
    }
6260
 
  }
6261
 
  vresult = SWIG_From_int(static_cast< int >(result));
6262
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6263
 
  return vresult;
6264
 
fail:
6265
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6266
 
  return Qnil;
6267
 
}
6268
 
 
6269
 
 
6270
 
SWIGINTERN VALUE _wrap_Feature_get_field_type(int nargs, VALUE *args, VALUE self) {
6271
 
  int argc;
6272
 
  VALUE argv[3];
6273
 
  int ii;
6274
 
  
6275
 
  argc = nargs + 1;
6276
 
  argv[0] = self;
6277
 
  if (argc > 3) SWIG_fail;
6278
 
  for (ii = 1; (ii < argc); ii++) {
6279
 
    argv[ii] = args[ii-1];
6280
 
  }
6281
 
  if (argc == 2) {
6282
 
    int _v;
6283
 
    void *vptr = 0;
6284
 
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
6285
 
    _v = SWIG_CheckState(res);
6286
 
    if (_v) {
6287
 
      {
6288
 
        int res = SWIG_AsVal_int(argv[1], NULL);
6289
 
        _v = SWIG_CheckState(res);
6290
 
      }
6291
 
      if (_v) {
6292
 
        return _wrap_Feature_get_field_type__SWIG_0(nargs, args, self);
6293
 
      }
6294
 
    }
6295
 
  }
6296
 
  if (argc == 2) {
6297
 
    int _v;
6298
 
    void *vptr = 0;
6299
 
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_OGRFeatureShadow, 0);
6300
 
    _v = SWIG_CheckState(res);
6301
 
    if (_v) {
6302
 
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
6303
 
      _v = SWIG_CheckState(res);
6304
 
      if (_v) {
6305
 
        return _wrap_Feature_get_field_type__SWIG_1(nargs, args, self);
6306
 
      }
6307
 
    }
6308
 
  }
6309
 
  
6310
 
fail:
6311
 
  rb_raise(rb_eArgError, "No matching function for overloaded 'Feature_get_field_type'");
6312
 
  return Qnil;
6313
 
}
6314
 
 
6315
 
 
6316
 
SWIGINTERN VALUE
6317
 
_wrap_Feature_get_field(int argc, VALUE *argv, VALUE self) {
6318
 
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
6319
 
  VALUE arg2 = (VALUE) 0 ;
6320
 
  VALUE result;
6321
 
  void *argp1 = 0 ;
6322
 
  int res1 = 0 ;
6323
 
  VALUE vresult = Qnil;
6324
 
  
6325
 
  if ((argc < 1) || (argc > 1)) {
6326
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6327
 
  }
6328
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureShadow, 0 |  0 );
6329
 
  if (!SWIG_IsOK(res1)) {
6330
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetField" "', argument " "1"" of type '" "OGRFeatureShadow *""'"); 
6331
 
  }
6332
 
  arg1 = reinterpret_cast< OGRFeatureShadow * >(argp1);
6333
 
  arg2 = argv[0];
6334
 
  {
6335
 
    CPLErrorReset();
6336
 
    result = (VALUE)OGRFeatureShadow_GetField(arg1,arg2);
6337
 
    CPLErr eclass = CPLGetLastErrorType();
6338
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6339
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6340
 
      
6341
 
    }
6342
 
  }
6343
 
  vresult = result;
6344
 
  return vresult;
6345
 
fail:
6346
 
  return Qnil;
6347
 
}
6348
 
 
6349
 
 
6350
 
swig_class cFeatureDefn;
6351
 
 
6352
 
SWIGINTERN void delete_OGRFeatureDefnShadow(OGRFeatureDefnShadow *self){
6353
 
    OGR_FD_Destroy(self);
6354
 
  }
6355
 
SWIGINTERN void
6356
 
free_OGRFeatureDefnShadow(OGRFeatureDefnShadow *arg1) {
6357
 
    delete_OGRFeatureDefnShadow(arg1);
6358
 
}
6359
 
 
6360
 
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
6361
 
SWIGINTERN VALUE
6362
 
_wrap_FeatureDefn_allocate(VALUE self) {
6363
 
#else
6364
 
  SWIGINTERN VALUE
6365
 
  _wrap_FeatureDefn_allocate(int argc, VALUE *argv, VALUE self) {
6366
 
#endif
6367
 
    
6368
 
    
6369
 
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OGRFeatureDefnShadow);
6370
 
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
6371
 
    rb_obj_call_init(vresult, argc, argv);
6372
 
#endif
6373
 
    return vresult;
6374
 
  }
6375
 
  
6376
 
 
6377
 
SWIGINTERN VALUE
6378
 
_wrap_new_FeatureDefn(int argc, VALUE *argv, VALUE self) {
6379
 
  char *arg1 = (char *) NULL ;
6380
 
  OGRFeatureDefnShadow *result = 0 ;
6381
 
  int res1 ;
6382
 
  char *buf1 = 0 ;
6383
 
  int alloc1 = 0 ;
6384
 
  char *kwnames[] = {
6385
 
    "name", NULL 
6386
 
  };
6387
 
  
6388
 
  if ((argc < 0) || (argc > 1)) {
6389
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6390
 
  }
6391
 
  if (argc > 0) {
6392
 
    res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
6393
 
    if (!SWIG_IsOK(res1)) {
6394
 
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OGRFeatureDefnShadow" "', argument " "1"" of type '" "char const *""'");
6395
 
    }
6396
 
    arg1 = buf1;
6397
 
  }
6398
 
  {
6399
 
    CPLErrorReset();
6400
 
    result = (OGRFeatureDefnShadow *)new_OGRFeatureDefnShadow((char const *)arg1);DATA_PTR(self) = result;
6401
 
    
6402
 
    CPLErr eclass = CPLGetLastErrorType();
6403
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6404
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6405
 
      
6406
 
    }
6407
 
  }
6408
 
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
6409
 
  return self;
6410
 
fail:
6411
 
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
6412
 
  return Qnil;
6413
 
}
6414
 
 
6415
 
 
6416
 
SWIGINTERN VALUE
6417
 
_wrap_FeatureDefn_get_name(int argc, VALUE *argv, VALUE self) {
6418
 
  OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
6419
 
  char *result = 0 ;
6420
 
  void *argp1 = 0 ;
6421
 
  int res1 = 0 ;
6422
 
  VALUE vresult = Qnil;
6423
 
  
6424
 
  if ((argc < 0) || (argc > 0)) {
6425
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6426
 
  }
6427
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 |  0 );
6428
 
  if (!SWIG_IsOK(res1)) {
6429
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetName" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'"); 
6430
 
  }
6431
 
  arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
6432
 
  {
6433
 
    CPLErrorReset();
6434
 
    result = (char *)OGRFeatureDefnShadow_GetName(arg1);
6435
 
    CPLErr eclass = CPLGetLastErrorType();
6436
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6437
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6438
 
      
6439
 
    }
6440
 
  }
6441
 
  vresult = SWIG_FromCharPtr(result);
6442
 
  return vresult;
6443
 
fail:
6444
 
  return Qnil;
6445
 
}
6446
 
 
6447
 
 
6448
 
SWIGINTERN VALUE
6449
 
_wrap_FeatureDefn_get_field_count(int argc, VALUE *argv, VALUE self) {
6450
 
  OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
6451
 
  int result;
6452
 
  void *argp1 = 0 ;
6453
 
  int res1 = 0 ;
6454
 
  VALUE vresult = Qnil;
6455
 
  
6456
 
  if ((argc < 0) || (argc > 0)) {
6457
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6458
 
  }
6459
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 |  0 );
6460
 
  if (!SWIG_IsOK(res1)) {
6461
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetFieldCount" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'"); 
6462
 
  }
6463
 
  arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
6464
 
  {
6465
 
    CPLErrorReset();
6466
 
    result = (int)OGRFeatureDefnShadow_GetFieldCount(arg1);
6467
 
    CPLErr eclass = CPLGetLastErrorType();
6468
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6469
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6470
 
      
6471
 
    }
6472
 
  }
6473
 
  vresult = SWIG_From_int(static_cast< int >(result));
6474
 
  return vresult;
6475
 
fail:
6476
 
  return Qnil;
6477
 
}
6478
 
 
6479
 
 
6480
 
SWIGINTERN VALUE
6481
 
_wrap_FeatureDefn_get_field_defn(int argc, VALUE *argv, VALUE self) {
6482
 
  OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
6483
 
  int arg2 ;
6484
 
  OGRFieldDefnShadow *result = 0 ;
6485
 
  void *argp1 = 0 ;
6486
 
  int res1 = 0 ;
6487
 
  int val2 ;
6488
 
  int ecode2 = 0 ;
6489
 
  VALUE vresult = Qnil;
6490
 
  
6491
 
  if ((argc < 1) || (argc > 1)) {
6492
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6493
 
  }
6494
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 |  0 );
6495
 
  if (!SWIG_IsOK(res1)) {
6496
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetFieldDefn" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'"); 
6497
 
  }
6498
 
  arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
6499
 
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
6500
 
  if (!SWIG_IsOK(ecode2)) {
6501
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetFieldDefn" "', argument " "2"" of type '" "int""'");
6502
 
  } 
6503
 
  arg2 = static_cast< int >(val2);
6504
 
  {
6505
 
    CPLErrorReset();
6506
 
    result = (OGRFieldDefnShadow *)OGRFeatureDefnShadow_GetFieldDefn(arg1,arg2);
6507
 
    CPLErr eclass = CPLGetLastErrorType();
6508
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6509
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6510
 
      
6511
 
    }
6512
 
  }
6513
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRFieldDefnShadow, 0 |  0 );
6514
 
  return vresult;
6515
 
fail:
6516
 
  return Qnil;
6517
 
}
6518
 
 
6519
 
 
6520
 
SWIGINTERN VALUE
6521
 
_wrap_FeatureDefn_get_field_index(int argc, VALUE *argv, VALUE self) {
6522
 
  OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
6523
 
  char *arg2 = (char *) 0 ;
6524
 
  int result;
6525
 
  void *argp1 = 0 ;
6526
 
  int res1 = 0 ;
6527
 
  int res2 ;
6528
 
  char *buf2 = 0 ;
6529
 
  int alloc2 = 0 ;
6530
 
  VALUE vresult = Qnil;
6531
 
  
6532
 
  if ((argc < 1) || (argc > 1)) {
6533
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6534
 
  }
6535
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 |  0 );
6536
 
  if (!SWIG_IsOK(res1)) {
6537
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetFieldIndex" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'"); 
6538
 
  }
6539
 
  arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
6540
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
6541
 
  if (!SWIG_IsOK(res2)) {
6542
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetFieldIndex" "', argument " "2"" of type '" "char const *""'");
6543
 
  }
6544
 
  arg2 = buf2;
6545
 
  {
6546
 
    CPLErrorReset();
6547
 
    result = (int)OGRFeatureDefnShadow_GetFieldIndex(arg1,(char const *)arg2);
6548
 
    CPLErr eclass = CPLGetLastErrorType();
6549
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6550
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6551
 
      
6552
 
    }
6553
 
  }
6554
 
  vresult = SWIG_From_int(static_cast< int >(result));
6555
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6556
 
  return vresult;
6557
 
fail:
6558
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6559
 
  return Qnil;
6560
 
}
6561
 
 
6562
 
 
6563
 
SWIGINTERN VALUE
6564
 
_wrap_FeatureDefn_add_field_defn(int argc, VALUE *argv, VALUE self) {
6565
 
  OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
6566
 
  OGRFieldDefnShadow *arg2 = (OGRFieldDefnShadow *) 0 ;
6567
 
  void *argp1 = 0 ;
6568
 
  int res1 = 0 ;
6569
 
  void *argp2 = 0 ;
6570
 
  int res2 = 0 ;
6571
 
  
6572
 
  if ((argc < 1) || (argc > 1)) {
6573
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6574
 
  }
6575
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 |  0 );
6576
 
  if (!SWIG_IsOK(res1)) {
6577
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddFieldDefn" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'"); 
6578
 
  }
6579
 
  arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
6580
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRFieldDefnShadow, 0 |  0 );
6581
 
  if (!SWIG_IsOK(res2)) {
6582
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddFieldDefn" "', argument " "2"" of type '" "OGRFieldDefnShadow *""'"); 
6583
 
  }
6584
 
  arg2 = reinterpret_cast< OGRFieldDefnShadow * >(argp2);
6585
 
  {
6586
 
    CPLErrorReset();
6587
 
    OGRFeatureDefnShadow_AddFieldDefn(arg1,arg2);
6588
 
    CPLErr eclass = CPLGetLastErrorType();
6589
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6590
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6591
 
      
6592
 
    }
6593
 
  }
6594
 
  return Qnil;
6595
 
fail:
6596
 
  return Qnil;
6597
 
}
6598
 
 
6599
 
 
6600
 
SWIGINTERN VALUE
6601
 
_wrap_FeatureDefn_get_geom_type(int argc, VALUE *argv, VALUE self) {
6602
 
  OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
6603
 
  OGRwkbGeometryType result;
6604
 
  void *argp1 = 0 ;
6605
 
  int res1 = 0 ;
6606
 
  VALUE vresult = Qnil;
6607
 
  
6608
 
  if ((argc < 0) || (argc > 0)) {
6609
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6610
 
  }
6611
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 |  0 );
6612
 
  if (!SWIG_IsOK(res1)) {
6613
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetGeomType" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'"); 
6614
 
  }
6615
 
  arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
6616
 
  {
6617
 
    CPLErrorReset();
6618
 
    result = (OGRwkbGeometryType)OGRFeatureDefnShadow_GetGeomType(arg1);
6619
 
    CPLErr eclass = CPLGetLastErrorType();
6620
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6621
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6622
 
      
6623
 
    }
6624
 
  }
6625
 
  vresult = SWIG_From_int(static_cast< int >(result));
6626
 
  return vresult;
6627
 
fail:
6628
 
  return Qnil;
6629
 
}
6630
 
 
6631
 
 
6632
 
SWIGINTERN VALUE
6633
 
_wrap_FeatureDefn_set_geom_type(int argc, VALUE *argv, VALUE self) {
6634
 
  OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
6635
 
  OGRwkbGeometryType arg2 ;
6636
 
  void *argp1 = 0 ;
6637
 
  int res1 = 0 ;
6638
 
  
6639
 
  if ((argc < 1) || (argc > 1)) {
6640
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6641
 
  }
6642
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 |  0 );
6643
 
  if (!SWIG_IsOK(res1)) {
6644
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetGeomType" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'"); 
6645
 
  }
6646
 
  arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
6647
 
  {
6648
 
    /* %typemap(in) CPLErr */
6649
 
    arg2 = (OGRwkbGeometryType) NUM2INT(argv[0]);
6650
 
  }
6651
 
  {
6652
 
    CPLErrorReset();
6653
 
    OGRFeatureDefnShadow_SetGeomType(arg1,arg2);
6654
 
    CPLErr eclass = CPLGetLastErrorType();
6655
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6656
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6657
 
      
6658
 
    }
6659
 
  }
6660
 
  return Qnil;
6661
 
fail:
6662
 
  return Qnil;
6663
 
}
6664
 
 
6665
 
 
6666
 
SWIGINTERN VALUE
6667
 
_wrap_FeatureDefn_get_reference_count(int argc, VALUE *argv, VALUE self) {
6668
 
  OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
6669
 
  int result;
6670
 
  void *argp1 = 0 ;
6671
 
  int res1 = 0 ;
6672
 
  VALUE vresult = Qnil;
6673
 
  
6674
 
  if ((argc < 0) || (argc > 0)) {
6675
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6676
 
  }
6677
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFeatureDefnShadow, 0 |  0 );
6678
 
  if (!SWIG_IsOK(res1)) {
6679
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetReferenceCount" "', argument " "1"" of type '" "OGRFeatureDefnShadow *""'"); 
6680
 
  }
6681
 
  arg1 = reinterpret_cast< OGRFeatureDefnShadow * >(argp1);
6682
 
  {
6683
 
    CPLErrorReset();
6684
 
    result = (int)OGRFeatureDefnShadow_GetReferenceCount(arg1);
6685
 
    CPLErr eclass = CPLGetLastErrorType();
6686
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6687
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6688
 
      
6689
 
    }
6690
 
  }
6691
 
  vresult = SWIG_From_int(static_cast< int >(result));
6692
 
  return vresult;
6693
 
fail:
6694
 
  return Qnil;
6695
 
}
6696
 
 
6697
 
 
6698
 
swig_class cFieldDefn;
6699
 
 
6700
 
SWIGINTERN void delete_OGRFieldDefnShadow(OGRFieldDefnShadow *self){
6701
 
    OGR_Fld_Destroy(self);
6702
 
  }
6703
 
SWIGINTERN void
6704
 
free_OGRFieldDefnShadow(OGRFieldDefnShadow *arg1) {
6705
 
    delete_OGRFieldDefnShadow(arg1);
6706
 
}
6707
 
 
6708
 
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
6709
 
SWIGINTERN VALUE
6710
 
_wrap_FieldDefn_allocate(VALUE self) {
6711
 
#else
6712
 
  SWIGINTERN VALUE
6713
 
  _wrap_FieldDefn_allocate(int argc, VALUE *argv, VALUE self) {
6714
 
#endif
6715
 
    
6716
 
    
6717
 
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OGRFieldDefnShadow);
6718
 
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
6719
 
    rb_obj_call_init(vresult, argc, argv);
6720
 
#endif
6721
 
    return vresult;
6722
 
  }
6723
 
  
6724
 
 
6725
 
SWIGINTERN VALUE
6726
 
_wrap_new_FieldDefn(int argc, VALUE *argv, VALUE self) {
6727
 
  char *arg1 = (char *) "unnamed" ;
6728
 
  OGRFieldType arg2 = (OGRFieldType) OFTString ;
6729
 
  OGRFieldDefnShadow *result = 0 ;
6730
 
  int res1 ;
6731
 
  char *buf1 = 0 ;
6732
 
  int alloc1 = 0 ;
6733
 
  char *kwnames[] = {
6734
 
    "name","field_type", NULL 
6735
 
  };
6736
 
  
6737
 
  if ((argc < 0) || (argc > 2)) {
6738
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6739
 
  }
6740
 
  if (argc > 0) {
6741
 
    res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
6742
 
    if (!SWIG_IsOK(res1)) {
6743
 
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OGRFieldDefnShadow" "', argument " "1"" of type '" "char const *""'");
6744
 
    }
6745
 
    arg1 = buf1;
6746
 
  }
6747
 
  if (argc > 1) {
6748
 
    {
6749
 
      /* %typemap(in) CPLErr */
6750
 
      arg2 = (OGRFieldType) NUM2INT(argv[1]);
6751
 
    }
6752
 
  }
6753
 
  {
6754
 
    CPLErrorReset();
6755
 
    result = (OGRFieldDefnShadow *)new_OGRFieldDefnShadow((char const *)arg1,arg2);DATA_PTR(self) = result;
6756
 
    
6757
 
    CPLErr eclass = CPLGetLastErrorType();
6758
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6759
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6760
 
      
6761
 
    }
6762
 
  }
6763
 
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
6764
 
  return self;
6765
 
fail:
6766
 
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
6767
 
  return Qnil;
6768
 
}
6769
 
 
6770
 
 
6771
 
SWIGINTERN VALUE
6772
 
_wrap_FieldDefn_get_name(int argc, VALUE *argv, VALUE self) {
6773
 
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
6774
 
  char *result = 0 ;
6775
 
  void *argp1 = 0 ;
6776
 
  int res1 = 0 ;
6777
 
  VALUE vresult = Qnil;
6778
 
  
6779
 
  if ((argc < 0) || (argc > 0)) {
6780
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6781
 
  }
6782
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 |  0 );
6783
 
  if (!SWIG_IsOK(res1)) {
6784
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetName" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'"); 
6785
 
  }
6786
 
  arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
6787
 
  {
6788
 
    CPLErrorReset();
6789
 
    result = (char *)OGRFieldDefnShadow_GetName(arg1);
6790
 
    CPLErr eclass = CPLGetLastErrorType();
6791
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6792
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6793
 
      
6794
 
    }
6795
 
  }
6796
 
  vresult = SWIG_FromCharPtr(result);
6797
 
  return vresult;
6798
 
fail:
6799
 
  return Qnil;
6800
 
}
6801
 
 
6802
 
 
6803
 
SWIGINTERN VALUE
6804
 
_wrap_FieldDefn_get_name_ref(int argc, VALUE *argv, VALUE self) {
6805
 
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
6806
 
  char *result = 0 ;
6807
 
  void *argp1 = 0 ;
6808
 
  int res1 = 0 ;
6809
 
  VALUE vresult = Qnil;
6810
 
  
6811
 
  if ((argc < 0) || (argc > 0)) {
6812
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6813
 
  }
6814
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 |  0 );
6815
 
  if (!SWIG_IsOK(res1)) {
6816
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetNameRef" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'"); 
6817
 
  }
6818
 
  arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
6819
 
  {
6820
 
    CPLErrorReset();
6821
 
    result = (char *)OGRFieldDefnShadow_GetNameRef(arg1);
6822
 
    CPLErr eclass = CPLGetLastErrorType();
6823
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6824
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6825
 
      
6826
 
    }
6827
 
  }
6828
 
  vresult = SWIG_FromCharPtr(result);
6829
 
  return vresult;
6830
 
fail:
6831
 
  return Qnil;
6832
 
}
6833
 
 
6834
 
 
6835
 
SWIGINTERN VALUE
6836
 
_wrap_FieldDefn_set_name(int argc, VALUE *argv, VALUE self) {
6837
 
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
6838
 
  char *arg2 = (char *) 0 ;
6839
 
  void *argp1 = 0 ;
6840
 
  int res1 = 0 ;
6841
 
  int res2 ;
6842
 
  char *buf2 = 0 ;
6843
 
  int alloc2 = 0 ;
6844
 
  
6845
 
  if ((argc < 1) || (argc > 1)) {
6846
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6847
 
  }
6848
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 |  0 );
6849
 
  if (!SWIG_IsOK(res1)) {
6850
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetName" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'"); 
6851
 
  }
6852
 
  arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
6853
 
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
6854
 
  if (!SWIG_IsOK(res2)) {
6855
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetName" "', argument " "2"" of type '" "char const *""'");
6856
 
  }
6857
 
  arg2 = buf2;
6858
 
  {
6859
 
    CPLErrorReset();
6860
 
    OGRFieldDefnShadow_SetName(arg1,(char const *)arg2);
6861
 
    CPLErr eclass = CPLGetLastErrorType();
6862
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6863
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6864
 
      
6865
 
    }
6866
 
  }
6867
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6868
 
  return Qnil;
6869
 
fail:
6870
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6871
 
  return Qnil;
6872
 
}
6873
 
 
6874
 
 
6875
 
SWIGINTERN VALUE
6876
 
_wrap_FieldDefn_get_type(int argc, VALUE *argv, VALUE self) {
6877
 
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
6878
 
  OGRFieldType result;
6879
 
  void *argp1 = 0 ;
6880
 
  int res1 = 0 ;
6881
 
  VALUE vresult = Qnil;
6882
 
  
6883
 
  if ((argc < 0) || (argc > 0)) {
6884
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6885
 
  }
6886
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 |  0 );
6887
 
  if (!SWIG_IsOK(res1)) {
6888
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetType" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'"); 
6889
 
  }
6890
 
  arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
6891
 
  {
6892
 
    CPLErrorReset();
6893
 
    result = (OGRFieldType)OGRFieldDefnShadow_GetType(arg1);
6894
 
    CPLErr eclass = CPLGetLastErrorType();
6895
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6896
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6897
 
      
6898
 
    }
6899
 
  }
6900
 
  vresult = SWIG_From_int(static_cast< int >(result));
6901
 
  return vresult;
6902
 
fail:
6903
 
  return Qnil;
6904
 
}
6905
 
 
6906
 
 
6907
 
SWIGINTERN VALUE
6908
 
_wrap_FieldDefn_set_type(int argc, VALUE *argv, VALUE self) {
6909
 
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
6910
 
  OGRFieldType arg2 ;
6911
 
  void *argp1 = 0 ;
6912
 
  int res1 = 0 ;
6913
 
  
6914
 
  if ((argc < 1) || (argc > 1)) {
6915
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6916
 
  }
6917
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 |  0 );
6918
 
  if (!SWIG_IsOK(res1)) {
6919
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetType" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'"); 
6920
 
  }
6921
 
  arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
6922
 
  {
6923
 
    /* %typemap(in) CPLErr */
6924
 
    arg2 = (OGRFieldType) NUM2INT(argv[0]);
6925
 
  }
6926
 
  {
6927
 
    CPLErrorReset();
6928
 
    OGRFieldDefnShadow_SetType(arg1,arg2);
6929
 
    CPLErr eclass = CPLGetLastErrorType();
6930
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6931
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6932
 
      
6933
 
    }
6934
 
  }
6935
 
  return Qnil;
6936
 
fail:
6937
 
  return Qnil;
6938
 
}
6939
 
 
6940
 
 
6941
 
SWIGINTERN VALUE
6942
 
_wrap_FieldDefn_get_justify(int argc, VALUE *argv, VALUE self) {
6943
 
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
6944
 
  OGRJustification result;
6945
 
  void *argp1 = 0 ;
6946
 
  int res1 = 0 ;
6947
 
  VALUE vresult = Qnil;
6948
 
  
6949
 
  if ((argc < 0) || (argc > 0)) {
6950
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6951
 
  }
6952
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 |  0 );
6953
 
  if (!SWIG_IsOK(res1)) {
6954
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetJustify" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'"); 
6955
 
  }
6956
 
  arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
6957
 
  {
6958
 
    CPLErrorReset();
6959
 
    result = (OGRJustification)OGRFieldDefnShadow_GetJustify(arg1);
6960
 
    CPLErr eclass = CPLGetLastErrorType();
6961
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6962
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6963
 
      
6964
 
    }
6965
 
  }
6966
 
  vresult = SWIG_From_int(static_cast< int >(result));
6967
 
  return vresult;
6968
 
fail:
6969
 
  return Qnil;
6970
 
}
6971
 
 
6972
 
 
6973
 
SWIGINTERN VALUE
6974
 
_wrap_FieldDefn_set_justify(int argc, VALUE *argv, VALUE self) {
6975
 
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
6976
 
  OGRJustification arg2 ;
6977
 
  void *argp1 = 0 ;
6978
 
  int res1 = 0 ;
6979
 
  
6980
 
  if ((argc < 1) || (argc > 1)) {
6981
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6982
 
  }
6983
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 |  0 );
6984
 
  if (!SWIG_IsOK(res1)) {
6985
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetJustify" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'"); 
6986
 
  }
6987
 
  arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
6988
 
  {
6989
 
    /* %typemap(in) CPLErr */
6990
 
    arg2 = (OGRJustification) NUM2INT(argv[0]);
6991
 
  }
6992
 
  {
6993
 
    CPLErrorReset();
6994
 
    OGRFieldDefnShadow_SetJustify(arg1,arg2);
6995
 
    CPLErr eclass = CPLGetLastErrorType();
6996
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
6997
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
6998
 
      
6999
 
    }
7000
 
  }
7001
 
  return Qnil;
7002
 
fail:
7003
 
  return Qnil;
7004
 
}
7005
 
 
7006
 
 
7007
 
SWIGINTERN VALUE
7008
 
_wrap_FieldDefn_get_width(int argc, VALUE *argv, VALUE self) {
7009
 
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
7010
 
  int result;
7011
 
  void *argp1 = 0 ;
7012
 
  int res1 = 0 ;
7013
 
  VALUE vresult = Qnil;
7014
 
  
7015
 
  if ((argc < 0) || (argc > 0)) {
7016
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7017
 
  }
7018
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 |  0 );
7019
 
  if (!SWIG_IsOK(res1)) {
7020
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetWidth" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'"); 
7021
 
  }
7022
 
  arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
7023
 
  {
7024
 
    CPLErrorReset();
7025
 
    result = (int)OGRFieldDefnShadow_GetWidth(arg1);
7026
 
    CPLErr eclass = CPLGetLastErrorType();
7027
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7028
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7029
 
      
7030
 
    }
7031
 
  }
7032
 
  vresult = SWIG_From_int(static_cast< int >(result));
7033
 
  return vresult;
7034
 
fail:
7035
 
  return Qnil;
7036
 
}
7037
 
 
7038
 
 
7039
 
SWIGINTERN VALUE
7040
 
_wrap_FieldDefn_set_width(int argc, VALUE *argv, VALUE self) {
7041
 
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
7042
 
  int arg2 ;
7043
 
  void *argp1 = 0 ;
7044
 
  int res1 = 0 ;
7045
 
  int val2 ;
7046
 
  int ecode2 = 0 ;
7047
 
  
7048
 
  if ((argc < 1) || (argc > 1)) {
7049
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7050
 
  }
7051
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 |  0 );
7052
 
  if (!SWIG_IsOK(res1)) {
7053
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetWidth" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'"); 
7054
 
  }
7055
 
  arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
7056
 
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
7057
 
  if (!SWIG_IsOK(ecode2)) {
7058
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SetWidth" "', argument " "2"" of type '" "int""'");
7059
 
  } 
7060
 
  arg2 = static_cast< int >(val2);
7061
 
  {
7062
 
    CPLErrorReset();
7063
 
    OGRFieldDefnShadow_SetWidth(arg1,arg2);
7064
 
    CPLErr eclass = CPLGetLastErrorType();
7065
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7066
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7067
 
      
7068
 
    }
7069
 
  }
7070
 
  return Qnil;
7071
 
fail:
7072
 
  return Qnil;
7073
 
}
7074
 
 
7075
 
 
7076
 
SWIGINTERN VALUE
7077
 
_wrap_FieldDefn_get_precision(int argc, VALUE *argv, VALUE self) {
7078
 
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
7079
 
  int result;
7080
 
  void *argp1 = 0 ;
7081
 
  int res1 = 0 ;
7082
 
  VALUE vresult = Qnil;
7083
 
  
7084
 
  if ((argc < 0) || (argc > 0)) {
7085
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7086
 
  }
7087
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 |  0 );
7088
 
  if (!SWIG_IsOK(res1)) {
7089
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetPrecision" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'"); 
7090
 
  }
7091
 
  arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
7092
 
  {
7093
 
    CPLErrorReset();
7094
 
    result = (int)OGRFieldDefnShadow_GetPrecision(arg1);
7095
 
    CPLErr eclass = CPLGetLastErrorType();
7096
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7097
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7098
 
      
7099
 
    }
7100
 
  }
7101
 
  vresult = SWIG_From_int(static_cast< int >(result));
7102
 
  return vresult;
7103
 
fail:
7104
 
  return Qnil;
7105
 
}
7106
 
 
7107
 
 
7108
 
SWIGINTERN VALUE
7109
 
_wrap_FieldDefn_set_precision(int argc, VALUE *argv, VALUE self) {
7110
 
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
7111
 
  int arg2 ;
7112
 
  void *argp1 = 0 ;
7113
 
  int res1 = 0 ;
7114
 
  int val2 ;
7115
 
  int ecode2 = 0 ;
7116
 
  
7117
 
  if ((argc < 1) || (argc > 1)) {
7118
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7119
 
  }
7120
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 |  0 );
7121
 
  if (!SWIG_IsOK(res1)) {
7122
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetPrecision" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'"); 
7123
 
  }
7124
 
  arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
7125
 
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
7126
 
  if (!SWIG_IsOK(ecode2)) {
7127
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SetPrecision" "', argument " "2"" of type '" "int""'");
7128
 
  } 
7129
 
  arg2 = static_cast< int >(val2);
7130
 
  {
7131
 
    CPLErrorReset();
7132
 
    OGRFieldDefnShadow_SetPrecision(arg1,arg2);
7133
 
    CPLErr eclass = CPLGetLastErrorType();
7134
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7135
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7136
 
      
7137
 
    }
7138
 
  }
7139
 
  return Qnil;
7140
 
fail:
7141
 
  return Qnil;
7142
 
}
7143
 
 
7144
 
 
7145
 
SWIGINTERN VALUE
7146
 
_wrap_FieldDefn_get_field_type_name(int argc, VALUE *argv, VALUE self) {
7147
 
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
7148
 
  OGRFieldType arg2 ;
7149
 
  char *result = 0 ;
7150
 
  void *argp1 = 0 ;
7151
 
  int res1 = 0 ;
7152
 
  VALUE vresult = Qnil;
7153
 
  
7154
 
  if ((argc < 1) || (argc > 1)) {
7155
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7156
 
  }
7157
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRFieldDefnShadow, 0 |  0 );
7158
 
  if (!SWIG_IsOK(res1)) {
7159
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetFieldTypeName" "', argument " "1"" of type '" "OGRFieldDefnShadow *""'"); 
7160
 
  }
7161
 
  arg1 = reinterpret_cast< OGRFieldDefnShadow * >(argp1);
7162
 
  {
7163
 
    /* %typemap(in) CPLErr */
7164
 
    arg2 = (OGRFieldType) NUM2INT(argv[0]);
7165
 
  }
7166
 
  {
7167
 
    CPLErrorReset();
7168
 
    result = (char *)OGRFieldDefnShadow_GetFieldTypeName(arg1,arg2);
7169
 
    CPLErr eclass = CPLGetLastErrorType();
7170
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7171
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7172
 
      
7173
 
    }
7174
 
  }
7175
 
  vresult = SWIG_FromCharPtr(result);
7176
 
  return vresult;
7177
 
fail:
7178
 
  return Qnil;
7179
 
}
7180
 
 
7181
 
 
7182
 
SWIGINTERN VALUE
7183
 
_wrap_create_geometry_from_wkb(int argc, VALUE *argv, VALUE self) {
7184
 
  int arg1 ;
7185
 
  char *arg2 = (char *) 0 ;
7186
 
  OSRSpatialReferenceShadow *arg3 = (OSRSpatialReferenceShadow *) NULL ;
7187
 
  OGRGeometryShadow *result = 0 ;
7188
 
  int res1 ;
7189
 
  char *buf1 = 0 ;
7190
 
  size_t size1 = 0 ;
7191
 
  int alloc1 = 0 ;
7192
 
  void *argp3 = 0 ;
7193
 
  int res3 = 0 ;
7194
 
  char *kwnames[] = {
7195
 
    "len","reference", NULL 
7196
 
  };
7197
 
  VALUE vresult = Qnil;
7198
 
  
7199
 
  if ((argc < 1) || (argc > 2)) {
7200
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7201
 
  }
7202
 
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, &size1, &alloc1);
7203
 
  if (!SWIG_IsOK(res1)) {
7204
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateGeometryFromWkb" "', argument " "1"" of type '" "int""'");
7205
 
  }  
7206
 
  arg2 = static_cast< char * >(buf1) ;
7207
 
  arg1 = static_cast< int >(size1 - 1) ;
7208
 
  if (argc > 1) {
7209
 
    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 |  0 );
7210
 
    if (!SWIG_IsOK(res3)) {
7211
 
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CreateGeometryFromWkb" "', argument " "3"" of type '" "OSRSpatialReferenceShadow *""'"); 
7212
 
    }
7213
 
    arg3 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp3);
7214
 
  }
7215
 
  {
7216
 
    CPLErrorReset();
7217
 
    result = (OGRGeometryShadow *)CreateGeometryFromWkb(arg1,arg2,arg3);
7218
 
    CPLErr eclass = CPLGetLastErrorType();
7219
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7220
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7221
 
      
7222
 
    }
7223
 
  }
7224
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN |  0 );
7225
 
  return vresult;
7226
 
fail:
7227
 
  return Qnil;
7228
 
}
7229
 
 
7230
 
 
7231
 
SWIGINTERN VALUE
7232
 
_wrap_create_geometry_from_wkt(int argc, VALUE *argv, VALUE self) {
7233
 
  char **arg1 = (char **) 0 ;
7234
 
  OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) NULL ;
7235
 
  OGRGeometryShadow *result = 0 ;
7236
 
  char *val1 = 0 ;
7237
 
  void *argp2 = 0 ;
7238
 
  int res2 = 0 ;
7239
 
  char *kwnames[] = {
7240
 
    "val","reference", NULL 
7241
 
  };
7242
 
  VALUE vresult = Qnil;
7243
 
  
7244
 
  if ((argc < 1) || (argc > 2)) {
7245
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7246
 
  }
7247
 
  {
7248
 
    /* %typemap(in) char ** ( char *val1=0 ) */
7249
 
    
7250
 
    val1 = StringValuePtr(argv[0]);
7251
 
    arg1 = &val1;
7252
 
  }
7253
 
  if (argc > 1) {
7254
 
    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 |  0 );
7255
 
    if (!SWIG_IsOK(res2)) {
7256
 
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CreateGeometryFromWkt" "', argument " "2"" of type '" "OSRSpatialReferenceShadow *""'"); 
7257
 
    }
7258
 
    arg2 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp2);
7259
 
  }
7260
 
  {
7261
 
    CPLErrorReset();
7262
 
    result = (OGRGeometryShadow *)CreateGeometryFromWkt(arg1,arg2);
7263
 
    CPLErr eclass = CPLGetLastErrorType();
7264
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7265
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7266
 
      
7267
 
    }
7268
 
  }
7269
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN |  0 );
7270
 
  return vresult;
7271
 
fail:
7272
 
  return Qnil;
7273
 
}
7274
 
 
7275
 
 
7276
 
SWIGINTERN VALUE
7277
 
_wrap_create_geometry_from_gml(int argc, VALUE *argv, VALUE self) {
7278
 
  char *arg1 = (char *) 0 ;
7279
 
  OGRGeometryShadow *result = 0 ;
7280
 
  int res1 ;
7281
 
  char *buf1 = 0 ;
7282
 
  int alloc1 = 0 ;
7283
 
  VALUE vresult = Qnil;
7284
 
  
7285
 
  if ((argc < 1) || (argc > 1)) {
7286
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7287
 
  }
7288
 
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
7289
 
  if (!SWIG_IsOK(res1)) {
7290
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateGeometryFromGML" "', argument " "1"" of type '" "char const *""'");
7291
 
  }
7292
 
  arg1 = buf1;
7293
 
  {
7294
 
    CPLErrorReset();
7295
 
    result = (OGRGeometryShadow *)CreateGeometryFromGML((char const *)arg1);
7296
 
    CPLErr eclass = CPLGetLastErrorType();
7297
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7298
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7299
 
      
7300
 
    }
7301
 
  }
7302
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN |  0 );
7303
 
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
7304
 
  return vresult;
7305
 
fail:
7306
 
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
7307
 
  return Qnil;
7308
 
}
7309
 
 
7310
 
 
7311
 
swig_class cGeometry;
7312
 
 
7313
 
SWIGINTERN void delete_OGRGeometryShadow(OGRGeometryShadow *self){
7314
 
    OGR_G_DestroyGeometry( self );
7315
 
  }
7316
 
SWIGINTERN void
7317
 
free_OGRGeometryShadow(OGRGeometryShadow *arg1) {
7318
 
    delete_OGRGeometryShadow(arg1);
7319
 
}
7320
 
 
7321
 
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
7322
 
SWIGINTERN VALUE
7323
 
_wrap_Geometry_allocate(VALUE self) {
7324
 
#else
7325
 
  SWIGINTERN VALUE
7326
 
  _wrap_Geometry_allocate(int argc, VALUE *argv, VALUE self) {
7327
 
#endif
7328
 
    
7329
 
    
7330
 
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_OGRGeometryShadow);
7331
 
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
7332
 
    rb_obj_call_init(vresult, argc, argv);
7333
 
#endif
7334
 
    return vresult;
7335
 
  }
7336
 
  
7337
 
 
7338
 
SWIGINTERN VALUE
7339
 
_wrap_new_Geometry(int argc, VALUE *argv, VALUE self) {
7340
 
  OGRwkbGeometryType arg1 = (OGRwkbGeometryType) wkbUnknown ;
7341
 
  char *arg2 = (char *) 0 ;
7342
 
  int arg3 = (int) 0 ;
7343
 
  char *arg4 = (char *) 0 ;
7344
 
  char *arg5 = (char *) 0 ;
7345
 
  OGRGeometryShadow *result = 0 ;
7346
 
  int res2 ;
7347
 
  char *buf2 = 0 ;
7348
 
  int alloc2 = 0 ;
7349
 
  int val3 ;
7350
 
  int ecode3 = 0 ;
7351
 
  int res4 ;
7352
 
  char *buf4 = 0 ;
7353
 
  int alloc4 = 0 ;
7354
 
  int res5 ;
7355
 
  char *buf5 = 0 ;
7356
 
  int alloc5 = 0 ;
7357
 
  char *kwnames[] = {
7358
 
    "type","wkt","wkb","wkb_buf","gml", NULL 
7359
 
  };
7360
 
  
7361
 
  if ((argc < 0) || (argc > 5)) {
7362
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7363
 
  }
7364
 
  if (argc > 0) {
7365
 
    {
7366
 
      /* %typemap(in) CPLErr */
7367
 
      arg1 = (OGRwkbGeometryType) NUM2INT(argv[0]);
7368
 
    }
7369
 
  }
7370
 
  if (argc > 1) {
7371
 
    res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
7372
 
    if (!SWIG_IsOK(res2)) {
7373
 
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OGRGeometryShadow" "', argument " "2"" of type '" "char *""'");
7374
 
    }
7375
 
    arg2 = buf2;
7376
 
  }
7377
 
  if (argc > 2) {
7378
 
    ecode3 = SWIG_AsVal_int(argv[2], &val3);
7379
 
    if (!SWIG_IsOK(ecode3)) {
7380
 
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OGRGeometryShadow" "', argument " "3"" of type '" "int""'");
7381
 
    } 
7382
 
    arg3 = static_cast< int >(val3);
7383
 
  }
7384
 
  if (argc > 3) {
7385
 
    res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
7386
 
    if (!SWIG_IsOK(res4)) {
7387
 
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OGRGeometryShadow" "', argument " "4"" of type '" "char *""'");
7388
 
    }
7389
 
    arg4 = buf4;
7390
 
  }
7391
 
  if (argc > 4) {
7392
 
    res5 = SWIG_AsCharPtrAndSize(argv[4], &buf5, NULL, &alloc5);
7393
 
    if (!SWIG_IsOK(res5)) {
7394
 
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "OGRGeometryShadow" "', argument " "5"" of type '" "char *""'");
7395
 
    }
7396
 
    arg5 = buf5;
7397
 
  }
7398
 
  {
7399
 
    CPLErrorReset();
7400
 
    result = (OGRGeometryShadow *)new_OGRGeometryShadow(arg1,arg2,arg3,arg4,arg5);DATA_PTR(self) = result;
7401
 
    
7402
 
    CPLErr eclass = CPLGetLastErrorType();
7403
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7404
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7405
 
      
7406
 
    }
7407
 
  }
7408
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7409
 
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
7410
 
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
7411
 
  return self;
7412
 
fail:
7413
 
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7414
 
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
7415
 
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
7416
 
  return Qnil;
7417
 
}
7418
 
 
7419
 
 
7420
 
SWIGINTERN VALUE
7421
 
_wrap_Geometry_export_to_wkt(int argc, VALUE *argv, VALUE self) {
7422
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7423
 
  char **arg2 = (char **) 0 ;
7424
 
  OGRErr result;
7425
 
  void *argp1 = 0 ;
7426
 
  int res1 = 0 ;
7427
 
  char *argout2 = 0 ;
7428
 
  VALUE vresult = Qnil;
7429
 
  
7430
 
  {
7431
 
    /* %typemap(in,numinputs=0) (char **argout2) ( char *argout2=0 ) */
7432
 
    arg2 = &argout2;
7433
 
  }
7434
 
  if ((argc < 0) || (argc > 0)) {
7435
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7436
 
  }
7437
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
7438
 
  if (!SWIG_IsOK(res1)) {
7439
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExportToWkt" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
7440
 
  }
7441
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
7442
 
  {
7443
 
    CPLErrorReset();
7444
 
    result = (OGRErr)OGRGeometryShadow_ExportToWkt(arg1,arg2);
7445
 
    CPLErr eclass = CPLGetLastErrorType();
7446
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7447
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7448
 
      
7449
 
    }
7450
 
  }
7451
 
  {
7452
 
    /* %typemap(out) OGRErr */
7453
 
    if (result != 0) {
7454
 
      rb_raise(rb_eRuntimeError, OGRErrMessages(result));
7455
 
    }
7456
 
  }
7457
 
  {
7458
 
    /* %typemap(argout) (char **argout) */
7459
 
    VALUE outArg;
7460
 
    if ( arg2 ) {
7461
 
      outArg = rb_str_new2( *arg2 );
7462
 
    }
7463
 
    else {
7464
 
      outArg = Qnil;
7465
 
    }
7466
 
    
7467
 
    vresult = SWIG_Ruby_AppendOutput(vresult, outArg);
7468
 
  }
7469
 
  {
7470
 
    /* %typemap(freearg) (char **argout) */
7471
 
    
7472
 
    if ( *arg2 )
7473
 
    CPLFree( *arg2 );
7474
 
  }
7475
 
  {
7476
 
    /* %typemap(ret) OGRErr */
7477
 
    if (vresult == Qnil) {
7478
 
      vresult = INT2NUM(0);
7479
 
    }
7480
 
  }    return vresult;
7481
 
fail:
7482
 
  {
7483
 
    /* %typemap(freearg) (char **argout) */
7484
 
    
7485
 
    if ( *arg2 )
7486
 
    CPLFree( *arg2 );
7487
 
  }
7488
 
  return Qnil;
7489
 
}
7490
 
 
7491
 
 
7492
 
SWIGINTERN VALUE
7493
 
_wrap_Geometry_export_to_wkb(int argc, VALUE *argv, VALUE self) {
7494
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7495
 
  int *arg2 = (int *) 0 ;
7496
 
  char **arg3 = (char **) 0 ;
7497
 
  OGRwkbByteOrder arg4 = (OGRwkbByteOrder) wkbXDR ;
7498
 
  OGRErr result;
7499
 
  void *argp1 = 0 ;
7500
 
  int res1 = 0 ;
7501
 
  int nLen2 = 0 ;
7502
 
  char *pBuf2 = 0 ;
7503
 
  char *kwnames[] = {
7504
 
    "self","byte_order", NULL 
7505
 
  };
7506
 
  VALUE vresult = Qnil;
7507
 
  
7508
 
  {
7509
 
    /* %typemap(in,numinputs=0) (int *nLen2, char **pBuf2 ) ( int nLen2 = 0, char *pBuf2 = 0 ) */
7510
 
    arg2 = &nLen2;
7511
 
    arg3 = &pBuf2;
7512
 
  }
7513
 
  if ((argc < 0) || (argc > 1)) {
7514
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7515
 
  }
7516
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
7517
 
  if (!SWIG_IsOK(res1)) {
7518
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExportToWkb" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
7519
 
  }
7520
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
7521
 
  if (argc > 0) {
7522
 
    {
7523
 
      /* %typemap(in) CPLErr */
7524
 
      arg4 = (OGRwkbByteOrder) NUM2INT(argv[0]);
7525
 
    }
7526
 
  }
7527
 
  {
7528
 
    CPLErrorReset();
7529
 
    result = (OGRErr)OGRGeometryShadow_ExportToWkb(arg1,arg2,arg3,arg4);
7530
 
    CPLErr eclass = CPLGetLastErrorType();
7531
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7532
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7533
 
      
7534
 
    }
7535
 
  }
7536
 
  {
7537
 
    /* %typemap(out) OGRErr */
7538
 
    if (result != 0) {
7539
 
      rb_raise(rb_eRuntimeError, OGRErrMessages(result));
7540
 
    }
7541
 
  }
7542
 
  {
7543
 
    /* %typemap(argout) (int *nLen, char **pBuf ) */
7544
 
    vresult = rb_str_new(*arg3, *arg2);
7545
 
  }
7546
 
  {
7547
 
    /* %typemap(freearg) (int *nLen, char **pBuf ) */
7548
 
    if( *arg3 ) {
7549
 
      free( *arg3 );
7550
 
    }
7551
 
  }
7552
 
  {
7553
 
    /* %typemap(ret) OGRErr */
7554
 
    if (vresult == Qnil) {
7555
 
      vresult = INT2NUM(0);
7556
 
    }
7557
 
  }    return vresult;
7558
 
fail:
7559
 
  {
7560
 
    /* %typemap(freearg) (int *nLen, char **pBuf ) */
7561
 
    if( *arg3 ) {
7562
 
      free( *arg3 );
7563
 
    }
7564
 
  }
7565
 
  return Qnil;
7566
 
}
7567
 
 
7568
 
 
7569
 
SWIGINTERN VALUE
7570
 
_wrap_Geometry_export_to_gml(int argc, VALUE *argv, VALUE self) {
7571
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7572
 
  char *result = 0 ;
7573
 
  void *argp1 = 0 ;
7574
 
  int res1 = 0 ;
7575
 
  VALUE vresult = Qnil;
7576
 
  
7577
 
  if ((argc < 0) || (argc > 0)) {
7578
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7579
 
  }
7580
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
7581
 
  if (!SWIG_IsOK(res1)) {
7582
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExportToGML" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
7583
 
  }
7584
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
7585
 
  {
7586
 
    CPLErrorReset();
7587
 
    result = (char *)OGRGeometryShadow_ExportToGML(arg1);
7588
 
    CPLErr eclass = CPLGetLastErrorType();
7589
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7590
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7591
 
      
7592
 
    }
7593
 
  }
7594
 
  vresult = SWIG_FromCharPtr(result);
7595
 
  return vresult;
7596
 
fail:
7597
 
  return Qnil;
7598
 
}
7599
 
 
7600
 
 
7601
 
SWIGINTERN VALUE
7602
 
_wrap_Geometry_add_point(int argc, VALUE *argv, VALUE self) {
7603
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7604
 
  double arg2 ;
7605
 
  double arg3 ;
7606
 
  double arg4 = (double) 0 ;
7607
 
  void *argp1 = 0 ;
7608
 
  int res1 = 0 ;
7609
 
  double val2 ;
7610
 
  int ecode2 = 0 ;
7611
 
  double val3 ;
7612
 
  int ecode3 = 0 ;
7613
 
  double val4 ;
7614
 
  int ecode4 = 0 ;
7615
 
  char *kwnames[] = {
7616
 
    "self","x","y","z", NULL 
7617
 
  };
7618
 
  
7619
 
  if ((argc < 2) || (argc > 3)) {
7620
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
7621
 
  }
7622
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
7623
 
  if (!SWIG_IsOK(res1)) {
7624
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddPoint" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
7625
 
  }
7626
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
7627
 
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
7628
 
  if (!SWIG_IsOK(ecode2)) {
7629
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AddPoint" "', argument " "2"" of type '" "double""'");
7630
 
  } 
7631
 
  arg2 = static_cast< double >(val2);
7632
 
  ecode3 = SWIG_AsVal_double(argv[1], &val3);
7633
 
  if (!SWIG_IsOK(ecode3)) {
7634
 
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AddPoint" "', argument " "3"" of type '" "double""'");
7635
 
  } 
7636
 
  arg3 = static_cast< double >(val3);
7637
 
  if (argc > 2) {
7638
 
    ecode4 = SWIG_AsVal_double(argv[2], &val4);
7639
 
    if (!SWIG_IsOK(ecode4)) {
7640
 
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AddPoint" "', argument " "4"" of type '" "double""'");
7641
 
    } 
7642
 
    arg4 = static_cast< double >(val4);
7643
 
  }
7644
 
  {
7645
 
    CPLErrorReset();
7646
 
    OGRGeometryShadow_AddPoint(arg1,arg2,arg3,arg4);
7647
 
    CPLErr eclass = CPLGetLastErrorType();
7648
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7649
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7650
 
      
7651
 
    }
7652
 
  }
7653
 
  return Qnil;
7654
 
fail:
7655
 
  return Qnil;
7656
 
}
7657
 
 
7658
 
 
7659
 
SWIGINTERN VALUE
7660
 
_wrap_Geometry_add_geometry_directly(int argc, VALUE *argv, VALUE self) {
7661
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7662
 
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
7663
 
  OGRErr result;
7664
 
  void *argp1 = 0 ;
7665
 
  int res1 = 0 ;
7666
 
  int res2 = 0 ;
7667
 
  VALUE vresult = Qnil;
7668
 
  
7669
 
  if ((argc < 1) || (argc > 1)) {
7670
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7671
 
  }
7672
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
7673
 
  if (!SWIG_IsOK(res1)) {
7674
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddGeometryDirectly" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
7675
 
  }
7676
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
7677
 
  res2 = SWIG_ConvertPtr(argv[0], SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_DISOWN |  0 );
7678
 
  if (!SWIG_IsOK(res2)) {
7679
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddGeometryDirectly" "', argument " "2"" of type '" "OGRGeometryShadow *""'");
7680
 
  }
7681
 
  {
7682
 
    CPLErrorReset();
7683
 
    result = (OGRErr)OGRGeometryShadow_AddGeometryDirectly(arg1,arg2);
7684
 
    CPLErr eclass = CPLGetLastErrorType();
7685
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7686
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7687
 
      
7688
 
    }
7689
 
  }
7690
 
  {
7691
 
    /* %typemap(out) OGRErr */
7692
 
    if (result != 0) {
7693
 
      rb_raise(rb_eRuntimeError, OGRErrMessages(result));
7694
 
    }
7695
 
  }
7696
 
  {
7697
 
    /* %typemap(ret) OGRErr */
7698
 
    if (vresult == Qnil) {
7699
 
      vresult = INT2NUM(0);
7700
 
    }
7701
 
  }    return vresult;
7702
 
fail:
7703
 
  return Qnil;
7704
 
}
7705
 
 
7706
 
 
7707
 
SWIGINTERN VALUE
7708
 
_wrap_Geometry_add_geometry(int argc, VALUE *argv, VALUE self) {
7709
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7710
 
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
7711
 
  OGRErr result;
7712
 
  void *argp1 = 0 ;
7713
 
  int res1 = 0 ;
7714
 
  void *argp2 = 0 ;
7715
 
  int res2 = 0 ;
7716
 
  VALUE vresult = Qnil;
7717
 
  
7718
 
  if ((argc < 1) || (argc > 1)) {
7719
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7720
 
  }
7721
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
7722
 
  if (!SWIG_IsOK(res1)) {
7723
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddGeometry" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
7724
 
  }
7725
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
7726
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
7727
 
  if (!SWIG_IsOK(res2)) {
7728
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddGeometry" "', argument " "2"" of type '" "OGRGeometryShadow *""'"); 
7729
 
  }
7730
 
  arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
7731
 
  {
7732
 
    CPLErrorReset();
7733
 
    result = (OGRErr)OGRGeometryShadow_AddGeometry(arg1,arg2);
7734
 
    CPLErr eclass = CPLGetLastErrorType();
7735
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7736
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7737
 
      
7738
 
    }
7739
 
  }
7740
 
  {
7741
 
    /* %typemap(out) OGRErr */
7742
 
    if (result != 0) {
7743
 
      rb_raise(rb_eRuntimeError, OGRErrMessages(result));
7744
 
    }
7745
 
  }
7746
 
  {
7747
 
    /* %typemap(ret) OGRErr */
7748
 
    if (vresult == Qnil) {
7749
 
      vresult = INT2NUM(0);
7750
 
    }
7751
 
  }    return vresult;
7752
 
fail:
7753
 
  return Qnil;
7754
 
}
7755
 
 
7756
 
 
7757
 
SWIGINTERN VALUE
7758
 
_wrap_Geometry_clone(int argc, VALUE *argv, VALUE self) {
7759
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7760
 
  OGRGeometryShadow *result = 0 ;
7761
 
  void *argp1 = 0 ;
7762
 
  int res1 = 0 ;
7763
 
  VALUE vresult = Qnil;
7764
 
  
7765
 
  if ((argc < 0) || (argc > 0)) {
7766
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7767
 
  }
7768
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
7769
 
  if (!SWIG_IsOK(res1)) {
7770
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clone" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
7771
 
  }
7772
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
7773
 
  {
7774
 
    CPLErrorReset();
7775
 
    result = (OGRGeometryShadow *)OGRGeometryShadow_Clone(arg1);
7776
 
    CPLErr eclass = CPLGetLastErrorType();
7777
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7778
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7779
 
      
7780
 
    }
7781
 
  }
7782
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN |  0 );
7783
 
  return vresult;
7784
 
fail:
7785
 
  return Qnil;
7786
 
}
7787
 
 
7788
 
 
7789
 
SWIGINTERN VALUE
7790
 
_wrap_Geometry_get_geometry_type(int argc, VALUE *argv, VALUE self) {
7791
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7792
 
  OGRwkbGeometryType result;
7793
 
  void *argp1 = 0 ;
7794
 
  int res1 = 0 ;
7795
 
  VALUE vresult = Qnil;
7796
 
  
7797
 
  if ((argc < 0) || (argc > 0)) {
7798
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7799
 
  }
7800
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
7801
 
  if (!SWIG_IsOK(res1)) {
7802
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetGeometryType" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
7803
 
  }
7804
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
7805
 
  {
7806
 
    CPLErrorReset();
7807
 
    result = (OGRwkbGeometryType)OGRGeometryShadow_GetGeometryType(arg1);
7808
 
    CPLErr eclass = CPLGetLastErrorType();
7809
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7810
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7811
 
      
7812
 
    }
7813
 
  }
7814
 
  vresult = SWIG_From_int(static_cast< int >(result));
7815
 
  return vresult;
7816
 
fail:
7817
 
  return Qnil;
7818
 
}
7819
 
 
7820
 
 
7821
 
SWIGINTERN VALUE
7822
 
_wrap_Geometry_get_geometry_name(int argc, VALUE *argv, VALUE self) {
7823
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7824
 
  char *result = 0 ;
7825
 
  void *argp1 = 0 ;
7826
 
  int res1 = 0 ;
7827
 
  VALUE vresult = Qnil;
7828
 
  
7829
 
  if ((argc < 0) || (argc > 0)) {
7830
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7831
 
  }
7832
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
7833
 
  if (!SWIG_IsOK(res1)) {
7834
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetGeometryName" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
7835
 
  }
7836
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
7837
 
  {
7838
 
    CPLErrorReset();
7839
 
    result = (char *)OGRGeometryShadow_GetGeometryName(arg1);
7840
 
    CPLErr eclass = CPLGetLastErrorType();
7841
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7842
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7843
 
      
7844
 
    }
7845
 
  }
7846
 
  vresult = SWIG_FromCharPtr(result);
7847
 
  return vresult;
7848
 
fail:
7849
 
  return Qnil;
7850
 
}
7851
 
 
7852
 
 
7853
 
SWIGINTERN VALUE
7854
 
_wrap_Geometry_get_area(int argc, VALUE *argv, VALUE self) {
7855
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7856
 
  double result;
7857
 
  void *argp1 = 0 ;
7858
 
  int res1 = 0 ;
7859
 
  VALUE vresult = Qnil;
7860
 
  
7861
 
  if ((argc < 0) || (argc > 0)) {
7862
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7863
 
  }
7864
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
7865
 
  if (!SWIG_IsOK(res1)) {
7866
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetArea" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
7867
 
  }
7868
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
7869
 
  {
7870
 
    CPLErrorReset();
7871
 
    result = (double)OGRGeometryShadow_GetArea(arg1);
7872
 
    CPLErr eclass = CPLGetLastErrorType();
7873
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7874
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7875
 
      
7876
 
    }
7877
 
  }
7878
 
  vresult = SWIG_From_double(static_cast< double >(result));
7879
 
  return vresult;
7880
 
fail:
7881
 
  return Qnil;
7882
 
}
7883
 
 
7884
 
 
7885
 
SWIGINTERN VALUE
7886
 
_wrap_Geometry_get_point_count(int argc, VALUE *argv, VALUE self) {
7887
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7888
 
  int result;
7889
 
  void *argp1 = 0 ;
7890
 
  int res1 = 0 ;
7891
 
  VALUE vresult = Qnil;
7892
 
  
7893
 
  if ((argc < 0) || (argc > 0)) {
7894
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7895
 
  }
7896
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
7897
 
  if (!SWIG_IsOK(res1)) {
7898
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetPointCount" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
7899
 
  }
7900
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
7901
 
  {
7902
 
    CPLErrorReset();
7903
 
    result = (int)OGRGeometryShadow_GetPointCount(arg1);
7904
 
    CPLErr eclass = CPLGetLastErrorType();
7905
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7906
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7907
 
      
7908
 
    }
7909
 
  }
7910
 
  vresult = SWIG_From_int(static_cast< int >(result));
7911
 
  return vresult;
7912
 
fail:
7913
 
  return Qnil;
7914
 
}
7915
 
 
7916
 
 
7917
 
SWIGINTERN VALUE
7918
 
_wrap_Geometry_get_x(int argc, VALUE *argv, VALUE self) {
7919
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7920
 
  int arg2 = (int) 0 ;
7921
 
  double result;
7922
 
  void *argp1 = 0 ;
7923
 
  int res1 = 0 ;
7924
 
  int val2 ;
7925
 
  int ecode2 = 0 ;
7926
 
  char *kwnames[] = {
7927
 
    "self","point", NULL 
7928
 
  };
7929
 
  VALUE vresult = Qnil;
7930
 
  
7931
 
  if ((argc < 0) || (argc > 1)) {
7932
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7933
 
  }
7934
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
7935
 
  if (!SWIG_IsOK(res1)) {
7936
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetX" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
7937
 
  }
7938
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
7939
 
  if (argc > 0) {
7940
 
    ecode2 = SWIG_AsVal_int(argv[0], &val2);
7941
 
    if (!SWIG_IsOK(ecode2)) {
7942
 
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetX" "', argument " "2"" of type '" "int""'");
7943
 
    } 
7944
 
    arg2 = static_cast< int >(val2);
7945
 
  }
7946
 
  {
7947
 
    CPLErrorReset();
7948
 
    result = (double)OGRGeometryShadow_GetX(arg1,arg2);
7949
 
    CPLErr eclass = CPLGetLastErrorType();
7950
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7951
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7952
 
      
7953
 
    }
7954
 
  }
7955
 
  vresult = SWIG_From_double(static_cast< double >(result));
7956
 
  return vresult;
7957
 
fail:
7958
 
  return Qnil;
7959
 
}
7960
 
 
7961
 
 
7962
 
SWIGINTERN VALUE
7963
 
_wrap_Geometry_get_y(int argc, VALUE *argv, VALUE self) {
7964
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7965
 
  int arg2 = (int) 0 ;
7966
 
  double result;
7967
 
  void *argp1 = 0 ;
7968
 
  int res1 = 0 ;
7969
 
  int val2 ;
7970
 
  int ecode2 = 0 ;
7971
 
  char *kwnames[] = {
7972
 
    "self","point", NULL 
7973
 
  };
7974
 
  VALUE vresult = Qnil;
7975
 
  
7976
 
  if ((argc < 0) || (argc > 1)) {
7977
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7978
 
  }
7979
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
7980
 
  if (!SWIG_IsOK(res1)) {
7981
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetY" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
7982
 
  }
7983
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
7984
 
  if (argc > 0) {
7985
 
    ecode2 = SWIG_AsVal_int(argv[0], &val2);
7986
 
    if (!SWIG_IsOK(ecode2)) {
7987
 
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetY" "', argument " "2"" of type '" "int""'");
7988
 
    } 
7989
 
    arg2 = static_cast< int >(val2);
7990
 
  }
7991
 
  {
7992
 
    CPLErrorReset();
7993
 
    result = (double)OGRGeometryShadow_GetY(arg1,arg2);
7994
 
    CPLErr eclass = CPLGetLastErrorType();
7995
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
7996
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
7997
 
      
7998
 
    }
7999
 
  }
8000
 
  vresult = SWIG_From_double(static_cast< double >(result));
8001
 
  return vresult;
8002
 
fail:
8003
 
  return Qnil;
8004
 
}
8005
 
 
8006
 
 
8007
 
SWIGINTERN VALUE
8008
 
_wrap_Geometry_get_z(int argc, VALUE *argv, VALUE self) {
8009
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8010
 
  int arg2 = (int) 0 ;
8011
 
  double result;
8012
 
  void *argp1 = 0 ;
8013
 
  int res1 = 0 ;
8014
 
  int val2 ;
8015
 
  int ecode2 = 0 ;
8016
 
  char *kwnames[] = {
8017
 
    "self","point", NULL 
8018
 
  };
8019
 
  VALUE vresult = Qnil;
8020
 
  
8021
 
  if ((argc < 0) || (argc > 1)) {
8022
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8023
 
  }
8024
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8025
 
  if (!SWIG_IsOK(res1)) {
8026
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetZ" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8027
 
  }
8028
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8029
 
  if (argc > 0) {
8030
 
    ecode2 = SWIG_AsVal_int(argv[0], &val2);
8031
 
    if (!SWIG_IsOK(ecode2)) {
8032
 
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetZ" "', argument " "2"" of type '" "int""'");
8033
 
    } 
8034
 
    arg2 = static_cast< int >(val2);
8035
 
  }
8036
 
  {
8037
 
    CPLErrorReset();
8038
 
    result = (double)OGRGeometryShadow_GetZ(arg1,arg2);
8039
 
    CPLErr eclass = CPLGetLastErrorType();
8040
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8041
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8042
 
      
8043
 
    }
8044
 
  }
8045
 
  vresult = SWIG_From_double(static_cast< double >(result));
8046
 
  return vresult;
8047
 
fail:
8048
 
  return Qnil;
8049
 
}
8050
 
 
8051
 
 
8052
 
SWIGINTERN VALUE
8053
 
_wrap_Geometry_get_geometry_count(int argc, VALUE *argv, VALUE self) {
8054
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8055
 
  int result;
8056
 
  void *argp1 = 0 ;
8057
 
  int res1 = 0 ;
8058
 
  VALUE vresult = Qnil;
8059
 
  
8060
 
  if ((argc < 0) || (argc > 0)) {
8061
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8062
 
  }
8063
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8064
 
  if (!SWIG_IsOK(res1)) {
8065
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetGeometryCount" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8066
 
  }
8067
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8068
 
  {
8069
 
    CPLErrorReset();
8070
 
    result = (int)OGRGeometryShadow_GetGeometryCount(arg1);
8071
 
    CPLErr eclass = CPLGetLastErrorType();
8072
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8073
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8074
 
      
8075
 
    }
8076
 
  }
8077
 
  vresult = SWIG_From_int(static_cast< int >(result));
8078
 
  return vresult;
8079
 
fail:
8080
 
  return Qnil;
8081
 
}
8082
 
 
8083
 
 
8084
 
SWIGINTERN VALUE
8085
 
_wrap_Geometry_set_point(int argc, VALUE *argv, VALUE self) {
8086
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8087
 
  int arg2 ;
8088
 
  double arg3 ;
8089
 
  double arg4 ;
8090
 
  double arg5 = (double) 0 ;
8091
 
  void *argp1 = 0 ;
8092
 
  int res1 = 0 ;
8093
 
  int val2 ;
8094
 
  int ecode2 = 0 ;
8095
 
  double val3 ;
8096
 
  int ecode3 = 0 ;
8097
 
  double val4 ;
8098
 
  int ecode4 = 0 ;
8099
 
  double val5 ;
8100
 
  int ecode5 = 0 ;
8101
 
  char *kwnames[] = {
8102
 
    "self","point","x","y","z", NULL 
8103
 
  };
8104
 
  
8105
 
  if ((argc < 3) || (argc > 4)) {
8106
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
8107
 
  }
8108
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8109
 
  if (!SWIG_IsOK(res1)) {
8110
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetPoint" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8111
 
  }
8112
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8113
 
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
8114
 
  if (!SWIG_IsOK(ecode2)) {
8115
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SetPoint" "', argument " "2"" of type '" "int""'");
8116
 
  } 
8117
 
  arg2 = static_cast< int >(val2);
8118
 
  ecode3 = SWIG_AsVal_double(argv[1], &val3);
8119
 
  if (!SWIG_IsOK(ecode3)) {
8120
 
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SetPoint" "', argument " "3"" of type '" "double""'");
8121
 
  } 
8122
 
  arg3 = static_cast< double >(val3);
8123
 
  ecode4 = SWIG_AsVal_double(argv[2], &val4);
8124
 
  if (!SWIG_IsOK(ecode4)) {
8125
 
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SetPoint" "', argument " "4"" of type '" "double""'");
8126
 
  } 
8127
 
  arg4 = static_cast< double >(val4);
8128
 
  if (argc > 3) {
8129
 
    ecode5 = SWIG_AsVal_double(argv[3], &val5);
8130
 
    if (!SWIG_IsOK(ecode5)) {
8131
 
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SetPoint" "', argument " "5"" of type '" "double""'");
8132
 
    } 
8133
 
    arg5 = static_cast< double >(val5);
8134
 
  }
8135
 
  {
8136
 
    CPLErrorReset();
8137
 
    OGRGeometryShadow_SetPoint(arg1,arg2,arg3,arg4,arg5);
8138
 
    CPLErr eclass = CPLGetLastErrorType();
8139
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8140
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8141
 
      
8142
 
    }
8143
 
  }
8144
 
  return Qnil;
8145
 
fail:
8146
 
  return Qnil;
8147
 
}
8148
 
 
8149
 
 
8150
 
SWIGINTERN VALUE
8151
 
_wrap_Geometry_get_geometry_ref(int argc, VALUE *argv, VALUE self) {
8152
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8153
 
  int arg2 ;
8154
 
  OGRGeometryShadow *result = 0 ;
8155
 
  void *argp1 = 0 ;
8156
 
  int res1 = 0 ;
8157
 
  int val2 ;
8158
 
  int ecode2 = 0 ;
8159
 
  VALUE vresult = Qnil;
8160
 
  
8161
 
  if ((argc < 1) || (argc > 1)) {
8162
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8163
 
  }
8164
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8165
 
  if (!SWIG_IsOK(res1)) {
8166
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetGeometryRef" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8167
 
  }
8168
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8169
 
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
8170
 
  if (!SWIG_IsOK(ecode2)) {
8171
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetGeometryRef" "', argument " "2"" of type '" "int""'");
8172
 
  } 
8173
 
  arg2 = static_cast< int >(val2);
8174
 
  {
8175
 
    CPLErrorReset();
8176
 
    result = (OGRGeometryShadow *)OGRGeometryShadow_GetGeometryRef(arg1,arg2);
8177
 
    CPLErr eclass = CPLGetLastErrorType();
8178
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8179
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8180
 
      
8181
 
    }
8182
 
  }
8183
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8184
 
  return vresult;
8185
 
fail:
8186
 
  return Qnil;
8187
 
}
8188
 
 
8189
 
 
8190
 
SWIGINTERN VALUE
8191
 
_wrap_Geometry_get_boundary(int argc, VALUE *argv, VALUE self) {
8192
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8193
 
  OGRGeometryShadow *result = 0 ;
8194
 
  void *argp1 = 0 ;
8195
 
  int res1 = 0 ;
8196
 
  VALUE vresult = Qnil;
8197
 
  
8198
 
  if ((argc < 0) || (argc > 0)) {
8199
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8200
 
  }
8201
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8202
 
  if (!SWIG_IsOK(res1)) {
8203
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetBoundary" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8204
 
  }
8205
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8206
 
  {
8207
 
    CPLErrorReset();
8208
 
    result = (OGRGeometryShadow *)OGRGeometryShadow_GetBoundary(arg1);
8209
 
    CPLErr eclass = CPLGetLastErrorType();
8210
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8211
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8212
 
      
8213
 
    }
8214
 
  }
8215
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN |  0 );
8216
 
  return vresult;
8217
 
fail:
8218
 
  return Qnil;
8219
 
}
8220
 
 
8221
 
 
8222
 
SWIGINTERN VALUE
8223
 
_wrap_Geometry_convex_hull(int argc, VALUE *argv, VALUE self) {
8224
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8225
 
  OGRGeometryShadow *result = 0 ;
8226
 
  void *argp1 = 0 ;
8227
 
  int res1 = 0 ;
8228
 
  VALUE vresult = Qnil;
8229
 
  
8230
 
  if ((argc < 0) || (argc > 0)) {
8231
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8232
 
  }
8233
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8234
 
  if (!SWIG_IsOK(res1)) {
8235
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHull" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8236
 
  }
8237
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8238
 
  {
8239
 
    CPLErrorReset();
8240
 
    result = (OGRGeometryShadow *)OGRGeometryShadow_ConvexHull(arg1);
8241
 
    CPLErr eclass = CPLGetLastErrorType();
8242
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8243
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8244
 
      
8245
 
    }
8246
 
  }
8247
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN |  0 );
8248
 
  return vresult;
8249
 
fail:
8250
 
  return Qnil;
8251
 
}
8252
 
 
8253
 
 
8254
 
SWIGINTERN VALUE
8255
 
_wrap_Geometry_buffer(int argc, VALUE *argv, VALUE self) {
8256
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8257
 
  double arg2 ;
8258
 
  int arg3 = (int) 30 ;
8259
 
  OGRGeometryShadow *result = 0 ;
8260
 
  void *argp1 = 0 ;
8261
 
  int res1 = 0 ;
8262
 
  double val2 ;
8263
 
  int ecode2 = 0 ;
8264
 
  int val3 ;
8265
 
  int ecode3 = 0 ;
8266
 
  char *kwnames[] = {
8267
 
    "self","distance","quadsecs", NULL 
8268
 
  };
8269
 
  VALUE vresult = Qnil;
8270
 
  
8271
 
  if ((argc < 1) || (argc > 2)) {
8272
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8273
 
  }
8274
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8275
 
  if (!SWIG_IsOK(res1)) {
8276
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Buffer" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8277
 
  }
8278
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8279
 
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
8280
 
  if (!SWIG_IsOK(ecode2)) {
8281
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Buffer" "', argument " "2"" of type '" "double""'");
8282
 
  } 
8283
 
  arg2 = static_cast< double >(val2);
8284
 
  if (argc > 1) {
8285
 
    ecode3 = SWIG_AsVal_int(argv[1], &val3);
8286
 
    if (!SWIG_IsOK(ecode3)) {
8287
 
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Buffer" "', argument " "3"" of type '" "int""'");
8288
 
    } 
8289
 
    arg3 = static_cast< int >(val3);
8290
 
  }
8291
 
  {
8292
 
    CPLErrorReset();
8293
 
    result = (OGRGeometryShadow *)OGRGeometryShadow_Buffer(arg1,arg2,arg3);
8294
 
    CPLErr eclass = CPLGetLastErrorType();
8295
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8296
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8297
 
      
8298
 
    }
8299
 
  }
8300
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN |  0 );
8301
 
  return vresult;
8302
 
fail:
8303
 
  return Qnil;
8304
 
}
8305
 
 
8306
 
 
8307
 
SWIGINTERN VALUE
8308
 
_wrap_Geometry_intersection(int argc, VALUE *argv, VALUE self) {
8309
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8310
 
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
8311
 
  OGRGeometryShadow *result = 0 ;
8312
 
  void *argp1 = 0 ;
8313
 
  int res1 = 0 ;
8314
 
  void *argp2 = 0 ;
8315
 
  int res2 = 0 ;
8316
 
  VALUE vresult = Qnil;
8317
 
  
8318
 
  if ((argc < 1) || (argc > 1)) {
8319
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8320
 
  }
8321
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8322
 
  if (!SWIG_IsOK(res1)) {
8323
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Intersection" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8324
 
  }
8325
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8326
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8327
 
  if (!SWIG_IsOK(res2)) {
8328
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Intersection" "', argument " "2"" of type '" "OGRGeometryShadow *""'"); 
8329
 
  }
8330
 
  arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
8331
 
  {
8332
 
    CPLErrorReset();
8333
 
    result = (OGRGeometryShadow *)OGRGeometryShadow_Intersection(arg1,arg2);
8334
 
    CPLErr eclass = CPLGetLastErrorType();
8335
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8336
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8337
 
      
8338
 
    }
8339
 
  }
8340
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN |  0 );
8341
 
  return vresult;
8342
 
fail:
8343
 
  return Qnil;
8344
 
}
8345
 
 
8346
 
 
8347
 
SWIGINTERN VALUE
8348
 
_wrap_Geometry_union(int argc, VALUE *argv, VALUE self) {
8349
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8350
 
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
8351
 
  OGRGeometryShadow *result = 0 ;
8352
 
  void *argp1 = 0 ;
8353
 
  int res1 = 0 ;
8354
 
  void *argp2 = 0 ;
8355
 
  int res2 = 0 ;
8356
 
  VALUE vresult = Qnil;
8357
 
  
8358
 
  if ((argc < 1) || (argc > 1)) {
8359
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8360
 
  }
8361
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8362
 
  if (!SWIG_IsOK(res1)) {
8363
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Union" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8364
 
  }
8365
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8366
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8367
 
  if (!SWIG_IsOK(res2)) {
8368
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Union" "', argument " "2"" of type '" "OGRGeometryShadow *""'"); 
8369
 
  }
8370
 
  arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
8371
 
  {
8372
 
    CPLErrorReset();
8373
 
    result = (OGRGeometryShadow *)OGRGeometryShadow_Union(arg1,arg2);
8374
 
    CPLErr eclass = CPLGetLastErrorType();
8375
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8376
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8377
 
      
8378
 
    }
8379
 
  }
8380
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN |  0 );
8381
 
  return vresult;
8382
 
fail:
8383
 
  return Qnil;
8384
 
}
8385
 
 
8386
 
 
8387
 
SWIGINTERN VALUE
8388
 
_wrap_Geometry_difference(int argc, VALUE *argv, VALUE self) {
8389
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8390
 
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
8391
 
  OGRGeometryShadow *result = 0 ;
8392
 
  void *argp1 = 0 ;
8393
 
  int res1 = 0 ;
8394
 
  void *argp2 = 0 ;
8395
 
  int res2 = 0 ;
8396
 
  VALUE vresult = Qnil;
8397
 
  
8398
 
  if ((argc < 1) || (argc > 1)) {
8399
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8400
 
  }
8401
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8402
 
  if (!SWIG_IsOK(res1)) {
8403
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Difference" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8404
 
  }
8405
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8406
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8407
 
  if (!SWIG_IsOK(res2)) {
8408
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Difference" "', argument " "2"" of type '" "OGRGeometryShadow *""'"); 
8409
 
  }
8410
 
  arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
8411
 
  {
8412
 
    CPLErrorReset();
8413
 
    result = (OGRGeometryShadow *)OGRGeometryShadow_Difference(arg1,arg2);
8414
 
    CPLErr eclass = CPLGetLastErrorType();
8415
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8416
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8417
 
      
8418
 
    }
8419
 
  }
8420
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN |  0 );
8421
 
  return vresult;
8422
 
fail:
8423
 
  return Qnil;
8424
 
}
8425
 
 
8426
 
 
8427
 
SWIGINTERN VALUE
8428
 
_wrap_Geometry_symmetric_difference(int argc, VALUE *argv, VALUE self) {
8429
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8430
 
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
8431
 
  OGRGeometryShadow *result = 0 ;
8432
 
  void *argp1 = 0 ;
8433
 
  int res1 = 0 ;
8434
 
  void *argp2 = 0 ;
8435
 
  int res2 = 0 ;
8436
 
  VALUE vresult = Qnil;
8437
 
  
8438
 
  if ((argc < 1) || (argc > 1)) {
8439
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8440
 
  }
8441
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8442
 
  if (!SWIG_IsOK(res1)) {
8443
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SymmetricDifference" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8444
 
  }
8445
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8446
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8447
 
  if (!SWIG_IsOK(res2)) {
8448
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SymmetricDifference" "', argument " "2"" of type '" "OGRGeometryShadow *""'"); 
8449
 
  }
8450
 
  arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
8451
 
  {
8452
 
    CPLErrorReset();
8453
 
    result = (OGRGeometryShadow *)OGRGeometryShadow_SymmetricDifference(arg1,arg2);
8454
 
    CPLErr eclass = CPLGetLastErrorType();
8455
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8456
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8457
 
      
8458
 
    }
8459
 
  }
8460
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN |  0 );
8461
 
  return vresult;
8462
 
fail:
8463
 
  return Qnil;
8464
 
}
8465
 
 
8466
 
 
8467
 
SWIGINTERN VALUE
8468
 
_wrap_Geometry_distance(int argc, VALUE *argv, VALUE self) {
8469
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8470
 
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
8471
 
  double result;
8472
 
  void *argp1 = 0 ;
8473
 
  int res1 = 0 ;
8474
 
  void *argp2 = 0 ;
8475
 
  int res2 = 0 ;
8476
 
  VALUE vresult = Qnil;
8477
 
  
8478
 
  if ((argc < 1) || (argc > 1)) {
8479
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8480
 
  }
8481
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8482
 
  if (!SWIG_IsOK(res1)) {
8483
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Distance" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8484
 
  }
8485
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8486
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8487
 
  if (!SWIG_IsOK(res2)) {
8488
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Distance" "', argument " "2"" of type '" "OGRGeometryShadow *""'"); 
8489
 
  }
8490
 
  arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
8491
 
  {
8492
 
    CPLErrorReset();
8493
 
    result = (double)OGRGeometryShadow_Distance(arg1,arg2);
8494
 
    CPLErr eclass = CPLGetLastErrorType();
8495
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8496
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8497
 
      
8498
 
    }
8499
 
  }
8500
 
  vresult = SWIG_From_double(static_cast< double >(result));
8501
 
  return vresult;
8502
 
fail:
8503
 
  return Qnil;
8504
 
}
8505
 
 
8506
 
 
8507
 
SWIGINTERN VALUE
8508
 
_wrap_Geometry_empty(int argc, VALUE *argv, VALUE self) {
8509
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8510
 
  void *argp1 = 0 ;
8511
 
  int res1 = 0 ;
8512
 
  
8513
 
  if ((argc < 0) || (argc > 0)) {
8514
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8515
 
  }
8516
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8517
 
  if (!SWIG_IsOK(res1)) {
8518
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Empty" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8519
 
  }
8520
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8521
 
  {
8522
 
    CPLErrorReset();
8523
 
    OGRGeometryShadow_Empty(arg1);
8524
 
    CPLErr eclass = CPLGetLastErrorType();
8525
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8526
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8527
 
      
8528
 
    }
8529
 
  }
8530
 
  return Qnil;
8531
 
fail:
8532
 
  return Qnil;
8533
 
}
8534
 
 
8535
 
 
8536
 
SWIGINTERN VALUE
8537
 
_wrap_Geometry_intersect(int argc, VALUE *argv, VALUE self) {
8538
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8539
 
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
8540
 
  bool result;
8541
 
  void *argp1 = 0 ;
8542
 
  int res1 = 0 ;
8543
 
  void *argp2 = 0 ;
8544
 
  int res2 = 0 ;
8545
 
  VALUE vresult = Qnil;
8546
 
  
8547
 
  if ((argc < 1) || (argc > 1)) {
8548
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8549
 
  }
8550
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8551
 
  if (!SWIG_IsOK(res1)) {
8552
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Intersect" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8553
 
  }
8554
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8555
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8556
 
  if (!SWIG_IsOK(res2)) {
8557
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Intersect" "', argument " "2"" of type '" "OGRGeometryShadow *""'"); 
8558
 
  }
8559
 
  arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
8560
 
  {
8561
 
    CPLErrorReset();
8562
 
    result = (bool)OGRGeometryShadow_Intersect(arg1,arg2);
8563
 
    CPLErr eclass = CPLGetLastErrorType();
8564
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8565
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8566
 
      
8567
 
    }
8568
 
  }
8569
 
  vresult = SWIG_From_bool(static_cast< bool >(result));
8570
 
  return vresult;
8571
 
fail:
8572
 
  return Qnil;
8573
 
}
8574
 
 
8575
 
 
8576
 
SWIGINTERN VALUE
8577
 
_wrap_Geometry_equal(int argc, VALUE *argv, VALUE self) {
8578
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8579
 
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
8580
 
  bool result;
8581
 
  void *argp1 = 0 ;
8582
 
  int res1 = 0 ;
8583
 
  void *argp2 = 0 ;
8584
 
  int res2 = 0 ;
8585
 
  VALUE vresult = Qnil;
8586
 
  
8587
 
  if ((argc < 1) || (argc > 1)) {
8588
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8589
 
  }
8590
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8591
 
  if (!SWIG_IsOK(res1)) {
8592
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Equal" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8593
 
  }
8594
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8595
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8596
 
  if (!SWIG_IsOK(res2)) {
8597
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Equal" "', argument " "2"" of type '" "OGRGeometryShadow *""'"); 
8598
 
  }
8599
 
  arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
8600
 
  {
8601
 
    CPLErrorReset();
8602
 
    result = (bool)OGRGeometryShadow_Equal(arg1,arg2);
8603
 
    CPLErr eclass = CPLGetLastErrorType();
8604
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8605
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8606
 
      
8607
 
    }
8608
 
  }
8609
 
  vresult = SWIG_From_bool(static_cast< bool >(result));
8610
 
  return vresult;
8611
 
fail:
8612
 
  return Qnil;
8613
 
}
8614
 
 
8615
 
 
8616
 
SWIGINTERN VALUE
8617
 
_wrap_Geometry_disjoint(int argc, VALUE *argv, VALUE self) {
8618
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8619
 
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
8620
 
  bool result;
8621
 
  void *argp1 = 0 ;
8622
 
  int res1 = 0 ;
8623
 
  void *argp2 = 0 ;
8624
 
  int res2 = 0 ;
8625
 
  VALUE vresult = Qnil;
8626
 
  
8627
 
  if ((argc < 1) || (argc > 1)) {
8628
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8629
 
  }
8630
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8631
 
  if (!SWIG_IsOK(res1)) {
8632
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Disjoint" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8633
 
  }
8634
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8635
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8636
 
  if (!SWIG_IsOK(res2)) {
8637
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Disjoint" "', argument " "2"" of type '" "OGRGeometryShadow *""'"); 
8638
 
  }
8639
 
  arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
8640
 
  {
8641
 
    CPLErrorReset();
8642
 
    result = (bool)OGRGeometryShadow_Disjoint(arg1,arg2);
8643
 
    CPLErr eclass = CPLGetLastErrorType();
8644
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8645
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8646
 
      
8647
 
    }
8648
 
  }
8649
 
  vresult = SWIG_From_bool(static_cast< bool >(result));
8650
 
  return vresult;
8651
 
fail:
8652
 
  return Qnil;
8653
 
}
8654
 
 
8655
 
 
8656
 
SWIGINTERN VALUE
8657
 
_wrap_Geometry_touches(int argc, VALUE *argv, VALUE self) {
8658
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8659
 
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
8660
 
  bool result;
8661
 
  void *argp1 = 0 ;
8662
 
  int res1 = 0 ;
8663
 
  void *argp2 = 0 ;
8664
 
  int res2 = 0 ;
8665
 
  VALUE vresult = Qnil;
8666
 
  
8667
 
  if ((argc < 1) || (argc > 1)) {
8668
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8669
 
  }
8670
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8671
 
  if (!SWIG_IsOK(res1)) {
8672
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Touches" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8673
 
  }
8674
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8675
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8676
 
  if (!SWIG_IsOK(res2)) {
8677
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Touches" "', argument " "2"" of type '" "OGRGeometryShadow *""'"); 
8678
 
  }
8679
 
  arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
8680
 
  {
8681
 
    CPLErrorReset();
8682
 
    result = (bool)OGRGeometryShadow_Touches(arg1,arg2);
8683
 
    CPLErr eclass = CPLGetLastErrorType();
8684
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8685
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8686
 
      
8687
 
    }
8688
 
  }
8689
 
  vresult = SWIG_From_bool(static_cast< bool >(result));
8690
 
  return vresult;
8691
 
fail:
8692
 
  return Qnil;
8693
 
}
8694
 
 
8695
 
 
8696
 
SWIGINTERN VALUE
8697
 
_wrap_Geometry_crosses(int argc, VALUE *argv, VALUE self) {
8698
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8699
 
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
8700
 
  bool result;
8701
 
  void *argp1 = 0 ;
8702
 
  int res1 = 0 ;
8703
 
  void *argp2 = 0 ;
8704
 
  int res2 = 0 ;
8705
 
  VALUE vresult = Qnil;
8706
 
  
8707
 
  if ((argc < 1) || (argc > 1)) {
8708
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8709
 
  }
8710
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8711
 
  if (!SWIG_IsOK(res1)) {
8712
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Crosses" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8713
 
  }
8714
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8715
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8716
 
  if (!SWIG_IsOK(res2)) {
8717
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Crosses" "', argument " "2"" of type '" "OGRGeometryShadow *""'"); 
8718
 
  }
8719
 
  arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
8720
 
  {
8721
 
    CPLErrorReset();
8722
 
    result = (bool)OGRGeometryShadow_Crosses(arg1,arg2);
8723
 
    CPLErr eclass = CPLGetLastErrorType();
8724
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8725
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8726
 
      
8727
 
    }
8728
 
  }
8729
 
  vresult = SWIG_From_bool(static_cast< bool >(result));
8730
 
  return vresult;
8731
 
fail:
8732
 
  return Qnil;
8733
 
}
8734
 
 
8735
 
 
8736
 
SWIGINTERN VALUE
8737
 
_wrap_Geometry_within(int argc, VALUE *argv, VALUE self) {
8738
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8739
 
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
8740
 
  bool result;
8741
 
  void *argp1 = 0 ;
8742
 
  int res1 = 0 ;
8743
 
  void *argp2 = 0 ;
8744
 
  int res2 = 0 ;
8745
 
  VALUE vresult = Qnil;
8746
 
  
8747
 
  if ((argc < 1) || (argc > 1)) {
8748
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8749
 
  }
8750
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8751
 
  if (!SWIG_IsOK(res1)) {
8752
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Within" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8753
 
  }
8754
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8755
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8756
 
  if (!SWIG_IsOK(res2)) {
8757
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Within" "', argument " "2"" of type '" "OGRGeometryShadow *""'"); 
8758
 
  }
8759
 
  arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
8760
 
  {
8761
 
    CPLErrorReset();
8762
 
    result = (bool)OGRGeometryShadow_Within(arg1,arg2);
8763
 
    CPLErr eclass = CPLGetLastErrorType();
8764
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8765
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8766
 
      
8767
 
    }
8768
 
  }
8769
 
  vresult = SWIG_From_bool(static_cast< bool >(result));
8770
 
  return vresult;
8771
 
fail:
8772
 
  return Qnil;
8773
 
}
8774
 
 
8775
 
 
8776
 
SWIGINTERN VALUE
8777
 
_wrap_Geometry_contains(int argc, VALUE *argv, VALUE self) {
8778
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8779
 
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
8780
 
  bool result;
8781
 
  void *argp1 = 0 ;
8782
 
  int res1 = 0 ;
8783
 
  void *argp2 = 0 ;
8784
 
  int res2 = 0 ;
8785
 
  VALUE vresult = Qnil;
8786
 
  
8787
 
  if ((argc < 1) || (argc > 1)) {
8788
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8789
 
  }
8790
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8791
 
  if (!SWIG_IsOK(res1)) {
8792
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Contains" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8793
 
  }
8794
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8795
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8796
 
  if (!SWIG_IsOK(res2)) {
8797
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Contains" "', argument " "2"" of type '" "OGRGeometryShadow *""'"); 
8798
 
  }
8799
 
  arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
8800
 
  {
8801
 
    CPLErrorReset();
8802
 
    result = (bool)OGRGeometryShadow_Contains(arg1,arg2);
8803
 
    CPLErr eclass = CPLGetLastErrorType();
8804
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8805
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8806
 
      
8807
 
    }
8808
 
  }
8809
 
  vresult = SWIG_From_bool(static_cast< bool >(result));
8810
 
  return vresult;
8811
 
fail:
8812
 
  return Qnil;
8813
 
}
8814
 
 
8815
 
 
8816
 
SWIGINTERN VALUE
8817
 
_wrap_Geometry_overlaps(int argc, VALUE *argv, VALUE self) {
8818
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8819
 
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
8820
 
  bool result;
8821
 
  void *argp1 = 0 ;
8822
 
  int res1 = 0 ;
8823
 
  void *argp2 = 0 ;
8824
 
  int res2 = 0 ;
8825
 
  VALUE vresult = Qnil;
8826
 
  
8827
 
  if ((argc < 1) || (argc > 1)) {
8828
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8829
 
  }
8830
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8831
 
  if (!SWIG_IsOK(res1)) {
8832
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Overlaps" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8833
 
  }
8834
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8835
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8836
 
  if (!SWIG_IsOK(res2)) {
8837
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Overlaps" "', argument " "2"" of type '" "OGRGeometryShadow *""'"); 
8838
 
  }
8839
 
  arg2 = reinterpret_cast< OGRGeometryShadow * >(argp2);
8840
 
  {
8841
 
    CPLErrorReset();
8842
 
    result = (bool)OGRGeometryShadow_Overlaps(arg1,arg2);
8843
 
    CPLErr eclass = CPLGetLastErrorType();
8844
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8845
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8846
 
      
8847
 
    }
8848
 
  }
8849
 
  vresult = SWIG_From_bool(static_cast< bool >(result));
8850
 
  return vresult;
8851
 
fail:
8852
 
  return Qnil;
8853
 
}
8854
 
 
8855
 
 
8856
 
SWIGINTERN VALUE
8857
 
_wrap_Geometry_transform_to(int argc, VALUE *argv, VALUE self) {
8858
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8859
 
  OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
8860
 
  OGRErr result;
8861
 
  void *argp1 = 0 ;
8862
 
  int res1 = 0 ;
8863
 
  void *argp2 = 0 ;
8864
 
  int res2 = 0 ;
8865
 
  VALUE vresult = Qnil;
8866
 
  
8867
 
  if ((argc < 1) || (argc > 1)) {
8868
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8869
 
  }
8870
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8871
 
  if (!SWIG_IsOK(res1)) {
8872
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransformTo" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8873
 
  }
8874
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8875
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 |  0 );
8876
 
  if (!SWIG_IsOK(res2)) {
8877
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransformTo" "', argument " "2"" of type '" "OSRSpatialReferenceShadow *""'"); 
8878
 
  }
8879
 
  arg2 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp2);
8880
 
  {
8881
 
    CPLErrorReset();
8882
 
    result = (OGRErr)OGRGeometryShadow_TransformTo(arg1,arg2);
8883
 
    CPLErr eclass = CPLGetLastErrorType();
8884
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8885
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8886
 
      
8887
 
    }
8888
 
  }
8889
 
  {
8890
 
    /* %typemap(out) OGRErr */
8891
 
    if (result != 0) {
8892
 
      rb_raise(rb_eRuntimeError, OGRErrMessages(result));
8893
 
    }
8894
 
  }
8895
 
  {
8896
 
    /* %typemap(ret) OGRErr */
8897
 
    if (vresult == Qnil) {
8898
 
      vresult = INT2NUM(0);
8899
 
    }
8900
 
  }    return vresult;
8901
 
fail:
8902
 
  return Qnil;
8903
 
}
8904
 
 
8905
 
 
8906
 
SWIGINTERN VALUE
8907
 
_wrap_Geometry_transform(int argc, VALUE *argv, VALUE self) {
8908
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8909
 
  OSRCoordinateTransformationShadow *arg2 = (OSRCoordinateTransformationShadow *) 0 ;
8910
 
  OGRErr result;
8911
 
  void *argp1 = 0 ;
8912
 
  int res1 = 0 ;
8913
 
  void *argp2 = 0 ;
8914
 
  int res2 = 0 ;
8915
 
  VALUE vresult = Qnil;
8916
 
  
8917
 
  if ((argc < 1) || (argc > 1)) {
8918
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8919
 
  }
8920
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8921
 
  if (!SWIG_IsOK(res1)) {
8922
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8923
 
  }
8924
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8925
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OSRCoordinateTransformationShadow, 0 |  0 );
8926
 
  if (!SWIG_IsOK(res2)) {
8927
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Transform" "', argument " "2"" of type '" "OSRCoordinateTransformationShadow *""'"); 
8928
 
  }
8929
 
  arg2 = reinterpret_cast< OSRCoordinateTransformationShadow * >(argp2);
8930
 
  {
8931
 
    CPLErrorReset();
8932
 
    result = (OGRErr)OGRGeometryShadow_Transform(arg1,arg2);
8933
 
    CPLErr eclass = CPLGetLastErrorType();
8934
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8935
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8936
 
      
8937
 
    }
8938
 
  }
8939
 
  {
8940
 
    /* %typemap(out) OGRErr */
8941
 
    if (result != 0) {
8942
 
      rb_raise(rb_eRuntimeError, OGRErrMessages(result));
8943
 
    }
8944
 
  }
8945
 
  {
8946
 
    /* %typemap(ret) OGRErr */
8947
 
    if (vresult == Qnil) {
8948
 
      vresult = INT2NUM(0);
8949
 
    }
8950
 
  }    return vresult;
8951
 
fail:
8952
 
  return Qnil;
8953
 
}
8954
 
 
8955
 
 
8956
 
SWIGINTERN VALUE
8957
 
_wrap_Geometry_get_spatial_reference(int argc, VALUE *argv, VALUE self) {
8958
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8959
 
  OSRSpatialReferenceShadow *result = 0 ;
8960
 
  void *argp1 = 0 ;
8961
 
  int res1 = 0 ;
8962
 
  VALUE vresult = Qnil;
8963
 
  
8964
 
  if ((argc < 0) || (argc > 0)) {
8965
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8966
 
  }
8967
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
8968
 
  if (!SWIG_IsOK(res1)) {
8969
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetSpatialReference" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
8970
 
  }
8971
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
8972
 
  {
8973
 
    CPLErrorReset();
8974
 
    result = (OSRSpatialReferenceShadow *)OGRGeometryShadow_GetSpatialReference(arg1);
8975
 
    CPLErr eclass = CPLGetLastErrorType();
8976
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
8977
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
8978
 
      
8979
 
    }
8980
 
  }
8981
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OSRSpatialReferenceShadow, 0 |  0 );
8982
 
  return vresult;
8983
 
fail:
8984
 
  return Qnil;
8985
 
}
8986
 
 
8987
 
 
8988
 
SWIGINTERN VALUE
8989
 
_wrap_Geometry_assign_spatial_reference(int argc, VALUE *argv, VALUE self) {
8990
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8991
 
  OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
8992
 
  void *argp1 = 0 ;
8993
 
  int res1 = 0 ;
8994
 
  void *argp2 = 0 ;
8995
 
  int res2 = 0 ;
8996
 
  
8997
 
  if ((argc < 1) || (argc > 1)) {
8998
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8999
 
  }
9000
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
9001
 
  if (!SWIG_IsOK(res1)) {
9002
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AssignSpatialReference" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
9003
 
  }
9004
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
9005
 
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_OSRSpatialReferenceShadow, 0 |  0 );
9006
 
  if (!SWIG_IsOK(res2)) {
9007
 
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AssignSpatialReference" "', argument " "2"" of type '" "OSRSpatialReferenceShadow *""'"); 
9008
 
  }
9009
 
  arg2 = reinterpret_cast< OSRSpatialReferenceShadow * >(argp2);
9010
 
  {
9011
 
    CPLErrorReset();
9012
 
    OGRGeometryShadow_AssignSpatialReference(arg1,arg2);
9013
 
    CPLErr eclass = CPLGetLastErrorType();
9014
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9015
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9016
 
      
9017
 
    }
9018
 
  }
9019
 
  return Qnil;
9020
 
fail:
9021
 
  return Qnil;
9022
 
}
9023
 
 
9024
 
 
9025
 
SWIGINTERN VALUE
9026
 
_wrap_Geometry_close_rings(int argc, VALUE *argv, VALUE self) {
9027
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
9028
 
  void *argp1 = 0 ;
9029
 
  int res1 = 0 ;
9030
 
  
9031
 
  if ((argc < 0) || (argc > 0)) {
9032
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9033
 
  }
9034
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
9035
 
  if (!SWIG_IsOK(res1)) {
9036
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseRings" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
9037
 
  }
9038
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
9039
 
  {
9040
 
    CPLErrorReset();
9041
 
    OGRGeometryShadow_CloseRings(arg1);
9042
 
    CPLErr eclass = CPLGetLastErrorType();
9043
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9044
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9045
 
      
9046
 
    }
9047
 
  }
9048
 
  return Qnil;
9049
 
fail:
9050
 
  return Qnil;
9051
 
}
9052
 
 
9053
 
 
9054
 
SWIGINTERN VALUE
9055
 
_wrap_Geometry_flatten_to_2d(int argc, VALUE *argv, VALUE self) {
9056
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
9057
 
  void *argp1 = 0 ;
9058
 
  int res1 = 0 ;
9059
 
  
9060
 
  if ((argc < 0) || (argc > 0)) {
9061
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9062
 
  }
9063
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
9064
 
  if (!SWIG_IsOK(res1)) {
9065
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlattenTo2D" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
9066
 
  }
9067
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
9068
 
  {
9069
 
    CPLErrorReset();
9070
 
    OGRGeometryShadow_FlattenTo2D(arg1);
9071
 
    CPLErr eclass = CPLGetLastErrorType();
9072
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9073
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9074
 
      
9075
 
    }
9076
 
  }
9077
 
  return Qnil;
9078
 
fail:
9079
 
  return Qnil;
9080
 
}
9081
 
 
9082
 
 
9083
 
SWIGINTERN VALUE
9084
 
_wrap_Geometry_get_envelope(int argc, VALUE *argv, VALUE self) {
9085
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
9086
 
  double *arg2 ;
9087
 
  void *argp1 = 0 ;
9088
 
  int res1 = 0 ;
9089
 
  double argout2[4] ;
9090
 
  VALUE vresult = Qnil;
9091
 
  
9092
 
  {
9093
 
    /* %typemap(in,numinputs=0) (double argout2[ANY]) */
9094
 
    arg2 = argout2;
9095
 
  }
9096
 
  if ((argc < 0) || (argc > 0)) {
9097
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9098
 
  }
9099
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
9100
 
  if (!SWIG_IsOK(res1)) {
9101
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetEnvelope" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
9102
 
  }
9103
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
9104
 
  {
9105
 
    CPLErrorReset();
9106
 
    OGRGeometryShadow_GetEnvelope(arg1,arg2);
9107
 
    CPLErr eclass = CPLGetLastErrorType();
9108
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9109
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9110
 
      
9111
 
    }
9112
 
  }
9113
 
  {
9114
 
    /* %typemap(argout) (double argout[ANY]) */
9115
 
    VALUE outArr = rb_ary_new();
9116
 
    
9117
 
    for(int i=0; i<4; i++)
9118
 
    {
9119
 
      VALUE value = rb_float_new((arg2)[i]);
9120
 
      rb_ary_push(outArr, value);
9121
 
    }
9122
 
    
9123
 
    /* Add the output to the result */
9124
 
    vresult = SWIG_Ruby_AppendOutput(vresult, outArr);  
9125
 
  }
9126
 
  return vresult;
9127
 
fail:
9128
 
  return Qnil;
9129
 
}
9130
 
 
9131
 
 
9132
 
SWIGINTERN VALUE
9133
 
_wrap_Geometry_centroid(int argc, VALUE *argv, VALUE self) {
9134
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
9135
 
  OGRGeometryShadow *result = 0 ;
9136
 
  void *argp1 = 0 ;
9137
 
  int res1 = 0 ;
9138
 
  VALUE vresult = Qnil;
9139
 
  
9140
 
  if ((argc < 0) || (argc > 0)) {
9141
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9142
 
  }
9143
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
9144
 
  if (!SWIG_IsOK(res1)) {
9145
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Centroid" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
9146
 
  }
9147
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
9148
 
  {
9149
 
    CPLErrorReset();
9150
 
    result = (OGRGeometryShadow *)OGRGeometryShadow_Centroid(arg1);
9151
 
    CPLErr eclass = CPLGetLastErrorType();
9152
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9153
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9154
 
      
9155
 
    }
9156
 
  }
9157
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_OWN |  0 );
9158
 
  return vresult;
9159
 
fail:
9160
 
  return Qnil;
9161
 
}
9162
 
 
9163
 
 
9164
 
SWIGINTERN VALUE
9165
 
_wrap_Geometry_wkb_size(int argc, VALUE *argv, VALUE self) {
9166
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
9167
 
  int result;
9168
 
  void *argp1 = 0 ;
9169
 
  int res1 = 0 ;
9170
 
  VALUE vresult = Qnil;
9171
 
  
9172
 
  if ((argc < 0) || (argc > 0)) {
9173
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9174
 
  }
9175
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
9176
 
  if (!SWIG_IsOK(res1)) {
9177
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WkbSize" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
9178
 
  }
9179
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
9180
 
  {
9181
 
    CPLErrorReset();
9182
 
    result = (int)OGRGeometryShadow_WkbSize(arg1);
9183
 
    CPLErr eclass = CPLGetLastErrorType();
9184
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9185
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9186
 
      
9187
 
    }
9188
 
  }
9189
 
  vresult = SWIG_From_int(static_cast< int >(result));
9190
 
  return vresult;
9191
 
fail:
9192
 
  return Qnil;
9193
 
}
9194
 
 
9195
 
 
9196
 
SWIGINTERN VALUE
9197
 
_wrap_Geometry_get_coordinate_dimension(int argc, VALUE *argv, VALUE self) {
9198
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
9199
 
  int result;
9200
 
  void *argp1 = 0 ;
9201
 
  int res1 = 0 ;
9202
 
  VALUE vresult = Qnil;
9203
 
  
9204
 
  if ((argc < 0) || (argc > 0)) {
9205
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9206
 
  }
9207
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
9208
 
  if (!SWIG_IsOK(res1)) {
9209
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetCoordinateDimension" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
9210
 
  }
9211
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
9212
 
  {
9213
 
    CPLErrorReset();
9214
 
    result = (int)OGRGeometryShadow_GetCoordinateDimension(arg1);
9215
 
    CPLErr eclass = CPLGetLastErrorType();
9216
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9217
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9218
 
      
9219
 
    }
9220
 
  }
9221
 
  vresult = SWIG_From_int(static_cast< int >(result));
9222
 
  return vresult;
9223
 
fail:
9224
 
  return Qnil;
9225
 
}
9226
 
 
9227
 
 
9228
 
SWIGINTERN VALUE
9229
 
_wrap_Geometry_set_coordinate_dimension(int argc, VALUE *argv, VALUE self) {
9230
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
9231
 
  int arg2 ;
9232
 
  void *argp1 = 0 ;
9233
 
  int res1 = 0 ;
9234
 
  int val2 ;
9235
 
  int ecode2 = 0 ;
9236
 
  
9237
 
  if ((argc < 1) || (argc > 1)) {
9238
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9239
 
  }
9240
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
9241
 
  if (!SWIG_IsOK(res1)) {
9242
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCoordinateDimension" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
9243
 
  }
9244
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
9245
 
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
9246
 
  if (!SWIG_IsOK(ecode2)) {
9247
 
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SetCoordinateDimension" "', argument " "2"" of type '" "int""'");
9248
 
  } 
9249
 
  arg2 = static_cast< int >(val2);
9250
 
  {
9251
 
    CPLErrorReset();
9252
 
    OGRGeometryShadow_SetCoordinateDimension(arg1,arg2);
9253
 
    CPLErr eclass = CPLGetLastErrorType();
9254
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9255
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9256
 
      
9257
 
    }
9258
 
  }
9259
 
  return Qnil;
9260
 
fail:
9261
 
  return Qnil;
9262
 
}
9263
 
 
9264
 
 
9265
 
SWIGINTERN VALUE
9266
 
_wrap_Geometry_get_dimension(int argc, VALUE *argv, VALUE self) {
9267
 
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
9268
 
  int result;
9269
 
  void *argp1 = 0 ;
9270
 
  int res1 = 0 ;
9271
 
  VALUE vresult = Qnil;
9272
 
  
9273
 
  if ((argc < 0) || (argc > 0)) {
9274
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9275
 
  }
9276
 
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_OGRGeometryShadow, 0 |  0 );
9277
 
  if (!SWIG_IsOK(res1)) {
9278
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetDimension" "', argument " "1"" of type '" "OGRGeometryShadow *""'"); 
9279
 
  }
9280
 
  arg1 = reinterpret_cast< OGRGeometryShadow * >(argp1);
9281
 
  {
9282
 
    CPLErrorReset();
9283
 
    result = (int)OGRGeometryShadow_GetDimension(arg1);
9284
 
    CPLErr eclass = CPLGetLastErrorType();
9285
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9286
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9287
 
      
9288
 
    }
9289
 
  }
9290
 
  vresult = SWIG_From_int(static_cast< int >(result));
9291
 
  return vresult;
9292
 
fail:
9293
 
  return Qnil;
9294
 
}
9295
 
 
9296
 
 
9297
 
SWIGINTERN VALUE
9298
 
_wrap_get_driver_count(int argc, VALUE *argv, VALUE self) {
9299
 
  int result;
9300
 
  VALUE vresult = Qnil;
9301
 
  
9302
 
  if ((argc < 0) || (argc > 0)) {
9303
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9304
 
  }
9305
 
  {
9306
 
    CPLErrorReset();
9307
 
    result = (int)OGRGetDriverCount();
9308
 
    CPLErr eclass = CPLGetLastErrorType();
9309
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9310
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9311
 
      
9312
 
    }
9313
 
  }
9314
 
  vresult = SWIG_From_int(static_cast< int >(result));
9315
 
  return vresult;
9316
 
fail:
9317
 
  return Qnil;
9318
 
}
9319
 
 
9320
 
 
9321
 
SWIGINTERN VALUE
9322
 
_wrap_get_open_dscount(int argc, VALUE *argv, VALUE self) {
9323
 
  int result;
9324
 
  VALUE vresult = Qnil;
9325
 
  
9326
 
  if ((argc < 0) || (argc > 0)) {
9327
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9328
 
  }
9329
 
  {
9330
 
    CPLErrorReset();
9331
 
    result = (int)OGRGetOpenDSCount();
9332
 
    CPLErr eclass = CPLGetLastErrorType();
9333
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9334
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9335
 
      
9336
 
    }
9337
 
  }
9338
 
  vresult = SWIG_From_int(static_cast< int >(result));
9339
 
  return vresult;
9340
 
fail:
9341
 
  return Qnil;
9342
 
}
9343
 
 
9344
 
 
9345
 
SWIGINTERN VALUE
9346
 
_wrap_set_generate_db2_v72_byte_order(int argc, VALUE *argv, VALUE self) {
9347
 
  int arg1 ;
9348
 
  OGRErr result;
9349
 
  int val1 ;
9350
 
  int ecode1 = 0 ;
9351
 
  VALUE vresult = Qnil;
9352
 
  
9353
 
  if ((argc < 1) || (argc > 1)) {
9354
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9355
 
  }
9356
 
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
9357
 
  if (!SWIG_IsOK(ecode1)) {
9358
 
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "OGRSetGenerate_DB2_V72_BYTE_ORDER" "', argument " "1"" of type '" "int""'");
9359
 
  } 
9360
 
  arg1 = static_cast< int >(val1);
9361
 
  {
9362
 
    CPLErrorReset();
9363
 
    result = (OGRErr)OGRSetGenerate_DB2_V72_BYTE_ORDER(arg1);
9364
 
    CPLErr eclass = CPLGetLastErrorType();
9365
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9366
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9367
 
      
9368
 
    }
9369
 
  }
9370
 
  {
9371
 
    /* %typemap(out) OGRErr */
9372
 
    if (result != 0) {
9373
 
      rb_raise(rb_eRuntimeError, OGRErrMessages(result));
9374
 
    }
9375
 
  }
9376
 
  {
9377
 
    /* %typemap(ret) OGRErr */
9378
 
    if (vresult == Qnil) {
9379
 
      vresult = INT2NUM(0);
9380
 
    }
9381
 
  }    return vresult;
9382
 
fail:
9383
 
  return Qnil;
9384
 
}
9385
 
 
9386
 
 
9387
 
SWIGINTERN VALUE
9388
 
_wrap_register_all(int argc, VALUE *argv, VALUE self) {
9389
 
  if ((argc < 0) || (argc > 0)) {
9390
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9391
 
  }
9392
 
  {
9393
 
    CPLErrorReset();
9394
 
    OGRRegisterAll();
9395
 
    CPLErr eclass = CPLGetLastErrorType();
9396
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9397
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9398
 
      
9399
 
    }
9400
 
  }
9401
 
  return Qnil;
9402
 
fail:
9403
 
  return Qnil;
9404
 
}
9405
 
 
9406
 
 
9407
 
SWIGINTERN VALUE
9408
 
_wrap_get_open_ds(int argc, VALUE *argv, VALUE self) {
9409
 
  int arg1 ;
9410
 
  OGRDataSourceShadow *result = 0 ;
9411
 
  int val1 ;
9412
 
  int ecode1 = 0 ;
9413
 
  VALUE vresult = Qnil;
9414
 
  
9415
 
  if ((argc < 1) || (argc > 1)) {
9416
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9417
 
  }
9418
 
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
9419
 
  if (!SWIG_IsOK(ecode1)) {
9420
 
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetOpenDS" "', argument " "1"" of type '" "int""'");
9421
 
  } 
9422
 
  arg1 = static_cast< int >(val1);
9423
 
  {
9424
 
    CPLErrorReset();
9425
 
    result = (OGRDataSourceShadow *)GetOpenDS(arg1);
9426
 
    CPLErr eclass = CPLGetLastErrorType();
9427
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9428
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9429
 
      
9430
 
    }
9431
 
  }
9432
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRDataSourceShadow, 0 |  0 );
9433
 
  return vresult;
9434
 
fail:
9435
 
  return Qnil;
9436
 
}
9437
 
 
9438
 
 
9439
 
SWIGINTERN VALUE
9440
 
_wrap_open(int argc, VALUE *argv, VALUE self) {
9441
 
  char *arg1 = (char *) 0 ;
9442
 
  int arg2 = (int) 0 ;
9443
 
  OGRDataSourceShadow *result = 0 ;
9444
 
  int res1 ;
9445
 
  char *buf1 = 0 ;
9446
 
  int alloc1 = 0 ;
9447
 
  int val2 ;
9448
 
  int ecode2 = 0 ;
9449
 
  char *kwnames[] = {
9450
 
    "filename","update", NULL 
9451
 
  };
9452
 
  VALUE vresult = Qnil;
9453
 
  
9454
 
  if ((argc < 1) || (argc > 2)) {
9455
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9456
 
  }
9457
 
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
9458
 
  if (!SWIG_IsOK(res1)) {
9459
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Open" "', argument " "1"" of type '" "char const *""'");
9460
 
  }
9461
 
  arg1 = buf1;
9462
 
  if (argc > 1) {
9463
 
    ecode2 = SWIG_AsVal_int(argv[1], &val2);
9464
 
    if (!SWIG_IsOK(ecode2)) {
9465
 
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Open" "', argument " "2"" of type '" "int""'");
9466
 
    } 
9467
 
    arg2 = static_cast< int >(val2);
9468
 
  }
9469
 
  {
9470
 
    CPLErrorReset();
9471
 
    result = (OGRDataSourceShadow *)Open((char const *)arg1,arg2);
9472
 
    CPLErr eclass = CPLGetLastErrorType();
9473
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9474
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9475
 
      
9476
 
    }
9477
 
  }
9478
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRDataSourceShadow, SWIG_POINTER_OWN |  0 );
9479
 
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
9480
 
  return vresult;
9481
 
fail:
9482
 
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
9483
 
  return Qnil;
9484
 
}
9485
 
 
9486
 
 
9487
 
SWIGINTERN VALUE
9488
 
_wrap_open_shared(int argc, VALUE *argv, VALUE self) {
9489
 
  char *arg1 = (char *) 0 ;
9490
 
  int arg2 = (int) 0 ;
9491
 
  OGRDataSourceShadow *result = 0 ;
9492
 
  int res1 ;
9493
 
  char *buf1 = 0 ;
9494
 
  int alloc1 = 0 ;
9495
 
  int val2 ;
9496
 
  int ecode2 = 0 ;
9497
 
  char *kwnames[] = {
9498
 
    "filename","update", NULL 
9499
 
  };
9500
 
  VALUE vresult = Qnil;
9501
 
  
9502
 
  if ((argc < 1) || (argc > 2)) {
9503
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9504
 
  }
9505
 
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
9506
 
  if (!SWIG_IsOK(res1)) {
9507
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OpenShared" "', argument " "1"" of type '" "char const *""'");
9508
 
  }
9509
 
  arg1 = buf1;
9510
 
  if (argc > 1) {
9511
 
    ecode2 = SWIG_AsVal_int(argv[1], &val2);
9512
 
    if (!SWIG_IsOK(ecode2)) {
9513
 
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OpenShared" "', argument " "2"" of type '" "int""'");
9514
 
    } 
9515
 
    arg2 = static_cast< int >(val2);
9516
 
  }
9517
 
  {
9518
 
    CPLErrorReset();
9519
 
    result = (OGRDataSourceShadow *)OpenShared((char const *)arg1,arg2);
9520
 
    CPLErr eclass = CPLGetLastErrorType();
9521
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9522
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9523
 
      
9524
 
    }
9525
 
  }
9526
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRDataSourceShadow, SWIG_POINTER_OWN |  0 );
9527
 
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
9528
 
  return vresult;
9529
 
fail:
9530
 
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
9531
 
  return Qnil;
9532
 
}
9533
 
 
9534
 
 
9535
 
SWIGINTERN VALUE
9536
 
_wrap_get_driver_by_name(int argc, VALUE *argv, VALUE self) {
9537
 
  char *arg1 = (char *) 0 ;
9538
 
  OGRDriverShadow *result = 0 ;
9539
 
  int res1 ;
9540
 
  char *buf1 = 0 ;
9541
 
  int alloc1 = 0 ;
9542
 
  VALUE vresult = Qnil;
9543
 
  
9544
 
  if ((argc < 1) || (argc > 1)) {
9545
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9546
 
  }
9547
 
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
9548
 
  if (!SWIG_IsOK(res1)) {
9549
 
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetDriverByName" "', argument " "1"" of type '" "char const *""'");
9550
 
  }
9551
 
  arg1 = buf1;
9552
 
  {
9553
 
    CPLErrorReset();
9554
 
    result = (OGRDriverShadow *)GetDriverByName((char const *)arg1);
9555
 
    CPLErr eclass = CPLGetLastErrorType();
9556
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9557
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9558
 
      
9559
 
    }
9560
 
  }
9561
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRDriverShadow, 0 |  0 );
9562
 
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
9563
 
  return vresult;
9564
 
fail:
9565
 
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
9566
 
  return Qnil;
9567
 
}
9568
 
 
9569
 
 
9570
 
SWIGINTERN VALUE
9571
 
_wrap_get_driver(int argc, VALUE *argv, VALUE self) {
9572
 
  int arg1 ;
9573
 
  OGRDriverShadow *result = 0 ;
9574
 
  int val1 ;
9575
 
  int ecode1 = 0 ;
9576
 
  VALUE vresult = Qnil;
9577
 
  
9578
 
  if ((argc < 1) || (argc > 1)) {
9579
 
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9580
 
  }
9581
 
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
9582
 
  if (!SWIG_IsOK(ecode1)) {
9583
 
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetDriver" "', argument " "1"" of type '" "int""'");
9584
 
  } 
9585
 
  arg1 = static_cast< int >(val1);
9586
 
  {
9587
 
    CPLErrorReset();
9588
 
    result = (OGRDriverShadow *)GetDriver(arg1);
9589
 
    CPLErr eclass = CPLGetLastErrorType();
9590
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9591
 
      SWIG_exception( SWIG_RuntimeError, CPLGetLastErrorMsg() );
9592
 
      
9593
 
    }
9594
 
  }
9595
 
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OGRDriverShadow, 0 |  0 );
9596
 
  return vresult;
9597
 
fail:
9598
 
  return Qnil;
9599
 
}
9600
 
 
9601
 
 
9602
 
 
9603
 
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
9604
 
 
9605
 
static swig_type_info _swigt__p_GIntBig = {"_p_GIntBig", "GIntBig *", 0, 0, (void*)0, 0};
9606
 
static swig_type_info _swigt__p_OGRDataSourceShadow = {"_p_OGRDataSourceShadow", "OGRDataSourceShadow *", 0, 0, (void*)0, 0};
9607
 
static swig_type_info _swigt__p_OGRDriverShadow = {"_p_OGRDriverShadow", "OGRDriverShadow *", 0, 0, (void*)0, 0};
9608
 
static swig_type_info _swigt__p_OGRFeatureDefnShadow = {"_p_OGRFeatureDefnShadow", "OGRFeatureDefnShadow *", 0, 0, (void*)0, 0};
9609
 
static swig_type_info _swigt__p_OGRFeatureShadow = {"_p_OGRFeatureShadow", "OGRFeatureShadow *", 0, 0, (void*)0, 0};
9610
 
static swig_type_info _swigt__p_OGRFieldDefnShadow = {"_p_OGRFieldDefnShadow", "OGRFieldDefnShadow *", 0, 0, (void*)0, 0};
9611
 
static swig_type_info _swigt__p_OGRGeometryShadow = {"_p_OGRGeometryShadow", "OGRGeometryShadow *", 0, 0, (void*)0, 0};
9612
 
static swig_type_info _swigt__p_OGRLayerShadow = {"_p_OGRLayerShadow", "OGRLayerShadow *", 0, 0, (void*)0, 0};
9613
 
static swig_type_info _swigt__p_OSRCoordinateTransformationShadow = {"_p_OSRCoordinateTransformationShadow", "OSRCoordinateTransformationShadow *", 0, 0, (void*)0, 0};
9614
 
static swig_type_info _swigt__p_OSRSpatialReferenceShadow = {"_p_OSRSpatialReferenceShadow", "OSRSpatialReferenceShadow *", 0, 0, (void*)0, 0};
9615
 
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
9616
 
static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
9617
 
static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
9618
 
static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
9619
 
 
9620
 
static swig_type_info *swig_type_initial[] = {
9621
 
  &_swigt__p_GIntBig,
9622
 
  &_swigt__p_OGRDataSourceShadow,
9623
 
  &_swigt__p_OGRDriverShadow,
9624
 
  &_swigt__p_OGRFeatureDefnShadow,
9625
 
  &_swigt__p_OGRFeatureShadow,
9626
 
  &_swigt__p_OGRFieldDefnShadow,
9627
 
  &_swigt__p_OGRGeometryShadow,
9628
 
  &_swigt__p_OGRLayerShadow,
9629
 
  &_swigt__p_OSRCoordinateTransformationShadow,
9630
 
  &_swigt__p_OSRSpatialReferenceShadow,
9631
 
  &_swigt__p_char,
9632
 
  &_swigt__p_double,
9633
 
  &_swigt__p_int,
9634
 
  &_swigt__p_p_char,
9635
 
};
9636
 
 
9637
 
static swig_cast_info _swigc__p_GIntBig[] = {  {&_swigt__p_GIntBig, 0, 0, 0},{0, 0, 0, 0}};
9638
 
static swig_cast_info _swigc__p_OGRDataSourceShadow[] = {  {&_swigt__p_OGRDataSourceShadow, 0, 0, 0},{0, 0, 0, 0}};
9639
 
static swig_cast_info _swigc__p_OGRDriverShadow[] = {  {&_swigt__p_OGRDriverShadow, 0, 0, 0},{0, 0, 0, 0}};
9640
 
static swig_cast_info _swigc__p_OGRFeatureDefnShadow[] = {  {&_swigt__p_OGRFeatureDefnShadow, 0, 0, 0},{0, 0, 0, 0}};
9641
 
static swig_cast_info _swigc__p_OGRFeatureShadow[] = {  {&_swigt__p_OGRFeatureShadow, 0, 0, 0},{0, 0, 0, 0}};
9642
 
static swig_cast_info _swigc__p_OGRFieldDefnShadow[] = {  {&_swigt__p_OGRFieldDefnShadow, 0, 0, 0},{0, 0, 0, 0}};
9643
 
static swig_cast_info _swigc__p_OGRGeometryShadow[] = {  {&_swigt__p_OGRGeometryShadow, 0, 0, 0},{0, 0, 0, 0}};
9644
 
static swig_cast_info _swigc__p_OGRLayerShadow[] = {  {&_swigt__p_OGRLayerShadow, 0, 0, 0},{0, 0, 0, 0}};
9645
 
static swig_cast_info _swigc__p_OSRCoordinateTransformationShadow[] = {  {&_swigt__p_OSRCoordinateTransformationShadow, 0, 0, 0},{0, 0, 0, 0}};
9646
 
static swig_cast_info _swigc__p_OSRSpatialReferenceShadow[] = {  {&_swigt__p_OSRSpatialReferenceShadow, 0, 0, 0},{0, 0, 0, 0}};
9647
 
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
9648
 
static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
9649
 
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
9650
 
static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
9651
 
 
9652
 
static swig_cast_info *swig_cast_initial[] = {
9653
 
  _swigc__p_GIntBig,
9654
 
  _swigc__p_OGRDataSourceShadow,
9655
 
  _swigc__p_OGRDriverShadow,
9656
 
  _swigc__p_OGRFeatureDefnShadow,
9657
 
  _swigc__p_OGRFeatureShadow,
9658
 
  _swigc__p_OGRFieldDefnShadow,
9659
 
  _swigc__p_OGRGeometryShadow,
9660
 
  _swigc__p_OGRLayerShadow,
9661
 
  _swigc__p_OSRCoordinateTransformationShadow,
9662
 
  _swigc__p_OSRSpatialReferenceShadow,
9663
 
  _swigc__p_char,
9664
 
  _swigc__p_double,
9665
 
  _swigc__p_int,
9666
 
  _swigc__p_p_char,
9667
 
};
9668
 
 
9669
 
 
9670
 
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
9671
 
 
9672
 
/* -----------------------------------------------------------------------------
9673
 
 * Type initialization:
9674
 
 * This problem is tough by the requirement that no dynamic 
9675
 
 * memory is used. Also, since swig_type_info structures store pointers to 
9676
 
 * swig_cast_info structures and swig_cast_info structures store pointers back
9677
 
 * to swig_type_info structures, we need some lookup code at initialization. 
9678
 
 * The idea is that swig generates all the structures that are needed. 
9679
 
 * The runtime then collects these partially filled structures. 
9680
 
 * The SWIG_InitializeModule function takes these initial arrays out of 
9681
 
 * swig_module, and does all the lookup, filling in the swig_module.types
9682
 
 * array with the correct data and linking the correct swig_cast_info
9683
 
 * structures together.
9684
 
 *
9685
 
 * The generated swig_type_info structures are assigned staticly to an initial 
9686
 
 * array. We just loop though that array, and handle each type individually.
9687
 
 * First we lookup if this type has been already loaded, and if so, use the
9688
 
 * loaded structure instead of the generated one. Then we have to fill in the
9689
 
 * cast linked list. The cast data is initially stored in something like a
9690
 
 * two-dimensional array. Each row corresponds to a type (there are the same
9691
 
 * number of rows as there are in the swig_type_initial array). Each entry in
9692
 
 * a column is one of the swig_cast_info structures for that type.
9693
 
 * The cast_initial array is actually an array of arrays, because each row has
9694
 
 * a variable number of columns. So to actually build the cast linked list,
9695
 
 * we find the array of casts associated with the type, and loop through it 
9696
 
 * adding the casts to the list. The one last trick we need to do is making
9697
 
 * sure the type pointer in the swig_cast_info struct is correct.
9698
 
 *
9699
 
 * First off, we lookup the cast->type name to see if it is already loaded. 
9700
 
 * There are three cases to handle:
9701
 
 *  1) If the cast->type has already been loaded AND the type we are adding
9702
 
 *     casting info to has not been loaded (it is in this module), THEN we
9703
 
 *     replace the cast->type pointer with the type pointer that has already
9704
 
 *     been loaded.
9705
 
 *  2) If BOTH types (the one we are adding casting info to, and the 
9706
 
 *     cast->type) are loaded, THEN the cast info has already been loaded by
9707
 
 *     the previous module so we just ignore it.
9708
 
 *  3) Finally, if cast->type has not already been loaded, then we add that
9709
 
 *     swig_cast_info to the linked list (because the cast->type) pointer will
9710
 
 *     be correct.
9711
 
 * ----------------------------------------------------------------------------- */
9712
 
 
9713
 
#ifdef __cplusplus
9714
 
extern "C" {
9715
 
#if 0
9716
 
} /* c-mode */
9717
 
#endif
9718
 
#endif
9719
 
 
9720
 
#if 0
9721
 
#define SWIGRUNTIME_DEBUG
9722
 
#endif
9723
 
 
9724
 
SWIGRUNTIME void
9725
 
SWIG_InitializeModule(void *clientdata) {
9726
 
  size_t i;
9727
 
  swig_module_info *module_head;
9728
 
  static int init_run = 0;
9729
 
 
9730
 
  clientdata = clientdata;
9731
 
 
9732
 
  if (init_run) return;
9733
 
  init_run = 1;
9734
 
 
9735
 
  /* Initialize the swig_module */
9736
 
  swig_module.type_initial = swig_type_initial;
9737
 
  swig_module.cast_initial = swig_cast_initial;
9738
 
 
9739
 
  /* Try and load any already created modules */
9740
 
  module_head = SWIG_GetModule(clientdata);
9741
 
  if (module_head) {
9742
 
    swig_module.next = module_head->next;
9743
 
    module_head->next = &swig_module;
9744
 
  } else {
9745
 
    /* This is the first module loaded */
9746
 
    swig_module.next = &swig_module;
9747
 
    SWIG_SetModule(clientdata, &swig_module);
9748
 
  }
9749
 
                 
9750
 
  /* Now work on filling in swig_module.types */
9751
 
#ifdef SWIGRUNTIME_DEBUG
9752
 
  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
9753
 
#endif
9754
 
  for (i = 0; i < swig_module.size; ++i) {
9755
 
    swig_type_info *type = 0;
9756
 
    swig_type_info *ret;
9757
 
    swig_cast_info *cast;
9758
 
  
9759
 
#ifdef SWIGRUNTIME_DEBUG
9760
 
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
9761
 
#endif
9762
 
 
9763
 
    /* if there is another module already loaded */
9764
 
    if (swig_module.next != &swig_module) {
9765
 
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
9766
 
    }
9767
 
    if (type) {
9768
 
      /* Overwrite clientdata field */
9769
 
#ifdef SWIGRUNTIME_DEBUG
9770
 
      printf("SWIG_InitializeModule: found type %s\n", type->name);
9771
 
#endif
9772
 
      if (swig_module.type_initial[i]->clientdata) {
9773
 
        type->clientdata = swig_module.type_initial[i]->clientdata;
9774
 
#ifdef SWIGRUNTIME_DEBUG
9775
 
      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
9776
 
#endif
9777
 
      }
9778
 
    } else {
9779
 
      type = swig_module.type_initial[i];
9780
 
    }
9781
 
 
9782
 
    /* Insert casting types */
9783
 
    cast = swig_module.cast_initial[i];
9784
 
    while (cast->type) {
9785
 
    
9786
 
      /* Don't need to add information already in the list */
9787
 
      ret = 0;
9788
 
#ifdef SWIGRUNTIME_DEBUG
9789
 
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
9790
 
#endif
9791
 
      if (swig_module.next != &swig_module) {
9792
 
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
9793
 
#ifdef SWIGRUNTIME_DEBUG
9794
 
        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
9795
 
#endif
9796
 
      }
9797
 
      if (ret) {
9798
 
        if (type == swig_module.type_initial[i]) {
9799
 
#ifdef SWIGRUNTIME_DEBUG
9800
 
          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
9801
 
#endif
9802
 
          cast->type = ret;
9803
 
          ret = 0;
9804
 
        } else {
9805
 
          /* Check for casting already in the list */
9806
 
          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
9807
 
#ifdef SWIGRUNTIME_DEBUG
9808
 
          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
9809
 
#endif
9810
 
          if (!ocast) ret = 0;
9811
 
        }
9812
 
      }
9813
 
 
9814
 
      if (!ret) {
9815
 
#ifdef SWIGRUNTIME_DEBUG
9816
 
        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
9817
 
#endif
9818
 
        if (type->cast) {
9819
 
          type->cast->prev = cast;
9820
 
          cast->next = type->cast;
9821
 
        }
9822
 
        type->cast = cast;
9823
 
      }
9824
 
      cast++;
9825
 
    }
9826
 
    /* Set entry in modules->types array equal to the type */
9827
 
    swig_module.types[i] = type;
9828
 
  }
9829
 
  swig_module.types[i] = 0;
9830
 
 
9831
 
#ifdef SWIGRUNTIME_DEBUG
9832
 
  printf("**** SWIG_InitializeModule: Cast List ******\n");
9833
 
  for (i = 0; i < swig_module.size; ++i) {
9834
 
    int j = 0;
9835
 
    swig_cast_info *cast = swig_module.cast_initial[i];
9836
 
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
9837
 
    while (cast->type) {
9838
 
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
9839
 
      cast++;
9840
 
      ++j;
9841
 
    }
9842
 
  printf("---- Total casts: %d\n",j);
9843
 
  }
9844
 
  printf("**** SWIG_InitializeModule: Cast List ******\n");
9845
 
#endif
9846
 
}
9847
 
 
9848
 
/* This function will propagate the clientdata field of type to
9849
 
* any new swig_type_info structures that have been added into the list
9850
 
* of equivalent types.  It is like calling
9851
 
* SWIG_TypeClientData(type, clientdata) a second time.
9852
 
*/
9853
 
SWIGRUNTIME void
9854
 
SWIG_PropagateClientData(void) {
9855
 
  size_t i;
9856
 
  swig_cast_info *equiv;
9857
 
  static int init_run = 0;
9858
 
 
9859
 
  if (init_run) return;
9860
 
  init_run = 1;
9861
 
 
9862
 
  for (i = 0; i < swig_module.size; i++) {
9863
 
    if (swig_module.types[i]->clientdata) {
9864
 
      equiv = swig_module.types[i]->cast;
9865
 
      while (equiv) {
9866
 
        if (!equiv->converter) {
9867
 
          if (equiv->type && !equiv->type->clientdata)
9868
 
            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
9869
 
        }
9870
 
        equiv = equiv->next;
9871
 
      }
9872
 
    }
9873
 
  }
9874
 
}
9875
 
 
9876
 
#ifdef __cplusplus
9877
 
#if 0
9878
 
{ /* c-mode */
9879
 
#endif
9880
 
}
9881
 
#endif
9882
 
 
9883
 
 
9884
 
#ifdef __cplusplus
9885
 
extern "C"
9886
 
#endif
9887
 
SWIGEXPORT void Init_ogr(void) {
9888
 
  size_t i;
9889
 
  
9890
 
  SWIG_InitRuntime();
9891
 
  mOgr = rb_define_module("Gdal");
9892
 
  mOgr = rb_define_module_under(mOgr, "Ogr");
9893
 
  
9894
 
  SWIG_InitializeModule(0);
9895
 
  for (i = 0; i < swig_module.size; i++) {
9896
 
    SWIG_define_class(swig_module.types[i]);
9897
 
  }
9898
 
  
9899
 
  SWIG_RubyInitializeTrackings();
9900
 
  rb_define_const(mOgr, "WKB25BIT", SWIG_From_int(static_cast< int >(wkb25DBit)));
9901
 
  rb_define_const(mOgr, "WKBUNKNOWN", SWIG_From_int(static_cast< int >(0)));
9902
 
  rb_define_const(mOgr, "WKBPOINT", SWIG_From_int(static_cast< int >(1)));
9903
 
  rb_define_const(mOgr, "WKBLINESTRING", SWIG_From_int(static_cast< int >(2)));
9904
 
  rb_define_const(mOgr, "WKBPOLYGON", SWIG_From_int(static_cast< int >(3)));
9905
 
  rb_define_const(mOgr, "WKBMULTIPOINT", SWIG_From_int(static_cast< int >(4)));
9906
 
  rb_define_const(mOgr, "WKBMULTILINESTRING", SWIG_From_int(static_cast< int >(5)));
9907
 
  rb_define_const(mOgr, "WKBMULTIPOLYGON", SWIG_From_int(static_cast< int >(6)));
9908
 
  rb_define_const(mOgr, "WKBGEOMETRYCOLLECTION", SWIG_From_int(static_cast< int >(7)));
9909
 
  rb_define_const(mOgr, "WKBNONE", SWIG_From_int(static_cast< int >(100)));
9910
 
  rb_define_const(mOgr, "WKBLINEARRING", SWIG_From_int(static_cast< int >(101)));
9911
 
  rb_define_const(mOgr, "WKBPOINT25D", SWIG_From_int(static_cast< int >(wkbPoint+wkb25DBit)));
9912
 
  rb_define_const(mOgr, "WKBLINESTRING25D", SWIG_From_int(static_cast< int >(wkbLineString+wkb25DBit)));
9913
 
  rb_define_const(mOgr, "WKBPOLYGON25D", SWIG_From_int(static_cast< int >(wkbPolygon+wkb25DBit)));
9914
 
  rb_define_const(mOgr, "WKBMULTIPOINT25D", SWIG_From_int(static_cast< int >(wkbMultiPoint+wkb25DBit)));
9915
 
  rb_define_const(mOgr, "WKBMULTILINESTRING25D", SWIG_From_int(static_cast< int >(wkbMultiLineString+wkb25DBit)));
9916
 
  rb_define_const(mOgr, "WKBMULTIPOLYGON25D", SWIG_From_int(static_cast< int >(wkbMultiPolygon+wkb25DBit)));
9917
 
  rb_define_const(mOgr, "WKBGEOMETRYCOLLECTION25D", SWIG_From_int(static_cast< int >(wkbGeometryCollection+wkb25DBit)));
9918
 
  rb_define_const(mOgr, "OFTINTEGER", SWIG_From_int(static_cast< int >(0)));
9919
 
  rb_define_const(mOgr, "OFTINTEGERLIST", SWIG_From_int(static_cast< int >(1)));
9920
 
  rb_define_const(mOgr, "OFTREAL", SWIG_From_int(static_cast< int >(2)));
9921
 
  rb_define_const(mOgr, "OFTREALLIST", SWIG_From_int(static_cast< int >(3)));
9922
 
  rb_define_const(mOgr, "OFTSTRING", SWIG_From_int(static_cast< int >(4)));
9923
 
  rb_define_const(mOgr, "OFTSTRINGLIST", SWIG_From_int(static_cast< int >(5)));
9924
 
  rb_define_const(mOgr, "OFTWIDESTRING", SWIG_From_int(static_cast< int >(6)));
9925
 
  rb_define_const(mOgr, "OFTWIDESTRINGLIST", SWIG_From_int(static_cast< int >(7)));
9926
 
  rb_define_const(mOgr, "OFTBINARY", SWIG_From_int(static_cast< int >(8)));
9927
 
  rb_define_const(mOgr, "OFTDATE", SWIG_From_int(static_cast< int >(9)));
9928
 
  rb_define_const(mOgr, "OFTTIME", SWIG_From_int(static_cast< int >(10)));
9929
 
  rb_define_const(mOgr, "OFTDATETIME", SWIG_From_int(static_cast< int >(11)));
9930
 
  rb_define_const(mOgr, "OJUNDEFINED", SWIG_From_int(static_cast< int >(0)));
9931
 
  rb_define_const(mOgr, "OJLEFT", SWIG_From_int(static_cast< int >(1)));
9932
 
  rb_define_const(mOgr, "OJRIGHT", SWIG_From_int(static_cast< int >(2)));
9933
 
  rb_define_const(mOgr, "WKBXDR", SWIG_From_int(static_cast< int >(0)));
9934
 
  rb_define_const(mOgr, "WKBNDR", SWIG_From_int(static_cast< int >(1)));
9935
 
  rb_define_const(mOgr, "OLCRANDOMREAD", SWIG_FromCharPtr("RandomRead"));
9936
 
  rb_define_const(mOgr, "OLCSEQUENTIALWRITE", SWIG_FromCharPtr("SequentialWrite"));
9937
 
  rb_define_const(mOgr, "OLCRANDOMWRITE", SWIG_FromCharPtr("RandomWrite"));
9938
 
  rb_define_const(mOgr, "OLCFASTSPATIALFILTER", SWIG_FromCharPtr("FastSpatialFilter"));
9939
 
  rb_define_const(mOgr, "OLCFASTFEATURECOUNT", SWIG_FromCharPtr("FastFeatureCount"));
9940
 
  rb_define_const(mOgr, "OLCFASTGETEXTENT", SWIG_FromCharPtr("FastGetExtent"));
9941
 
  rb_define_const(mOgr, "OLCCREATEFIELD", SWIG_FromCharPtr("CreateField"));
9942
 
  rb_define_const(mOgr, "OLCTRANSACTIONS", SWIG_FromCharPtr("Transactions"));
9943
 
  rb_define_const(mOgr, "OLCDELETEFEATURE", SWIG_FromCharPtr("DeleteFeature"));
9944
 
  rb_define_const(mOgr, "OLCFASTSETNEXTBYINDEX", SWIG_FromCharPtr("FastSetNextByIndex"));
9945
 
  rb_define_const(mOgr, "ODSCCREATELAYER", SWIG_FromCharPtr("CreateLayer"));
9946
 
  rb_define_const(mOgr, "ODSCDELETELAYER", SWIG_FromCharPtr("DeleteLayer"));
9947
 
  rb_define_const(mOgr, "ODRCCREATEDATASOURCE", SWIG_FromCharPtr("CreateDataSource"));
9948
 
  rb_define_const(mOgr, "ODRCDELETEDATASOURCE", SWIG_FromCharPtr("DeleteDataSource"));
9949
 
  rb_define_module_function(mOgr, "use_exceptions", VALUEFUNC(_wrap_use_exceptions), -1);
9950
 
  rb_define_module_function(mOgr, "dont_use_exceptions", VALUEFUNC(_wrap_dont_use_exceptions), -1);
9951
 
  
9952
 
  
9953
 
  if ( OGRGetDriverCount() == 0 ) {
9954
 
    OGRRegisterAll();
9955
 
  }
9956
 
  
9957
 
  /* Setup exception handling */
9958
 
  UseExceptions();
9959
 
  
9960
 
  rb_require("gdal/osr");
9961
 
  
9962
 
  cDriver.klass = rb_define_class_under(mOgr, "Driver", rb_cObject);
9963
 
  SWIG_TypeClientData(SWIGTYPE_p_OGRDriverShadow, (void *) &cDriver);
9964
 
  rb_undef_alloc_func(cDriver.klass);
9965
 
  rb_define_method(cDriver.klass, "name", VALUEFUNC(_wrap_Driver_name_get), -1);
9966
 
  rb_define_method(cDriver.klass, "create_data_source", VALUEFUNC(_wrap_Driver_create_data_source), -1);
9967
 
  rb_define_method(cDriver.klass, "copy_data_source", VALUEFUNC(_wrap_Driver_copy_data_source), -1);
9968
 
  rb_define_method(cDriver.klass, "open", VALUEFUNC(_wrap_Driver_open), -1);
9969
 
  rb_define_method(cDriver.klass, "delete_data_source", VALUEFUNC(_wrap_Driver_delete_data_source), -1);
9970
 
  rb_define_method(cDriver.klass, "test_capability", VALUEFUNC(_wrap_Driver_test_capability), -1);
9971
 
  rb_define_method(cDriver.klass, "get_name", VALUEFUNC(_wrap_Driver_get_name), -1);
9972
 
  cDriver.mark = 0;
9973
 
  cDriver.trackObjects = 0;
9974
 
  
9975
 
  cDataSource.klass = rb_define_class_under(mOgr, "DataSource", rb_cObject);
9976
 
  SWIG_TypeClientData(SWIGTYPE_p_OGRDataSourceShadow, (void *) &cDataSource);
9977
 
  rb_undef_alloc_func(cDataSource.klass);
9978
 
  rb_define_method(cDataSource.klass, "name", VALUEFUNC(_wrap_DataSource_name_get), -1);
9979
 
  rb_define_method(cDataSource.klass, "get_ref_count", VALUEFUNC(_wrap_DataSource_get_ref_count), -1);
9980
 
  rb_define_method(cDataSource.klass, "get_summary_ref_count", VALUEFUNC(_wrap_DataSource_get_summary_ref_count), -1);
9981
 
  rb_define_method(cDataSource.klass, "get_layer_count", VALUEFUNC(_wrap_DataSource_get_layer_count), -1);
9982
 
  rb_define_method(cDataSource.klass, "get_driver", VALUEFUNC(_wrap_DataSource_get_driver), -1);
9983
 
  rb_define_method(cDataSource.klass, "get_name", VALUEFUNC(_wrap_DataSource_get_name), -1);
9984
 
  rb_define_method(cDataSource.klass, "delete_layer", VALUEFUNC(_wrap_DataSource_delete_layer), -1);
9985
 
  rb_define_method(cDataSource.klass, "create_layer", VALUEFUNC(_wrap_DataSource_create_layer), -1);
9986
 
  rb_define_method(cDataSource.klass, "copy_layer", VALUEFUNC(_wrap_DataSource_copy_layer), -1);
9987
 
  rb_define_method(cDataSource.klass, "test_capability", VALUEFUNC(_wrap_DataSource_test_capability), -1);
9988
 
  rb_define_method(cDataSource.klass, "execute_sql", VALUEFUNC(_wrap_DataSource_execute_sql), -1);
9989
 
  rb_define_method(cDataSource.klass, "release_result_set", VALUEFUNC(_wrap_DataSource_release_result_set), -1);
9990
 
  rb_define_method(cDataSource.klass, "get_layer", VALUEFUNC(_wrap_DataSource_get_layer), -1);
9991
 
  cDataSource.mark = 0;
9992
 
  cDataSource.destroy = (void (*)(void *)) free_OGRDataSourceShadow;
9993
 
  cDataSource.trackObjects = 0;
9994
 
  
9995
 
  cLayer.klass = rb_define_class_under(mOgr, "Layer", rb_cObject);
9996
 
  SWIG_TypeClientData(SWIGTYPE_p_OGRLayerShadow, (void *) &cLayer);
9997
 
  rb_include_module(cLayer.klass, rb_eval_string("Enumerable"));
9998
 
  rb_undef_alloc_func(cLayer.klass);
9999
 
  rb_define_method(cLayer.klass, "get_ref_count", VALUEFUNC(_wrap_Layer_get_ref_count), -1);
10000
 
  rb_define_method(cLayer.klass, "set_spatial_filter", VALUEFUNC(_wrap_Layer_set_spatial_filter), -1);
10001
 
  rb_define_method(cLayer.klass, "set_spatial_filter_rect", VALUEFUNC(_wrap_Layer_set_spatial_filter_rect), -1);
10002
 
  rb_define_method(cLayer.klass, "get_spatial_filter", VALUEFUNC(_wrap_Layer_get_spatial_filter), -1);
10003
 
  rb_define_method(cLayer.klass, "set_attribute_filter", VALUEFUNC(_wrap_Layer_set_attribute_filter), -1);
10004
 
  rb_define_method(cLayer.klass, "reset_reading", VALUEFUNC(_wrap_Layer_reset_reading), -1);
10005
 
  rb_define_method(cLayer.klass, "get_name", VALUEFUNC(_wrap_Layer_get_name), -1);
10006
 
  rb_define_method(cLayer.klass, "get_feature", VALUEFUNC(_wrap_Layer_get_feature), -1);
10007
 
  rb_define_method(cLayer.klass, "get_next_feature", VALUEFUNC(_wrap_Layer_get_next_feature), -1);
10008
 
  rb_define_method(cLayer.klass, "set_next_by_index", VALUEFUNC(_wrap_Layer_set_next_by_index), -1);
10009
 
  rb_define_method(cLayer.klass, "set_feature", VALUEFUNC(_wrap_Layer_set_feature), -1);
10010
 
  rb_define_method(cLayer.klass, "create_feature", VALUEFUNC(_wrap_Layer_create_feature), -1);
10011
 
  rb_define_method(cLayer.klass, "delete_feature", VALUEFUNC(_wrap_Layer_delete_feature), -1);
10012
 
  rb_define_method(cLayer.klass, "sync_to_disk", VALUEFUNC(_wrap_Layer_sync_to_disk), -1);
10013
 
  rb_define_method(cLayer.klass, "get_layer_defn", VALUEFUNC(_wrap_Layer_get_layer_defn), -1);
10014
 
  rb_define_method(cLayer.klass, "get_feature_count", VALUEFUNC(_wrap_Layer_get_feature_count), -1);
10015
 
  rb_define_method(cLayer.klass, "get_extent", VALUEFUNC(_wrap_Layer_get_extent), -1);
10016
 
  rb_define_method(cLayer.klass, "test_capability", VALUEFUNC(_wrap_Layer_test_capability), -1);
10017
 
  rb_define_method(cLayer.klass, "create_field", VALUEFUNC(_wrap_Layer_create_field), -1);
10018
 
  rb_define_method(cLayer.klass, "start_transaction", VALUEFUNC(_wrap_Layer_start_transaction), -1);
10019
 
  rb_define_method(cLayer.klass, "commit_transaction", VALUEFUNC(_wrap_Layer_commit_transaction), -1);
10020
 
  rb_define_method(cLayer.klass, "rollback_transaction", VALUEFUNC(_wrap_Layer_rollback_transaction), -1);
10021
 
  rb_define_method(cLayer.klass, "get_spatial_ref", VALUEFUNC(_wrap_Layer_get_spatial_ref), -1);
10022
 
  rb_define_method(cLayer.klass, "get_feature_read", VALUEFUNC(_wrap_Layer_get_feature_read), -1);
10023
 
  rb_define_method(cLayer.klass, "each", VALUEFUNC(_wrap_Layer_each), -1);
10024
 
  cLayer.mark = 0;
10025
 
  cLayer.trackObjects = 0;
10026
 
  
10027
 
  cFeature.klass = rb_define_class_under(mOgr, "Feature", rb_cObject);
10028
 
  SWIG_TypeClientData(SWIGTYPE_p_OGRFeatureShadow, (void *) &cFeature);
10029
 
  rb_define_alloc_func(cFeature.klass, _wrap_Feature_allocate);
10030
 
  rb_define_method(cFeature.klass, "initialize", VALUEFUNC(_wrap_new_Feature), -1);
10031
 
  rb_define_method(cFeature.klass, "get_defn_ref", VALUEFUNC(_wrap_Feature_get_defn_ref), -1);
10032
 
  rb_define_method(cFeature.klass, "set_geometry", VALUEFUNC(_wrap_Feature_set_geometry), -1);
10033
 
  rb_define_method(cFeature.klass, "set_geometry_directly", VALUEFUNC(_wrap_Feature_set_geometry_directly), -1);
10034
 
  rb_define_method(cFeature.klass, "get_geometry_ref", VALUEFUNC(_wrap_Feature_get_geometry_ref), -1);
10035
 
  rb_define_method(cFeature.klass, "clone", VALUEFUNC(_wrap_Feature_clone), -1);
10036
 
  rb_define_method(cFeature.klass, "equal", VALUEFUNC(_wrap_Feature_equal), -1);
10037
 
  rb_define_method(cFeature.klass, "get_field_count", VALUEFUNC(_wrap_Feature_get_field_count), -1);
10038
 
  rb_define_method(cFeature.klass, "get_field_defn_ref", VALUEFUNC(_wrap_Feature_get_field_defn_ref), -1);
10039
 
  rb_define_method(cFeature.klass, "get_field_as_string", VALUEFUNC(_wrap_Feature_get_field_as_string), -1);
10040
 
  rb_define_method(cFeature.klass, "get_field_as_integer", VALUEFUNC(_wrap_Feature_get_field_as_integer), -1);
10041
 
  rb_define_method(cFeature.klass, "get_field_as_double", VALUEFUNC(_wrap_Feature_get_field_as_double), -1);
10042
 
  rb_define_method(cFeature.klass, "is_field_set", VALUEFUNC(_wrap_Feature_is_field_set), -1);
10043
 
  rb_define_method(cFeature.klass, "get_field_index", VALUEFUNC(_wrap_Feature_get_field_index), -1);
10044
 
  rb_define_method(cFeature.klass, "get_fid", VALUEFUNC(_wrap_Feature_get_fid), -1);
10045
 
  rb_define_method(cFeature.klass, "set_fid", VALUEFUNC(_wrap_Feature_set_fid), -1);
10046
 
  rb_define_method(cFeature.klass, "dump_readable", VALUEFUNC(_wrap_Feature_dump_readable), -1);
10047
 
  rb_define_method(cFeature.klass, "unset_field", VALUEFUNC(_wrap_Feature_unset_field), -1);
10048
 
  rb_define_method(cFeature.klass, "set_field", VALUEFUNC(_wrap_Feature_set_field), -1);
10049
 
  rb_define_method(cFeature.klass, "set_from", VALUEFUNC(_wrap_Feature_set_from), -1);
10050
 
  rb_define_method(cFeature.klass, "get_style_string", VALUEFUNC(_wrap_Feature_get_style_string), -1);
10051
 
  rb_define_method(cFeature.klass, "set_style_string", VALUEFUNC(_wrap_Feature_set_style_string), -1);
10052
 
  rb_define_method(cFeature.klass, "get_field_type", VALUEFUNC(_wrap_Feature_get_field_type), -1);
10053
 
  rb_define_method(cFeature.klass, "get_field", VALUEFUNC(_wrap_Feature_get_field), -1);
10054
 
  cFeature.mark = 0;
10055
 
  cFeature.destroy = (void (*)(void *)) free_OGRFeatureShadow;
10056
 
  cFeature.trackObjects = 0;
10057
 
  
10058
 
  cFeatureDefn.klass = rb_define_class_under(mOgr, "FeatureDefn", rb_cObject);
10059
 
  SWIG_TypeClientData(SWIGTYPE_p_OGRFeatureDefnShadow, (void *) &cFeatureDefn);
10060
 
  rb_define_alloc_func(cFeatureDefn.klass, _wrap_FeatureDefn_allocate);
10061
 
  rb_define_method(cFeatureDefn.klass, "initialize", VALUEFUNC(_wrap_new_FeatureDefn), -1);
10062
 
  rb_define_method(cFeatureDefn.klass, "get_name", VALUEFUNC(_wrap_FeatureDefn_get_name), -1);
10063
 
  rb_define_method(cFeatureDefn.klass, "get_field_count", VALUEFUNC(_wrap_FeatureDefn_get_field_count), -1);
10064
 
  rb_define_method(cFeatureDefn.klass, "get_field_defn", VALUEFUNC(_wrap_FeatureDefn_get_field_defn), -1);
10065
 
  rb_define_method(cFeatureDefn.klass, "get_field_index", VALUEFUNC(_wrap_FeatureDefn_get_field_index), -1);
10066
 
  rb_define_method(cFeatureDefn.klass, "add_field_defn", VALUEFUNC(_wrap_FeatureDefn_add_field_defn), -1);
10067
 
  rb_define_method(cFeatureDefn.klass, "get_geom_type", VALUEFUNC(_wrap_FeatureDefn_get_geom_type), -1);
10068
 
  rb_define_method(cFeatureDefn.klass, "set_geom_type", VALUEFUNC(_wrap_FeatureDefn_set_geom_type), -1);
10069
 
  rb_define_method(cFeatureDefn.klass, "get_reference_count", VALUEFUNC(_wrap_FeatureDefn_get_reference_count), -1);
10070
 
  cFeatureDefn.mark = 0;
10071
 
  cFeatureDefn.destroy = (void (*)(void *)) free_OGRFeatureDefnShadow;
10072
 
  cFeatureDefn.trackObjects = 0;
10073
 
  
10074
 
  cFieldDefn.klass = rb_define_class_under(mOgr, "FieldDefn", rb_cObject);
10075
 
  SWIG_TypeClientData(SWIGTYPE_p_OGRFieldDefnShadow, (void *) &cFieldDefn);
10076
 
  rb_define_alloc_func(cFieldDefn.klass, _wrap_FieldDefn_allocate);
10077
 
  rb_define_method(cFieldDefn.klass, "initialize", VALUEFUNC(_wrap_new_FieldDefn), -1);
10078
 
  rb_define_method(cFieldDefn.klass, "get_name", VALUEFUNC(_wrap_FieldDefn_get_name), -1);
10079
 
  rb_define_method(cFieldDefn.klass, "get_name_ref", VALUEFUNC(_wrap_FieldDefn_get_name_ref), -1);
10080
 
  rb_define_method(cFieldDefn.klass, "set_name", VALUEFUNC(_wrap_FieldDefn_set_name), -1);
10081
 
  rb_define_method(cFieldDefn.klass, "get_type", VALUEFUNC(_wrap_FieldDefn_get_type), -1);
10082
 
  rb_define_method(cFieldDefn.klass, "set_type", VALUEFUNC(_wrap_FieldDefn_set_type), -1);
10083
 
  rb_define_method(cFieldDefn.klass, "get_justify", VALUEFUNC(_wrap_FieldDefn_get_justify), -1);
10084
 
  rb_define_method(cFieldDefn.klass, "set_justify", VALUEFUNC(_wrap_FieldDefn_set_justify), -1);
10085
 
  rb_define_method(cFieldDefn.klass, "get_width", VALUEFUNC(_wrap_FieldDefn_get_width), -1);
10086
 
  rb_define_method(cFieldDefn.klass, "set_width", VALUEFUNC(_wrap_FieldDefn_set_width), -1);
10087
 
  rb_define_method(cFieldDefn.klass, "get_precision", VALUEFUNC(_wrap_FieldDefn_get_precision), -1);
10088
 
  rb_define_method(cFieldDefn.klass, "set_precision", VALUEFUNC(_wrap_FieldDefn_set_precision), -1);
10089
 
  rb_define_method(cFieldDefn.klass, "get_field_type_name", VALUEFUNC(_wrap_FieldDefn_get_field_type_name), -1);
10090
 
  cFieldDefn.mark = 0;
10091
 
  cFieldDefn.destroy = (void (*)(void *)) free_OGRFieldDefnShadow;
10092
 
  cFieldDefn.trackObjects = 0;
10093
 
  rb_define_module_function(mOgr, "create_geometry_from_wkb", VALUEFUNC(_wrap_create_geometry_from_wkb), -1);
10094
 
  rb_define_module_function(mOgr, "create_geometry_from_wkt", VALUEFUNC(_wrap_create_geometry_from_wkt), -1);
10095
 
  rb_define_module_function(mOgr, "create_geometry_from_gml", VALUEFUNC(_wrap_create_geometry_from_gml), -1);
10096
 
  
10097
 
  cGeometry.klass = rb_define_class_under(mOgr, "Geometry", rb_cObject);
10098
 
  SWIG_TypeClientData(SWIGTYPE_p_OGRGeometryShadow, (void *) &cGeometry);
10099
 
  rb_define_alloc_func(cGeometry.klass, _wrap_Geometry_allocate);
10100
 
  rb_define_method(cGeometry.klass, "initialize", VALUEFUNC(_wrap_new_Geometry), -1);
10101
 
  rb_define_method(cGeometry.klass, "export_to_wkt", VALUEFUNC(_wrap_Geometry_export_to_wkt), -1);
10102
 
  rb_define_method(cGeometry.klass, "export_to_wkb", VALUEFUNC(_wrap_Geometry_export_to_wkb), -1);
10103
 
  rb_define_method(cGeometry.klass, "export_to_gml", VALUEFUNC(_wrap_Geometry_export_to_gml), -1);
10104
 
  rb_define_method(cGeometry.klass, "add_point", VALUEFUNC(_wrap_Geometry_add_point), -1);
10105
 
  rb_define_method(cGeometry.klass, "add_geometry_directly", VALUEFUNC(_wrap_Geometry_add_geometry_directly), -1);
10106
 
  rb_define_method(cGeometry.klass, "add_geometry", VALUEFUNC(_wrap_Geometry_add_geometry), -1);
10107
 
  rb_define_method(cGeometry.klass, "clone", VALUEFUNC(_wrap_Geometry_clone), -1);
10108
 
  rb_define_method(cGeometry.klass, "get_geometry_type", VALUEFUNC(_wrap_Geometry_get_geometry_type), -1);
10109
 
  rb_define_method(cGeometry.klass, "get_geometry_name", VALUEFUNC(_wrap_Geometry_get_geometry_name), -1);
10110
 
  rb_define_method(cGeometry.klass, "get_area", VALUEFUNC(_wrap_Geometry_get_area), -1);
10111
 
  rb_define_method(cGeometry.klass, "get_point_count", VALUEFUNC(_wrap_Geometry_get_point_count), -1);
10112
 
  rb_define_method(cGeometry.klass, "get_x", VALUEFUNC(_wrap_Geometry_get_x), -1);
10113
 
  rb_define_method(cGeometry.klass, "get_y", VALUEFUNC(_wrap_Geometry_get_y), -1);
10114
 
  rb_define_method(cGeometry.klass, "get_z", VALUEFUNC(_wrap_Geometry_get_z), -1);
10115
 
  rb_define_method(cGeometry.klass, "get_geometry_count", VALUEFUNC(_wrap_Geometry_get_geometry_count), -1);
10116
 
  rb_define_method(cGeometry.klass, "set_point", VALUEFUNC(_wrap_Geometry_set_point), -1);
10117
 
  rb_define_method(cGeometry.klass, "get_geometry_ref", VALUEFUNC(_wrap_Geometry_get_geometry_ref), -1);
10118
 
  rb_define_method(cGeometry.klass, "get_boundary", VALUEFUNC(_wrap_Geometry_get_boundary), -1);
10119
 
  rb_define_method(cGeometry.klass, "convex_hull", VALUEFUNC(_wrap_Geometry_convex_hull), -1);
10120
 
  rb_define_method(cGeometry.klass, "buffer", VALUEFUNC(_wrap_Geometry_buffer), -1);
10121
 
  rb_define_method(cGeometry.klass, "intersection", VALUEFUNC(_wrap_Geometry_intersection), -1);
10122
 
  rb_define_method(cGeometry.klass, "union", VALUEFUNC(_wrap_Geometry_union), -1);
10123
 
  rb_define_method(cGeometry.klass, "difference", VALUEFUNC(_wrap_Geometry_difference), -1);
10124
 
  rb_define_method(cGeometry.klass, "symmetric_difference", VALUEFUNC(_wrap_Geometry_symmetric_difference), -1);
10125
 
  rb_define_method(cGeometry.klass, "distance", VALUEFUNC(_wrap_Geometry_distance), -1);
10126
 
  rb_define_method(cGeometry.klass, "empty", VALUEFUNC(_wrap_Geometry_empty), -1);
10127
 
  rb_define_method(cGeometry.klass, "intersect", VALUEFUNC(_wrap_Geometry_intersect), -1);
10128
 
  rb_define_method(cGeometry.klass, "equal", VALUEFUNC(_wrap_Geometry_equal), -1);
10129
 
  rb_define_method(cGeometry.klass, "disjoint", VALUEFUNC(_wrap_Geometry_disjoint), -1);
10130
 
  rb_define_method(cGeometry.klass, "touches", VALUEFUNC(_wrap_Geometry_touches), -1);
10131
 
  rb_define_method(cGeometry.klass, "crosses", VALUEFUNC(_wrap_Geometry_crosses), -1);
10132
 
  rb_define_method(cGeometry.klass, "within", VALUEFUNC(_wrap_Geometry_within), -1);
10133
 
  rb_define_method(cGeometry.klass, "contains", VALUEFUNC(_wrap_Geometry_contains), -1);
10134
 
  rb_define_method(cGeometry.klass, "overlaps", VALUEFUNC(_wrap_Geometry_overlaps), -1);
10135
 
  rb_define_method(cGeometry.klass, "transform_to", VALUEFUNC(_wrap_Geometry_transform_to), -1);
10136
 
  rb_define_method(cGeometry.klass, "transform", VALUEFUNC(_wrap_Geometry_transform), -1);
10137
 
  rb_define_method(cGeometry.klass, "get_spatial_reference", VALUEFUNC(_wrap_Geometry_get_spatial_reference), -1);
10138
 
  rb_define_method(cGeometry.klass, "assign_spatial_reference", VALUEFUNC(_wrap_Geometry_assign_spatial_reference), -1);
10139
 
  rb_define_method(cGeometry.klass, "close_rings", VALUEFUNC(_wrap_Geometry_close_rings), -1);
10140
 
  rb_define_method(cGeometry.klass, "flatten_to_2d", VALUEFUNC(_wrap_Geometry_flatten_to_2d), -1);
10141
 
  rb_define_method(cGeometry.klass, "get_envelope", VALUEFUNC(_wrap_Geometry_get_envelope), -1);
10142
 
  rb_define_method(cGeometry.klass, "centroid", VALUEFUNC(_wrap_Geometry_centroid), -1);
10143
 
  rb_define_method(cGeometry.klass, "wkb_size", VALUEFUNC(_wrap_Geometry_wkb_size), -1);
10144
 
  rb_define_method(cGeometry.klass, "get_coordinate_dimension", VALUEFUNC(_wrap_Geometry_get_coordinate_dimension), -1);
10145
 
  rb_define_method(cGeometry.klass, "set_coordinate_dimension", VALUEFUNC(_wrap_Geometry_set_coordinate_dimension), -1);
10146
 
  rb_define_method(cGeometry.klass, "get_dimension", VALUEFUNC(_wrap_Geometry_get_dimension), -1);
10147
 
  cGeometry.mark = 0;
10148
 
  cGeometry.destroy = (void (*)(void *)) free_OGRGeometryShadow;
10149
 
  cGeometry.trackObjects = 0;
10150
 
  rb_define_module_function(mOgr, "get_driver_count", VALUEFUNC(_wrap_get_driver_count), -1);
10151
 
  rb_define_module_function(mOgr, "get_open_dscount", VALUEFUNC(_wrap_get_open_dscount), -1);
10152
 
  rb_define_module_function(mOgr, "set_generate_db2_v72_byte_order", VALUEFUNC(_wrap_set_generate_db2_v72_byte_order), -1);
10153
 
  rb_define_module_function(mOgr, "register_all", VALUEFUNC(_wrap_register_all), -1);
10154
 
  rb_define_module_function(mOgr, "get_open_ds", VALUEFUNC(_wrap_get_open_ds), -1);
10155
 
  rb_define_module_function(mOgr, "open", VALUEFUNC(_wrap_open), -1);
10156
 
  rb_define_module_function(mOgr, "open_shared", VALUEFUNC(_wrap_open_shared), -1);
10157
 
  rb_define_module_function(mOgr, "get_driver_by_name", VALUEFUNC(_wrap_get_driver_by_name), -1);
10158
 
  rb_define_module_function(mOgr, "get_driver", VALUEFUNC(_wrap_get_driver), -1);
10159
 
}
10160