← Back to branch summary

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

« back to all changes in this revision

Viewing changes to swig/php/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/php/ogr_wrap.cpp
1
1
/* ----------------------------------------------------------------------------
2
2
 * This file was automatically generated by SWIG (http://www.swig.org).
3
 
 * Version 1.3.26
 
3
 * Version 1.3.40
4
4
 * 
5
5
 * This file is not intended to be easily readable and contains a number of 
6
6
 * coding conventions designed to improve portability and efficiency. Do not make
8
8
 * interface file instead. 
9
9
 * ----------------------------------------------------------------------------- */
10
10
 
 
11
#define SWIGPHP
 
12
 
11
13
 
12
14
#ifdef __cplusplus
13
 
template<class T> class SwigValueWrapper {
14
 
    T *tt;
 
15
/* SwigValueWrapper is described in swig.swg */
 
16
template<typename T> class SwigValueWrapper {
 
17
  struct SwigMovePointer {
 
18
    T *ptr;
 
19
    SwigMovePointer(T *p) : ptr(p) { }
 
20
    ~SwigMovePointer() { delete ptr; }
 
21
    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
 
22
  } pointer;
 
23
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
 
24
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
15
25
public:
16
 
    SwigValueWrapper() : tt(0) { }
17
 
    SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
18
 
    SwigValueWrapper(const T& t) : tt(new T(t)) { }
19
 
    ~SwigValueWrapper() { delete tt; } 
20
 
    SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
21
 
    operator T&() const { return *tt; }
22
 
    T *operator&() { return tt; }
23
 
private:
24
 
    SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
 
26
  SwigValueWrapper() : pointer(0) { }
 
27
  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
 
28
  operator T&() const { return *pointer.ptr; }
 
29
  T *operator&() { return pointer.ptr; }
25
30
};
 
31
 
 
32
template <typename T> T SwigValueInit() {
 
33
  return T();
 
34
}
26
35
#endif
27
36
 
28
 
/***********************************************************************
29
 
 *
 
37
/* -----------------------------------------------------------------------------
30
38
 *  This section contains generic SWIG labels for method/variable
31
39
 *  declarations/attributes, and other compiler dependent labels.
32
 
 *
33
 
 ************************************************************************/
 
40
 * ----------------------------------------------------------------------------- */
34
41
 
35
42
/* template workaround for compilers that cannot correctly implement the C++ standard */
36
43
#ifndef SWIGTEMPLATEDISAMBIGUATOR
37
 
#  if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
38
 
#    define SWIGTEMPLATEDISAMBIGUATOR template
39
 
#  else
40
 
#    define SWIGTEMPLATEDISAMBIGUATOR 
41
 
#  endif
 
44
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
 
45
#  define SWIGTEMPLATEDISAMBIGUATOR template
 
46
# elif defined(__HP_aCC)
 
47
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
 
48
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
 
49
#  define SWIGTEMPLATEDISAMBIGUATOR template
 
50
# else
 
51
#  define SWIGTEMPLATEDISAMBIGUATOR
 
52
# endif
42
53
#endif
43
54
 
44
55
/* inline attribute */
52
63
 
53
64
/* attribute recognised by some compilers to avoid 'unused' warnings */
54
65
#ifndef SWIGUNUSED
55
 
# if defined(__GNUC__) || defined(__ICC)
56
 
#   define SWIGUNUSED __attribute__ ((unused)) 
 
66
# if defined(__GNUC__)
 
67
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
 
68
#     define SWIGUNUSED __attribute__ ((__unused__)) 
 
69
#   else
 
70
#     define SWIGUNUSED
 
71
#   endif
 
72
# elif defined(__ICC)
 
73
#   define SWIGUNUSED __attribute__ ((__unused__)) 
57
74
# else
58
75
#   define SWIGUNUSED 
59
76
# endif
60
77
#endif
61
78
 
 
79
#ifndef SWIG_MSC_UNSUPPRESS_4505
 
80
# if defined(_MSC_VER)
 
81
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
 
82
# endif 
 
83
#endif
 
84
 
 
85
#ifndef SWIGUNUSEDPARM
 
86
# ifdef __cplusplus
 
87
#   define SWIGUNUSEDPARM(p)
 
88
# else
 
89
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
 
90
# endif
 
91
#endif
 
92
 
62
93
/* internal SWIG method */
63
94
#ifndef SWIGINTERN
64
95
# define SWIGINTERN static SWIGUNUSED
69
100
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
70
101
#endif
71
102
 
72
 
/* exporting methods for Windows DLLs */
 
103
/* exporting methods */
 
104
#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 
105
#  ifndef GCC_HASCLASSVISIBILITY
 
106
#    define GCC_HASCLASSVISIBILITY
 
107
#  endif
 
108
#endif
 
109
 
73
110
#ifndef SWIGEXPORT
74
111
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
75
112
#   if defined(STATIC_LINKED)
78
115
#     define SWIGEXPORT __declspec(dllexport)
79
116
#   endif
80
117
# else
81
 
#   define SWIGEXPORT
 
118
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 
119
#     define SWIGEXPORT __attribute__ ((visibility("default")))
 
120
#   else
 
121
#     define SWIGEXPORT
 
122
#   endif
82
123
# endif
83
124
#endif
84
125
 
91
132
# endif 
92
133
#endif
93
134
 
94
 
 
95
 
/***********************************************************************
 
135
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 
136
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 
137
# define _CRT_SECURE_NO_DEPRECATE
 
138
#endif
 
139
 
 
140
/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 
141
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 
142
# define _SCL_SECURE_NO_DEPRECATE
 
143
#endif
 
144
 
 
145
 
 
146
/* -----------------------------------------------------------------------------
96
147
 * swigrun.swg
97
148
 *
98
 
 *     This file contains generic CAPI SWIG runtime support for pointer
99
 
 *     type checking.
100
 
 *
101
 
 ************************************************************************/
 
149
 * This file contains generic C API SWIG runtime support for pointer
 
150
 * type checking.
 
151
 * ----------------------------------------------------------------------------- */
102
152
 
103
153
/* This should only be incremented when either the layout of swig_type_info changes,
104
154
   or for whatever reason, the runtime changes incompatibly */
105
 
#define SWIG_RUNTIME_VERSION "2"
 
155
#define SWIG_RUNTIME_VERSION "4"
106
156
 
107
157
/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
108
158
#ifdef SWIG_TYPE_TABLE
115
165
 
116
166
/*
117
167
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
118
 
  creating a static or dynamic library from the swig runtime code.
119
 
  In 99.9% of the cases, swig just needs to declare them as 'static'.
 
168
  creating a static or dynamic library from the SWIG runtime code.
 
169
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
120
170
  
121
 
  But only do this if is strictly necessary, ie, if you have problems
122
 
  with your compiler or so.
 
171
  But only do this if strictly necessary, ie, if you have problems
 
172
  with your compiler or suchlike.
123
173
*/
124
174
 
125
175
#ifndef SWIGRUNTIME
130
180
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
131
181
#endif
132
182
 
 
183
/*  Generic buffer size */
 
184
#ifndef SWIG_BUFFER_SIZE
 
185
# define SWIG_BUFFER_SIZE 1024
 
186
#endif
 
187
 
 
188
/* Flags for pointer conversions */
 
189
#define SWIG_POINTER_DISOWN        0x1
 
190
#define SWIG_CAST_NEW_MEMORY       0x2
 
191
 
 
192
/* Flags for new pointer objects */
 
193
#define SWIG_POINTER_OWN           0x1
 
194
 
 
195
 
 
196
/* 
 
197
   Flags/methods for returning states.
 
198
   
 
199
   The SWIG conversion methods, as ConvertPtr, return and integer 
 
200
   that tells if the conversion was successful or not. And if not,
 
201
   an error code can be returned (see swigerrors.swg for the codes).
 
202
   
 
203
   Use the following macros/flags to set or process the returning
 
204
   states.
 
205
   
 
206
   In old versions of SWIG, code such as the following was usually written:
 
207
 
 
208
     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
 
209
       // success code
 
210
     } else {
 
211
       //fail code
 
212
     }
 
213
 
 
214
   Now you can be more explicit:
 
215
 
 
216
    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
 
217
    if (SWIG_IsOK(res)) {
 
218
      // success code
 
219
    } else {
 
220
      // fail code
 
221
    }
 
222
 
 
223
   which is the same really, but now you can also do
 
224
 
 
225
    Type *ptr;
 
226
    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
 
227
    if (SWIG_IsOK(res)) {
 
228
      // success code
 
229
      if (SWIG_IsNewObj(res) {
 
230
        ...
 
231
        delete *ptr;
 
232
      } else {
 
233
        ...
 
234
      }
 
235
    } else {
 
236
      // fail code
 
237
    }
 
238
    
 
239
   I.e., now SWIG_ConvertPtr can return new objects and you can
 
240
   identify the case and take care of the deallocation. Of course that
 
241
   also requires SWIG_ConvertPtr to return new result values, such as
 
242
 
 
243
      int SWIG_ConvertPtr(obj, ptr,...) {         
 
244
        if (<obj is ok>) {                             
 
245
          if (<need new object>) {                     
 
246
            *ptr = <ptr to new allocated object>; 
 
247
            return SWIG_NEWOBJ;                
 
248
          } else {                                     
 
249
            *ptr = <ptr to old object>;        
 
250
            return SWIG_OLDOBJ;                
 
251
          }                                    
 
252
        } else {                                       
 
253
          return SWIG_BADOBJ;                  
 
254
        }                                              
 
255
      }
 
256
 
 
257
   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
 
258
   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
 
259
   SWIG errors code.
 
260
 
 
261
   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
 
262
   allows to return the 'cast rank', for example, if you have this
 
263
 
 
264
       int food(double)
 
265
       int fooi(int);
 
266
 
 
267
   and you call
 
268
 
 
269
      food(1)   // cast rank '1'  (1 -> 1.0)
 
270
      fooi(1)   // cast rank '0'
 
271
 
 
272
   just use the SWIG_AddCast()/SWIG_CheckState()
 
273
*/
 
274
 
 
275
#define SWIG_OK                    (0) 
 
276
#define SWIG_ERROR                 (-1)
 
277
#define SWIG_IsOK(r)               (r >= 0)
 
278
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)  
 
279
 
 
280
/* The CastRankLimit says how many bits are used for the cast rank */
 
281
#define SWIG_CASTRANKLIMIT         (1 << 8)
 
282
/* The NewMask denotes the object was created (using new/malloc) */
 
283
#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
 
284
/* The TmpMask is for in/out typemaps that use temporal objects */
 
285
#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
 
286
/* Simple returning values */
 
287
#define SWIG_BADOBJ                (SWIG_ERROR)
 
288
#define SWIG_OLDOBJ                (SWIG_OK)
 
289
#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
 
290
#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
 
291
/* Check, add and del mask methods */
 
292
#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
 
293
#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
 
294
#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
 
295
#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
 
296
#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
 
297
#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
 
298
 
 
299
/* Cast-Rank Mode */
 
300
#if defined(SWIG_CASTRANK_MODE)
 
301
#  ifndef SWIG_TypeRank
 
302
#    define SWIG_TypeRank             unsigned long
 
303
#  endif
 
304
#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
 
305
#    define SWIG_MAXCASTRANK          (2)
 
306
#  endif
 
307
#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
 
308
#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
 
309
SWIGINTERNINLINE int SWIG_AddCast(int r) { 
 
310
  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
 
311
}
 
312
SWIGINTERNINLINE int SWIG_CheckState(int r) { 
 
313
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; 
 
314
}
 
315
#else /* no cast-rank mode */
 
316
#  define SWIG_AddCast
 
317
#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
 
318
#endif
 
319
 
 
320
 
133
321
#include <string.h>
134
322
 
135
323
#ifdef __cplusplus
136
324
extern "C" {
137
325
#endif
138
326
 
139
 
typedef void *(*swig_converter_func)(void *);
 
327
typedef void *(*swig_converter_func)(void *, int *);
140
328
typedef struct swig_type_info *(*swig_dycast_func)(void **);
141
329
 
142
 
/* Structure to store inforomation on one type */
 
330
/* Structure to store information on one type */
143
331
typedef struct swig_type_info {
144
332
  const char             *name;                 /* mangled name of this type */
145
333
  const char             *str;                  /* human readable name of this type */
146
334
  swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
147
335
  struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
148
336
  void                   *clientdata;           /* language specific type data */
 
337
  int                    owndata;               /* flag if the structure owns the clientdata */
149
338
} swig_type_info;
150
339
 
151
340
/* Structure to store a type and conversion function used for casting */
168
357
  void                    *clientdata;          /* Language specific module data */
169
358
} swig_module_info;
170
359
 
171
 
 
172
360
/* 
173
361
  Compare two type names skipping the space characters, therefore
174
362
  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
182
370
  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
183
371
    while ((*f1 == ' ') && (f1 != l1)) ++f1;
184
372
    while ((*f2 == ' ') && (f2 != l2)) ++f2;
185
 
    if (*f1 != *f2) return (int)(*f1 - *f2);
 
373
    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
186
374
  }
187
 
  return (l1 - f1) - (l2 - f2);
 
375
  return (int)((l1 - f1) - (l2 - f2));
188
376
}
189
377
 
190
378
/*
226
414
}
227
415
 
228
416
 
229
 
/* think of this as a c++ template<> or a scheme macro */
230
 
#define SWIG_TypeCheck_Template(comparison, ty)         \
231
 
  if (ty) {                                             \
232
 
    swig_cast_info *iter = ty->cast;                    \
233
 
    while (iter) {                                      \
234
 
      if (comparison) {                                 \
235
 
        if (iter == ty->cast) return iter;              \
236
 
        /* Move iter to the top of the linked list */   \
237
 
        iter->prev->next = iter->next;                  \
238
 
        if (iter->next)                                 \
239
 
          iter->next->prev = iter->prev;                \
240
 
        iter->next = ty->cast;                          \
241
 
        iter->prev = 0;                                 \
242
 
        if (ty->cast) ty->cast->prev = iter;            \
243
 
        ty->cast = iter;                                \
244
 
        return iter;                                    \
245
 
      }                                                 \
246
 
      iter = iter->next;                                \
247
 
    }                                                   \
248
 
  }                                                     \
249
 
  return 0
250
 
 
251
417
/*
252
418
  Check the typename
253
419
*/
254
420
SWIGRUNTIME swig_cast_info *
255
421
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
256
 
  SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
 
422
  if (ty) {
 
423
    swig_cast_info *iter = ty->cast;
 
424
    while (iter) {
 
425
      if (strcmp(iter->type->name, c) == 0) {
 
426
        if (iter == ty->cast)
 
427
          return iter;
 
428
        /* Move iter to the top of the linked list */
 
429
        iter->prev->next = iter->next;
 
430
        if (iter->next)
 
431
          iter->next->prev = iter->prev;
 
432
        iter->next = ty->cast;
 
433
        iter->prev = 0;
 
434
        if (ty->cast) ty->cast->prev = iter;
 
435
        ty->cast = iter;
 
436
        return iter;
 
437
      }
 
438
      iter = iter->next;
 
439
    }
 
440
  }
 
441
  return 0;
257
442
}
258
443
 
259
 
/* Same as previous function, except strcmp is replaced with a pointer comparison */
 
444
/* 
 
445
  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
 
446
*/
260
447
SWIGRUNTIME swig_cast_info *
261
 
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
262
 
  SWIG_TypeCheck_Template(iter->type == from, into);
 
448
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
 
449
  if (ty) {
 
450
    swig_cast_info *iter = ty->cast;
 
451
    while (iter) {
 
452
      if (iter->type == from) {
 
453
        if (iter == ty->cast)
 
454
          return iter;
 
455
        /* Move iter to the top of the linked list */
 
456
        iter->prev->next = iter->next;
 
457
        if (iter->next)
 
458
          iter->next->prev = iter->prev;
 
459
        iter->next = ty->cast;
 
460
        iter->prev = 0;
 
461
        if (ty->cast) ty->cast->prev = iter;
 
462
        ty->cast = iter;
 
463
        return iter;
 
464
      }
 
465
      iter = iter->next;
 
466
    }
 
467
  }
 
468
  return 0;
263
469
}
264
470
 
265
471
/*
266
472
  Cast a pointer up an inheritance hierarchy
267
473
*/
268
474
SWIGRUNTIMEINLINE void *
269
 
SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
270
 
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
 
475
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
 
476
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
271
477
}
272
478
 
273
479
/* 
302
508
     type, separated by vertical-bar characters.  We choose
303
509
     to print the last name, as it is often (?) the most
304
510
     specific. */
 
511
  if (!type) return NULL;
305
512
  if (type->str != NULL) {
306
513
    const char *last_name = type->str;
307
514
    const char *s;
332
539
    cast = cast->next;
333
540
  }
334
541
}
335
 
 
 
542
SWIGRUNTIME void
 
543
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
 
544
  SWIG_TypeClientData(ti, clientdata);
 
545
  ti->owndata = 1;
 
546
}
 
547
  
336
548
/*
337
549
  Search for a swig_type_info structure only by mangled name
338
550
  Search is a O(log #types)
412
624
  return 0;
413
625
}
414
626
 
415
 
 
416
627
/* 
417
628
   Pack binary data into a string
418
629
*/
438
649
  register const unsigned char *eu = u + sz;
439
650
  for (; u != eu; ++u) {
440
651
    register char d = *(c++);
441
 
    register unsigned char uu = 0;
 
652
    register unsigned char uu;
442
653
    if ((d >= '0') && (d <= '9'))
443
654
      uu = ((d - '0') << 4);
444
655
    else if ((d >= 'a') && (d <= 'f'))
516
727
}
517
728
#endif
518
729
 
519
 
/*
520
 
 * php4.swg
521
 
 *
522
 
 * PHP4 runtime library
523
 
 *
524
 
 */
 
730
/* -----------------------------------------------------------------------------
 
731
 * See the LICENSE file for information on copyright, usage and redistribution
 
732
 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
 
733
 *
 
734
 * phprun.swg
 
735
 *
 
736
 * PHP runtime library
 
737
 * ----------------------------------------------------------------------------- */
525
738
 
526
739
#ifdef __cplusplus
527
740
extern "C" {
529
742
#include "zend.h"
530
743
#include "zend_API.h"
531
744
#include "php.h"
 
745
#include "ext/standard/php_string.h"
 
746
 
 
747
#ifdef ZEND_RAW_FENTRY
 
748
/* ZEND_RAW_FENTRY was added somewhere between 5.2.0 and 5.2.3 */
 
749
# define SWIG_ZEND_NAMED_FE(ZN, N, A) ZEND_RAW_FENTRY((char*)#ZN, N, A, 0)
 
750
#else
 
751
/* This causes warnings from GCC >= 4.2 (assigning a string literal to char*).
 
752
 * But this seems to be unavoidable without directly assuming knowledge of
 
753
 * the structure, which changed between PHP4 and PHP5. */
 
754
# define SWIG_ZEND_NAMED_FE(ZN, N, A) ZEND_NAMED_FE(ZN, N, A)
 
755
#endif
 
756
 
 
757
#ifndef Z_SET_ISREF_P
 
758
// For PHP < 5.3
 
759
# define Z_SET_ISREF_P(z) (z)->is_ref = 1
 
760
#endif
 
761
#ifndef Z_SET_REFCOUNT_P
 
762
// For PHP < 5.3
 
763
# define Z_SET_REFCOUNT_P(z, rc) (z)->refcount = (rc)
 
764
#endif
 
765
 
 
766
#define SWIG_LONG_CONSTANT(N, V) zend_register_long_constant((char*)#N, sizeof(#N), V, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC)
 
767
#define SWIG_DOUBLE_CONSTANT(N, V) zend_register_double_constant((char*)#N, sizeof(#N), V, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC)
 
768
#define SWIG_STRING_CONSTANT(N, V) zend_register_stringl_constant((char*)#N, sizeof(#N), V, strlen(V), CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC)
 
769
#define SWIG_CHAR_CONSTANT(N, V) do {\
 
770
    static char swig_char = (V);\
 
771
    zend_register_stringl_constant((char*)#N, sizeof(#N), &swig_char, 1, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC);\
 
772
} while (0)
532
773
 
533
774
/* These TSRMLS_ stuff should already be defined now, but with older php under
534
775
   redhat are not... */
554
795
   make PHP type calls later as we handle php resources */
555
796
#define SWIG_ConvertPtr(obj,pp,type,flags) SWIG_ZTS_ConvertPtr(obj,pp,type,flags TSRMLS_CC)
556
797
 
557
 
/* Flags for SWIG_ConvertPtr */
558
 
#define SWIG_POINTER_DISOWN  0x1
559
798
 
560
799
#define SWIG_fail goto fail
561
800
 
562
 
static char *default_error_msg = "Unknown error occurred";
 
801
static const char *default_error_msg = "Unknown error occurred";
563
802
static int default_error_code = E_ERROR;
564
803
 
565
804
#define SWIG_PHP_Arg_Error_Msg(argnum,extramsg) "Error in argument " #argnum " "#extramsg
566
805
 
567
 
#define SWIG_PHP_Error(code,msg) ErrorCode() = code; ErrorMsg() = msg; SWIG_fail;
 
806
#define SWIG_PHP_Error(code,msg) do { SWIG_ErrorCode() = code; SWIG_ErrorMsg() = msg; SWIG_fail; } while (0)
568
807
 
569
808
#define SWIG_contract_assert(expr,msg) \
570
809
  if (!(expr) ) { zend_printf("Contract Assert Failed %s\n",msg ); } else
571
810
 
572
811
/* Standard SWIG API */
573
 
#define SWIG_GetModule(clientdata) SWIG_Php4_GetModule()
574
 
#define SWIG_SetModule(clientdata, pointer) SWIG_Php4_SetModule(pointer)
 
812
#define SWIG_GetModule(clientdata) SWIG_Php_GetModule()
 
813
#define SWIG_SetModule(clientdata, pointer) SWIG_Php_SetModule(pointer)
575
814
 
576
815
/* used to wrap returned objects in so we know whether they are newobject
577
816
   and need freeing, or not */
578
 
typedef struct _swig_object_wrapper {
 
817
typedef struct {
579
818
  void * ptr;
580
819
  int newobject;
581
820
} swig_object_wrapper;
582
821
 
583
822
/* empty zend destructor for types without one */
584
 
static ZEND_RSRC_DTOR_FUNC(SWIG_landfill) {};
 
823
static ZEND_RSRC_DTOR_FUNC(SWIG_landfill) { (void)rsrc; }
585
824
 
586
 
#define SWIG_SetPointerZval(a,b,c,d) SWIG_ZTS_SetPointerZval(a,b,c,d, SWIG_module_entry TSRMLS_CC)
 
825
#define SWIG_SetPointerZval(a,b,c,d) SWIG_ZTS_SetPointerZval(a,b,c,d TSRMLS_CC)
 
826
#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
587
827
 
588
828
static void
589
 
SWIG_ZTS_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject, zend_module_entry* module_entry TSRMLS_DC) {
 
829
SWIG_ZTS_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject TSRMLS_DC) {
590
830
  swig_object_wrapper *value=NULL;
591
831
  /*
592
832
   * First test for Null pointers.  Return those as PHP native NULL
601
841
    value=(swig_object_wrapper *)emalloc(sizeof(swig_object_wrapper));
602
842
    value->ptr=ptr;
603
843
    value->newobject=newobject;
604
 
    ZEND_REGISTER_RESOURCE(z, value, *(int *)(type->clientdata));
 
844
    if (newobject <= 1) {
 
845
      /* Just register the pointer as a resource. */
 
846
      ZEND_REGISTER_RESOURCE(z, value, *(int *)(type->clientdata));
 
847
    } else {
 
848
      /*
 
849
       * Wrap the resource in an object, the resource will be accessible
 
850
       * via the "_cPtr" member. This is currently only used by
 
851
       * directorin typemaps.
 
852
       */
 
853
      value->newobject = 0;
 
854
      zval *resource;
 
855
      MAKE_STD_ZVAL(resource);
 
856
      ZEND_REGISTER_RESOURCE(resource, value, *(int *)(type->clientdata));
 
857
      zend_class_entry **ce = NULL;
 
858
      zval *classname;
 
859
      MAKE_STD_ZVAL(classname);
 
860
      /* _p_Foo -> Foo */
 
861
      ZVAL_STRING(classname, (char*)type->name+3, 1);
 
862
      /* class names are stored in lowercase */
 
863
      php_strtolower(Z_STRVAL_PP(&classname), Z_STRLEN_PP(&classname));
 
864
      if (zend_lookup_class(Z_STRVAL_P(classname), Z_STRLEN_P(classname), &ce TSRMLS_CC) != SUCCESS) {
 
865
        /* class does not exist */
 
866
        object_init(z);
 
867
      } else {
 
868
        object_init_ex(z, *ce);
 
869
      }
 
870
      Z_SET_REFCOUNT_P(z, 1);
 
871
      Z_SET_ISREF_P(z);
 
872
      zend_hash_update(HASH_OF(z), (char*)"_cPtr", sizeof("_cPtr"), (void*)&resource, sizeof(zval), NULL);
 
873
      FREE_ZVAL(classname);
 
874
    }
605
875
    return;
606
 
  } else { /* have to deal with old fashioned string pointer?
607
 
              but this should not get this far */
608
 
    zend_error(E_ERROR, "Type: %s not registered with zend",type->name);
609
876
  }
 
877
  zend_error(E_ERROR, "Type: %s not registered with zend",type->name);
610
878
}
611
879
 
612
 
/* This is a new pointer conversion routine
613
 
   Taking the native pointer p (which would have been converted from the old
614
 
   string pointer) and it's php type id, and it's type name (which also would
615
 
   have come from the old string pointer) it converts it to ptr calling 
616
 
   appropriate casting functions according to ty
617
 
   Sadly PHP has no API to find a type name from a type id, only from an instance
618
 
   of a resource of the type id, so we have to pass type_name as well.
 
880
/* This pointer conversion routine takes the native pointer p (along with
 
881
   its type name) and converts it by calling appropriate casting functions
 
882
   according to ty.  The resultant pointer is returned, or NULL is returned
 
883
   if the pointer can't be cast.
 
884
 
 
885
   Sadly PHP has no API to find a type name from a type id, only from an
 
886
   instance of a resource of the type id, so we have to pass type_name as well.
 
887
 
619
888
   The two functions which might call this are:
620
889
   SWIG_ZTS_ConvertResourcePtr which gets the type name from the resource
621
890
   and the registered zend destructors for which we have one per type each
622
891
   with the type name hard wired in. */
623
 
static int
624
 
SWIG_ZTS_ConvertResourceData(void * p, int type, const char *type_name, void **ptr, swig_type_info *ty TSRMLS_DC) {
 
892
static void *
 
893
SWIG_ZTS_ConvertResourceData(void * p, const char *type_name, swig_type_info *ty TSRMLS_DC) {
625
894
  swig_cast_info *tc;
 
895
  void *result = 0;
626
896
 
627
 
  if (ty) {
628
 
    if (! type_name) {  
629
 
      /* can't convert p to ptr type ty if we don't know what type p is */
630
 
      return -1;
631
 
    } else {
632
 
      /* convert and cast p from type_name to ptr as ty
633
 
         Need to sort out const-ness, can SWIG_TypeCast really not take a const? */
634
 
      tc = SWIG_TypeCheck((char *)type_name,ty);
635
 
      if (!tc) return -1;
636
 
      *ptr = SWIG_TypeCast(tc, (void*)p);
637
 
    }
638
 
  } else {
 
897
  if (!ty) {
639
898
    /* They don't care about the target type, so just pass on the pointer! */
640
 
    *ptr = (void *) p;
641
 
  }
642
 
  return 0;
 
899
    return p;
 
900
  }
 
901
 
 
902
  if (! type_name) {  
 
903
    /* can't convert p to ptr type ty if we don't know what type p is */
 
904
    return NULL;
 
905
  }
 
906
 
 
907
  /* convert and cast p from type_name to ptr as ty. */
 
908
  tc = SWIG_TypeCheck(type_name, ty);
 
909
  if (tc) {
 
910
    int newmemory = 0;
 
911
    result = SWIG_TypeCast(tc, p, &newmemory);
 
912
    assert(!newmemory); /* newmemory handling not yet implemented */
 
913
  }
 
914
  return result;
643
915
}
644
916
 
645
 
/* This function fills ptr with a pointer of type ty by extracting the pointer
646
 
   and type info from the resource in z.  z must be a resource
 
917
/* This function returns a pointer of type ty by extracting the pointer
 
918
   and type info from the resource in z.  z must be a resource.
 
919
   If it fails, NULL is returned.
647
920
   It uses SWIG_ZTS_ConvertResourceData to do the real work. */
648
 
static int
649
 
SWIG_ZTS_ConvertResourcePtr(zval *z, void **ptr, swig_type_info *ty, int flags TSRMLS_DC) {
 
921
static void *
 
922
SWIG_ZTS_ConvertResourcePtr(zval *z, swig_type_info *ty, int flags TSRMLS_DC) {
650
923
  swig_object_wrapper *value;
651
924
  void *p;
652
925
  int type;
653
926
  char *type_name;
654
927
 
655
 
  value = (swig_object_wrapper *) zend_list_find(z->value.lval,&type);
656
 
  if ( flags && SWIG_POINTER_DISOWN ) {
 
928
  value = (swig_object_wrapper *) zend_list_find(z->value.lval, &type);
 
929
  if ( flags & SWIG_POINTER_DISOWN ) {
657
930
    value->newobject = 0;
658
931
  }
659
932
  p = value->ptr;
660
 
  if (type==-1) return -1;
 
933
  if (type==-1) return NULL;
661
934
 
662
935
  type_name=zend_rsrc_list_get_rsrc_type(z->value.lval TSRMLS_CC);
663
936
 
664
 
  return SWIG_ZTS_ConvertResourceData(p,type,type_name,ptr,ty TSRMLS_CC);
 
937
  return SWIG_ZTS_ConvertResourceData(p, type_name, ty TSRMLS_CC);
665
938
}
666
939
 
667
 
/* We allow passing of a STRING or RESOURCE pointing to the object
668
 
   or an OBJECT whose _cPtr is a string or resource pointing to the object
669
 
   STRING pointers are very depracated */
 
940
/* We allow passing of a RESOURCE pointing to the object or an OBJECT whose
 
941
   _cPtr is a resource pointing to the object */
670
942
static int
671
943
SWIG_ZTS_ConvertPtr(zval *z, void **ptr, swig_type_info *ty, int flags TSRMLS_DC) {
672
 
   char *c;
673
 
   zval *val;
674
 
   
675
 
   if(z == NULL) {
676
 
        *ptr = 0;
677
 
        return 0;
678
 
   }
679
 
 
680
 
   if (z->type==IS_OBJECT) {
681
 
     zval ** _cPtr;
682
 
     if (zend_hash_find(HASH_OF(z),"_cPtr",sizeof("_cPtr"),(void**)&_cPtr)==SUCCESS) {
683
 
       /* Don't co-erce to string if it isn't */
684
 
       if ((*_cPtr)->type==IS_STRING) c = Z_STRVAL_PP(_cPtr);
685
 
       else if ((*_cPtr)->type==IS_RESOURCE) {
686
 
         return SWIG_ZTS_ConvertResourcePtr(*_cPtr,ptr,ty, flags TSRMLS_CC);
687
 
       } else goto type_error; /* _cPtr was not string or resource property */
688
 
     } else goto type_error; /* can't find property _cPtr */
689
 
   } else if (z->type==IS_RESOURCE) {
690
 
     return SWIG_ZTS_ConvertResourcePtr(z,ptr,ty, flags TSRMLS_CC);
691
 
   } else goto type_error;
692
 
 
693
 
type_error:
694
 
 
695
 
    return -1;
 
944
  if (z == NULL) {
 
945
    *ptr = 0;
 
946
    return 0;
 
947
  }
 
948
 
 
949
  switch (z->type) {
 
950
    case IS_OBJECT: {
 
951
      zval ** _cPtr;
 
952
      if (zend_hash_find(HASH_OF(z),(char*)"_cPtr",sizeof("_cPtr"),(void**)&_cPtr)==SUCCESS) {
 
953
        if ((*_cPtr)->type==IS_RESOURCE) {
 
954
          *ptr = SWIG_ZTS_ConvertResourcePtr(*_cPtr, ty, flags TSRMLS_CC);
 
955
          return (*ptr == NULL ? -1 : 0);
 
956
        }
 
957
      }
 
958
      break;
 
959
    }
 
960
    case IS_RESOURCE:
 
961
      *ptr = SWIG_ZTS_ConvertResourcePtr(z, ty, flags TSRMLS_CC);
 
962
      return (*ptr == NULL ? -1 : 0);
 
963
    case IS_NULL:
 
964
      *ptr = 0;
 
965
      return 0;
 
966
  }
 
967
 
 
968
  return -1;
696
969
}
697
970
 
698
971
static char const_name[] = "swig_runtime_data_type_pointer";
699
 
static swig_module_info *SWIG_Php4_GetModule() {
 
972
static swig_module_info *SWIG_Php_GetModule() {
700
973
  zval *pointer;
701
974
  swig_module_info *ret = 0;
702
975
 
703
976
  MAKE_STD_ZVAL(pointer);
704
977
 
705
 
  if (zend_get_constant(const_name, sizeof(const_name), pointer)) {
 
978
  TSRMLS_FETCH();
 
979
 
 
980
  if (zend_get_constant(const_name, sizeof(const_name), pointer TSRMLS_CC)) {
706
981
    if (pointer->type == IS_LONG) {
707
982
      ret = (swig_module_info *) pointer->value.lval;
708
983
    }
709
984
  } 
710
 
  return 0;
 
985
  FREE_ZVAL(pointer);
 
986
  return ret; 
711
987
}
712
988
 
713
 
static void SWIG_Php4_SetModule(swig_module_info *pointer) {
 
989
static void SWIG_Php_SetModule(swig_module_info *pointer) {
 
990
  TSRMLS_FETCH();
714
991
  REGISTER_MAIN_LONG_CONSTANT(const_name, (long) pointer, 0);
715
992
}
716
993
 
 
994
/*  Errors in SWIG */
 
995
#define  SWIG_UnknownError         -1 
 
996
#define  SWIG_IOError              -2 
 
997
#define  SWIG_RuntimeError         -3 
 
998
#define  SWIG_IndexError           -4 
 
999
#define  SWIG_TypeError            -5 
 
1000
#define  SWIG_DivisionByZero       -6 
 
1001
#define  SWIG_OverflowError        -7 
 
1002
#define  SWIG_SyntaxError          -8 
 
1003
#define  SWIG_ValueError           -9 
 
1004
#define  SWIG_SystemError          -10
 
1005
#define  SWIG_AttributeError       -11
 
1006
#define  SWIG_MemoryError          -12 
 
1007
#define  SWIG_NullReferenceError   -13
 
1008
 
 
1009
 
 
1010
 
717
1011
 
718
1012
/* -------- TYPES TABLE (BEGIN) -------- */
719
1013
 
731
1025
#define SWIGTYPE_p_char swig_types[11]
732
1026
#define SWIGTYPE_p_double swig_types[12]
733
1027
#define SWIGTYPE_p_int swig_types[13]
734
 
#define SWIGTYPE_p_p_OGRDataSourceShadow swig_types[14]
735
 
#define SWIGTYPE_p_p_OGRDriverShadow swig_types[15]
736
 
#define SWIGTYPE_p_p_OGRFeatureDefnShadow swig_types[16]
737
 
#define SWIGTYPE_p_p_OGRFeatureShadow swig_types[17]
738
 
#define SWIGTYPE_p_p_OGRFieldDefnShadow swig_types[18]
739
 
#define SWIGTYPE_p_p_OGRGeometryShadow swig_types[19]
740
 
#define SWIGTYPE_p_p_OGRLayerShadow swig_types[20]
741
 
#define SWIGTYPE_p_p_OSRCoordinateTransformationShadow swig_types[21]
742
 
#define SWIGTYPE_p_p_OSRSpatialReferenceShadow swig_types[22]
743
 
#define SWIGTYPE_p_p_char swig_types[23]
744
 
static swig_type_info *swig_types[25];
745
 
static swig_module_info swig_module = {swig_types, 24, 0, 0, 0, 0};
 
1028
#define SWIGTYPE_p_p_OGRGeometryShadow swig_types[14]
 
1029
#define SWIGTYPE_p_p_OGRLayerShadow swig_types[15]
 
1030
#define SWIGTYPE_p_p_char swig_types[16]
 
1031
#define SWIGTYPE_p_p_double swig_types[17]
 
1032
#define SWIGTYPE_p_p_int swig_types[18]
 
1033
#define SWIGTYPE_p_p_p_char swig_types[19]
 
1034
static swig_type_info *swig_types[21];
 
1035
static swig_module_info swig_module = {swig_types, 20, 0, 0, 0, 0};
746
1036
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
747
1037
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
748
1038
 
749
1039
/* -------- TYPES TABLE (END) -------- */
750
1040
 
751
1041
/* header section */
752
 
/*
753
 
  +----------------------------------------------------------------------+
754
 
  | PHP version 4.0                                                      |
755
 
  +----------------------------------------------------------------------+
756
 
  | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group             |
757
 
  +----------------------------------------------------------------------+
758
 
  | This source file is subject to version 2.02 of the PHP license,      |
759
 
  | that is bundled with this package in the file LICENSE, and is        |
760
 
  | available at through the world-wide-web at                           |
761
 
  | http://www.php.net/license/2_02.txt.                                 |
762
 
  | If you did not receive a copy of the PHP license and are unable to   |
763
 
  | obtain it through the world-wide-web, please send a note to          |
764
 
  | license@php.net so we can mail you a copy immediately.               |
765
 
  +----------------------------------------------------------------------+
766
 
  | Authors:                                                             |
767
 
  |                                                                      |
768
 
  +----------------------------------------------------------------------+
769
 
 */
770
1042
ZEND_BEGIN_MODULE_GLOBALS(ogr)
771
 
char *error_msg;
 
1043
const char *error_msg;
772
1044
int error_code;
773
1045
ZEND_END_MODULE_GLOBALS(ogr)
774
1046
ZEND_DECLARE_MODULE_GLOBALS(ogr)
775
1047
#ifdef ZTS
776
 
#define ErrorMsg() TSRMG(ogr_globals_id, zend_ogr_globals *, error_msg );
777
 
#define ErrorCode() TSRMG(ogr_globals_id, zend_ogr_globals *, error_code );
 
1048
#define SWIG_ErrorMsg() TSRMG(ogr_globals_id, zend_ogr_globals *, error_msg )
 
1049
#define SWIG_ErrorCode() TSRMG(ogr_globals_id, zend_ogr_globals *, error_code )
778
1050
#else
779
 
#define ErrorMsg() (ogr_globals.error_msg)
780
 
#define ErrorCode() (ogr_globals.error_code)
 
1051
#define SWIG_ErrorMsg() (ogr_globals.error_msg)
 
1052
#define SWIG_ErrorCode() (ogr_globals.error_code)
781
1053
#endif
782
1054
 
783
 
static void ogr_init_globals(zend_ogr_globals *ogr_globals ) {
784
 
  ogr_globals->error_msg = default_error_msg;
785
 
  ogr_globals->error_code = default_error_code;
786
 
}
787
 
static void ogr_destroy_globals(zend_ogr_globals *ogr_globals) { }
788
 
 
789
 
void SWIG_ResetError() {
790
 
  ErrorMsg() = default_error_msg;
791
 
  ErrorCode() = default_error_code;
 
1055
static void ogr_init_globals(zend_ogr_globals *globals ) {
 
1056
  globals->error_msg = default_error_msg;
 
1057
  globals->error_code = default_error_code;
 
1058
}
 
1059
static void ogr_destroy_globals(zend_ogr_globals * globals) { (void)globals; }
 
1060
 
 
1061
static void SWIG_ResetError() {
 
1062
  TSRMLS_FETCH();
 
1063
  SWIG_ErrorMsg() = default_error_msg;
 
1064
  SWIG_ErrorCode() = default_error_code;
 
1065
}
 
1066
 
 
1067
ZEND_NAMED_FUNCTION(_wrap_swig_ogr_alter_newobject) {
 
1068
  zval **args[2];
 
1069
  swig_object_wrapper *value;
 
1070
  int type;
 
1071
  int thisown;
 
1072
 
 
1073
  SWIG_ResetError();
 
1074
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
1075
    WRONG_PARAM_COUNT;
 
1076
  }
 
1077
 
 
1078
  value = (swig_object_wrapper *) zend_list_find((*args[0])->value.lval, &type);
 
1079
  value->newobject = zval_is_true(*args[1]);
 
1080
 
 
1081
  return;
 
1082
}
 
1083
ZEND_NAMED_FUNCTION(_wrap_swig_ogr_get_newobject) {
 
1084
  zval **args[1];
 
1085
  swig_object_wrapper *value;
 
1086
  int type;
 
1087
 
 
1088
  SWIG_ResetError();
 
1089
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
1090
    WRONG_PARAM_COUNT;
 
1091
  }
 
1092
 
 
1093
  value = (swig_object_wrapper *) zend_list_find((*args[0])->value.lval, &type);
 
1094
  RETVAL_LONG(value->newobject);
 
1095
 
 
1096
  return;
792
1097
}
793
1098
#define SWIG_name  "ogr"
794
1099
#ifdef __cplusplus
803
1108
#endif
804
1109
 
805
1110
 
806
 
#define  SWIG_MemoryError    1
807
 
#define  SWIG_IOError        2
808
 
#define  SWIG_RuntimeError   3
809
 
#define  SWIG_IndexError     4
810
 
#define  SWIG_TypeError      5
811
 
#define  SWIG_DivisionByZero 6
812
 
#define  SWIG_OverflowError  7
813
 
#define  SWIG_SyntaxError    8
814
 
#define  SWIG_ValueError     9
815
 
#define  SWIG_SystemError   10
816
 
#define  SWIG_UnknownError  99
817
 
 
818
 
 
819
 
/* We should make use of "code" if we can */
820
 
#define SWIG_exception(code, msg) { zend_error(E_ERROR, msg); }
 
1111
#if PHP_MAJOR_VERSION < 5
 
1112
# define SWIG_exception(code, msg) { zend_error(E_ERROR, msg); }
 
1113
#else
 
1114
# include "zend_exceptions.h"
 
1115
# define SWIG_exception(code, msg) { zend_throw_exception(NULL, (char*)msg, code TSRMLS_CC); }
 
1116
#endif
821
1117
 
822
1118
 
823
1119
#include <stdexcept>
824
1120
 
825
1121
 
 
1122
typedef char retStringAndCPLFree;
 
1123
 
 
1124
 
826
1125
#include <iostream>
827
1126
using namespace std;
828
1127
 
829
1128
#include "ogr_api.h"
 
1129
#include "ogr_p.h"
830
1130
#include "ogr_core.h"
831
1131
#include "cpl_port.h"
832
1132
#include "cpl_string.h"
 
1133
#include "ogr_srs_api.h"
833
1134
 
 
1135
#ifdef DEBUG 
 
1136
typedef struct OGRSpatialReferenceHS OSRSpatialReferenceShadow;
 
1137
typedef struct OGRDriverHS OGRDriverShadow;
 
1138
typedef struct OGRDataSourceHS OGRDataSourceShadow;
 
1139
typedef struct OGRLayerHS OGRLayerShadow;
 
1140
typedef struct OGRFeatureHS OGRFeatureShadow;
 
1141
typedef struct OGRFeatureDefnHS OGRFeatureDefnShadow;
 
1142
typedef struct OGRGeometryHS OGRGeometryShadow;
 
1143
typedef struct OGRCoordinateTransformationHS OSRCoordinateTransformationShadow;
 
1144
typedef struct OGRCoordinateTransformationHS OGRCoordinateTransformationShadow;
 
1145
typedef struct OGRFieldDefnHS OGRFieldDefnShadow;
 
1146
#else
834
1147
typedef void OSRSpatialReferenceShadow;
835
1148
typedef void OGRDriverShadow;
836
1149
typedef void OGRDataSourceShadow;
840
1153
typedef void OGRGeometryShadow;
841
1154
typedef void OSRCoordinateTransformationShadow;
842
1155
typedef void OGRFieldDefnShadow;
 
1156
#endif
843
1157
 
844
 
static OGRDataSourceShadow *OGRDriverShadow_CreateDataSource(OGRDriverShadow *self,char const *name,char **options=0){
 
1158
SWIGINTERN OGRDataSourceShadow *OGRDriverShadow_CreateDataSource(OGRDriverShadow *self,char const *name,char **options=0){
845
1159
    OGRDataSourceShadow *ds = (OGRDataSourceShadow*) OGR_Dr_CreateDataSource( self, name, options);
846
1160
    return ds;
847
1161
  }
848
 
static OGRDataSourceShadow *OGRDriverShadow_CopyDataSource(OGRDriverShadow *self,OGRDataSourceShadow *copy_ds,char const *name,char **options=0){
849
 
    OGRDataSourceShadow *ds = (OGRDataSourceShadow*) OGR_Dr_CopyDataSource(self, copy_ds, name, options);
850
 
    return ds;
851
 
  }
852
 
static OGRDataSourceShadow *OGRDriverShadow_Open(OGRDriverShadow *self,char const *name,int update=0){
853
 
    OGRDataSourceShadow* ds = (OGRDataSourceShadow*) OGR_Dr_Open(self, name, update);
854
 
    return ds;
855
 
  }
856
 
static int OGRDriverShadow_DeleteDataSource(OGRDriverShadow *self,char const *name){
 
1162
SWIGINTERN OGRDataSourceShadow *OGRDriverShadow_CopyDataSource(OGRDriverShadow *self,OGRDataSourceShadow *copy_ds,char const *utf8_path,char **options=0){
 
1163
    OGRDataSourceShadow *ds = (OGRDataSourceShadow*) OGR_Dr_CopyDataSource(self, copy_ds, utf8_path, options);
 
1164
    return ds;
 
1165
  }
 
1166
SWIGINTERN OGRDataSourceShadow *OGRDriverShadow_Open(OGRDriverShadow *self,char const *utf8_path,int update=0){
 
1167
    OGRDataSourceShadow* ds = (OGRDataSourceShadow*) OGR_Dr_Open(self, utf8_path, update);
 
1168
    return ds;
 
1169
  }
 
1170
SWIGINTERN int OGRDriverShadow_DeleteDataSource(OGRDriverShadow *self,char const *name){
 
1171
 
857
1172
    return OGR_Dr_DeleteDataSource( self, name );
858
1173
  }
859
 
static int OGRDriverShadow_TestCapability(OGRDriverShadow *self,char const *cap){
860
 
    return OGR_Dr_TestCapability(self, cap);
 
1174
SWIGINTERN bool OGRDriverShadow_TestCapability(OGRDriverShadow *self,char const *cap){
 
1175
    return (OGR_Dr_TestCapability(self, cap) > 0);
861
1176
  }
862
 
static char const *OGRDriverShadow_GetName(OGRDriverShadow *self){
 
1177
SWIGINTERN char const *OGRDriverShadow_GetName(OGRDriverShadow *self){
863
1178
    return OGR_Dr_GetName( self );
864
1179
  }
865
 
static int _wrap_propset_Driver(zend_property_reference *property_reference, pval *value);
866
 
static int _propset_Driver(zend_property_reference *property_reference, pval *value);
867
 
static pval _wrap_propget_Driver(zend_property_reference *property_reference);
868
 
static int _propget_Driver(zend_property_reference *property_reference, pval *value);
869
 
static void delete_OGRDataSourceShadow(OGRDataSourceShadow *self){
 
1180
SWIGINTERN void OGRDriverShadow_Register(OGRDriverShadow *self){
 
1181
    OGRRegisterDriver( self );
 
1182
  }
 
1183
SWIGINTERN void OGRDriverShadow_Deregister(OGRDriverShadow *self){
 
1184
    OGRDeregisterDriver( self );
 
1185
  }
 
1186
SWIGINTERN void delete_OGRDataSourceShadow(OGRDataSourceShadow *self){
870
1187
    OGRReleaseDataSource(self);
871
1188
  }
872
 
static int OGRDataSourceShadow_GetRefCount(OGRDataSourceShadow *self){
 
1189
SWIGINTERN int OGRDataSourceShadow_GetRefCount(OGRDataSourceShadow *self){
873
1190
    return OGR_DS_GetRefCount(self);
874
1191
  }
875
 
static int OGRDataSourceShadow_GetSummaryRefCount(OGRDataSourceShadow *self){
 
1192
SWIGINTERN int OGRDataSourceShadow_GetSummaryRefCount(OGRDataSourceShadow *self){
876
1193
    return OGR_DS_GetSummaryRefCount(self);
877
1194
  }
878
 
static int OGRDataSourceShadow_GetLayerCount(OGRDataSourceShadow *self){
 
1195
SWIGINTERN int OGRDataSourceShadow_GetLayerCount(OGRDataSourceShadow *self){
879
1196
    return OGR_DS_GetLayerCount(self);
880
1197
  }
881
 
static char const *OGRDataSourceShadow_GetName(OGRDataSourceShadow *self){
 
1198
SWIGINTERN OGRDriverShadow *OGRDataSourceShadow_GetDriver(OGRDataSourceShadow *self){
 
1199
    return (OGRDriverShadow *) OGR_DS_GetDriver( self );
 
1200
  }
 
1201
SWIGINTERN char const *OGRDataSourceShadow_GetName(OGRDataSourceShadow *self){
882
1202
    return OGR_DS_GetName(self);
883
1203
  }
884
 
static OGRErr OGRDataSourceShadow_DeleteLayer(OGRDataSourceShadow *self,int index){
 
1204
SWIGINTERN OGRErr OGRDataSourceShadow_DeleteLayer(OGRDataSourceShadow *self,int index){
885
1205
    return OGR_DS_DeleteLayer(self, index);
886
1206
  }
887
1207
 
907
1227
  }
908
1228
}
909
1229
 
910
 
static OGRLayerShadow *OGRDataSourceShadow_CreateLayer(OGRDataSourceShadow *self,char const *name,OSRSpatialReferenceShadow *reference=NULL,OGRwkbGeometryType geom_type=wkbUnknown,char **options=0){
 
1230
SWIGINTERN OGRLayerShadow *OGRDataSourceShadow_CreateLayer(OGRDataSourceShadow *self,char const *name,OSRSpatialReferenceShadow *srs=NULL,OGRwkbGeometryType geom_type=wkbUnknown,char **options=0){
911
1231
    OGRLayerShadow* layer = (OGRLayerShadow*) OGR_DS_CreateLayer( self,
912
 
                                                        name,
913
 
                                                        reference,
914
 
                                                        geom_type,
915
 
                                                        options);
 
1232
                                                                  name,
 
1233
                                                                  srs,
 
1234
                                                                  geom_type,
 
1235
                                                                  options);
916
1236
    return layer;
917
1237
  }
918
 
static OGRLayerShadow *OGRDataSourceShadow_CopyLayer(OGRDataSourceShadow *self,OGRLayerShadow *src_layer,char const *new_name,char **options=0){
 
1238
SWIGINTERN OGRLayerShadow *OGRDataSourceShadow_CopyLayer(OGRDataSourceShadow *self,OGRLayerShadow *src_layer,char const *new_name,char **options=0){
919
1239
    OGRLayerShadow* layer = (OGRLayerShadow*) OGR_DS_CopyLayer( self,
920
1240
                                                      src_layer,
921
1241
                                                      new_name,
922
1242
                                                      options);
923
1243
    return layer;
924
1244
  }
925
 
static OGRLayerShadow *OGRDataSourceShadow_GetLayerByIndex(OGRDataSourceShadow *self,int index=0){
 
1245
SWIGINTERN OGRLayerShadow *OGRDataSourceShadow_GetLayerByIndex(OGRDataSourceShadow *self,int index=0){
 
1246
 
926
1247
    OGRLayerShadow* layer = (OGRLayerShadow*) OGR_DS_GetLayer(self, index);
927
1248
    return layer;
928
1249
  }
929
 
static OGRLayerShadow *OGRDataSourceShadow_GetLayerByName(OGRDataSourceShadow *self,char const *layer_name){
 
1250
SWIGINTERN OGRLayerShadow *OGRDataSourceShadow_GetLayerByName(OGRDataSourceShadow *self,char const *layer_name){
930
1251
    OGRLayerShadow* layer = (OGRLayerShadow*) OGR_DS_GetLayerByName(self, layer_name);
931
1252
    return layer;
932
1253
  }
933
 
static int OGRDataSourceShadow_TestCapability(OGRDataSourceShadow *self,char const *cap){
934
 
    return OGR_DS_TestCapability(self, cap);
 
1254
SWIGINTERN bool OGRDataSourceShadow_TestCapability(OGRDataSourceShadow *self,char const *cap){
 
1255
    return (OGR_DS_TestCapability(self, cap) > 0);
935
1256
  }
936
 
static OGRLayerShadow *OGRDataSourceShadow_ExecuteSQL(OGRDataSourceShadow *self,char const *statement,OGRGeometryShadow *geom=NULL,char const *dialect=""){
 
1257
SWIGINTERN OGRLayerShadow *OGRDataSourceShadow_ExecuteSQL(OGRDataSourceShadow *self,char const *statement,OGRGeometryShadow *spatialFilter=NULL,char const *dialect=""){
937
1258
    OGRLayerShadow* layer = (OGRLayerShadow*) OGR_DS_ExecuteSQL((OGRDataSourceShadow*)self,
938
1259
                                                      statement,
939
 
                                                      geom,
 
1260
                                                      spatialFilter,
940
1261
                                                      dialect);
941
1262
    return layer;
942
1263
  }
943
 
static void OGRDataSourceShadow_ReleaseResultSet(OGRDataSourceShadow *self,OGRLayerShadow *layer){
 
1264
SWIGINTERN void OGRDataSourceShadow_ReleaseResultSet(OGRDataSourceShadow *self,OGRLayerShadow *layer){
944
1265
    OGR_DS_ReleaseResultSet(self, layer);
945
1266
  }
946
 
static int _wrap_propset_DataSource(zend_property_reference *property_reference, pval *value);
947
 
static int _propset_DataSource(zend_property_reference *property_reference, pval *value);
948
 
static pval _wrap_propget_DataSource(zend_property_reference *property_reference);
949
 
static int _propget_DataSource(zend_property_reference *property_reference, pval *value);
950
 
static int OGRLayerShadow_GetRefCount(OGRLayerShadow *self){
 
1267
SWIGINTERN int OGRLayerShadow_GetRefCount(OGRLayerShadow *self){
951
1268
    return OGR_L_GetRefCount(self);
952
1269
  }
953
 
static void OGRLayerShadow_SetSpatialFilter(OGRLayerShadow *self,OGRGeometryShadow *filter){
 
1270
SWIGINTERN void OGRLayerShadow_SetSpatialFilter(OGRLayerShadow *self,OGRGeometryShadow *filter){
954
1271
    OGR_L_SetSpatialFilter (self, filter);
955
1272
  }
956
 
static void OGRLayerShadow_SetSpatialFilterRect(OGRLayerShadow *self,double minx,double miny,double maxx,double maxy){
 
1273
SWIGINTERN void OGRLayerShadow_SetSpatialFilterRect(OGRLayerShadow *self,double minx,double miny,double maxx,double maxy){
957
1274
    OGR_L_SetSpatialFilterRect(self, minx, miny, maxx, maxy);                          
958
1275
  }
959
 
static OGRGeometryShadow *OGRLayerShadow_GetSpatialFilter(OGRLayerShadow *self){
 
1276
SWIGINTERN OGRGeometryShadow *OGRLayerShadow_GetSpatialFilter(OGRLayerShadow *self){
960
1277
    return (OGRGeometryShadow *) OGR_L_GetSpatialFilter(self);
961
1278
  }
962
 
static OGRErr OGRLayerShadow_SetAttributeFilter(OGRLayerShadow *self,char *filter_string){
963
 
    OGRErr err = OGR_L_SetAttributeFilter((OGRLayerShadow*)self, filter_string);
964
 
    if (err != 0) {
965
 
      throw err;
966
 
    } 
967
 
    return 0;
 
1279
SWIGINTERN OGRErr OGRLayerShadow_SetAttributeFilter(OGRLayerShadow *self,char *filter_string){
 
1280
    return OGR_L_SetAttributeFilter((OGRLayerShadow*)self, filter_string);
968
1281
  }
969
 
static void OGRLayerShadow_ResetReading(OGRLayerShadow *self){
 
1282
SWIGINTERN void OGRLayerShadow_ResetReading(OGRLayerShadow *self){
970
1283
    OGR_L_ResetReading(self);
971
1284
  }
972
 
static char const *OGRLayerShadow_GetName(OGRLayerShadow *self){
973
 
    return OGR_FD_GetName(OGR_L_GetLayerDefn(self));
974
 
  }
975
 
static OGRFeatureShadow *OGRLayerShadow_GetFeature(OGRLayerShadow *self,long fid){
 
1285
SWIGINTERN char const *OGRLayerShadow_GetName(OGRLayerShadow *self){
 
1286
    return OGR_L_GetName(self);
 
1287
  }
 
1288
SWIGINTERN OGRwkbGeometryType OGRLayerShadow_GetGeomType(OGRLayerShadow *self){
 
1289
    return (OGRwkbGeometryType) OGR_L_GetGeomType(self);
 
1290
  }
 
1291
SWIGINTERN char const *OGRLayerShadow_GetGeometryColumn(OGRLayerShadow *self){
 
1292
    return OGR_L_GetGeometryColumn(self);
 
1293
  }
 
1294
SWIGINTERN char const *OGRLayerShadow_GetFIDColumn(OGRLayerShadow *self){
 
1295
    return OGR_L_GetFIDColumn(self);
 
1296
  }
 
1297
SWIGINTERN OGRFeatureShadow *OGRLayerShadow_GetFeature(OGRLayerShadow *self,long fid){
976
1298
    return (OGRFeatureShadow*) OGR_L_GetFeature(self, fid);
977
1299
  }
978
 
static OGRFeatureShadow *OGRLayerShadow_GetNextFeature(OGRLayerShadow *self){
 
1300
SWIGINTERN OGRFeatureShadow *OGRLayerShadow_GetNextFeature(OGRLayerShadow *self){
979
1301
    return (OGRFeatureShadow*) OGR_L_GetNextFeature(self);
980
1302
  }
981
 
static OGRErr OGRLayerShadow_SetNextByIndex(OGRLayerShadow *self,long new_index){
982
 
    OGRErr err = OGR_L_SetNextByIndex(self, new_index);
983
 
    if (err != 0) {
984
 
      throw err;
985
 
    }
986
 
    return 0;
987
 
  }
988
 
static OGRErr OGRLayerShadow_SetFeature(OGRLayerShadow *self,OGRFeatureShadow *feature){
989
 
    OGRErr err = OGR_L_SetFeature(self, feature);
990
 
    if (err != 0) {
991
 
      throw err;
992
 
    }
993
 
    return 0;
994
 
  }
995
 
static OGRErr OGRLayerShadow_CreateFeature(OGRLayerShadow *self,OGRFeatureShadow *feature){
996
 
    OGRErr err = OGR_L_CreateFeature(self, feature);
997
 
    if (err != 0) {
998
 
      throw err;
999
 
    }
1000
 
    return 0;
1001
 
  }
1002
 
static OGRErr OGRLayerShadow_DeleteFeature(OGRLayerShadow *self,long fid){
1003
 
    OGRErr err = OGR_L_DeleteFeature(self, fid);
1004
 
    if (err != 0) {
1005
 
      throw err;
1006
 
    }
1007
 
    return 0;
1008
 
  }
1009
 
static OGRErr OGRLayerShadow_SyncToDisk(OGRLayerShadow *self){
1010
 
    OGRErr err = OGR_L_SyncToDisk(self);
1011
 
    if (err != 0) {
1012
 
      throw err;
1013
 
    }
1014
 
    return 0;
1015
 
  }
1016
 
static OGRFeatureDefnShadow *OGRLayerShadow_GetLayerDefn(OGRLayerShadow *self){
 
1303
SWIGINTERN OGRErr OGRLayerShadow_SetNextByIndex(OGRLayerShadow *self,long new_index){
 
1304
    return OGR_L_SetNextByIndex(self, new_index);
 
1305
  }
 
1306
SWIGINTERN OGRErr OGRLayerShadow_SetFeature(OGRLayerShadow *self,OGRFeatureShadow *feature){
 
1307
    return OGR_L_SetFeature(self, feature);
 
1308
  }
 
1309
SWIGINTERN OGRErr OGRLayerShadow_CreateFeature(OGRLayerShadow *self,OGRFeatureShadow *feature){
 
1310
    return OGR_L_CreateFeature(self, feature);
 
1311
  }
 
1312
SWIGINTERN OGRErr OGRLayerShadow_DeleteFeature(OGRLayerShadow *self,long fid){
 
1313
    return OGR_L_DeleteFeature(self, fid);
 
1314
  }
 
1315
SWIGINTERN OGRErr OGRLayerShadow_SyncToDisk(OGRLayerShadow *self){
 
1316
    return OGR_L_SyncToDisk(self);
 
1317
  }
 
1318
SWIGINTERN OGRFeatureDefnShadow *OGRLayerShadow_GetLayerDefn(OGRLayerShadow *self){
1017
1319
    return (OGRFeatureDefnShadow*) OGR_L_GetLayerDefn(self);
1018
1320
  }
1019
 
static int OGRLayerShadow_GetFeatureCount(OGRLayerShadow *self,int force=1){
 
1321
SWIGINTERN int OGRLayerShadow_GetFeatureCount(OGRLayerShadow *self,int force=1){
1020
1322
    return OGR_L_GetFeatureCount(self, force);
1021
1323
  }
1022
1324
 
1033
1335
 }
1034
1336
 
1035
1337
 
1036
 
void
 
1338
static void
1037
1339
t_output_helper( zval **target, zval *o) {
1038
1340
  if ( (*target)->type == IS_ARRAY ) {
1039
1341
    /* it's already an array, just append */
1042
1344
  }
1043
1345
  if ( (*target)->type == IS_NULL ) {
1044
1346
    REPLACE_ZVAL_VALUE(target,o,1);
 
1347
    FREE_ZVAL(o);
1045
1348
    return;
1046
1349
  }
1047
1350
  zval *tmp;
1048
 
  tmp = *target;
 
1351
  ALLOC_INIT_ZVAL(tmp);
 
1352
  *tmp = **target;
1049
1353
  zval_copy_ctor(tmp);
1050
1354
  array_init(*target);
1051
1355
  add_next_index_zval( *target, tmp);
1053
1357
 
1054
1358
}
1055
1359
 
1056
 
static void OGRLayerShadow_GetExtent(OGRLayerShadow *self,double argout[4],int force=1){
1057
 
    OGRErr err = OGR_L_GetExtent(self, (OGREnvelope*)argout, force);
1058
 
    if (err != 0)
1059
 
      throw err;
1060
 
  }
1061
 
static int OGRLayerShadow_TestCapability(OGRLayerShadow *self,char const *cap){
1062
 
    return OGR_L_TestCapability(self, cap);
1063
 
  }
1064
 
static OGRErr OGRLayerShadow_CreateField(OGRLayerShadow *self,OGRFieldDefnShadow *field_def,int approx_ok=1){
1065
 
    OGRErr err = OGR_L_CreateField(self, field_def, approx_ok);
1066
 
    if (err != 0)
1067
 
      throw err;
1068
 
    return 0;
1069
 
  }
1070
 
static OGRErr OGRLayerShadow_StartTransaction(OGRLayerShadow *self){
1071
 
    OGRErr err = OGR_L_StartTransaction(self);
1072
 
    if (err != 0)
1073
 
      throw err;
1074
 
    return 0;
1075
 
  }
1076
 
static OGRErr OGRLayerShadow_CommitTransaction(OGRLayerShadow *self){
1077
 
    OGRErr err = OGR_L_CommitTransaction(self);
1078
 
    if (err != 0)
1079
 
      throw err;
1080
 
    return 0;
1081
 
  }
1082
 
static OGRErr OGRLayerShadow_RollbackTransaction(OGRLayerShadow *self){
1083
 
    OGRErr err = OGR_L_RollbackTransaction(self);
1084
 
    if (err != 0)
1085
 
      throw err;
1086
 
    return 0;
1087
 
  }
1088
 
static OSRSpatialReferenceShadow *OGRLayerShadow_GetSpatialRef(OGRLayerShadow *self){
1089
 
    return (OSRSpatialReferenceShadow*) OGR_L_GetSpatialRef(self);
1090
 
  }
1091
 
static GIntBig OGRLayerShadow_GetFeatureRead(OGRLayerShadow *self){
 
1360
SWIGINTERN OGRErr OGRLayerShadow_GetExtent(OGRLayerShadow *self,double argout[4],int force=1){
 
1361
 
 
1362
 
 
1363
 
 
1364
    return OGR_L_GetExtent(self, (OGREnvelope*)argout, force);
 
1365
  }
 
1366
SWIGINTERN bool OGRLayerShadow_TestCapability(OGRLayerShadow *self,char const *cap){
 
1367
    return (OGR_L_TestCapability(self, cap) > 0);
 
1368
  }
 
1369
SWIGINTERN OGRErr OGRLayerShadow_CreateField(OGRLayerShadow *self,OGRFieldDefnShadow *field_def,int approx_ok=1){
 
1370
    return OGR_L_CreateField(self, field_def, approx_ok);
 
1371
  }
 
1372
SWIGINTERN OGRErr OGRLayerShadow_StartTransaction(OGRLayerShadow *self){
 
1373
    return OGR_L_StartTransaction(self);
 
1374
  }
 
1375
SWIGINTERN OGRErr OGRLayerShadow_CommitTransaction(OGRLayerShadow *self){
 
1376
    return OGR_L_CommitTransaction(self);
 
1377
  }
 
1378
SWIGINTERN OGRErr OGRLayerShadow_RollbackTransaction(OGRLayerShadow *self){
 
1379
    return OGR_L_RollbackTransaction(self);
 
1380
  }
 
1381
SWIGINTERN OSRSpatialReferenceShadow *OGRLayerShadow_GetSpatialRef(OGRLayerShadow *self){
 
1382
    OGRSpatialReferenceH ref =  OGR_L_GetSpatialRef(self);
 
1383
    if( ref )
 
1384
        OSRReference(ref);
 
1385
    return (OSRSpatialReferenceShadow*) ref;
 
1386
  }
 
1387
SWIGINTERN GIntBig OGRLayerShadow_GetFeaturesRead(OGRLayerShadow *self){
1092
1388
    return OGR_L_GetFeaturesRead(self);
1093
1389
  }
1094
 
static int _wrap_propset_Layer(zend_property_reference *property_reference, pval *value);
1095
 
static int _propset_Layer(zend_property_reference *property_reference, pval *value);
1096
 
static pval _wrap_propget_Layer(zend_property_reference *property_reference);
1097
 
static int _propget_Layer(zend_property_reference *property_reference, pval *value);
1098
 
static void delete_OGRFeatureShadow(OGRFeatureShadow *self){
 
1390
SWIGINTERN OGRErr OGRLayerShadow_SetIgnoredFields(OGRLayerShadow *self,char const **options){
 
1391
    return OGR_L_SetIgnoredFields( self, options );
 
1392
  }
 
1393
SWIGINTERN void delete_OGRFeatureShadow(OGRFeatureShadow *self){
1099
1394
    OGR_F_Destroy(self);
1100
1395
  }
1101
 
static OGRFeatureShadow *new_OGRFeatureShadow(OGRFeatureDefnShadow *feature_def=0){
1102
 
    return (OGRFeatureShadow*) OGR_F_Create( feature_def );
 
1396
SWIGINTERN OGRFeatureShadow *new_OGRFeatureShadow(OGRFeatureDefnShadow *feature_def){
 
1397
      return (OGRFeatureShadow*) OGR_F_Create( feature_def );
1103
1398
  }
1104
 
static OGRFeatureDefnShadow *OGRFeatureShadow_GetDefnRef(OGRFeatureShadow *self){
 
1399
SWIGINTERN OGRFeatureDefnShadow *OGRFeatureShadow_GetDefnRef(OGRFeatureShadow *self){
1105
1400
    return (OGRFeatureDefnShadow*) OGR_F_GetDefnRef(self);
1106
1401
  }
1107
 
static OGRErr OGRFeatureShadow_SetGeometry(OGRFeatureShadow *self,OGRGeometryShadow *geom){
1108
 
    OGRErr err = OGR_F_SetGeometry(self, geom);
1109
 
    if (err != 0)
1110
 
      throw err;
1111
 
    return 0;
1112
 
  }
1113
 
static OGRErr OGRFeatureShadow_SetGeometryDirectly(OGRFeatureShadow *self,OGRGeometryShadow *geom){
1114
 
    OGRErr err = OGR_F_SetGeometryDirectly(self, geom);
1115
 
    if (err != 0)
1116
 
      throw err;
1117
 
    return 0;
1118
 
  }
1119
 
static OGRGeometryShadow *OGRFeatureShadow_GetGeometryRef(OGRFeatureShadow *self){
 
1402
SWIGINTERN OGRErr OGRFeatureShadow_SetGeometry(OGRFeatureShadow *self,OGRGeometryShadow *geom){
 
1403
    return OGR_F_SetGeometry(self, geom);
 
1404
  }
 
1405
SWIGINTERN OGRErr OGRFeatureShadow_SetGeometryDirectly(OGRFeatureShadow *self,OGRGeometryShadow *geom){
 
1406
    return OGR_F_SetGeometryDirectly(self, geom);
 
1407
  }
 
1408
SWIGINTERN OGRGeometryShadow *OGRFeatureShadow_GetGeometryRef(OGRFeatureShadow *self){
1120
1409
    return (OGRGeometryShadow*) OGR_F_GetGeometryRef(self);
1121
1410
  }
1122
 
static OGRFeatureShadow *OGRFeatureShadow_Clone(OGRFeatureShadow *self){
 
1411
SWIGINTERN OGRFeatureShadow *OGRFeatureShadow_Clone(OGRFeatureShadow *self){
1123
1412
    return (OGRFeatureShadow*) OGR_F_Clone(self);
1124
1413
  }
1125
 
static int OGRFeatureShadow_Equal(OGRFeatureShadow *self,OGRFeatureShadow *feature){
1126
 
    return OGR_F_Equal(self, feature);
 
1414
SWIGINTERN bool OGRFeatureShadow_Equal(OGRFeatureShadow *self,OGRFeatureShadow *feature){
 
1415
    return (OGR_F_Equal(self, feature) > 0);
1127
1416
  }
1128
 
static int OGRFeatureShadow_GetFieldCount(OGRFeatureShadow *self){
 
1417
SWIGINTERN int OGRFeatureShadow_GetFieldCount(OGRFeatureShadow *self){
1129
1418
    return OGR_F_GetFieldCount(self);
1130
1419
  }
1131
 
static OGRFieldDefnShadow *OGRFeatureShadow_GetFieldDefnRef__SWIG_0(OGRFeatureShadow *self,int id){
 
1420
SWIGINTERN OGRFieldDefnShadow *OGRFeatureShadow_GetFieldDefnRef__SWIG_0(OGRFeatureShadow *self,int id){
1132
1421
    return (OGRFieldDefnShadow *) OGR_F_GetFieldDefnRef(self, id);
1133
1422
  }
1134
 
static OGRFieldDefnShadow *OGRFeatureShadow_GetFieldDefnRef__SWIG_1(OGRFeatureShadow *self,char const *name){
1135
 
    return (OGRFieldDefnShadow *) OGR_F_GetFieldDefnRef(self, OGR_F_GetFieldIndex(self, name));
 
1423
SWIGINTERN OGRFieldDefnShadow *OGRFeatureShadow_GetFieldDefnRef__SWIG_1(OGRFeatureShadow *self,char const *name){
 
1424
      int i = OGR_F_GetFieldIndex(self, name);
 
1425
      if (i == -1)
 
1426
          CPLError(CE_Failure, 1, "No such field: '%s'", name);
 
1427
      else
 
1428
          return (OGRFieldDefnShadow *) OGR_F_GetFieldDefnRef(self, i);
 
1429
      return NULL;
1136
1430
  }
1137
 
static char const *OGRFeatureShadow_GetFieldAsString__SWIG_0(OGRFeatureShadow *self,int id){
 
1431
SWIGINTERN char const *OGRFeatureShadow_GetFieldAsString__SWIG_0(OGRFeatureShadow *self,int id){
1138
1432
    return (const char *) OGR_F_GetFieldAsString(self, id);
1139
1433
  }
1140
 
static char const *OGRFeatureShadow_GetFieldAsString__SWIG_1(OGRFeatureShadow *self,char const *name){
1141
 
    return (const char *) OGR_F_GetFieldAsString(self, OGR_F_GetFieldIndex(self, name));
 
1434
SWIGINTERN char const *OGRFeatureShadow_GetFieldAsString__SWIG_1(OGRFeatureShadow *self,char const *name){
 
1435
      int i = OGR_F_GetFieldIndex(self, name);
 
1436
      if (i == -1)
 
1437
          CPLError(CE_Failure, 1, "No such field: '%s'", name);
 
1438
      else
 
1439
          return (const char *) OGR_F_GetFieldAsString(self, i);
 
1440
      return NULL;
1142
1441
  }
1143
 
static int OGRFeatureShadow_GetFieldAsInteger__SWIG_0(OGRFeatureShadow *self,int id){
 
1442
SWIGINTERN int OGRFeatureShadow_GetFieldAsInteger__SWIG_0(OGRFeatureShadow *self,int id){
1144
1443
    return OGR_F_GetFieldAsInteger(self, id);
1145
1444
  }
1146
 
static int OGRFeatureShadow_GetFieldAsInteger__SWIG_1(OGRFeatureShadow *self,char const *name){
1147
 
    return OGR_F_GetFieldAsInteger(self, OGR_F_GetFieldIndex(self, name));
 
1445
SWIGINTERN int OGRFeatureShadow_GetFieldAsInteger__SWIG_1(OGRFeatureShadow *self,char const *name){
 
1446
      int i = OGR_F_GetFieldIndex(self, name);
 
1447
      if (i == -1)
 
1448
          CPLError(CE_Failure, 1, "No such field: '%s'", name);
 
1449
      else
 
1450
          return OGR_F_GetFieldAsInteger(self, i);
 
1451
      return 0;
1148
1452
  }
1149
 
static double OGRFeatureShadow_GetFieldAsDouble__SWIG_0(OGRFeatureShadow *self,int id){
 
1453
SWIGINTERN double OGRFeatureShadow_GetFieldAsDouble__SWIG_0(OGRFeatureShadow *self,int id){
1150
1454
    return OGR_F_GetFieldAsDouble(self, id);
1151
1455
  }
1152
 
static double OGRFeatureShadow_GetFieldAsDouble__SWIG_1(OGRFeatureShadow *self,char const *name){
1153
 
    return OGR_F_GetFieldAsDouble(self, OGR_F_GetFieldIndex(self, name));
1154
 
  }
1155
 
static int OGRFeatureShadow_IsFieldSet__SWIG_0(OGRFeatureShadow *self,int id){
1156
 
    return OGR_F_IsFieldSet(self, id);
1157
 
  }
1158
 
static int OGRFeatureShadow_IsFieldSet__SWIG_1(OGRFeatureShadow *self,char const *name){
1159
 
    return OGR_F_IsFieldSet(self, OGR_F_GetFieldIndex(self, name));
1160
 
  }
1161
 
static int OGRFeatureShadow_GetFieldIndex(OGRFeatureShadow *self,char const *name){
1162
 
    return OGR_F_GetFieldIndex(self, name);
1163
 
  }
1164
 
static int OGRFeatureShadow_GetFID(OGRFeatureShadow *self){
 
1456
SWIGINTERN double OGRFeatureShadow_GetFieldAsDouble__SWIG_1(OGRFeatureShadow *self,char const *name){
 
1457
      int i = OGR_F_GetFieldIndex(self, name);
 
1458
      if (i == -1)
 
1459
          CPLError(CE_Failure, 1, "No such field: '%s'", name);
 
1460
      else
 
1461
          return OGR_F_GetFieldAsDouble(self, i);
 
1462
      return 0;
 
1463
  }
 
1464
SWIGINTERN void OGRFeatureShadow_GetFieldAsDateTime(OGRFeatureShadow *self,int id,int *pnYear,int *pnMonth,int *pnDay,int *pnHour,int *pnMinute,int *pnSecond,int *pnTZFlag){
 
1465
      OGR_F_GetFieldAsDateTime(self, id, pnYear, pnMonth, pnDay,
 
1466
                               pnHour, pnMinute, pnSecond,
 
1467
                               pnTZFlag);
 
1468
  }
 
1469
SWIGINTERN void OGRFeatureShadow_GetFieldAsIntegerList(OGRFeatureShadow *self,int id,int *nLen,int const **pList){
 
1470
      *pList = OGR_F_GetFieldAsIntegerList(self, id, nLen);
 
1471
  }
 
1472
SWIGINTERN void OGRFeatureShadow_GetFieldAsDoubleList(OGRFeatureShadow *self,int id,int *nLen,double const **pList){
 
1473
      *pList = OGR_F_GetFieldAsDoubleList(self, id, nLen);
 
1474
  }
 
1475
SWIGINTERN void OGRFeatureShadow_GetFieldAsStringList(OGRFeatureShadow *self,int id,char ***pList){
 
1476
      *pList = OGR_F_GetFieldAsStringList(self, id);
 
1477
  }
 
1478
SWIGINTERN bool OGRFeatureShadow_IsFieldSet__SWIG_0(OGRFeatureShadow *self,int id){
 
1479
    return (OGR_F_IsFieldSet(self, id) > 0);
 
1480
  }
 
1481
SWIGINTERN bool OGRFeatureShadow_IsFieldSet__SWIG_1(OGRFeatureShadow *self,char const *name){
 
1482
      int i = OGR_F_GetFieldIndex(self, name);
 
1483
      if (i == -1)
 
1484
          CPLError(CE_Failure, 1, "No such field: '%s'", name);
 
1485
      else
 
1486
          return (OGR_F_IsFieldSet(self, i) > 0);
 
1487
      return false;
 
1488
  }
 
1489
SWIGINTERN int OGRFeatureShadow_GetFieldIndex(OGRFeatureShadow *self,char const *name){
 
1490
      return OGR_F_GetFieldIndex(self, name);
 
1491
  }
 
1492
SWIGINTERN int OGRFeatureShadow_GetFID(OGRFeatureShadow *self){
1165
1493
    return OGR_F_GetFID(self);
1166
1494
  }
1167
 
static OGRErr OGRFeatureShadow_SetFID(OGRFeatureShadow *self,int fid){
1168
 
    OGRErr err = OGR_F_SetFID(self, fid);
1169
 
    if (err != 0)
1170
 
      throw err;
1171
 
    return 0;
 
1495
SWIGINTERN OGRErr OGRFeatureShadow_SetFID(OGRFeatureShadow *self,int fid){
 
1496
    return OGR_F_SetFID(self, fid);
1172
1497
  }
1173
 
static void OGRFeatureShadow_DumpReadable(OGRFeatureShadow *self){
 
1498
SWIGINTERN void OGRFeatureShadow_DumpReadable(OGRFeatureShadow *self){
1174
1499
    OGR_F_DumpReadable(self, NULL);
1175
1500
  }
1176
 
static void OGRFeatureShadow_UnsetField__SWIG_0(OGRFeatureShadow *self,int id){
 
1501
SWIGINTERN void OGRFeatureShadow_UnsetField__SWIG_0(OGRFeatureShadow *self,int id){
1177
1502
    OGR_F_UnsetField(self, id);
1178
1503
  }
1179
 
static void OGRFeatureShadow_UnsetField__SWIG_1(OGRFeatureShadow *self,char const *name){
1180
 
    OGR_F_UnsetField(self, OGR_F_GetFieldIndex(self, name));
 
1504
SWIGINTERN void OGRFeatureShadow_UnsetField__SWIG_1(OGRFeatureShadow *self,char const *name){
 
1505
      int i = OGR_F_GetFieldIndex(self, name);
 
1506
      if (i == -1)
 
1507
          CPLError(CE_Failure, 1, "No such field: '%s'", name);
 
1508
      else
 
1509
          OGR_F_UnsetField(self, i);
1181
1510
  }
1182
 
static void OGRFeatureShadow_SetField__SWIG_0(OGRFeatureShadow *self,int id,char const *value){
 
1511
SWIGINTERN void OGRFeatureShadow_SetField__SWIG_0(OGRFeatureShadow *self,int id,char const *value){
1183
1512
    OGR_F_SetFieldString(self, id, value);
1184
1513
  }
1185
 
static void OGRFeatureShadow_SetField__SWIG_1(OGRFeatureShadow *self,char const *name,char const *value){
1186
 
    OGR_F_SetFieldString(self, OGR_F_GetFieldIndex(self, name), value);
1187
 
  }
1188
 
static OGRErr OGRFeatureShadow_SetFrom(OGRFeatureShadow *self,OGRFeatureShadow *other,int forgiving=1){
1189
 
    OGRErr err = OGR_F_SetFrom(self, other, forgiving);
1190
 
    if (err != 0)
1191
 
      throw err;
1192
 
    return 0;
1193
 
  }
1194
 
static char const *OGRFeatureShadow_GetStyleString(OGRFeatureShadow *self){
 
1514
SWIGINTERN void OGRFeatureShadow_SetField__SWIG_1(OGRFeatureShadow *self,char const *name,char const *value){
 
1515
      int i = OGR_F_GetFieldIndex(self, name);
 
1516
      if (i == -1)
 
1517
          CPLError(CE_Failure, 1, "No such field: '%s'", name);
 
1518
      else
 
1519
          OGR_F_SetFieldString(self, i, value);
 
1520
  }
 
1521
SWIGINTERN void OGRFeatureShadow_SetField__SWIG_2(OGRFeatureShadow *self,int id,int value){
 
1522
    OGR_F_SetFieldInteger(self, id, value);
 
1523
  }
 
1524
SWIGINTERN void OGRFeatureShadow_SetField__SWIG_3(OGRFeatureShadow *self,char const *name,int value){
 
1525
      int i = OGR_F_GetFieldIndex(self, name);
 
1526
      if (i == -1)
 
1527
          CPLError(CE_Failure, 1, "No such field: '%s'", name);
 
1528
      else
 
1529
          OGR_F_SetFieldInteger(self, i, value);
 
1530
  }
 
1531
SWIGINTERN void OGRFeatureShadow_SetField__SWIG_4(OGRFeatureShadow *self,int id,double value){
 
1532
    OGR_F_SetFieldDouble(self, id, value);
 
1533
  }
 
1534
SWIGINTERN void OGRFeatureShadow_SetField__SWIG_5(OGRFeatureShadow *self,char const *name,double value){
 
1535
      int i = OGR_F_GetFieldIndex(self, name);
 
1536
      if (i == -1)
 
1537
          CPLError(CE_Failure, 1, "No such field: '%s'", name);
 
1538
      else
 
1539
          OGR_F_SetFieldDouble(self, i, value);
 
1540
  }
 
1541
SWIGINTERN void OGRFeatureShadow_SetField__SWIG_6(OGRFeatureShadow *self,int id,int year,int month,int day,int hour,int minute,int second,int tzflag){
 
1542
    OGR_F_SetFieldDateTime(self, id, year, month, day,
 
1543
                             hour, minute, second, 
 
1544
                             tzflag);
 
1545
  }
 
1546
SWIGINTERN void OGRFeatureShadow_SetField__SWIG_7(OGRFeatureShadow *self,char const *name,int year,int month,int day,int hour,int minute,int second,int tzflag){
 
1547
      int i = OGR_F_GetFieldIndex(self, name);
 
1548
      if (i == -1)
 
1549
          CPLError(CE_Failure, 1, "No such field: '%s'", name);
 
1550
      else
 
1551
          OGR_F_SetFieldDateTime(self, i, year, month, day,
 
1552
                                 hour, minute, second, 
 
1553
                                 tzflag);
 
1554
  }
 
1555
SWIGINTERN void OGRFeatureShadow_SetFieldIntegerList(OGRFeatureShadow *self,int id,int nList,int *pList){
 
1556
      OGR_F_SetFieldIntegerList(self, id, nList, pList);
 
1557
  }
 
1558
SWIGINTERN void OGRFeatureShadow_SetFieldDoubleList(OGRFeatureShadow *self,int id,int nList,double *pList){
 
1559
      OGR_F_SetFieldDoubleList(self, id, nList, pList);
 
1560
  }
 
1561
SWIGINTERN void OGRFeatureShadow_SetFieldStringList(OGRFeatureShadow *self,int id,char **pList){
 
1562
      OGR_F_SetFieldStringList(self, id, pList);
 
1563
  }
 
1564
SWIGINTERN OGRErr OGRFeatureShadow_SetFrom(OGRFeatureShadow *self,OGRFeatureShadow *other,int forgiving=1){
 
1565
    return OGR_F_SetFrom(self, other, forgiving);
 
1566
  }
 
1567
SWIGINTERN char const *OGRFeatureShadow_GetStyleString(OGRFeatureShadow *self){
1195
1568
    return (const char*) OGR_F_GetStyleString(self);
1196
1569
  }
1197
 
static void OGRFeatureShadow_SetStyleString(OGRFeatureShadow *self,char const *the_string){
 
1570
SWIGINTERN void OGRFeatureShadow_SetStyleString(OGRFeatureShadow *self,char const *the_string){
1198
1571
    OGR_F_SetStyleString(self, the_string);
1199
1572
  }
1200
 
static OGRFieldType OGRFeatureShadow_GetFieldType__SWIG_0(OGRFeatureShadow *self,int id){
 
1573
SWIGINTERN OGRFieldType OGRFeatureShadow_GetFieldType__SWIG_0(OGRFeatureShadow *self,int id){
1201
1574
    return (OGRFieldType) OGR_Fld_GetType( OGR_F_GetFieldDefnRef( self, id));
1202
1575
  }
1203
 
static OGRFieldType OGRFeatureShadow_GetFieldType__SWIG_1(OGRFeatureShadow *self,char const *name,char const *value){
1204
 
    return (OGRFieldType) OGR_Fld_GetType( 
1205
 
                            OGR_F_GetFieldDefnRef( self,  
1206
 
                                                   OGR_F_GetFieldIndex(self, 
1207
 
                                                                       name)
1208
 
                                                  )
1209
 
                                          );
1210
 
    
1211
 
  }
1212
 
static int _wrap_propset_Feature(zend_property_reference *property_reference, pval *value);
1213
 
static int _propset_Feature(zend_property_reference *property_reference, pval *value);
1214
 
static pval _wrap_propget_Feature(zend_property_reference *property_reference);
1215
 
static int _propget_Feature(zend_property_reference *property_reference, pval *value);
1216
 
static void delete_OGRFeatureDefnShadow(OGRFeatureDefnShadow *self){
1217
 
    OGR_FD_Destroy(self);
1218
 
  }
1219
 
static OGRFeatureDefnShadow *new_OGRFeatureDefnShadow(char const *name=NULL){
1220
 
    return (OGRFeatureDefnShadow* )OGR_FD_Create(name);
1221
 
  }
1222
 
static char const *OGRFeatureDefnShadow_GetName(OGRFeatureDefnShadow *self){
 
1576
SWIGINTERN OGRFieldType OGRFeatureShadow_GetFieldType__SWIG_1(OGRFeatureShadow *self,char const *name){
 
1577
      int i = OGR_F_GetFieldIndex(self, name);
 
1578
      if (i == -1) {
 
1579
          CPLError(CE_Failure, 1, "No such field: '%s'", name);
 
1580
          return (OGRFieldType)0;
 
1581
      } else
 
1582
          return (OGRFieldType) OGR_Fld_GetType( 
 
1583
              OGR_F_GetFieldDefnRef( self,  i )
 
1584
              );
 
1585
  }
 
1586
SWIGINTERN void delete_OGRFeatureDefnShadow(OGRFeatureDefnShadow *self){
 
1587
    /*OGR_FD_Destroy(self);*/
 
1588
    OGR_FD_Release( OGRFeatureDefnH(self) );
 
1589
  }
 
1590
SWIGINTERN OGRFeatureDefnShadow *new_OGRFeatureDefnShadow(char const *name_null_ok=NULL){
 
1591
    OGRFeatureDefnH h = OGR_FD_Create(name_null_ok);
 
1592
    OGR_FD_Reference(h);
 
1593
    return (OGRFeatureDefnShadow* )h;
 
1594
  }
 
1595
SWIGINTERN char const *OGRFeatureDefnShadow_GetName(OGRFeatureDefnShadow *self){
1223
1596
    return OGR_FD_GetName(self);
1224
1597
  }
1225
 
static int OGRFeatureDefnShadow_GetFieldCount(OGRFeatureDefnShadow *self){
 
1598
SWIGINTERN int OGRFeatureDefnShadow_GetFieldCount(OGRFeatureDefnShadow *self){
1226
1599
    return OGR_FD_GetFieldCount(self);
1227
1600
  }
1228
 
static OGRFieldDefnShadow *OGRFeatureDefnShadow_GetFieldDefn(OGRFeatureDefnShadow *self,int i){
 
1601
SWIGINTERN OGRFieldDefnShadow *OGRFeatureDefnShadow_GetFieldDefn(OGRFeatureDefnShadow *self,int i){
1229
1602
    return (OGRFieldDefnShadow*) OGR_FD_GetFieldDefn(self, i);
1230
1603
  }
1231
 
static int OGRFeatureDefnShadow_GetFieldIndex(OGRFeatureDefnShadow *self,char const *name){
1232
 
    return OGR_FD_GetFieldIndex(self, name);
 
1604
SWIGINTERN int OGRFeatureDefnShadow_GetFieldIndex(OGRFeatureDefnShadow *self,char const *name){
 
1605
      return OGR_FD_GetFieldIndex(self, name);
1233
1606
  }
1234
 
static void OGRFeatureDefnShadow_AddFieldDefn(OGRFeatureDefnShadow *self,OGRFieldDefnShadow *defn){
 
1607
SWIGINTERN void OGRFeatureDefnShadow_AddFieldDefn(OGRFeatureDefnShadow *self,OGRFieldDefnShadow *defn){
1235
1608
    OGR_FD_AddFieldDefn(self, defn);
1236
1609
  }
1237
 
static OGRwkbGeometryType OGRFeatureDefnShadow_GetGeomType(OGRFeatureDefnShadow *self){
 
1610
SWIGINTERN OGRwkbGeometryType OGRFeatureDefnShadow_GetGeomType(OGRFeatureDefnShadow *self){
1238
1611
    return (OGRwkbGeometryType) OGR_FD_GetGeomType(self);
1239
1612
  }
1240
 
static void OGRFeatureDefnShadow_SetGeomType(OGRFeatureDefnShadow *self,OGRwkbGeometryType geom_type){
 
1613
SWIGINTERN void OGRFeatureDefnShadow_SetGeomType(OGRFeatureDefnShadow *self,OGRwkbGeometryType geom_type){
1241
1614
    OGR_FD_SetGeomType(self, geom_type);
1242
1615
  }
1243
 
static int OGRFeatureDefnShadow_GetReferenceCount(OGRFeatureDefnShadow *self){
 
1616
SWIGINTERN int OGRFeatureDefnShadow_GetReferenceCount(OGRFeatureDefnShadow *self){
1244
1617
    return OGR_FD_GetReferenceCount(self);
1245
1618
  }
1246
 
static int _wrap_propset_FeatureDefn(zend_property_reference *property_reference, pval *value);
1247
 
static int _propset_FeatureDefn(zend_property_reference *property_reference, pval *value);
1248
 
static pval _wrap_propget_FeatureDefn(zend_property_reference *property_reference);
1249
 
static int _propget_FeatureDefn(zend_property_reference *property_reference, pval *value);
1250
 
static void delete_OGRFieldDefnShadow(OGRFieldDefnShadow *self){
 
1619
SWIGINTERN int OGRFeatureDefnShadow_IsGeometryIgnored(OGRFeatureDefnShadow *self){
 
1620
    return OGR_FD_IsGeometryIgnored(self);
 
1621
  }
 
1622
SWIGINTERN void OGRFeatureDefnShadow_SetGeometryIgnored(OGRFeatureDefnShadow *self,int bIgnored){
 
1623
    return OGR_FD_SetGeometryIgnored(self,bIgnored);
 
1624
  }
 
1625
SWIGINTERN int OGRFeatureDefnShadow_IsStyleIgnored(OGRFeatureDefnShadow *self){
 
1626
    return OGR_FD_IsStyleIgnored(self);
 
1627
  }
 
1628
SWIGINTERN void OGRFeatureDefnShadow_SetStyleIgnored(OGRFeatureDefnShadow *self,int bIgnored){
 
1629
    return OGR_FD_SetStyleIgnored(self,bIgnored);
 
1630
  }
 
1631
 
 
1632
    static int ValidateOGRFieldType(OGRFieldType field_type)
 
1633
    {
 
1634
        switch(field_type)
 
1635
        {
 
1636
            case OFTInteger:
 
1637
            case OFTIntegerList:
 
1638
            case OFTReal:
 
1639
            case OFTRealList:
 
1640
            case OFTString:
 
1641
            case OFTStringList:
 
1642
            case OFTBinary:
 
1643
            case OFTDate:
 
1644
            case OFTTime:
 
1645
            case OFTDateTime:
 
1646
                return TRUE;
 
1647
            default:
 
1648
                CPLError(CE_Failure, CPLE_IllegalArg, "Illegal field type value");
 
1649
                return FALSE;
 
1650
        }
 
1651
    }
 
1652
 
 
1653
SWIGINTERN void delete_OGRFieldDefnShadow(OGRFieldDefnShadow *self){
1251
1654
    OGR_Fld_Destroy(self);
1252
1655
  }
1253
 
static OGRFieldDefnShadow *new_OGRFieldDefnShadow(char const *name="unnamed",OGRFieldType field_type=OFTString){
1254
 
    return (OGRFieldDefnShadow*) OGR_Fld_Create(name, field_type);
1255
 
  }
1256
 
static char const *OGRFieldDefnShadow_GetName(OGRFieldDefnShadow *self){
1257
 
    return (const char *) OGR_Fld_GetNameRef(self);
1258
 
  }
1259
 
static char const *OGRFieldDefnShadow_GetNameRef(OGRFieldDefnShadow *self){
1260
 
    return (const char *) OGR_Fld_GetNameRef(self);
1261
 
  }
1262
 
static void OGRFieldDefnShadow_SetName(OGRFieldDefnShadow *self,char const *name){
 
1656
SWIGINTERN OGRFieldDefnShadow *new_OGRFieldDefnShadow(char const *name_null_ok="unnamed",OGRFieldType field_type=OFTString){
 
1657
    if (ValidateOGRFieldType(field_type))
 
1658
        return (OGRFieldDefnShadow*) OGR_Fld_Create(name_null_ok, field_type);
 
1659
    else
 
1660
        return NULL;
 
1661
  }
 
1662
SWIGINTERN char const *OGRFieldDefnShadow_GetName(OGRFieldDefnShadow *self){
 
1663
    return (const char *) OGR_Fld_GetNameRef(self);
 
1664
  }
 
1665
SWIGINTERN char const *OGRFieldDefnShadow_GetNameRef(OGRFieldDefnShadow *self){
 
1666
    return (const char *) OGR_Fld_GetNameRef(self);
 
1667
  }
 
1668
SWIGINTERN void OGRFieldDefnShadow_SetName(OGRFieldDefnShadow *self,char const *name){
1263
1669
    OGR_Fld_SetName(self, name);
1264
1670
  }
1265
 
static OGRFieldType OGRFieldDefnShadow_GetType(OGRFieldDefnShadow *self){
 
1671
SWIGINTERN OGRFieldType OGRFieldDefnShadow_GetType(OGRFieldDefnShadow *self){
1266
1672
    return OGR_Fld_GetType(self);
1267
1673
  }
1268
 
static void OGRFieldDefnShadow_SetType(OGRFieldDefnShadow *self,OGRFieldType type){
1269
 
    OGR_Fld_SetType(self, type);
 
1674
SWIGINTERN void OGRFieldDefnShadow_SetType(OGRFieldDefnShadow *self,OGRFieldType type){
 
1675
    if (ValidateOGRFieldType(type))
 
1676
        OGR_Fld_SetType(self, type);
1270
1677
  }
1271
 
static OGRJustification OGRFieldDefnShadow_GetJustify(OGRFieldDefnShadow *self){
 
1678
SWIGINTERN OGRJustification OGRFieldDefnShadow_GetJustify(OGRFieldDefnShadow *self){
1272
1679
    return OGR_Fld_GetJustify(self);
1273
1680
  }
1274
 
static void OGRFieldDefnShadow_SetJustify(OGRFieldDefnShadow *self,OGRJustification justify){
 
1681
SWIGINTERN void OGRFieldDefnShadow_SetJustify(OGRFieldDefnShadow *self,OGRJustification justify){
1275
1682
    OGR_Fld_SetJustify(self, justify);
1276
1683
  }
1277
 
static int OGRFieldDefnShadow_GetWidth(OGRFieldDefnShadow *self){
 
1684
SWIGINTERN int OGRFieldDefnShadow_GetWidth(OGRFieldDefnShadow *self){
1278
1685
    return OGR_Fld_GetWidth(self);
1279
1686
  }
1280
 
static void OGRFieldDefnShadow_SetWidth(OGRFieldDefnShadow *self,int width){
 
1687
SWIGINTERN void OGRFieldDefnShadow_SetWidth(OGRFieldDefnShadow *self,int width){
1281
1688
    OGR_Fld_SetWidth(self, width);
1282
1689
  }
1283
 
static int OGRFieldDefnShadow_GetPrecision(OGRFieldDefnShadow *self){
 
1690
SWIGINTERN int OGRFieldDefnShadow_GetPrecision(OGRFieldDefnShadow *self){
1284
1691
    return OGR_Fld_GetPrecision(self);
1285
1692
  }
1286
 
static void OGRFieldDefnShadow_SetPrecision(OGRFieldDefnShadow *self,int precision){
 
1693
SWIGINTERN void OGRFieldDefnShadow_SetPrecision(OGRFieldDefnShadow *self,int precision){
1287
1694
    OGR_Fld_SetPrecision(self, precision);
1288
1695
  }
1289
 
static char const *OGRFieldDefnShadow_GetFieldTypeName(OGRFieldDefnShadow *self,OGRFieldType type){
 
1696
SWIGINTERN char const *OGRFieldDefnShadow_GetTypeName(OGRFieldDefnShadow *self){
 
1697
      return OGR_GetFieldTypeName(OGR_Fld_GetType(self));
 
1698
  }
 
1699
SWIGINTERN char const *OGRFieldDefnShadow_GetFieldTypeName(OGRFieldDefnShadow *self,OGRFieldType type){
1290
1700
    return OGR_GetFieldTypeName(type);
1291
1701
  }
1292
 
static int _wrap_propset_FieldDefn(zend_property_reference *property_reference, pval *value);
1293
 
static int _propset_FieldDefn(zend_property_reference *property_reference, pval *value);
1294
 
static pval _wrap_propget_FieldDefn(zend_property_reference *property_reference);
1295
 
static int _propget_FieldDefn(zend_property_reference *property_reference, pval *value);
 
1702
SWIGINTERN int OGRFieldDefnShadow_IsIgnored(OGRFieldDefnShadow *self){
 
1703
    return OGR_Fld_IsIgnored( self );
 
1704
  }
 
1705
SWIGINTERN void OGRFieldDefnShadow_SetIgnored(OGRFieldDefnShadow *self,int bIgnored){
 
1706
    return OGR_Fld_SetIgnored( self, bIgnored );
 
1707
  }
1296
1708
 
1297
1709
  OGRGeometryShadow* CreateGeometryFromWkb( int len, char *bin_string, 
1298
1710
                                            OSRSpatialReferenceShadow *reference=NULL ) {
1299
 
    void *geom;
 
1711
    OGRGeometryShadow *geom;
1300
1712
    OGRErr err = OGR_G_CreateFromWkb( (unsigned char *) bin_string,
1301
1713
                                      reference,
1302
1714
                                      &geom,
1303
1715
                                      len );
1304
 
    if (err != 0 )
1305
 
       throw err;
 
1716
    if (err != 0 ) {
 
1717
       CPLError(CE_Failure, err, "%s", OGRErrMessages(err));
 
1718
       return NULL;
 
1719
    }
1306
1720
    return (OGRGeometryShadow*) geom;
1307
1721
  }
1308
1722
 
1310
1724
 
1311
1725
  OGRGeometryShadow* CreateGeometryFromWkt( char **val, 
1312
1726
                                      OSRSpatialReferenceShadow *reference=NULL ) {
1313
 
    void *geom;
 
1727
    OGRGeometryShadow *geom;
1314
1728
    OGRErr err = OGR_G_CreateFromWkt(val,
1315
1729
                                      reference,
1316
1730
                                      &geom);
1317
 
    if (err != 0 )
1318
 
       throw err;
 
1731
    if (err != 0 ) {
 
1732
       CPLError(CE_Failure, err, "%s", OGRErrMessages(err));
 
1733
       return NULL;
 
1734
    }
1319
1735
    return (OGRGeometryShadow*) geom;
1320
1736
  }
1321
1737
 
1327
1743
  }
1328
1744
 
1329
1745
 
1330
 
static void delete_OGRGeometryShadow(OGRGeometryShadow *self){
 
1746
 
 
1747
  OGRGeometryShadow *CreateGeometryFromJson( const char * input_string ) {
 
1748
    OGRGeometryShadow* geom = (OGRGeometryShadow*)OGR_G_CreateGeometryFromJson(input_string);
 
1749
    return geom;
 
1750
  }
 
1751
 
 
1752
 
 
1753
 
 
1754
  OGRGeometryShadow* BuildPolygonFromEdges( OGRGeometryShadow*  hLineCollection,  
 
1755
                                            int bBestEffort = 0, 
 
1756
                                            int bAutoClose = 0, 
 
1757
                                            double dfTolerance=0) {
 
1758
  
 
1759
  OGRGeometryH hPolygon = NULL;
 
1760
  
 
1761
  OGRErr eErr;
 
1762
 
 
1763
  hPolygon = OGRBuildPolygonFromEdges( hLineCollection, bBestEffort, 
 
1764
                                       bAutoClose, dfTolerance, &eErr );
 
1765
 
 
1766
  if (eErr != OGRERR_NONE ) {
 
1767
    CPLError(CE_Failure, eErr, "%s", OGRErrMessages(eErr));
 
1768
    return NULL;
 
1769
  }
 
1770
 
 
1771
  return hPolygon;
 
1772
  }
 
1773
 
 
1774
 
 
1775
  OGRGeometryShadow* ApproximateArcAngles( 
 
1776
        double dfCenterX, double dfCenterY, double dfZ,
 
1777
        double dfPrimaryRadius, double dfSecondaryAxis, double dfRotation, 
 
1778
        double dfStartAngle, double dfEndAngle,
 
1779
        double dfMaxAngleStepSizeDegrees ) {
 
1780
  
 
1781
  return OGR_G_ApproximateArcAngles( 
 
1782
             dfCenterX, dfCenterY, dfZ, 
 
1783
             dfPrimaryRadius, dfSecondaryAxis, dfRotation,
 
1784
             dfStartAngle, dfEndAngle, dfMaxAngleStepSizeDegrees );
 
1785
  }
 
1786
 
 
1787
 
 
1788
OGRGeometryShadow* ForceToPolygon( OGRGeometryShadow *geom_in ) {
 
1789
 if (geom_in == NULL)
 
1790
     return NULL;
 
1791
 return OGR_G_ForceToPolygon( OGR_G_Clone(geom_in) );
 
1792
}
 
1793
 
 
1794
 
 
1795
OGRGeometryShadow* ForceToMultiPolygon( OGRGeometryShadow *geom_in ) {
 
1796
 if (geom_in == NULL)
 
1797
     return NULL;
 
1798
 return OGR_G_ForceToMultiPolygon( OGR_G_Clone(geom_in) );
 
1799
}
 
1800
 
 
1801
 
 
1802
OGRGeometryShadow* ForceToMultiPoint( OGRGeometryShadow *geom_in ) {
 
1803
 if (geom_in == NULL)
 
1804
     return NULL;
 
1805
 return OGR_G_ForceToMultiPoint( OGR_G_Clone(geom_in) );
 
1806
}
 
1807
 
 
1808
 
 
1809
OGRGeometryShadow* ForceToMultiLineString( OGRGeometryShadow *geom_in ) {
 
1810
 if (geom_in == NULL)
 
1811
     return NULL;
 
1812
 return OGR_G_ForceToMultiLineString( OGR_G_Clone(geom_in) );
 
1813
}
 
1814
 
 
1815
SWIGINTERN void delete_OGRGeometryShadow(OGRGeometryShadow *self){
1331
1816
    OGR_G_DestroyGeometry( self );
1332
1817
  }
1333
 
static OGRGeometryShadow *new_OGRGeometryShadow(OGRwkbGeometryType type=wkbUnknown,char *wkt=0,int wkb=0,char *wkb_buf=0,char *gml=0){
 
1818
SWIGINTERN OGRGeometryShadow *new_OGRGeometryShadow(OGRwkbGeometryType type=wkbUnknown,char *wkt=0,int wkb=0,char *wkb_buf=0,char *gml=0){
1334
1819
    if (type != wkbUnknown ) {
1335
1820
      return (OGRGeometryShadow*) OGR_G_CreateGeometry( type );
1336
1821
    }
1344
1829
      return CreateGeometryFromGML( gml );
1345
1830
    }
1346
1831
    // throw?
1347
 
    else return 0;
1348
 
  }
1349
 
static char const *OGRGeometryShadow_ExportToWkt(OGRGeometryShadow *self){
1350
 
    char * output;
1351
 
    OGRErr err = OGR_G_ExportToWkt(self, &output);
1352
 
    if (err != 0) 
1353
 
      throw err;
1354
 
    return output;
1355
 
  }
1356
 
static OGRErr OGRGeometryShadow_ExportToWkb(OGRGeometryShadow *self,int *nLen,char **pBuf,OGRwkbByteOrder byte_order=wkbXDR){
 
1832
    else {
 
1833
        CPLError(CE_Failure, 1, "Empty geometries cannot be constructed");
 
1834
        return NULL;}
 
1835
 
 
1836
  }
 
1837
SWIGINTERN OGRErr OGRGeometryShadow_ExportToWkt(OGRGeometryShadow *self,char **argout){
 
1838
    return OGR_G_ExportToWkt(self, argout);
 
1839
  }
 
1840
SWIGINTERN OGRErr OGRGeometryShadow_ExportToWkb(OGRGeometryShadow *self,int *nLen,char **pBuf,OGRwkbByteOrder byte_order=wkbXDR){
1357
1841
    *nLen = OGR_G_WkbSize( self );
1358
1842
    *pBuf = (char *) malloc( *nLen * sizeof(unsigned char) );
1359
1843
    return OGR_G_ExportToWkb(self, byte_order, (unsigned char*) *pBuf );
1360
1844
  }
1361
 
static char const *OGRGeometryShadow_ExportToGML(OGRGeometryShadow *self){
 
1845
SWIGINTERN char const *OGRGeometryShadow_ExportToGML(OGRGeometryShadow *self){
1362
1846
    return (const char *) OGR_G_ExportToGML(self);
1363
1847
  }
1364
 
static void OGRGeometryShadow_AddPoint(OGRGeometryShadow *self,double x,double y,double z=0){
 
1848
SWIGINTERN char const *OGRGeometryShadow_ExportToKML(OGRGeometryShadow *self,char const *altitude_mode=NULL){
 
1849
    return (const char *) OGR_G_ExportToKML(self, altitude_mode);
 
1850
  }
 
1851
SWIGINTERN char const *OGRGeometryShadow_ExportToJson(OGRGeometryShadow *self){
 
1852
    return (const char *) OGR_G_ExportToJson(self);
 
1853
  }
 
1854
SWIGINTERN void OGRGeometryShadow_AddPoint(OGRGeometryShadow *self,double x,double y,double z=0){
1365
1855
    OGR_G_AddPoint( self, x, y, z );
1366
1856
  }
1367
 
static OGRErr OGRGeometryShadow_AddGeometryDirectly(OGRGeometryShadow *self,OGRGeometryShadow *other){
1368
 
    return OGR_G_AddGeometryDirectly( self, other );
1369
 
  }
1370
 
static OGRErr OGRGeometryShadow_AddGeometry(OGRGeometryShadow *self,OGRGeometryShadow *other){
 
1857
SWIGINTERN void OGRGeometryShadow_AddPoint_2D(OGRGeometryShadow *self,double x,double y){
 
1858
    OGR_G_AddPoint_2D( self, x, y );
 
1859
  }
 
1860
SWIGINTERN OGRErr OGRGeometryShadow_AddGeometryDirectly(OGRGeometryShadow *self,OGRGeometryShadow *other_disown){
 
1861
    return OGR_G_AddGeometryDirectly( self, other_disown );
 
1862
  }
 
1863
SWIGINTERN OGRErr OGRGeometryShadow_AddGeometry(OGRGeometryShadow *self,OGRGeometryShadow *other){
1371
1864
    return OGR_G_AddGeometry( self, other );
1372
1865
  }
1373
 
static OGRGeometryShadow *OGRGeometryShadow_Clone(OGRGeometryShadow *self){
 
1866
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Clone(OGRGeometryShadow *self){
1374
1867
    return (OGRGeometryShadow*) OGR_G_Clone(self);
1375
1868
  }
1376
 
static OGRwkbGeometryType OGRGeometryShadow_GetGeometryType(OGRGeometryShadow *self){
 
1869
SWIGINTERN OGRwkbGeometryType OGRGeometryShadow_GetGeometryType(OGRGeometryShadow *self){
1377
1870
    return (OGRwkbGeometryType) OGR_G_GetGeometryType(self);
1378
1871
  }
1379
 
static char const *OGRGeometryShadow_GetGeometryName(OGRGeometryShadow *self){
 
1872
SWIGINTERN char const *OGRGeometryShadow_GetGeometryName(OGRGeometryShadow *self){
1380
1873
    return (const char *) OGR_G_GetGeometryName(self);
1381
1874
  }
1382
 
static double OGRGeometryShadow_GetArea(OGRGeometryShadow *self){
1383
 
    return OGR_G_GetArea(self);
1384
 
  }
1385
 
static int OGRGeometryShadow_GetPointCount(OGRGeometryShadow *self){
 
1875
SWIGINTERN double OGRGeometryShadow_Length(OGRGeometryShadow *self){
 
1876
    return OGR_G_Length(self);
 
1877
  }
 
1878
SWIGINTERN double OGRGeometryShadow_Area(OGRGeometryShadow *self){
 
1879
    return OGR_G_Area(self);
 
1880
  }
 
1881
SWIGINTERN double OGRGeometryShadow_GetArea(OGRGeometryShadow *self){
 
1882
    return OGR_G_Area(self);
 
1883
  }
 
1884
SWIGINTERN int OGRGeometryShadow_GetPointCount(OGRGeometryShadow *self){
1386
1885
    return OGR_G_GetPointCount(self);
1387
1886
  }
1388
 
static double OGRGeometryShadow_GetX(OGRGeometryShadow *self,int point=0){
 
1887
SWIGINTERN double OGRGeometryShadow_GetX(OGRGeometryShadow *self,int point=0){
1389
1888
    return OGR_G_GetX(self, point);
1390
1889
  }
1391
 
static double OGRGeometryShadow_GetY(OGRGeometryShadow *self,int point=0){
 
1890
SWIGINTERN double OGRGeometryShadow_GetY(OGRGeometryShadow *self,int point=0){
1392
1891
    return OGR_G_GetY(self, point);
1393
1892
  }
1394
 
static double OGRGeometryShadow_GetZ(OGRGeometryShadow *self,int point=0){
 
1893
SWIGINTERN double OGRGeometryShadow_GetZ(OGRGeometryShadow *self,int point=0){
1395
1894
    return OGR_G_GetZ(self, point);
1396
1895
  }
1397
 
static int OGRGeometryShadow_GetGeometryCount(OGRGeometryShadow *self){
 
1896
SWIGINTERN void OGRGeometryShadow_GetPoint(OGRGeometryShadow *self,int iPoint=0,double argout[3]=NULL){
 
1897
 
 
1898
    OGR_G_GetPoint( self, iPoint, argout+0, argout+1, argout+2 );
 
1899
  }
 
1900
SWIGINTERN void OGRGeometryShadow_GetPoint_2D(OGRGeometryShadow *self,int iPoint=0,double argout[2]=NULL){
 
1901
 
 
1902
    OGR_G_GetPoint( self, iPoint, argout+0, argout+1, NULL );
 
1903
  }
 
1904
SWIGINTERN int OGRGeometryShadow_GetGeometryCount(OGRGeometryShadow *self){
1398
1905
    return OGR_G_GetGeometryCount(self);
1399
1906
  }
1400
 
static void OGRGeometryShadow_SetPoint(OGRGeometryShadow *self,int point,double x,double y,double z=0){
 
1907
SWIGINTERN void OGRGeometryShadow_SetPoint(OGRGeometryShadow *self,int point,double x,double y,double z=0){
1401
1908
    OGR_G_SetPoint(self, point, x, y, z);
1402
1909
  }
1403
 
static OGRGeometryShadow *OGRGeometryShadow_GetGeometryRef(OGRGeometryShadow *self,int geom){
 
1910
SWIGINTERN void OGRGeometryShadow_SetPoint_2D(OGRGeometryShadow *self,int point,double x,double y){
 
1911
    OGR_G_SetPoint_2D(self, point, x, y);
 
1912
  }
 
1913
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_GetGeometryRef(OGRGeometryShadow *self,int geom){
1404
1914
    return (OGRGeometryShadow*) OGR_G_GetGeometryRef(self, geom);
1405
1915
  }
1406
 
static OGRGeometryShadow *OGRGeometryShadow_GetBoundary(OGRGeometryShadow *self){
1407
 
    return (OGRGeometryShadow*) OGR_G_GetBoundary(self);
1408
 
  }
1409
 
static OGRGeometryShadow *OGRGeometryShadow_ConvexHull(OGRGeometryShadow *self){
 
1916
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Simplify(OGRGeometryShadow *self,double tolerance){
 
1917
    return (OGRGeometryShadow*) OGR_G_Simplify(self, tolerance);
 
1918
  }
 
1919
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Boundary(OGRGeometryShadow *self){
 
1920
    return (OGRGeometryShadow*) OGR_G_Boundary(self);
 
1921
  }
 
1922
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_GetBoundary(OGRGeometryShadow *self){
 
1923
    return (OGRGeometryShadow*) OGR_G_Boundary(self);
 
1924
  }
 
1925
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_ConvexHull(OGRGeometryShadow *self){
1410
1926
    return (OGRGeometryShadow*) OGR_G_ConvexHull(self);
1411
1927
  }
1412
 
static OGRGeometryShadow *OGRGeometryShadow_Buffer(OGRGeometryShadow *self,double distance,int quadsecs=30){
 
1928
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Buffer(OGRGeometryShadow *self,double distance,int quadsecs=30){
1413
1929
    return (OGRGeometryShadow*) OGR_G_Buffer( self, distance, quadsecs );
1414
1930
  }
1415
 
static OGRGeometryShadow *OGRGeometryShadow_Intersection(OGRGeometryShadow *self,OGRGeometryShadow *other){
 
1931
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Intersection(OGRGeometryShadow *self,OGRGeometryShadow *other){
1416
1932
    return (OGRGeometryShadow*) OGR_G_Intersection( self, other );
1417
1933
  }
1418
 
static OGRGeometryShadow *OGRGeometryShadow_Union(OGRGeometryShadow *self,OGRGeometryShadow *other){
 
1934
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Union(OGRGeometryShadow *self,OGRGeometryShadow *other){
1419
1935
    return (OGRGeometryShadow*) OGR_G_Union( self, other );
1420
1936
  }
1421
 
static OGRGeometryShadow *OGRGeometryShadow_Difference(OGRGeometryShadow *self,OGRGeometryShadow *other){
 
1937
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_UnionCascaded(OGRGeometryShadow *self){
 
1938
    return (OGRGeometryShadow*) OGR_G_UnionCascaded( self );
 
1939
  }
 
1940
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Difference(OGRGeometryShadow *self,OGRGeometryShadow *other){
1422
1941
    return (OGRGeometryShadow*) OGR_G_Difference( self, other );
1423
1942
  }
1424
 
static OGRGeometryShadow *OGRGeometryShadow_SymmetricDifference(OGRGeometryShadow *self,OGRGeometryShadow *other){
1425
 
    return (OGRGeometryShadow*) OGR_G_SymmetricDifference( self, other );
1426
 
  }
1427
 
static double OGRGeometryShadow_Distance(OGRGeometryShadow *self,OGRGeometryShadow *other){
 
1943
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_SymDifference(OGRGeometryShadow *self,OGRGeometryShadow *other){
 
1944
    return (OGRGeometryShadow*) OGR_G_SymDifference( self, other );
 
1945
  }
 
1946
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_SymmetricDifference(OGRGeometryShadow *self,OGRGeometryShadow *other){
 
1947
    return (OGRGeometryShadow*) OGR_G_SymDifference( self, other );
 
1948
  }
 
1949
SWIGINTERN double OGRGeometryShadow_Distance(OGRGeometryShadow *self,OGRGeometryShadow *other){
1428
1950
    return OGR_G_Distance(self, other);
1429
1951
  }
1430
 
static void OGRGeometryShadow_Empty(OGRGeometryShadow *self){
 
1952
SWIGINTERN void OGRGeometryShadow_Empty(OGRGeometryShadow *self){
1431
1953
    OGR_G_Empty(self);
1432
1954
  }
1433
 
static int OGRGeometryShadow_Intersect(OGRGeometryShadow *self,OGRGeometryShadow *other){
1434
 
    return OGR_G_Intersect(self, other);
1435
 
  }
1436
 
static int OGRGeometryShadow_Equal(OGRGeometryShadow *self,OGRGeometryShadow *other){
1437
 
    return OGR_G_Equal(self, other);
1438
 
  }
1439
 
static int OGRGeometryShadow_Disjoint(OGRGeometryShadow *self,OGRGeometryShadow *other){
1440
 
    return OGR_G_Disjoint(self, other);
1441
 
  }
1442
 
static int OGRGeometryShadow_Touches(OGRGeometryShadow *self,OGRGeometryShadow *other){
1443
 
    return OGR_G_Touches(self, other);
1444
 
  }
1445
 
static int OGRGeometryShadow_Crosses(OGRGeometryShadow *self,OGRGeometryShadow *other){
1446
 
    return OGR_G_Crosses(self, other);
1447
 
  }
1448
 
static int OGRGeometryShadow_Within(OGRGeometryShadow *self,OGRGeometryShadow *other){
1449
 
    return OGR_G_Within(self, other);
1450
 
  }
1451
 
static int OGRGeometryShadow_Contains(OGRGeometryShadow *self,OGRGeometryShadow *other){
1452
 
    return OGR_G_Contains(self, other);
1453
 
  }
1454
 
static int OGRGeometryShadow_Overlaps(OGRGeometryShadow *self,OGRGeometryShadow *other){
1455
 
    return OGR_G_Overlaps(self, other);
1456
 
  }
1457
 
static OGRErr OGRGeometryShadow_TransformTo(OGRGeometryShadow *self,OSRSpatialReferenceShadow *reference){
 
1955
SWIGINTERN bool OGRGeometryShadow_IsEmpty(OGRGeometryShadow *self){
 
1956
    return (OGR_G_IsEmpty(self) > 0);
 
1957
  }
 
1958
SWIGINTERN bool OGRGeometryShadow_IsValid(OGRGeometryShadow *self){
 
1959
    return (OGR_G_IsValid(self) > 0);
 
1960
  }
 
1961
SWIGINTERN bool OGRGeometryShadow_IsSimple(OGRGeometryShadow *self){
 
1962
    return (OGR_G_IsSimple(self) > 0);
 
1963
  }
 
1964
SWIGINTERN bool OGRGeometryShadow_IsRing(OGRGeometryShadow *self){
 
1965
    return (OGR_G_IsRing(self) > 0);
 
1966
  }
 
1967
SWIGINTERN bool OGRGeometryShadow_Intersects(OGRGeometryShadow *self,OGRGeometryShadow *other){
 
1968
    return (OGR_G_Intersects(self, other) > 0);
 
1969
  }
 
1970
SWIGINTERN bool OGRGeometryShadow_Intersect(OGRGeometryShadow *self,OGRGeometryShadow *other){
 
1971
    return (OGR_G_Intersects(self, other) > 0);
 
1972
  }
 
1973
SWIGINTERN bool OGRGeometryShadow_Equals(OGRGeometryShadow *self,OGRGeometryShadow *other){
 
1974
    return (OGR_G_Equals(self, other) > 0);
 
1975
  }
 
1976
SWIGINTERN bool OGRGeometryShadow_Equal(OGRGeometryShadow *self,OGRGeometryShadow *other){
 
1977
    return (OGR_G_Equals(self, other) > 0);
 
1978
  }
 
1979
SWIGINTERN bool OGRGeometryShadow_Disjoint(OGRGeometryShadow *self,OGRGeometryShadow *other){
 
1980
    return (OGR_G_Disjoint(self, other) > 0);
 
1981
  }
 
1982
SWIGINTERN bool OGRGeometryShadow_Touches(OGRGeometryShadow *self,OGRGeometryShadow *other){
 
1983
    return (OGR_G_Touches(self, other) > 0);
 
1984
  }
 
1985
SWIGINTERN bool OGRGeometryShadow_Crosses(OGRGeometryShadow *self,OGRGeometryShadow *other){
 
1986
    return (OGR_G_Crosses(self, other) > 0);
 
1987
  }
 
1988
SWIGINTERN bool OGRGeometryShadow_Within(OGRGeometryShadow *self,OGRGeometryShadow *other){
 
1989
    return (OGR_G_Within(self, other) > 0);
 
1990
  }
 
1991
SWIGINTERN bool OGRGeometryShadow_Contains(OGRGeometryShadow *self,OGRGeometryShadow *other){
 
1992
    return (OGR_G_Contains(self, other) > 0);
 
1993
  }
 
1994
SWIGINTERN bool OGRGeometryShadow_Overlaps(OGRGeometryShadow *self,OGRGeometryShadow *other){
 
1995
    return (OGR_G_Overlaps(self, other) > 0);
 
1996
  }
 
1997
SWIGINTERN OGRErr OGRGeometryShadow_TransformTo(OGRGeometryShadow *self,OSRSpatialReferenceShadow *reference){
1458
1998
    return OGR_G_TransformTo(self, reference);
1459
1999
  }
1460
 
static OGRErr OGRGeometryShadow_Transform(OGRGeometryShadow *self,OSRCoordinateTransformationShadow *trans){
 
2000
SWIGINTERN OGRErr OGRGeometryShadow_Transform(OGRGeometryShadow *self,OSRCoordinateTransformationShadow *trans){
1461
2001
    return OGR_G_Transform(self, trans);
1462
2002
  }
1463
 
static OSRSpatialReferenceShadow *OGRGeometryShadow_GetSpatialReference(OGRGeometryShadow *self){
1464
 
    return (OSRSpatialReferenceShadow*)OGR_G_GetSpatialReference(self);
 
2003
SWIGINTERN OSRSpatialReferenceShadow *OGRGeometryShadow_GetSpatialReference(OGRGeometryShadow *self){
 
2004
    OGRSpatialReferenceH ref =  OGR_G_GetSpatialReference(self);
 
2005
    if( ref )
 
2006
        OSRReference(ref);
 
2007
    return (OSRSpatialReferenceShadow*) ref;
1465
2008
  }
1466
 
static void OGRGeometryShadow_AssignSpatialReference(OGRGeometryShadow *self,OSRSpatialReferenceShadow *reference){
 
2009
SWIGINTERN void OGRGeometryShadow_AssignSpatialReference(OGRGeometryShadow *self,OSRSpatialReferenceShadow *reference){
1467
2010
    OGR_G_AssignSpatialReference(self, reference);
1468
2011
  }
1469
 
static void OGRGeometryShadow_CloseRings(OGRGeometryShadow *self){
 
2012
SWIGINTERN void OGRGeometryShadow_CloseRings(OGRGeometryShadow *self){
1470
2013
    OGR_G_CloseRings(self);
1471
2014
  }
1472
 
static void OGRGeometryShadow_FlattenTo2D(OGRGeometryShadow *self){
 
2015
SWIGINTERN void OGRGeometryShadow_FlattenTo2D(OGRGeometryShadow *self){
1473
2016
    OGR_G_FlattenTo2D(self);
1474
2017
  }
1475
 
static void OGRGeometryShadow_GetEnvelope(OGRGeometryShadow *self,double argout[4]){
 
2018
SWIGINTERN void OGRGeometryShadow_Segmentize(OGRGeometryShadow *self,double dfMaxLength){
 
2019
    OGR_G_Segmentize(self, dfMaxLength);
 
2020
  }
 
2021
SWIGINTERN void OGRGeometryShadow_GetEnvelope(OGRGeometryShadow *self,double argout[4]){
1476
2022
    OGR_G_GetEnvelope(self, (OGREnvelope*)argout);
1477
2023
  }
1478
 
static OGRGeometryShadow *OGRGeometryShadow_Centroid(OGRGeometryShadow *self){
1479
 
    OGRGeometryShadow *pt = new_OGRGeometryShadow( wkbPoint );
1480
 
    OGRErr rcode = OGR_G_Centroid( self, pt );
 
2024
SWIGINTERN OGRGeometryShadow *OGRGeometryShadow_Centroid(OGRGeometryShadow *self){
 
2025
    OGRGeometryShadow *pt = (OGRGeometryShadow*) OGR_G_CreateGeometry( wkbPoint );
 
2026
    OGR_G_Centroid( self, pt );
1481
2027
    return pt;
1482
2028
  }
1483
 
static int OGRGeometryShadow_WkbSize(OGRGeometryShadow *self){
 
2029
SWIGINTERN int OGRGeometryShadow_WkbSize(OGRGeometryShadow *self){
1484
2030
    return OGR_G_WkbSize(self);
1485
2031
  }
1486
 
static int OGRGeometryShadow_GetCoordinateDimension(OGRGeometryShadow *self){
 
2032
SWIGINTERN int OGRGeometryShadow_GetCoordinateDimension(OGRGeometryShadow *self){
1487
2033
    return OGR_G_GetCoordinateDimension(self);
1488
2034
  }
1489
 
static int OGRGeometryShadow_GetDimension(OGRGeometryShadow *self){
 
2035
SWIGINTERN void OGRGeometryShadow_SetCoordinateDimension(OGRGeometryShadow *self,int dimension){
 
2036
    OGR_G_SetCoordinateDimension(self, dimension);
 
2037
  }
 
2038
SWIGINTERN int OGRGeometryShadow_GetDimension(OGRGeometryShadow *self){
1490
2039
    return OGR_G_GetDimension(self);
1491
2040
  }
1492
 
static int _wrap_propset_Geometry(zend_property_reference *property_reference, pval *value);
1493
 
static int _propset_Geometry(zend_property_reference *property_reference, pval *value);
1494
 
static pval _wrap_propget_Geometry(zend_property_reference *property_reference);
1495
 
static int _propget_Geometry(zend_property_reference *property_reference, pval *value);
1496
2041
 
1497
2042
char const *OGRDriverShadow_get_name( OGRDriverShadow *h ) {
1498
2043
  return OGR_Dr_GetName( h );
1518
2063
 
1519
2064
 
1520
2065
  OGRDataSourceShadow* Open( const char *filename, int update =0 ) {
 
2066
    CPLErrorReset();
1521
2067
    OGRDataSourceShadow* ds = (OGRDataSourceShadow*)OGROpen(filename,update,NULL);
 
2068
    if( CPLGetLastErrorType() == CE_Failure && ds != NULL )
 
2069
    {
 
2070
        CPLDebug( "SWIG", 
 
2071
                  "OGROpen() succeeded, but an error is posted, so we destroy"
 
2072
                  " the datasource and fail at swig level." );
 
2073
        OGRReleaseDataSource(ds);
 
2074
        ds = NULL;
 
2075
    }
 
2076
        
1522
2077
    return ds;
1523
2078
  }
1524
2079
 
1525
2080
 
1526
 
  OGRDataSourceShadow* OpenShared( const char *filename, int update =0 ) {
1527
 
    OGRDataSourceShadow* ds = (OGRDataSourceShadow*)OGROpenShared(filename,update,NULL);
 
2081
  OGRDataSourceShadow* OpenShared( const char *utf8_path, int update =0 ) {
 
2082
    CPLErrorReset();
 
2083
    OGRDataSourceShadow* ds = (OGRDataSourceShadow*)OGROpenShared(utf8_path,update,NULL);
 
2084
    if( CPLGetLastErrorType() == CE_Failure && ds != NULL )
 
2085
    {
 
2086
        OGRReleaseDataSource(ds);
 
2087
        ds = NULL;
 
2088
    }
 
2089
        
1528
2090
    return ds;
1529
2091
  }
1530
2092
 
1537
2099
  return (OGRDriverShadow*) OGRGetDriver(driver_number);
1538
2100
}
1539
2101
 
1540
 
/* class entry subsection */
1541
 
/* Function entries for Driver */
1542
 
static zend_function_entry Driver_functions[] = {
1543
 
 ZEND_NAMED_FE(driver_createdatasource,_wrap_Driver_CreateDataSource, NULL)
1544
 
 ZEND_NAMED_FE(createdatasource,_wrap_Driver_CreateDataSource, NULL)
1545
 
 ZEND_NAMED_FE(driver_copydatasource,_wrap_Driver_CopyDataSource, NULL)
1546
 
 ZEND_NAMED_FE(copydatasource,_wrap_Driver_CopyDataSource, NULL)
1547
 
 ZEND_NAMED_FE(driver_open,_wrap_Driver_Open, NULL)
1548
 
 ZEND_NAMED_FE(open,_wrap_Driver_Open, NULL)
1549
 
 ZEND_NAMED_FE(driver_deletedatasource,_wrap_Driver_DeleteDataSource, NULL)
1550
 
 ZEND_NAMED_FE(deletedatasource,_wrap_Driver_DeleteDataSource, NULL)
1551
 
 ZEND_NAMED_FE(driver_testcapability,_wrap_Driver_TestCapability, NULL)
1552
 
 ZEND_NAMED_FE(testcapability,_wrap_Driver_TestCapability, NULL)
1553
 
 ZEND_NAMED_FE(driver_getname,_wrap_Driver_GetName, NULL)
1554
 
 ZEND_NAMED_FE(getname,_wrap_Driver_GetName, NULL)
1555
 
   { NULL, NULL, NULL}
1556
 
};
1557
 
/* Function entries for DataSource */
1558
 
static zend_function_entry DataSource_functions[] = {
1559
 
 ZEND_NAMED_FE(datasource_getrefcount,_wrap_DataSource_GetRefCount, NULL)
1560
 
 ZEND_NAMED_FE(getrefcount,_wrap_DataSource_GetRefCount, NULL)
1561
 
 ZEND_NAMED_FE(datasource_getsummaryrefcount,_wrap_DataSource_GetSummaryRefCount, NULL)
1562
 
 ZEND_NAMED_FE(getsummaryrefcount,_wrap_DataSource_GetSummaryRefCount, NULL)
1563
 
 ZEND_NAMED_FE(datasource_getlayercount,_wrap_DataSource_GetLayerCount, NULL)
1564
 
 ZEND_NAMED_FE(getlayercount,_wrap_DataSource_GetLayerCount, NULL)
1565
 
 ZEND_NAMED_FE(datasource_getname,_wrap_DataSource_GetName, NULL)
1566
 
 ZEND_NAMED_FE(getname,_wrap_DataSource_GetName, NULL)
1567
 
 ZEND_NAMED_FE(datasource_deletelayer,_wrap_DataSource_DeleteLayer, NULL)
1568
 
 ZEND_NAMED_FE(deletelayer,_wrap_DataSource_DeleteLayer, NULL)
1569
 
 ZEND_NAMED_FE(datasource_createlayer,_wrap_DataSource_CreateLayer, NULL)
1570
 
 ZEND_NAMED_FE(createlayer,_wrap_DataSource_CreateLayer, NULL)
1571
 
 ZEND_NAMED_FE(datasource_copylayer,_wrap_DataSource_CopyLayer, NULL)
1572
 
 ZEND_NAMED_FE(copylayer,_wrap_DataSource_CopyLayer, NULL)
1573
 
 ZEND_NAMED_FE(datasource_getlayerbyindex,_wrap_DataSource_GetLayerByIndex, NULL)
1574
 
 ZEND_NAMED_FE(getlayerbyindex,_wrap_DataSource_GetLayerByIndex, NULL)
1575
 
 ZEND_NAMED_FE(datasource_getlayerbyname,_wrap_DataSource_GetLayerByName, NULL)
1576
 
 ZEND_NAMED_FE(getlayerbyname,_wrap_DataSource_GetLayerByName, NULL)
1577
 
 ZEND_NAMED_FE(datasource_testcapability,_wrap_DataSource_TestCapability, NULL)
1578
 
 ZEND_NAMED_FE(testcapability,_wrap_DataSource_TestCapability, NULL)
1579
 
 ZEND_NAMED_FE(datasource_executesql,_wrap_DataSource_ExecuteSQL, NULL)
1580
 
 ZEND_NAMED_FE(executesql,_wrap_DataSource_ExecuteSQL, NULL)
1581
 
 ZEND_NAMED_FE(datasource_releaseresultset,_wrap_DataSource_ReleaseResultSet, NULL)
1582
 
 ZEND_NAMED_FE(releaseresultset,_wrap_DataSource_ReleaseResultSet, NULL)
1583
 
   { NULL, NULL, NULL}
1584
 
};
1585
 
/* Function entries for Layer */
1586
 
static zend_function_entry Layer_functions[] = {
1587
 
 ZEND_NAMED_FE(layer_getrefcount,_wrap_Layer_GetRefCount, NULL)
1588
 
 ZEND_NAMED_FE(getrefcount,_wrap_Layer_GetRefCount, NULL)
1589
 
 ZEND_NAMED_FE(layer_setspatialfilter,_wrap_Layer_SetSpatialFilter, NULL)
1590
 
 ZEND_NAMED_FE(setspatialfilter,_wrap_Layer_SetSpatialFilter, NULL)
1591
 
 ZEND_NAMED_FE(layer_setspatialfilterrect,_wrap_Layer_SetSpatialFilterRect, NULL)
1592
 
 ZEND_NAMED_FE(setspatialfilterrect,_wrap_Layer_SetSpatialFilterRect, NULL)
1593
 
 ZEND_NAMED_FE(layer_getspatialfilter,_wrap_Layer_GetSpatialFilter, NULL)
1594
 
 ZEND_NAMED_FE(getspatialfilter,_wrap_Layer_GetSpatialFilter, NULL)
1595
 
 ZEND_NAMED_FE(layer_setattributefilter,_wrap_Layer_SetAttributeFilter, NULL)
1596
 
 ZEND_NAMED_FE(setattributefilter,_wrap_Layer_SetAttributeFilter, NULL)
1597
 
 ZEND_NAMED_FE(layer_resetreading,_wrap_Layer_ResetReading, NULL)
1598
 
 ZEND_NAMED_FE(resetreading,_wrap_Layer_ResetReading, NULL)
1599
 
 ZEND_NAMED_FE(layer_getname,_wrap_Layer_GetName, NULL)
1600
 
 ZEND_NAMED_FE(getname,_wrap_Layer_GetName, NULL)
1601
 
 ZEND_NAMED_FE(layer_getfeature,_wrap_Layer_GetFeature, NULL)
1602
 
 ZEND_NAMED_FE(getfeature,_wrap_Layer_GetFeature, NULL)
1603
 
 ZEND_NAMED_FE(layer_getnextfeature,_wrap_Layer_GetNextFeature, NULL)
1604
 
 ZEND_NAMED_FE(getnextfeature,_wrap_Layer_GetNextFeature, NULL)
1605
 
 ZEND_NAMED_FE(layer_setnextbyindex,_wrap_Layer_SetNextByIndex, NULL)
1606
 
 ZEND_NAMED_FE(setnextbyindex,_wrap_Layer_SetNextByIndex, NULL)
1607
 
 ZEND_NAMED_FE(layer_setfeature,_wrap_Layer_SetFeature, NULL)
1608
 
 ZEND_NAMED_FE(setfeature,_wrap_Layer_SetFeature, NULL)
1609
 
 ZEND_NAMED_FE(layer_createfeature,_wrap_Layer_CreateFeature, NULL)
1610
 
 ZEND_NAMED_FE(createfeature,_wrap_Layer_CreateFeature, NULL)
1611
 
 ZEND_NAMED_FE(layer_deletefeature,_wrap_Layer_DeleteFeature, NULL)
1612
 
 ZEND_NAMED_FE(deletefeature,_wrap_Layer_DeleteFeature, NULL)
1613
 
 ZEND_NAMED_FE(layer_synctodisk,_wrap_Layer_SyncToDisk, NULL)
1614
 
 ZEND_NAMED_FE(synctodisk,_wrap_Layer_SyncToDisk, NULL)
1615
 
 ZEND_NAMED_FE(layer_getlayerdefn,_wrap_Layer_GetLayerDefn, NULL)
1616
 
 ZEND_NAMED_FE(getlayerdefn,_wrap_Layer_GetLayerDefn, NULL)
1617
 
 ZEND_NAMED_FE(layer_getfeaturecount,_wrap_Layer_GetFeatureCount, NULL)
1618
 
 ZEND_NAMED_FE(getfeaturecount,_wrap_Layer_GetFeatureCount, NULL)
1619
 
 ZEND_NAMED_FE(layer_getextent,_wrap_Layer_GetExtent, NULL)
1620
 
 ZEND_NAMED_FE(getextent,_wrap_Layer_GetExtent, NULL)
1621
 
 ZEND_NAMED_FE(layer_testcapability,_wrap_Layer_TestCapability, NULL)
1622
 
 ZEND_NAMED_FE(testcapability,_wrap_Layer_TestCapability, NULL)
1623
 
 ZEND_NAMED_FE(layer_createfield,_wrap_Layer_CreateField, NULL)
1624
 
 ZEND_NAMED_FE(createfield,_wrap_Layer_CreateField, NULL)
1625
 
 ZEND_NAMED_FE(layer_starttransaction,_wrap_Layer_StartTransaction, NULL)
1626
 
 ZEND_NAMED_FE(starttransaction,_wrap_Layer_StartTransaction, NULL)
1627
 
 ZEND_NAMED_FE(layer_committransaction,_wrap_Layer_CommitTransaction, NULL)
1628
 
 ZEND_NAMED_FE(committransaction,_wrap_Layer_CommitTransaction, NULL)
1629
 
 ZEND_NAMED_FE(layer_rollbacktransaction,_wrap_Layer_RollbackTransaction, NULL)
1630
 
 ZEND_NAMED_FE(rollbacktransaction,_wrap_Layer_RollbackTransaction, NULL)
1631
 
 ZEND_NAMED_FE(layer_getspatialref,_wrap_Layer_GetSpatialRef, NULL)
1632
 
 ZEND_NAMED_FE(getspatialref,_wrap_Layer_GetSpatialRef, NULL)
1633
 
 ZEND_NAMED_FE(layer_getfeatureread,_wrap_Layer_GetFeatureRead, NULL)
1634
 
 ZEND_NAMED_FE(getfeatureread,_wrap_Layer_GetFeatureRead, NULL)
1635
 
   { NULL, NULL, NULL}
1636
 
};
1637
 
/* Function entries for Feature */
1638
 
static zend_function_entry Feature_functions[] = {
1639
 
 ZEND_NAMED_FE(new_feature,_wrap_new_Feature, NULL)
1640
 
 ZEND_NAMED_FE(feature,_wrap_new_Feature, NULL)
1641
 
 ZEND_NAMED_FE(feature_getdefnref,_wrap_Feature_GetDefnRef, NULL)
1642
 
 ZEND_NAMED_FE(getdefnref,_wrap_Feature_GetDefnRef, NULL)
1643
 
 ZEND_NAMED_FE(feature_setgeometry,_wrap_Feature_SetGeometry, NULL)
1644
 
 ZEND_NAMED_FE(setgeometry,_wrap_Feature_SetGeometry, NULL)
1645
 
 ZEND_NAMED_FE(feature_setgeometrydirectly,_wrap_Feature_SetGeometryDirectly, NULL)
1646
 
 ZEND_NAMED_FE(setgeometrydirectly,_wrap_Feature_SetGeometryDirectly, NULL)
1647
 
 ZEND_NAMED_FE(feature_getgeometryref,_wrap_Feature_GetGeometryRef, NULL)
1648
 
 ZEND_NAMED_FE(getgeometryref,_wrap_Feature_GetGeometryRef, NULL)
1649
 
 ZEND_NAMED_FE(feature_clone,_wrap_Feature_Clone, NULL)
1650
 
 ZEND_NAMED_FE(clone,_wrap_Feature_Clone, NULL)
1651
 
 ZEND_NAMED_FE(feature_equal,_wrap_Feature_Equal, NULL)
1652
 
 ZEND_NAMED_FE(equal,_wrap_Feature_Equal, NULL)
1653
 
 ZEND_NAMED_FE(feature_getfieldcount,_wrap_Feature_GetFieldCount, NULL)
1654
 
 ZEND_NAMED_FE(getfieldcount,_wrap_Feature_GetFieldCount, NULL)
1655
 
 ZEND_NAMED_FE(getfielddefnref,_wrap_Feature_GetFieldDefnRef, NULL)
1656
 
 ZEND_NAMED_FE(feature_getfielddefnref,_wrap_Feature_GetFieldDefnRef, NULL)
1657
 
 ZEND_NAMED_FE(getfielddefnref,_wrap_Feature_GetFieldDefnRef, NULL)
1658
 
 ZEND_NAMED_FE(getfieldasstring,_wrap_Feature_GetFieldAsString, NULL)
1659
 
 ZEND_NAMED_FE(feature_getfieldasstring,_wrap_Feature_GetFieldAsString, NULL)
1660
 
 ZEND_NAMED_FE(getfieldasstring,_wrap_Feature_GetFieldAsString, NULL)
1661
 
 ZEND_NAMED_FE(getfieldasinteger,_wrap_Feature_GetFieldAsInteger, NULL)
1662
 
 ZEND_NAMED_FE(feature_getfieldasinteger,_wrap_Feature_GetFieldAsInteger, NULL)
1663
 
 ZEND_NAMED_FE(getfieldasinteger,_wrap_Feature_GetFieldAsInteger, NULL)
1664
 
 ZEND_NAMED_FE(getfieldasdouble,_wrap_Feature_GetFieldAsDouble, NULL)
1665
 
 ZEND_NAMED_FE(feature_getfieldasdouble,_wrap_Feature_GetFieldAsDouble, NULL)
1666
 
 ZEND_NAMED_FE(getfieldasdouble,_wrap_Feature_GetFieldAsDouble, NULL)
1667
 
 ZEND_NAMED_FE(isfieldset,_wrap_Feature_IsFieldSet, NULL)
1668
 
 ZEND_NAMED_FE(feature_isfieldset,_wrap_Feature_IsFieldSet, NULL)
1669
 
 ZEND_NAMED_FE(isfieldset,_wrap_Feature_IsFieldSet, NULL)
1670
 
 ZEND_NAMED_FE(feature_getfieldindex,_wrap_Feature_GetFieldIndex, NULL)
1671
 
 ZEND_NAMED_FE(getfieldindex,_wrap_Feature_GetFieldIndex, NULL)
1672
 
 ZEND_NAMED_FE(feature_getfid,_wrap_Feature_GetFID, NULL)
1673
 
 ZEND_NAMED_FE(getfid,_wrap_Feature_GetFID, NULL)
1674
 
 ZEND_NAMED_FE(feature_setfid,_wrap_Feature_SetFID, NULL)
1675
 
 ZEND_NAMED_FE(setfid,_wrap_Feature_SetFID, NULL)
1676
 
 ZEND_NAMED_FE(feature_dumpreadable,_wrap_Feature_DumpReadable, NULL)
1677
 
 ZEND_NAMED_FE(dumpreadable,_wrap_Feature_DumpReadable, NULL)
1678
 
 ZEND_NAMED_FE(unsetfield,_wrap_Feature_UnsetField, NULL)
1679
 
 ZEND_NAMED_FE(feature_unsetfield,_wrap_Feature_UnsetField, NULL)
1680
 
 ZEND_NAMED_FE(unsetfield,_wrap_Feature_UnsetField, NULL)
1681
 
 ZEND_NAMED_FE(setfield,_wrap_Feature_SetField, NULL)
1682
 
 ZEND_NAMED_FE(feature_setfield,_wrap_Feature_SetField, NULL)
1683
 
 ZEND_NAMED_FE(setfield,_wrap_Feature_SetField, NULL)
1684
 
 ZEND_NAMED_FE(feature_setfrom,_wrap_Feature_SetFrom, NULL)
1685
 
 ZEND_NAMED_FE(setfrom,_wrap_Feature_SetFrom, NULL)
1686
 
 ZEND_NAMED_FE(feature_getstylestring,_wrap_Feature_GetStyleString, NULL)
1687
 
 ZEND_NAMED_FE(getstylestring,_wrap_Feature_GetStyleString, NULL)
1688
 
 ZEND_NAMED_FE(feature_setstylestring,_wrap_Feature_SetStyleString, NULL)
1689
 
 ZEND_NAMED_FE(setstylestring,_wrap_Feature_SetStyleString, NULL)
1690
 
 ZEND_NAMED_FE(getfieldtype,_wrap_Feature_GetFieldType, NULL)
1691
 
 ZEND_NAMED_FE(feature_getfieldtype,_wrap_Feature_GetFieldType, NULL)
1692
 
 ZEND_NAMED_FE(getfieldtype,_wrap_Feature_GetFieldType, NULL)
1693
 
   { NULL, NULL, NULL}
1694
 
};
1695
 
/* Function entries for FeatureDefn */
1696
 
static zend_function_entry FeatureDefn_functions[] = {
1697
 
 ZEND_NAMED_FE(new_featuredefn,_wrap_new_FeatureDefn, NULL)
1698
 
 ZEND_NAMED_FE(featuredefn,_wrap_new_FeatureDefn, NULL)
1699
 
 ZEND_NAMED_FE(featuredefn_getname,_wrap_FeatureDefn_GetName, NULL)
1700
 
 ZEND_NAMED_FE(getname,_wrap_FeatureDefn_GetName, NULL)
1701
 
 ZEND_NAMED_FE(featuredefn_getfieldcount,_wrap_FeatureDefn_GetFieldCount, NULL)
1702
 
 ZEND_NAMED_FE(getfieldcount,_wrap_FeatureDefn_GetFieldCount, NULL)
1703
 
 ZEND_NAMED_FE(featuredefn_getfielddefn,_wrap_FeatureDefn_GetFieldDefn, NULL)
1704
 
 ZEND_NAMED_FE(getfielddefn,_wrap_FeatureDefn_GetFieldDefn, NULL)
1705
 
 ZEND_NAMED_FE(featuredefn_getfieldindex,_wrap_FeatureDefn_GetFieldIndex, NULL)
1706
 
 ZEND_NAMED_FE(getfieldindex,_wrap_FeatureDefn_GetFieldIndex, NULL)
1707
 
 ZEND_NAMED_FE(featuredefn_addfielddefn,_wrap_FeatureDefn_AddFieldDefn, NULL)
1708
 
 ZEND_NAMED_FE(addfielddefn,_wrap_FeatureDefn_AddFieldDefn, NULL)
1709
 
 ZEND_NAMED_FE(featuredefn_getgeomtype,_wrap_FeatureDefn_GetGeomType, NULL)
1710
 
 ZEND_NAMED_FE(getgeomtype,_wrap_FeatureDefn_GetGeomType, NULL)
1711
 
 ZEND_NAMED_FE(featuredefn_setgeomtype,_wrap_FeatureDefn_SetGeomType, NULL)
1712
 
 ZEND_NAMED_FE(setgeomtype,_wrap_FeatureDefn_SetGeomType, NULL)
1713
 
 ZEND_NAMED_FE(featuredefn_getreferencecount,_wrap_FeatureDefn_GetReferenceCount, NULL)
1714
 
 ZEND_NAMED_FE(getreferencecount,_wrap_FeatureDefn_GetReferenceCount, NULL)
1715
 
   { NULL, NULL, NULL}
1716
 
};
1717
 
/* Function entries for FieldDefn */
1718
 
static zend_function_entry FieldDefn_functions[] = {
1719
 
 ZEND_NAMED_FE(new_fielddefn,_wrap_new_FieldDefn, NULL)
1720
 
 ZEND_NAMED_FE(fielddefn,_wrap_new_FieldDefn, NULL)
1721
 
 ZEND_NAMED_FE(fielddefn_getname,_wrap_FieldDefn_GetName, NULL)
1722
 
 ZEND_NAMED_FE(getname,_wrap_FieldDefn_GetName, NULL)
1723
 
 ZEND_NAMED_FE(fielddefn_getnameref,_wrap_FieldDefn_GetNameRef, NULL)
1724
 
 ZEND_NAMED_FE(getnameref,_wrap_FieldDefn_GetNameRef, NULL)
1725
 
 ZEND_NAMED_FE(fielddefn_setname,_wrap_FieldDefn_SetName, NULL)
1726
 
 ZEND_NAMED_FE(setname,_wrap_FieldDefn_SetName, NULL)
1727
 
 ZEND_NAMED_FE(fielddefn_gettype,_wrap_FieldDefn_GetType, NULL)
1728
 
 ZEND_NAMED_FE(gettype,_wrap_FieldDefn_GetType, NULL)
1729
 
 ZEND_NAMED_FE(fielddefn_settype,_wrap_FieldDefn_SetType, NULL)
1730
 
 ZEND_NAMED_FE(settype,_wrap_FieldDefn_SetType, NULL)
1731
 
 ZEND_NAMED_FE(fielddefn_getjustify,_wrap_FieldDefn_GetJustify, NULL)
1732
 
 ZEND_NAMED_FE(getjustify,_wrap_FieldDefn_GetJustify, NULL)
1733
 
 ZEND_NAMED_FE(fielddefn_setjustify,_wrap_FieldDefn_SetJustify, NULL)
1734
 
 ZEND_NAMED_FE(setjustify,_wrap_FieldDefn_SetJustify, NULL)
1735
 
 ZEND_NAMED_FE(fielddefn_getwidth,_wrap_FieldDefn_GetWidth, NULL)
1736
 
 ZEND_NAMED_FE(getwidth,_wrap_FieldDefn_GetWidth, NULL)
1737
 
 ZEND_NAMED_FE(fielddefn_setwidth,_wrap_FieldDefn_SetWidth, NULL)
1738
 
 ZEND_NAMED_FE(setwidth,_wrap_FieldDefn_SetWidth, NULL)
1739
 
 ZEND_NAMED_FE(fielddefn_getprecision,_wrap_FieldDefn_GetPrecision, NULL)
1740
 
 ZEND_NAMED_FE(getprecision,_wrap_FieldDefn_GetPrecision, NULL)
1741
 
 ZEND_NAMED_FE(fielddefn_setprecision,_wrap_FieldDefn_SetPrecision, NULL)
1742
 
 ZEND_NAMED_FE(setprecision,_wrap_FieldDefn_SetPrecision, NULL)
1743
 
 ZEND_NAMED_FE(fielddefn_getfieldtypename,_wrap_FieldDefn_GetFieldTypeName, NULL)
1744
 
 ZEND_NAMED_FE(getfieldtypename,_wrap_FieldDefn_GetFieldTypeName, NULL)
1745
 
   { NULL, NULL, NULL}
1746
 
};
1747
 
/* Function entries for Geometry */
1748
 
static zend_function_entry Geometry_functions[] = {
1749
 
 ZEND_NAMED_FE(new_geometry,_wrap_new_Geometry, NULL)
1750
 
 ZEND_NAMED_FE(geometry,_wrap_new_Geometry, NULL)
1751
 
 ZEND_NAMED_FE(geometry_exporttowkt,_wrap_Geometry_ExportToWkt, NULL)
1752
 
 ZEND_NAMED_FE(exporttowkt,_wrap_Geometry_ExportToWkt, NULL)
1753
 
 ZEND_NAMED_FE(geometry_exporttowkb,_wrap_Geometry_ExportToWkb, NULL)
1754
 
 ZEND_NAMED_FE(exporttowkb,_wrap_Geometry_ExportToWkb, NULL)
1755
 
 ZEND_NAMED_FE(geometry_exporttogml,_wrap_Geometry_ExportToGML, NULL)
1756
 
 ZEND_NAMED_FE(exporttogml,_wrap_Geometry_ExportToGML, NULL)
1757
 
 ZEND_NAMED_FE(geometry_addpoint,_wrap_Geometry_AddPoint, NULL)
1758
 
 ZEND_NAMED_FE(addpoint,_wrap_Geometry_AddPoint, NULL)
1759
 
 ZEND_NAMED_FE(geometry_addgeometrydirectly,_wrap_Geometry_AddGeometryDirectly, NULL)
1760
 
 ZEND_NAMED_FE(addgeometrydirectly,_wrap_Geometry_AddGeometryDirectly, NULL)
1761
 
 ZEND_NAMED_FE(geometry_addgeometry,_wrap_Geometry_AddGeometry, NULL)
1762
 
 ZEND_NAMED_FE(addgeometry,_wrap_Geometry_AddGeometry, NULL)
1763
 
 ZEND_NAMED_FE(geometry_clone,_wrap_Geometry_Clone, NULL)
1764
 
 ZEND_NAMED_FE(clone,_wrap_Geometry_Clone, NULL)
1765
 
 ZEND_NAMED_FE(geometry_getgeometrytype,_wrap_Geometry_GetGeometryType, NULL)
1766
 
 ZEND_NAMED_FE(getgeometrytype,_wrap_Geometry_GetGeometryType, NULL)
1767
 
 ZEND_NAMED_FE(geometry_getgeometryname,_wrap_Geometry_GetGeometryName, NULL)
1768
 
 ZEND_NAMED_FE(getgeometryname,_wrap_Geometry_GetGeometryName, NULL)
1769
 
 ZEND_NAMED_FE(geometry_getarea,_wrap_Geometry_GetArea, NULL)
1770
 
 ZEND_NAMED_FE(getarea,_wrap_Geometry_GetArea, NULL)
1771
 
 ZEND_NAMED_FE(geometry_getpointcount,_wrap_Geometry_GetPointCount, NULL)
1772
 
 ZEND_NAMED_FE(getpointcount,_wrap_Geometry_GetPointCount, NULL)
1773
 
 ZEND_NAMED_FE(geometry_getx,_wrap_Geometry_GetX, NULL)
1774
 
 ZEND_NAMED_FE(getx,_wrap_Geometry_GetX, NULL)
1775
 
 ZEND_NAMED_FE(geometry_gety,_wrap_Geometry_GetY, NULL)
1776
 
 ZEND_NAMED_FE(gety,_wrap_Geometry_GetY, NULL)
1777
 
 ZEND_NAMED_FE(geometry_getz,_wrap_Geometry_GetZ, NULL)
1778
 
 ZEND_NAMED_FE(getz,_wrap_Geometry_GetZ, NULL)
1779
 
 ZEND_NAMED_FE(geometry_getgeometrycount,_wrap_Geometry_GetGeometryCount, NULL)
1780
 
 ZEND_NAMED_FE(getgeometrycount,_wrap_Geometry_GetGeometryCount, NULL)
1781
 
 ZEND_NAMED_FE(geometry_setpoint,_wrap_Geometry_SetPoint, NULL)
1782
 
 ZEND_NAMED_FE(setpoint,_wrap_Geometry_SetPoint, NULL)
1783
 
 ZEND_NAMED_FE(geometry_getgeometryref,_wrap_Geometry_GetGeometryRef, NULL)
1784
 
 ZEND_NAMED_FE(getgeometryref,_wrap_Geometry_GetGeometryRef, NULL)
1785
 
 ZEND_NAMED_FE(geometry_getboundary,_wrap_Geometry_GetBoundary, NULL)
1786
 
 ZEND_NAMED_FE(getboundary,_wrap_Geometry_GetBoundary, NULL)
1787
 
 ZEND_NAMED_FE(geometry_convexhull,_wrap_Geometry_ConvexHull, NULL)
1788
 
 ZEND_NAMED_FE(convexhull,_wrap_Geometry_ConvexHull, NULL)
1789
 
 ZEND_NAMED_FE(geometry_buffer,_wrap_Geometry_Buffer, NULL)
1790
 
 ZEND_NAMED_FE(buffer,_wrap_Geometry_Buffer, NULL)
1791
 
 ZEND_NAMED_FE(geometry_intersection,_wrap_Geometry_Intersection, NULL)
1792
 
 ZEND_NAMED_FE(intersection,_wrap_Geometry_Intersection, NULL)
1793
 
 ZEND_NAMED_FE(geometry_union,_wrap_Geometry_Union, NULL)
1794
 
 ZEND_NAMED_FE(union,_wrap_Geometry_Union, NULL)
1795
 
 ZEND_NAMED_FE(geometry_difference,_wrap_Geometry_Difference, NULL)
1796
 
 ZEND_NAMED_FE(difference,_wrap_Geometry_Difference, NULL)
1797
 
 ZEND_NAMED_FE(geometry_symmetricdifference,_wrap_Geometry_SymmetricDifference, NULL)
1798
 
 ZEND_NAMED_FE(symmetricdifference,_wrap_Geometry_SymmetricDifference, NULL)
1799
 
 ZEND_NAMED_FE(geometry_distance,_wrap_Geometry_Distance, NULL)
1800
 
 ZEND_NAMED_FE(distance,_wrap_Geometry_Distance, NULL)
1801
 
 ZEND_NAMED_FE(geometry_empty,_wrap_Geometry_Empty, NULL)
1802
 
 ZEND_NAMED_FE(empty,_wrap_Geometry_Empty, NULL)
1803
 
 ZEND_NAMED_FE(geometry_intersect,_wrap_Geometry_Intersect, NULL)
1804
 
 ZEND_NAMED_FE(intersect,_wrap_Geometry_Intersect, NULL)
1805
 
 ZEND_NAMED_FE(geometry_equal,_wrap_Geometry_Equal, NULL)
1806
 
 ZEND_NAMED_FE(equal,_wrap_Geometry_Equal, NULL)
1807
 
 ZEND_NAMED_FE(geometry_disjoint,_wrap_Geometry_Disjoint, NULL)
1808
 
 ZEND_NAMED_FE(disjoint,_wrap_Geometry_Disjoint, NULL)
1809
 
 ZEND_NAMED_FE(geometry_touches,_wrap_Geometry_Touches, NULL)
1810
 
 ZEND_NAMED_FE(touches,_wrap_Geometry_Touches, NULL)
1811
 
 ZEND_NAMED_FE(geometry_crosses,_wrap_Geometry_Crosses, NULL)
1812
 
 ZEND_NAMED_FE(crosses,_wrap_Geometry_Crosses, NULL)
1813
 
 ZEND_NAMED_FE(geometry_within,_wrap_Geometry_Within, NULL)
1814
 
 ZEND_NAMED_FE(within,_wrap_Geometry_Within, NULL)
1815
 
 ZEND_NAMED_FE(geometry_contains,_wrap_Geometry_Contains, NULL)
1816
 
 ZEND_NAMED_FE(contains,_wrap_Geometry_Contains, NULL)
1817
 
 ZEND_NAMED_FE(geometry_overlaps,_wrap_Geometry_Overlaps, NULL)
1818
 
 ZEND_NAMED_FE(overlaps,_wrap_Geometry_Overlaps, NULL)
1819
 
 ZEND_NAMED_FE(geometry_transformto,_wrap_Geometry_TransformTo, NULL)
1820
 
 ZEND_NAMED_FE(transformto,_wrap_Geometry_TransformTo, NULL)
1821
 
 ZEND_NAMED_FE(geometry_transform,_wrap_Geometry_Transform, NULL)
1822
 
 ZEND_NAMED_FE(transform,_wrap_Geometry_Transform, NULL)
1823
 
 ZEND_NAMED_FE(geometry_getspatialreference,_wrap_Geometry_GetSpatialReference, NULL)
1824
 
 ZEND_NAMED_FE(getspatialreference,_wrap_Geometry_GetSpatialReference, NULL)
1825
 
 ZEND_NAMED_FE(geometry_assignspatialreference,_wrap_Geometry_AssignSpatialReference, NULL)
1826
 
 ZEND_NAMED_FE(assignspatialreference,_wrap_Geometry_AssignSpatialReference, NULL)
1827
 
 ZEND_NAMED_FE(geometry_closerings,_wrap_Geometry_CloseRings, NULL)
1828
 
 ZEND_NAMED_FE(closerings,_wrap_Geometry_CloseRings, NULL)
1829
 
 ZEND_NAMED_FE(geometry_flattento2d,_wrap_Geometry_FlattenTo2D, NULL)
1830
 
 ZEND_NAMED_FE(flattento2d,_wrap_Geometry_FlattenTo2D, NULL)
1831
 
 ZEND_NAMED_FE(geometry_getenvelope,_wrap_Geometry_GetEnvelope, NULL)
1832
 
 ZEND_NAMED_FE(getenvelope,_wrap_Geometry_GetEnvelope, NULL)
1833
 
 ZEND_NAMED_FE(geometry_centroid,_wrap_Geometry_Centroid, NULL)
1834
 
 ZEND_NAMED_FE(centroid,_wrap_Geometry_Centroid, NULL)
1835
 
 ZEND_NAMED_FE(geometry_wkbsize,_wrap_Geometry_WkbSize, NULL)
1836
 
 ZEND_NAMED_FE(wkbsize,_wrap_Geometry_WkbSize, NULL)
1837
 
 ZEND_NAMED_FE(geometry_getcoordinatedimension,_wrap_Geometry_GetCoordinateDimension, NULL)
1838
 
 ZEND_NAMED_FE(getcoordinatedimension,_wrap_Geometry_GetCoordinateDimension, NULL)
1839
 
 ZEND_NAMED_FE(geometry_getdimension,_wrap_Geometry_GetDimension, NULL)
1840
 
 ZEND_NAMED_FE(getdimension,_wrap_Geometry_GetDimension, NULL)
1841
 
   { NULL, NULL, NULL}
1842
 
};
1843
 
 
1844
 
 
1845
 
/* entry subsection */
1846
 
/* Every non-class user visible function must have an entry here */
1847
 
function_entry ogr_functions[] = {
1848
 
  ZEND_NAMED_FE(creategeometryfromwkb,_wrap_CreateGeometryFromWkb, NULL)
1849
 
  ZEND_NAMED_FE(creategeometryfromwkt,_wrap_CreateGeometryFromWkt, NULL)
1850
 
  ZEND_NAMED_FE(creategeometryfromgml,_wrap_CreateGeometryFromGML, NULL)
1851
 
  ZEND_NAMED_FE(ogrgetdrivercount,_wrap_OGRGetDriverCount, NULL)
1852
 
  ZEND_NAMED_FE(ogrgetopendscount,_wrap_OGRGetOpenDSCount, NULL)
1853
 
  ZEND_NAMED_FE(ogrsetgenerate_db2_v72_byte_order,_wrap_OGRSetGenerate_DB2_V72_BYTE_ORDER, NULL)
1854
 
  ZEND_NAMED_FE(ogrregisterall,_wrap_OGRRegisterAll, NULL)
1855
 
  ZEND_NAMED_FE(getopends,_wrap_GetOpenDS, NULL)
1856
 
  ZEND_NAMED_FE(open,_wrap_Open, NULL)
1857
 
  ZEND_NAMED_FE(openshared,_wrap_OpenShared, NULL)
1858
 
  ZEND_NAMED_FE(getdriverbyname,_wrap_GetDriverByName, NULL)
1859
 
  ZEND_NAMED_FE(getdriver,_wrap_GetDriver, NULL)
1860
 
 {NULL, NULL, NULL}
1861
 
};
1862
 
 
1863
 
zend_module_entry ogr_module_entry = {
1864
 
#if ZEND_MODULE_API_NO > 20010900
1865
 
    STANDARD_MODULE_HEADER,
1866
 
#endif
1867
 
    "ogr",
1868
 
    ogr_functions,
1869
 
    PHP_MINIT(ogr),
1870
 
    PHP_MSHUTDOWN(ogr),
1871
 
    PHP_RINIT(ogr),
1872
 
    PHP_RSHUTDOWN(ogr),
1873
 
    PHP_MINFO(ogr),
1874
 
#if ZEND_MODULE_API_NO > 20010900
1875
 
    NO_VERSION_YET,
1876
 
#endif
1877
 
    STANDARD_MODULE_PROPERTIES
1878
 
};
1879
 
zend_module_entry* SWIG_module_entry = &ogr_module_entry;
 
2102
 
 
2103
  char **GeneralCmdLineProcessor( char **papszArgv, int nOptions = 0 ) {
 
2104
    int nResArgCount;
 
2105
 
 
2106
    nResArgCount = 
 
2107
      OGRGeneralCmdLineProcessor( CSLCount(papszArgv), &papszArgv, nOptions ); 
 
2108
 
 
2109
    if( nResArgCount <= 0 )
 
2110
        return NULL;
 
2111
    else
 
2112
        return papszArgv;
 
2113
  }
1880
2114
 
1881
2115
 
1882
2116
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
1883
2117
 
1884
 
static swig_type_info _swigt__int = {"_int", "int", 0, 0, 0};
1885
 
static swig_type_info _swigt__p_GIntBig = {"_p_GIntBig", "GIntBig *", 0, 0, 0};
1886
 
static swig_type_info _swigt__p_OGRDataSourceShadow = {"_p_OGRDataSourceShadow", "OGRDataSourceShadow *", 0, 0, 0};
1887
 
static swig_type_info _swigt__p_OGRDriverShadow = {"_p_OGRDriverShadow", "OGRDriverShadow *", 0, 0, 0};
1888
 
static swig_type_info _swigt__p_OGRFeatureDefnShadow = {"_p_OGRFeatureDefnShadow", "OGRFeatureDefnShadow *", 0, 0, 0};
1889
 
static swig_type_info _swigt__p_OGRFeatureShadow = {"_p_OGRFeatureShadow", "OGRFeatureShadow *", 0, 0, 0};
1890
 
static swig_type_info _swigt__p_OGRFieldDefnShadow = {"_p_OGRFieldDefnShadow", "OGRFieldDefnShadow *", 0, 0, 0};
1891
 
static swig_type_info _swigt__p_OGRGeometryShadow = {"_p_OGRGeometryShadow", "OGRGeometryShadow *", 0, 0, 0};
1892
 
static swig_type_info _swigt__p_OGRLayerShadow = {"_p_OGRLayerShadow", "OGRLayerShadow *", 0, 0, 0};
1893
 
static swig_type_info _swigt__p_OSRCoordinateTransformationShadow = {"_p_OSRCoordinateTransformationShadow", "OSRCoordinateTransformationShadow *", 0, 0, 0};
1894
 
static swig_type_info _swigt__p_OSRSpatialReferenceShadow = {"_p_OSRSpatialReferenceShadow", "OSRSpatialReferenceShadow *", 0, 0, 0};
1895
 
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, 0};
1896
 
static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, 0};
1897
 
static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, 0};
1898
 
static swig_type_info _swigt__p_p_OGRDataSourceShadow = {"_p_p_OGRDataSourceShadow", "OGRDataSourceShadow **", 0, 0, 0};
1899
 
static swig_type_info _swigt__p_p_OGRDriverShadow = {"_p_p_OGRDriverShadow", "OGRDriverShadow **", 0, 0, 0};
1900
 
static swig_type_info _swigt__p_p_OGRFeatureDefnShadow = {"_p_p_OGRFeatureDefnShadow", "OGRFeatureDefnShadow **", 0, 0, 0};
1901
 
static swig_type_info _swigt__p_p_OGRFeatureShadow = {"_p_p_OGRFeatureShadow", "OGRFeatureShadow **", 0, 0, 0};
1902
 
static swig_type_info _swigt__p_p_OGRFieldDefnShadow = {"_p_p_OGRFieldDefnShadow", "OGRFieldDefnShadow **", 0, 0, 0};
1903
 
static swig_type_info _swigt__p_p_OGRGeometryShadow = {"_p_p_OGRGeometryShadow", "OGRGeometryShadow **", 0, 0, 0};
1904
 
static swig_type_info _swigt__p_p_OGRLayerShadow = {"_p_p_OGRLayerShadow", "OGRLayerShadow **", 0, 0, 0};
1905
 
static swig_type_info _swigt__p_p_OSRCoordinateTransformationShadow = {"_p_p_OSRCoordinateTransformationShadow", "OSRCoordinateTransformationShadow **", 0, 0, 0};
1906
 
static swig_type_info _swigt__p_p_OSRSpatialReferenceShadow = {"_p_p_OSRSpatialReferenceShadow", "OSRSpatialReferenceShadow **", 0, 0, 0};
1907
 
static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, 0};
 
2118
static swig_type_info _swigt__int = {"_int", "int", 0, 0, (void*)0, 0};
 
2119
static swig_type_info _swigt__p_GIntBig = {"_p_GIntBig", "GIntBig *", 0, 0, (void*)0, 0};
 
2120
static swig_type_info _swigt__p_OGRDataSourceShadow = {"_p_OGRDataSourceShadow", "OGRDataSourceShadow *", 0, 0, (void*)0, 0};
 
2121
static swig_type_info _swigt__p_OGRDriverShadow = {"_p_OGRDriverShadow", "OGRDriverShadow *", 0, 0, (void*)0, 0};
 
2122
static swig_type_info _swigt__p_OGRFeatureDefnShadow = {"_p_OGRFeatureDefnShadow", "OGRFeatureDefnShadow *", 0, 0, (void*)0, 0};
 
2123
static swig_type_info _swigt__p_OGRFeatureShadow = {"_p_OGRFeatureShadow", "OGRFeatureShadow *", 0, 0, (void*)0, 0};
 
2124
static swig_type_info _swigt__p_OGRFieldDefnShadow = {"_p_OGRFieldDefnShadow", "OGRFieldDefnShadow *", 0, 0, (void*)0, 0};
 
2125
static swig_type_info _swigt__p_OGRGeometryShadow = {"_p_OGRGeometryShadow", "OGRGeometryShadow *", 0, 0, (void*)0, 0};
 
2126
static swig_type_info _swigt__p_OGRLayerShadow = {"_p_OGRLayerShadow", "OGRLayerShadow *", 0, 0, (void*)0, 0};
 
2127
static swig_type_info _swigt__p_OSRCoordinateTransformationShadow = {"_p_OSRCoordinateTransformationShadow", "OSRCoordinateTransformationShadow *", 0, 0, (void*)0, 0};
 
2128
static swig_type_info _swigt__p_OSRSpatialReferenceShadow = {"_p_OSRSpatialReferenceShadow", "OSRSpatialReferenceShadow *", 0, 0, (void*)0, 0};
 
2129
static swig_type_info _swigt__p_char = {"_p_char", "char *|retStringAndCPLFree *", 0, 0, (void*)0, 0};
 
2130
static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
 
2131
static swig_type_info _swigt__p_int = {"_p_int", "OGRFieldType *|int *|OGRwkbGeometryType *|OGRJustification *|OGRwkbByteOrder *|OGRErr *", 0, 0, (void*)0, 0};
 
2132
static swig_type_info _swigt__p_p_OGRGeometryShadow = {"_p_p_OGRGeometryShadow", "OGRGeometryShadow **", 0, 0, (void*)0, 0};
 
2133
static swig_type_info _swigt__p_p_OGRLayerShadow = {"_p_p_OGRLayerShadow", "OGRLayerShadow **", 0, 0, (void*)0, 0};
 
2134
static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
 
2135
static swig_type_info _swigt__p_p_double = {"_p_p_double", "double **", 0, 0, (void*)0, 0};
 
2136
static swig_type_info _swigt__p_p_int = {"_p_p_int", "int **", 0, 0, (void*)0, 0};
 
2137
static swig_type_info _swigt__p_p_p_char = {"_p_p_p_char", "char ***", 0, 0, (void*)0, 0};
1908
2138
 
1909
2139
static swig_type_info *swig_type_initial[] = {
1910
2140
  &_swigt__int,
1921
2151
  &_swigt__p_char,
1922
2152
  &_swigt__p_double,
1923
2153
  &_swigt__p_int,
1924
 
  &_swigt__p_p_OGRDataSourceShadow,
1925
 
  &_swigt__p_p_OGRDriverShadow,
1926
 
  &_swigt__p_p_OGRFeatureDefnShadow,
1927
 
  &_swigt__p_p_OGRFeatureShadow,
1928
 
  &_swigt__p_p_OGRFieldDefnShadow,
1929
2154
  &_swigt__p_p_OGRGeometryShadow,
1930
2155
  &_swigt__p_p_OGRLayerShadow,
1931
 
  &_swigt__p_p_OSRCoordinateTransformationShadow,
1932
 
  &_swigt__p_p_OSRSpatialReferenceShadow,
1933
2156
  &_swigt__p_p_char,
 
2157
  &_swigt__p_p_double,
 
2158
  &_swigt__p_p_int,
 
2159
  &_swigt__p_p_p_char,
1934
2160
};
1935
2161
 
1936
2162
static swig_cast_info _swigc__int[] = {  {&_swigt__int, 0, 0, 0},{0, 0, 0, 0}};
1947
2173
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
1948
2174
static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
1949
2175
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
1950
 
static swig_cast_info _swigc__p_p_OGRDataSourceShadow[] = {  {&_swigt__p_p_OGRDataSourceShadow, 0, 0, 0},{0, 0, 0, 0}};
1951
 
static swig_cast_info _swigc__p_p_OGRDriverShadow[] = {  {&_swigt__p_p_OGRDriverShadow, 0, 0, 0},{0, 0, 0, 0}};
1952
 
static swig_cast_info _swigc__p_p_OGRFeatureDefnShadow[] = {  {&_swigt__p_p_OGRFeatureDefnShadow, 0, 0, 0},{0, 0, 0, 0}};
1953
 
static swig_cast_info _swigc__p_p_OGRFeatureShadow[] = {  {&_swigt__p_p_OGRFeatureShadow, 0, 0, 0},{0, 0, 0, 0}};
1954
 
static swig_cast_info _swigc__p_p_OGRFieldDefnShadow[] = {  {&_swigt__p_p_OGRFieldDefnShadow, 0, 0, 0},{0, 0, 0, 0}};
1955
2176
static swig_cast_info _swigc__p_p_OGRGeometryShadow[] = {  {&_swigt__p_p_OGRGeometryShadow, 0, 0, 0},{0, 0, 0, 0}};
1956
2177
static swig_cast_info _swigc__p_p_OGRLayerShadow[] = {  {&_swigt__p_p_OGRLayerShadow, 0, 0, 0},{0, 0, 0, 0}};
1957
 
static swig_cast_info _swigc__p_p_OSRCoordinateTransformationShadow[] = {  {&_swigt__p_p_OSRCoordinateTransformationShadow, 0, 0, 0},{0, 0, 0, 0}};
1958
 
static swig_cast_info _swigc__p_p_OSRSpatialReferenceShadow[] = {  {&_swigt__p_p_OSRSpatialReferenceShadow, 0, 0, 0},{0, 0, 0, 0}};
1959
2178
static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
 
2179
static swig_cast_info _swigc__p_p_double[] = {  {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
 
2180
static swig_cast_info _swigc__p_p_int[] = {  {&_swigt__p_p_int, 0, 0, 0},{0, 0, 0, 0}};
 
2181
static swig_cast_info _swigc__p_p_p_char[] = {  {&_swigt__p_p_p_char, 0, 0, 0},{0, 0, 0, 0}};
1960
2182
 
1961
2183
static swig_cast_info *swig_cast_initial[] = {
1962
2184
  _swigc__int,
1973
2195
  _swigc__p_char,
1974
2196
  _swigc__p_double,
1975
2197
  _swigc__p_int,
1976
 
  _swigc__p_p_OGRDataSourceShadow,
1977
 
  _swigc__p_p_OGRDriverShadow,
1978
 
  _swigc__p_p_OGRFeatureDefnShadow,
1979
 
  _swigc__p_p_OGRFeatureShadow,
1980
 
  _swigc__p_p_OGRFieldDefnShadow,
1981
2198
  _swigc__p_p_OGRGeometryShadow,
1982
2199
  _swigc__p_p_OGRLayerShadow,
1983
 
  _swigc__p_p_OSRCoordinateTransformationShadow,
1984
 
  _swigc__p_p_OSRSpatialReferenceShadow,
1985
2200
  _swigc__p_p_char,
 
2201
  _swigc__p_p_double,
 
2202
  _swigc__p_p_int,
 
2203
  _swigc__p_p_p_char,
1986
2204
};
1987
2205
 
1988
2206
 
1990
2208
 
1991
2209
/* end header section */
1992
2210
/* vdecl subsection */
1993
 
static zend_class_entry ce_swig_Driver;
1994
 
static zend_class_entry* ptr_ce_swig_Driver=NULL;
1995
 
static zend_class_entry ce_swig_DataSource;
1996
 
static zend_class_entry* ptr_ce_swig_DataSource=NULL;
1997
 
static zend_class_entry ce_swig_Layer;
1998
 
static zend_class_entry* ptr_ce_swig_Layer=NULL;
1999
 
static zend_class_entry ce_swig_Feature;
2000
 
static zend_class_entry* ptr_ce_swig_Feature=NULL;
2001
 
static zend_class_entry ce_swig_FeatureDefn;
2002
 
static zend_class_entry* ptr_ce_swig_FeatureDefn=NULL;
2003
 
static zend_class_entry ce_swig_FieldDefn;
2004
 
static zend_class_entry* ptr_ce_swig_FieldDefn=NULL;
2005
 
static zend_class_entry ce_swig_Geometry;
2006
 
static zend_class_entry* ptr_ce_swig_Geometry=NULL;
2007
 
static int le_swig__p_GIntBig=0; /* handle for  */
2008
 
static int le_swig__p_double=0; /* handle for  */
2009
 
static int le_swig__p_p_char=0; /* handle for  */
2010
 
static int le_swig__p_char=0; /* handle for  */
2011
 
static int le_swig__p_p_OGRGeometryShadow=0; /* handle for  */
 
2211
static int le_swig__p_GIntBig=0; /* handle for _p_GIntBig */
 
2212
static int le_swig__p_double=0; /* handle for _p_double */
 
2213
static int le_swig__p_p_double=0; /* handle for _p_p_double */
 
2214
static int le_swig__p_p_char=0; /* handle for _p_p_char */
 
2215
static int le_swig__p_char=0; /* handle for _p_char */
 
2216
static int le_swig__p_p_p_char=0; /* handle for _p_p_p_char */
 
2217
static int le_swig__p_OGRFeatureShadow=0; /* handle for Feature */
2012
2218
static int le_swig__p_OGRGeometryShadow=0; /* handle for Geometry */
2013
 
static int le_swig__p_p_OSRSpatialReferenceShadow=0; /* handle for Geometry */
2014
2219
static int le_swig__p_OSRSpatialReferenceShadow=0; /* handle for SpatialReference */
2015
 
static int le_swig__p_p_OGRDataSourceShadow=0; /* handle for SpatialReference */
2016
2220
static int le_swig__p_OGRDataSourceShadow=0; /* handle for DataSource */
2017
 
static int le_swig__p_OGRFeatureShadow=0; /* handle for Feature */
2018
 
static int le_swig__p_p_OGRFeatureShadow=0; /* handle for Feature */
2019
 
static int le_swig__int=0; /* handle for Feature */
2020
 
static int le_swig__p_int=0; /* handle for Feature */
2021
 
static int le_swig__p_p_OGRLayerShadow=0; /* handle for Feature */
 
2221
static int le_swig__p_p_OGRGeometryShadow=0; /* handle for _p_p_OGRGeometryShadow */
 
2222
static int le_swig__int=0; /* handle for _int */
 
2223
static int le_swig__p_int=0; /* handle for _p_int */
 
2224
static int le_swig__p_OGRFieldDefnShadow=0; /* handle for FieldDefn */
 
2225
static int le_swig__p_OGRFeatureDefnShadow=0; /* handle for FeatureDefn */
 
2226
static int le_swig__p_p_OGRLayerShadow=0; /* handle for _p_p_OGRLayerShadow */
2022
2227
static int le_swig__p_OGRLayerShadow=0; /* handle for Layer */
2023
 
static int le_swig__p_p_OGRDriverShadow=0; /* handle for Layer */
2024
2228
static int le_swig__p_OGRDriverShadow=0; /* handle for Driver */
2025
 
static int le_swig__p_OGRFeatureDefnShadow=0; /* handle for FeatureDefn */
2026
 
static int le_swig__p_OGRFieldDefnShadow=0; /* handle for FieldDefn */
2027
 
static int le_swig__p_p_OGRFieldDefnShadow=0; /* handle for FieldDefn */
2028
 
static int le_swig__p_p_OGRFeatureDefnShadow=0; /* handle for FieldDefn */
 
2229
static int le_swig__p_p_int=0; /* handle for _p_p_int */
2029
2230
static int le_swig__p_OSRCoordinateTransformationShadow=0; /* handle for CoordinateTransformation */
2030
 
static int le_swig__p_p_OSRCoordinateTransformationShadow=0; /* handle for CoordinateTransformation */
2031
2231
/* end vdecl subsection */
2032
2232
/* wrapper section */
2033
 
static pval _wrap_Driver_name_get(zend_property_reference *property_reference) {
2034
 
    OGRDriverShadow *arg1 = (OGRDriverShadow *) 0 ;
2035
 
    char *result;
2036
 
    zval **args[1];
2037
 
    zval _return_value;
2038
 
    zval *return_value=&_return_value;
2039
 
    
2040
 
    SWIG_ResetError();
2041
 
    {
2042
 
        /* typemap(in) SWIGTYPE * */
2043
 
        if(SWIG_ConvertPtr(*&(property_reference->object), (void **) &arg1, SWIGTYPE_p_OGRDriverShadow, 0) < 0) {
2044
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Driver_name_get. Expected SWIGTYPE_p_p_OGRDriverShadow");
2045
 
        }
2046
 
    }
2047
 
    result = (char *)OGRDriverShadow_name_get(arg1);
2048
 
    
2049
 
    {
2050
 
        if(!result) {
2051
 
            ZVAL_NULL(return_value);
2052
 
        } else {
2053
 
            ZVAL_STRING(return_value,result, 1);
2054
 
        }
2055
 
    }
2056
 
    return _return_value;
2057
 
    fail:
2058
 
    zend_error(ErrorCode(),ErrorMsg());
 
2233
ZEND_NAMED_FUNCTION(_wrap_Driver_name_get) {
 
2234
  OGRDriverShadow *arg1 = (OGRDriverShadow *) 0 ;
 
2235
  zval **args[1];
 
2236
  char *result = 0 ;
 
2237
  
 
2238
  SWIG_ResetError();
 
2239
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
2240
    WRONG_PARAM_COUNT;
 
2241
  }
 
2242
  
 
2243
  {
 
2244
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRDriverShadow, 0) < 0) {
 
2245
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Driver_name_get. Expected SWIGTYPE_p_OGRDriverShadow");
 
2246
    }
 
2247
  }
 
2248
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
2249
  result = (char *)OGRDriverShadow_name_get(arg1);
 
2250
  {
 
2251
    if(!result) {
 
2252
      ZVAL_NULL(return_value);
 
2253
    } else {
 
2254
      ZVAL_STRING(return_value, (char *)result, 1);
 
2255
    }
 
2256
  }
 
2257
  return;
 
2258
fail:
 
2259
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
2059
2260
}
2060
2261
 
2061
2262
 
2062
2263
ZEND_NAMED_FUNCTION(_wrap_Driver_CreateDataSource) {
2063
 
    OGRDriverShadow *arg1 = (OGRDriverShadow *) 0 ;
2064
 
    char *arg2 = (char *) 0 ;
2065
 
    char **arg3 = (char **) 0 ;
2066
 
    OGRDataSourceShadow *result;
2067
 
    zval **args[2];
2068
 
    int arg_count;
2069
 
    
2070
 
    SWIG_ResetError();
2071
 
    /* This function uses a this_ptr*/
2072
 
    arg_count = ZEND_NUM_ARGS();
2073
 
    if(arg_count<2 || arg_count>3)
2074
 
    WRONG_PARAM_COUNT;
2075
 
    
2076
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
2077
 
    WRONG_PARAM_COUNT;
2078
 
    
2079
 
    {
2080
 
        /* typemap(in) SWIGTYPE * */
2081
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRDriverShadow, 0) < 0) {
2082
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Driver_CreateDataSource. Expected SWIGTYPE_p_p_OGRDriverShadow");
2083
 
        }
2084
 
    }
2085
 
    {
2086
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
2087
 
        convert_to_string_ex(args[0]);
2088
 
        arg2 = (char *) Z_STRVAL_PP(args[0]);
2089
 
        /*@@*/;
2090
 
    }
2091
 
    if(arg_count > 2) {
2092
 
        {
2093
 
            /* %typemap(in) char **options */
2094
 
            zend_error(E_ERROR,"Typemap (in) char **options not properly defined");
2095
 
            //  int size = PySequence_Size(args[1]);
2096
 
            //  for (int i = 0; i < size; i++) {
2097
 
            //    char *pszItem = NULL;
2098
 
            //    if ( ! PyArg_Parse( PySequence_GetItem(args[1],i), "s", &pszItem ) ) {
2099
 
            //      PyErr_SetString(PyExc_TypeError,"sequence must contain strings");
2100
 
            //      SWIG_fail;
2101
 
            //    }
2102
 
            //    arg3 = CSLAddString( arg3, pszItem );
2103
 
            //  }
2104
 
        }
2105
 
    }
2106
 
    result = (OGRDataSourceShadow *)OGRDriverShadow_CreateDataSource(arg1,(char const *)arg2,arg3);
2107
 
    
2108
 
    {
2109
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRDataSourceShadow, 1);
2110
 
    }
2111
 
    /* Wrap this return value */
2112
 
    {
2113
 
        /* ALTERNATIVE Constructor, make an object wrapper */
2114
 
        zval *obj, *_cPtr;
2115
 
        MAKE_STD_ZVAL(obj);
2116
 
        MAKE_STD_ZVAL(_cPtr);
2117
 
        *_cPtr = *return_value;
2118
 
        INIT_ZVAL(*return_value);
2119
 
        object_init_ex(obj,ptr_ce_swig_DataSource);
2120
 
        add_property_zval(obj,"_cPtr",_cPtr);
2121
 
        *return_value=*obj;
2122
 
    }
2123
 
    {
2124
 
        /* %typemap(freearg) char **options */
2125
 
        CSLDestroy( arg3 );
2126
 
    }
2127
 
    return;
2128
 
    fail:
2129
 
    {
2130
 
        /* %typemap(freearg) char **options */
2131
 
        CSLDestroy( arg3 );
2132
 
    }
2133
 
    zend_error(ErrorCode(),ErrorMsg());
 
2264
  OGRDriverShadow *arg1 = (OGRDriverShadow *) 0 ;
 
2265
  char *arg2 = (char *) 0 ;
 
2266
  char **arg3 = (char **) 0 ;
 
2267
  zval **args[3];
 
2268
  int arg_count;
 
2269
  OGRDataSourceShadow *result = 0 ;
 
2270
  
 
2271
  SWIG_ResetError();
 
2272
  arg_count = ZEND_NUM_ARGS();
 
2273
  if(arg_count<2 || arg_count>3 ||
 
2274
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
2275
  WRONG_PARAM_COUNT;
 
2276
  
 
2277
  {
 
2278
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRDriverShadow, 0) < 0) {
 
2279
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Driver_CreateDataSource. Expected SWIGTYPE_p_OGRDriverShadow");
 
2280
    }
 
2281
  }
 
2282
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
2283
  
 
2284
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
2285
  if ((*args[1])->type==IS_NULL) {
 
2286
    arg2 = (char *) 0;
 
2287
  } else {
 
2288
    convert_to_string_ex(args[1]);
 
2289
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
2290
  }
 
2291
  /*@SWIG@*/;
 
2292
  
 
2293
  if(arg_count > 2) {
 
2294
    {
 
2295
      /* %typemap(in) char **options */
 
2296
      zend_error(E_ERROR,"Typemap (in) char **options not properly defined");
 
2297
      //  int size = PySequence_Size(args[2]);
 
2298
      //  for (int i = 0; i < size; i++) {
 
2299
      //    char *pszItem = NULL;
 
2300
      //    if ( ! PyArg_Parse( PySequence_GetItem(args[2],i), "s", &pszItem ) ) {
 
2301
      //      PyErr_SetString(PyExc_TypeError,"sequence must contain strings");
 
2302
      //      SWIG_fail;
 
2303
      //    }
 
2304
      //    arg3 = CSLAddString( arg3, pszItem );
 
2305
      //  }
 
2306
    }
 
2307
  }
 
2308
  {
 
2309
    if (!arg2) {
 
2310
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
2311
    }
 
2312
  }
 
2313
  result = (OGRDataSourceShadow *)OGRDriverShadow_CreateDataSource(arg1,(char const *)arg2,arg3);
 
2314
  
 
2315
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRDataSourceShadow, 1);
 
2316
  
 
2317
  {
 
2318
    /* %typemap(freearg) char **options */
 
2319
    CSLDestroy( arg3 );
 
2320
  }
 
2321
  return;
 
2322
fail:
 
2323
  {
 
2324
    /* %typemap(freearg) char **options */
 
2325
    CSLDestroy( arg3 );
 
2326
  }
 
2327
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
2134
2328
}
2135
2329
 
2136
2330
 
2137
2331
ZEND_NAMED_FUNCTION(_wrap_Driver_CopyDataSource) {
2138
 
    OGRDriverShadow *arg1 = (OGRDriverShadow *) 0 ;
2139
 
    OGRDataSourceShadow *arg2 = (OGRDataSourceShadow *) 0 ;
2140
 
    char *arg3 = (char *) 0 ;
2141
 
    char **arg4 = (char **) 0 ;
2142
 
    OGRDataSourceShadow *result;
2143
 
    zval **args[3];
2144
 
    int arg_count;
2145
 
    
2146
 
    SWIG_ResetError();
2147
 
    /* This function uses a this_ptr*/
2148
 
    arg_count = ZEND_NUM_ARGS();
2149
 
    if(arg_count<3 || arg_count>4)
2150
 
    WRONG_PARAM_COUNT;
2151
 
    
2152
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
2153
 
    WRONG_PARAM_COUNT;
2154
 
    
2155
 
    {
2156
 
        /* typemap(in) SWIGTYPE * */
2157
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRDriverShadow, 0) < 0) {
2158
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Driver_CopyDataSource. Expected SWIGTYPE_p_p_OGRDriverShadow");
2159
 
        }
2160
 
    }
2161
 
    {
2162
 
        /* typemap(in) SWIGTYPE * */
2163
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
2164
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Driver_CopyDataSource. Expected SWIGTYPE_p_p_OGRDataSourceShadow");
2165
 
        }
2166
 
    }
2167
 
    {
2168
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
2169
 
        convert_to_string_ex(args[1]);
2170
 
        arg3 = (char *) Z_STRVAL_PP(args[1]);
2171
 
        /*@@*/;
2172
 
    }
2173
 
    if(arg_count > 3) {
2174
 
        {
2175
 
            /* %typemap(in) char **options */
2176
 
            zend_error(E_ERROR,"Typemap (in) char **options not properly defined");
2177
 
            //  int size = PySequence_Size(args[2]);
2178
 
            //  for (int i = 0; i < size; i++) {
2179
 
            //    char *pszItem = NULL;
2180
 
            //    if ( ! PyArg_Parse( PySequence_GetItem(args[2],i), "s", &pszItem ) ) {
2181
 
            //      PyErr_SetString(PyExc_TypeError,"sequence must contain strings");
2182
 
            //      SWIG_fail;
2183
 
            //    }
2184
 
            //    arg4 = CSLAddString( arg4, pszItem );
2185
 
            //  }
2186
 
        }
2187
 
    }
2188
 
    result = (OGRDataSourceShadow *)OGRDriverShadow_CopyDataSource(arg1,arg2,(char const *)arg3,arg4);
2189
 
    
2190
 
    {
2191
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRDataSourceShadow, 1);
2192
 
    }
2193
 
    /* Wrap this return value */
2194
 
    {
2195
 
        /* ALTERNATIVE Constructor, make an object wrapper */
2196
 
        zval *obj, *_cPtr;
2197
 
        MAKE_STD_ZVAL(obj);
2198
 
        MAKE_STD_ZVAL(_cPtr);
2199
 
        *_cPtr = *return_value;
2200
 
        INIT_ZVAL(*return_value);
2201
 
        object_init_ex(obj,ptr_ce_swig_DataSource);
2202
 
        add_property_zval(obj,"_cPtr",_cPtr);
2203
 
        *return_value=*obj;
2204
 
    }
2205
 
    {
2206
 
        /* %typemap(freearg) char **options */
2207
 
        CSLDestroy( arg4 );
2208
 
    }
2209
 
    return;
2210
 
    fail:
2211
 
    {
2212
 
        /* %typemap(freearg) char **options */
2213
 
        CSLDestroy( arg4 );
2214
 
    }
2215
 
    zend_error(ErrorCode(),ErrorMsg());
 
2332
  OGRDriverShadow *arg1 = (OGRDriverShadow *) 0 ;
 
2333
  OGRDataSourceShadow *arg2 = (OGRDataSourceShadow *) 0 ;
 
2334
  char *arg3 = (char *) 0 ;
 
2335
  char **arg4 = (char **) 0 ;
 
2336
  zval **args[4];
 
2337
  int arg_count;
 
2338
  OGRDataSourceShadow *result = 0 ;
 
2339
  
 
2340
  SWIG_ResetError();
 
2341
  arg_count = ZEND_NUM_ARGS();
 
2342
  if(arg_count<3 || arg_count>4 ||
 
2343
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
2344
  WRONG_PARAM_COUNT;
 
2345
  
 
2346
  {
 
2347
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRDriverShadow, 0) < 0) {
 
2348
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Driver_CopyDataSource. Expected SWIGTYPE_p_OGRDriverShadow");
 
2349
    }
 
2350
  }
 
2351
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
2352
  {
 
2353
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
 
2354
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Driver_CopyDataSource. Expected SWIGTYPE_p_OGRDataSourceShadow");
 
2355
    }
 
2356
  }
 
2357
  
 
2358
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
2359
  if ((*args[2])->type==IS_NULL) {
 
2360
    arg3 = (char *) 0;
 
2361
  } else {
 
2362
    convert_to_string_ex(args[2]);
 
2363
    arg3 = (char *) Z_STRVAL_PP(args[2]);
 
2364
  }
 
2365
  /*@SWIG@*/;
 
2366
  
 
2367
  if(arg_count > 3) {
 
2368
    {
 
2369
      /* %typemap(in) char **options */
 
2370
      zend_error(E_ERROR,"Typemap (in) char **options not properly defined");
 
2371
      //  int size = PySequence_Size(args[3]);
 
2372
      //  for (int i = 0; i < size; i++) {
 
2373
      //    char *pszItem = NULL;
 
2374
      //    if ( ! PyArg_Parse( PySequence_GetItem(args[3],i), "s", &pszItem ) ) {
 
2375
      //      PyErr_SetString(PyExc_TypeError,"sequence must contain strings");
 
2376
      //      SWIG_fail;
 
2377
      //    }
 
2378
      //    arg4 = CSLAddString( arg4, pszItem );
 
2379
      //  }
 
2380
    }
 
2381
  }
 
2382
  result = (OGRDataSourceShadow *)OGRDriverShadow_CopyDataSource(arg1,arg2,(char const *)arg3,arg4);
 
2383
  
 
2384
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRDataSourceShadow, 1);
 
2385
  
 
2386
  {
 
2387
    /* %typemap(freearg) char **options */
 
2388
    CSLDestroy( arg4 );
 
2389
  }
 
2390
  return;
 
2391
fail:
 
2392
  {
 
2393
    /* %typemap(freearg) char **options */
 
2394
    CSLDestroy( arg4 );
 
2395
  }
 
2396
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
2216
2397
}
2217
2398
 
2218
2399
 
2219
2400
ZEND_NAMED_FUNCTION(_wrap_Driver_Open) {
2220
 
    OGRDriverShadow *arg1 = (OGRDriverShadow *) 0 ;
2221
 
    char *arg2 = (char *) 0 ;
2222
 
    int arg3 = (int) 0 ;
2223
 
    OGRDataSourceShadow *result;
2224
 
    zval **args[2];
2225
 
    int arg_count;
2226
 
    
2227
 
    SWIG_ResetError();
2228
 
    /* This function uses a this_ptr*/
2229
 
    arg_count = ZEND_NUM_ARGS();
2230
 
    if(arg_count<2 || arg_count>3)
2231
 
    WRONG_PARAM_COUNT;
2232
 
    
2233
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
2234
 
    WRONG_PARAM_COUNT;
2235
 
    
2236
 
    {
2237
 
        /* typemap(in) SWIGTYPE * */
2238
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRDriverShadow, 0) < 0) {
2239
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Driver_Open. Expected SWIGTYPE_p_p_OGRDriverShadow");
2240
 
        }
2241
 
    }
2242
 
    {
2243
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
2244
 
        convert_to_string_ex(args[0]);
2245
 
        arg2 = (char *) Z_STRVAL_PP(args[0]);
2246
 
        /*@@*/;
2247
 
    }
2248
 
    if(arg_count > 2) {
2249
 
        {
2250
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
2251
 
            convert_to_long_ex(args[1]);
2252
 
            arg3 = (int) Z_LVAL_PP(args[1]);
2253
 
            /*@@*/;
2254
 
        }
2255
 
    }
2256
 
    result = (OGRDataSourceShadow *)OGRDriverShadow_Open(arg1,(char const *)arg2,arg3);
2257
 
    
2258
 
    {
2259
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRDataSourceShadow, 1);
2260
 
    }
2261
 
    /* Wrap this return value */
2262
 
    {
2263
 
        /* ALTERNATIVE Constructor, make an object wrapper */
2264
 
        zval *obj, *_cPtr;
2265
 
        MAKE_STD_ZVAL(obj);
2266
 
        MAKE_STD_ZVAL(_cPtr);
2267
 
        *_cPtr = *return_value;
2268
 
        INIT_ZVAL(*return_value);
2269
 
        object_init_ex(obj,ptr_ce_swig_DataSource);
2270
 
        add_property_zval(obj,"_cPtr",_cPtr);
2271
 
        *return_value=*obj;
2272
 
    }
2273
 
    return;
2274
 
    fail:
2275
 
    zend_error(ErrorCode(),ErrorMsg());
 
2401
  OGRDriverShadow *arg1 = (OGRDriverShadow *) 0 ;
 
2402
  char *arg2 = (char *) 0 ;
 
2403
  int arg3 = (int) 0 ;
 
2404
  zval **args[3];
 
2405
  int arg_count;
 
2406
  OGRDataSourceShadow *result = 0 ;
 
2407
  
 
2408
  SWIG_ResetError();
 
2409
  arg_count = ZEND_NUM_ARGS();
 
2410
  if(arg_count<2 || arg_count>3 ||
 
2411
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
2412
  WRONG_PARAM_COUNT;
 
2413
  
 
2414
  {
 
2415
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRDriverShadow, 0) < 0) {
 
2416
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Driver_Open. Expected SWIGTYPE_p_OGRDriverShadow");
 
2417
    }
 
2418
  }
 
2419
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
2420
  
 
2421
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
2422
  if ((*args[1])->type==IS_NULL) {
 
2423
    arg2 = (char *) 0;
 
2424
  } else {
 
2425
    convert_to_string_ex(args[1]);
 
2426
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
2427
  }
 
2428
  /*@SWIG@*/;
 
2429
  
 
2430
  if(arg_count > 2) {
 
2431
    /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
2432
    convert_to_long_ex(args[2]);
 
2433
    arg3 = (int) Z_LVAL_PP(args[2]);
 
2434
    /*@SWIG@*/;
 
2435
    
 
2436
  }
 
2437
  result = (OGRDataSourceShadow *)OGRDriverShadow_Open(arg1,(char const *)arg2,arg3);
 
2438
  
 
2439
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRDataSourceShadow, 1);
 
2440
  
 
2441
  return;
 
2442
fail:
 
2443
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
2276
2444
}
2277
2445
 
2278
2446
 
2279
2447
ZEND_NAMED_FUNCTION(_wrap_Driver_DeleteDataSource) {
2280
 
    OGRDriverShadow *arg1 = (OGRDriverShadow *) 0 ;
2281
 
    char *arg2 = (char *) 0 ;
2282
 
    int result;
2283
 
    zval **args[1];
2284
 
    
2285
 
    SWIG_ResetError();
2286
 
    /* This function uses a this_ptr*/
2287
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
2288
 
        WRONG_PARAM_COUNT;
2289
 
    }
2290
 
    
2291
 
    {
2292
 
        /* typemap(in) SWIGTYPE * */
2293
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRDriverShadow, 0) < 0) {
2294
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Driver_DeleteDataSource. Expected SWIGTYPE_p_p_OGRDriverShadow");
2295
 
        }
2296
 
    }
2297
 
    {
2298
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
2299
 
        convert_to_string_ex(args[0]);
2300
 
        arg2 = (char *) Z_STRVAL_PP(args[0]);
2301
 
        /*@@*/;
2302
 
    }
2303
 
    result = (int)OGRDriverShadow_DeleteDataSource(arg1,(char const *)arg2);
2304
 
    
2305
 
    {
2306
 
        ZVAL_LONG(return_value,result);
2307
 
    }
2308
 
    return;
2309
 
    fail:
2310
 
    zend_error(ErrorCode(),ErrorMsg());
 
2448
  OGRDriverShadow *arg1 = (OGRDriverShadow *) 0 ;
 
2449
  char *arg2 = (char *) 0 ;
 
2450
  zval **args[2];
 
2451
  int result;
 
2452
  
 
2453
  SWIG_ResetError();
 
2454
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
2455
    WRONG_PARAM_COUNT;
 
2456
  }
 
2457
  
 
2458
  {
 
2459
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRDriverShadow, 0) < 0) {
 
2460
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Driver_DeleteDataSource. Expected SWIGTYPE_p_OGRDriverShadow");
 
2461
    }
 
2462
  }
 
2463
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
2464
  
 
2465
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
2466
  if ((*args[1])->type==IS_NULL) {
 
2467
    arg2 = (char *) 0;
 
2468
  } else {
 
2469
    convert_to_string_ex(args[1]);
 
2470
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
2471
  }
 
2472
  /*@SWIG@*/;
 
2473
  
 
2474
  {
 
2475
    if (!arg2) {
 
2476
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
2477
    }
 
2478
  }
 
2479
  result = (int)OGRDriverShadow_DeleteDataSource(arg1,(char const *)arg2);
 
2480
  {
 
2481
    ZVAL_LONG(return_value,result);
 
2482
  }
 
2483
  return;
 
2484
fail:
 
2485
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
2311
2486
}
2312
2487
 
2313
2488
 
2314
2489
ZEND_NAMED_FUNCTION(_wrap_Driver_TestCapability) {
2315
 
    OGRDriverShadow *arg1 = (OGRDriverShadow *) 0 ;
2316
 
    char *arg2 = (char *) 0 ;
2317
 
    int result;
2318
 
    zval **args[1];
2319
 
    
2320
 
    SWIG_ResetError();
2321
 
    /* This function uses a this_ptr*/
2322
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
2323
 
        WRONG_PARAM_COUNT;
2324
 
    }
2325
 
    
2326
 
    {
2327
 
        /* typemap(in) SWIGTYPE * */
2328
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRDriverShadow, 0) < 0) {
2329
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Driver_TestCapability. Expected SWIGTYPE_p_p_OGRDriverShadow");
2330
 
        }
2331
 
    }
2332
 
    {
2333
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
2334
 
        convert_to_string_ex(args[0]);
2335
 
        arg2 = (char *) Z_STRVAL_PP(args[0]);
2336
 
        /*@@*/;
2337
 
    }
2338
 
    result = (int)OGRDriverShadow_TestCapability(arg1,(char const *)arg2);
2339
 
    
2340
 
    {
2341
 
        ZVAL_LONG(return_value,result);
2342
 
    }
2343
 
    return;
2344
 
    fail:
2345
 
    zend_error(ErrorCode(),ErrorMsg());
 
2490
  OGRDriverShadow *arg1 = (OGRDriverShadow *) 0 ;
 
2491
  char *arg2 = (char *) 0 ;
 
2492
  zval **args[2];
 
2493
  bool result;
 
2494
  
 
2495
  SWIG_ResetError();
 
2496
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
2497
    WRONG_PARAM_COUNT;
 
2498
  }
 
2499
  
 
2500
  {
 
2501
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRDriverShadow, 0) < 0) {
 
2502
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Driver_TestCapability. Expected SWIGTYPE_p_OGRDriverShadow");
 
2503
    }
 
2504
  }
 
2505
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
2506
  
 
2507
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
2508
  if ((*args[1])->type==IS_NULL) {
 
2509
    arg2 = (char *) 0;
 
2510
  } else {
 
2511
    convert_to_string_ex(args[1]);
 
2512
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
2513
  }
 
2514
  /*@SWIG@*/;
 
2515
  
 
2516
  {
 
2517
    if (!arg2) {
 
2518
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
2519
    }
 
2520
  }
 
2521
  result = (bool)OGRDriverShadow_TestCapability(arg1,(char const *)arg2);
 
2522
  {
 
2523
    ZVAL_BOOL(return_value,(result)?1:0);
 
2524
  }
 
2525
  return;
 
2526
fail:
 
2527
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
2346
2528
}
2347
2529
 
2348
2530
 
2349
2531
ZEND_NAMED_FUNCTION(_wrap_Driver_GetName) {
2350
 
    OGRDriverShadow *arg1 = (OGRDriverShadow *) 0 ;
2351
 
    char *result;
2352
 
    zval **args[0];
2353
 
    
2354
 
    SWIG_ResetError();
2355
 
    /* This function uses a this_ptr*/
2356
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
2357
 
        WRONG_PARAM_COUNT;
2358
 
    }
2359
 
    
2360
 
    {
2361
 
        /* typemap(in) SWIGTYPE * */
2362
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRDriverShadow, 0) < 0) {
2363
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Driver_GetName. Expected SWIGTYPE_p_p_OGRDriverShadow");
2364
 
        }
2365
 
    }
2366
 
    result = (char *)OGRDriverShadow_GetName(arg1);
2367
 
    
2368
 
    {
2369
 
        if(!result) {
2370
 
            ZVAL_NULL(return_value);
2371
 
        } else {
2372
 
            ZVAL_STRING(return_value,result, 1);
2373
 
        }
2374
 
    }
2375
 
    return;
2376
 
    fail:
2377
 
    zend_error(ErrorCode(),ErrorMsg());
2378
 
}
2379
 
 
2380
 
 
2381
 
/* property handler for class Driver */
2382
 
static pval _wrap_propget_Driver(zend_property_reference *property_reference) {
2383
 
  pval result;
2384
 
  pval **_result;
2385
 
  zend_llist_element *element = property_reference->elements_list->head;
2386
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
2387
 
  result.type = IS_NULL;
2388
 
  if (_propget_Driver(property_reference, &result)==SUCCESS) return result;
2389
 
  /* return it ourselves */
2390
 
  if (zend_hash_find(Z_OBJPROP_P(property_reference->object),Z_STRVAL_P(&(property->element)),1+Z_STRLEN_P(&(property->element)),(void**)&_result)==SUCCESS) {
2391
 
  zval *_value;
2392
 
  MAKE_STD_ZVAL(_value);  *_value=**_result;
2393
 
  INIT_PZVAL(_value);
2394
 
  zval_copy_ctor(_value);
2395
 
  return *_value;
2396
 
  }
2397
 
  result.type = IS_NULL;
2398
 
  return result;
2399
 
}
2400
 
static int _propget_Driver(zend_property_reference *property_reference, pval *value) {
2401
 
  /* get the property name */
2402
 
  zend_llist_element *element = property_reference->elements_list->head;
2403
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
2404
 
  char *propname=Z_STRVAL_P(&(property->element));
2405
 
  if (strcmp(propname,"name")==0) {
2406
 
    *value=_wrap_Driver_name_get(property_reference);
2407
 
    return SUCCESS;
2408
 
  } else  return FAILURE;
2409
 
}
2410
 
 
2411
 
static int _wrap_propset_Driver(zend_property_reference *property_reference, pval *value) { 
2412
 
  zval * _value;
2413
 
  zend_llist_element *element = property_reference->elements_list->head;
2414
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
2415
 
  if (_propset_Driver(property_reference, value)==SUCCESS) return SUCCESS;
2416
 
  /* set it ourselves as it is Driver */
2417
 
  MAKE_STD_ZVAL(_value);
2418
 
  *_value=*value;
2419
 
  INIT_PZVAL(_value);
2420
 
  zval_copy_ctor(_value);
2421
 
  return add_property_zval_ex(property_reference->object,Z_STRVAL_P(&(property->element)),1+Z_STRLEN_P(&(property->element)),_value);
2422
 
}
2423
 
static int _propset_Driver(zend_property_reference *property_reference, pval *value) {
2424
 
  /* get the property name */
2425
 
  zend_llist_element *element = property_reference->elements_list->head;
2426
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
2427
 
  char *propname=Z_STRVAL_P(&(property->element));
2428
 
  return FAILURE;
2429
 
}
2430
 
 
2431
 
static pval _wrap_DataSource_name_get(zend_property_reference *property_reference) {
2432
 
    OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
2433
 
    char *result;
2434
 
    zval **args[1];
2435
 
    zval _return_value;
2436
 
    zval *return_value=&_return_value;
2437
 
    
2438
 
    SWIG_ResetError();
2439
 
    {
2440
 
        /* typemap(in) SWIGTYPE * */
2441
 
        if(SWIG_ConvertPtr(*&(property_reference->object), (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
2442
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_name_get. Expected SWIGTYPE_p_p_OGRDataSourceShadow");
2443
 
        }
2444
 
    }
2445
 
    result = (char *)OGRDataSourceShadow_name_get(arg1);
2446
 
    
2447
 
    {
2448
 
        if(!result) {
2449
 
            ZVAL_NULL(return_value);
2450
 
        } else {
2451
 
            ZVAL_STRING(return_value,result, 1);
2452
 
        }
2453
 
    }
2454
 
    return _return_value;
2455
 
    fail:
2456
 
    zend_error(ErrorCode(),ErrorMsg());
 
2532
  OGRDriverShadow *arg1 = (OGRDriverShadow *) 0 ;
 
2533
  zval **args[1];
 
2534
  char *result = 0 ;
 
2535
  
 
2536
  SWIG_ResetError();
 
2537
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
2538
    WRONG_PARAM_COUNT;
 
2539
  }
 
2540
  
 
2541
  {
 
2542
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRDriverShadow, 0) < 0) {
 
2543
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Driver_GetName. Expected SWIGTYPE_p_OGRDriverShadow");
 
2544
    }
 
2545
  }
 
2546
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
2547
  result = (char *)OGRDriverShadow_GetName(arg1);
 
2548
  {
 
2549
    if(!result) {
 
2550
      ZVAL_NULL(return_value);
 
2551
    } else {
 
2552
      ZVAL_STRING(return_value, (char *)result, 1);
 
2553
    }
 
2554
  }
 
2555
  return;
 
2556
fail:
 
2557
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
2558
}
 
2559
 
 
2560
 
 
2561
ZEND_NAMED_FUNCTION(_wrap_Driver_Register) {
 
2562
  OGRDriverShadow *arg1 = (OGRDriverShadow *) 0 ;
 
2563
  zval **args[1];
 
2564
  
 
2565
  SWIG_ResetError();
 
2566
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
2567
    WRONG_PARAM_COUNT;
 
2568
  }
 
2569
  
 
2570
  {
 
2571
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRDriverShadow, 0) < 0) {
 
2572
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Driver_Register. Expected SWIGTYPE_p_OGRDriverShadow");
 
2573
    }
 
2574
  }
 
2575
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
2576
  OGRDriverShadow_Register(arg1);
 
2577
  
 
2578
  return;
 
2579
fail:
 
2580
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
2581
}
 
2582
 
 
2583
 
 
2584
ZEND_NAMED_FUNCTION(_wrap_Driver_Deregister) {
 
2585
  OGRDriverShadow *arg1 = (OGRDriverShadow *) 0 ;
 
2586
  zval **args[1];
 
2587
  
 
2588
  SWIG_ResetError();
 
2589
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
2590
    WRONG_PARAM_COUNT;
 
2591
  }
 
2592
  
 
2593
  {
 
2594
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRDriverShadow, 0) < 0) {
 
2595
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Driver_Deregister. Expected SWIGTYPE_p_OGRDriverShadow");
 
2596
    }
 
2597
  }
 
2598
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
2599
  OGRDriverShadow_Deregister(arg1);
 
2600
  
 
2601
  return;
 
2602
fail:
 
2603
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
2604
}
 
2605
 
 
2606
 
 
2607
ZEND_NAMED_FUNCTION(_wrap_DataSource_name_get) {
 
2608
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
 
2609
  zval **args[1];
 
2610
  char *result = 0 ;
 
2611
  
 
2612
  SWIG_ResetError();
 
2613
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
2614
    WRONG_PARAM_COUNT;
 
2615
  }
 
2616
  
 
2617
  {
 
2618
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
 
2619
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_name_get. Expected SWIGTYPE_p_OGRDataSourceShadow");
 
2620
    }
 
2621
  }
 
2622
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
2623
  result = (char *)OGRDataSourceShadow_name_get(arg1);
 
2624
  {
 
2625
    if(!result) {
 
2626
      ZVAL_NULL(return_value);
 
2627
    } else {
 
2628
      ZVAL_STRING(return_value, (char *)result, 1);
 
2629
    }
 
2630
  }
 
2631
  return;
 
2632
fail:
 
2633
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
2457
2634
}
2458
2635
 
2459
2636
 
2460
2637
/* This function is designed to be called by the zend list destructors */
2461
2638
/* to typecast and do the actual destruction */
2462
 
void __wrap_delete_DataSource(zend_rsrc_list_entry *rsrc, const char *type_name TSRMLS_DC) {
2463
 
    swig_object_wrapper *value=(swig_object_wrapper *) rsrc->ptr ;
2464
 
    void *ptr=value->ptr ;
2465
 
    int newobject=value->newobject ;
2466
 
    OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
2467
 
    
2468
 
    efree(value);
2469
 
    if (! newobject) return; /* can't delete it! */
2470
 
    SWIG_ZTS_ConvertResourceData(ptr,rsrc->type,type_name,(void **) &arg1,SWIGTYPE_p_OGRDataSourceShadow TSRMLS_CC);
2471
 
    if (! arg1) zend_error(E_ERROR, "OGRDataSourceShadow resource already free'd");
2472
 
    delete_OGRDataSourceShadow(arg1);
2473
 
    
 
2639
static void __wrap_delete_DataSource(zend_rsrc_list_entry *rsrc, const char *type_name TSRMLS_DC) {
 
2640
  swig_object_wrapper *value=(swig_object_wrapper *) rsrc->ptr ;
 
2641
  void *ptr=value->ptr ;
 
2642
  int newobject=value->newobject ;
 
2643
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
 
2644
  
 
2645
  efree(value);
 
2646
  if (! newobject) return; /* can't delete it! */
 
2647
  arg1 = (OGRDataSourceShadow *)SWIG_ZTS_ConvertResourceData(ptr,type_name,SWIGTYPE_p_OGRDataSourceShadow TSRMLS_CC);
 
2648
  if (! arg1) zend_error(E_ERROR, "OGRDataSourceShadow resource already free'd");
 
2649
  delete_OGRDataSourceShadow(arg1);
 
2650
  return;
 
2651
fail:
 
2652
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
2474
2653
}
2475
2654
 
2476
2655
 
2477
2656
ZEND_NAMED_FUNCTION(_wrap_DataSource_GetRefCount) {
2478
 
    OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
2479
 
    int result;
2480
 
    zval **args[0];
2481
 
    
2482
 
    SWIG_ResetError();
2483
 
    /* This function uses a this_ptr*/
2484
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
2485
 
        WRONG_PARAM_COUNT;
2486
 
    }
2487
 
    
2488
 
    {
2489
 
        /* typemap(in) SWIGTYPE * */
2490
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
2491
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_GetRefCount. Expected SWIGTYPE_p_p_OGRDataSourceShadow");
2492
 
        }
2493
 
    }
2494
 
    result = (int)OGRDataSourceShadow_GetRefCount(arg1);
2495
 
    
2496
 
    {
2497
 
        ZVAL_LONG(return_value,result);
2498
 
    }
2499
 
    return;
2500
 
    fail:
2501
 
    zend_error(ErrorCode(),ErrorMsg());
 
2657
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
 
2658
  zval **args[1];
 
2659
  int result;
 
2660
  
 
2661
  SWIG_ResetError();
 
2662
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
2663
    WRONG_PARAM_COUNT;
 
2664
  }
 
2665
  
 
2666
  {
 
2667
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
 
2668
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_GetRefCount. Expected SWIGTYPE_p_OGRDataSourceShadow");
 
2669
    }
 
2670
  }
 
2671
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
2672
  result = (int)OGRDataSourceShadow_GetRefCount(arg1);
 
2673
  {
 
2674
    ZVAL_LONG(return_value,result);
 
2675
  }
 
2676
  return;
 
2677
fail:
 
2678
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
2502
2679
}
2503
2680
 
2504
2681
 
2505
2682
ZEND_NAMED_FUNCTION(_wrap_DataSource_GetSummaryRefCount) {
2506
 
    OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
2507
 
    int result;
2508
 
    zval **args[0];
2509
 
    
2510
 
    SWIG_ResetError();
2511
 
    /* This function uses a this_ptr*/
2512
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
2513
 
        WRONG_PARAM_COUNT;
2514
 
    }
2515
 
    
2516
 
    {
2517
 
        /* typemap(in) SWIGTYPE * */
2518
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
2519
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_GetSummaryRefCount. Expected SWIGTYPE_p_p_OGRDataSourceShadow");
2520
 
        }
2521
 
    }
2522
 
    result = (int)OGRDataSourceShadow_GetSummaryRefCount(arg1);
2523
 
    
2524
 
    {
2525
 
        ZVAL_LONG(return_value,result);
2526
 
    }
2527
 
    return;
2528
 
    fail:
2529
 
    zend_error(ErrorCode(),ErrorMsg());
 
2683
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
 
2684
  zval **args[1];
 
2685
  int result;
 
2686
  
 
2687
  SWIG_ResetError();
 
2688
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
2689
    WRONG_PARAM_COUNT;
 
2690
  }
 
2691
  
 
2692
  {
 
2693
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
 
2694
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_GetSummaryRefCount. Expected SWIGTYPE_p_OGRDataSourceShadow");
 
2695
    }
 
2696
  }
 
2697
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
2698
  result = (int)OGRDataSourceShadow_GetSummaryRefCount(arg1);
 
2699
  {
 
2700
    ZVAL_LONG(return_value,result);
 
2701
  }
 
2702
  return;
 
2703
fail:
 
2704
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
2530
2705
}
2531
2706
 
2532
2707
 
2533
2708
ZEND_NAMED_FUNCTION(_wrap_DataSource_GetLayerCount) {
2534
 
    OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
2535
 
    int result;
2536
 
    zval **args[0];
2537
 
    
2538
 
    SWIG_ResetError();
2539
 
    /* This function uses a this_ptr*/
2540
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
2541
 
        WRONG_PARAM_COUNT;
2542
 
    }
2543
 
    
2544
 
    {
2545
 
        /* typemap(in) SWIGTYPE * */
2546
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
2547
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_GetLayerCount. Expected SWIGTYPE_p_p_OGRDataSourceShadow");
2548
 
        }
2549
 
    }
2550
 
    result = (int)OGRDataSourceShadow_GetLayerCount(arg1);
2551
 
    
2552
 
    {
2553
 
        ZVAL_LONG(return_value,result);
2554
 
    }
2555
 
    return;
2556
 
    fail:
2557
 
    zend_error(ErrorCode(),ErrorMsg());
 
2709
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
 
2710
  zval **args[1];
 
2711
  int result;
 
2712
  
 
2713
  SWIG_ResetError();
 
2714
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
2715
    WRONG_PARAM_COUNT;
 
2716
  }
 
2717
  
 
2718
  {
 
2719
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
 
2720
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_GetLayerCount. Expected SWIGTYPE_p_OGRDataSourceShadow");
 
2721
    }
 
2722
  }
 
2723
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
2724
  result = (int)OGRDataSourceShadow_GetLayerCount(arg1);
 
2725
  {
 
2726
    ZVAL_LONG(return_value,result);
 
2727
  }
 
2728
  return;
 
2729
fail:
 
2730
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
2731
}
 
2732
 
 
2733
 
 
2734
ZEND_NAMED_FUNCTION(_wrap_DataSource_GetDriver) {
 
2735
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
 
2736
  zval **args[1];
 
2737
  OGRDriverShadow *result = 0 ;
 
2738
  
 
2739
  SWIG_ResetError();
 
2740
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
2741
    WRONG_PARAM_COUNT;
 
2742
  }
 
2743
  
 
2744
  {
 
2745
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
 
2746
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_GetDriver. Expected SWIGTYPE_p_OGRDataSourceShadow");
 
2747
    }
 
2748
  }
 
2749
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
2750
  result = (OGRDriverShadow *)OGRDataSourceShadow_GetDriver(arg1);
 
2751
  
 
2752
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRDriverShadow, 0);
 
2753
  
 
2754
  return;
 
2755
fail:
 
2756
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
2558
2757
}
2559
2758
 
2560
2759
 
2561
2760
ZEND_NAMED_FUNCTION(_wrap_DataSource_GetName) {
2562
 
    OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
2563
 
    char *result;
2564
 
    zval **args[0];
2565
 
    
2566
 
    SWIG_ResetError();
2567
 
    /* This function uses a this_ptr*/
2568
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
2569
 
        WRONG_PARAM_COUNT;
2570
 
    }
2571
 
    
2572
 
    {
2573
 
        /* typemap(in) SWIGTYPE * */
2574
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
2575
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_GetName. Expected SWIGTYPE_p_p_OGRDataSourceShadow");
2576
 
        }
2577
 
    }
2578
 
    result = (char *)OGRDataSourceShadow_GetName(arg1);
2579
 
    
2580
 
    {
2581
 
        if(!result) {
2582
 
            ZVAL_NULL(return_value);
2583
 
        } else {
2584
 
            ZVAL_STRING(return_value,result, 1);
2585
 
        }
2586
 
    }
2587
 
    return;
2588
 
    fail:
2589
 
    zend_error(ErrorCode(),ErrorMsg());
 
2761
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
 
2762
  zval **args[1];
 
2763
  char *result = 0 ;
 
2764
  
 
2765
  SWIG_ResetError();
 
2766
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
2767
    WRONG_PARAM_COUNT;
 
2768
  }
 
2769
  
 
2770
  {
 
2771
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
 
2772
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_GetName. Expected SWIGTYPE_p_OGRDataSourceShadow");
 
2773
    }
 
2774
  }
 
2775
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
2776
  result = (char *)OGRDataSourceShadow_GetName(arg1);
 
2777
  {
 
2778
    if(!result) {
 
2779
      ZVAL_NULL(return_value);
 
2780
    } else {
 
2781
      ZVAL_STRING(return_value, (char *)result, 1);
 
2782
    }
 
2783
  }
 
2784
  return;
 
2785
fail:
 
2786
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
2590
2787
}
2591
2788
 
2592
2789
 
2593
2790
ZEND_NAMED_FUNCTION(_wrap_DataSource_DeleteLayer) {
2594
 
    OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
2595
 
    int arg2 ;
2596
 
    OGRErr result;
2597
 
    zval **args[1];
2598
 
    
2599
 
    SWIG_ResetError();
2600
 
    /* This function uses a this_ptr*/
2601
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
2602
 
        WRONG_PARAM_COUNT;
2603
 
    }
2604
 
    
2605
 
    {
2606
 
        /* typemap(in) SWIGTYPE * */
2607
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
2608
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_DeleteLayer. Expected SWIGTYPE_p_p_OGRDataSourceShadow");
2609
 
        }
2610
 
    }
2611
 
    {
2612
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
2613
 
        convert_to_long_ex(args[0]);
2614
 
        arg2 = (int) Z_LVAL_PP(args[0]);
2615
 
        /*@@*/;
2616
 
    }
2617
 
    result = (OGRErr)OGRDataSourceShadow_DeleteLayer(arg1,arg2);
2618
 
    
2619
 
    {
2620
 
        /* %typemap(out) OGRErr */
2621
 
        if (result != 0 ) {
2622
 
            SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
2623
 
        }
2624
 
    }
2625
 
    {
2626
 
        /* %typemap(ret) OGRErr */
2627
 
        RETVAL_LONG(0);
2628
 
    }
2629
 
    return;
2630
 
    fail:
2631
 
    zend_error(ErrorCode(),ErrorMsg());
 
2791
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
 
2792
  int arg2 ;
 
2793
  zval **args[2];
 
2794
  OGRErr result;
 
2795
  
 
2796
  SWIG_ResetError();
 
2797
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
2798
    WRONG_PARAM_COUNT;
 
2799
  }
 
2800
  
 
2801
  {
 
2802
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
 
2803
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_DeleteLayer. Expected SWIGTYPE_p_OGRDataSourceShadow");
 
2804
    }
 
2805
  }
 
2806
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
2807
  
 
2808
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
2809
  convert_to_long_ex(args[1]);
 
2810
  arg2 = (int) Z_LVAL_PP(args[1]);
 
2811
  /*@SWIG@*/;
 
2812
  
 
2813
  result = (OGRErr)OGRDataSourceShadow_DeleteLayer(arg1,arg2);
 
2814
  {
 
2815
    /* %typemap(out) OGRErr */
 
2816
    if (result != 0 ) {
 
2817
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
2818
    }
 
2819
  }
 
2820
  {
 
2821
    /* %typemap(ret) OGRErr */
 
2822
    RETVAL_LONG(0);
 
2823
  }
 
2824
  return;
 
2825
fail:
 
2826
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
2632
2827
}
2633
2828
 
2634
2829
 
2635
2830
ZEND_NAMED_FUNCTION(_wrap_DataSource_CreateLayer) {
2636
 
    OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
2637
 
    char *arg2 = (char *) 0 ;
2638
 
    OSRSpatialReferenceShadow *arg3 = (OSRSpatialReferenceShadow *) NULL ;
2639
 
    OGRwkbGeometryType arg4 = (OGRwkbGeometryType) wkbUnknown ;
2640
 
    char **arg5 = (char **) 0 ;
2641
 
    OGRLayerShadow *result;
2642
 
    zval **args[4];
2643
 
    int arg_count;
2644
 
    
2645
 
    SWIG_ResetError();
2646
 
    /* This function uses a this_ptr*/
2647
 
    arg_count = ZEND_NUM_ARGS();
2648
 
    if(arg_count<2 || arg_count>5)
2649
 
    WRONG_PARAM_COUNT;
2650
 
    
2651
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
2652
 
    WRONG_PARAM_COUNT;
2653
 
    
2654
 
    {
2655
 
        /* typemap(in) SWIGTYPE * */
2656
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
2657
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_CreateLayer. Expected SWIGTYPE_p_p_OGRDataSourceShadow");
2658
 
        }
2659
 
    }
2660
 
    {
2661
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
2662
 
        convert_to_string_ex(args[0]);
2663
 
        arg2 = (char *) Z_STRVAL_PP(args[0]);
2664
 
        /*@@*/;
2665
 
    }
2666
 
    if(arg_count > 2) {
2667
 
        {
2668
 
            /* typemap(in) SWIGTYPE * */
2669
 
            if(SWIG_ConvertPtr(*args[1], (void **) &arg3, SWIGTYPE_p_OSRSpatialReferenceShadow, 0) < 0) {
2670
 
                SWIG_PHP_Error(E_ERROR, "Type error in argument 3 of DataSource_CreateLayer. Expected SWIGTYPE_p_p_OSRSpatialReferenceShadow");
2671
 
            }
2672
 
        }
2673
 
    }
2674
 
    if(arg_count > 3) {
2675
 
        {
2676
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
2677
 
            convert_to_long_ex(args[2]);
2678
 
            arg4 = (OGRwkbGeometryType) Z_LVAL_PP(args[2]);
2679
 
            /*@@*/;
2680
 
        }
2681
 
    }
2682
 
    if(arg_count > 4) {
2683
 
        {
2684
 
            /* %typemap(in) char **options */
2685
 
            zend_error(E_ERROR,"Typemap (in) char **options not properly defined");
2686
 
            //  int size = PySequence_Size(args[3]);
2687
 
            //  for (int i = 0; i < size; i++) {
2688
 
            //    char *pszItem = NULL;
2689
 
            //    if ( ! PyArg_Parse( PySequence_GetItem(args[3],i), "s", &pszItem ) ) {
2690
 
            //      PyErr_SetString(PyExc_TypeError,"sequence must contain strings");
2691
 
            //      SWIG_fail;
2692
 
            //    }
2693
 
            //    arg5 = CSLAddString( arg5, pszItem );
2694
 
            //  }
2695
 
        }
2696
 
    }
2697
 
    result = (OGRLayerShadow *)OGRDataSourceShadow_CreateLayer(arg1,(char const *)arg2,arg3,arg4,arg5);
2698
 
    
2699
 
    {
2700
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRLayerShadow, 0);
2701
 
    }
2702
 
    /* Wrap this return value */
2703
 
    {
2704
 
        /* ALTERNATIVE Constructor, make an object wrapper */
2705
 
        zval *obj, *_cPtr;
2706
 
        MAKE_STD_ZVAL(obj);
2707
 
        MAKE_STD_ZVAL(_cPtr);
2708
 
        *_cPtr = *return_value;
2709
 
        INIT_ZVAL(*return_value);
2710
 
        object_init_ex(obj,ptr_ce_swig_Layer);
2711
 
        add_property_zval(obj,"_cPtr",_cPtr);
2712
 
        *return_value=*obj;
2713
 
    }
2714
 
    {
2715
 
        /* %typemap(freearg) char **options */
2716
 
        CSLDestroy( arg5 );
2717
 
    }
2718
 
    return;
2719
 
    fail:
2720
 
    {
2721
 
        /* %typemap(freearg) char **options */
2722
 
        CSLDestroy( arg5 );
2723
 
    }
2724
 
    zend_error(ErrorCode(),ErrorMsg());
 
2831
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
 
2832
  char *arg2 = (char *) 0 ;
 
2833
  OSRSpatialReferenceShadow *arg3 = (OSRSpatialReferenceShadow *) NULL ;
 
2834
  OGRwkbGeometryType arg4 = (OGRwkbGeometryType) wkbUnknown ;
 
2835
  char **arg5 = (char **) 0 ;
 
2836
  zval **args[5];
 
2837
  int arg_count;
 
2838
  OGRLayerShadow *result = 0 ;
 
2839
  
 
2840
  SWIG_ResetError();
 
2841
  arg_count = ZEND_NUM_ARGS();
 
2842
  if(arg_count<2 || arg_count>5 ||
 
2843
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
2844
  WRONG_PARAM_COUNT;
 
2845
  
 
2846
  {
 
2847
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
 
2848
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_CreateLayer. Expected SWIGTYPE_p_OGRDataSourceShadow");
 
2849
    }
 
2850
  }
 
2851
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
2852
  
 
2853
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
2854
  if ((*args[1])->type==IS_NULL) {
 
2855
    arg2 = (char *) 0;
 
2856
  } else {
 
2857
    convert_to_string_ex(args[1]);
 
2858
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
2859
  }
 
2860
  /*@SWIG@*/;
 
2861
  
 
2862
  if(arg_count > 2) {
 
2863
    {
 
2864
      if(SWIG_ConvertPtr(*args[2], (void **) &arg3, SWIGTYPE_p_OSRSpatialReferenceShadow, 0) < 0) {
 
2865
        SWIG_PHP_Error(E_ERROR, "Type error in argument 3 of DataSource_CreateLayer. Expected SWIGTYPE_p_OSRSpatialReferenceShadow");
 
2866
      }
 
2867
    }
 
2868
  }
 
2869
  if(arg_count > 3) {
 
2870
    /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
2871
    convert_to_long_ex(args[3]);
 
2872
    arg4 = (OGRwkbGeometryType) Z_LVAL_PP(args[3]);
 
2873
    /*@SWIG@*/;
 
2874
    
 
2875
  }
 
2876
  if(arg_count > 4) {
 
2877
    {
 
2878
      /* %typemap(in) char **options */
 
2879
      zend_error(E_ERROR,"Typemap (in) char **options not properly defined");
 
2880
      //  int size = PySequence_Size(args[4]);
 
2881
      //  for (int i = 0; i < size; i++) {
 
2882
      //    char *pszItem = NULL;
 
2883
      //    if ( ! PyArg_Parse( PySequence_GetItem(args[4],i), "s", &pszItem ) ) {
 
2884
      //      PyErr_SetString(PyExc_TypeError,"sequence must contain strings");
 
2885
      //      SWIG_fail;
 
2886
      //    }
 
2887
      //    arg5 = CSLAddString( arg5, pszItem );
 
2888
      //  }
 
2889
    }
 
2890
  }
 
2891
  {
 
2892
    if (!arg2) {
 
2893
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
2894
    }
 
2895
  }
 
2896
  result = (OGRLayerShadow *)OGRDataSourceShadow_CreateLayer(arg1,(char const *)arg2,arg3,arg4,arg5);
 
2897
  
 
2898
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRLayerShadow, 0);
 
2899
  
 
2900
  {
 
2901
    /* %typemap(freearg) char **options */
 
2902
    CSLDestroy( arg5 );
 
2903
  }
 
2904
  return;
 
2905
fail:
 
2906
  {
 
2907
    /* %typemap(freearg) char **options */
 
2908
    CSLDestroy( arg5 );
 
2909
  }
 
2910
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
2725
2911
}
2726
2912
 
2727
2913
 
2728
2914
ZEND_NAMED_FUNCTION(_wrap_DataSource_CopyLayer) {
2729
 
    OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
2730
 
    OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
2731
 
    char *arg3 = (char *) 0 ;
2732
 
    char **arg4 = (char **) 0 ;
2733
 
    OGRLayerShadow *result;
2734
 
    zval **args[3];
2735
 
    int arg_count;
2736
 
    
2737
 
    SWIG_ResetError();
2738
 
    /* This function uses a this_ptr*/
2739
 
    arg_count = ZEND_NUM_ARGS();
2740
 
    if(arg_count<3 || arg_count>4)
2741
 
    WRONG_PARAM_COUNT;
2742
 
    
2743
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
2744
 
    WRONG_PARAM_COUNT;
2745
 
    
2746
 
    {
2747
 
        /* typemap(in) SWIGTYPE * */
2748
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
2749
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_CopyLayer. Expected SWIGTYPE_p_p_OGRDataSourceShadow");
2750
 
        }
2751
 
    }
2752
 
    {
2753
 
        /* typemap(in) SWIGTYPE * */
2754
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
2755
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of DataSource_CopyLayer. Expected SWIGTYPE_p_p_OGRLayerShadow");
2756
 
        }
2757
 
    }
2758
 
    {
2759
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
2760
 
        convert_to_string_ex(args[1]);
2761
 
        arg3 = (char *) Z_STRVAL_PP(args[1]);
2762
 
        /*@@*/;
2763
 
    }
2764
 
    if(arg_count > 3) {
2765
 
        {
2766
 
            /* %typemap(in) char **options */
2767
 
            zend_error(E_ERROR,"Typemap (in) char **options not properly defined");
2768
 
            //  int size = PySequence_Size(args[2]);
2769
 
            //  for (int i = 0; i < size; i++) {
2770
 
            //    char *pszItem = NULL;
2771
 
            //    if ( ! PyArg_Parse( PySequence_GetItem(args[2],i), "s", &pszItem ) ) {
2772
 
            //      PyErr_SetString(PyExc_TypeError,"sequence must contain strings");
2773
 
            //      SWIG_fail;
2774
 
            //    }
2775
 
            //    arg4 = CSLAddString( arg4, pszItem );
2776
 
            //  }
2777
 
        }
2778
 
    }
2779
 
    result = (OGRLayerShadow *)OGRDataSourceShadow_CopyLayer(arg1,arg2,(char const *)arg3,arg4);
2780
 
    
2781
 
    {
2782
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRLayerShadow, 0);
2783
 
    }
2784
 
    /* Wrap this return value */
2785
 
    {
2786
 
        /* ALTERNATIVE Constructor, make an object wrapper */
2787
 
        zval *obj, *_cPtr;
2788
 
        MAKE_STD_ZVAL(obj);
2789
 
        MAKE_STD_ZVAL(_cPtr);
2790
 
        *_cPtr = *return_value;
2791
 
        INIT_ZVAL(*return_value);
2792
 
        object_init_ex(obj,ptr_ce_swig_Layer);
2793
 
        add_property_zval(obj,"_cPtr",_cPtr);
2794
 
        *return_value=*obj;
2795
 
    }
2796
 
    {
2797
 
        /* %typemap(freearg) char **options */
2798
 
        CSLDestroy( arg4 );
2799
 
    }
2800
 
    return;
2801
 
    fail:
2802
 
    {
2803
 
        /* %typemap(freearg) char **options */
2804
 
        CSLDestroy( arg4 );
2805
 
    }
2806
 
    zend_error(ErrorCode(),ErrorMsg());
 
2915
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
 
2916
  OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
 
2917
  char *arg3 = (char *) 0 ;
 
2918
  char **arg4 = (char **) 0 ;
 
2919
  zval **args[4];
 
2920
  int arg_count;
 
2921
  OGRLayerShadow *result = 0 ;
 
2922
  
 
2923
  SWIG_ResetError();
 
2924
  arg_count = ZEND_NUM_ARGS();
 
2925
  if(arg_count<3 || arg_count>4 ||
 
2926
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
2927
  WRONG_PARAM_COUNT;
 
2928
  
 
2929
  {
 
2930
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
 
2931
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_CopyLayer. Expected SWIGTYPE_p_OGRDataSourceShadow");
 
2932
    }
 
2933
  }
 
2934
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
2935
  {
 
2936
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
2937
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of DataSource_CopyLayer. Expected SWIGTYPE_p_OGRLayerShadow");
 
2938
    }
 
2939
  }
 
2940
  
 
2941
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
2942
  if ((*args[2])->type==IS_NULL) {
 
2943
    arg3 = (char *) 0;
 
2944
  } else {
 
2945
    convert_to_string_ex(args[2]);
 
2946
    arg3 = (char *) Z_STRVAL_PP(args[2]);
 
2947
  }
 
2948
  /*@SWIG@*/;
 
2949
  
 
2950
  if(arg_count > 3) {
 
2951
    {
 
2952
      /* %typemap(in) char **options */
 
2953
      zend_error(E_ERROR,"Typemap (in) char **options not properly defined");
 
2954
      //  int size = PySequence_Size(args[3]);
 
2955
      //  for (int i = 0; i < size; i++) {
 
2956
      //    char *pszItem = NULL;
 
2957
      //    if ( ! PyArg_Parse( PySequence_GetItem(args[3],i), "s", &pszItem ) ) {
 
2958
      //      PyErr_SetString(PyExc_TypeError,"sequence must contain strings");
 
2959
      //      SWIG_fail;
 
2960
      //    }
 
2961
      //    arg4 = CSLAddString( arg4, pszItem );
 
2962
      //  }
 
2963
    }
 
2964
  }
 
2965
  {
 
2966
    if (!arg2) {
 
2967
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
2968
    }
 
2969
  }
 
2970
  result = (OGRLayerShadow *)OGRDataSourceShadow_CopyLayer(arg1,arg2,(char const *)arg3,arg4);
 
2971
  
 
2972
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRLayerShadow, 0);
 
2973
  
 
2974
  {
 
2975
    /* %typemap(freearg) char **options */
 
2976
    CSLDestroy( arg4 );
 
2977
  }
 
2978
  return;
 
2979
fail:
 
2980
  {
 
2981
    /* %typemap(freearg) char **options */
 
2982
    CSLDestroy( arg4 );
 
2983
  }
 
2984
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
2807
2985
}
2808
2986
 
2809
2987
 
2810
2988
ZEND_NAMED_FUNCTION(_wrap_DataSource_GetLayerByIndex) {
2811
 
    OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
2812
 
    int arg2 = (int) 0 ;
2813
 
    OGRLayerShadow *result;
2814
 
    zval **args[1];
2815
 
    int arg_count;
2816
 
    
2817
 
    SWIG_ResetError();
2818
 
    /* This function uses a this_ptr*/
2819
 
    arg_count = ZEND_NUM_ARGS();
2820
 
    if(arg_count<1 || arg_count>2)
2821
 
    WRONG_PARAM_COUNT;
2822
 
    
2823
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
2824
 
    WRONG_PARAM_COUNT;
2825
 
    
2826
 
    {
2827
 
        /* typemap(in) SWIGTYPE * */
2828
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
2829
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_GetLayerByIndex. Expected SWIGTYPE_p_p_OGRDataSourceShadow");
2830
 
        }
2831
 
    }
2832
 
    if(arg_count > 1) {
2833
 
        {
2834
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
2835
 
            convert_to_long_ex(args[0]);
2836
 
            arg2 = (int) Z_LVAL_PP(args[0]);
2837
 
            /*@@*/;
2838
 
        }
2839
 
    }
2840
 
    result = (OGRLayerShadow *)OGRDataSourceShadow_GetLayerByIndex(arg1,arg2);
2841
 
    
2842
 
    {
2843
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRLayerShadow, 0);
2844
 
    }
2845
 
    /* Wrap this return value */
2846
 
    {
2847
 
        /* ALTERNATIVE Constructor, make an object wrapper */
2848
 
        zval *obj, *_cPtr;
2849
 
        MAKE_STD_ZVAL(obj);
2850
 
        MAKE_STD_ZVAL(_cPtr);
2851
 
        *_cPtr = *return_value;
2852
 
        INIT_ZVAL(*return_value);
2853
 
        object_init_ex(obj,ptr_ce_swig_Layer);
2854
 
        add_property_zval(obj,"_cPtr",_cPtr);
2855
 
        *return_value=*obj;
2856
 
    }
2857
 
    return;
2858
 
    fail:
2859
 
    zend_error(ErrorCode(),ErrorMsg());
 
2989
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
 
2990
  int arg2 = (int) 0 ;
 
2991
  zval **args[2];
 
2992
  int arg_count;
 
2993
  OGRLayerShadow *result = 0 ;
 
2994
  
 
2995
  SWIG_ResetError();
 
2996
  arg_count = ZEND_NUM_ARGS();
 
2997
  if(arg_count<1 || arg_count>2 ||
 
2998
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
2999
  WRONG_PARAM_COUNT;
 
3000
  
 
3001
  {
 
3002
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
 
3003
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_GetLayerByIndex. Expected SWIGTYPE_p_OGRDataSourceShadow");
 
3004
    }
 
3005
  }
 
3006
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3007
  if(arg_count > 1) {
 
3008
    /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
3009
    convert_to_long_ex(args[1]);
 
3010
    arg2 = (int) Z_LVAL_PP(args[1]);
 
3011
    /*@SWIG@*/;
 
3012
    
 
3013
  }
 
3014
  result = (OGRLayerShadow *)OGRDataSourceShadow_GetLayerByIndex(arg1,arg2);
 
3015
  
 
3016
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRLayerShadow, 0);
 
3017
  
 
3018
  return;
 
3019
fail:
 
3020
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
2860
3021
}
2861
3022
 
2862
3023
 
2863
3024
ZEND_NAMED_FUNCTION(_wrap_DataSource_GetLayerByName) {
2864
 
    OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
2865
 
    char *arg2 = (char *) 0 ;
2866
 
    OGRLayerShadow *result;
2867
 
    zval **args[1];
2868
 
    
2869
 
    SWIG_ResetError();
2870
 
    /* This function uses a this_ptr*/
2871
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
2872
 
        WRONG_PARAM_COUNT;
2873
 
    }
2874
 
    
2875
 
    {
2876
 
        /* typemap(in) SWIGTYPE * */
2877
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
2878
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_GetLayerByName. Expected SWIGTYPE_p_p_OGRDataSourceShadow");
2879
 
        }
2880
 
    }
2881
 
    {
2882
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
2883
 
        convert_to_string_ex(args[0]);
2884
 
        arg2 = (char *) Z_STRVAL_PP(args[0]);
2885
 
        /*@@*/;
2886
 
    }
2887
 
    result = (OGRLayerShadow *)OGRDataSourceShadow_GetLayerByName(arg1,(char const *)arg2);
2888
 
    
2889
 
    {
2890
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRLayerShadow, 0);
2891
 
    }
2892
 
    /* Wrap this return value */
2893
 
    {
2894
 
        /* ALTERNATIVE Constructor, make an object wrapper */
2895
 
        zval *obj, *_cPtr;
2896
 
        MAKE_STD_ZVAL(obj);
2897
 
        MAKE_STD_ZVAL(_cPtr);
2898
 
        *_cPtr = *return_value;
2899
 
        INIT_ZVAL(*return_value);
2900
 
        object_init_ex(obj,ptr_ce_swig_Layer);
2901
 
        add_property_zval(obj,"_cPtr",_cPtr);
2902
 
        *return_value=*obj;
2903
 
    }
2904
 
    return;
2905
 
    fail:
2906
 
    zend_error(ErrorCode(),ErrorMsg());
 
3025
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
 
3026
  char *arg2 = (char *) 0 ;
 
3027
  zval **args[2];
 
3028
  OGRLayerShadow *result = 0 ;
 
3029
  
 
3030
  SWIG_ResetError();
 
3031
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
3032
    WRONG_PARAM_COUNT;
 
3033
  }
 
3034
  
 
3035
  {
 
3036
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
 
3037
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_GetLayerByName. Expected SWIGTYPE_p_OGRDataSourceShadow");
 
3038
    }
 
3039
  }
 
3040
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3041
  
 
3042
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
3043
  if ((*args[1])->type==IS_NULL) {
 
3044
    arg2 = (char *) 0;
 
3045
  } else {
 
3046
    convert_to_string_ex(args[1]);
 
3047
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
3048
  }
 
3049
  /*@SWIG@*/;
 
3050
  
 
3051
  result = (OGRLayerShadow *)OGRDataSourceShadow_GetLayerByName(arg1,(char const *)arg2);
 
3052
  
 
3053
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRLayerShadow, 0);
 
3054
  
 
3055
  return;
 
3056
fail:
 
3057
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
2907
3058
}
2908
3059
 
2909
3060
 
2910
3061
ZEND_NAMED_FUNCTION(_wrap_DataSource_TestCapability) {
2911
 
    OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
2912
 
    char *arg2 = (char *) 0 ;
2913
 
    int result;
2914
 
    zval **args[1];
2915
 
    
2916
 
    SWIG_ResetError();
2917
 
    /* This function uses a this_ptr*/
2918
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
2919
 
        WRONG_PARAM_COUNT;
2920
 
    }
2921
 
    
2922
 
    {
2923
 
        /* typemap(in) SWIGTYPE * */
2924
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
2925
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_TestCapability. Expected SWIGTYPE_p_p_OGRDataSourceShadow");
2926
 
        }
2927
 
    }
2928
 
    {
2929
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
2930
 
        convert_to_string_ex(args[0]);
2931
 
        arg2 = (char *) Z_STRVAL_PP(args[0]);
2932
 
        /*@@*/;
2933
 
    }
2934
 
    result = (int)OGRDataSourceShadow_TestCapability(arg1,(char const *)arg2);
2935
 
    
2936
 
    {
2937
 
        ZVAL_LONG(return_value,result);
2938
 
    }
2939
 
    return;
2940
 
    fail:
2941
 
    zend_error(ErrorCode(),ErrorMsg());
 
3062
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
 
3063
  char *arg2 = (char *) 0 ;
 
3064
  zval **args[2];
 
3065
  bool result;
 
3066
  
 
3067
  SWIG_ResetError();
 
3068
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
3069
    WRONG_PARAM_COUNT;
 
3070
  }
 
3071
  
 
3072
  {
 
3073
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
 
3074
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_TestCapability. Expected SWIGTYPE_p_OGRDataSourceShadow");
 
3075
    }
 
3076
  }
 
3077
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3078
  
 
3079
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
3080
  if ((*args[1])->type==IS_NULL) {
 
3081
    arg2 = (char *) 0;
 
3082
  } else {
 
3083
    convert_to_string_ex(args[1]);
 
3084
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
3085
  }
 
3086
  /*@SWIG@*/;
 
3087
  
 
3088
  {
 
3089
    if (!arg2) {
 
3090
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
3091
    }
 
3092
  }
 
3093
  result = (bool)OGRDataSourceShadow_TestCapability(arg1,(char const *)arg2);
 
3094
  {
 
3095
    ZVAL_BOOL(return_value,(result)?1:0);
 
3096
  }
 
3097
  return;
 
3098
fail:
 
3099
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
2942
3100
}
2943
3101
 
2944
3102
 
2945
3103
ZEND_NAMED_FUNCTION(_wrap_DataSource_ExecuteSQL) {
2946
 
    OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
2947
 
    char *arg2 = (char *) 0 ;
2948
 
    OGRGeometryShadow *arg3 = (OGRGeometryShadow *) NULL ;
2949
 
    char *arg4 = (char *) "" ;
2950
 
    OGRLayerShadow *result;
2951
 
    zval **args[3];
2952
 
    int arg_count;
2953
 
    
2954
 
    SWIG_ResetError();
2955
 
    /* This function uses a this_ptr*/
2956
 
    arg_count = ZEND_NUM_ARGS();
2957
 
    if(arg_count<2 || arg_count>4)
2958
 
    WRONG_PARAM_COUNT;
2959
 
    
2960
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
2961
 
    WRONG_PARAM_COUNT;
2962
 
    
2963
 
    {
2964
 
        /* typemap(in) SWIGTYPE * */
2965
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
2966
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_ExecuteSQL. Expected SWIGTYPE_p_p_OGRDataSourceShadow");
2967
 
        }
2968
 
    }
2969
 
    {
2970
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
2971
 
        convert_to_string_ex(args[0]);
2972
 
        arg2 = (char *) Z_STRVAL_PP(args[0]);
2973
 
        /*@@*/;
2974
 
    }
2975
 
    if(arg_count > 2) {
2976
 
        {
2977
 
            /* typemap(in) SWIGTYPE * */
2978
 
            if(SWIG_ConvertPtr(*args[1], (void **) &arg3, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
2979
 
                SWIG_PHP_Error(E_ERROR, "Type error in argument 3 of DataSource_ExecuteSQL. Expected SWIGTYPE_p_p_OGRGeometryShadow");
2980
 
            }
2981
 
        }
2982
 
    }
2983
 
    if(arg_count > 3) {
2984
 
        {
2985
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
2986
 
            convert_to_string_ex(args[2]);
2987
 
            arg4 = (char *) Z_STRVAL_PP(args[2]);
2988
 
            /*@@*/;
2989
 
        }
2990
 
    }
2991
 
    result = (OGRLayerShadow *)OGRDataSourceShadow_ExecuteSQL(arg1,(char const *)arg2,arg3,(char const *)arg4);
2992
 
    
2993
 
    {
2994
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRLayerShadow, 1);
2995
 
    }
2996
 
    /* Wrap this return value */
2997
 
    {
2998
 
        /* ALTERNATIVE Constructor, make an object wrapper */
2999
 
        zval *obj, *_cPtr;
3000
 
        MAKE_STD_ZVAL(obj);
3001
 
        MAKE_STD_ZVAL(_cPtr);
3002
 
        *_cPtr = *return_value;
3003
 
        INIT_ZVAL(*return_value);
3004
 
        object_init_ex(obj,ptr_ce_swig_Layer);
3005
 
        add_property_zval(obj,"_cPtr",_cPtr);
3006
 
        *return_value=*obj;
3007
 
    }
3008
 
    return;
3009
 
    fail:
3010
 
    zend_error(ErrorCode(),ErrorMsg());
 
3104
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
 
3105
  char *arg2 = (char *) 0 ;
 
3106
  OGRGeometryShadow *arg3 = (OGRGeometryShadow *) NULL ;
 
3107
  char *arg4 = (char *) "" ;
 
3108
  zval **args[4];
 
3109
  int arg_count;
 
3110
  OGRLayerShadow *result = 0 ;
 
3111
  
 
3112
  SWIG_ResetError();
 
3113
  arg_count = ZEND_NUM_ARGS();
 
3114
  if(arg_count<2 || arg_count>4 ||
 
3115
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
3116
  WRONG_PARAM_COUNT;
 
3117
  
 
3118
  {
 
3119
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
 
3120
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_ExecuteSQL. Expected SWIGTYPE_p_OGRDataSourceShadow");
 
3121
    }
 
3122
  }
 
3123
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3124
  
 
3125
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
3126
  if ((*args[1])->type==IS_NULL) {
 
3127
    arg2 = (char *) 0;
 
3128
  } else {
 
3129
    convert_to_string_ex(args[1]);
 
3130
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
3131
  }
 
3132
  /*@SWIG@*/;
 
3133
  
 
3134
  if(arg_count > 2) {
 
3135
    {
 
3136
      if(SWIG_ConvertPtr(*args[2], (void **) &arg3, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
3137
        SWIG_PHP_Error(E_ERROR, "Type error in argument 3 of DataSource_ExecuteSQL. Expected SWIGTYPE_p_OGRGeometryShadow");
 
3138
      }
 
3139
    }
 
3140
  }
 
3141
  if(arg_count > 3) {
 
3142
    /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
3143
    if ((*args[3])->type==IS_NULL) {
 
3144
      arg4 = (char *) 0;
 
3145
    } else {
 
3146
      convert_to_string_ex(args[3]);
 
3147
      arg4 = (char *) Z_STRVAL_PP(args[3]);
 
3148
    }
 
3149
    /*@SWIG@*/;
 
3150
    
 
3151
  }
 
3152
  {
 
3153
    if (!arg2) {
 
3154
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
3155
    }
 
3156
  }
 
3157
  result = (OGRLayerShadow *)OGRDataSourceShadow_ExecuteSQL(arg1,(char const *)arg2,arg3,(char const *)arg4);
 
3158
  
 
3159
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRLayerShadow, 0);
 
3160
  
 
3161
  return;
 
3162
fail:
 
3163
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
3011
3164
}
3012
3165
 
3013
3166
 
3014
3167
ZEND_NAMED_FUNCTION(_wrap_DataSource_ReleaseResultSet) {
3015
 
    OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
3016
 
    OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
3017
 
    zval **args[1];
3018
 
    
3019
 
    SWIG_ResetError();
3020
 
    /* This function uses a this_ptr*/
3021
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
3022
 
        WRONG_PARAM_COUNT;
3023
 
    }
3024
 
    
3025
 
    {
3026
 
        /* typemap(in) SWIGTYPE * */
3027
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
3028
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_ReleaseResultSet. Expected SWIGTYPE_p_p_OGRDataSourceShadow");
3029
 
        }
3030
 
    }
3031
 
    {
3032
 
        /* typemap(in) SWIGTYPE *DISOWN */
3033
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRLayerShadow, SWIG_POINTER_DISOWN ) < 0) {
3034
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of DataSource_ReleaseResultSet. Expected SWIGTYPE_p_p_OGRLayerShadow");
3035
 
        }
3036
 
    }
3037
 
    OGRDataSourceShadow_ReleaseResultSet(arg1,arg2);
3038
 
    
3039
 
    
3040
 
    return;
3041
 
    fail:
3042
 
    zend_error(ErrorCode(),ErrorMsg());
3043
 
}
3044
 
 
3045
 
 
3046
 
/* property handler for class DataSource */
3047
 
static pval _wrap_propget_DataSource(zend_property_reference *property_reference) {
3048
 
  pval result;
3049
 
  pval **_result;
3050
 
  zend_llist_element *element = property_reference->elements_list->head;
3051
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
3052
 
  result.type = IS_NULL;
3053
 
  if (_propget_DataSource(property_reference, &result)==SUCCESS) return result;
3054
 
  /* return it ourselves */
3055
 
  if (zend_hash_find(Z_OBJPROP_P(property_reference->object),Z_STRVAL_P(&(property->element)),1+Z_STRLEN_P(&(property->element)),(void**)&_result)==SUCCESS) {
3056
 
  zval *_value;
3057
 
  MAKE_STD_ZVAL(_value);  *_value=**_result;
3058
 
  INIT_PZVAL(_value);
3059
 
  zval_copy_ctor(_value);
3060
 
  return *_value;
3061
 
  }
3062
 
  result.type = IS_NULL;
3063
 
  return result;
3064
 
}
3065
 
static int _propget_DataSource(zend_property_reference *property_reference, pval *value) {
3066
 
  /* get the property name */
3067
 
  zend_llist_element *element = property_reference->elements_list->head;
3068
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
3069
 
  char *propname=Z_STRVAL_P(&(property->element));
3070
 
  if (strcmp(propname,"name")==0) {
3071
 
    *value=_wrap_DataSource_name_get(property_reference);
3072
 
    return SUCCESS;
3073
 
  } else  return FAILURE;
3074
 
}
3075
 
 
3076
 
static int _wrap_propset_DataSource(zend_property_reference *property_reference, pval *value) { 
3077
 
  zval * _value;
3078
 
  zend_llist_element *element = property_reference->elements_list->head;
3079
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
3080
 
  if (_propset_DataSource(property_reference, value)==SUCCESS) return SUCCESS;
3081
 
  /* set it ourselves as it is DataSource */
3082
 
  MAKE_STD_ZVAL(_value);
3083
 
  *_value=*value;
3084
 
  INIT_PZVAL(_value);
3085
 
  zval_copy_ctor(_value);
3086
 
  return add_property_zval_ex(property_reference->object,Z_STRVAL_P(&(property->element)),1+Z_STRLEN_P(&(property->element)),_value);
3087
 
}
3088
 
static int _propset_DataSource(zend_property_reference *property_reference, pval *value) {
3089
 
  /* get the property name */
3090
 
  zend_llist_element *element = property_reference->elements_list->head;
3091
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
3092
 
  char *propname=Z_STRVAL_P(&(property->element));
3093
 
  return FAILURE;
3094
 
}
 
3168
  OGRDataSourceShadow *arg1 = (OGRDataSourceShadow *) 0 ;
 
3169
  OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
 
3170
  zval **args[2];
 
3171
  
 
3172
  SWIG_ResetError();
 
3173
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
3174
    WRONG_PARAM_COUNT;
 
3175
  }
 
3176
  
 
3177
  {
 
3178
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRDataSourceShadow, 0) < 0) {
 
3179
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of DataSource_ReleaseResultSet. Expected SWIGTYPE_p_OGRDataSourceShadow");
 
3180
    }
 
3181
  }
 
3182
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3183
  {
 
3184
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRLayerShadow, SWIG_POINTER_DISOWN ) < 0) {
 
3185
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of DataSource_ReleaseResultSet. Expected SWIGTYPE_p_p_OGRLayerShadow");
 
3186
    }
 
3187
  }
 
3188
  OGRDataSourceShadow_ReleaseResultSet(arg1,arg2);
 
3189
  
 
3190
  return;
 
3191
fail:
 
3192
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
3193
}
 
3194
 
3095
3195
 
3096
3196
ZEND_NAMED_FUNCTION(_wrap_Layer_GetRefCount) {
3097
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3098
 
    int result;
3099
 
    zval **args[0];
3100
 
    
3101
 
    SWIG_ResetError();
3102
 
    /* This function uses a this_ptr*/
3103
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
3104
 
        WRONG_PARAM_COUNT;
3105
 
    }
3106
 
    
3107
 
    {
3108
 
        /* typemap(in) SWIGTYPE * */
3109
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
3110
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_GetRefCount. Expected SWIGTYPE_p_p_OGRLayerShadow");
3111
 
        }
3112
 
    }
3113
 
    result = (int)OGRLayerShadow_GetRefCount(arg1);
3114
 
    
3115
 
    {
3116
 
        ZVAL_LONG(return_value,result);
3117
 
    }
3118
 
    return;
3119
 
    fail:
3120
 
    zend_error(ErrorCode(),ErrorMsg());
 
3197
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
3198
  zval **args[1];
 
3199
  int result;
 
3200
  
 
3201
  SWIG_ResetError();
 
3202
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
3203
    WRONG_PARAM_COUNT;
 
3204
  }
 
3205
  
 
3206
  {
 
3207
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
3208
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_GetRefCount. Expected SWIGTYPE_p_OGRLayerShadow");
 
3209
    }
 
3210
  }
 
3211
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3212
  result = (int)OGRLayerShadow_GetRefCount(arg1);
 
3213
  {
 
3214
    ZVAL_LONG(return_value,result);
 
3215
  }
 
3216
  return;
 
3217
fail:
 
3218
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
3121
3219
}
3122
3220
 
3123
3221
 
3124
3222
ZEND_NAMED_FUNCTION(_wrap_Layer_SetSpatialFilter) {
3125
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3126
 
    OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
3127
 
    zval **args[1];
3128
 
    
3129
 
    SWIG_ResetError();
3130
 
    /* This function uses a this_ptr*/
3131
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
3132
 
        WRONG_PARAM_COUNT;
3133
 
    }
3134
 
    
3135
 
    {
3136
 
        /* typemap(in) SWIGTYPE * */
3137
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
3138
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_SetSpatialFilter. Expected SWIGTYPE_p_p_OGRLayerShadow");
3139
 
        }
3140
 
    }
3141
 
    {
3142
 
        /* typemap(in) SWIGTYPE * */
3143
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
3144
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Layer_SetSpatialFilter. Expected SWIGTYPE_p_p_OGRGeometryShadow");
3145
 
        }
3146
 
    }
3147
 
    OGRLayerShadow_SetSpatialFilter(arg1,arg2);
3148
 
    
3149
 
    
3150
 
    return;
3151
 
    fail:
3152
 
    zend_error(ErrorCode(),ErrorMsg());
 
3223
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
3224
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
 
3225
  zval **args[2];
 
3226
  
 
3227
  SWIG_ResetError();
 
3228
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
3229
    WRONG_PARAM_COUNT;
 
3230
  }
 
3231
  
 
3232
  {
 
3233
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
3234
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_SetSpatialFilter. Expected SWIGTYPE_p_OGRLayerShadow");
 
3235
    }
 
3236
  }
 
3237
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3238
  {
 
3239
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
3240
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Layer_SetSpatialFilter. Expected SWIGTYPE_p_OGRGeometryShadow");
 
3241
    }
 
3242
  }
 
3243
  OGRLayerShadow_SetSpatialFilter(arg1,arg2);
 
3244
  
 
3245
  return;
 
3246
fail:
 
3247
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
3153
3248
}
3154
3249
 
3155
3250
 
3156
3251
ZEND_NAMED_FUNCTION(_wrap_Layer_SetSpatialFilterRect) {
3157
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3158
 
    double arg2 ;
3159
 
    double arg3 ;
3160
 
    double arg4 ;
3161
 
    double arg5 ;
3162
 
    zval **args[4];
3163
 
    
3164
 
    SWIG_ResetError();
3165
 
    /* This function uses a this_ptr*/
3166
 
    if(((ZEND_NUM_ARGS() )!= 4) || (zend_get_parameters_array_ex(4, args)!= SUCCESS)) {
3167
 
        WRONG_PARAM_COUNT;
3168
 
    }
3169
 
    
3170
 
    {
3171
 
        /* typemap(in) SWIGTYPE * */
3172
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
3173
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_SetSpatialFilterRect. Expected SWIGTYPE_p_p_OGRLayerShadow");
3174
 
        }
3175
 
    }
3176
 
    {
3177
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,13,CONVERT_FLOAT_IN@*/
3178
 
        convert_to_double_ex(args[0]);
3179
 
        arg2 = (double) Z_DVAL_PP(args[0]);
3180
 
        /*@@*/;
3181
 
    }
3182
 
    {
3183
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,13,CONVERT_FLOAT_IN@*/
3184
 
        convert_to_double_ex(args[1]);
3185
 
        arg3 = (double) Z_DVAL_PP(args[1]);
3186
 
        /*@@*/;
3187
 
    }
3188
 
    {
3189
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,13,CONVERT_FLOAT_IN@*/
3190
 
        convert_to_double_ex(args[2]);
3191
 
        arg4 = (double) Z_DVAL_PP(args[2]);
3192
 
        /*@@*/;
3193
 
    }
3194
 
    {
3195
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,13,CONVERT_FLOAT_IN@*/
3196
 
        convert_to_double_ex(args[3]);
3197
 
        arg5 = (double) Z_DVAL_PP(args[3]);
3198
 
        /*@@*/;
3199
 
    }
3200
 
    OGRLayerShadow_SetSpatialFilterRect(arg1,arg2,arg3,arg4,arg5);
3201
 
    
3202
 
    
3203
 
    return;
3204
 
    fail:
3205
 
    zend_error(ErrorCode(),ErrorMsg());
 
3252
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
3253
  double arg2 ;
 
3254
  double arg3 ;
 
3255
  double arg4 ;
 
3256
  double arg5 ;
 
3257
  zval **args[5];
 
3258
  
 
3259
  SWIG_ResetError();
 
3260
  if(ZEND_NUM_ARGS() != 5 || zend_get_parameters_array_ex(5, args) != SUCCESS) {
 
3261
    WRONG_PARAM_COUNT;
 
3262
  }
 
3263
  
 
3264
  {
 
3265
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
3266
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_SetSpatialFilterRect. Expected SWIGTYPE_p_OGRLayerShadow");
 
3267
    }
 
3268
  }
 
3269
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3270
  
 
3271
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
3272
  convert_to_double_ex(args[1]);
 
3273
  arg2 = (double) Z_DVAL_PP(args[1]);
 
3274
  /*@SWIG@*/;
 
3275
  
 
3276
  
 
3277
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
3278
  convert_to_double_ex(args[2]);
 
3279
  arg3 = (double) Z_DVAL_PP(args[2]);
 
3280
  /*@SWIG@*/;
 
3281
  
 
3282
  
 
3283
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
3284
  convert_to_double_ex(args[3]);
 
3285
  arg4 = (double) Z_DVAL_PP(args[3]);
 
3286
  /*@SWIG@*/;
 
3287
  
 
3288
  
 
3289
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
3290
  convert_to_double_ex(args[4]);
 
3291
  arg5 = (double) Z_DVAL_PP(args[4]);
 
3292
  /*@SWIG@*/;
 
3293
  
 
3294
  OGRLayerShadow_SetSpatialFilterRect(arg1,arg2,arg3,arg4,arg5);
 
3295
  
 
3296
  return;
 
3297
fail:
 
3298
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
3206
3299
}
3207
3300
 
3208
3301
 
3209
3302
ZEND_NAMED_FUNCTION(_wrap_Layer_GetSpatialFilter) {
3210
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3211
 
    OGRGeometryShadow *result;
3212
 
    zval **args[0];
3213
 
    
3214
 
    SWIG_ResetError();
3215
 
    /* This function uses a this_ptr*/
3216
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
3217
 
        WRONG_PARAM_COUNT;
3218
 
    }
3219
 
    
3220
 
    {
3221
 
        /* typemap(in) SWIGTYPE * */
3222
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
3223
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_GetSpatialFilter. Expected SWIGTYPE_p_p_OGRLayerShadow");
3224
 
        }
3225
 
    }
3226
 
    result = (OGRGeometryShadow *)OGRLayerShadow_GetSpatialFilter(arg1);
3227
 
    
3228
 
    {
3229
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 0);
3230
 
    }
3231
 
    /* Wrap this return value */
3232
 
    {
3233
 
        /* ALTERNATIVE Constructor, make an object wrapper */
3234
 
        zval *obj, *_cPtr;
3235
 
        MAKE_STD_ZVAL(obj);
3236
 
        MAKE_STD_ZVAL(_cPtr);
3237
 
        *_cPtr = *return_value;
3238
 
        INIT_ZVAL(*return_value);
3239
 
        object_init_ex(obj,ptr_ce_swig_Geometry);
3240
 
        add_property_zval(obj,"_cPtr",_cPtr);
3241
 
        *return_value=*obj;
3242
 
    }
3243
 
    return;
3244
 
    fail:
3245
 
    zend_error(ErrorCode(),ErrorMsg());
 
3303
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
3304
  zval **args[1];
 
3305
  OGRGeometryShadow *result = 0 ;
 
3306
  
 
3307
  SWIG_ResetError();
 
3308
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
3309
    WRONG_PARAM_COUNT;
 
3310
  }
 
3311
  
 
3312
  {
 
3313
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
3314
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_GetSpatialFilter. Expected SWIGTYPE_p_OGRLayerShadow");
 
3315
    }
 
3316
  }
 
3317
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3318
  result = (OGRGeometryShadow *)OGRLayerShadow_GetSpatialFilter(arg1);
 
3319
  
 
3320
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 0);
 
3321
  
 
3322
  return;
 
3323
fail:
 
3324
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
3246
3325
}
3247
3326
 
3248
3327
 
3249
3328
ZEND_NAMED_FUNCTION(_wrap_Layer_SetAttributeFilter) {
3250
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3251
 
    char *arg2 = (char *) 0 ;
3252
 
    OGRErr result;
3253
 
    zval **args[1];
3254
 
    
3255
 
    SWIG_ResetError();
3256
 
    /* This function uses a this_ptr*/
3257
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
3258
 
        WRONG_PARAM_COUNT;
3259
 
    }
3260
 
    
3261
 
    {
3262
 
        /* typemap(in) SWIGTYPE * */
3263
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
3264
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_SetAttributeFilter. Expected SWIGTYPE_p_p_OGRLayerShadow");
3265
 
        }
3266
 
    }
3267
 
    {
3268
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
3269
 
        convert_to_string_ex(args[0]);
3270
 
        arg2 = (char *) Z_STRVAL_PP(args[0]);
3271
 
        /*@@*/;
3272
 
    }
3273
 
    result = (OGRErr)OGRLayerShadow_SetAttributeFilter(arg1,arg2);
3274
 
    
3275
 
    {
3276
 
        /* %typemap(out) OGRErr */
3277
 
        if (result != 0 ) {
3278
 
            SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
3279
 
        }
3280
 
    }
3281
 
    {
3282
 
        /* %typemap(ret) OGRErr */
3283
 
        RETVAL_LONG(0);
3284
 
    }
3285
 
    return;
3286
 
    fail:
3287
 
    zend_error(ErrorCode(),ErrorMsg());
 
3329
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
3330
  char *arg2 = (char *) 0 ;
 
3331
  zval **args[2];
 
3332
  OGRErr result;
 
3333
  
 
3334
  SWIG_ResetError();
 
3335
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
3336
    WRONG_PARAM_COUNT;
 
3337
  }
 
3338
  
 
3339
  {
 
3340
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
3341
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_SetAttributeFilter. Expected SWIGTYPE_p_OGRLayerShadow");
 
3342
    }
 
3343
  }
 
3344
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3345
  
 
3346
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
3347
  if ((*args[1])->type==IS_NULL) {
 
3348
    arg2 = (char *) 0;
 
3349
  } else {
 
3350
    convert_to_string_ex(args[1]);
 
3351
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
3352
  }
 
3353
  /*@SWIG@*/;
 
3354
  
 
3355
  result = (OGRErr)OGRLayerShadow_SetAttributeFilter(arg1,arg2);
 
3356
  {
 
3357
    /* %typemap(out) OGRErr */
 
3358
    if (result != 0 ) {
 
3359
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
3360
    }
 
3361
  }
 
3362
  {
 
3363
    /* %typemap(ret) OGRErr */
 
3364
    RETVAL_LONG(0);
 
3365
  }
 
3366
  return;
 
3367
fail:
 
3368
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
3288
3369
}
3289
3370
 
3290
3371
 
3291
3372
ZEND_NAMED_FUNCTION(_wrap_Layer_ResetReading) {
3292
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3293
 
    zval **args[0];
3294
 
    
3295
 
    SWIG_ResetError();
3296
 
    /* This function uses a this_ptr*/
3297
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
3298
 
        WRONG_PARAM_COUNT;
3299
 
    }
3300
 
    
3301
 
    {
3302
 
        /* typemap(in) SWIGTYPE * */
3303
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
3304
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_ResetReading. Expected SWIGTYPE_p_p_OGRLayerShadow");
3305
 
        }
3306
 
    }
3307
 
    OGRLayerShadow_ResetReading(arg1);
3308
 
    
3309
 
    
3310
 
    return;
3311
 
    fail:
3312
 
    zend_error(ErrorCode(),ErrorMsg());
 
3373
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
3374
  zval **args[1];
 
3375
  
 
3376
  SWIG_ResetError();
 
3377
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
3378
    WRONG_PARAM_COUNT;
 
3379
  }
 
3380
  
 
3381
  {
 
3382
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
3383
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_ResetReading. Expected SWIGTYPE_p_OGRLayerShadow");
 
3384
    }
 
3385
  }
 
3386
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3387
  OGRLayerShadow_ResetReading(arg1);
 
3388
  
 
3389
  return;
 
3390
fail:
 
3391
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
3313
3392
}
3314
3393
 
3315
3394
 
3316
3395
ZEND_NAMED_FUNCTION(_wrap_Layer_GetName) {
3317
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3318
 
    char *result;
3319
 
    zval **args[0];
3320
 
    
3321
 
    SWIG_ResetError();
3322
 
    /* This function uses a this_ptr*/
3323
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
3324
 
        WRONG_PARAM_COUNT;
3325
 
    }
3326
 
    
3327
 
    {
3328
 
        /* typemap(in) SWIGTYPE * */
3329
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
3330
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_GetName. Expected SWIGTYPE_p_p_OGRLayerShadow");
3331
 
        }
3332
 
    }
3333
 
    result = (char *)OGRLayerShadow_GetName(arg1);
3334
 
    
3335
 
    {
3336
 
        if(!result) {
3337
 
            ZVAL_NULL(return_value);
3338
 
        } else {
3339
 
            ZVAL_STRING(return_value,result, 1);
3340
 
        }
3341
 
    }
3342
 
    return;
3343
 
    fail:
3344
 
    zend_error(ErrorCode(),ErrorMsg());
 
3396
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
3397
  zval **args[1];
 
3398
  char *result = 0 ;
 
3399
  
 
3400
  SWIG_ResetError();
 
3401
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
3402
    WRONG_PARAM_COUNT;
 
3403
  }
 
3404
  
 
3405
  {
 
3406
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
3407
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_GetName. Expected SWIGTYPE_p_OGRLayerShadow");
 
3408
    }
 
3409
  }
 
3410
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3411
  result = (char *)OGRLayerShadow_GetName(arg1);
 
3412
  {
 
3413
    if(!result) {
 
3414
      ZVAL_NULL(return_value);
 
3415
    } else {
 
3416
      ZVAL_STRING(return_value, (char *)result, 1);
 
3417
    }
 
3418
  }
 
3419
  return;
 
3420
fail:
 
3421
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
3422
}
 
3423
 
 
3424
 
 
3425
ZEND_NAMED_FUNCTION(_wrap_Layer_GetGeomType) {
 
3426
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
3427
  zval **args[1];
 
3428
  OGRwkbGeometryType result;
 
3429
  
 
3430
  SWIG_ResetError();
 
3431
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
3432
    WRONG_PARAM_COUNT;
 
3433
  }
 
3434
  
 
3435
  {
 
3436
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
3437
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_GetGeomType. Expected SWIGTYPE_p_OGRLayerShadow");
 
3438
    }
 
3439
  }
 
3440
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3441
  result = (OGRwkbGeometryType)OGRLayerShadow_GetGeomType(arg1);
 
3442
  {
 
3443
    ZVAL_LONG(return_value,result);
 
3444
  }
 
3445
  return;
 
3446
fail:
 
3447
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
3448
}
 
3449
 
 
3450
 
 
3451
ZEND_NAMED_FUNCTION(_wrap_Layer_GetGeometryColumn) {
 
3452
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
3453
  zval **args[1];
 
3454
  char *result = 0 ;
 
3455
  
 
3456
  SWIG_ResetError();
 
3457
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
3458
    WRONG_PARAM_COUNT;
 
3459
  }
 
3460
  
 
3461
  {
 
3462
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
3463
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_GetGeometryColumn. Expected SWIGTYPE_p_OGRLayerShadow");
 
3464
    }
 
3465
  }
 
3466
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3467
  result = (char *)OGRLayerShadow_GetGeometryColumn(arg1);
 
3468
  {
 
3469
    if(!result) {
 
3470
      ZVAL_NULL(return_value);
 
3471
    } else {
 
3472
      ZVAL_STRING(return_value, (char *)result, 1);
 
3473
    }
 
3474
  }
 
3475
  return;
 
3476
fail:
 
3477
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
3478
}
 
3479
 
 
3480
 
 
3481
ZEND_NAMED_FUNCTION(_wrap_Layer_GetFIDColumn) {
 
3482
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
3483
  zval **args[1];
 
3484
  char *result = 0 ;
 
3485
  
 
3486
  SWIG_ResetError();
 
3487
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
3488
    WRONG_PARAM_COUNT;
 
3489
  }
 
3490
  
 
3491
  {
 
3492
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
3493
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_GetFIDColumn. Expected SWIGTYPE_p_OGRLayerShadow");
 
3494
    }
 
3495
  }
 
3496
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3497
  result = (char *)OGRLayerShadow_GetFIDColumn(arg1);
 
3498
  {
 
3499
    if(!result) {
 
3500
      ZVAL_NULL(return_value);
 
3501
    } else {
 
3502
      ZVAL_STRING(return_value, (char *)result, 1);
 
3503
    }
 
3504
  }
 
3505
  return;
 
3506
fail:
 
3507
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
3345
3508
}
3346
3509
 
3347
3510
 
3348
3511
ZEND_NAMED_FUNCTION(_wrap_Layer_GetFeature) {
3349
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3350
 
    long arg2 ;
3351
 
    OGRFeatureShadow *result;
3352
 
    zval **args[1];
3353
 
    
3354
 
    SWIG_ResetError();
3355
 
    /* This function uses a this_ptr*/
3356
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
3357
 
        WRONG_PARAM_COUNT;
3358
 
    }
3359
 
    
3360
 
    {
3361
 
        /* typemap(in) SWIGTYPE * */
3362
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
3363
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_GetFeature. Expected SWIGTYPE_p_p_OGRLayerShadow");
3364
 
        }
3365
 
    }
3366
 
    {
3367
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
3368
 
        convert_to_long_ex(args[0]);
3369
 
        arg2 = (long) Z_LVAL_PP(args[0]);
3370
 
        /*@@*/;
3371
 
    }
3372
 
    result = (OGRFeatureShadow *)OGRLayerShadow_GetFeature(arg1,arg2);
3373
 
    
3374
 
    {
3375
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRFeatureShadow, 1);
3376
 
    }
3377
 
    /* Wrap this return value */
3378
 
    {
3379
 
        /* ALTERNATIVE Constructor, make an object wrapper */
3380
 
        zval *obj, *_cPtr;
3381
 
        MAKE_STD_ZVAL(obj);
3382
 
        MAKE_STD_ZVAL(_cPtr);
3383
 
        *_cPtr = *return_value;
3384
 
        INIT_ZVAL(*return_value);
3385
 
        object_init_ex(obj,ptr_ce_swig_Feature);
3386
 
        add_property_zval(obj,"_cPtr",_cPtr);
3387
 
        *return_value=*obj;
3388
 
    }
3389
 
    return;
3390
 
    fail:
3391
 
    zend_error(ErrorCode(),ErrorMsg());
 
3512
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
3513
  long arg2 ;
 
3514
  zval **args[2];
 
3515
  OGRFeatureShadow *result = 0 ;
 
3516
  
 
3517
  SWIG_ResetError();
 
3518
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
3519
    WRONG_PARAM_COUNT;
 
3520
  }
 
3521
  
 
3522
  {
 
3523
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
3524
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_GetFeature. Expected SWIGTYPE_p_OGRLayerShadow");
 
3525
    }
 
3526
  }
 
3527
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3528
  
 
3529
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
3530
  convert_to_long_ex(args[1]);
 
3531
  arg2 = (long) Z_LVAL_PP(args[1]);
 
3532
  /*@SWIG@*/;
 
3533
  
 
3534
  result = (OGRFeatureShadow *)OGRLayerShadow_GetFeature(arg1,arg2);
 
3535
  
 
3536
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRFeatureShadow, 1);
 
3537
  
 
3538
  return;
 
3539
fail:
 
3540
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
3392
3541
}
3393
3542
 
3394
3543
 
3395
3544
ZEND_NAMED_FUNCTION(_wrap_Layer_GetNextFeature) {
3396
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3397
 
    OGRFeatureShadow *result;
3398
 
    zval **args[0];
3399
 
    
3400
 
    SWIG_ResetError();
3401
 
    /* This function uses a this_ptr*/
3402
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
3403
 
        WRONG_PARAM_COUNT;
3404
 
    }
3405
 
    
3406
 
    {
3407
 
        /* typemap(in) SWIGTYPE * */
3408
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
3409
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_GetNextFeature. Expected SWIGTYPE_p_p_OGRLayerShadow");
3410
 
        }
3411
 
    }
3412
 
    result = (OGRFeatureShadow *)OGRLayerShadow_GetNextFeature(arg1);
3413
 
    
3414
 
    {
3415
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRFeatureShadow, 1);
3416
 
    }
3417
 
    /* Wrap this return value */
3418
 
    {
3419
 
        /* ALTERNATIVE Constructor, make an object wrapper */
3420
 
        zval *obj, *_cPtr;
3421
 
        MAKE_STD_ZVAL(obj);
3422
 
        MAKE_STD_ZVAL(_cPtr);
3423
 
        *_cPtr = *return_value;
3424
 
        INIT_ZVAL(*return_value);
3425
 
        object_init_ex(obj,ptr_ce_swig_Feature);
3426
 
        add_property_zval(obj,"_cPtr",_cPtr);
3427
 
        *return_value=*obj;
3428
 
    }
3429
 
    return;
3430
 
    fail:
3431
 
    zend_error(ErrorCode(),ErrorMsg());
 
3545
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
3546
  zval **args[1];
 
3547
  OGRFeatureShadow *result = 0 ;
 
3548
  
 
3549
  SWIG_ResetError();
 
3550
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
3551
    WRONG_PARAM_COUNT;
 
3552
  }
 
3553
  
 
3554
  {
 
3555
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
3556
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_GetNextFeature. Expected SWIGTYPE_p_OGRLayerShadow");
 
3557
    }
 
3558
  }
 
3559
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3560
  result = (OGRFeatureShadow *)OGRLayerShadow_GetNextFeature(arg1);
 
3561
  
 
3562
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRFeatureShadow, 1);
 
3563
  
 
3564
  return;
 
3565
fail:
 
3566
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
3432
3567
}
3433
3568
 
3434
3569
 
3435
3570
ZEND_NAMED_FUNCTION(_wrap_Layer_SetNextByIndex) {
3436
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3437
 
    long arg2 ;
3438
 
    OGRErr result;
3439
 
    zval **args[1];
3440
 
    
3441
 
    SWIG_ResetError();
3442
 
    /* This function uses a this_ptr*/
3443
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
3444
 
        WRONG_PARAM_COUNT;
3445
 
    }
3446
 
    
3447
 
    {
3448
 
        /* typemap(in) SWIGTYPE * */
3449
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
3450
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_SetNextByIndex. Expected SWIGTYPE_p_p_OGRLayerShadow");
3451
 
        }
3452
 
    }
3453
 
    {
3454
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
3455
 
        convert_to_long_ex(args[0]);
3456
 
        arg2 = (long) Z_LVAL_PP(args[0]);
3457
 
        /*@@*/;
3458
 
    }
3459
 
    result = (OGRErr)OGRLayerShadow_SetNextByIndex(arg1,arg2);
3460
 
    
3461
 
    {
3462
 
        /* %typemap(out) OGRErr */
3463
 
        if (result != 0 ) {
3464
 
            SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
3465
 
        }
3466
 
    }
3467
 
    {
3468
 
        /* %typemap(ret) OGRErr */
3469
 
        RETVAL_LONG(0);
3470
 
    }
3471
 
    return;
3472
 
    fail:
3473
 
    zend_error(ErrorCode(),ErrorMsg());
 
3571
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
3572
  long arg2 ;
 
3573
  zval **args[2];
 
3574
  OGRErr result;
 
3575
  
 
3576
  SWIG_ResetError();
 
3577
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
3578
    WRONG_PARAM_COUNT;
 
3579
  }
 
3580
  
 
3581
  {
 
3582
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
3583
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_SetNextByIndex. Expected SWIGTYPE_p_OGRLayerShadow");
 
3584
    }
 
3585
  }
 
3586
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3587
  
 
3588
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
3589
  convert_to_long_ex(args[1]);
 
3590
  arg2 = (long) Z_LVAL_PP(args[1]);
 
3591
  /*@SWIG@*/;
 
3592
  
 
3593
  result = (OGRErr)OGRLayerShadow_SetNextByIndex(arg1,arg2);
 
3594
  {
 
3595
    /* %typemap(out) OGRErr */
 
3596
    if (result != 0 ) {
 
3597
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
3598
    }
 
3599
  }
 
3600
  {
 
3601
    /* %typemap(ret) OGRErr */
 
3602
    RETVAL_LONG(0);
 
3603
  }
 
3604
  return;
 
3605
fail:
 
3606
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
3474
3607
}
3475
3608
 
3476
3609
 
3477
3610
ZEND_NAMED_FUNCTION(_wrap_Layer_SetFeature) {
3478
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3479
 
    OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
3480
 
    OGRErr result;
3481
 
    zval **args[1];
3482
 
    
3483
 
    SWIG_ResetError();
3484
 
    /* This function uses a this_ptr*/
3485
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
3486
 
        WRONG_PARAM_COUNT;
3487
 
    }
3488
 
    
3489
 
    {
3490
 
        /* typemap(in) SWIGTYPE * */
3491
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
3492
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_SetFeature. Expected SWIGTYPE_p_p_OGRLayerShadow");
3493
 
        }
3494
 
    }
3495
 
    {
3496
 
        /* typemap(in) SWIGTYPE * */
3497
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
3498
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Layer_SetFeature. Expected SWIGTYPE_p_p_OGRFeatureShadow");
3499
 
        }
3500
 
    }
3501
 
    result = (OGRErr)OGRLayerShadow_SetFeature(arg1,arg2);
3502
 
    
3503
 
    {
3504
 
        /* %typemap(out) OGRErr */
3505
 
        if (result != 0 ) {
3506
 
            SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
3507
 
        }
3508
 
    }
3509
 
    {
3510
 
        /* %typemap(ret) OGRErr */
3511
 
        RETVAL_LONG(0);
3512
 
    }
3513
 
    return;
3514
 
    fail:
3515
 
    zend_error(ErrorCode(),ErrorMsg());
 
3611
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
3612
  OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
 
3613
  zval **args[2];
 
3614
  OGRErr result;
 
3615
  
 
3616
  SWIG_ResetError();
 
3617
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
3618
    WRONG_PARAM_COUNT;
 
3619
  }
 
3620
  
 
3621
  {
 
3622
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
3623
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_SetFeature. Expected SWIGTYPE_p_OGRLayerShadow");
 
3624
    }
 
3625
  }
 
3626
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3627
  {
 
3628
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
3629
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Layer_SetFeature. Expected SWIGTYPE_p_OGRFeatureShadow");
 
3630
    }
 
3631
  }
 
3632
  {
 
3633
    if (!arg2) {
 
3634
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
3635
    }
 
3636
  }
 
3637
  result = (OGRErr)OGRLayerShadow_SetFeature(arg1,arg2);
 
3638
  {
 
3639
    /* %typemap(out) OGRErr */
 
3640
    if (result != 0 ) {
 
3641
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
3642
    }
 
3643
  }
 
3644
  {
 
3645
    /* %typemap(ret) OGRErr */
 
3646
    RETVAL_LONG(0);
 
3647
  }
 
3648
  return;
 
3649
fail:
 
3650
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
3516
3651
}
3517
3652
 
3518
3653
 
3519
3654
ZEND_NAMED_FUNCTION(_wrap_Layer_CreateFeature) {
3520
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3521
 
    OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
3522
 
    OGRErr result;
3523
 
    zval **args[1];
3524
 
    
3525
 
    SWIG_ResetError();
3526
 
    /* This function uses a this_ptr*/
3527
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
3528
 
        WRONG_PARAM_COUNT;
3529
 
    }
3530
 
    
3531
 
    {
3532
 
        /* typemap(in) SWIGTYPE * */
3533
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
3534
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_CreateFeature. Expected SWIGTYPE_p_p_OGRLayerShadow");
3535
 
        }
3536
 
    }
3537
 
    {
3538
 
        /* typemap(in) SWIGTYPE * */
3539
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
3540
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Layer_CreateFeature. Expected SWIGTYPE_p_p_OGRFeatureShadow");
3541
 
        }
3542
 
    }
3543
 
    result = (OGRErr)OGRLayerShadow_CreateFeature(arg1,arg2);
3544
 
    
3545
 
    {
3546
 
        /* %typemap(out) OGRErr */
3547
 
        if (result != 0 ) {
3548
 
            SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
3549
 
        }
3550
 
    }
3551
 
    {
3552
 
        /* %typemap(ret) OGRErr */
3553
 
        RETVAL_LONG(0);
3554
 
    }
3555
 
    return;
3556
 
    fail:
3557
 
    zend_error(ErrorCode(),ErrorMsg());
 
3655
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
3656
  OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
 
3657
  zval **args[2];
 
3658
  OGRErr result;
 
3659
  
 
3660
  SWIG_ResetError();
 
3661
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
3662
    WRONG_PARAM_COUNT;
 
3663
  }
 
3664
  
 
3665
  {
 
3666
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
3667
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_CreateFeature. Expected SWIGTYPE_p_OGRLayerShadow");
 
3668
    }
 
3669
  }
 
3670
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3671
  {
 
3672
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
3673
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Layer_CreateFeature. Expected SWIGTYPE_p_OGRFeatureShadow");
 
3674
    }
 
3675
  }
 
3676
  {
 
3677
    if (!arg2) {
 
3678
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
3679
    }
 
3680
  }
 
3681
  result = (OGRErr)OGRLayerShadow_CreateFeature(arg1,arg2);
 
3682
  {
 
3683
    /* %typemap(out) OGRErr */
 
3684
    if (result != 0 ) {
 
3685
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
3686
    }
 
3687
  }
 
3688
  {
 
3689
    /* %typemap(ret) OGRErr */
 
3690
    RETVAL_LONG(0);
 
3691
  }
 
3692
  return;
 
3693
fail:
 
3694
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
3558
3695
}
3559
3696
 
3560
3697
 
3561
3698
ZEND_NAMED_FUNCTION(_wrap_Layer_DeleteFeature) {
3562
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3563
 
    long arg2 ;
3564
 
    OGRErr result;
3565
 
    zval **args[1];
3566
 
    
3567
 
    SWIG_ResetError();
3568
 
    /* This function uses a this_ptr*/
3569
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
3570
 
        WRONG_PARAM_COUNT;
3571
 
    }
3572
 
    
3573
 
    {
3574
 
        /* typemap(in) SWIGTYPE * */
3575
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
3576
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_DeleteFeature. Expected SWIGTYPE_p_p_OGRLayerShadow");
3577
 
        }
3578
 
    }
3579
 
    {
3580
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
3581
 
        convert_to_long_ex(args[0]);
3582
 
        arg2 = (long) Z_LVAL_PP(args[0]);
3583
 
        /*@@*/;
3584
 
    }
3585
 
    result = (OGRErr)OGRLayerShadow_DeleteFeature(arg1,arg2);
3586
 
    
3587
 
    {
3588
 
        /* %typemap(out) OGRErr */
3589
 
        if (result != 0 ) {
3590
 
            SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
3591
 
        }
3592
 
    }
3593
 
    {
3594
 
        /* %typemap(ret) OGRErr */
3595
 
        RETVAL_LONG(0);
3596
 
    }
3597
 
    return;
3598
 
    fail:
3599
 
    zend_error(ErrorCode(),ErrorMsg());
 
3699
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
3700
  long arg2 ;
 
3701
  zval **args[2];
 
3702
  OGRErr result;
 
3703
  
 
3704
  SWIG_ResetError();
 
3705
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
3706
    WRONG_PARAM_COUNT;
 
3707
  }
 
3708
  
 
3709
  {
 
3710
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
3711
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_DeleteFeature. Expected SWIGTYPE_p_OGRLayerShadow");
 
3712
    }
 
3713
  }
 
3714
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3715
  
 
3716
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
3717
  convert_to_long_ex(args[1]);
 
3718
  arg2 = (long) Z_LVAL_PP(args[1]);
 
3719
  /*@SWIG@*/;
 
3720
  
 
3721
  result = (OGRErr)OGRLayerShadow_DeleteFeature(arg1,arg2);
 
3722
  {
 
3723
    /* %typemap(out) OGRErr */
 
3724
    if (result != 0 ) {
 
3725
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
3726
    }
 
3727
  }
 
3728
  {
 
3729
    /* %typemap(ret) OGRErr */
 
3730
    RETVAL_LONG(0);
 
3731
  }
 
3732
  return;
 
3733
fail:
 
3734
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
3600
3735
}
3601
3736
 
3602
3737
 
3603
3738
ZEND_NAMED_FUNCTION(_wrap_Layer_SyncToDisk) {
3604
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3605
 
    OGRErr result;
3606
 
    zval **args[0];
3607
 
    
3608
 
    SWIG_ResetError();
3609
 
    /* This function uses a this_ptr*/
3610
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
3611
 
        WRONG_PARAM_COUNT;
3612
 
    }
3613
 
    
3614
 
    {
3615
 
        /* typemap(in) SWIGTYPE * */
3616
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
3617
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_SyncToDisk. Expected SWIGTYPE_p_p_OGRLayerShadow");
3618
 
        }
3619
 
    }
3620
 
    result = (OGRErr)OGRLayerShadow_SyncToDisk(arg1);
3621
 
    
3622
 
    {
3623
 
        /* %typemap(out) OGRErr */
3624
 
        if (result != 0 ) {
3625
 
            SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
3626
 
        }
3627
 
    }
3628
 
    {
3629
 
        /* %typemap(ret) OGRErr */
3630
 
        RETVAL_LONG(0);
3631
 
    }
3632
 
    return;
3633
 
    fail:
3634
 
    zend_error(ErrorCode(),ErrorMsg());
 
3739
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
3740
  zval **args[1];
 
3741
  OGRErr result;
 
3742
  
 
3743
  SWIG_ResetError();
 
3744
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
3745
    WRONG_PARAM_COUNT;
 
3746
  }
 
3747
  
 
3748
  {
 
3749
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
3750
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_SyncToDisk. Expected SWIGTYPE_p_OGRLayerShadow");
 
3751
    }
 
3752
  }
 
3753
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3754
  result = (OGRErr)OGRLayerShadow_SyncToDisk(arg1);
 
3755
  {
 
3756
    /* %typemap(out) OGRErr */
 
3757
    if (result != 0 ) {
 
3758
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
3759
    }
 
3760
  }
 
3761
  {
 
3762
    /* %typemap(ret) OGRErr */
 
3763
    RETVAL_LONG(0);
 
3764
  }
 
3765
  return;
 
3766
fail:
 
3767
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
3635
3768
}
3636
3769
 
3637
3770
 
3638
3771
ZEND_NAMED_FUNCTION(_wrap_Layer_GetLayerDefn) {
3639
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3640
 
    OGRFeatureDefnShadow *result;
3641
 
    zval **args[0];
3642
 
    
3643
 
    SWIG_ResetError();
3644
 
    /* This function uses a this_ptr*/
3645
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
3646
 
        WRONG_PARAM_COUNT;
3647
 
    }
3648
 
    
3649
 
    {
3650
 
        /* typemap(in) SWIGTYPE * */
3651
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
3652
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_GetLayerDefn. Expected SWIGTYPE_p_p_OGRLayerShadow");
3653
 
        }
3654
 
    }
3655
 
    result = (OGRFeatureDefnShadow *)OGRLayerShadow_GetLayerDefn(arg1);
3656
 
    
3657
 
    {
3658
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRFeatureDefnShadow, 0);
3659
 
    }
3660
 
    /* Wrap this return value */
3661
 
    {
3662
 
        /* ALTERNATIVE Constructor, make an object wrapper */
3663
 
        zval *obj, *_cPtr;
3664
 
        MAKE_STD_ZVAL(obj);
3665
 
        MAKE_STD_ZVAL(_cPtr);
3666
 
        *_cPtr = *return_value;
3667
 
        INIT_ZVAL(*return_value);
3668
 
        object_init_ex(obj,ptr_ce_swig_FeatureDefn);
3669
 
        add_property_zval(obj,"_cPtr",_cPtr);
3670
 
        *return_value=*obj;
3671
 
    }
3672
 
    return;
3673
 
    fail:
3674
 
    zend_error(ErrorCode(),ErrorMsg());
 
3772
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
3773
  zval **args[1];
 
3774
  OGRFeatureDefnShadow *result = 0 ;
 
3775
  
 
3776
  SWIG_ResetError();
 
3777
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
3778
    WRONG_PARAM_COUNT;
 
3779
  }
 
3780
  
 
3781
  {
 
3782
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
3783
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_GetLayerDefn. Expected SWIGTYPE_p_OGRLayerShadow");
 
3784
    }
 
3785
  }
 
3786
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3787
  result = (OGRFeatureDefnShadow *)OGRLayerShadow_GetLayerDefn(arg1);
 
3788
  
 
3789
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRFeatureDefnShadow, 0);
 
3790
  
 
3791
  return;
 
3792
fail:
 
3793
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
3675
3794
}
3676
3795
 
3677
3796
 
3678
3797
ZEND_NAMED_FUNCTION(_wrap_Layer_GetFeatureCount) {
3679
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3680
 
    int arg2 = (int) 1 ;
3681
 
    int result;
3682
 
    zval **args[1];
3683
 
    int arg_count;
3684
 
    
3685
 
    SWIG_ResetError();
3686
 
    /* This function uses a this_ptr*/
3687
 
    arg_count = ZEND_NUM_ARGS();
3688
 
    if(arg_count<1 || arg_count>2)
3689
 
    WRONG_PARAM_COUNT;
3690
 
    
3691
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
3692
 
    WRONG_PARAM_COUNT;
3693
 
    
3694
 
    {
3695
 
        /* typemap(in) SWIGTYPE * */
3696
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
3697
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_GetFeatureCount. Expected SWIGTYPE_p_p_OGRLayerShadow");
3698
 
        }
3699
 
    }
3700
 
    if(arg_count > 1) {
3701
 
        {
3702
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
3703
 
            convert_to_long_ex(args[0]);
3704
 
            arg2 = (int) Z_LVAL_PP(args[0]);
3705
 
            /*@@*/;
3706
 
        }
3707
 
    }
3708
 
    result = (int)OGRLayerShadow_GetFeatureCount(arg1,arg2);
3709
 
    
3710
 
    {
3711
 
        ZVAL_LONG(return_value,result);
3712
 
    }
3713
 
    return;
3714
 
    fail:
3715
 
    zend_error(ErrorCode(),ErrorMsg());
 
3798
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
3799
  int arg2 = (int) 1 ;
 
3800
  zval **args[2];
 
3801
  int arg_count;
 
3802
  int result;
 
3803
  
 
3804
  SWIG_ResetError();
 
3805
  arg_count = ZEND_NUM_ARGS();
 
3806
  if(arg_count<1 || arg_count>2 ||
 
3807
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
3808
  WRONG_PARAM_COUNT;
 
3809
  
 
3810
  {
 
3811
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
3812
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_GetFeatureCount. Expected SWIGTYPE_p_OGRLayerShadow");
 
3813
    }
 
3814
  }
 
3815
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3816
  if(arg_count > 1) {
 
3817
    /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
3818
    convert_to_long_ex(args[1]);
 
3819
    arg2 = (int) Z_LVAL_PP(args[1]);
 
3820
    /*@SWIG@*/;
 
3821
    
 
3822
  }
 
3823
  result = (int)OGRLayerShadow_GetFeatureCount(arg1,arg2);
 
3824
  {
 
3825
    ZVAL_LONG(return_value,result);
 
3826
  }
 
3827
  return;
 
3828
fail:
 
3829
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
3716
3830
}
3717
3831
 
3718
3832
 
3719
3833
ZEND_NAMED_FUNCTION(_wrap_Layer_GetExtent) {
3720
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3721
 
    double *arg2 ;
3722
 
    int arg3 = (int) 1 ;
3723
 
    double argout2[4] ;
3724
 
    zval **args[1];
3725
 
    int arg_count;
3726
 
    
3727
 
    {
3728
 
        /* %typemap(in,numinputs=0) (double argout2[ANY]) */
3729
 
        arg2 = argout2;
3730
 
    }
3731
 
    SWIG_ResetError();
3732
 
    /* This function uses a this_ptr*/
3733
 
    arg_count = ZEND_NUM_ARGS();
3734
 
    if(arg_count<1 || arg_count>2)
3735
 
    WRONG_PARAM_COUNT;
3736
 
    
3737
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
3738
 
    WRONG_PARAM_COUNT;
3739
 
    
3740
 
    {
3741
 
        /* typemap(in) SWIGTYPE * */
3742
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
3743
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_GetExtent. Expected SWIGTYPE_p_p_OGRLayerShadow");
3744
 
        }
3745
 
    }
3746
 
    if(arg_count > 1) {
3747
 
        {
3748
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
3749
 
            convert_to_long_ex(args[0]);
3750
 
            arg3 = (int) Z_LVAL_PP(args[0]);
3751
 
            /*@@*/;
3752
 
        }
3753
 
    }
3754
 
    OGRLayerShadow_GetExtent(arg1,arg2,arg3);
3755
 
    
3756
 
    
3757
 
    {
3758
 
        /* %typemap(argout) (double argout[ANY]) */
3759
 
        zval *t = CreateTupleFromDoubleArray( arg2, 4 );
3760
 
        t_output_helper( &return_value, t );
3761
 
    }
3762
 
    return;
3763
 
    fail:
3764
 
    zend_error(ErrorCode(),ErrorMsg());
 
3834
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
3835
  double *arg2 ;
 
3836
  int arg3 = (int) 1 ;
 
3837
  double argout2[4] ;
 
3838
  zval **args[2];
 
3839
  int arg_count;
 
3840
  OGRErr result;
 
3841
  
 
3842
  {
 
3843
    /* %typemap(in,numinputs=0) (double argout2[ANY]) */
 
3844
    arg2 = argout2;
 
3845
  }
 
3846
  SWIG_ResetError();
 
3847
  arg_count = ZEND_NUM_ARGS();
 
3848
  if(arg_count<1 || arg_count>2 ||
 
3849
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
3850
  WRONG_PARAM_COUNT;
 
3851
  
 
3852
  {
 
3853
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
3854
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_GetExtent. Expected SWIGTYPE_p_OGRLayerShadow");
 
3855
    }
 
3856
  }
 
3857
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3858
  if(arg_count > 1) {
 
3859
    /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
3860
    convert_to_long_ex(args[1]);
 
3861
    arg3 = (int) Z_LVAL_PP(args[1]);
 
3862
    /*@SWIG@*/;
 
3863
    
 
3864
  }
 
3865
  result = (OGRErr)OGRLayerShadow_GetExtent(arg1,arg2,arg3);
 
3866
  {
 
3867
    /* %typemap(out) OGRErr */
 
3868
    if (result != 0 ) {
 
3869
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
3870
    }
 
3871
  }
 
3872
  {
 
3873
    /* %typemap(argout) (double argout[ANY]) */
 
3874
    zval *t = CreateTupleFromDoubleArray( arg2, 4 );
 
3875
    t_output_helper( &return_value, t );
 
3876
  }
 
3877
  {
 
3878
    /* %typemap(ret) OGRErr */
 
3879
    RETVAL_LONG(0);
 
3880
  }
 
3881
  return;
 
3882
fail:
 
3883
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
3765
3884
}
3766
3885
 
3767
3886
 
3768
3887
ZEND_NAMED_FUNCTION(_wrap_Layer_TestCapability) {
3769
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3770
 
    char *arg2 = (char *) 0 ;
3771
 
    int result;
3772
 
    zval **args[1];
3773
 
    
3774
 
    SWIG_ResetError();
3775
 
    /* This function uses a this_ptr*/
3776
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
3777
 
        WRONG_PARAM_COUNT;
3778
 
    }
3779
 
    
3780
 
    {
3781
 
        /* typemap(in) SWIGTYPE * */
3782
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
3783
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_TestCapability. Expected SWIGTYPE_p_p_OGRLayerShadow");
3784
 
        }
3785
 
    }
3786
 
    {
3787
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
3788
 
        convert_to_string_ex(args[0]);
3789
 
        arg2 = (char *) Z_STRVAL_PP(args[0]);
3790
 
        /*@@*/;
3791
 
    }
3792
 
    result = (int)OGRLayerShadow_TestCapability(arg1,(char const *)arg2);
3793
 
    
3794
 
    {
3795
 
        ZVAL_LONG(return_value,result);
3796
 
    }
3797
 
    return;
3798
 
    fail:
3799
 
    zend_error(ErrorCode(),ErrorMsg());
 
3888
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
3889
  char *arg2 = (char *) 0 ;
 
3890
  zval **args[2];
 
3891
  bool result;
 
3892
  
 
3893
  SWIG_ResetError();
 
3894
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
3895
    WRONG_PARAM_COUNT;
 
3896
  }
 
3897
  
 
3898
  {
 
3899
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
3900
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_TestCapability. Expected SWIGTYPE_p_OGRLayerShadow");
 
3901
    }
 
3902
  }
 
3903
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3904
  
 
3905
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
3906
  if ((*args[1])->type==IS_NULL) {
 
3907
    arg2 = (char *) 0;
 
3908
  } else {
 
3909
    convert_to_string_ex(args[1]);
 
3910
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
3911
  }
 
3912
  /*@SWIG@*/;
 
3913
  
 
3914
  {
 
3915
    if (!arg2) {
 
3916
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
3917
    }
 
3918
  }
 
3919
  result = (bool)OGRLayerShadow_TestCapability(arg1,(char const *)arg2);
 
3920
  {
 
3921
    ZVAL_BOOL(return_value,(result)?1:0);
 
3922
  }
 
3923
  return;
 
3924
fail:
 
3925
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
3800
3926
}
3801
3927
 
3802
3928
 
3803
3929
ZEND_NAMED_FUNCTION(_wrap_Layer_CreateField) {
3804
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3805
 
    OGRFieldDefnShadow *arg2 = (OGRFieldDefnShadow *) 0 ;
3806
 
    int arg3 = (int) 1 ;
3807
 
    OGRErr result;
3808
 
    zval **args[2];
3809
 
    int arg_count;
3810
 
    
3811
 
    SWIG_ResetError();
3812
 
    /* This function uses a this_ptr*/
3813
 
    arg_count = ZEND_NUM_ARGS();
3814
 
    if(arg_count<2 || arg_count>3)
3815
 
    WRONG_PARAM_COUNT;
3816
 
    
3817
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
3818
 
    WRONG_PARAM_COUNT;
3819
 
    
3820
 
    {
3821
 
        /* typemap(in) SWIGTYPE * */
3822
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
3823
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_CreateField. Expected SWIGTYPE_p_p_OGRLayerShadow");
3824
 
        }
3825
 
    }
3826
 
    {
3827
 
        /* typemap(in) SWIGTYPE * */
3828
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
3829
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Layer_CreateField. Expected SWIGTYPE_p_p_OGRFieldDefnShadow");
3830
 
        }
3831
 
    }
3832
 
    if(arg_count > 2) {
3833
 
        {
3834
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
3835
 
            convert_to_long_ex(args[1]);
3836
 
            arg3 = (int) Z_LVAL_PP(args[1]);
3837
 
            /*@@*/;
3838
 
        }
3839
 
    }
3840
 
    result = (OGRErr)OGRLayerShadow_CreateField(arg1,arg2,arg3);
3841
 
    
3842
 
    {
3843
 
        /* %typemap(out) OGRErr */
3844
 
        if (result != 0 ) {
3845
 
            SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
3846
 
        }
3847
 
    }
3848
 
    {
3849
 
        /* %typemap(ret) OGRErr */
3850
 
        RETVAL_LONG(0);
3851
 
    }
3852
 
    return;
3853
 
    fail:
3854
 
    zend_error(ErrorCode(),ErrorMsg());
 
3930
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
3931
  OGRFieldDefnShadow *arg2 = (OGRFieldDefnShadow *) 0 ;
 
3932
  int arg3 = (int) 1 ;
 
3933
  zval **args[3];
 
3934
  int arg_count;
 
3935
  OGRErr result;
 
3936
  
 
3937
  SWIG_ResetError();
 
3938
  arg_count = ZEND_NUM_ARGS();
 
3939
  if(arg_count<2 || arg_count>3 ||
 
3940
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
3941
  WRONG_PARAM_COUNT;
 
3942
  
 
3943
  {
 
3944
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
3945
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_CreateField. Expected SWIGTYPE_p_OGRLayerShadow");
 
3946
    }
 
3947
  }
 
3948
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3949
  {
 
3950
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
 
3951
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Layer_CreateField. Expected SWIGTYPE_p_OGRFieldDefnShadow");
 
3952
    }
 
3953
  }
 
3954
  if(arg_count > 2) {
 
3955
    /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
3956
    convert_to_long_ex(args[2]);
 
3957
    arg3 = (int) Z_LVAL_PP(args[2]);
 
3958
    /*@SWIG@*/;
 
3959
    
 
3960
  }
 
3961
  {
 
3962
    if (!arg2) {
 
3963
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
3964
    }
 
3965
  }
 
3966
  result = (OGRErr)OGRLayerShadow_CreateField(arg1,arg2,arg3);
 
3967
  {
 
3968
    /* %typemap(out) OGRErr */
 
3969
    if (result != 0 ) {
 
3970
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
3971
    }
 
3972
  }
 
3973
  {
 
3974
    /* %typemap(ret) OGRErr */
 
3975
    RETVAL_LONG(0);
 
3976
  }
 
3977
  return;
 
3978
fail:
 
3979
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
3855
3980
}
3856
3981
 
3857
3982
 
3858
3983
ZEND_NAMED_FUNCTION(_wrap_Layer_StartTransaction) {
3859
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3860
 
    OGRErr result;
3861
 
    zval **args[0];
3862
 
    
3863
 
    SWIG_ResetError();
3864
 
    /* This function uses a this_ptr*/
3865
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
3866
 
        WRONG_PARAM_COUNT;
3867
 
    }
3868
 
    
3869
 
    {
3870
 
        /* typemap(in) SWIGTYPE * */
3871
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
3872
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_StartTransaction. Expected SWIGTYPE_p_p_OGRLayerShadow");
3873
 
        }
3874
 
    }
3875
 
    result = (OGRErr)OGRLayerShadow_StartTransaction(arg1);
3876
 
    
3877
 
    {
3878
 
        /* %typemap(out) OGRErr */
3879
 
        if (result != 0 ) {
3880
 
            SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
3881
 
        }
3882
 
    }
3883
 
    {
3884
 
        /* %typemap(ret) OGRErr */
3885
 
        RETVAL_LONG(0);
3886
 
    }
3887
 
    return;
3888
 
    fail:
3889
 
    zend_error(ErrorCode(),ErrorMsg());
 
3984
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
3985
  zval **args[1];
 
3986
  OGRErr result;
 
3987
  
 
3988
  SWIG_ResetError();
 
3989
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
3990
    WRONG_PARAM_COUNT;
 
3991
  }
 
3992
  
 
3993
  {
 
3994
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
3995
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_StartTransaction. Expected SWIGTYPE_p_OGRLayerShadow");
 
3996
    }
 
3997
  }
 
3998
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
3999
  result = (OGRErr)OGRLayerShadow_StartTransaction(arg1);
 
4000
  {
 
4001
    /* %typemap(out) OGRErr */
 
4002
    if (result != 0 ) {
 
4003
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
4004
    }
 
4005
  }
 
4006
  {
 
4007
    /* %typemap(ret) OGRErr */
 
4008
    RETVAL_LONG(0);
 
4009
  }
 
4010
  return;
 
4011
fail:
 
4012
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
3890
4013
}
3891
4014
 
3892
4015
 
3893
4016
ZEND_NAMED_FUNCTION(_wrap_Layer_CommitTransaction) {
3894
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3895
 
    OGRErr result;
3896
 
    zval **args[0];
3897
 
    
3898
 
    SWIG_ResetError();
3899
 
    /* This function uses a this_ptr*/
3900
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
3901
 
        WRONG_PARAM_COUNT;
3902
 
    }
3903
 
    
3904
 
    {
3905
 
        /* typemap(in) SWIGTYPE * */
3906
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
3907
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_CommitTransaction. Expected SWIGTYPE_p_p_OGRLayerShadow");
3908
 
        }
3909
 
    }
3910
 
    result = (OGRErr)OGRLayerShadow_CommitTransaction(arg1);
3911
 
    
3912
 
    {
3913
 
        /* %typemap(out) OGRErr */
3914
 
        if (result != 0 ) {
3915
 
            SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
3916
 
        }
3917
 
    }
3918
 
    {
3919
 
        /* %typemap(ret) OGRErr */
3920
 
        RETVAL_LONG(0);
3921
 
    }
3922
 
    return;
3923
 
    fail:
3924
 
    zend_error(ErrorCode(),ErrorMsg());
 
4017
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
4018
  zval **args[1];
 
4019
  OGRErr result;
 
4020
  
 
4021
  SWIG_ResetError();
 
4022
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
4023
    WRONG_PARAM_COUNT;
 
4024
  }
 
4025
  
 
4026
  {
 
4027
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
4028
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_CommitTransaction. Expected SWIGTYPE_p_OGRLayerShadow");
 
4029
    }
 
4030
  }
 
4031
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
4032
  result = (OGRErr)OGRLayerShadow_CommitTransaction(arg1);
 
4033
  {
 
4034
    /* %typemap(out) OGRErr */
 
4035
    if (result != 0 ) {
 
4036
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
4037
    }
 
4038
  }
 
4039
  {
 
4040
    /* %typemap(ret) OGRErr */
 
4041
    RETVAL_LONG(0);
 
4042
  }
 
4043
  return;
 
4044
fail:
 
4045
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
3925
4046
}
3926
4047
 
3927
4048
 
3928
4049
ZEND_NAMED_FUNCTION(_wrap_Layer_RollbackTransaction) {
3929
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3930
 
    OGRErr result;
3931
 
    zval **args[0];
3932
 
    
3933
 
    SWIG_ResetError();
3934
 
    /* This function uses a this_ptr*/
3935
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
3936
 
        WRONG_PARAM_COUNT;
3937
 
    }
3938
 
    
3939
 
    {
3940
 
        /* typemap(in) SWIGTYPE * */
3941
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
3942
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_RollbackTransaction. Expected SWIGTYPE_p_p_OGRLayerShadow");
3943
 
        }
3944
 
    }
3945
 
    result = (OGRErr)OGRLayerShadow_RollbackTransaction(arg1);
3946
 
    
3947
 
    {
3948
 
        /* %typemap(out) OGRErr */
3949
 
        if (result != 0 ) {
3950
 
            SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
3951
 
        }
3952
 
    }
3953
 
    {
3954
 
        /* %typemap(ret) OGRErr */
3955
 
        RETVAL_LONG(0);
3956
 
    }
3957
 
    return;
3958
 
    fail:
3959
 
    zend_error(ErrorCode(),ErrorMsg());
 
4050
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
4051
  zval **args[1];
 
4052
  OGRErr result;
 
4053
  
 
4054
  SWIG_ResetError();
 
4055
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
4056
    WRONG_PARAM_COUNT;
 
4057
  }
 
4058
  
 
4059
  {
 
4060
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
4061
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_RollbackTransaction. Expected SWIGTYPE_p_OGRLayerShadow");
 
4062
    }
 
4063
  }
 
4064
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
4065
  result = (OGRErr)OGRLayerShadow_RollbackTransaction(arg1);
 
4066
  {
 
4067
    /* %typemap(out) OGRErr */
 
4068
    if (result != 0 ) {
 
4069
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
4070
    }
 
4071
  }
 
4072
  {
 
4073
    /* %typemap(ret) OGRErr */
 
4074
    RETVAL_LONG(0);
 
4075
  }
 
4076
  return;
 
4077
fail:
 
4078
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
3960
4079
}
3961
4080
 
3962
4081
 
3963
4082
ZEND_NAMED_FUNCTION(_wrap_Layer_GetSpatialRef) {
3964
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
3965
 
    OSRSpatialReferenceShadow *result;
3966
 
    zval **args[0];
3967
 
    
3968
 
    SWIG_ResetError();
3969
 
    /* This function uses a this_ptr*/
3970
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
3971
 
        WRONG_PARAM_COUNT;
3972
 
    }
3973
 
    
3974
 
    {
3975
 
        /* typemap(in) SWIGTYPE * */
3976
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
3977
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_GetSpatialRef. Expected SWIGTYPE_p_p_OGRLayerShadow");
3978
 
        }
3979
 
    }
3980
 
    result = (OSRSpatialReferenceShadow *)OGRLayerShadow_GetSpatialRef(arg1);
3981
 
    
3982
 
    {
3983
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OSRSpatialReferenceShadow, 0);
3984
 
    }
3985
 
    /* Wrap this return value */
3986
 
    {
3987
 
        /* ALTERNATIVE Constructor, make an object wrapper */
3988
 
        zval *obj, *_cPtr;
3989
 
        MAKE_STD_ZVAL(obj);
3990
 
        MAKE_STD_ZVAL(_cPtr);
3991
 
        *_cPtr = *return_value;
3992
 
        INIT_ZVAL(*return_value);
3993
 
        object_init_ex(obj,ptr_ce_swig_SpatialReference);
3994
 
        add_property_zval(obj,"_cPtr",_cPtr);
3995
 
        *return_value=*obj;
3996
 
    }
3997
 
    return;
3998
 
    fail:
3999
 
    zend_error(ErrorCode(),ErrorMsg());
4000
 
}
4001
 
 
4002
 
 
4003
 
ZEND_NAMED_FUNCTION(_wrap_Layer_GetFeatureRead) {
4004
 
    OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
4005
 
    GIntBig result;
4006
 
    zval **args[0];
4007
 
    
4008
 
    SWIG_ResetError();
4009
 
    /* This function uses a this_ptr*/
4010
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
4011
 
        WRONG_PARAM_COUNT;
4012
 
    }
4013
 
    
4014
 
    {
4015
 
        /* typemap(in) SWIGTYPE * */
4016
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
4017
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_GetFeatureRead. Expected SWIGTYPE_p_p_OGRLayerShadow");
4018
 
        }
4019
 
    }
4020
 
    result = OGRLayerShadow_GetFeatureRead(arg1);
4021
 
    
4022
 
    {
4023
 
        GIntBig * resultobj = new GIntBig((GIntBig &) result);
4024
 
        SWIG_SetPointerZval(return_value, (void *)resultobj, SWIGTYPE_p_GIntBig, 1);
4025
 
    }
4026
 
    return;
4027
 
    fail:
4028
 
    zend_error(ErrorCode(),ErrorMsg());
4029
 
}
4030
 
 
4031
 
 
4032
 
/* property handler for class Layer */
4033
 
static pval _wrap_propget_Layer(zend_property_reference *property_reference) {
4034
 
  pval result;
4035
 
  pval **_result;
4036
 
  zend_llist_element *element = property_reference->elements_list->head;
4037
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
4038
 
  result.type = IS_NULL;
4039
 
  if (_propget_Layer(property_reference, &result)==SUCCESS) return result;
4040
 
  /* return it ourselves */
4041
 
  if (zend_hash_find(Z_OBJPROP_P(property_reference->object),Z_STRVAL_P(&(property->element)),1+Z_STRLEN_P(&(property->element)),(void**)&_result)==SUCCESS) {
4042
 
  zval *_value;
4043
 
  MAKE_STD_ZVAL(_value);  *_value=**_result;
4044
 
  INIT_PZVAL(_value);
4045
 
  zval_copy_ctor(_value);
4046
 
  return *_value;
4047
 
  }
4048
 
  result.type = IS_NULL;
4049
 
  return result;
4050
 
}
4051
 
static int _propget_Layer(zend_property_reference *property_reference, pval *value) {
4052
 
  /* get the property name */
4053
 
  zend_llist_element *element = property_reference->elements_list->head;
4054
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
4055
 
  char *propname=Z_STRVAL_P(&(property->element));
4056
 
  return FAILURE;
4057
 
}
4058
 
 
4059
 
static int _wrap_propset_Layer(zend_property_reference *property_reference, pval *value) { 
4060
 
  zval * _value;
4061
 
  zend_llist_element *element = property_reference->elements_list->head;
4062
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
4063
 
  if (_propset_Layer(property_reference, value)==SUCCESS) return SUCCESS;
4064
 
  /* set it ourselves as it is Layer */
4065
 
  MAKE_STD_ZVAL(_value);
4066
 
  *_value=*value;
4067
 
  INIT_PZVAL(_value);
4068
 
  zval_copy_ctor(_value);
4069
 
  return add_property_zval_ex(property_reference->object,Z_STRVAL_P(&(property->element)),1+Z_STRLEN_P(&(property->element)),_value);
4070
 
}
4071
 
static int _propset_Layer(zend_property_reference *property_reference, pval *value) {
4072
 
  /* get the property name */
4073
 
  zend_llist_element *element = property_reference->elements_list->head;
4074
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
4075
 
  char *propname=Z_STRVAL_P(&(property->element));
4076
 
  return FAILURE;
4077
 
}
 
4083
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
4084
  zval **args[1];
 
4085
  OSRSpatialReferenceShadow *result = 0 ;
 
4086
  
 
4087
  SWIG_ResetError();
 
4088
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
4089
    WRONG_PARAM_COUNT;
 
4090
  }
 
4091
  
 
4092
  {
 
4093
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
4094
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_GetSpatialRef. Expected SWIGTYPE_p_OGRLayerShadow");
 
4095
    }
 
4096
  }
 
4097
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
4098
  result = (OSRSpatialReferenceShadow *)OGRLayerShadow_GetSpatialRef(arg1);
 
4099
  
 
4100
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OSRSpatialReferenceShadow, 1);
 
4101
  
 
4102
  return;
 
4103
fail:
 
4104
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
4105
}
 
4106
 
 
4107
 
 
4108
ZEND_NAMED_FUNCTION(_wrap_Layer_GetFeaturesRead) {
 
4109
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
4110
  zval **args[1];
 
4111
  GIntBig result;
 
4112
  
 
4113
  SWIG_ResetError();
 
4114
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
4115
    WRONG_PARAM_COUNT;
 
4116
  }
 
4117
  
 
4118
  {
 
4119
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
4120
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_GetFeaturesRead. Expected SWIGTYPE_p_OGRLayerShadow");
 
4121
    }
 
4122
  }
 
4123
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
4124
  result = OGRLayerShadow_GetFeaturesRead(arg1);
 
4125
  {
 
4126
    GIntBig * resultobj = new GIntBig((const GIntBig &) result);
 
4127
    SWIG_SetPointerZval(return_value, (void *)resultobj, SWIGTYPE_p_GIntBig, 1);
 
4128
  }
 
4129
  return;
 
4130
fail:
 
4131
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
4132
}
 
4133
 
 
4134
 
 
4135
ZEND_NAMED_FUNCTION(_wrap_Layer_SetIgnoredFields) {
 
4136
  OGRLayerShadow *arg1 = (OGRLayerShadow *) 0 ;
 
4137
  char **arg2 = (char **) 0 ;
 
4138
  zval **args[2];
 
4139
  OGRErr result;
 
4140
  
 
4141
  SWIG_ResetError();
 
4142
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
4143
    WRONG_PARAM_COUNT;
 
4144
  }
 
4145
  
 
4146
  {
 
4147
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRLayerShadow, 0) < 0) {
 
4148
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Layer_SetIgnoredFields. Expected SWIGTYPE_p_OGRLayerShadow");
 
4149
    }
 
4150
  }
 
4151
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
4152
  {
 
4153
    /* %typemap(in) char **options */
 
4154
    zend_error(E_ERROR,"Typemap (in) char **options not properly defined");
 
4155
    //  int size = PySequence_Size(args[1]);
 
4156
    //  for (int i = 0; i < size; i++) {
 
4157
    //    char *pszItem = NULL;
 
4158
    //    if ( ! PyArg_Parse( PySequence_GetItem(args[1],i), "s", &pszItem ) ) {
 
4159
    //      PyErr_SetString(PyExc_TypeError,"sequence must contain strings");
 
4160
    //      SWIG_fail;
 
4161
    //    }
 
4162
    //    arg2 = CSLAddString( arg2, pszItem );
 
4163
    //  }
 
4164
  }
 
4165
  result = (OGRErr)OGRLayerShadow_SetIgnoredFields(arg1,(char const **)arg2);
 
4166
  {
 
4167
    /* %typemap(out) OGRErr */
 
4168
    if (result != 0 ) {
 
4169
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
4170
    }
 
4171
  }
 
4172
  {
 
4173
    /* %typemap(freearg) char **options */
 
4174
    CSLDestroy( arg2 );
 
4175
  }
 
4176
  {
 
4177
    /* %typemap(ret) OGRErr */
 
4178
    RETVAL_LONG(0);
 
4179
  }
 
4180
  return;
 
4181
fail:
 
4182
  {
 
4183
    /* %typemap(freearg) char **options */
 
4184
    CSLDestroy( arg2 );
 
4185
  }
 
4186
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
4187
}
 
4188
 
4078
4189
 
4079
4190
/* This function is designed to be called by the zend list destructors */
4080
4191
/* to typecast and do the actual destruction */
4081
 
void __wrap_delete_Feature(zend_rsrc_list_entry *rsrc, const char *type_name TSRMLS_DC) {
4082
 
    swig_object_wrapper *value=(swig_object_wrapper *) rsrc->ptr ;
4083
 
    void *ptr=value->ptr ;
4084
 
    int newobject=value->newobject ;
4085
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4086
 
    
4087
 
    efree(value);
4088
 
    if (! newobject) return; /* can't delete it! */
4089
 
    SWIG_ZTS_ConvertResourceData(ptr,rsrc->type,type_name,(void **) &arg1,SWIGTYPE_p_OGRFeatureShadow TSRMLS_CC);
4090
 
    if (! arg1) zend_error(E_ERROR, "OGRFeatureShadow resource already free'd");
4091
 
    delete_OGRFeatureShadow(arg1);
4092
 
    
 
4192
static void __wrap_delete_Feature(zend_rsrc_list_entry *rsrc, const char *type_name TSRMLS_DC) {
 
4193
  swig_object_wrapper *value=(swig_object_wrapper *) rsrc->ptr ;
 
4194
  void *ptr=value->ptr ;
 
4195
  int newobject=value->newobject ;
 
4196
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
4197
  
 
4198
  efree(value);
 
4199
  if (! newobject) return; /* can't delete it! */
 
4200
  arg1 = (OGRFeatureShadow *)SWIG_ZTS_ConvertResourceData(ptr,type_name,SWIGTYPE_p_OGRFeatureShadow TSRMLS_CC);
 
4201
  if (! arg1) zend_error(E_ERROR, "OGRFeatureShadow resource already free'd");
 
4202
  delete_OGRFeatureShadow(arg1);
 
4203
  return;
 
4204
fail:
 
4205
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
4093
4206
}
4094
4207
 
4095
4208
 
4096
4209
ZEND_NAMED_FUNCTION(_wrap_new_Feature) {
4097
 
    OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
4098
 
    OGRFeatureShadow *result;
4099
 
    zval **args[1];
4100
 
    int arg_count;
4101
 
    
4102
 
    SWIG_ResetError();
4103
 
    /* NATIVE Constructor */
4104
 
    arg_count = ZEND_NUM_ARGS();
4105
 
    if(arg_count<0 || arg_count>1)
4106
 
    WRONG_PARAM_COUNT;
4107
 
    
4108
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
4109
 
    WRONG_PARAM_COUNT;
4110
 
    
4111
 
    if(arg_count > 0) {
4112
 
        {
4113
 
            /* typemap(in) SWIGTYPE * */
4114
 
            if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureDefnShadow, 0) < 0) {
4115
 
                SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of new_Feature. Expected SWIGTYPE_p_p_OGRFeatureDefnShadow");
4116
 
            }
4117
 
        }
4118
 
    }
4119
 
    result = (OGRFeatureShadow *)new_OGRFeatureShadow(arg1);
4120
 
    
4121
 
    {
4122
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRFeatureShadow, 1);
4123
 
    }
4124
 
    /* Wrap this return value */
4125
 
    if (this_ptr) {
4126
 
        /* NATIVE Constructor, use this_ptr */
4127
 
        zval *_cPtr; MAKE_STD_ZVAL(_cPtr);
4128
 
        *_cPtr = *return_value;
4129
 
        INIT_ZVAL(*return_value);
4130
 
        add_property_zval(this_ptr,"_cPtr",_cPtr);
4131
 
    } else if (! this_ptr) {
4132
 
        /* ALTERNATIVE Constructor, make an object wrapper */
4133
 
        zval *obj, *_cPtr;
4134
 
        MAKE_STD_ZVAL(obj);
4135
 
        MAKE_STD_ZVAL(_cPtr);
4136
 
        *_cPtr = *return_value;
4137
 
        INIT_ZVAL(*return_value);
4138
 
        object_init_ex(obj,ptr_ce_swig_Feature);
4139
 
        add_property_zval(obj,"_cPtr",_cPtr);
4140
 
        *return_value=*obj;
4141
 
    }
4142
 
    return;
4143
 
    fail:
4144
 
    zend_error(ErrorCode(),ErrorMsg());
 
4210
  OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
 
4211
  zval **args[1];
 
4212
  OGRFeatureShadow *result = 0 ;
 
4213
  
 
4214
  SWIG_ResetError();
 
4215
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
4216
    WRONG_PARAM_COUNT;
 
4217
  }
 
4218
  
 
4219
  {
 
4220
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureDefnShadow, 0) < 0) {
 
4221
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of new_Feature. Expected SWIGTYPE_p_OGRFeatureDefnShadow");
 
4222
    }
 
4223
  }
 
4224
  {
 
4225
    if (!arg1) {
 
4226
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
4227
    }
 
4228
  }
 
4229
  result = (OGRFeatureShadow *)new_OGRFeatureShadow(arg1);
 
4230
  
 
4231
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRFeatureShadow, 1);
 
4232
  
 
4233
  return;
 
4234
fail:
 
4235
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
4145
4236
}
4146
4237
 
4147
4238
 
4148
4239
ZEND_NAMED_FUNCTION(_wrap_Feature_GetDefnRef) {
4149
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4150
 
    OGRFeatureDefnShadow *result;
4151
 
    zval **args[0];
4152
 
    
4153
 
    SWIG_ResetError();
4154
 
    /* This function uses a this_ptr*/
4155
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
4156
 
        WRONG_PARAM_COUNT;
4157
 
    }
4158
 
    
4159
 
    {
4160
 
        /* typemap(in) SWIGTYPE * */
4161
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
4162
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetDefnRef. Expected SWIGTYPE_p_p_OGRFeatureShadow");
4163
 
        }
4164
 
    }
4165
 
    result = (OGRFeatureDefnShadow *)OGRFeatureShadow_GetDefnRef(arg1);
4166
 
    
4167
 
    {
4168
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRFeatureDefnShadow, 0);
4169
 
    }
4170
 
    /* Wrap this return value */
4171
 
    {
4172
 
        /* ALTERNATIVE Constructor, make an object wrapper */
4173
 
        zval *obj, *_cPtr;
4174
 
        MAKE_STD_ZVAL(obj);
4175
 
        MAKE_STD_ZVAL(_cPtr);
4176
 
        *_cPtr = *return_value;
4177
 
        INIT_ZVAL(*return_value);
4178
 
        object_init_ex(obj,ptr_ce_swig_FeatureDefn);
4179
 
        add_property_zval(obj,"_cPtr",_cPtr);
4180
 
        *return_value=*obj;
4181
 
    }
4182
 
    return;
4183
 
    fail:
4184
 
    zend_error(ErrorCode(),ErrorMsg());
 
4240
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
4241
  zval **args[1];
 
4242
  OGRFeatureDefnShadow *result = 0 ;
 
4243
  
 
4244
  SWIG_ResetError();
 
4245
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
4246
    WRONG_PARAM_COUNT;
 
4247
  }
 
4248
  
 
4249
  {
 
4250
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
4251
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetDefnRef. Expected SWIGTYPE_p_OGRFeatureShadow");
 
4252
    }
 
4253
  }
 
4254
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
4255
  result = (OGRFeatureDefnShadow *)OGRFeatureShadow_GetDefnRef(arg1);
 
4256
  
 
4257
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRFeatureDefnShadow, 0);
 
4258
  
 
4259
  return;
 
4260
fail:
 
4261
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
4185
4262
}
4186
4263
 
4187
4264
 
4188
4265
ZEND_NAMED_FUNCTION(_wrap_Feature_SetGeometry) {
4189
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4190
 
    OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
4191
 
    OGRErr result;
4192
 
    zval **args[1];
4193
 
    
4194
 
    SWIG_ResetError();
4195
 
    /* This function uses a this_ptr*/
4196
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
4197
 
        WRONG_PARAM_COUNT;
4198
 
    }
4199
 
    
4200
 
    {
4201
 
        /* typemap(in) SWIGTYPE * */
4202
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
4203
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_SetGeometry. Expected SWIGTYPE_p_p_OGRFeatureShadow");
4204
 
        }
4205
 
    }
4206
 
    {
4207
 
        /* typemap(in) SWIGTYPE * */
4208
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
4209
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Feature_SetGeometry. Expected SWIGTYPE_p_p_OGRGeometryShadow");
4210
 
        }
4211
 
    }
4212
 
    result = (OGRErr)OGRFeatureShadow_SetGeometry(arg1,arg2);
4213
 
    
4214
 
    {
4215
 
        /* %typemap(out) OGRErr */
4216
 
        if (result != 0 ) {
4217
 
            SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
4218
 
        }
4219
 
    }
4220
 
    {
4221
 
        /* %typemap(ret) OGRErr */
4222
 
        RETVAL_LONG(0);
4223
 
    }
4224
 
    return;
4225
 
    fail:
4226
 
    zend_error(ErrorCode(),ErrorMsg());
 
4266
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
4267
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
 
4268
  zval **args[2];
 
4269
  OGRErr result;
 
4270
  
 
4271
  SWIG_ResetError();
 
4272
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
4273
    WRONG_PARAM_COUNT;
 
4274
  }
 
4275
  
 
4276
  {
 
4277
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
4278
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_SetGeometry. Expected SWIGTYPE_p_OGRFeatureShadow");
 
4279
    }
 
4280
  }
 
4281
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
4282
  {
 
4283
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
4284
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Feature_SetGeometry. Expected SWIGTYPE_p_OGRGeometryShadow");
 
4285
    }
 
4286
  }
 
4287
  result = (OGRErr)OGRFeatureShadow_SetGeometry(arg1,arg2);
 
4288
  {
 
4289
    /* %typemap(out) OGRErr */
 
4290
    if (result != 0 ) {
 
4291
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
4292
    }
 
4293
  }
 
4294
  {
 
4295
    /* %typemap(ret) OGRErr */
 
4296
    RETVAL_LONG(0);
 
4297
  }
 
4298
  return;
 
4299
fail:
 
4300
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
4227
4301
}
4228
4302
 
4229
4303
 
4230
4304
ZEND_NAMED_FUNCTION(_wrap_Feature_SetGeometryDirectly) {
4231
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4232
 
    OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
4233
 
    OGRErr result;
4234
 
    zval **args[1];
4235
 
    
4236
 
    SWIG_ResetError();
4237
 
    /* This function uses a this_ptr*/
4238
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
4239
 
        WRONG_PARAM_COUNT;
4240
 
    }
4241
 
    
4242
 
    {
4243
 
        /* typemap(in) SWIGTYPE * */
4244
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
4245
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_SetGeometryDirectly. Expected SWIGTYPE_p_p_OGRFeatureShadow");
4246
 
        }
4247
 
    }
4248
 
    {
4249
 
        /* typemap(in) SWIGTYPE *DISOWN */
4250
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_DISOWN ) < 0) {
4251
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Feature_SetGeometryDirectly. Expected SWIGTYPE_p_p_OGRGeometryShadow");
4252
 
        }
4253
 
    }
4254
 
    result = (OGRErr)OGRFeatureShadow_SetGeometryDirectly(arg1,arg2);
4255
 
    
4256
 
    {
4257
 
        /* %typemap(out) OGRErr */
4258
 
        if (result != 0 ) {
4259
 
            SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
4260
 
        }
4261
 
    }
4262
 
    {
4263
 
        /* %typemap(ret) OGRErr */
4264
 
        RETVAL_LONG(0);
4265
 
    }
4266
 
    return;
4267
 
    fail:
4268
 
    zend_error(ErrorCode(),ErrorMsg());
 
4305
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
4306
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
 
4307
  zval **args[2];
 
4308
  OGRErr result;
 
4309
  
 
4310
  SWIG_ResetError();
 
4311
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
4312
    WRONG_PARAM_COUNT;
 
4313
  }
 
4314
  
 
4315
  {
 
4316
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
4317
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_SetGeometryDirectly. Expected SWIGTYPE_p_OGRFeatureShadow");
 
4318
    }
 
4319
  }
 
4320
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
4321
  {
 
4322
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_DISOWN ) < 0) {
 
4323
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Feature_SetGeometryDirectly. Expected SWIGTYPE_p_p_OGRGeometryShadow");
 
4324
    }
 
4325
  }
 
4326
  result = (OGRErr)OGRFeatureShadow_SetGeometryDirectly(arg1,arg2);
 
4327
  {
 
4328
    /* %typemap(out) OGRErr */
 
4329
    if (result != 0 ) {
 
4330
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
4331
    }
 
4332
  }
 
4333
  {
 
4334
    /* %typemap(ret) OGRErr */
 
4335
    RETVAL_LONG(0);
 
4336
  }
 
4337
  return;
 
4338
fail:
 
4339
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
4269
4340
}
4270
4341
 
4271
4342
 
4272
4343
ZEND_NAMED_FUNCTION(_wrap_Feature_GetGeometryRef) {
4273
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4274
 
    OGRGeometryShadow *result;
4275
 
    zval **args[0];
4276
 
    
4277
 
    SWIG_ResetError();
4278
 
    /* This function uses a this_ptr*/
4279
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
4280
 
        WRONG_PARAM_COUNT;
4281
 
    }
4282
 
    
4283
 
    {
4284
 
        /* typemap(in) SWIGTYPE * */
4285
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
4286
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetGeometryRef. Expected SWIGTYPE_p_p_OGRFeatureShadow");
4287
 
        }
4288
 
    }
4289
 
    result = (OGRGeometryShadow *)OGRFeatureShadow_GetGeometryRef(arg1);
4290
 
    
4291
 
    {
4292
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 0);
4293
 
    }
4294
 
    /* Wrap this return value */
4295
 
    {
4296
 
        /* ALTERNATIVE Constructor, make an object wrapper */
4297
 
        zval *obj, *_cPtr;
4298
 
        MAKE_STD_ZVAL(obj);
4299
 
        MAKE_STD_ZVAL(_cPtr);
4300
 
        *_cPtr = *return_value;
4301
 
        INIT_ZVAL(*return_value);
4302
 
        object_init_ex(obj,ptr_ce_swig_Geometry);
4303
 
        add_property_zval(obj,"_cPtr",_cPtr);
4304
 
        *return_value=*obj;
4305
 
    }
4306
 
    return;
4307
 
    fail:
4308
 
    zend_error(ErrorCode(),ErrorMsg());
 
4344
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
4345
  zval **args[1];
 
4346
  OGRGeometryShadow *result = 0 ;
 
4347
  
 
4348
  SWIG_ResetError();
 
4349
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
4350
    WRONG_PARAM_COUNT;
 
4351
  }
 
4352
  
 
4353
  {
 
4354
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
4355
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetGeometryRef. Expected SWIGTYPE_p_OGRFeatureShadow");
 
4356
    }
 
4357
  }
 
4358
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
4359
  result = (OGRGeometryShadow *)OGRFeatureShadow_GetGeometryRef(arg1);
 
4360
  
 
4361
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 0);
 
4362
  
 
4363
  return;
 
4364
fail:
 
4365
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
4309
4366
}
4310
4367
 
4311
4368
 
4312
 
ZEND_NAMED_FUNCTION(_wrap_Feature_Clone) {
4313
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4314
 
    OGRFeatureShadow *result;
4315
 
    zval **args[0];
4316
 
    
4317
 
    SWIG_ResetError();
4318
 
    /* This function uses a this_ptr*/
4319
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
4320
 
        WRONG_PARAM_COUNT;
4321
 
    }
4322
 
    
4323
 
    {
4324
 
        /* typemap(in) SWIGTYPE * */
4325
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
4326
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_Clone. Expected SWIGTYPE_p_p_OGRFeatureShadow");
4327
 
        }
4328
 
    }
4329
 
    result = (OGRFeatureShadow *)OGRFeatureShadow_Clone(arg1);
4330
 
    
4331
 
    {
4332
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRFeatureShadow, 1);
4333
 
    }
4334
 
    /* Wrap this return value */
4335
 
    {
4336
 
        /* ALTERNATIVE Constructor, make an object wrapper */
4337
 
        zval *obj, *_cPtr;
4338
 
        MAKE_STD_ZVAL(obj);
4339
 
        MAKE_STD_ZVAL(_cPtr);
4340
 
        *_cPtr = *return_value;
4341
 
        INIT_ZVAL(*return_value);
4342
 
        object_init_ex(obj,ptr_ce_swig_Feature);
4343
 
        add_property_zval(obj,"_cPtr",_cPtr);
4344
 
        *return_value=*obj;
4345
 
    }
4346
 
    return;
4347
 
    fail:
4348
 
    zend_error(ErrorCode(),ErrorMsg());
 
4369
ZEND_NAMED_FUNCTION(_wrap_Feature_c_Clone) {
 
4370
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
4371
  zval **args[1];
 
4372
  OGRFeatureShadow *result = 0 ;
 
4373
  
 
4374
  SWIG_ResetError();
 
4375
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
4376
    WRONG_PARAM_COUNT;
 
4377
  }
 
4378
  
 
4379
  {
 
4380
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
4381
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_c_Clone. Expected SWIGTYPE_p_OGRFeatureShadow");
 
4382
    }
 
4383
  }
 
4384
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
4385
  result = (OGRFeatureShadow *)OGRFeatureShadow_Clone(arg1);
 
4386
  
 
4387
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRFeatureShadow, 1);
 
4388
  
 
4389
  return;
 
4390
fail:
 
4391
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
4349
4392
}
4350
4393
 
4351
4394
 
4352
4395
ZEND_NAMED_FUNCTION(_wrap_Feature_Equal) {
4353
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4354
 
    OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
4355
 
    int result;
4356
 
    zval **args[1];
4357
 
    
4358
 
    SWIG_ResetError();
4359
 
    /* This function uses a this_ptr*/
4360
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
4361
 
        WRONG_PARAM_COUNT;
4362
 
    }
4363
 
    
4364
 
    {
4365
 
        /* typemap(in) SWIGTYPE * */
4366
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
4367
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_Equal. Expected SWIGTYPE_p_p_OGRFeatureShadow");
4368
 
        }
4369
 
    }
4370
 
    {
4371
 
        /* typemap(in) SWIGTYPE * */
4372
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
4373
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Feature_Equal. Expected SWIGTYPE_p_p_OGRFeatureShadow");
4374
 
        }
4375
 
    }
4376
 
    result = (int)OGRFeatureShadow_Equal(arg1,arg2);
4377
 
    
4378
 
    {
4379
 
        ZVAL_LONG(return_value,result);
4380
 
    }
4381
 
    return;
4382
 
    fail:
4383
 
    zend_error(ErrorCode(),ErrorMsg());
 
4396
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
4397
  OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
 
4398
  zval **args[2];
 
4399
  bool result;
 
4400
  
 
4401
  SWIG_ResetError();
 
4402
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
4403
    WRONG_PARAM_COUNT;
 
4404
  }
 
4405
  
 
4406
  {
 
4407
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
4408
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_Equal. Expected SWIGTYPE_p_OGRFeatureShadow");
 
4409
    }
 
4410
  }
 
4411
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
4412
  {
 
4413
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
4414
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Feature_Equal. Expected SWIGTYPE_p_OGRFeatureShadow");
 
4415
    }
 
4416
  }
 
4417
  {
 
4418
    if (!arg2) {
 
4419
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
4420
    }
 
4421
  }
 
4422
  result = (bool)OGRFeatureShadow_Equal(arg1,arg2);
 
4423
  {
 
4424
    ZVAL_BOOL(return_value,(result)?1:0);
 
4425
  }
 
4426
  return;
 
4427
fail:
 
4428
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
4384
4429
}
4385
4430
 
4386
4431
 
4387
4432
ZEND_NAMED_FUNCTION(_wrap_Feature_GetFieldCount) {
4388
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4389
 
    int result;
4390
 
    zval **args[0];
4391
 
    
4392
 
    SWIG_ResetError();
4393
 
    /* This function uses a this_ptr*/
4394
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
4395
 
        WRONG_PARAM_COUNT;
4396
 
    }
4397
 
    
4398
 
    {
4399
 
        /* typemap(in) SWIGTYPE * */
4400
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
4401
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldCount. Expected SWIGTYPE_p_p_OGRFeatureShadow");
4402
 
        }
4403
 
    }
4404
 
    result = (int)OGRFeatureShadow_GetFieldCount(arg1);
4405
 
    
4406
 
    {
4407
 
        ZVAL_LONG(return_value,result);
4408
 
    }
4409
 
    return;
4410
 
    fail:
4411
 
    zend_error(ErrorCode(),ErrorMsg());
 
4433
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
4434
  zval **args[1];
 
4435
  int result;
 
4436
  
 
4437
  SWIG_ResetError();
 
4438
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
4439
    WRONG_PARAM_COUNT;
 
4440
  }
 
4441
  
 
4442
  {
 
4443
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
4444
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldCount. Expected SWIGTYPE_p_OGRFeatureShadow");
 
4445
    }
 
4446
  }
 
4447
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
4448
  result = (int)OGRFeatureShadow_GetFieldCount(arg1);
 
4449
  {
 
4450
    ZVAL_LONG(return_value,result);
 
4451
  }
 
4452
  return;
 
4453
fail:
 
4454
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
4412
4455
}
4413
4456
 
4414
4457
 
4415
4458
ZEND_NAMED_FUNCTION(_wrap_Feature_GetFieldDefnRef__SWIG_0) {
4416
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4417
 
    int arg2 ;
4418
 
    OGRFieldDefnShadow *result;
4419
 
    zval **args[1];
4420
 
    
4421
 
    SWIG_ResetError();
4422
 
    /* This function uses a this_ptr*/
4423
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
4424
 
        WRONG_PARAM_COUNT;
4425
 
    }
4426
 
    
4427
 
    {
4428
 
        /* typemap(in) SWIGTYPE * */
4429
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
4430
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldDefnRef. Expected SWIGTYPE_p_p_OGRFeatureShadow");
4431
 
        }
4432
 
    }
4433
 
    {
4434
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
4435
 
        convert_to_long_ex(args[0]);
4436
 
        arg2 = (int) Z_LVAL_PP(args[0]);
4437
 
        /*@@*/;
4438
 
    }
4439
 
    result = (OGRFieldDefnShadow *)OGRFeatureShadow_GetFieldDefnRef__SWIG_0(arg1,arg2);
4440
 
    
4441
 
    {
4442
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRFieldDefnShadow, 0);
4443
 
    }
4444
 
    /* Wrap this return value */
4445
 
    {
4446
 
        /* ALTERNATIVE Constructor, make an object wrapper */
4447
 
        zval *obj, *_cPtr;
4448
 
        MAKE_STD_ZVAL(obj);
4449
 
        MAKE_STD_ZVAL(_cPtr);
4450
 
        *_cPtr = *return_value;
4451
 
        INIT_ZVAL(*return_value);
4452
 
        object_init_ex(obj,ptr_ce_swig_FieldDefn);
4453
 
        add_property_zval(obj,"_cPtr",_cPtr);
4454
 
        *return_value=*obj;
4455
 
    }
4456
 
    return;
4457
 
    fail:
4458
 
    zend_error(ErrorCode(),ErrorMsg());
 
4459
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
4460
  int arg2 ;
 
4461
  zval **args[2];
 
4462
  OGRFieldDefnShadow *result = 0 ;
 
4463
  
 
4464
  SWIG_ResetError();
 
4465
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
4466
    WRONG_PARAM_COUNT;
 
4467
  }
 
4468
  
 
4469
  {
 
4470
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
4471
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldDefnRef. Expected SWIGTYPE_p_OGRFeatureShadow");
 
4472
    }
 
4473
  }
 
4474
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
4475
  
 
4476
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
4477
  convert_to_long_ex(args[1]);
 
4478
  arg2 = (int) Z_LVAL_PP(args[1]);
 
4479
  /*@SWIG@*/;
 
4480
  
 
4481
  result = (OGRFieldDefnShadow *)OGRFeatureShadow_GetFieldDefnRef__SWIG_0(arg1,arg2);
 
4482
  
 
4483
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRFieldDefnShadow, 0);
 
4484
  
 
4485
  return;
 
4486
fail:
 
4487
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
4459
4488
}
4460
4489
 
4461
4490
 
4462
4491
ZEND_NAMED_FUNCTION(_wrap_Feature_GetFieldDefnRef__SWIG_1) {
4463
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4464
 
    char *arg2 = (char *) 0 ;
4465
 
    OGRFieldDefnShadow *result;
4466
 
    zval **args[1];
4467
 
    
4468
 
    SWIG_ResetError();
4469
 
    /* This function uses a this_ptr*/
4470
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
4471
 
        WRONG_PARAM_COUNT;
4472
 
    }
4473
 
    
4474
 
    {
4475
 
        /* typemap(in) SWIGTYPE * */
4476
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
4477
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldDefnRef. Expected SWIGTYPE_p_p_OGRFeatureShadow");
4478
 
        }
4479
 
    }
4480
 
    {
4481
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
4482
 
        convert_to_string_ex(args[0]);
4483
 
        arg2 = (char *) Z_STRVAL_PP(args[0]);
4484
 
        /*@@*/;
4485
 
    }
4486
 
    result = (OGRFieldDefnShadow *)OGRFeatureShadow_GetFieldDefnRef__SWIG_1(arg1,(char const *)arg2);
4487
 
    
4488
 
    {
4489
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRFieldDefnShadow, 0);
4490
 
    }
4491
 
    /* Wrap this return value */
4492
 
    {
4493
 
        /* ALTERNATIVE Constructor, make an object wrapper */
4494
 
        zval *obj, *_cPtr;
4495
 
        MAKE_STD_ZVAL(obj);
4496
 
        MAKE_STD_ZVAL(_cPtr);
4497
 
        *_cPtr = *return_value;
4498
 
        INIT_ZVAL(*return_value);
4499
 
        object_init_ex(obj,ptr_ce_swig_FieldDefn);
4500
 
        add_property_zval(obj,"_cPtr",_cPtr);
4501
 
        *return_value=*obj;
4502
 
    }
4503
 
    return;
4504
 
    fail:
4505
 
    zend_error(ErrorCode(),ErrorMsg());
 
4492
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
4493
  char *arg2 = (char *) 0 ;
 
4494
  zval **args[2];
 
4495
  OGRFieldDefnShadow *result = 0 ;
 
4496
  
 
4497
  SWIG_ResetError();
 
4498
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
4499
    WRONG_PARAM_COUNT;
 
4500
  }
 
4501
  
 
4502
  {
 
4503
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
4504
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldDefnRef. Expected SWIGTYPE_p_OGRFeatureShadow");
 
4505
    }
 
4506
  }
 
4507
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
4508
  
 
4509
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
4510
  if ((*args[1])->type==IS_NULL) {
 
4511
    arg2 = (char *) 0;
 
4512
  } else {
 
4513
    convert_to_string_ex(args[1]);
 
4514
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
4515
  }
 
4516
  /*@SWIG@*/;
 
4517
  
 
4518
  {
 
4519
    if (!arg2) {
 
4520
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
4521
    }
 
4522
  }
 
4523
  result = (OGRFieldDefnShadow *)OGRFeatureShadow_GetFieldDefnRef__SWIG_1(arg1,(char const *)arg2);
 
4524
  
 
4525
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRFieldDefnShadow, 0);
 
4526
  
 
4527
  return;
 
4528
fail:
 
4529
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
4506
4530
}
4507
4531
 
4508
4532
 
4509
4533
ZEND_NAMED_FUNCTION(_wrap_Feature_GetFieldDefnRef) {
4510
 
    int argc;
4511
 
    zval **argv[2];
4512
 
    int ii;
4513
 
    
4514
 
    argc = ZEND_NUM_ARGS();
4515
 
    zend_get_parameters_array_ex(argc,argv);
4516
 
    if (argc == 2) {
4517
 
        int _v;
4518
 
        {
4519
 
            /* typecheck SWIGTYPE * */
4520
 
            void *tmp;
4521
 
            _v = (SWIG_ConvertPtr( *argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) < 0)? 0:1;
4522
 
        }
4523
 
        if (_v) {
4524
 
            _v = (Z_TYPE_PP(argv[1]) == IS_LONG ||
4525
 
            Z_TYPE_PP(argv[1]) == IS_DOUBLE ||
4526
 
            Z_TYPE_PP(argv[1]) == IS_STRING) ? 1 : 0; 
4527
 
            if (_v) {
4528
 
                return _wrap_Feature_GetFieldDefnRef__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU);
4529
 
            }
4530
 
        }
4531
 
    }
4532
 
    if (argc == 2) {
4533
 
        int _v;
4534
 
        {
4535
 
            /* typecheck SWIGTYPE * */
4536
 
            void *tmp;
4537
 
            _v = (SWIG_ConvertPtr( *argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) < 0)? 0:1;
4538
 
        }
4539
 
        if (_v) {
4540
 
            _v = (Z_TYPE_PP(argv[1]) == IS_LONG ||
4541
 
            Z_TYPE_PP(argv[1]) == IS_DOUBLE ||
4542
 
            Z_TYPE_PP(argv[1]) == IS_STRING) ? 1 : 0; 
4543
 
            if (_v) {
4544
 
                return _wrap_Feature_GetFieldDefnRef__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU);
4545
 
            }
4546
 
        }
4547
 
    }
4548
 
    
4549
 
    /*No matching function for overloaded 'Feature_GetFieldDefnRef'*/
4550
 
    
 
4534
  int argc;
 
4535
  zval **argv[2];
 
4536
  
 
4537
  argc = ZEND_NUM_ARGS();
 
4538
  zend_get_parameters_array_ex(argc,argv);
 
4539
  if (argc == 2) {
 
4540
    int _v;
 
4541
    {
 
4542
      void *tmp;
 
4543
      _v = (SWIG_ConvertPtr(*argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) >= 0);
 
4544
    }
 
4545
    if (_v) {
 
4546
      _v = (Z_TYPE_PP(argv[1]) == IS_LONG); 
 
4547
      if (_v) {
 
4548
        return _wrap_Feature_GetFieldDefnRef__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
4549
      }
 
4550
    }
 
4551
  }
 
4552
  if (argc == 2) {
 
4553
    int _v;
 
4554
    {
 
4555
      void *tmp;
 
4556
      _v = (SWIG_ConvertPtr(*argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) >= 0);
 
4557
    }
 
4558
    if (_v) {
 
4559
      _v = (Z_TYPE_PP(argv[1]) == IS_STRING); 
 
4560
      if (_v) {
 
4561
        return _wrap_Feature_GetFieldDefnRef__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
4562
      }
 
4563
    }
 
4564
  }
 
4565
  
 
4566
  SWIG_ErrorCode() = E_ERROR;
 
4567
  SWIG_ErrorMsg() = "No matching function for overloaded 'Feature_GetFieldDefnRef'";
 
4568
  zend_error(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
4551
4569
}
4552
4570
 
4553
4571
 
4554
4572
ZEND_NAMED_FUNCTION(_wrap_Feature_GetFieldAsString__SWIG_0) {
4555
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4556
 
    int arg2 ;
4557
 
    char *result;
4558
 
    zval **args[1];
4559
 
    
4560
 
    SWIG_ResetError();
4561
 
    /* This function uses a this_ptr*/
4562
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
4563
 
        WRONG_PARAM_COUNT;
4564
 
    }
4565
 
    
4566
 
    {
4567
 
        /* typemap(in) SWIGTYPE * */
4568
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
4569
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldAsString. Expected SWIGTYPE_p_p_OGRFeatureShadow");
4570
 
        }
4571
 
    }
4572
 
    {
4573
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
4574
 
        convert_to_long_ex(args[0]);
4575
 
        arg2 = (int) Z_LVAL_PP(args[0]);
4576
 
        /*@@*/;
4577
 
    }
4578
 
    result = (char *)OGRFeatureShadow_GetFieldAsString__SWIG_0(arg1,arg2);
4579
 
    
4580
 
    {
4581
 
        if(!result) {
4582
 
            ZVAL_NULL(return_value);
4583
 
        } else {
4584
 
            ZVAL_STRING(return_value,result, 1);
4585
 
        }
4586
 
    }
4587
 
    return;
4588
 
    fail:
4589
 
    zend_error(ErrorCode(),ErrorMsg());
 
4573
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
4574
  int arg2 ;
 
4575
  zval **args[2];
 
4576
  char *result = 0 ;
 
4577
  
 
4578
  SWIG_ResetError();
 
4579
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
4580
    WRONG_PARAM_COUNT;
 
4581
  }
 
4582
  
 
4583
  {
 
4584
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
4585
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldAsString. Expected SWIGTYPE_p_OGRFeatureShadow");
 
4586
    }
 
4587
  }
 
4588
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
4589
  
 
4590
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
4591
  convert_to_long_ex(args[1]);
 
4592
  arg2 = (int) Z_LVAL_PP(args[1]);
 
4593
  /*@SWIG@*/;
 
4594
  
 
4595
  result = (char *)OGRFeatureShadow_GetFieldAsString__SWIG_0(arg1,arg2);
 
4596
  {
 
4597
    if(!result) {
 
4598
      ZVAL_NULL(return_value);
 
4599
    } else {
 
4600
      ZVAL_STRING(return_value, (char *)result, 1);
 
4601
    }
 
4602
  }
 
4603
  return;
 
4604
fail:
 
4605
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
4590
4606
}
4591
4607
 
4592
4608
 
4593
4609
ZEND_NAMED_FUNCTION(_wrap_Feature_GetFieldAsString__SWIG_1) {
4594
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4595
 
    char *arg2 = (char *) 0 ;
4596
 
    char *result;
4597
 
    zval **args[1];
4598
 
    
4599
 
    SWIG_ResetError();
4600
 
    /* This function uses a this_ptr*/
4601
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
4602
 
        WRONG_PARAM_COUNT;
4603
 
    }
4604
 
    
4605
 
    {
4606
 
        /* typemap(in) SWIGTYPE * */
4607
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
4608
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldAsString. Expected SWIGTYPE_p_p_OGRFeatureShadow");
4609
 
        }
4610
 
    }
4611
 
    {
4612
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
4613
 
        convert_to_string_ex(args[0]);
4614
 
        arg2 = (char *) Z_STRVAL_PP(args[0]);
4615
 
        /*@@*/;
4616
 
    }
4617
 
    result = (char *)OGRFeatureShadow_GetFieldAsString__SWIG_1(arg1,(char const *)arg2);
4618
 
    
4619
 
    {
4620
 
        if(!result) {
4621
 
            ZVAL_NULL(return_value);
4622
 
        } else {
4623
 
            ZVAL_STRING(return_value,result, 1);
4624
 
        }
4625
 
    }
4626
 
    return;
4627
 
    fail:
4628
 
    zend_error(ErrorCode(),ErrorMsg());
 
4610
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
4611
  char *arg2 = (char *) 0 ;
 
4612
  zval **args[2];
 
4613
  char *result = 0 ;
 
4614
  
 
4615
  SWIG_ResetError();
 
4616
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
4617
    WRONG_PARAM_COUNT;
 
4618
  }
 
4619
  
 
4620
  {
 
4621
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
4622
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldAsString. Expected SWIGTYPE_p_OGRFeatureShadow");
 
4623
    }
 
4624
  }
 
4625
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
4626
  
 
4627
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
4628
  if ((*args[1])->type==IS_NULL) {
 
4629
    arg2 = (char *) 0;
 
4630
  } else {
 
4631
    convert_to_string_ex(args[1]);
 
4632
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
4633
  }
 
4634
  /*@SWIG@*/;
 
4635
  
 
4636
  {
 
4637
    if (!arg2) {
 
4638
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
4639
    }
 
4640
  }
 
4641
  result = (char *)OGRFeatureShadow_GetFieldAsString__SWIG_1(arg1,(char const *)arg2);
 
4642
  {
 
4643
    if(!result) {
 
4644
      ZVAL_NULL(return_value);
 
4645
    } else {
 
4646
      ZVAL_STRING(return_value, (char *)result, 1);
 
4647
    }
 
4648
  }
 
4649
  return;
 
4650
fail:
 
4651
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
4629
4652
}
4630
4653
 
4631
4654
 
4632
4655
ZEND_NAMED_FUNCTION(_wrap_Feature_GetFieldAsString) {
4633
 
    int argc;
4634
 
    zval **argv[2];
4635
 
    int ii;
4636
 
    
4637
 
    argc = ZEND_NUM_ARGS();
4638
 
    zend_get_parameters_array_ex(argc,argv);
4639
 
    if (argc == 2) {
4640
 
        int _v;
4641
 
        {
4642
 
            /* typecheck SWIGTYPE * */
4643
 
            void *tmp;
4644
 
            _v = (SWIG_ConvertPtr( *argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) < 0)? 0:1;
4645
 
        }
4646
 
        if (_v) {
4647
 
            _v = (Z_TYPE_PP(argv[1]) == IS_LONG ||
4648
 
            Z_TYPE_PP(argv[1]) == IS_DOUBLE ||
4649
 
            Z_TYPE_PP(argv[1]) == IS_STRING) ? 1 : 0; 
4650
 
            if (_v) {
4651
 
                return _wrap_Feature_GetFieldAsString__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU);
4652
 
            }
4653
 
        }
4654
 
    }
4655
 
    if (argc == 2) {
4656
 
        int _v;
4657
 
        {
4658
 
            /* typecheck SWIGTYPE * */
4659
 
            void *tmp;
4660
 
            _v = (SWIG_ConvertPtr( *argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) < 0)? 0:1;
4661
 
        }
4662
 
        if (_v) {
4663
 
            _v = (Z_TYPE_PP(argv[1]) == IS_LONG ||
4664
 
            Z_TYPE_PP(argv[1]) == IS_DOUBLE ||
4665
 
            Z_TYPE_PP(argv[1]) == IS_STRING) ? 1 : 0; 
4666
 
            if (_v) {
4667
 
                return _wrap_Feature_GetFieldAsString__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU);
4668
 
            }
4669
 
        }
4670
 
    }
4671
 
    
4672
 
    /*No matching function for overloaded 'Feature_GetFieldAsString'*/
4673
 
    
 
4656
  int argc;
 
4657
  zval **argv[2];
 
4658
  
 
4659
  argc = ZEND_NUM_ARGS();
 
4660
  zend_get_parameters_array_ex(argc,argv);
 
4661
  if (argc == 2) {
 
4662
    int _v;
 
4663
    {
 
4664
      void *tmp;
 
4665
      _v = (SWIG_ConvertPtr(*argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) >= 0);
 
4666
    }
 
4667
    if (_v) {
 
4668
      _v = (Z_TYPE_PP(argv[1]) == IS_LONG); 
 
4669
      if (_v) {
 
4670
        return _wrap_Feature_GetFieldAsString__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
4671
      }
 
4672
    }
 
4673
  }
 
4674
  if (argc == 2) {
 
4675
    int _v;
 
4676
    {
 
4677
      void *tmp;
 
4678
      _v = (SWIG_ConvertPtr(*argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) >= 0);
 
4679
    }
 
4680
    if (_v) {
 
4681
      _v = (Z_TYPE_PP(argv[1]) == IS_STRING); 
 
4682
      if (_v) {
 
4683
        return _wrap_Feature_GetFieldAsString__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
4684
      }
 
4685
    }
 
4686
  }
 
4687
  
 
4688
  SWIG_ErrorCode() = E_ERROR;
 
4689
  SWIG_ErrorMsg() = "No matching function for overloaded 'Feature_GetFieldAsString'";
 
4690
  zend_error(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
4674
4691
}
4675
4692
 
4676
4693
 
4677
4694
ZEND_NAMED_FUNCTION(_wrap_Feature_GetFieldAsInteger__SWIG_0) {
4678
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4679
 
    int arg2 ;
4680
 
    int result;
4681
 
    zval **args[1];
4682
 
    
4683
 
    SWIG_ResetError();
4684
 
    /* This function uses a this_ptr*/
4685
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
4686
 
        WRONG_PARAM_COUNT;
4687
 
    }
4688
 
    
4689
 
    {
4690
 
        /* typemap(in) SWIGTYPE * */
4691
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
4692
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldAsInteger. Expected SWIGTYPE_p_p_OGRFeatureShadow");
4693
 
        }
4694
 
    }
4695
 
    {
4696
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
4697
 
        convert_to_long_ex(args[0]);
4698
 
        arg2 = (int) Z_LVAL_PP(args[0]);
4699
 
        /*@@*/;
4700
 
    }
4701
 
    result = (int)OGRFeatureShadow_GetFieldAsInteger__SWIG_0(arg1,arg2);
4702
 
    
4703
 
    {
4704
 
        ZVAL_LONG(return_value,result);
4705
 
    }
4706
 
    return;
4707
 
    fail:
4708
 
    zend_error(ErrorCode(),ErrorMsg());
 
4695
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
4696
  int arg2 ;
 
4697
  zval **args[2];
 
4698
  int result;
 
4699
  
 
4700
  SWIG_ResetError();
 
4701
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
4702
    WRONG_PARAM_COUNT;
 
4703
  }
 
4704
  
 
4705
  {
 
4706
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
4707
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldAsInteger. Expected SWIGTYPE_p_OGRFeatureShadow");
 
4708
    }
 
4709
  }
 
4710
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
4711
  
 
4712
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
4713
  convert_to_long_ex(args[1]);
 
4714
  arg2 = (int) Z_LVAL_PP(args[1]);
 
4715
  /*@SWIG@*/;
 
4716
  
 
4717
  result = (int)OGRFeatureShadow_GetFieldAsInteger__SWIG_0(arg1,arg2);
 
4718
  {
 
4719
    ZVAL_LONG(return_value,result);
 
4720
  }
 
4721
  return;
 
4722
fail:
 
4723
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
4709
4724
}
4710
4725
 
4711
4726
 
4712
4727
ZEND_NAMED_FUNCTION(_wrap_Feature_GetFieldAsInteger__SWIG_1) {
4713
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4714
 
    char *arg2 = (char *) 0 ;
4715
 
    int result;
4716
 
    zval **args[1];
4717
 
    
4718
 
    SWIG_ResetError();
4719
 
    /* This function uses a this_ptr*/
4720
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
4721
 
        WRONG_PARAM_COUNT;
4722
 
    }
4723
 
    
4724
 
    {
4725
 
        /* typemap(in) SWIGTYPE * */
4726
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
4727
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldAsInteger. Expected SWIGTYPE_p_p_OGRFeatureShadow");
4728
 
        }
4729
 
    }
4730
 
    {
4731
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
4732
 
        convert_to_string_ex(args[0]);
4733
 
        arg2 = (char *) Z_STRVAL_PP(args[0]);
4734
 
        /*@@*/;
4735
 
    }
4736
 
    result = (int)OGRFeatureShadow_GetFieldAsInteger__SWIG_1(arg1,(char const *)arg2);
4737
 
    
4738
 
    {
4739
 
        ZVAL_LONG(return_value,result);
4740
 
    }
4741
 
    return;
4742
 
    fail:
4743
 
    zend_error(ErrorCode(),ErrorMsg());
 
4728
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
4729
  char *arg2 = (char *) 0 ;
 
4730
  zval **args[2];
 
4731
  int result;
 
4732
  
 
4733
  SWIG_ResetError();
 
4734
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
4735
    WRONG_PARAM_COUNT;
 
4736
  }
 
4737
  
 
4738
  {
 
4739
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
4740
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldAsInteger. Expected SWIGTYPE_p_OGRFeatureShadow");
 
4741
    }
 
4742
  }
 
4743
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
4744
  
 
4745
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
4746
  if ((*args[1])->type==IS_NULL) {
 
4747
    arg2 = (char *) 0;
 
4748
  } else {
 
4749
    convert_to_string_ex(args[1]);
 
4750
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
4751
  }
 
4752
  /*@SWIG@*/;
 
4753
  
 
4754
  {
 
4755
    if (!arg2) {
 
4756
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
4757
    }
 
4758
  }
 
4759
  result = (int)OGRFeatureShadow_GetFieldAsInteger__SWIG_1(arg1,(char const *)arg2);
 
4760
  {
 
4761
    ZVAL_LONG(return_value,result);
 
4762
  }
 
4763
  return;
 
4764
fail:
 
4765
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
4744
4766
}
4745
4767
 
4746
4768
 
4747
4769
ZEND_NAMED_FUNCTION(_wrap_Feature_GetFieldAsInteger) {
4748
 
    int argc;
4749
 
    zval **argv[2];
4750
 
    int ii;
4751
 
    
4752
 
    argc = ZEND_NUM_ARGS();
4753
 
    zend_get_parameters_array_ex(argc,argv);
4754
 
    if (argc == 2) {
4755
 
        int _v;
4756
 
        {
4757
 
            /* typecheck SWIGTYPE * */
4758
 
            void *tmp;
4759
 
            _v = (SWIG_ConvertPtr( *argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) < 0)? 0:1;
4760
 
        }
4761
 
        if (_v) {
4762
 
            _v = (Z_TYPE_PP(argv[1]) == IS_LONG ||
4763
 
            Z_TYPE_PP(argv[1]) == IS_DOUBLE ||
4764
 
            Z_TYPE_PP(argv[1]) == IS_STRING) ? 1 : 0; 
4765
 
            if (_v) {
4766
 
                return _wrap_Feature_GetFieldAsInteger__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU);
4767
 
            }
4768
 
        }
4769
 
    }
4770
 
    if (argc == 2) {
4771
 
        int _v;
4772
 
        {
4773
 
            /* typecheck SWIGTYPE * */
4774
 
            void *tmp;
4775
 
            _v = (SWIG_ConvertPtr( *argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) < 0)? 0:1;
4776
 
        }
4777
 
        if (_v) {
4778
 
            _v = (Z_TYPE_PP(argv[1]) == IS_LONG ||
4779
 
            Z_TYPE_PP(argv[1]) == IS_DOUBLE ||
4780
 
            Z_TYPE_PP(argv[1]) == IS_STRING) ? 1 : 0; 
4781
 
            if (_v) {
4782
 
                return _wrap_Feature_GetFieldAsInteger__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU);
4783
 
            }
4784
 
        }
4785
 
    }
4786
 
    
4787
 
    /*No matching function for overloaded 'Feature_GetFieldAsInteger'*/
4788
 
    
 
4770
  int argc;
 
4771
  zval **argv[2];
 
4772
  
 
4773
  argc = ZEND_NUM_ARGS();
 
4774
  zend_get_parameters_array_ex(argc,argv);
 
4775
  if (argc == 2) {
 
4776
    int _v;
 
4777
    {
 
4778
      void *tmp;
 
4779
      _v = (SWIG_ConvertPtr(*argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) >= 0);
 
4780
    }
 
4781
    if (_v) {
 
4782
      _v = (Z_TYPE_PP(argv[1]) == IS_LONG); 
 
4783
      if (_v) {
 
4784
        return _wrap_Feature_GetFieldAsInteger__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
4785
      }
 
4786
    }
 
4787
  }
 
4788
  if (argc == 2) {
 
4789
    int _v;
 
4790
    {
 
4791
      void *tmp;
 
4792
      _v = (SWIG_ConvertPtr(*argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) >= 0);
 
4793
    }
 
4794
    if (_v) {
 
4795
      _v = (Z_TYPE_PP(argv[1]) == IS_STRING); 
 
4796
      if (_v) {
 
4797
        return _wrap_Feature_GetFieldAsInteger__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
4798
      }
 
4799
    }
 
4800
  }
 
4801
  
 
4802
  SWIG_ErrorCode() = E_ERROR;
 
4803
  SWIG_ErrorMsg() = "No matching function for overloaded 'Feature_GetFieldAsInteger'";
 
4804
  zend_error(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
4789
4805
}
4790
4806
 
4791
4807
 
4792
4808
ZEND_NAMED_FUNCTION(_wrap_Feature_GetFieldAsDouble__SWIG_0) {
4793
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4794
 
    int arg2 ;
4795
 
    double result;
4796
 
    zval **args[1];
4797
 
    
4798
 
    SWIG_ResetError();
4799
 
    /* This function uses a this_ptr*/
4800
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
4801
 
        WRONG_PARAM_COUNT;
4802
 
    }
4803
 
    
4804
 
    {
4805
 
        /* typemap(in) SWIGTYPE * */
4806
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
4807
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldAsDouble. Expected SWIGTYPE_p_p_OGRFeatureShadow");
4808
 
        }
4809
 
    }
4810
 
    {
4811
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
4812
 
        convert_to_long_ex(args[0]);
4813
 
        arg2 = (int) Z_LVAL_PP(args[0]);
4814
 
        /*@@*/;
4815
 
    }
4816
 
    result = (double)OGRFeatureShadow_GetFieldAsDouble__SWIG_0(arg1,arg2);
4817
 
    
4818
 
    {
4819
 
        ZVAL_DOUBLE(return_value,result);
4820
 
    }
4821
 
    return;
4822
 
    fail:
4823
 
    zend_error(ErrorCode(),ErrorMsg());
 
4809
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
4810
  int arg2 ;
 
4811
  zval **args[2];
 
4812
  double result;
 
4813
  
 
4814
  SWIG_ResetError();
 
4815
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
4816
    WRONG_PARAM_COUNT;
 
4817
  }
 
4818
  
 
4819
  {
 
4820
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
4821
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldAsDouble. Expected SWIGTYPE_p_OGRFeatureShadow");
 
4822
    }
 
4823
  }
 
4824
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
4825
  
 
4826
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
4827
  convert_to_long_ex(args[1]);
 
4828
  arg2 = (int) Z_LVAL_PP(args[1]);
 
4829
  /*@SWIG@*/;
 
4830
  
 
4831
  result = (double)OGRFeatureShadow_GetFieldAsDouble__SWIG_0(arg1,arg2);
 
4832
  {
 
4833
    ZVAL_DOUBLE(return_value,result);
 
4834
  }
 
4835
  return;
 
4836
fail:
 
4837
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
4824
4838
}
4825
4839
 
4826
4840
 
4827
4841
ZEND_NAMED_FUNCTION(_wrap_Feature_GetFieldAsDouble__SWIG_1) {
4828
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4829
 
    char *arg2 = (char *) 0 ;
4830
 
    double result;
4831
 
    zval **args[1];
4832
 
    
4833
 
    SWIG_ResetError();
4834
 
    /* This function uses a this_ptr*/
4835
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
4836
 
        WRONG_PARAM_COUNT;
4837
 
    }
4838
 
    
4839
 
    {
4840
 
        /* typemap(in) SWIGTYPE * */
4841
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
4842
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldAsDouble. Expected SWIGTYPE_p_p_OGRFeatureShadow");
4843
 
        }
4844
 
    }
4845
 
    {
4846
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
4847
 
        convert_to_string_ex(args[0]);
4848
 
        arg2 = (char *) Z_STRVAL_PP(args[0]);
4849
 
        /*@@*/;
4850
 
    }
4851
 
    result = (double)OGRFeatureShadow_GetFieldAsDouble__SWIG_1(arg1,(char const *)arg2);
4852
 
    
4853
 
    {
4854
 
        ZVAL_DOUBLE(return_value,result);
4855
 
    }
4856
 
    return;
4857
 
    fail:
4858
 
    zend_error(ErrorCode(),ErrorMsg());
 
4842
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
4843
  char *arg2 = (char *) 0 ;
 
4844
  zval **args[2];
 
4845
  double result;
 
4846
  
 
4847
  SWIG_ResetError();
 
4848
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
4849
    WRONG_PARAM_COUNT;
 
4850
  }
 
4851
  
 
4852
  {
 
4853
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
4854
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldAsDouble. Expected SWIGTYPE_p_OGRFeatureShadow");
 
4855
    }
 
4856
  }
 
4857
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
4858
  
 
4859
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
4860
  if ((*args[1])->type==IS_NULL) {
 
4861
    arg2 = (char *) 0;
 
4862
  } else {
 
4863
    convert_to_string_ex(args[1]);
 
4864
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
4865
  }
 
4866
  /*@SWIG@*/;
 
4867
  
 
4868
  {
 
4869
    if (!arg2) {
 
4870
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
4871
    }
 
4872
  }
 
4873
  result = (double)OGRFeatureShadow_GetFieldAsDouble__SWIG_1(arg1,(char const *)arg2);
 
4874
  {
 
4875
    ZVAL_DOUBLE(return_value,result);
 
4876
  }
 
4877
  return;
 
4878
fail:
 
4879
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
4859
4880
}
4860
4881
 
4861
4882
 
4862
4883
ZEND_NAMED_FUNCTION(_wrap_Feature_GetFieldAsDouble) {
4863
 
    int argc;
4864
 
    zval **argv[2];
4865
 
    int ii;
4866
 
    
4867
 
    argc = ZEND_NUM_ARGS();
4868
 
    zend_get_parameters_array_ex(argc,argv);
4869
 
    if (argc == 2) {
4870
 
        int _v;
4871
 
        {
4872
 
            /* typecheck SWIGTYPE * */
4873
 
            void *tmp;
4874
 
            _v = (SWIG_ConvertPtr( *argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) < 0)? 0:1;
4875
 
        }
4876
 
        if (_v) {
4877
 
            _v = (Z_TYPE_PP(argv[1]) == IS_LONG ||
4878
 
            Z_TYPE_PP(argv[1]) == IS_DOUBLE ||
4879
 
            Z_TYPE_PP(argv[1]) == IS_STRING) ? 1 : 0; 
4880
 
            if (_v) {
4881
 
                return _wrap_Feature_GetFieldAsDouble__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU);
4882
 
            }
4883
 
        }
4884
 
    }
4885
 
    if (argc == 2) {
4886
 
        int _v;
4887
 
        {
4888
 
            /* typecheck SWIGTYPE * */
4889
 
            void *tmp;
4890
 
            _v = (SWIG_ConvertPtr( *argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) < 0)? 0:1;
4891
 
        }
4892
 
        if (_v) {
4893
 
            _v = (Z_TYPE_PP(argv[1]) == IS_LONG ||
4894
 
            Z_TYPE_PP(argv[1]) == IS_DOUBLE ||
4895
 
            Z_TYPE_PP(argv[1]) == IS_STRING) ? 1 : 0; 
4896
 
            if (_v) {
4897
 
                return _wrap_Feature_GetFieldAsDouble__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU);
4898
 
            }
4899
 
        }
4900
 
    }
4901
 
    
4902
 
    /*No matching function for overloaded 'Feature_GetFieldAsDouble'*/
4903
 
    
 
4884
  int argc;
 
4885
  zval **argv[2];
 
4886
  
 
4887
  argc = ZEND_NUM_ARGS();
 
4888
  zend_get_parameters_array_ex(argc,argv);
 
4889
  if (argc == 2) {
 
4890
    int _v;
 
4891
    {
 
4892
      void *tmp;
 
4893
      _v = (SWIG_ConvertPtr(*argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) >= 0);
 
4894
    }
 
4895
    if (_v) {
 
4896
      _v = (Z_TYPE_PP(argv[1]) == IS_LONG); 
 
4897
      if (_v) {
 
4898
        return _wrap_Feature_GetFieldAsDouble__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
4899
      }
 
4900
    }
 
4901
  }
 
4902
  if (argc == 2) {
 
4903
    int _v;
 
4904
    {
 
4905
      void *tmp;
 
4906
      _v = (SWIG_ConvertPtr(*argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) >= 0);
 
4907
    }
 
4908
    if (_v) {
 
4909
      _v = (Z_TYPE_PP(argv[1]) == IS_STRING); 
 
4910
      if (_v) {
 
4911
        return _wrap_Feature_GetFieldAsDouble__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
4912
      }
 
4913
    }
 
4914
  }
 
4915
  
 
4916
  SWIG_ErrorCode() = E_ERROR;
 
4917
  SWIG_ErrorMsg() = "No matching function for overloaded 'Feature_GetFieldAsDouble'";
 
4918
  zend_error(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
4919
}
 
4920
 
 
4921
 
 
4922
ZEND_NAMED_FUNCTION(_wrap_Feature_GetFieldAsDateTime) {
 
4923
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
4924
  int arg2 ;
 
4925
  int *arg3 = (int *) 0 ;
 
4926
  int *arg4 = (int *) 0 ;
 
4927
  int *arg5 = (int *) 0 ;
 
4928
  int *arg6 = (int *) 0 ;
 
4929
  int *arg7 = (int *) 0 ;
 
4930
  int *arg8 = (int *) 0 ;
 
4931
  int *arg9 = (int *) 0 ;
 
4932
  int temp3 ;
 
4933
  int temp4 ;
 
4934
  int temp5 ;
 
4935
  int temp6 ;
 
4936
  int temp7 ;
 
4937
  int temp8 ;
 
4938
  int temp9 ;
 
4939
  zval **args[2];
 
4940
  
 
4941
  arg3 = &temp3;
 
4942
  arg4 = &temp4;
 
4943
  arg5 = &temp5;
 
4944
  arg6 = &temp6;
 
4945
  arg7 = &temp7;
 
4946
  arg8 = &temp8;
 
4947
  arg9 = &temp9;
 
4948
  SWIG_ResetError();
 
4949
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
4950
    WRONG_PARAM_COUNT;
 
4951
  }
 
4952
  
 
4953
  {
 
4954
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
4955
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldAsDateTime. Expected SWIGTYPE_p_OGRFeatureShadow");
 
4956
    }
 
4957
  }
 
4958
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
4959
  
 
4960
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
4961
  convert_to_long_ex(args[1]);
 
4962
  arg2 = (int) Z_LVAL_PP(args[1]);
 
4963
  /*@SWIG@*/;
 
4964
  
 
4965
  OGRFeatureShadow_GetFieldAsDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
 
4966
  
 
4967
  {
 
4968
    zval *o;
 
4969
    MAKE_STD_ZVAL(o);
 
4970
    ZVAL_LONG(o,temp3);
 
4971
    t_output_helper( &return_value, o );
 
4972
  }
 
4973
  {
 
4974
    zval *o;
 
4975
    MAKE_STD_ZVAL(o);
 
4976
    ZVAL_LONG(o,temp4);
 
4977
    t_output_helper( &return_value, o );
 
4978
  }
 
4979
  {
 
4980
    zval *o;
 
4981
    MAKE_STD_ZVAL(o);
 
4982
    ZVAL_LONG(o,temp5);
 
4983
    t_output_helper( &return_value, o );
 
4984
  }
 
4985
  {
 
4986
    zval *o;
 
4987
    MAKE_STD_ZVAL(o);
 
4988
    ZVAL_LONG(o,temp6);
 
4989
    t_output_helper( &return_value, o );
 
4990
  }
 
4991
  {
 
4992
    zval *o;
 
4993
    MAKE_STD_ZVAL(o);
 
4994
    ZVAL_LONG(o,temp7);
 
4995
    t_output_helper( &return_value, o );
 
4996
  }
 
4997
  {
 
4998
    zval *o;
 
4999
    MAKE_STD_ZVAL(o);
 
5000
    ZVAL_LONG(o,temp8);
 
5001
    t_output_helper( &return_value, o );
 
5002
  }
 
5003
  {
 
5004
    zval *o;
 
5005
    MAKE_STD_ZVAL(o);
 
5006
    ZVAL_LONG(o,temp9);
 
5007
    t_output_helper( &return_value, o );
 
5008
  }
 
5009
  return;
 
5010
fail:
 
5011
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
5012
}
 
5013
 
 
5014
 
 
5015
ZEND_NAMED_FUNCTION(_wrap_Feature_GetFieldAsIntegerList) {
 
5016
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
5017
  int arg2 ;
 
5018
  int *arg3 = (int *) 0 ;
 
5019
  int **arg4 = (int **) 0 ;
 
5020
  zval **args[4];
 
5021
  
 
5022
  SWIG_ResetError();
 
5023
  if(ZEND_NUM_ARGS() != 4 || zend_get_parameters_array_ex(4, args) != SUCCESS) {
 
5024
    WRONG_PARAM_COUNT;
 
5025
  }
 
5026
  
 
5027
  {
 
5028
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
5029
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldAsIntegerList. Expected SWIGTYPE_p_OGRFeatureShadow");
 
5030
    }
 
5031
  }
 
5032
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
5033
  
 
5034
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5035
  convert_to_long_ex(args[1]);
 
5036
  arg2 = (int) Z_LVAL_PP(args[1]);
 
5037
  /*@SWIG@*/;
 
5038
  
 
5039
  {
 
5040
    if(SWIG_ConvertPtr(*args[2], (void **) &arg3, SWIGTYPE_p_int, 0) < 0) {
 
5041
      SWIG_PHP_Error(E_ERROR, "Type error in argument 3 of Feature_GetFieldAsIntegerList. Expected SWIGTYPE_p_int");
 
5042
    }
 
5043
  }
 
5044
  {
 
5045
    if(SWIG_ConvertPtr(*args[3], (void **) &arg4, SWIGTYPE_p_p_int, 0) < 0) {
 
5046
      SWIG_PHP_Error(E_ERROR, "Type error in argument 4 of Feature_GetFieldAsIntegerList. Expected SWIGTYPE_p_p_int");
 
5047
    }
 
5048
  }
 
5049
  OGRFeatureShadow_GetFieldAsIntegerList(arg1,arg2,arg3,(int const **)arg4);
 
5050
  
 
5051
  return;
 
5052
fail:
 
5053
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
5054
}
 
5055
 
 
5056
 
 
5057
ZEND_NAMED_FUNCTION(_wrap_Feature_GetFieldAsDoubleList) {
 
5058
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
5059
  int arg2 ;
 
5060
  int *arg3 = (int *) 0 ;
 
5061
  double **arg4 = (double **) 0 ;
 
5062
  zval **args[4];
 
5063
  
 
5064
  SWIG_ResetError();
 
5065
  if(ZEND_NUM_ARGS() != 4 || zend_get_parameters_array_ex(4, args) != SUCCESS) {
 
5066
    WRONG_PARAM_COUNT;
 
5067
  }
 
5068
  
 
5069
  {
 
5070
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
5071
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldAsDoubleList. Expected SWIGTYPE_p_OGRFeatureShadow");
 
5072
    }
 
5073
  }
 
5074
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
5075
  
 
5076
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5077
  convert_to_long_ex(args[1]);
 
5078
  arg2 = (int) Z_LVAL_PP(args[1]);
 
5079
  /*@SWIG@*/;
 
5080
  
 
5081
  {
 
5082
    if(SWIG_ConvertPtr(*args[2], (void **) &arg3, SWIGTYPE_p_int, 0) < 0) {
 
5083
      SWIG_PHP_Error(E_ERROR, "Type error in argument 3 of Feature_GetFieldAsDoubleList. Expected SWIGTYPE_p_int");
 
5084
    }
 
5085
  }
 
5086
  {
 
5087
    if(SWIG_ConvertPtr(*args[3], (void **) &arg4, SWIGTYPE_p_p_double, 0) < 0) {
 
5088
      SWIG_PHP_Error(E_ERROR, "Type error in argument 4 of Feature_GetFieldAsDoubleList. Expected SWIGTYPE_p_p_double");
 
5089
    }
 
5090
  }
 
5091
  OGRFeatureShadow_GetFieldAsDoubleList(arg1,arg2,arg3,(double const **)arg4);
 
5092
  
 
5093
  return;
 
5094
fail:
 
5095
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
5096
}
 
5097
 
 
5098
 
 
5099
ZEND_NAMED_FUNCTION(_wrap_Feature_GetFieldAsStringList) {
 
5100
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
5101
  int arg2 ;
 
5102
  char ***arg3 = (char ***) 0 ;
 
5103
  zval **args[3];
 
5104
  
 
5105
  SWIG_ResetError();
 
5106
  if(ZEND_NUM_ARGS() != 3 || zend_get_parameters_array_ex(3, args) != SUCCESS) {
 
5107
    WRONG_PARAM_COUNT;
 
5108
  }
 
5109
  
 
5110
  {
 
5111
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
5112
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldAsStringList. Expected SWIGTYPE_p_OGRFeatureShadow");
 
5113
    }
 
5114
  }
 
5115
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
5116
  
 
5117
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5118
  convert_to_long_ex(args[1]);
 
5119
  arg2 = (int) Z_LVAL_PP(args[1]);
 
5120
  /*@SWIG@*/;
 
5121
  
 
5122
  {
 
5123
    if(SWIG_ConvertPtr(*args[2], (void **) &arg3, SWIGTYPE_p_p_p_char, 0) < 0) {
 
5124
      SWIG_PHP_Error(E_ERROR, "Type error in argument 3 of Feature_GetFieldAsStringList. Expected SWIGTYPE_p_p_p_char");
 
5125
    }
 
5126
  }
 
5127
  OGRFeatureShadow_GetFieldAsStringList(arg1,arg2,arg3);
 
5128
  
 
5129
  return;
 
5130
fail:
 
5131
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
4904
5132
}
4905
5133
 
4906
5134
 
4907
5135
ZEND_NAMED_FUNCTION(_wrap_Feature_IsFieldSet__SWIG_0) {
4908
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4909
 
    int arg2 ;
4910
 
    int result;
4911
 
    zval **args[1];
4912
 
    
4913
 
    SWIG_ResetError();
4914
 
    /* This function uses a this_ptr*/
4915
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
4916
 
        WRONG_PARAM_COUNT;
4917
 
    }
4918
 
    
4919
 
    {
4920
 
        /* typemap(in) SWIGTYPE * */
4921
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
4922
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_IsFieldSet. Expected SWIGTYPE_p_p_OGRFeatureShadow");
4923
 
        }
4924
 
    }
4925
 
    {
4926
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
4927
 
        convert_to_long_ex(args[0]);
4928
 
        arg2 = (int) Z_LVAL_PP(args[0]);
4929
 
        /*@@*/;
4930
 
    }
4931
 
    result = (int)OGRFeatureShadow_IsFieldSet__SWIG_0(arg1,arg2);
4932
 
    
4933
 
    {
4934
 
        ZVAL_LONG(return_value,result);
4935
 
    }
4936
 
    return;
4937
 
    fail:
4938
 
    zend_error(ErrorCode(),ErrorMsg());
 
5136
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
5137
  int arg2 ;
 
5138
  zval **args[2];
 
5139
  bool result;
 
5140
  
 
5141
  SWIG_ResetError();
 
5142
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
5143
    WRONG_PARAM_COUNT;
 
5144
  }
 
5145
  
 
5146
  {
 
5147
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
5148
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_IsFieldSet. Expected SWIGTYPE_p_OGRFeatureShadow");
 
5149
    }
 
5150
  }
 
5151
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
5152
  
 
5153
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5154
  convert_to_long_ex(args[1]);
 
5155
  arg2 = (int) Z_LVAL_PP(args[1]);
 
5156
  /*@SWIG@*/;
 
5157
  
 
5158
  result = (bool)OGRFeatureShadow_IsFieldSet__SWIG_0(arg1,arg2);
 
5159
  {
 
5160
    ZVAL_BOOL(return_value,(result)?1:0);
 
5161
  }
 
5162
  return;
 
5163
fail:
 
5164
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
4939
5165
}
4940
5166
 
4941
5167
 
4942
5168
ZEND_NAMED_FUNCTION(_wrap_Feature_IsFieldSet__SWIG_1) {
4943
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
4944
 
    char *arg2 = (char *) 0 ;
4945
 
    int result;
4946
 
    zval **args[1];
4947
 
    
4948
 
    SWIG_ResetError();
4949
 
    /* This function uses a this_ptr*/
4950
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
4951
 
        WRONG_PARAM_COUNT;
4952
 
    }
4953
 
    
4954
 
    {
4955
 
        /* typemap(in) SWIGTYPE * */
4956
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
4957
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_IsFieldSet. Expected SWIGTYPE_p_p_OGRFeatureShadow");
4958
 
        }
4959
 
    }
4960
 
    {
4961
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
4962
 
        convert_to_string_ex(args[0]);
4963
 
        arg2 = (char *) Z_STRVAL_PP(args[0]);
4964
 
        /*@@*/;
4965
 
    }
4966
 
    result = (int)OGRFeatureShadow_IsFieldSet__SWIG_1(arg1,(char const *)arg2);
4967
 
    
4968
 
    {
4969
 
        ZVAL_LONG(return_value,result);
4970
 
    }
4971
 
    return;
4972
 
    fail:
4973
 
    zend_error(ErrorCode(),ErrorMsg());
 
5169
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
5170
  char *arg2 = (char *) 0 ;
 
5171
  zval **args[2];
 
5172
  bool result;
 
5173
  
 
5174
  SWIG_ResetError();
 
5175
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
5176
    WRONG_PARAM_COUNT;
 
5177
  }
 
5178
  
 
5179
  {
 
5180
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
5181
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_IsFieldSet. Expected SWIGTYPE_p_OGRFeatureShadow");
 
5182
    }
 
5183
  }
 
5184
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
5185
  
 
5186
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
5187
  if ((*args[1])->type==IS_NULL) {
 
5188
    arg2 = (char *) 0;
 
5189
  } else {
 
5190
    convert_to_string_ex(args[1]);
 
5191
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
5192
  }
 
5193
  /*@SWIG@*/;
 
5194
  
 
5195
  {
 
5196
    if (!arg2) {
 
5197
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
5198
    }
 
5199
  }
 
5200
  result = (bool)OGRFeatureShadow_IsFieldSet__SWIG_1(arg1,(char const *)arg2);
 
5201
  {
 
5202
    ZVAL_BOOL(return_value,(result)?1:0);
 
5203
  }
 
5204
  return;
 
5205
fail:
 
5206
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
4974
5207
}
4975
5208
 
4976
5209
 
4977
5210
ZEND_NAMED_FUNCTION(_wrap_Feature_IsFieldSet) {
4978
 
    int argc;
4979
 
    zval **argv[2];
4980
 
    int ii;
4981
 
    
4982
 
    argc = ZEND_NUM_ARGS();
4983
 
    zend_get_parameters_array_ex(argc,argv);
4984
 
    if (argc == 2) {
4985
 
        int _v;
4986
 
        {
4987
 
            /* typecheck SWIGTYPE * */
4988
 
            void *tmp;
4989
 
            _v = (SWIG_ConvertPtr( *argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) < 0)? 0:1;
4990
 
        }
4991
 
        if (_v) {
4992
 
            _v = (Z_TYPE_PP(argv[1]) == IS_LONG ||
4993
 
            Z_TYPE_PP(argv[1]) == IS_DOUBLE ||
4994
 
            Z_TYPE_PP(argv[1]) == IS_STRING) ? 1 : 0; 
4995
 
            if (_v) {
4996
 
                return _wrap_Feature_IsFieldSet__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU);
4997
 
            }
4998
 
        }
4999
 
    }
5000
 
    if (argc == 2) {
5001
 
        int _v;
5002
 
        {
5003
 
            /* typecheck SWIGTYPE * */
5004
 
            void *tmp;
5005
 
            _v = (SWIG_ConvertPtr( *argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) < 0)? 0:1;
5006
 
        }
5007
 
        if (_v) {
5008
 
            _v = (Z_TYPE_PP(argv[1]) == IS_LONG ||
5009
 
            Z_TYPE_PP(argv[1]) == IS_DOUBLE ||
5010
 
            Z_TYPE_PP(argv[1]) == IS_STRING) ? 1 : 0; 
5011
 
            if (_v) {
5012
 
                return _wrap_Feature_IsFieldSet__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU);
5013
 
            }
5014
 
        }
5015
 
    }
5016
 
    
5017
 
    /*No matching function for overloaded 'Feature_IsFieldSet'*/
5018
 
    
 
5211
  int argc;
 
5212
  zval **argv[2];
 
5213
  
 
5214
  argc = ZEND_NUM_ARGS();
 
5215
  zend_get_parameters_array_ex(argc,argv);
 
5216
  if (argc == 2) {
 
5217
    int _v;
 
5218
    {
 
5219
      void *tmp;
 
5220
      _v = (SWIG_ConvertPtr(*argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) >= 0);
 
5221
    }
 
5222
    if (_v) {
 
5223
      _v = (Z_TYPE_PP(argv[1]) == IS_LONG); 
 
5224
      if (_v) {
 
5225
        return _wrap_Feature_IsFieldSet__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
5226
      }
 
5227
    }
 
5228
  }
 
5229
  if (argc == 2) {
 
5230
    int _v;
 
5231
    {
 
5232
      void *tmp;
 
5233
      _v = (SWIG_ConvertPtr(*argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) >= 0);
 
5234
    }
 
5235
    if (_v) {
 
5236
      _v = (Z_TYPE_PP(argv[1]) == IS_STRING); 
 
5237
      if (_v) {
 
5238
        return _wrap_Feature_IsFieldSet__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
5239
      }
 
5240
    }
 
5241
  }
 
5242
  
 
5243
  SWIG_ErrorCode() = E_ERROR;
 
5244
  SWIG_ErrorMsg() = "No matching function for overloaded 'Feature_IsFieldSet'";
 
5245
  zend_error(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5019
5246
}
5020
5247
 
5021
5248
 
5022
5249
ZEND_NAMED_FUNCTION(_wrap_Feature_GetFieldIndex) {
5023
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5024
 
    char *arg2 = (char *) 0 ;
5025
 
    int result;
5026
 
    zval **args[1];
5027
 
    
5028
 
    SWIG_ResetError();
5029
 
    /* This function uses a this_ptr*/
5030
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
5031
 
        WRONG_PARAM_COUNT;
5032
 
    }
5033
 
    
5034
 
    {
5035
 
        /* typemap(in) SWIGTYPE * */
5036
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
5037
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldIndex. Expected SWIGTYPE_p_p_OGRFeatureShadow");
5038
 
        }
5039
 
    }
5040
 
    {
5041
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
5042
 
        convert_to_string_ex(args[0]);
5043
 
        arg2 = (char *) Z_STRVAL_PP(args[0]);
5044
 
        /*@@*/;
5045
 
    }
5046
 
    result = (int)OGRFeatureShadow_GetFieldIndex(arg1,(char const *)arg2);
5047
 
    
5048
 
    {
5049
 
        ZVAL_LONG(return_value,result);
5050
 
    }
5051
 
    return;
5052
 
    fail:
5053
 
    zend_error(ErrorCode(),ErrorMsg());
 
5250
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
5251
  char *arg2 = (char *) 0 ;
 
5252
  zval **args[2];
 
5253
  int result;
 
5254
  
 
5255
  SWIG_ResetError();
 
5256
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
5257
    WRONG_PARAM_COUNT;
 
5258
  }
 
5259
  
 
5260
  {
 
5261
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
5262
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldIndex. Expected SWIGTYPE_p_OGRFeatureShadow");
 
5263
    }
 
5264
  }
 
5265
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
5266
  
 
5267
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
5268
  if ((*args[1])->type==IS_NULL) {
 
5269
    arg2 = (char *) 0;
 
5270
  } else {
 
5271
    convert_to_string_ex(args[1]);
 
5272
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
5273
  }
 
5274
  /*@SWIG@*/;
 
5275
  
 
5276
  {
 
5277
    if (!arg2) {
 
5278
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
5279
    }
 
5280
  }
 
5281
  result = (int)OGRFeatureShadow_GetFieldIndex(arg1,(char const *)arg2);
 
5282
  {
 
5283
    ZVAL_LONG(return_value,result);
 
5284
  }
 
5285
  return;
 
5286
fail:
 
5287
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5054
5288
}
5055
5289
 
5056
5290
 
5057
5291
ZEND_NAMED_FUNCTION(_wrap_Feature_GetFID) {
5058
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5059
 
    int result;
5060
 
    zval **args[0];
5061
 
    
5062
 
    SWIG_ResetError();
5063
 
    /* This function uses a this_ptr*/
5064
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
5065
 
        WRONG_PARAM_COUNT;
5066
 
    }
5067
 
    
5068
 
    {
5069
 
        /* typemap(in) SWIGTYPE * */
5070
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
5071
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFID. Expected SWIGTYPE_p_p_OGRFeatureShadow");
5072
 
        }
5073
 
    }
5074
 
    result = (int)OGRFeatureShadow_GetFID(arg1);
5075
 
    
5076
 
    {
5077
 
        ZVAL_LONG(return_value,result);
5078
 
    }
5079
 
    return;
5080
 
    fail:
5081
 
    zend_error(ErrorCode(),ErrorMsg());
 
5292
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
5293
  zval **args[1];
 
5294
  int result;
 
5295
  
 
5296
  SWIG_ResetError();
 
5297
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
5298
    WRONG_PARAM_COUNT;
 
5299
  }
 
5300
  
 
5301
  {
 
5302
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
5303
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFID. Expected SWIGTYPE_p_OGRFeatureShadow");
 
5304
    }
 
5305
  }
 
5306
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
5307
  result = (int)OGRFeatureShadow_GetFID(arg1);
 
5308
  {
 
5309
    ZVAL_LONG(return_value,result);
 
5310
  }
 
5311
  return;
 
5312
fail:
 
5313
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5082
5314
}
5083
5315
 
5084
5316
 
5085
5317
ZEND_NAMED_FUNCTION(_wrap_Feature_SetFID) {
5086
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5087
 
    int arg2 ;
5088
 
    OGRErr result;
5089
 
    zval **args[1];
5090
 
    
5091
 
    SWIG_ResetError();
5092
 
    /* This function uses a this_ptr*/
5093
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
5094
 
        WRONG_PARAM_COUNT;
5095
 
    }
5096
 
    
5097
 
    {
5098
 
        /* typemap(in) SWIGTYPE * */
5099
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
5100
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_SetFID. Expected SWIGTYPE_p_p_OGRFeatureShadow");
5101
 
        }
5102
 
    }
5103
 
    {
5104
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
5105
 
        convert_to_long_ex(args[0]);
5106
 
        arg2 = (int) Z_LVAL_PP(args[0]);
5107
 
        /*@@*/;
5108
 
    }
5109
 
    result = (OGRErr)OGRFeatureShadow_SetFID(arg1,arg2);
5110
 
    
5111
 
    {
5112
 
        /* %typemap(out) OGRErr */
5113
 
        if (result != 0 ) {
5114
 
            SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
5115
 
        }
5116
 
    }
5117
 
    {
5118
 
        /* %typemap(ret) OGRErr */
5119
 
        RETVAL_LONG(0);
5120
 
    }
5121
 
    return;
5122
 
    fail:
5123
 
    zend_error(ErrorCode(),ErrorMsg());
 
5318
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
5319
  int arg2 ;
 
5320
  zval **args[2];
 
5321
  OGRErr result;
 
5322
  
 
5323
  SWIG_ResetError();
 
5324
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
5325
    WRONG_PARAM_COUNT;
 
5326
  }
 
5327
  
 
5328
  {
 
5329
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
5330
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_SetFID. Expected SWIGTYPE_p_OGRFeatureShadow");
 
5331
    }
 
5332
  }
 
5333
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
5334
  
 
5335
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5336
  convert_to_long_ex(args[1]);
 
5337
  arg2 = (int) Z_LVAL_PP(args[1]);
 
5338
  /*@SWIG@*/;
 
5339
  
 
5340
  result = (OGRErr)OGRFeatureShadow_SetFID(arg1,arg2);
 
5341
  {
 
5342
    /* %typemap(out) OGRErr */
 
5343
    if (result != 0 ) {
 
5344
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
5345
    }
 
5346
  }
 
5347
  {
 
5348
    /* %typemap(ret) OGRErr */
 
5349
    RETVAL_LONG(0);
 
5350
  }
 
5351
  return;
 
5352
fail:
 
5353
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5124
5354
}
5125
5355
 
5126
5356
 
5127
5357
ZEND_NAMED_FUNCTION(_wrap_Feature_DumpReadable) {
5128
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5129
 
    zval **args[0];
5130
 
    
5131
 
    SWIG_ResetError();
5132
 
    /* This function uses a this_ptr*/
5133
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
5134
 
        WRONG_PARAM_COUNT;
5135
 
    }
5136
 
    
5137
 
    {
5138
 
        /* typemap(in) SWIGTYPE * */
5139
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
5140
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_DumpReadable. Expected SWIGTYPE_p_p_OGRFeatureShadow");
5141
 
        }
5142
 
    }
5143
 
    OGRFeatureShadow_DumpReadable(arg1);
5144
 
    
5145
 
    
5146
 
    return;
5147
 
    fail:
5148
 
    zend_error(ErrorCode(),ErrorMsg());
 
5358
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
5359
  zval **args[1];
 
5360
  
 
5361
  SWIG_ResetError();
 
5362
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
5363
    WRONG_PARAM_COUNT;
 
5364
  }
 
5365
  
 
5366
  {
 
5367
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
5368
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_DumpReadable. Expected SWIGTYPE_p_OGRFeatureShadow");
 
5369
    }
 
5370
  }
 
5371
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
5372
  OGRFeatureShadow_DumpReadable(arg1);
 
5373
  
 
5374
  return;
 
5375
fail:
 
5376
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5149
5377
}
5150
5378
 
5151
5379
 
5152
5380
ZEND_NAMED_FUNCTION(_wrap_Feature_UnsetField__SWIG_0) {
5153
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5154
 
    int arg2 ;
5155
 
    zval **args[1];
5156
 
    
5157
 
    SWIG_ResetError();
5158
 
    /* This function uses a this_ptr*/
5159
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
5160
 
        WRONG_PARAM_COUNT;
5161
 
    }
5162
 
    
5163
 
    {
5164
 
        /* typemap(in) SWIGTYPE * */
5165
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
5166
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_UnsetField. Expected SWIGTYPE_p_p_OGRFeatureShadow");
5167
 
        }
5168
 
    }
5169
 
    {
5170
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
5171
 
        convert_to_long_ex(args[0]);
5172
 
        arg2 = (int) Z_LVAL_PP(args[0]);
5173
 
        /*@@*/;
5174
 
    }
5175
 
    OGRFeatureShadow_UnsetField__SWIG_0(arg1,arg2);
5176
 
    
5177
 
    
5178
 
    return;
5179
 
    fail:
5180
 
    zend_error(ErrorCode(),ErrorMsg());
 
5381
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
5382
  int arg2 ;
 
5383
  zval **args[2];
 
5384
  
 
5385
  SWIG_ResetError();
 
5386
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
5387
    WRONG_PARAM_COUNT;
 
5388
  }
 
5389
  
 
5390
  {
 
5391
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
5392
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_UnsetField. Expected SWIGTYPE_p_OGRFeatureShadow");
 
5393
    }
 
5394
  }
 
5395
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
5396
  
 
5397
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5398
  convert_to_long_ex(args[1]);
 
5399
  arg2 = (int) Z_LVAL_PP(args[1]);
 
5400
  /*@SWIG@*/;
 
5401
  
 
5402
  OGRFeatureShadow_UnsetField__SWIG_0(arg1,arg2);
 
5403
  
 
5404
  return;
 
5405
fail:
 
5406
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5181
5407
}
5182
5408
 
5183
5409
 
5184
5410
ZEND_NAMED_FUNCTION(_wrap_Feature_UnsetField__SWIG_1) {
5185
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5186
 
    char *arg2 = (char *) 0 ;
5187
 
    zval **args[1];
5188
 
    
5189
 
    SWIG_ResetError();
5190
 
    /* This function uses a this_ptr*/
5191
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
5192
 
        WRONG_PARAM_COUNT;
5193
 
    }
5194
 
    
5195
 
    {
5196
 
        /* typemap(in) SWIGTYPE * */
5197
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
5198
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_UnsetField. Expected SWIGTYPE_p_p_OGRFeatureShadow");
5199
 
        }
5200
 
    }
5201
 
    {
5202
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
5203
 
        convert_to_string_ex(args[0]);
5204
 
        arg2 = (char *) Z_STRVAL_PP(args[0]);
5205
 
        /*@@*/;
5206
 
    }
5207
 
    OGRFeatureShadow_UnsetField__SWIG_1(arg1,(char const *)arg2);
5208
 
    
5209
 
    
5210
 
    return;
5211
 
    fail:
5212
 
    zend_error(ErrorCode(),ErrorMsg());
 
5411
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
5412
  char *arg2 = (char *) 0 ;
 
5413
  zval **args[2];
 
5414
  
 
5415
  SWIG_ResetError();
 
5416
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
5417
    WRONG_PARAM_COUNT;
 
5418
  }
 
5419
  
 
5420
  {
 
5421
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
5422
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_UnsetField. Expected SWIGTYPE_p_OGRFeatureShadow");
 
5423
    }
 
5424
  }
 
5425
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
5426
  
 
5427
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
5428
  if ((*args[1])->type==IS_NULL) {
 
5429
    arg2 = (char *) 0;
 
5430
  } else {
 
5431
    convert_to_string_ex(args[1]);
 
5432
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
5433
  }
 
5434
  /*@SWIG@*/;
 
5435
  
 
5436
  {
 
5437
    if (!arg2) {
 
5438
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
5439
    }
 
5440
  }
 
5441
  OGRFeatureShadow_UnsetField__SWIG_1(arg1,(char const *)arg2);
 
5442
  
 
5443
  return;
 
5444
fail:
 
5445
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5213
5446
}
5214
5447
 
5215
5448
 
5216
5449
ZEND_NAMED_FUNCTION(_wrap_Feature_UnsetField) {
5217
 
    int argc;
5218
 
    zval **argv[2];
5219
 
    int ii;
5220
 
    
5221
 
    argc = ZEND_NUM_ARGS();
5222
 
    zend_get_parameters_array_ex(argc,argv);
5223
 
    if (argc == 2) {
5224
 
        int _v;
5225
 
        {
5226
 
            /* typecheck SWIGTYPE * */
5227
 
            void *tmp;
5228
 
            _v = (SWIG_ConvertPtr( *argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) < 0)? 0:1;
5229
 
        }
5230
 
        if (_v) {
5231
 
            _v = (Z_TYPE_PP(argv[1]) == IS_LONG ||
5232
 
            Z_TYPE_PP(argv[1]) == IS_DOUBLE ||
5233
 
            Z_TYPE_PP(argv[1]) == IS_STRING) ? 1 : 0; 
5234
 
            if (_v) {
5235
 
                return _wrap_Feature_UnsetField__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU);
5236
 
            }
5237
 
        }
5238
 
    }
5239
 
    if (argc == 2) {
5240
 
        int _v;
5241
 
        {
5242
 
            /* typecheck SWIGTYPE * */
5243
 
            void *tmp;
5244
 
            _v = (SWIG_ConvertPtr( *argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) < 0)? 0:1;
5245
 
        }
5246
 
        if (_v) {
5247
 
            _v = (Z_TYPE_PP(argv[1]) == IS_LONG ||
5248
 
            Z_TYPE_PP(argv[1]) == IS_DOUBLE ||
5249
 
            Z_TYPE_PP(argv[1]) == IS_STRING) ? 1 : 0; 
5250
 
            if (_v) {
5251
 
                return _wrap_Feature_UnsetField__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU);
5252
 
            }
5253
 
        }
5254
 
    }
5255
 
    
5256
 
    /*No matching function for overloaded 'Feature_UnsetField'*/
5257
 
    
 
5450
  int argc;
 
5451
  zval **argv[2];
 
5452
  
 
5453
  argc = ZEND_NUM_ARGS();
 
5454
  zend_get_parameters_array_ex(argc,argv);
 
5455
  if (argc == 2) {
 
5456
    int _v;
 
5457
    {
 
5458
      void *tmp;
 
5459
      _v = (SWIG_ConvertPtr(*argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) >= 0);
 
5460
    }
 
5461
    if (_v) {
 
5462
      _v = (Z_TYPE_PP(argv[1]) == IS_LONG); 
 
5463
      if (_v) {
 
5464
        return _wrap_Feature_UnsetField__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
5465
      }
 
5466
    }
 
5467
  }
 
5468
  if (argc == 2) {
 
5469
    int _v;
 
5470
    {
 
5471
      void *tmp;
 
5472
      _v = (SWIG_ConvertPtr(*argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) >= 0);
 
5473
    }
 
5474
    if (_v) {
 
5475
      _v = (Z_TYPE_PP(argv[1]) == IS_STRING); 
 
5476
      if (_v) {
 
5477
        return _wrap_Feature_UnsetField__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
5478
      }
 
5479
    }
 
5480
  }
 
5481
  
 
5482
  SWIG_ErrorCode() = E_ERROR;
 
5483
  SWIG_ErrorMsg() = "No matching function for overloaded 'Feature_UnsetField'";
 
5484
  zend_error(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5258
5485
}
5259
5486
 
5260
5487
 
5261
5488
ZEND_NAMED_FUNCTION(_wrap_Feature_SetField__SWIG_0) {
5262
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5263
 
    int arg2 ;
5264
 
    char *arg3 = (char *) 0 ;
5265
 
    zval **args[2];
5266
 
    
5267
 
    SWIG_ResetError();
5268
 
    /* This function uses a this_ptr*/
5269
 
    if(((ZEND_NUM_ARGS() )!= 2) || (zend_get_parameters_array_ex(2, args)!= SUCCESS)) {
5270
 
        WRONG_PARAM_COUNT;
5271
 
    }
5272
 
    
5273
 
    {
5274
 
        /* typemap(in) SWIGTYPE * */
5275
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
5276
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_SetField. Expected SWIGTYPE_p_p_OGRFeatureShadow");
5277
 
        }
5278
 
    }
5279
 
    {
5280
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
5281
 
        convert_to_long_ex(args[0]);
5282
 
        arg2 = (int) Z_LVAL_PP(args[0]);
5283
 
        /*@@*/;
5284
 
    }
5285
 
    {
5286
 
        /* %typemap(in) (tostring argin) */
5287
 
        convert_to_string_ex(args[1]);
5288
 
        arg3 = Z_STRVAL_PP( args[1] );
5289
 
    }
5290
 
    OGRFeatureShadow_SetField__SWIG_0(arg1,arg2,(char const *)arg3);
5291
 
    
5292
 
    
5293
 
    return;
5294
 
    fail:
5295
 
    zend_error(ErrorCode(),ErrorMsg());
 
5489
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
5490
  int arg2 ;
 
5491
  char *arg3 = (char *) 0 ;
 
5492
  zval **args[3];
 
5493
  
 
5494
  SWIG_ResetError();
 
5495
  if(ZEND_NUM_ARGS() != 3 || zend_get_parameters_array_ex(3, args) != SUCCESS) {
 
5496
    WRONG_PARAM_COUNT;
 
5497
  }
 
5498
  
 
5499
  {
 
5500
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
5501
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_SetField. Expected SWIGTYPE_p_OGRFeatureShadow");
 
5502
    }
 
5503
  }
 
5504
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
5505
  
 
5506
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5507
  convert_to_long_ex(args[1]);
 
5508
  arg2 = (int) Z_LVAL_PP(args[1]);
 
5509
  /*@SWIG@*/;
 
5510
  
 
5511
  {
 
5512
    /* %typemap(in) (tostring argin) */
 
5513
    convert_to_string_ex(args[2]);
 
5514
    arg3 = Z_STRVAL_PP( args[2] );
 
5515
  }
 
5516
  OGRFeatureShadow_SetField__SWIG_0(arg1,arg2,(char const *)arg3);
 
5517
  
 
5518
  return;
 
5519
fail:
 
5520
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5296
5521
}
5297
5522
 
5298
5523
 
5299
5524
ZEND_NAMED_FUNCTION(_wrap_Feature_SetField__SWIG_1) {
5300
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5301
 
    char *arg2 = (char *) 0 ;
5302
 
    char *arg3 = (char *) 0 ;
5303
 
    zval **args[2];
5304
 
    
5305
 
    SWIG_ResetError();
5306
 
    /* This function uses a this_ptr*/
5307
 
    if(((ZEND_NUM_ARGS() )!= 2) || (zend_get_parameters_array_ex(2, args)!= SUCCESS)) {
5308
 
        WRONG_PARAM_COUNT;
5309
 
    }
5310
 
    
5311
 
    {
5312
 
        /* typemap(in) SWIGTYPE * */
5313
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
5314
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_SetField. Expected SWIGTYPE_p_p_OGRFeatureShadow");
5315
 
        }
5316
 
    }
5317
 
    {
5318
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
5319
 
        convert_to_string_ex(args[0]);
5320
 
        arg2 = (char *) Z_STRVAL_PP(args[0]);
5321
 
        /*@@*/;
5322
 
    }
5323
 
    {
5324
 
        /* %typemap(in) (tostring argin) */
5325
 
        convert_to_string_ex(args[1]);
5326
 
        arg3 = Z_STRVAL_PP( args[1] );
5327
 
    }
5328
 
    OGRFeatureShadow_SetField__SWIG_1(arg1,(char const *)arg2,(char const *)arg3);
5329
 
    
5330
 
    
5331
 
    return;
5332
 
    fail:
5333
 
    zend_error(ErrorCode(),ErrorMsg());
 
5525
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
5526
  char *arg2 = (char *) 0 ;
 
5527
  char *arg3 = (char *) 0 ;
 
5528
  zval **args[3];
 
5529
  
 
5530
  SWIG_ResetError();
 
5531
  if(ZEND_NUM_ARGS() != 3 || zend_get_parameters_array_ex(3, args) != SUCCESS) {
 
5532
    WRONG_PARAM_COUNT;
 
5533
  }
 
5534
  
 
5535
  {
 
5536
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
5537
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_SetField. Expected SWIGTYPE_p_OGRFeatureShadow");
 
5538
    }
 
5539
  }
 
5540
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
5541
  
 
5542
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
5543
  if ((*args[1])->type==IS_NULL) {
 
5544
    arg2 = (char *) 0;
 
5545
  } else {
 
5546
    convert_to_string_ex(args[1]);
 
5547
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
5548
  }
 
5549
  /*@SWIG@*/;
 
5550
  
 
5551
  {
 
5552
    /* %typemap(in) (tostring argin) */
 
5553
    convert_to_string_ex(args[2]);
 
5554
    arg3 = Z_STRVAL_PP( args[2] );
 
5555
  }
 
5556
  {
 
5557
    if (!arg2) {
 
5558
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
5559
    }
 
5560
  }
 
5561
  OGRFeatureShadow_SetField__SWIG_1(arg1,(char const *)arg2,(char const *)arg3);
 
5562
  
 
5563
  return;
 
5564
fail:
 
5565
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
5566
}
 
5567
 
 
5568
 
 
5569
ZEND_NAMED_FUNCTION(_wrap_Feature_SetField__SWIG_2) {
 
5570
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
5571
  int arg2 ;
 
5572
  int arg3 ;
 
5573
  zval **args[3];
 
5574
  
 
5575
  SWIG_ResetError();
 
5576
  if(ZEND_NUM_ARGS() != 3 || zend_get_parameters_array_ex(3, args) != SUCCESS) {
 
5577
    WRONG_PARAM_COUNT;
 
5578
  }
 
5579
  
 
5580
  {
 
5581
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
5582
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_SetField. Expected SWIGTYPE_p_OGRFeatureShadow");
 
5583
    }
 
5584
  }
 
5585
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
5586
  
 
5587
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5588
  convert_to_long_ex(args[1]);
 
5589
  arg2 = (int) Z_LVAL_PP(args[1]);
 
5590
  /*@SWIG@*/;
 
5591
  
 
5592
  
 
5593
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5594
  convert_to_long_ex(args[2]);
 
5595
  arg3 = (int) Z_LVAL_PP(args[2]);
 
5596
  /*@SWIG@*/;
 
5597
  
 
5598
  OGRFeatureShadow_SetField__SWIG_2(arg1,arg2,arg3);
 
5599
  
 
5600
  return;
 
5601
fail:
 
5602
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
5603
}
 
5604
 
 
5605
 
 
5606
ZEND_NAMED_FUNCTION(_wrap_Feature_SetField__SWIG_3) {
 
5607
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
5608
  char *arg2 = (char *) 0 ;
 
5609
  int arg3 ;
 
5610
  zval **args[3];
 
5611
  
 
5612
  SWIG_ResetError();
 
5613
  if(ZEND_NUM_ARGS() != 3 || zend_get_parameters_array_ex(3, args) != SUCCESS) {
 
5614
    WRONG_PARAM_COUNT;
 
5615
  }
 
5616
  
 
5617
  {
 
5618
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
5619
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_SetField. Expected SWIGTYPE_p_OGRFeatureShadow");
 
5620
    }
 
5621
  }
 
5622
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
5623
  
 
5624
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
5625
  if ((*args[1])->type==IS_NULL) {
 
5626
    arg2 = (char *) 0;
 
5627
  } else {
 
5628
    convert_to_string_ex(args[1]);
 
5629
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
5630
  }
 
5631
  /*@SWIG@*/;
 
5632
  
 
5633
  
 
5634
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5635
  convert_to_long_ex(args[2]);
 
5636
  arg3 = (int) Z_LVAL_PP(args[2]);
 
5637
  /*@SWIG@*/;
 
5638
  
 
5639
  {
 
5640
    if (!arg2) {
 
5641
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
5642
    }
 
5643
  }
 
5644
  OGRFeatureShadow_SetField__SWIG_3(arg1,(char const *)arg2,arg3);
 
5645
  
 
5646
  return;
 
5647
fail:
 
5648
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
5649
}
 
5650
 
 
5651
 
 
5652
ZEND_NAMED_FUNCTION(_wrap_Feature_SetField__SWIG_4) {
 
5653
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
5654
  int arg2 ;
 
5655
  double arg3 ;
 
5656
  zval **args[3];
 
5657
  
 
5658
  SWIG_ResetError();
 
5659
  if(ZEND_NUM_ARGS() != 3 || zend_get_parameters_array_ex(3, args) != SUCCESS) {
 
5660
    WRONG_PARAM_COUNT;
 
5661
  }
 
5662
  
 
5663
  {
 
5664
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
5665
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_SetField. Expected SWIGTYPE_p_OGRFeatureShadow");
 
5666
    }
 
5667
  }
 
5668
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
5669
  
 
5670
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5671
  convert_to_long_ex(args[1]);
 
5672
  arg2 = (int) Z_LVAL_PP(args[1]);
 
5673
  /*@SWIG@*/;
 
5674
  
 
5675
  
 
5676
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
5677
  convert_to_double_ex(args[2]);
 
5678
  arg3 = (double) Z_DVAL_PP(args[2]);
 
5679
  /*@SWIG@*/;
 
5680
  
 
5681
  OGRFeatureShadow_SetField__SWIG_4(arg1,arg2,arg3);
 
5682
  
 
5683
  return;
 
5684
fail:
 
5685
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
5686
}
 
5687
 
 
5688
 
 
5689
ZEND_NAMED_FUNCTION(_wrap_Feature_SetField__SWIG_5) {
 
5690
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
5691
  char *arg2 = (char *) 0 ;
 
5692
  double arg3 ;
 
5693
  zval **args[3];
 
5694
  
 
5695
  SWIG_ResetError();
 
5696
  if(ZEND_NUM_ARGS() != 3 || zend_get_parameters_array_ex(3, args) != SUCCESS) {
 
5697
    WRONG_PARAM_COUNT;
 
5698
  }
 
5699
  
 
5700
  {
 
5701
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
5702
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_SetField. Expected SWIGTYPE_p_OGRFeatureShadow");
 
5703
    }
 
5704
  }
 
5705
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
5706
  
 
5707
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
5708
  if ((*args[1])->type==IS_NULL) {
 
5709
    arg2 = (char *) 0;
 
5710
  } else {
 
5711
    convert_to_string_ex(args[1]);
 
5712
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
5713
  }
 
5714
  /*@SWIG@*/;
 
5715
  
 
5716
  
 
5717
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
5718
  convert_to_double_ex(args[2]);
 
5719
  arg3 = (double) Z_DVAL_PP(args[2]);
 
5720
  /*@SWIG@*/;
 
5721
  
 
5722
  {
 
5723
    if (!arg2) {
 
5724
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
5725
    }
 
5726
  }
 
5727
  OGRFeatureShadow_SetField__SWIG_5(arg1,(char const *)arg2,arg3);
 
5728
  
 
5729
  return;
 
5730
fail:
 
5731
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
5732
}
 
5733
 
 
5734
 
 
5735
ZEND_NAMED_FUNCTION(_wrap_Feature_SetField__SWIG_6) {
 
5736
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
5737
  int arg2 ;
 
5738
  int arg3 ;
 
5739
  int arg4 ;
 
5740
  int arg5 ;
 
5741
  int arg6 ;
 
5742
  int arg7 ;
 
5743
  int arg8 ;
 
5744
  int arg9 ;
 
5745
  zval **args[9];
 
5746
  
 
5747
  SWIG_ResetError();
 
5748
  if(ZEND_NUM_ARGS() != 9 || zend_get_parameters_array_ex(9, args) != SUCCESS) {
 
5749
    WRONG_PARAM_COUNT;
 
5750
  }
 
5751
  
 
5752
  {
 
5753
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
5754
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_SetField. Expected SWIGTYPE_p_OGRFeatureShadow");
 
5755
    }
 
5756
  }
 
5757
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
5758
  
 
5759
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5760
  convert_to_long_ex(args[1]);
 
5761
  arg2 = (int) Z_LVAL_PP(args[1]);
 
5762
  /*@SWIG@*/;
 
5763
  
 
5764
  
 
5765
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5766
  convert_to_long_ex(args[2]);
 
5767
  arg3 = (int) Z_LVAL_PP(args[2]);
 
5768
  /*@SWIG@*/;
 
5769
  
 
5770
  
 
5771
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5772
  convert_to_long_ex(args[3]);
 
5773
  arg4 = (int) Z_LVAL_PP(args[3]);
 
5774
  /*@SWIG@*/;
 
5775
  
 
5776
  
 
5777
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5778
  convert_to_long_ex(args[4]);
 
5779
  arg5 = (int) Z_LVAL_PP(args[4]);
 
5780
  /*@SWIG@*/;
 
5781
  
 
5782
  
 
5783
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5784
  convert_to_long_ex(args[5]);
 
5785
  arg6 = (int) Z_LVAL_PP(args[5]);
 
5786
  /*@SWIG@*/;
 
5787
  
 
5788
  
 
5789
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5790
  convert_to_long_ex(args[6]);
 
5791
  arg7 = (int) Z_LVAL_PP(args[6]);
 
5792
  /*@SWIG@*/;
 
5793
  
 
5794
  
 
5795
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5796
  convert_to_long_ex(args[7]);
 
5797
  arg8 = (int) Z_LVAL_PP(args[7]);
 
5798
  /*@SWIG@*/;
 
5799
  
 
5800
  
 
5801
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5802
  convert_to_long_ex(args[8]);
 
5803
  arg9 = (int) Z_LVAL_PP(args[8]);
 
5804
  /*@SWIG@*/;
 
5805
  
 
5806
  OGRFeatureShadow_SetField__SWIG_6(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
 
5807
  
 
5808
  return;
 
5809
fail:
 
5810
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
5811
}
 
5812
 
 
5813
 
 
5814
ZEND_NAMED_FUNCTION(_wrap_Feature_SetField__SWIG_7) {
 
5815
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
5816
  char *arg2 = (char *) 0 ;
 
5817
  int arg3 ;
 
5818
  int arg4 ;
 
5819
  int arg5 ;
 
5820
  int arg6 ;
 
5821
  int arg7 ;
 
5822
  int arg8 ;
 
5823
  int arg9 ;
 
5824
  zval **args[9];
 
5825
  
 
5826
  SWIG_ResetError();
 
5827
  if(ZEND_NUM_ARGS() != 9 || zend_get_parameters_array_ex(9, args) != SUCCESS) {
 
5828
    WRONG_PARAM_COUNT;
 
5829
  }
 
5830
  
 
5831
  {
 
5832
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
5833
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_SetField. Expected SWIGTYPE_p_OGRFeatureShadow");
 
5834
    }
 
5835
  }
 
5836
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
5837
  
 
5838
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
5839
  if ((*args[1])->type==IS_NULL) {
 
5840
    arg2 = (char *) 0;
 
5841
  } else {
 
5842
    convert_to_string_ex(args[1]);
 
5843
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
5844
  }
 
5845
  /*@SWIG@*/;
 
5846
  
 
5847
  
 
5848
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5849
  convert_to_long_ex(args[2]);
 
5850
  arg3 = (int) Z_LVAL_PP(args[2]);
 
5851
  /*@SWIG@*/;
 
5852
  
 
5853
  
 
5854
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5855
  convert_to_long_ex(args[3]);
 
5856
  arg4 = (int) Z_LVAL_PP(args[3]);
 
5857
  /*@SWIG@*/;
 
5858
  
 
5859
  
 
5860
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5861
  convert_to_long_ex(args[4]);
 
5862
  arg5 = (int) Z_LVAL_PP(args[4]);
 
5863
  /*@SWIG@*/;
 
5864
  
 
5865
  
 
5866
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5867
  convert_to_long_ex(args[5]);
 
5868
  arg6 = (int) Z_LVAL_PP(args[5]);
 
5869
  /*@SWIG@*/;
 
5870
  
 
5871
  
 
5872
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5873
  convert_to_long_ex(args[6]);
 
5874
  arg7 = (int) Z_LVAL_PP(args[6]);
 
5875
  /*@SWIG@*/;
 
5876
  
 
5877
  
 
5878
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5879
  convert_to_long_ex(args[7]);
 
5880
  arg8 = (int) Z_LVAL_PP(args[7]);
 
5881
  /*@SWIG@*/;
 
5882
  
 
5883
  
 
5884
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
5885
  convert_to_long_ex(args[8]);
 
5886
  arg9 = (int) Z_LVAL_PP(args[8]);
 
5887
  /*@SWIG@*/;
 
5888
  
 
5889
  {
 
5890
    if (!arg2) {
 
5891
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
5892
    }
 
5893
  }
 
5894
  OGRFeatureShadow_SetField__SWIG_7(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
 
5895
  
 
5896
  return;
 
5897
fail:
 
5898
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5334
5899
}
5335
5900
 
5336
5901
 
5337
5902
ZEND_NAMED_FUNCTION(_wrap_Feature_SetField) {
5338
 
    int argc;
5339
 
    zval **argv[3];
5340
 
    int ii;
5341
 
    
5342
 
    argc = ZEND_NUM_ARGS();
5343
 
    zend_get_parameters_array_ex(argc,argv);
5344
 
    if (argc == 3) {
5345
 
        int _v;
5346
 
        {
5347
 
            /* typecheck SWIGTYPE * */
5348
 
            void *tmp;
5349
 
            _v = (SWIG_ConvertPtr( *argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) < 0)? 0:1;
5350
 
        }
5351
 
        if (_v) {
5352
 
            _v = (Z_TYPE_PP(argv[1]) == IS_LONG ||
5353
 
            Z_TYPE_PP(argv[1]) == IS_DOUBLE ||
5354
 
            Z_TYPE_PP(argv[1]) == IS_STRING) ? 1 : 0; 
5355
 
            if (_v) {
5356
 
                {
5357
 
                    /* %typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER) (tostring argin) */
5358
 
                    _v = 1;
5359
 
                }
5360
 
                if (_v) {
5361
 
                    return _wrap_Feature_SetField__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU);
5362
 
                }
5363
 
            }
5364
 
        }
5365
 
    }
5366
 
    if (argc == 3) {
5367
 
        int _v;
5368
 
        {
5369
 
            /* typecheck SWIGTYPE * */
5370
 
            void *tmp;
5371
 
            _v = (SWIG_ConvertPtr( *argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) < 0)? 0:1;
5372
 
        }
5373
 
        if (_v) {
5374
 
            _v = (Z_TYPE_PP(argv[1]) == IS_LONG ||
5375
 
            Z_TYPE_PP(argv[1]) == IS_DOUBLE ||
5376
 
            Z_TYPE_PP(argv[1]) == IS_STRING) ? 1 : 0; 
5377
 
            if (_v) {
5378
 
                {
5379
 
                    /* %typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER) (tostring argin) */
5380
 
                    _v = 1;
5381
 
                }
5382
 
                if (_v) {
5383
 
                    return _wrap_Feature_SetField__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU);
5384
 
                }
5385
 
            }
5386
 
        }
5387
 
    }
5388
 
    
5389
 
    /*No matching function for overloaded 'Feature_SetField'*/
5390
 
    
 
5903
  int argc;
 
5904
  zval **argv[9];
 
5905
  
 
5906
  argc = ZEND_NUM_ARGS();
 
5907
  zend_get_parameters_array_ex(argc,argv);
 
5908
  if (argc == 3) {
 
5909
    int _v;
 
5910
    {
 
5911
      void *tmp;
 
5912
      _v = (SWIG_ConvertPtr(*argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) >= 0);
 
5913
    }
 
5914
    if (_v) {
 
5915
      _v = (Z_TYPE_PP(argv[1]) == IS_LONG); 
 
5916
      if (_v) {
 
5917
        {
 
5918
          /* %typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER) (tostring argin) */
 
5919
          _v = 1;
 
5920
        }
 
5921
        if (_v) {
 
5922
          return _wrap_Feature_SetField__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
5923
        }
 
5924
      }
 
5925
    }
 
5926
  }
 
5927
  if (argc == 3) {
 
5928
    int _v;
 
5929
    {
 
5930
      void *tmp;
 
5931
      _v = (SWIG_ConvertPtr(*argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) >= 0);
 
5932
    }
 
5933
    if (_v) {
 
5934
      _v = (Z_TYPE_PP(argv[1]) == IS_LONG); 
 
5935
      if (_v) {
 
5936
        _v = (Z_TYPE_PP(argv[2]) == IS_DOUBLE); 
 
5937
        if (_v) {
 
5938
          return _wrap_Feature_SetField__SWIG_4(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
5939
        }
 
5940
      }
 
5941
    }
 
5942
  }
 
5943
  if (argc == 3) {
 
5944
    int _v;
 
5945
    {
 
5946
      void *tmp;
 
5947
      _v = (SWIG_ConvertPtr(*argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) >= 0);
 
5948
    }
 
5949
    if (_v) {
 
5950
      _v = (Z_TYPE_PP(argv[1]) == IS_LONG); 
 
5951
      if (_v) {
 
5952
        _v = (Z_TYPE_PP(argv[2]) == IS_LONG); 
 
5953
        if (_v) {
 
5954
          return _wrap_Feature_SetField__SWIG_2(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
5955
        }
 
5956
      }
 
5957
    }
 
5958
  }
 
5959
  if (argc == 3) {
 
5960
    int _v;
 
5961
    {
 
5962
      void *tmp;
 
5963
      _v = (SWIG_ConvertPtr(*argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) >= 0);
 
5964
    }
 
5965
    if (_v) {
 
5966
      _v = (Z_TYPE_PP(argv[1]) == IS_STRING); 
 
5967
      if (_v) {
 
5968
        {
 
5969
          /* %typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER) (tostring argin) */
 
5970
          _v = 1;
 
5971
        }
 
5972
        if (_v) {
 
5973
          return _wrap_Feature_SetField__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
5974
        }
 
5975
      }
 
5976
    }
 
5977
  }
 
5978
  if (argc == 3) {
 
5979
    int _v;
 
5980
    {
 
5981
      void *tmp;
 
5982
      _v = (SWIG_ConvertPtr(*argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) >= 0);
 
5983
    }
 
5984
    if (_v) {
 
5985
      _v = (Z_TYPE_PP(argv[1]) == IS_STRING); 
 
5986
      if (_v) {
 
5987
        _v = (Z_TYPE_PP(argv[2]) == IS_DOUBLE); 
 
5988
        if (_v) {
 
5989
          return _wrap_Feature_SetField__SWIG_5(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
5990
        }
 
5991
      }
 
5992
    }
 
5993
  }
 
5994
  if (argc == 3) {
 
5995
    int _v;
 
5996
    {
 
5997
      void *tmp;
 
5998
      _v = (SWIG_ConvertPtr(*argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) >= 0);
 
5999
    }
 
6000
    if (_v) {
 
6001
      _v = (Z_TYPE_PP(argv[1]) == IS_STRING); 
 
6002
      if (_v) {
 
6003
        _v = (Z_TYPE_PP(argv[2]) == IS_LONG); 
 
6004
        if (_v) {
 
6005
          return _wrap_Feature_SetField__SWIG_3(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
6006
        }
 
6007
      }
 
6008
    }
 
6009
  }
 
6010
  if (argc == 9) {
 
6011
    int _v;
 
6012
    {
 
6013
      void *tmp;
 
6014
      _v = (SWIG_ConvertPtr(*argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) >= 0);
 
6015
    }
 
6016
    if (_v) {
 
6017
      _v = (Z_TYPE_PP(argv[1]) == IS_LONG); 
 
6018
      if (_v) {
 
6019
        _v = (Z_TYPE_PP(argv[2]) == IS_LONG); 
 
6020
        if (_v) {
 
6021
          _v = (Z_TYPE_PP(argv[3]) == IS_LONG); 
 
6022
          if (_v) {
 
6023
            _v = (Z_TYPE_PP(argv[4]) == IS_LONG); 
 
6024
            if (_v) {
 
6025
              _v = (Z_TYPE_PP(argv[5]) == IS_LONG); 
 
6026
              if (_v) {
 
6027
                _v = (Z_TYPE_PP(argv[6]) == IS_LONG); 
 
6028
                if (_v) {
 
6029
                  _v = (Z_TYPE_PP(argv[7]) == IS_LONG); 
 
6030
                  if (_v) {
 
6031
                    _v = (Z_TYPE_PP(argv[8]) == IS_LONG); 
 
6032
                    if (_v) {
 
6033
                      return _wrap_Feature_SetField__SWIG_6(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
6034
                    }
 
6035
                  }
 
6036
                }
 
6037
              }
 
6038
            }
 
6039
          }
 
6040
        }
 
6041
      }
 
6042
    }
 
6043
  }
 
6044
  if (argc == 9) {
 
6045
    int _v;
 
6046
    {
 
6047
      void *tmp;
 
6048
      _v = (SWIG_ConvertPtr(*argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) >= 0);
 
6049
    }
 
6050
    if (_v) {
 
6051
      _v = (Z_TYPE_PP(argv[1]) == IS_STRING); 
 
6052
      if (_v) {
 
6053
        _v = (Z_TYPE_PP(argv[2]) == IS_LONG); 
 
6054
        if (_v) {
 
6055
          _v = (Z_TYPE_PP(argv[3]) == IS_LONG); 
 
6056
          if (_v) {
 
6057
            _v = (Z_TYPE_PP(argv[4]) == IS_LONG); 
 
6058
            if (_v) {
 
6059
              _v = (Z_TYPE_PP(argv[5]) == IS_LONG); 
 
6060
              if (_v) {
 
6061
                _v = (Z_TYPE_PP(argv[6]) == IS_LONG); 
 
6062
                if (_v) {
 
6063
                  _v = (Z_TYPE_PP(argv[7]) == IS_LONG); 
 
6064
                  if (_v) {
 
6065
                    _v = (Z_TYPE_PP(argv[8]) == IS_LONG); 
 
6066
                    if (_v) {
 
6067
                      return _wrap_Feature_SetField__SWIG_7(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
6068
                    }
 
6069
                  }
 
6070
                }
 
6071
              }
 
6072
            }
 
6073
          }
 
6074
        }
 
6075
      }
 
6076
    }
 
6077
  }
 
6078
  
 
6079
  SWIG_ErrorCode() = E_ERROR;
 
6080
  SWIG_ErrorMsg() = "No matching function for overloaded 'Feature_SetField'";
 
6081
  zend_error(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
6082
}
 
6083
 
 
6084
 
 
6085
ZEND_NAMED_FUNCTION(_wrap_Feature_SetFieldIntegerList) {
 
6086
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
6087
  int arg2 ;
 
6088
  int arg3 ;
 
6089
  int *arg4 = (int *) 0 ;
 
6090
  zval **args[3];
 
6091
  
 
6092
  SWIG_ResetError();
 
6093
  if(ZEND_NUM_ARGS() != 3 || zend_get_parameters_array_ex(3, args) != SUCCESS) {
 
6094
    WRONG_PARAM_COUNT;
 
6095
  }
 
6096
  
 
6097
  {
 
6098
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
6099
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_SetFieldIntegerList. Expected SWIGTYPE_p_OGRFeatureShadow");
 
6100
    }
 
6101
  }
 
6102
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
6103
  
 
6104
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
6105
  convert_to_long_ex(args[1]);
 
6106
  arg2 = (int) Z_LVAL_PP(args[1]);
 
6107
  /*@SWIG@*/;
 
6108
  
 
6109
  {
 
6110
    /* %typemap(in,numinputs=1) (int nList, int* pList)*/
 
6111
    zend_error(E_ERROR,"Typemap (in,numinputs=1) (int nList, int*pList) not properly defined");
 
6112
    /* check if is List */
 
6113
    //  if ( !PySequence_Check(args[2]) ) {
 
6114
    //    PyErr_SetString(PyExc_TypeError, "not a sequence");
 
6115
    //    SWIG_fail;
 
6116
    //  }
 
6117
    //  arg3 = PySequence_Size(args[2]);
 
6118
    //  arg4 = (int*) malloc(arg3*sizeof(int));
 
6119
    //  for( int i = 0; i<arg3; i++ ) {
 
6120
    //    PyObject *o = PySequence_GetItem(args[2],i);
 
6121
    //    if ( !PyArg_Parse(o,"i",&arg4[i]) ) {
 
6122
    //      SWIG_fail;
 
6123
    //    }
 
6124
    //  }
 
6125
  }
 
6126
  OGRFeatureShadow_SetFieldIntegerList(arg1,arg2,arg3,arg4);
 
6127
  
 
6128
  {
 
6129
    /* %typemap(freearg) (int nList, int* pList) */
 
6130
    if (arg4) {
 
6131
      free((void*) arg4);
 
6132
    }
 
6133
  }
 
6134
  return;
 
6135
fail:
 
6136
  {
 
6137
    /* %typemap(freearg) (int nList, int* pList) */
 
6138
    if (arg4) {
 
6139
      free((void*) arg4);
 
6140
    }
 
6141
  }
 
6142
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
6143
}
 
6144
 
 
6145
 
 
6146
ZEND_NAMED_FUNCTION(_wrap_Feature_SetFieldDoubleList) {
 
6147
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
6148
  int arg2 ;
 
6149
  int arg3 ;
 
6150
  double *arg4 = (double *) 0 ;
 
6151
  zval **args[4];
 
6152
  
 
6153
  SWIG_ResetError();
 
6154
  if(ZEND_NUM_ARGS() != 4 || zend_get_parameters_array_ex(4, args) != SUCCESS) {
 
6155
    WRONG_PARAM_COUNT;
 
6156
  }
 
6157
  
 
6158
  {
 
6159
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
6160
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_SetFieldDoubleList. Expected SWIGTYPE_p_OGRFeatureShadow");
 
6161
    }
 
6162
  }
 
6163
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
6164
  
 
6165
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
6166
  convert_to_long_ex(args[1]);
 
6167
  arg2 = (int) Z_LVAL_PP(args[1]);
 
6168
  /*@SWIG@*/;
 
6169
  
 
6170
  
 
6171
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
6172
  convert_to_long_ex(args[2]);
 
6173
  arg3 = (int) Z_LVAL_PP(args[2]);
 
6174
  /*@SWIG@*/;
 
6175
  
 
6176
  {
 
6177
    if(SWIG_ConvertPtr(*args[3], (void **) &arg4, SWIGTYPE_p_double, 0) < 0) {
 
6178
      SWIG_PHP_Error(E_ERROR, "Type error in argument 4 of Feature_SetFieldDoubleList. Expected SWIGTYPE_p_double");
 
6179
    }
 
6180
  }
 
6181
  OGRFeatureShadow_SetFieldDoubleList(arg1,arg2,arg3,arg4);
 
6182
  
 
6183
  return;
 
6184
fail:
 
6185
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
6186
}
 
6187
 
 
6188
 
 
6189
ZEND_NAMED_FUNCTION(_wrap_Feature_SetFieldStringList) {
 
6190
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
6191
  int arg2 ;
 
6192
  char **arg3 = (char **) 0 ;
 
6193
  zval **args[3];
 
6194
  
 
6195
  SWIG_ResetError();
 
6196
  if(ZEND_NUM_ARGS() != 3 || zend_get_parameters_array_ex(3, args) != SUCCESS) {
 
6197
    WRONG_PARAM_COUNT;
 
6198
  }
 
6199
  
 
6200
  {
 
6201
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
6202
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_SetFieldStringList. Expected SWIGTYPE_p_OGRFeatureShadow");
 
6203
    }
 
6204
  }
 
6205
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
6206
  
 
6207
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
6208
  convert_to_long_ex(args[1]);
 
6209
  arg2 = (int) Z_LVAL_PP(args[1]);
 
6210
  /*@SWIG@*/;
 
6211
  
 
6212
  {
 
6213
    /* %typemap(in) char **options */
 
6214
    zend_error(E_ERROR,"Typemap (in) char **options not properly defined");
 
6215
    //  int size = PySequence_Size(args[2]);
 
6216
    //  for (int i = 0; i < size; i++) {
 
6217
    //    char *pszItem = NULL;
 
6218
    //    if ( ! PyArg_Parse( PySequence_GetItem(args[2],i), "s", &pszItem ) ) {
 
6219
    //      PyErr_SetString(PyExc_TypeError,"sequence must contain strings");
 
6220
    //      SWIG_fail;
 
6221
    //    }
 
6222
    //    arg3 = CSLAddString( arg3, pszItem );
 
6223
    //  }
 
6224
  }
 
6225
  OGRFeatureShadow_SetFieldStringList(arg1,arg2,arg3);
 
6226
  
 
6227
  {
 
6228
    /* %typemap(freearg) char **options */
 
6229
    CSLDestroy( arg3 );
 
6230
  }
 
6231
  return;
 
6232
fail:
 
6233
  {
 
6234
    /* %typemap(freearg) char **options */
 
6235
    CSLDestroy( arg3 );
 
6236
  }
 
6237
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5391
6238
}
5392
6239
 
5393
6240
 
5394
6241
ZEND_NAMED_FUNCTION(_wrap_Feature_SetFrom) {
5395
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5396
 
    OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
5397
 
    int arg3 = (int) 1 ;
5398
 
    OGRErr result;
5399
 
    zval **args[2];
5400
 
    int arg_count;
5401
 
    
5402
 
    SWIG_ResetError();
5403
 
    /* This function uses a this_ptr*/
5404
 
    arg_count = ZEND_NUM_ARGS();
5405
 
    if(arg_count<2 || arg_count>3)
5406
 
    WRONG_PARAM_COUNT;
5407
 
    
5408
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
5409
 
    WRONG_PARAM_COUNT;
5410
 
    
5411
 
    {
5412
 
        /* typemap(in) SWIGTYPE * */
5413
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
5414
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_SetFrom. Expected SWIGTYPE_p_p_OGRFeatureShadow");
5415
 
        }
5416
 
    }
5417
 
    {
5418
 
        /* typemap(in) SWIGTYPE * */
5419
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
5420
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Feature_SetFrom. Expected SWIGTYPE_p_p_OGRFeatureShadow");
5421
 
        }
5422
 
    }
5423
 
    if(arg_count > 2) {
5424
 
        {
5425
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
5426
 
            convert_to_long_ex(args[1]);
5427
 
            arg3 = (int) Z_LVAL_PP(args[1]);
5428
 
            /*@@*/;
5429
 
        }
5430
 
    }
5431
 
    result = (OGRErr)OGRFeatureShadow_SetFrom(arg1,arg2,arg3);
5432
 
    
5433
 
    {
5434
 
        /* %typemap(out) OGRErr */
5435
 
        if (result != 0 ) {
5436
 
            SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
5437
 
        }
5438
 
    }
5439
 
    {
5440
 
        /* %typemap(ret) OGRErr */
5441
 
        RETVAL_LONG(0);
5442
 
    }
5443
 
    return;
5444
 
    fail:
5445
 
    zend_error(ErrorCode(),ErrorMsg());
 
6242
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
6243
  OGRFeatureShadow *arg2 = (OGRFeatureShadow *) 0 ;
 
6244
  int arg3 = (int) 1 ;
 
6245
  zval **args[3];
 
6246
  int arg_count;
 
6247
  OGRErr result;
 
6248
  
 
6249
  SWIG_ResetError();
 
6250
  arg_count = ZEND_NUM_ARGS();
 
6251
  if(arg_count<2 || arg_count>3 ||
 
6252
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
6253
  WRONG_PARAM_COUNT;
 
6254
  
 
6255
  {
 
6256
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
6257
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_SetFrom. Expected SWIGTYPE_p_OGRFeatureShadow");
 
6258
    }
 
6259
  }
 
6260
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
6261
  {
 
6262
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
6263
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Feature_SetFrom. Expected SWIGTYPE_p_OGRFeatureShadow");
 
6264
    }
 
6265
  }
 
6266
  if(arg_count > 2) {
 
6267
    /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
6268
    convert_to_long_ex(args[2]);
 
6269
    arg3 = (int) Z_LVAL_PP(args[2]);
 
6270
    /*@SWIG@*/;
 
6271
    
 
6272
  }
 
6273
  {
 
6274
    if (!arg2) {
 
6275
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
6276
    }
 
6277
  }
 
6278
  result = (OGRErr)OGRFeatureShadow_SetFrom(arg1,arg2,arg3);
 
6279
  {
 
6280
    /* %typemap(out) OGRErr */
 
6281
    if (result != 0 ) {
 
6282
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
6283
    }
 
6284
  }
 
6285
  {
 
6286
    /* %typemap(ret) OGRErr */
 
6287
    RETVAL_LONG(0);
 
6288
  }
 
6289
  return;
 
6290
fail:
 
6291
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5446
6292
}
5447
6293
 
5448
6294
 
5449
6295
ZEND_NAMED_FUNCTION(_wrap_Feature_GetStyleString) {
5450
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5451
 
    char *result;
5452
 
    zval **args[0];
5453
 
    
5454
 
    SWIG_ResetError();
5455
 
    /* This function uses a this_ptr*/
5456
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
5457
 
        WRONG_PARAM_COUNT;
5458
 
    }
5459
 
    
5460
 
    {
5461
 
        /* typemap(in) SWIGTYPE * */
5462
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
5463
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetStyleString. Expected SWIGTYPE_p_p_OGRFeatureShadow");
5464
 
        }
5465
 
    }
5466
 
    result = (char *)OGRFeatureShadow_GetStyleString(arg1);
5467
 
    
5468
 
    {
5469
 
        if(!result) {
5470
 
            ZVAL_NULL(return_value);
5471
 
        } else {
5472
 
            ZVAL_STRING(return_value,result, 1);
5473
 
        }
5474
 
    }
5475
 
    return;
5476
 
    fail:
5477
 
    zend_error(ErrorCode(),ErrorMsg());
 
6296
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
6297
  zval **args[1];
 
6298
  char *result = 0 ;
 
6299
  
 
6300
  SWIG_ResetError();
 
6301
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
6302
    WRONG_PARAM_COUNT;
 
6303
  }
 
6304
  
 
6305
  {
 
6306
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
6307
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetStyleString. Expected SWIGTYPE_p_OGRFeatureShadow");
 
6308
    }
 
6309
  }
 
6310
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
6311
  result = (char *)OGRFeatureShadow_GetStyleString(arg1);
 
6312
  {
 
6313
    if(!result) {
 
6314
      ZVAL_NULL(return_value);
 
6315
    } else {
 
6316
      ZVAL_STRING(return_value, (char *)result, 1);
 
6317
    }
 
6318
  }
 
6319
  return;
 
6320
fail:
 
6321
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5478
6322
}
5479
6323
 
5480
6324
 
5481
6325
ZEND_NAMED_FUNCTION(_wrap_Feature_SetStyleString) {
5482
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5483
 
    char *arg2 = (char *) 0 ;
5484
 
    zval **args[1];
5485
 
    
5486
 
    SWIG_ResetError();
5487
 
    /* This function uses a this_ptr*/
5488
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
5489
 
        WRONG_PARAM_COUNT;
5490
 
    }
5491
 
    
5492
 
    {
5493
 
        /* typemap(in) SWIGTYPE * */
5494
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
5495
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_SetStyleString. Expected SWIGTYPE_p_p_OGRFeatureShadow");
5496
 
        }
5497
 
    }
5498
 
    {
5499
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
5500
 
        convert_to_string_ex(args[0]);
5501
 
        arg2 = (char *) Z_STRVAL_PP(args[0]);
5502
 
        /*@@*/;
5503
 
    }
5504
 
    OGRFeatureShadow_SetStyleString(arg1,(char const *)arg2);
5505
 
    
5506
 
    
5507
 
    return;
5508
 
    fail:
5509
 
    zend_error(ErrorCode(),ErrorMsg());
 
6326
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
6327
  char *arg2 = (char *) 0 ;
 
6328
  zval **args[2];
 
6329
  
 
6330
  SWIG_ResetError();
 
6331
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
6332
    WRONG_PARAM_COUNT;
 
6333
  }
 
6334
  
 
6335
  {
 
6336
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
6337
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_SetStyleString. Expected SWIGTYPE_p_OGRFeatureShadow");
 
6338
    }
 
6339
  }
 
6340
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
6341
  
 
6342
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
6343
  if ((*args[1])->type==IS_NULL) {
 
6344
    arg2 = (char *) 0;
 
6345
  } else {
 
6346
    convert_to_string_ex(args[1]);
 
6347
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
6348
  }
 
6349
  /*@SWIG@*/;
 
6350
  
 
6351
  OGRFeatureShadow_SetStyleString(arg1,(char const *)arg2);
 
6352
  
 
6353
  return;
 
6354
fail:
 
6355
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5510
6356
}
5511
6357
 
5512
6358
 
5513
6359
ZEND_NAMED_FUNCTION(_wrap_Feature_GetFieldType__SWIG_0) {
5514
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5515
 
    int arg2 ;
5516
 
    OGRFieldType result;
5517
 
    zval **args[1];
5518
 
    
5519
 
    SWIG_ResetError();
5520
 
    /* This function uses a this_ptr*/
5521
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
5522
 
        WRONG_PARAM_COUNT;
5523
 
    }
5524
 
    
5525
 
    {
5526
 
        /* typemap(in) SWIGTYPE * */
5527
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
5528
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldType. Expected SWIGTYPE_p_p_OGRFeatureShadow");
5529
 
        }
5530
 
    }
5531
 
    {
5532
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
5533
 
        convert_to_long_ex(args[0]);
5534
 
        arg2 = (int) Z_LVAL_PP(args[0]);
5535
 
        /*@@*/;
5536
 
    }
5537
 
    result = (OGRFieldType)OGRFeatureShadow_GetFieldType__SWIG_0(arg1,arg2);
5538
 
    
5539
 
    {
5540
 
        ZVAL_LONG(return_value,result);
5541
 
    }
5542
 
    return;
5543
 
    fail:
5544
 
    zend_error(ErrorCode(),ErrorMsg());
 
6360
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
6361
  int arg2 ;
 
6362
  zval **args[2];
 
6363
  OGRFieldType result;
 
6364
  
 
6365
  SWIG_ResetError();
 
6366
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
6367
    WRONG_PARAM_COUNT;
 
6368
  }
 
6369
  
 
6370
  {
 
6371
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
6372
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldType. Expected SWIGTYPE_p_OGRFeatureShadow");
 
6373
    }
 
6374
  }
 
6375
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
6376
  
 
6377
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
6378
  convert_to_long_ex(args[1]);
 
6379
  arg2 = (int) Z_LVAL_PP(args[1]);
 
6380
  /*@SWIG@*/;
 
6381
  
 
6382
  result = (OGRFieldType)OGRFeatureShadow_GetFieldType__SWIG_0(arg1,arg2);
 
6383
  {
 
6384
    ZVAL_LONG(return_value,result);
 
6385
  }
 
6386
  return;
 
6387
fail:
 
6388
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5545
6389
}
5546
6390
 
5547
6391
 
5548
6392
ZEND_NAMED_FUNCTION(_wrap_Feature_GetFieldType__SWIG_1) {
5549
 
    OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
5550
 
    char *arg2 = (char *) 0 ;
5551
 
    char *arg3 = (char *) 0 ;
5552
 
    OGRFieldType result;
5553
 
    zval **args[2];
5554
 
    
5555
 
    SWIG_ResetError();
5556
 
    /* This function uses a this_ptr*/
5557
 
    if(((ZEND_NUM_ARGS() )!= 2) || (zend_get_parameters_array_ex(2, args)!= SUCCESS)) {
5558
 
        WRONG_PARAM_COUNT;
5559
 
    }
5560
 
    
5561
 
    {
5562
 
        /* typemap(in) SWIGTYPE * */
5563
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
5564
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldType. Expected SWIGTYPE_p_p_OGRFeatureShadow");
5565
 
        }
5566
 
    }
5567
 
    {
5568
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
5569
 
        convert_to_string_ex(args[0]);
5570
 
        arg2 = (char *) Z_STRVAL_PP(args[0]);
5571
 
        /*@@*/;
5572
 
    }
5573
 
    {
5574
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
5575
 
        convert_to_string_ex(args[1]);
5576
 
        arg3 = (char *) Z_STRVAL_PP(args[1]);
5577
 
        /*@@*/;
5578
 
    }
5579
 
    result = (OGRFieldType)OGRFeatureShadow_GetFieldType__SWIG_1(arg1,(char const *)arg2,(char const *)arg3);
5580
 
    
5581
 
    {
5582
 
        ZVAL_LONG(return_value,result);
5583
 
    }
5584
 
    return;
5585
 
    fail:
5586
 
    zend_error(ErrorCode(),ErrorMsg());
 
6393
  OGRFeatureShadow *arg1 = (OGRFeatureShadow *) 0 ;
 
6394
  char *arg2 = (char *) 0 ;
 
6395
  zval **args[2];
 
6396
  OGRFieldType result;
 
6397
  
 
6398
  SWIG_ResetError();
 
6399
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
6400
    WRONG_PARAM_COUNT;
 
6401
  }
 
6402
  
 
6403
  {
 
6404
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureShadow, 0) < 0) {
 
6405
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Feature_GetFieldType. Expected SWIGTYPE_p_OGRFeatureShadow");
 
6406
    }
 
6407
  }
 
6408
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
6409
  
 
6410
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
6411
  if ((*args[1])->type==IS_NULL) {
 
6412
    arg2 = (char *) 0;
 
6413
  } else {
 
6414
    convert_to_string_ex(args[1]);
 
6415
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
6416
  }
 
6417
  /*@SWIG@*/;
 
6418
  
 
6419
  {
 
6420
    if (!arg2) {
 
6421
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
6422
    }
 
6423
  }
 
6424
  result = (OGRFieldType)OGRFeatureShadow_GetFieldType__SWIG_1(arg1,(char const *)arg2);
 
6425
  {
 
6426
    ZVAL_LONG(return_value,result);
 
6427
  }
 
6428
  return;
 
6429
fail:
 
6430
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5587
6431
}
5588
6432
 
5589
6433
 
5590
6434
ZEND_NAMED_FUNCTION(_wrap_Feature_GetFieldType) {
5591
 
    int argc;
5592
 
    zval **argv[3];
5593
 
    int ii;
5594
 
    
5595
 
    argc = ZEND_NUM_ARGS();
5596
 
    zend_get_parameters_array_ex(argc,argv);
5597
 
    if (argc == 2) {
5598
 
        int _v;
5599
 
        {
5600
 
            /* typecheck SWIGTYPE * */
5601
 
            void *tmp;
5602
 
            _v = (SWIG_ConvertPtr( *argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) < 0)? 0:1;
5603
 
        }
5604
 
        if (_v) {
5605
 
            _v = (Z_TYPE_PP(argv[1]) == IS_LONG ||
5606
 
            Z_TYPE_PP(argv[1]) == IS_DOUBLE ||
5607
 
            Z_TYPE_PP(argv[1]) == IS_STRING) ? 1 : 0; 
5608
 
            if (_v) {
5609
 
                return _wrap_Feature_GetFieldType__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU);
5610
 
            }
5611
 
        }
5612
 
    }
5613
 
    if (argc == 3) {
5614
 
        int _v;
5615
 
        {
5616
 
            /* typecheck SWIGTYPE * */
5617
 
            void *tmp;
5618
 
            _v = (SWIG_ConvertPtr( *argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) < 0)? 0:1;
5619
 
        }
5620
 
        if (_v) {
5621
 
            _v = (Z_TYPE_PP(argv[1]) == IS_LONG ||
5622
 
            Z_TYPE_PP(argv[1]) == IS_DOUBLE ||
5623
 
            Z_TYPE_PP(argv[1]) == IS_STRING) ? 1 : 0; 
5624
 
            if (_v) {
5625
 
                _v = (Z_TYPE_PP(argv[2]) == IS_LONG ||
5626
 
                Z_TYPE_PP(argv[2]) == IS_DOUBLE ||
5627
 
                Z_TYPE_PP(argv[2]) == IS_STRING) ? 1 : 0; 
5628
 
                if (_v) {
5629
 
                    return _wrap_Feature_GetFieldType__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU);
5630
 
                }
5631
 
            }
5632
 
        }
5633
 
    }
5634
 
    
5635
 
    /*No matching function for overloaded 'Feature_GetFieldType'*/
5636
 
    
5637
 
}
5638
 
 
5639
 
 
5640
 
/* property handler for class Feature */
5641
 
static pval _wrap_propget_Feature(zend_property_reference *property_reference) {
5642
 
  pval result;
5643
 
  pval **_result;
5644
 
  zend_llist_element *element = property_reference->elements_list->head;
5645
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
5646
 
  result.type = IS_NULL;
5647
 
  if (_propget_Feature(property_reference, &result)==SUCCESS) return result;
5648
 
  /* return it ourselves */
5649
 
  if (zend_hash_find(Z_OBJPROP_P(property_reference->object),Z_STRVAL_P(&(property->element)),1+Z_STRLEN_P(&(property->element)),(void**)&_result)==SUCCESS) {
5650
 
  zval *_value;
5651
 
  MAKE_STD_ZVAL(_value);  *_value=**_result;
5652
 
  INIT_PZVAL(_value);
5653
 
  zval_copy_ctor(_value);
5654
 
  return *_value;
5655
 
  }
5656
 
  result.type = IS_NULL;
5657
 
  return result;
5658
 
}
5659
 
static int _propget_Feature(zend_property_reference *property_reference, pval *value) {
5660
 
  /* get the property name */
5661
 
  zend_llist_element *element = property_reference->elements_list->head;
5662
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
5663
 
  char *propname=Z_STRVAL_P(&(property->element));
5664
 
  return FAILURE;
5665
 
}
5666
 
 
5667
 
static int _wrap_propset_Feature(zend_property_reference *property_reference, pval *value) { 
5668
 
  zval * _value;
5669
 
  zend_llist_element *element = property_reference->elements_list->head;
5670
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
5671
 
  if (_propset_Feature(property_reference, value)==SUCCESS) return SUCCESS;
5672
 
  /* set it ourselves as it is Feature */
5673
 
  MAKE_STD_ZVAL(_value);
5674
 
  *_value=*value;
5675
 
  INIT_PZVAL(_value);
5676
 
  zval_copy_ctor(_value);
5677
 
  return add_property_zval_ex(property_reference->object,Z_STRVAL_P(&(property->element)),1+Z_STRLEN_P(&(property->element)),_value);
5678
 
}
5679
 
static int _propset_Feature(zend_property_reference *property_reference, pval *value) {
5680
 
  /* get the property name */
5681
 
  zend_llist_element *element = property_reference->elements_list->head;
5682
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
5683
 
  char *propname=Z_STRVAL_P(&(property->element));
5684
 
  return FAILURE;
5685
 
}
 
6435
  int argc;
 
6436
  zval **argv[2];
 
6437
  
 
6438
  argc = ZEND_NUM_ARGS();
 
6439
  zend_get_parameters_array_ex(argc,argv);
 
6440
  if (argc == 2) {
 
6441
    int _v;
 
6442
    {
 
6443
      void *tmp;
 
6444
      _v = (SWIG_ConvertPtr(*argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) >= 0);
 
6445
    }
 
6446
    if (_v) {
 
6447
      _v = (Z_TYPE_PP(argv[1]) == IS_LONG); 
 
6448
      if (_v) {
 
6449
        return _wrap_Feature_GetFieldType__SWIG_0(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
6450
      }
 
6451
    }
 
6452
  }
 
6453
  if (argc == 2) {
 
6454
    int _v;
 
6455
    {
 
6456
      void *tmp;
 
6457
      _v = (SWIG_ConvertPtr(*argv[0], (void**)&tmp, SWIGTYPE_p_OGRFeatureShadow, 0) >= 0);
 
6458
    }
 
6459
    if (_v) {
 
6460
      _v = (Z_TYPE_PP(argv[1]) == IS_STRING); 
 
6461
      if (_v) {
 
6462
        return _wrap_Feature_GetFieldType__SWIG_1(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
6463
      }
 
6464
    }
 
6465
  }
 
6466
  
 
6467
  SWIG_ErrorCode() = E_ERROR;
 
6468
  SWIG_ErrorMsg() = "No matching function for overloaded 'Feature_GetFieldType'";
 
6469
  zend_error(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
6470
}
 
6471
 
5686
6472
 
5687
6473
/* This function is designed to be called by the zend list destructors */
5688
6474
/* to typecast and do the actual destruction */
5689
 
void __wrap_delete_FeatureDefn(zend_rsrc_list_entry *rsrc, const char *type_name TSRMLS_DC) {
5690
 
    swig_object_wrapper *value=(swig_object_wrapper *) rsrc->ptr ;
5691
 
    void *ptr=value->ptr ;
5692
 
    int newobject=value->newobject ;
5693
 
    OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
5694
 
    
5695
 
    efree(value);
5696
 
    if (! newobject) return; /* can't delete it! */
5697
 
    SWIG_ZTS_ConvertResourceData(ptr,rsrc->type,type_name,(void **) &arg1,SWIGTYPE_p_OGRFeatureDefnShadow TSRMLS_CC);
5698
 
    if (! arg1) zend_error(E_ERROR, "OGRFeatureDefnShadow resource already free'd");
5699
 
    delete_OGRFeatureDefnShadow(arg1);
5700
 
    
 
6475
static void __wrap_delete_FeatureDefn(zend_rsrc_list_entry *rsrc, const char *type_name TSRMLS_DC) {
 
6476
  swig_object_wrapper *value=(swig_object_wrapper *) rsrc->ptr ;
 
6477
  void *ptr=value->ptr ;
 
6478
  int newobject=value->newobject ;
 
6479
  OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
 
6480
  
 
6481
  efree(value);
 
6482
  if (! newobject) return; /* can't delete it! */
 
6483
  arg1 = (OGRFeatureDefnShadow *)SWIG_ZTS_ConvertResourceData(ptr,type_name,SWIGTYPE_p_OGRFeatureDefnShadow TSRMLS_CC);
 
6484
  if (! arg1) zend_error(E_ERROR, "OGRFeatureDefnShadow resource already free'd");
 
6485
  delete_OGRFeatureDefnShadow(arg1);
 
6486
  return;
 
6487
fail:
 
6488
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5701
6489
}
5702
6490
 
5703
6491
 
5704
6492
ZEND_NAMED_FUNCTION(_wrap_new_FeatureDefn) {
5705
 
    char *arg1 = (char *) NULL ;
5706
 
    OGRFeatureDefnShadow *result;
5707
 
    zval **args[1];
5708
 
    int arg_count;
5709
 
    
5710
 
    SWIG_ResetError();
5711
 
    /* NATIVE Constructor */
5712
 
    arg_count = ZEND_NUM_ARGS();
5713
 
    if(arg_count<0 || arg_count>1)
5714
 
    WRONG_PARAM_COUNT;
5715
 
    
5716
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
5717
 
    WRONG_PARAM_COUNT;
5718
 
    
5719
 
    if(arg_count > 0) {
5720
 
        {
5721
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
5722
 
            convert_to_string_ex(args[0]);
5723
 
            arg1 = (char *) Z_STRVAL_PP(args[0]);
5724
 
            /*@@*/;
5725
 
        }
5726
 
    }
5727
 
    result = (OGRFeatureDefnShadow *)new_OGRFeatureDefnShadow((char const *)arg1);
5728
 
    
5729
 
    {
5730
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRFeatureDefnShadow, 1);
5731
 
    }
5732
 
    /* Wrap this return value */
5733
 
    if (this_ptr) {
5734
 
        /* NATIVE Constructor, use this_ptr */
5735
 
        zval *_cPtr; MAKE_STD_ZVAL(_cPtr);
5736
 
        *_cPtr = *return_value;
5737
 
        INIT_ZVAL(*return_value);
5738
 
        add_property_zval(this_ptr,"_cPtr",_cPtr);
5739
 
    } else if (! this_ptr) {
5740
 
        /* ALTERNATIVE Constructor, make an object wrapper */
5741
 
        zval *obj, *_cPtr;
5742
 
        MAKE_STD_ZVAL(obj);
5743
 
        MAKE_STD_ZVAL(_cPtr);
5744
 
        *_cPtr = *return_value;
5745
 
        INIT_ZVAL(*return_value);
5746
 
        object_init_ex(obj,ptr_ce_swig_FeatureDefn);
5747
 
        add_property_zval(obj,"_cPtr",_cPtr);
5748
 
        *return_value=*obj;
5749
 
    }
5750
 
    return;
5751
 
    fail:
5752
 
    zend_error(ErrorCode(),ErrorMsg());
 
6493
  char *arg1 = (char *) NULL ;
 
6494
  zval **args[1];
 
6495
  int arg_count;
 
6496
  OGRFeatureDefnShadow *result = 0 ;
 
6497
  
 
6498
  SWIG_ResetError();
 
6499
  arg_count = ZEND_NUM_ARGS();
 
6500
  if(arg_count<0 || arg_count>1 ||
 
6501
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
6502
  WRONG_PARAM_COUNT;
 
6503
  
 
6504
  if(arg_count > 0) {
 
6505
    /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
6506
    if ((*args[0])->type==IS_NULL) {
 
6507
      arg1 = (char *) 0;
 
6508
    } else {
 
6509
      convert_to_string_ex(args[0]);
 
6510
      arg1 = (char *) Z_STRVAL_PP(args[0]);
 
6511
    }
 
6512
    /*@SWIG@*/;
 
6513
    
 
6514
  }
 
6515
  result = (OGRFeatureDefnShadow *)new_OGRFeatureDefnShadow((char const *)arg1);
 
6516
  
 
6517
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRFeatureDefnShadow, 1);
 
6518
  
 
6519
  return;
 
6520
fail:
 
6521
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5753
6522
}
5754
6523
 
5755
6524
 
5756
6525
ZEND_NAMED_FUNCTION(_wrap_FeatureDefn_GetName) {
5757
 
    OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
5758
 
    char *result;
5759
 
    zval **args[0];
5760
 
    
5761
 
    SWIG_ResetError();
5762
 
    /* This function uses a this_ptr*/
5763
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
5764
 
        WRONG_PARAM_COUNT;
5765
 
    }
5766
 
    
5767
 
    {
5768
 
        /* typemap(in) SWIGTYPE * */
5769
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureDefnShadow, 0) < 0) {
5770
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FeatureDefn_GetName. Expected SWIGTYPE_p_p_OGRFeatureDefnShadow");
5771
 
        }
5772
 
    }
5773
 
    result = (char *)OGRFeatureDefnShadow_GetName(arg1);
5774
 
    
5775
 
    {
5776
 
        if(!result) {
5777
 
            ZVAL_NULL(return_value);
5778
 
        } else {
5779
 
            ZVAL_STRING(return_value,result, 1);
5780
 
        }
5781
 
    }
5782
 
    return;
5783
 
    fail:
5784
 
    zend_error(ErrorCode(),ErrorMsg());
 
6526
  OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
 
6527
  zval **args[1];
 
6528
  char *result = 0 ;
 
6529
  
 
6530
  SWIG_ResetError();
 
6531
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
6532
    WRONG_PARAM_COUNT;
 
6533
  }
 
6534
  
 
6535
  {
 
6536
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureDefnShadow, 0) < 0) {
 
6537
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FeatureDefn_GetName. Expected SWIGTYPE_p_OGRFeatureDefnShadow");
 
6538
    }
 
6539
  }
 
6540
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
6541
  result = (char *)OGRFeatureDefnShadow_GetName(arg1);
 
6542
  {
 
6543
    if(!result) {
 
6544
      ZVAL_NULL(return_value);
 
6545
    } else {
 
6546
      ZVAL_STRING(return_value, (char *)result, 1);
 
6547
    }
 
6548
  }
 
6549
  return;
 
6550
fail:
 
6551
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5785
6552
}
5786
6553
 
5787
6554
 
5788
6555
ZEND_NAMED_FUNCTION(_wrap_FeatureDefn_GetFieldCount) {
5789
 
    OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
5790
 
    int result;
5791
 
    zval **args[0];
5792
 
    
5793
 
    SWIG_ResetError();
5794
 
    /* This function uses a this_ptr*/
5795
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
5796
 
        WRONG_PARAM_COUNT;
5797
 
    }
5798
 
    
5799
 
    {
5800
 
        /* typemap(in) SWIGTYPE * */
5801
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureDefnShadow, 0) < 0) {
5802
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FeatureDefn_GetFieldCount. Expected SWIGTYPE_p_p_OGRFeatureDefnShadow");
5803
 
        }
5804
 
    }
5805
 
    result = (int)OGRFeatureDefnShadow_GetFieldCount(arg1);
5806
 
    
5807
 
    {
5808
 
        ZVAL_LONG(return_value,result);
5809
 
    }
5810
 
    return;
5811
 
    fail:
5812
 
    zend_error(ErrorCode(),ErrorMsg());
 
6556
  OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
 
6557
  zval **args[1];
 
6558
  int result;
 
6559
  
 
6560
  SWIG_ResetError();
 
6561
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
6562
    WRONG_PARAM_COUNT;
 
6563
  }
 
6564
  
 
6565
  {
 
6566
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureDefnShadow, 0) < 0) {
 
6567
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FeatureDefn_GetFieldCount. Expected SWIGTYPE_p_OGRFeatureDefnShadow");
 
6568
    }
 
6569
  }
 
6570
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
6571
  result = (int)OGRFeatureDefnShadow_GetFieldCount(arg1);
 
6572
  {
 
6573
    ZVAL_LONG(return_value,result);
 
6574
  }
 
6575
  return;
 
6576
fail:
 
6577
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5813
6578
}
5814
6579
 
5815
6580
 
5816
6581
ZEND_NAMED_FUNCTION(_wrap_FeatureDefn_GetFieldDefn) {
5817
 
    OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
5818
 
    int arg2 ;
5819
 
    OGRFieldDefnShadow *result;
5820
 
    zval **args[1];
5821
 
    
5822
 
    SWIG_ResetError();
5823
 
    /* This function uses a this_ptr*/
5824
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
5825
 
        WRONG_PARAM_COUNT;
5826
 
    }
5827
 
    
5828
 
    {
5829
 
        /* typemap(in) SWIGTYPE * */
5830
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureDefnShadow, 0) < 0) {
5831
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FeatureDefn_GetFieldDefn. Expected SWIGTYPE_p_p_OGRFeatureDefnShadow");
5832
 
        }
5833
 
    }
5834
 
    {
5835
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
5836
 
        convert_to_long_ex(args[0]);
5837
 
        arg2 = (int) Z_LVAL_PP(args[0]);
5838
 
        /*@@*/;
5839
 
    }
5840
 
    result = (OGRFieldDefnShadow *)OGRFeatureDefnShadow_GetFieldDefn(arg1,arg2);
5841
 
    
5842
 
    {
5843
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRFieldDefnShadow, 0);
5844
 
    }
5845
 
    /* Wrap this return value */
5846
 
    {
5847
 
        /* ALTERNATIVE Constructor, make an object wrapper */
5848
 
        zval *obj, *_cPtr;
5849
 
        MAKE_STD_ZVAL(obj);
5850
 
        MAKE_STD_ZVAL(_cPtr);
5851
 
        *_cPtr = *return_value;
5852
 
        INIT_ZVAL(*return_value);
5853
 
        object_init_ex(obj,ptr_ce_swig_FieldDefn);
5854
 
        add_property_zval(obj,"_cPtr",_cPtr);
5855
 
        *return_value=*obj;
5856
 
    }
5857
 
    return;
5858
 
    fail:
5859
 
    zend_error(ErrorCode(),ErrorMsg());
 
6582
  OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
 
6583
  int arg2 ;
 
6584
  zval **args[2];
 
6585
  OGRFieldDefnShadow *result = 0 ;
 
6586
  
 
6587
  SWIG_ResetError();
 
6588
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
6589
    WRONG_PARAM_COUNT;
 
6590
  }
 
6591
  
 
6592
  {
 
6593
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureDefnShadow, 0) < 0) {
 
6594
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FeatureDefn_GetFieldDefn. Expected SWIGTYPE_p_OGRFeatureDefnShadow");
 
6595
    }
 
6596
  }
 
6597
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
6598
  
 
6599
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
6600
  convert_to_long_ex(args[1]);
 
6601
  arg2 = (int) Z_LVAL_PP(args[1]);
 
6602
  /*@SWIG@*/;
 
6603
  
 
6604
  result = (OGRFieldDefnShadow *)OGRFeatureDefnShadow_GetFieldDefn(arg1,arg2);
 
6605
  
 
6606
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRFieldDefnShadow, 0);
 
6607
  
 
6608
  return;
 
6609
fail:
 
6610
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5860
6611
}
5861
6612
 
5862
6613
 
5863
6614
ZEND_NAMED_FUNCTION(_wrap_FeatureDefn_GetFieldIndex) {
5864
 
    OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
5865
 
    char *arg2 = (char *) 0 ;
5866
 
    int result;
5867
 
    zval **args[1];
5868
 
    
5869
 
    SWIG_ResetError();
5870
 
    /* This function uses a this_ptr*/
5871
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
5872
 
        WRONG_PARAM_COUNT;
5873
 
    }
5874
 
    
5875
 
    {
5876
 
        /* typemap(in) SWIGTYPE * */
5877
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureDefnShadow, 0) < 0) {
5878
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FeatureDefn_GetFieldIndex. Expected SWIGTYPE_p_p_OGRFeatureDefnShadow");
5879
 
        }
5880
 
    }
5881
 
    {
5882
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
5883
 
        convert_to_string_ex(args[0]);
5884
 
        arg2 = (char *) Z_STRVAL_PP(args[0]);
5885
 
        /*@@*/;
5886
 
    }
5887
 
    result = (int)OGRFeatureDefnShadow_GetFieldIndex(arg1,(char const *)arg2);
5888
 
    
5889
 
    {
5890
 
        ZVAL_LONG(return_value,result);
5891
 
    }
5892
 
    return;
5893
 
    fail:
5894
 
    zend_error(ErrorCode(),ErrorMsg());
 
6615
  OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
 
6616
  char *arg2 = (char *) 0 ;
 
6617
  zval **args[2];
 
6618
  int result;
 
6619
  
 
6620
  SWIG_ResetError();
 
6621
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
6622
    WRONG_PARAM_COUNT;
 
6623
  }
 
6624
  
 
6625
  {
 
6626
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureDefnShadow, 0) < 0) {
 
6627
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FeatureDefn_GetFieldIndex. Expected SWIGTYPE_p_OGRFeatureDefnShadow");
 
6628
    }
 
6629
  }
 
6630
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
6631
  
 
6632
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
6633
  if ((*args[1])->type==IS_NULL) {
 
6634
    arg2 = (char *) 0;
 
6635
  } else {
 
6636
    convert_to_string_ex(args[1]);
 
6637
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
6638
  }
 
6639
  /*@SWIG@*/;
 
6640
  
 
6641
  {
 
6642
    if (!arg2) {
 
6643
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
6644
    }
 
6645
  }
 
6646
  result = (int)OGRFeatureDefnShadow_GetFieldIndex(arg1,(char const *)arg2);
 
6647
  {
 
6648
    ZVAL_LONG(return_value,result);
 
6649
  }
 
6650
  return;
 
6651
fail:
 
6652
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5895
6653
}
5896
6654
 
5897
6655
 
5898
6656
ZEND_NAMED_FUNCTION(_wrap_FeatureDefn_AddFieldDefn) {
5899
 
    OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
5900
 
    OGRFieldDefnShadow *arg2 = (OGRFieldDefnShadow *) 0 ;
5901
 
    zval **args[1];
5902
 
    
5903
 
    SWIG_ResetError();
5904
 
    /* This function uses a this_ptr*/
5905
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
5906
 
        WRONG_PARAM_COUNT;
5907
 
    }
5908
 
    
5909
 
    {
5910
 
        /* typemap(in) SWIGTYPE * */
5911
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureDefnShadow, 0) < 0) {
5912
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FeatureDefn_AddFieldDefn. Expected SWIGTYPE_p_p_OGRFeatureDefnShadow");
5913
 
        }
5914
 
    }
5915
 
    {
5916
 
        /* typemap(in) SWIGTYPE * */
5917
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
5918
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of FeatureDefn_AddFieldDefn. Expected SWIGTYPE_p_p_OGRFieldDefnShadow");
5919
 
        }
5920
 
    }
5921
 
    OGRFeatureDefnShadow_AddFieldDefn(arg1,arg2);
5922
 
    
5923
 
    
5924
 
    return;
5925
 
    fail:
5926
 
    zend_error(ErrorCode(),ErrorMsg());
 
6657
  OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
 
6658
  OGRFieldDefnShadow *arg2 = (OGRFieldDefnShadow *) 0 ;
 
6659
  zval **args[2];
 
6660
  
 
6661
  SWIG_ResetError();
 
6662
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
6663
    WRONG_PARAM_COUNT;
 
6664
  }
 
6665
  
 
6666
  {
 
6667
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureDefnShadow, 0) < 0) {
 
6668
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FeatureDefn_AddFieldDefn. Expected SWIGTYPE_p_OGRFeatureDefnShadow");
 
6669
    }
 
6670
  }
 
6671
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
6672
  {
 
6673
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
 
6674
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of FeatureDefn_AddFieldDefn. Expected SWIGTYPE_p_OGRFieldDefnShadow");
 
6675
    }
 
6676
  }
 
6677
  {
 
6678
    if (!arg2) {
 
6679
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
6680
    }
 
6681
  }
 
6682
  OGRFeatureDefnShadow_AddFieldDefn(arg1,arg2);
 
6683
  
 
6684
  return;
 
6685
fail:
 
6686
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5927
6687
}
5928
6688
 
5929
6689
 
5930
6690
ZEND_NAMED_FUNCTION(_wrap_FeatureDefn_GetGeomType) {
5931
 
    OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
5932
 
    OGRwkbGeometryType result;
5933
 
    zval **args[0];
5934
 
    
5935
 
    SWIG_ResetError();
5936
 
    /* This function uses a this_ptr*/
5937
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
5938
 
        WRONG_PARAM_COUNT;
5939
 
    }
5940
 
    
5941
 
    {
5942
 
        /* typemap(in) SWIGTYPE * */
5943
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureDefnShadow, 0) < 0) {
5944
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FeatureDefn_GetGeomType. Expected SWIGTYPE_p_p_OGRFeatureDefnShadow");
5945
 
        }
5946
 
    }
5947
 
    result = (OGRwkbGeometryType)OGRFeatureDefnShadow_GetGeomType(arg1);
5948
 
    
5949
 
    {
5950
 
        ZVAL_LONG(return_value,result);
5951
 
    }
5952
 
    return;
5953
 
    fail:
5954
 
    zend_error(ErrorCode(),ErrorMsg());
 
6691
  OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
 
6692
  zval **args[1];
 
6693
  OGRwkbGeometryType result;
 
6694
  
 
6695
  SWIG_ResetError();
 
6696
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
6697
    WRONG_PARAM_COUNT;
 
6698
  }
 
6699
  
 
6700
  {
 
6701
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureDefnShadow, 0) < 0) {
 
6702
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FeatureDefn_GetGeomType. Expected SWIGTYPE_p_OGRFeatureDefnShadow");
 
6703
    }
 
6704
  }
 
6705
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
6706
  result = (OGRwkbGeometryType)OGRFeatureDefnShadow_GetGeomType(arg1);
 
6707
  {
 
6708
    ZVAL_LONG(return_value,result);
 
6709
  }
 
6710
  return;
 
6711
fail:
 
6712
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5955
6713
}
5956
6714
 
5957
6715
 
5958
6716
ZEND_NAMED_FUNCTION(_wrap_FeatureDefn_SetGeomType) {
5959
 
    OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
5960
 
    OGRwkbGeometryType arg2 ;
5961
 
    zval **args[1];
5962
 
    
5963
 
    SWIG_ResetError();
5964
 
    /* This function uses a this_ptr*/
5965
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
5966
 
        WRONG_PARAM_COUNT;
5967
 
    }
5968
 
    
5969
 
    {
5970
 
        /* typemap(in) SWIGTYPE * */
5971
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureDefnShadow, 0) < 0) {
5972
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FeatureDefn_SetGeomType. Expected SWIGTYPE_p_p_OGRFeatureDefnShadow");
5973
 
        }
5974
 
    }
5975
 
    {
5976
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
5977
 
        convert_to_long_ex(args[0]);
5978
 
        arg2 = (OGRwkbGeometryType) Z_LVAL_PP(args[0]);
5979
 
        /*@@*/;
5980
 
    }
5981
 
    OGRFeatureDefnShadow_SetGeomType(arg1,arg2);
5982
 
    
5983
 
    
5984
 
    return;
5985
 
    fail:
5986
 
    zend_error(ErrorCode(),ErrorMsg());
 
6717
  OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
 
6718
  OGRwkbGeometryType arg2 ;
 
6719
  zval **args[2];
 
6720
  
 
6721
  SWIG_ResetError();
 
6722
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
6723
    WRONG_PARAM_COUNT;
 
6724
  }
 
6725
  
 
6726
  {
 
6727
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureDefnShadow, 0) < 0) {
 
6728
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FeatureDefn_SetGeomType. Expected SWIGTYPE_p_OGRFeatureDefnShadow");
 
6729
    }
 
6730
  }
 
6731
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
6732
  
 
6733
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
6734
  convert_to_long_ex(args[1]);
 
6735
  arg2 = (OGRwkbGeometryType) Z_LVAL_PP(args[1]);
 
6736
  /*@SWIG@*/;
 
6737
  
 
6738
  OGRFeatureDefnShadow_SetGeomType(arg1,arg2);
 
6739
  
 
6740
  return;
 
6741
fail:
 
6742
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
5987
6743
}
5988
6744
 
5989
6745
 
5990
6746
ZEND_NAMED_FUNCTION(_wrap_FeatureDefn_GetReferenceCount) {
5991
 
    OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
5992
 
    int result;
5993
 
    zval **args[0];
5994
 
    
5995
 
    SWIG_ResetError();
5996
 
    /* This function uses a this_ptr*/
5997
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
5998
 
        WRONG_PARAM_COUNT;
5999
 
    }
6000
 
    
6001
 
    {
6002
 
        /* typemap(in) SWIGTYPE * */
6003
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFeatureDefnShadow, 0) < 0) {
6004
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FeatureDefn_GetReferenceCount. Expected SWIGTYPE_p_p_OGRFeatureDefnShadow");
6005
 
        }
6006
 
    }
6007
 
    result = (int)OGRFeatureDefnShadow_GetReferenceCount(arg1);
6008
 
    
6009
 
    {
6010
 
        ZVAL_LONG(return_value,result);
6011
 
    }
6012
 
    return;
6013
 
    fail:
6014
 
    zend_error(ErrorCode(),ErrorMsg());
6015
 
}
6016
 
 
6017
 
 
6018
 
/* property handler for class FeatureDefn */
6019
 
static pval _wrap_propget_FeatureDefn(zend_property_reference *property_reference) {
6020
 
  pval result;
6021
 
  pval **_result;
6022
 
  zend_llist_element *element = property_reference->elements_list->head;
6023
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
6024
 
  result.type = IS_NULL;
6025
 
  if (_propget_FeatureDefn(property_reference, &result)==SUCCESS) return result;
6026
 
  /* return it ourselves */
6027
 
  if (zend_hash_find(Z_OBJPROP_P(property_reference->object),Z_STRVAL_P(&(property->element)),1+Z_STRLEN_P(&(property->element)),(void**)&_result)==SUCCESS) {
6028
 
  zval *_value;
6029
 
  MAKE_STD_ZVAL(_value);  *_value=**_result;
6030
 
  INIT_PZVAL(_value);
6031
 
  zval_copy_ctor(_value);
6032
 
  return *_value;
6033
 
  }
6034
 
  result.type = IS_NULL;
6035
 
  return result;
6036
 
}
6037
 
static int _propget_FeatureDefn(zend_property_reference *property_reference, pval *value) {
6038
 
  /* get the property name */
6039
 
  zend_llist_element *element = property_reference->elements_list->head;
6040
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
6041
 
  char *propname=Z_STRVAL_P(&(property->element));
6042
 
  return FAILURE;
6043
 
}
6044
 
 
6045
 
static int _wrap_propset_FeatureDefn(zend_property_reference *property_reference, pval *value) { 
6046
 
  zval * _value;
6047
 
  zend_llist_element *element = property_reference->elements_list->head;
6048
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
6049
 
  if (_propset_FeatureDefn(property_reference, value)==SUCCESS) return SUCCESS;
6050
 
  /* set it ourselves as it is FeatureDefn */
6051
 
  MAKE_STD_ZVAL(_value);
6052
 
  *_value=*value;
6053
 
  INIT_PZVAL(_value);
6054
 
  zval_copy_ctor(_value);
6055
 
  return add_property_zval_ex(property_reference->object,Z_STRVAL_P(&(property->element)),1+Z_STRLEN_P(&(property->element)),_value);
6056
 
}
6057
 
static int _propset_FeatureDefn(zend_property_reference *property_reference, pval *value) {
6058
 
  /* get the property name */
6059
 
  zend_llist_element *element = property_reference->elements_list->head;
6060
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
6061
 
  char *propname=Z_STRVAL_P(&(property->element));
6062
 
  return FAILURE;
6063
 
}
 
6747
  OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
 
6748
  zval **args[1];
 
6749
  int result;
 
6750
  
 
6751
  SWIG_ResetError();
 
6752
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
6753
    WRONG_PARAM_COUNT;
 
6754
  }
 
6755
  
 
6756
  {
 
6757
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureDefnShadow, 0) < 0) {
 
6758
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FeatureDefn_GetReferenceCount. Expected SWIGTYPE_p_OGRFeatureDefnShadow");
 
6759
    }
 
6760
  }
 
6761
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
6762
  result = (int)OGRFeatureDefnShadow_GetReferenceCount(arg1);
 
6763
  {
 
6764
    ZVAL_LONG(return_value,result);
 
6765
  }
 
6766
  return;
 
6767
fail:
 
6768
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
6769
}
 
6770
 
 
6771
 
 
6772
ZEND_NAMED_FUNCTION(_wrap_FeatureDefn_IsGeometryIgnored) {
 
6773
  OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
 
6774
  zval **args[1];
 
6775
  int result;
 
6776
  
 
6777
  SWIG_ResetError();
 
6778
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
6779
    WRONG_PARAM_COUNT;
 
6780
  }
 
6781
  
 
6782
  {
 
6783
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureDefnShadow, 0) < 0) {
 
6784
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FeatureDefn_IsGeometryIgnored. Expected SWIGTYPE_p_OGRFeatureDefnShadow");
 
6785
    }
 
6786
  }
 
6787
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
6788
  result = (int)OGRFeatureDefnShadow_IsGeometryIgnored(arg1);
 
6789
  {
 
6790
    ZVAL_LONG(return_value,result);
 
6791
  }
 
6792
  return;
 
6793
fail:
 
6794
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
6795
}
 
6796
 
 
6797
 
 
6798
ZEND_NAMED_FUNCTION(_wrap_FeatureDefn_SetGeometryIgnored) {
 
6799
  OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
 
6800
  int arg2 ;
 
6801
  zval **args[2];
 
6802
  
 
6803
  SWIG_ResetError();
 
6804
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
6805
    WRONG_PARAM_COUNT;
 
6806
  }
 
6807
  
 
6808
  {
 
6809
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureDefnShadow, 0) < 0) {
 
6810
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FeatureDefn_SetGeometryIgnored. Expected SWIGTYPE_p_OGRFeatureDefnShadow");
 
6811
    }
 
6812
  }
 
6813
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
6814
  
 
6815
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
6816
  convert_to_long_ex(args[1]);
 
6817
  arg2 = (int) Z_LVAL_PP(args[1]);
 
6818
  /*@SWIG@*/;
 
6819
  
 
6820
  OGRFeatureDefnShadow_SetGeometryIgnored(arg1,arg2);
 
6821
  
 
6822
  return;
 
6823
fail:
 
6824
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
6825
}
 
6826
 
 
6827
 
 
6828
ZEND_NAMED_FUNCTION(_wrap_FeatureDefn_IsStyleIgnored) {
 
6829
  OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
 
6830
  zval **args[1];
 
6831
  int result;
 
6832
  
 
6833
  SWIG_ResetError();
 
6834
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
6835
    WRONG_PARAM_COUNT;
 
6836
  }
 
6837
  
 
6838
  {
 
6839
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureDefnShadow, 0) < 0) {
 
6840
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FeatureDefn_IsStyleIgnored. Expected SWIGTYPE_p_OGRFeatureDefnShadow");
 
6841
    }
 
6842
  }
 
6843
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
6844
  result = (int)OGRFeatureDefnShadow_IsStyleIgnored(arg1);
 
6845
  {
 
6846
    ZVAL_LONG(return_value,result);
 
6847
  }
 
6848
  return;
 
6849
fail:
 
6850
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
6851
}
 
6852
 
 
6853
 
 
6854
ZEND_NAMED_FUNCTION(_wrap_FeatureDefn_SetStyleIgnored) {
 
6855
  OGRFeatureDefnShadow *arg1 = (OGRFeatureDefnShadow *) 0 ;
 
6856
  int arg2 ;
 
6857
  zval **args[2];
 
6858
  
 
6859
  SWIG_ResetError();
 
6860
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
6861
    WRONG_PARAM_COUNT;
 
6862
  }
 
6863
  
 
6864
  {
 
6865
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFeatureDefnShadow, 0) < 0) {
 
6866
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FeatureDefn_SetStyleIgnored. Expected SWIGTYPE_p_OGRFeatureDefnShadow");
 
6867
    }
 
6868
  }
 
6869
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
6870
  
 
6871
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
6872
  convert_to_long_ex(args[1]);
 
6873
  arg2 = (int) Z_LVAL_PP(args[1]);
 
6874
  /*@SWIG@*/;
 
6875
  
 
6876
  OGRFeatureDefnShadow_SetStyleIgnored(arg1,arg2);
 
6877
  
 
6878
  return;
 
6879
fail:
 
6880
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
6881
}
 
6882
 
6064
6883
 
6065
6884
/* This function is designed to be called by the zend list destructors */
6066
6885
/* to typecast and do the actual destruction */
6067
 
void __wrap_delete_FieldDefn(zend_rsrc_list_entry *rsrc, const char *type_name TSRMLS_DC) {
6068
 
    swig_object_wrapper *value=(swig_object_wrapper *) rsrc->ptr ;
6069
 
    void *ptr=value->ptr ;
6070
 
    int newobject=value->newobject ;
6071
 
    OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
6072
 
    
6073
 
    efree(value);
6074
 
    if (! newobject) return; /* can't delete it! */
6075
 
    SWIG_ZTS_ConvertResourceData(ptr,rsrc->type,type_name,(void **) &arg1,SWIGTYPE_p_OGRFieldDefnShadow TSRMLS_CC);
6076
 
    if (! arg1) zend_error(E_ERROR, "OGRFieldDefnShadow resource already free'd");
6077
 
    delete_OGRFieldDefnShadow(arg1);
6078
 
    
 
6886
static void __wrap_delete_FieldDefn(zend_rsrc_list_entry *rsrc, const char *type_name TSRMLS_DC) {
 
6887
  swig_object_wrapper *value=(swig_object_wrapper *) rsrc->ptr ;
 
6888
  void *ptr=value->ptr ;
 
6889
  int newobject=value->newobject ;
 
6890
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
 
6891
  
 
6892
  efree(value);
 
6893
  if (! newobject) return; /* can't delete it! */
 
6894
  arg1 = (OGRFieldDefnShadow *)SWIG_ZTS_ConvertResourceData(ptr,type_name,SWIGTYPE_p_OGRFieldDefnShadow TSRMLS_CC);
 
6895
  if (! arg1) zend_error(E_ERROR, "OGRFieldDefnShadow resource already free'd");
 
6896
  delete_OGRFieldDefnShadow(arg1);
 
6897
  return;
 
6898
fail:
 
6899
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
6079
6900
}
6080
6901
 
6081
6902
 
6082
6903
ZEND_NAMED_FUNCTION(_wrap_new_FieldDefn) {
6083
 
    char *arg1 = (char *) "unnamed" ;
6084
 
    OGRFieldType arg2 = (OGRFieldType) OFTString ;
6085
 
    OGRFieldDefnShadow *result;
6086
 
    zval **args[2];
6087
 
    int arg_count;
6088
 
    
6089
 
    SWIG_ResetError();
6090
 
    /* NATIVE Constructor */
6091
 
    arg_count = ZEND_NUM_ARGS();
6092
 
    if(arg_count<0 || arg_count>2)
6093
 
    WRONG_PARAM_COUNT;
6094
 
    
6095
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
6096
 
    WRONG_PARAM_COUNT;
6097
 
    
6098
 
    if(arg_count > 0) {
6099
 
        {
6100
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
6101
 
            convert_to_string_ex(args[0]);
6102
 
            arg1 = (char *) Z_STRVAL_PP(args[0]);
6103
 
            /*@@*/;
6104
 
        }
6105
 
    }
6106
 
    if(arg_count > 1) {
6107
 
        {
6108
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
6109
 
            convert_to_long_ex(args[1]);
6110
 
            arg2 = (OGRFieldType) Z_LVAL_PP(args[1]);
6111
 
            /*@@*/;
6112
 
        }
6113
 
    }
6114
 
    result = (OGRFieldDefnShadow *)new_OGRFieldDefnShadow((char const *)arg1,arg2);
6115
 
    
6116
 
    {
6117
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRFieldDefnShadow, 1);
6118
 
    }
6119
 
    /* Wrap this return value */
6120
 
    if (this_ptr) {
6121
 
        /* NATIVE Constructor, use this_ptr */
6122
 
        zval *_cPtr; MAKE_STD_ZVAL(_cPtr);
6123
 
        *_cPtr = *return_value;
6124
 
        INIT_ZVAL(*return_value);
6125
 
        add_property_zval(this_ptr,"_cPtr",_cPtr);
6126
 
    } else if (! this_ptr) {
6127
 
        /* ALTERNATIVE Constructor, make an object wrapper */
6128
 
        zval *obj, *_cPtr;
6129
 
        MAKE_STD_ZVAL(obj);
6130
 
        MAKE_STD_ZVAL(_cPtr);
6131
 
        *_cPtr = *return_value;
6132
 
        INIT_ZVAL(*return_value);
6133
 
        object_init_ex(obj,ptr_ce_swig_FieldDefn);
6134
 
        add_property_zval(obj,"_cPtr",_cPtr);
6135
 
        *return_value=*obj;
6136
 
    }
6137
 
    return;
6138
 
    fail:
6139
 
    zend_error(ErrorCode(),ErrorMsg());
 
6904
  char *arg1 = (char *) "unnamed" ;
 
6905
  OGRFieldType arg2 = (OGRFieldType) OFTString ;
 
6906
  zval **args[2];
 
6907
  int arg_count;
 
6908
  OGRFieldDefnShadow *result = 0 ;
 
6909
  
 
6910
  SWIG_ResetError();
 
6911
  arg_count = ZEND_NUM_ARGS();
 
6912
  if(arg_count<0 || arg_count>2 ||
 
6913
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
6914
  WRONG_PARAM_COUNT;
 
6915
  
 
6916
  if(arg_count > 0) {
 
6917
    /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
6918
    if ((*args[0])->type==IS_NULL) {
 
6919
      arg1 = (char *) 0;
 
6920
    } else {
 
6921
      convert_to_string_ex(args[0]);
 
6922
      arg1 = (char *) Z_STRVAL_PP(args[0]);
 
6923
    }
 
6924
    /*@SWIG@*/;
 
6925
    
 
6926
  }
 
6927
  if(arg_count > 1) {
 
6928
    /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
6929
    convert_to_long_ex(args[1]);
 
6930
    arg2 = (OGRFieldType) Z_LVAL_PP(args[1]);
 
6931
    /*@SWIG@*/;
 
6932
    
 
6933
  }
 
6934
  result = (OGRFieldDefnShadow *)new_OGRFieldDefnShadow((char const *)arg1,arg2);
 
6935
  
 
6936
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRFieldDefnShadow, 1);
 
6937
  
 
6938
  return;
 
6939
fail:
 
6940
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
6140
6941
}
6141
6942
 
6142
6943
 
6143
6944
ZEND_NAMED_FUNCTION(_wrap_FieldDefn_GetName) {
6144
 
    OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
6145
 
    char *result;
6146
 
    zval **args[0];
6147
 
    
6148
 
    SWIG_ResetError();
6149
 
    /* This function uses a this_ptr*/
6150
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
6151
 
        WRONG_PARAM_COUNT;
6152
 
    }
6153
 
    
6154
 
    {
6155
 
        /* typemap(in) SWIGTYPE * */
6156
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
6157
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_GetName. Expected SWIGTYPE_p_p_OGRFieldDefnShadow");
6158
 
        }
6159
 
    }
6160
 
    result = (char *)OGRFieldDefnShadow_GetName(arg1);
6161
 
    
6162
 
    {
6163
 
        if(!result) {
6164
 
            ZVAL_NULL(return_value);
6165
 
        } else {
6166
 
            ZVAL_STRING(return_value,result, 1);
6167
 
        }
6168
 
    }
6169
 
    return;
6170
 
    fail:
6171
 
    zend_error(ErrorCode(),ErrorMsg());
 
6945
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
 
6946
  zval **args[1];
 
6947
  char *result = 0 ;
 
6948
  
 
6949
  SWIG_ResetError();
 
6950
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
6951
    WRONG_PARAM_COUNT;
 
6952
  }
 
6953
  
 
6954
  {
 
6955
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
 
6956
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_GetName. Expected SWIGTYPE_p_OGRFieldDefnShadow");
 
6957
    }
 
6958
  }
 
6959
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
6960
  result = (char *)OGRFieldDefnShadow_GetName(arg1);
 
6961
  {
 
6962
    if(!result) {
 
6963
      ZVAL_NULL(return_value);
 
6964
    } else {
 
6965
      ZVAL_STRING(return_value, (char *)result, 1);
 
6966
    }
 
6967
  }
 
6968
  return;
 
6969
fail:
 
6970
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
6172
6971
}
6173
6972
 
6174
6973
 
6175
6974
ZEND_NAMED_FUNCTION(_wrap_FieldDefn_GetNameRef) {
6176
 
    OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
6177
 
    char *result;
6178
 
    zval **args[0];
6179
 
    
6180
 
    SWIG_ResetError();
6181
 
    /* This function uses a this_ptr*/
6182
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
6183
 
        WRONG_PARAM_COUNT;
6184
 
    }
6185
 
    
6186
 
    {
6187
 
        /* typemap(in) SWIGTYPE * */
6188
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
6189
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_GetNameRef. Expected SWIGTYPE_p_p_OGRFieldDefnShadow");
6190
 
        }
6191
 
    }
6192
 
    result = (char *)OGRFieldDefnShadow_GetNameRef(arg1);
6193
 
    
6194
 
    {
6195
 
        if(!result) {
6196
 
            ZVAL_NULL(return_value);
6197
 
        } else {
6198
 
            ZVAL_STRING(return_value,result, 1);
6199
 
        }
6200
 
    }
6201
 
    return;
6202
 
    fail:
6203
 
    zend_error(ErrorCode(),ErrorMsg());
 
6975
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
 
6976
  zval **args[1];
 
6977
  char *result = 0 ;
 
6978
  
 
6979
  SWIG_ResetError();
 
6980
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
6981
    WRONG_PARAM_COUNT;
 
6982
  }
 
6983
  
 
6984
  {
 
6985
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
 
6986
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_GetNameRef. Expected SWIGTYPE_p_OGRFieldDefnShadow");
 
6987
    }
 
6988
  }
 
6989
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
6990
  result = (char *)OGRFieldDefnShadow_GetNameRef(arg1);
 
6991
  {
 
6992
    if(!result) {
 
6993
      ZVAL_NULL(return_value);
 
6994
    } else {
 
6995
      ZVAL_STRING(return_value, (char *)result, 1);
 
6996
    }
 
6997
  }
 
6998
  return;
 
6999
fail:
 
7000
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
6204
7001
}
6205
7002
 
6206
7003
 
6207
7004
ZEND_NAMED_FUNCTION(_wrap_FieldDefn_SetName) {
6208
 
    OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
6209
 
    char *arg2 = (char *) 0 ;
6210
 
    zval **args[1];
6211
 
    
6212
 
    SWIG_ResetError();
6213
 
    /* This function uses a this_ptr*/
6214
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
6215
 
        WRONG_PARAM_COUNT;
6216
 
    }
6217
 
    
6218
 
    {
6219
 
        /* typemap(in) SWIGTYPE * */
6220
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
6221
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_SetName. Expected SWIGTYPE_p_p_OGRFieldDefnShadow");
6222
 
        }
6223
 
    }
6224
 
    {
6225
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
6226
 
        convert_to_string_ex(args[0]);
6227
 
        arg2 = (char *) Z_STRVAL_PP(args[0]);
6228
 
        /*@@*/;
6229
 
    }
6230
 
    OGRFieldDefnShadow_SetName(arg1,(char const *)arg2);
6231
 
    
6232
 
    
6233
 
    return;
6234
 
    fail:
6235
 
    zend_error(ErrorCode(),ErrorMsg());
 
7005
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
 
7006
  char *arg2 = (char *) 0 ;
 
7007
  zval **args[2];
 
7008
  
 
7009
  SWIG_ResetError();
 
7010
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
7011
    WRONG_PARAM_COUNT;
 
7012
  }
 
7013
  
 
7014
  {
 
7015
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
 
7016
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_SetName. Expected SWIGTYPE_p_OGRFieldDefnShadow");
 
7017
    }
 
7018
  }
 
7019
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
7020
  
 
7021
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
7022
  if ((*args[1])->type==IS_NULL) {
 
7023
    arg2 = (char *) 0;
 
7024
  } else {
 
7025
    convert_to_string_ex(args[1]);
 
7026
    arg2 = (char *) Z_STRVAL_PP(args[1]);
 
7027
  }
 
7028
  /*@SWIG@*/;
 
7029
  
 
7030
  {
 
7031
    if (!arg2) {
 
7032
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
7033
    }
 
7034
  }
 
7035
  OGRFieldDefnShadow_SetName(arg1,(char const *)arg2);
 
7036
  
 
7037
  return;
 
7038
fail:
 
7039
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
6236
7040
}
6237
7041
 
6238
7042
 
6239
7043
ZEND_NAMED_FUNCTION(_wrap_FieldDefn_GetType) {
6240
 
    OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
6241
 
    OGRFieldType result;
6242
 
    zval **args[0];
6243
 
    
6244
 
    SWIG_ResetError();
6245
 
    /* This function uses a this_ptr*/
6246
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
6247
 
        WRONG_PARAM_COUNT;
6248
 
    }
6249
 
    
6250
 
    {
6251
 
        /* typemap(in) SWIGTYPE * */
6252
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
6253
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_GetType. Expected SWIGTYPE_p_p_OGRFieldDefnShadow");
6254
 
        }
6255
 
    }
6256
 
    result = (OGRFieldType)OGRFieldDefnShadow_GetType(arg1);
6257
 
    
6258
 
    {
6259
 
        ZVAL_LONG(return_value,result);
6260
 
    }
6261
 
    return;
6262
 
    fail:
6263
 
    zend_error(ErrorCode(),ErrorMsg());
 
7044
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
 
7045
  zval **args[1];
 
7046
  OGRFieldType result;
 
7047
  
 
7048
  SWIG_ResetError();
 
7049
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
7050
    WRONG_PARAM_COUNT;
 
7051
  }
 
7052
  
 
7053
  {
 
7054
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
 
7055
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_GetType. Expected SWIGTYPE_p_OGRFieldDefnShadow");
 
7056
    }
 
7057
  }
 
7058
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
7059
  result = (OGRFieldType)OGRFieldDefnShadow_GetType(arg1);
 
7060
  {
 
7061
    ZVAL_LONG(return_value,result);
 
7062
  }
 
7063
  return;
 
7064
fail:
 
7065
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
6264
7066
}
6265
7067
 
6266
7068
 
6267
7069
ZEND_NAMED_FUNCTION(_wrap_FieldDefn_SetType) {
6268
 
    OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
6269
 
    OGRFieldType arg2 ;
6270
 
    zval **args[1];
6271
 
    
6272
 
    SWIG_ResetError();
6273
 
    /* This function uses a this_ptr*/
6274
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
6275
 
        WRONG_PARAM_COUNT;
6276
 
    }
6277
 
    
6278
 
    {
6279
 
        /* typemap(in) SWIGTYPE * */
6280
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
6281
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_SetType. Expected SWIGTYPE_p_p_OGRFieldDefnShadow");
6282
 
        }
6283
 
    }
6284
 
    {
6285
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
6286
 
        convert_to_long_ex(args[0]);
6287
 
        arg2 = (OGRFieldType) Z_LVAL_PP(args[0]);
6288
 
        /*@@*/;
6289
 
    }
6290
 
    OGRFieldDefnShadow_SetType(arg1,arg2);
6291
 
    
6292
 
    
6293
 
    return;
6294
 
    fail:
6295
 
    zend_error(ErrorCode(),ErrorMsg());
 
7070
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
 
7071
  OGRFieldType arg2 ;
 
7072
  zval **args[2];
 
7073
  
 
7074
  SWIG_ResetError();
 
7075
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
7076
    WRONG_PARAM_COUNT;
 
7077
  }
 
7078
  
 
7079
  {
 
7080
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
 
7081
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_SetType. Expected SWIGTYPE_p_OGRFieldDefnShadow");
 
7082
    }
 
7083
  }
 
7084
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
7085
  
 
7086
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
7087
  convert_to_long_ex(args[1]);
 
7088
  arg2 = (OGRFieldType) Z_LVAL_PP(args[1]);
 
7089
  /*@SWIG@*/;
 
7090
  
 
7091
  OGRFieldDefnShadow_SetType(arg1,arg2);
 
7092
  
 
7093
  return;
 
7094
fail:
 
7095
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
6296
7096
}
6297
7097
 
6298
7098
 
6299
7099
ZEND_NAMED_FUNCTION(_wrap_FieldDefn_GetJustify) {
6300
 
    OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
6301
 
    OGRJustification result;
6302
 
    zval **args[0];
6303
 
    
6304
 
    SWIG_ResetError();
6305
 
    /* This function uses a this_ptr*/
6306
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
6307
 
        WRONG_PARAM_COUNT;
6308
 
    }
6309
 
    
6310
 
    {
6311
 
        /* typemap(in) SWIGTYPE * */
6312
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
6313
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_GetJustify. Expected SWIGTYPE_p_p_OGRFieldDefnShadow");
6314
 
        }
6315
 
    }
6316
 
    result = (OGRJustification)OGRFieldDefnShadow_GetJustify(arg1);
6317
 
    
6318
 
    {
6319
 
        ZVAL_LONG(return_value,result);
6320
 
    }
6321
 
    return;
6322
 
    fail:
6323
 
    zend_error(ErrorCode(),ErrorMsg());
 
7100
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
 
7101
  zval **args[1];
 
7102
  OGRJustification result;
 
7103
  
 
7104
  SWIG_ResetError();
 
7105
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
7106
    WRONG_PARAM_COUNT;
 
7107
  }
 
7108
  
 
7109
  {
 
7110
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
 
7111
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_GetJustify. Expected SWIGTYPE_p_OGRFieldDefnShadow");
 
7112
    }
 
7113
  }
 
7114
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
7115
  result = (OGRJustification)OGRFieldDefnShadow_GetJustify(arg1);
 
7116
  {
 
7117
    ZVAL_LONG(return_value,result);
 
7118
  }
 
7119
  return;
 
7120
fail:
 
7121
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
6324
7122
}
6325
7123
 
6326
7124
 
6327
7125
ZEND_NAMED_FUNCTION(_wrap_FieldDefn_SetJustify) {
6328
 
    OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
6329
 
    OGRJustification arg2 ;
6330
 
    zval **args[1];
6331
 
    
6332
 
    SWIG_ResetError();
6333
 
    /* This function uses a this_ptr*/
6334
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
6335
 
        WRONG_PARAM_COUNT;
6336
 
    }
6337
 
    
6338
 
    {
6339
 
        /* typemap(in) SWIGTYPE * */
6340
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
6341
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_SetJustify. Expected SWIGTYPE_p_p_OGRFieldDefnShadow");
6342
 
        }
6343
 
    }
6344
 
    {
6345
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
6346
 
        convert_to_long_ex(args[0]);
6347
 
        arg2 = (OGRJustification) Z_LVAL_PP(args[0]);
6348
 
        /*@@*/;
6349
 
    }
6350
 
    OGRFieldDefnShadow_SetJustify(arg1,arg2);
6351
 
    
6352
 
    
6353
 
    return;
6354
 
    fail:
6355
 
    zend_error(ErrorCode(),ErrorMsg());
 
7126
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
 
7127
  OGRJustification arg2 ;
 
7128
  zval **args[2];
 
7129
  
 
7130
  SWIG_ResetError();
 
7131
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
7132
    WRONG_PARAM_COUNT;
 
7133
  }
 
7134
  
 
7135
  {
 
7136
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
 
7137
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_SetJustify. Expected SWIGTYPE_p_OGRFieldDefnShadow");
 
7138
    }
 
7139
  }
 
7140
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
7141
  
 
7142
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
7143
  convert_to_long_ex(args[1]);
 
7144
  arg2 = (OGRJustification) Z_LVAL_PP(args[1]);
 
7145
  /*@SWIG@*/;
 
7146
  
 
7147
  OGRFieldDefnShadow_SetJustify(arg1,arg2);
 
7148
  
 
7149
  return;
 
7150
fail:
 
7151
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
6356
7152
}
6357
7153
 
6358
7154
 
6359
7155
ZEND_NAMED_FUNCTION(_wrap_FieldDefn_GetWidth) {
6360
 
    OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
6361
 
    int result;
6362
 
    zval **args[0];
6363
 
    
6364
 
    SWIG_ResetError();
6365
 
    /* This function uses a this_ptr*/
6366
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
6367
 
        WRONG_PARAM_COUNT;
6368
 
    }
6369
 
    
6370
 
    {
6371
 
        /* typemap(in) SWIGTYPE * */
6372
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
6373
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_GetWidth. Expected SWIGTYPE_p_p_OGRFieldDefnShadow");
6374
 
        }
6375
 
    }
6376
 
    result = (int)OGRFieldDefnShadow_GetWidth(arg1);
6377
 
    
6378
 
    {
6379
 
        ZVAL_LONG(return_value,result);
6380
 
    }
6381
 
    return;
6382
 
    fail:
6383
 
    zend_error(ErrorCode(),ErrorMsg());
 
7156
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
 
7157
  zval **args[1];
 
7158
  int result;
 
7159
  
 
7160
  SWIG_ResetError();
 
7161
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
7162
    WRONG_PARAM_COUNT;
 
7163
  }
 
7164
  
 
7165
  {
 
7166
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
 
7167
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_GetWidth. Expected SWIGTYPE_p_OGRFieldDefnShadow");
 
7168
    }
 
7169
  }
 
7170
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
7171
  result = (int)OGRFieldDefnShadow_GetWidth(arg1);
 
7172
  {
 
7173
    ZVAL_LONG(return_value,result);
 
7174
  }
 
7175
  return;
 
7176
fail:
 
7177
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
6384
7178
}
6385
7179
 
6386
7180
 
6387
7181
ZEND_NAMED_FUNCTION(_wrap_FieldDefn_SetWidth) {
6388
 
    OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
6389
 
    int arg2 ;
6390
 
    zval **args[1];
6391
 
    
6392
 
    SWIG_ResetError();
6393
 
    /* This function uses a this_ptr*/
6394
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
6395
 
        WRONG_PARAM_COUNT;
6396
 
    }
6397
 
    
6398
 
    {
6399
 
        /* typemap(in) SWIGTYPE * */
6400
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
6401
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_SetWidth. Expected SWIGTYPE_p_p_OGRFieldDefnShadow");
6402
 
        }
6403
 
    }
6404
 
    {
6405
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
6406
 
        convert_to_long_ex(args[0]);
6407
 
        arg2 = (int) Z_LVAL_PP(args[0]);
6408
 
        /*@@*/;
6409
 
    }
6410
 
    OGRFieldDefnShadow_SetWidth(arg1,arg2);
6411
 
    
6412
 
    
6413
 
    return;
6414
 
    fail:
6415
 
    zend_error(ErrorCode(),ErrorMsg());
 
7182
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
 
7183
  int arg2 ;
 
7184
  zval **args[2];
 
7185
  
 
7186
  SWIG_ResetError();
 
7187
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
7188
    WRONG_PARAM_COUNT;
 
7189
  }
 
7190
  
 
7191
  {
 
7192
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
 
7193
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_SetWidth. Expected SWIGTYPE_p_OGRFieldDefnShadow");
 
7194
    }
 
7195
  }
 
7196
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
7197
  
 
7198
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
7199
  convert_to_long_ex(args[1]);
 
7200
  arg2 = (int) Z_LVAL_PP(args[1]);
 
7201
  /*@SWIG@*/;
 
7202
  
 
7203
  OGRFieldDefnShadow_SetWidth(arg1,arg2);
 
7204
  
 
7205
  return;
 
7206
fail:
 
7207
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
6416
7208
}
6417
7209
 
6418
7210
 
6419
7211
ZEND_NAMED_FUNCTION(_wrap_FieldDefn_GetPrecision) {
6420
 
    OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
6421
 
    int result;
6422
 
    zval **args[0];
6423
 
    
6424
 
    SWIG_ResetError();
6425
 
    /* This function uses a this_ptr*/
6426
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
6427
 
        WRONG_PARAM_COUNT;
6428
 
    }
6429
 
    
6430
 
    {
6431
 
        /* typemap(in) SWIGTYPE * */
6432
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
6433
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_GetPrecision. Expected SWIGTYPE_p_p_OGRFieldDefnShadow");
6434
 
        }
6435
 
    }
6436
 
    result = (int)OGRFieldDefnShadow_GetPrecision(arg1);
6437
 
    
6438
 
    {
6439
 
        ZVAL_LONG(return_value,result);
6440
 
    }
6441
 
    return;
6442
 
    fail:
6443
 
    zend_error(ErrorCode(),ErrorMsg());
 
7212
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
 
7213
  zval **args[1];
 
7214
  int result;
 
7215
  
 
7216
  SWIG_ResetError();
 
7217
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
7218
    WRONG_PARAM_COUNT;
 
7219
  }
 
7220
  
 
7221
  {
 
7222
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
 
7223
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_GetPrecision. Expected SWIGTYPE_p_OGRFieldDefnShadow");
 
7224
    }
 
7225
  }
 
7226
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
7227
  result = (int)OGRFieldDefnShadow_GetPrecision(arg1);
 
7228
  {
 
7229
    ZVAL_LONG(return_value,result);
 
7230
  }
 
7231
  return;
 
7232
fail:
 
7233
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
6444
7234
}
6445
7235
 
6446
7236
 
6447
7237
ZEND_NAMED_FUNCTION(_wrap_FieldDefn_SetPrecision) {
6448
 
    OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
6449
 
    int arg2 ;
6450
 
    zval **args[1];
6451
 
    
6452
 
    SWIG_ResetError();
6453
 
    /* This function uses a this_ptr*/
6454
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
6455
 
        WRONG_PARAM_COUNT;
6456
 
    }
6457
 
    
6458
 
    {
6459
 
        /* typemap(in) SWIGTYPE * */
6460
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
6461
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_SetPrecision. Expected SWIGTYPE_p_p_OGRFieldDefnShadow");
6462
 
        }
6463
 
    }
6464
 
    {
6465
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
6466
 
        convert_to_long_ex(args[0]);
6467
 
        arg2 = (int) Z_LVAL_PP(args[0]);
6468
 
        /*@@*/;
6469
 
    }
6470
 
    OGRFieldDefnShadow_SetPrecision(arg1,arg2);
6471
 
    
6472
 
    
6473
 
    return;
6474
 
    fail:
6475
 
    zend_error(ErrorCode(),ErrorMsg());
 
7238
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
 
7239
  int arg2 ;
 
7240
  zval **args[2];
 
7241
  
 
7242
  SWIG_ResetError();
 
7243
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
7244
    WRONG_PARAM_COUNT;
 
7245
  }
 
7246
  
 
7247
  {
 
7248
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
 
7249
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_SetPrecision. Expected SWIGTYPE_p_OGRFieldDefnShadow");
 
7250
    }
 
7251
  }
 
7252
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
7253
  
 
7254
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
7255
  convert_to_long_ex(args[1]);
 
7256
  arg2 = (int) Z_LVAL_PP(args[1]);
 
7257
  /*@SWIG@*/;
 
7258
  
 
7259
  OGRFieldDefnShadow_SetPrecision(arg1,arg2);
 
7260
  
 
7261
  return;
 
7262
fail:
 
7263
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
7264
}
 
7265
 
 
7266
 
 
7267
ZEND_NAMED_FUNCTION(_wrap_FieldDefn_GetTypeName) {
 
7268
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
 
7269
  zval **args[1];
 
7270
  char *result = 0 ;
 
7271
  
 
7272
  SWIG_ResetError();
 
7273
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
7274
    WRONG_PARAM_COUNT;
 
7275
  }
 
7276
  
 
7277
  {
 
7278
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
 
7279
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_GetTypeName. Expected SWIGTYPE_p_OGRFieldDefnShadow");
 
7280
    }
 
7281
  }
 
7282
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
7283
  result = (char *)OGRFieldDefnShadow_GetTypeName(arg1);
 
7284
  {
 
7285
    if(!result) {
 
7286
      ZVAL_NULL(return_value);
 
7287
    } else {
 
7288
      ZVAL_STRING(return_value, (char *)result, 1);
 
7289
    }
 
7290
  }
 
7291
  return;
 
7292
fail:
 
7293
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
6476
7294
}
6477
7295
 
6478
7296
 
6479
7297
ZEND_NAMED_FUNCTION(_wrap_FieldDefn_GetFieldTypeName) {
6480
 
    OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
6481
 
    OGRFieldType arg2 ;
6482
 
    char *result;
6483
 
    zval **args[1];
6484
 
    
6485
 
    SWIG_ResetError();
6486
 
    /* This function uses a this_ptr*/
6487
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
6488
 
        WRONG_PARAM_COUNT;
6489
 
    }
6490
 
    
6491
 
    {
6492
 
        /* typemap(in) SWIGTYPE * */
6493
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
6494
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_GetFieldTypeName. Expected SWIGTYPE_p_p_OGRFieldDefnShadow");
6495
 
        }
6496
 
    }
6497
 
    {
6498
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
6499
 
        convert_to_long_ex(args[0]);
6500
 
        arg2 = (OGRFieldType) Z_LVAL_PP(args[0]);
6501
 
        /*@@*/;
6502
 
    }
6503
 
    result = (char *)OGRFieldDefnShadow_GetFieldTypeName(arg1,arg2);
6504
 
    
6505
 
    {
6506
 
        if(!result) {
6507
 
            ZVAL_NULL(return_value);
6508
 
        } else {
6509
 
            ZVAL_STRING(return_value,result, 1);
6510
 
        }
6511
 
    }
6512
 
    return;
6513
 
    fail:
6514
 
    zend_error(ErrorCode(),ErrorMsg());
6515
 
}
6516
 
 
6517
 
 
6518
 
/* property handler for class FieldDefn */
6519
 
static pval _wrap_propget_FieldDefn(zend_property_reference *property_reference) {
6520
 
  pval result;
6521
 
  pval **_result;
6522
 
  zend_llist_element *element = property_reference->elements_list->head;
6523
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
6524
 
  result.type = IS_NULL;
6525
 
  if (_propget_FieldDefn(property_reference, &result)==SUCCESS) return result;
6526
 
  /* return it ourselves */
6527
 
  if (zend_hash_find(Z_OBJPROP_P(property_reference->object),Z_STRVAL_P(&(property->element)),1+Z_STRLEN_P(&(property->element)),(void**)&_result)==SUCCESS) {
6528
 
  zval *_value;
6529
 
  MAKE_STD_ZVAL(_value);  *_value=**_result;
6530
 
  INIT_PZVAL(_value);
6531
 
  zval_copy_ctor(_value);
6532
 
  return *_value;
6533
 
  }
6534
 
  result.type = IS_NULL;
6535
 
  return result;
6536
 
}
6537
 
static int _propget_FieldDefn(zend_property_reference *property_reference, pval *value) {
6538
 
  /* get the property name */
6539
 
  zend_llist_element *element = property_reference->elements_list->head;
6540
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
6541
 
  char *propname=Z_STRVAL_P(&(property->element));
6542
 
  return FAILURE;
6543
 
}
6544
 
 
6545
 
static int _wrap_propset_FieldDefn(zend_property_reference *property_reference, pval *value) { 
6546
 
  zval * _value;
6547
 
  zend_llist_element *element = property_reference->elements_list->head;
6548
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
6549
 
  if (_propset_FieldDefn(property_reference, value)==SUCCESS) return SUCCESS;
6550
 
  /* set it ourselves as it is FieldDefn */
6551
 
  MAKE_STD_ZVAL(_value);
6552
 
  *_value=*value;
6553
 
  INIT_PZVAL(_value);
6554
 
  zval_copy_ctor(_value);
6555
 
  return add_property_zval_ex(property_reference->object,Z_STRVAL_P(&(property->element)),1+Z_STRLEN_P(&(property->element)),_value);
6556
 
}
6557
 
static int _propset_FieldDefn(zend_property_reference *property_reference, pval *value) {
6558
 
  /* get the property name */
6559
 
  zend_llist_element *element = property_reference->elements_list->head;
6560
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
6561
 
  char *propname=Z_STRVAL_P(&(property->element));
6562
 
  return FAILURE;
6563
 
}
 
7298
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
 
7299
  OGRFieldType arg2 ;
 
7300
  zval **args[2];
 
7301
  char *result = 0 ;
 
7302
  
 
7303
  SWIG_ResetError();
 
7304
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
7305
    WRONG_PARAM_COUNT;
 
7306
  }
 
7307
  
 
7308
  {
 
7309
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
 
7310
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_GetFieldTypeName. Expected SWIGTYPE_p_OGRFieldDefnShadow");
 
7311
    }
 
7312
  }
 
7313
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
7314
  
 
7315
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
7316
  convert_to_long_ex(args[1]);
 
7317
  arg2 = (OGRFieldType) Z_LVAL_PP(args[1]);
 
7318
  /*@SWIG@*/;
 
7319
  
 
7320
  result = (char *)OGRFieldDefnShadow_GetFieldTypeName(arg1,arg2);
 
7321
  {
 
7322
    if(!result) {
 
7323
      ZVAL_NULL(return_value);
 
7324
    } else {
 
7325
      ZVAL_STRING(return_value, (char *)result, 1);
 
7326
    }
 
7327
  }
 
7328
  return;
 
7329
fail:
 
7330
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
7331
}
 
7332
 
 
7333
 
 
7334
ZEND_NAMED_FUNCTION(_wrap_FieldDefn_IsIgnored) {
 
7335
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
 
7336
  zval **args[1];
 
7337
  int result;
 
7338
  
 
7339
  SWIG_ResetError();
 
7340
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
7341
    WRONG_PARAM_COUNT;
 
7342
  }
 
7343
  
 
7344
  {
 
7345
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
 
7346
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_IsIgnored. Expected SWIGTYPE_p_OGRFieldDefnShadow");
 
7347
    }
 
7348
  }
 
7349
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
7350
  result = (int)OGRFieldDefnShadow_IsIgnored(arg1);
 
7351
  {
 
7352
    ZVAL_LONG(return_value,result);
 
7353
  }
 
7354
  return;
 
7355
fail:
 
7356
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
7357
}
 
7358
 
 
7359
 
 
7360
ZEND_NAMED_FUNCTION(_wrap_FieldDefn_SetIgnored) {
 
7361
  OGRFieldDefnShadow *arg1 = (OGRFieldDefnShadow *) 0 ;
 
7362
  int arg2 ;
 
7363
  zval **args[2];
 
7364
  
 
7365
  SWIG_ResetError();
 
7366
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
7367
    WRONG_PARAM_COUNT;
 
7368
  }
 
7369
  
 
7370
  {
 
7371
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRFieldDefnShadow, 0) < 0) {
 
7372
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of FieldDefn_SetIgnored. Expected SWIGTYPE_p_OGRFieldDefnShadow");
 
7373
    }
 
7374
  }
 
7375
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
7376
  
 
7377
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
7378
  convert_to_long_ex(args[1]);
 
7379
  arg2 = (int) Z_LVAL_PP(args[1]);
 
7380
  /*@SWIG@*/;
 
7381
  
 
7382
  OGRFieldDefnShadow_SetIgnored(arg1,arg2);
 
7383
  
 
7384
  return;
 
7385
fail:
 
7386
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
7387
}
 
7388
 
6564
7389
 
6565
7390
ZEND_NAMED_FUNCTION(_wrap_CreateGeometryFromWkb) {
6566
 
    int arg1 ;
6567
 
    char *arg2 = (char *) 0 ;
6568
 
    OSRSpatialReferenceShadow *arg3 = (OSRSpatialReferenceShadow *) NULL ;
6569
 
    OGRGeometryShadow *result;
6570
 
    zval **args[2];
6571
 
    int arg_count;
6572
 
    
6573
 
    SWIG_ResetError();
6574
 
    arg_count = ZEND_NUM_ARGS();
6575
 
    if(arg_count<1 || arg_count>2)
6576
 
    WRONG_PARAM_COUNT;
6577
 
    
6578
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
6579
 
    WRONG_PARAM_COUNT;
6580
 
    
6581
 
    {
6582
 
        /* %typemap(in,numinputs=1) (int nLen, char *pBuf ) */
6583
 
        convert_to_string_ex(args[0]);
6584
 
        arg2 = Z_STRVAL_PP(args[0]);
6585
 
        arg1 = Z_STRLEN_PP(args[0]);
6586
 
    }
6587
 
    if(arg_count > 1) {
6588
 
        {
6589
 
            /* typemap(in) SWIGTYPE * */
6590
 
            if(SWIG_ConvertPtr(*args[1], (void **) &arg3, SWIGTYPE_p_OSRSpatialReferenceShadow, 0) < 0) {
6591
 
                SWIG_PHP_Error(E_ERROR, "Type error in argument 3 of CreateGeometryFromWkb. Expected SWIGTYPE_p_p_OSRSpatialReferenceShadow");
6592
 
            }
6593
 
        }
6594
 
    }
6595
 
    result = (OGRGeometryShadow *)CreateGeometryFromWkb(arg1,arg2,arg3);
6596
 
    
6597
 
    {
6598
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
6599
 
    }
6600
 
    /* Wrap this return value */
6601
 
    {
6602
 
        /* ALTERNATIVE Constructor, make an object wrapper */
6603
 
        zval *obj, *_cPtr;
6604
 
        MAKE_STD_ZVAL(obj);
6605
 
        MAKE_STD_ZVAL(_cPtr);
6606
 
        *_cPtr = *return_value;
6607
 
        INIT_ZVAL(*return_value);
6608
 
        object_init_ex(obj,ptr_ce_swig_Geometry);
6609
 
        add_property_zval(obj,"_cPtr",_cPtr);
6610
 
        *return_value=*obj;
6611
 
    }
6612
 
    return;
6613
 
    fail:
6614
 
    zend_error(ErrorCode(),ErrorMsg());
 
7391
  int arg1 ;
 
7392
  char *arg2 = (char *) 0 ;
 
7393
  OSRSpatialReferenceShadow *arg3 = (OSRSpatialReferenceShadow *) NULL ;
 
7394
  zval **args[2];
 
7395
  int arg_count;
 
7396
  OGRGeometryShadow *result = 0 ;
 
7397
  
 
7398
  SWIG_ResetError();
 
7399
  arg_count = ZEND_NUM_ARGS();
 
7400
  if(arg_count<1 || arg_count>2 ||
 
7401
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
7402
  WRONG_PARAM_COUNT;
 
7403
  
 
7404
  {
 
7405
    /* %typemap(in,numinputs=1) (int nLen, char *pBuf ) */
 
7406
    convert_to_string_ex(args[0]);
 
7407
    arg2 = Z_STRVAL_PP(args[0]);
 
7408
    arg1 = Z_STRLEN_PP(args[0]);
 
7409
  }
 
7410
  if(arg_count > 1) {
 
7411
    {
 
7412
      if(SWIG_ConvertPtr(*args[1], (void **) &arg3, SWIGTYPE_p_OSRSpatialReferenceShadow, 0) < 0) {
 
7413
        SWIG_PHP_Error(E_ERROR, "Type error in argument 3 of CreateGeometryFromWkb. Expected SWIGTYPE_p_OSRSpatialReferenceShadow");
 
7414
      }
 
7415
    }
 
7416
  }
 
7417
  result = (OGRGeometryShadow *)CreateGeometryFromWkb(arg1,arg2,arg3);
 
7418
  
 
7419
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
7420
  
 
7421
  return;
 
7422
fail:
 
7423
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
6615
7424
}
6616
7425
 
6617
7426
 
6618
7427
ZEND_NAMED_FUNCTION(_wrap_CreateGeometryFromWkt) {
6619
 
    char **arg1 = (char **) 0 ;
6620
 
    OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) NULL ;
6621
 
    OGRGeometryShadow *result;
6622
 
    char *val1 ;
6623
 
    zval **args[2];
6624
 
    int arg_count;
6625
 
    
6626
 
    SWIG_ResetError();
6627
 
    arg_count = ZEND_NUM_ARGS();
6628
 
    if(arg_count<1 || arg_count>2)
6629
 
    WRONG_PARAM_COUNT;
6630
 
    
6631
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
6632
 
    WRONG_PARAM_COUNT;
6633
 
    
6634
 
    {
6635
 
        /* %typemap(in) (char **ignorechange) */
6636
 
        convert_to_string_ex( args[0] );
6637
 
        arg1 = NULL;
6638
 
    }
6639
 
    if(arg_count > 1) {
6640
 
        {
6641
 
            /* typemap(in) SWIGTYPE * */
6642
 
            if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OSRSpatialReferenceShadow, 0) < 0) {
6643
 
                SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of CreateGeometryFromWkt. Expected SWIGTYPE_p_p_OSRSpatialReferenceShadow");
6644
 
            }
6645
 
        }
6646
 
    }
6647
 
    result = (OGRGeometryShadow *)CreateGeometryFromWkt(arg1,arg2);
6648
 
    
6649
 
    {
6650
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
6651
 
    }
6652
 
    /* Wrap this return value */
6653
 
    {
6654
 
        /* ALTERNATIVE Constructor, make an object wrapper */
6655
 
        zval *obj, *_cPtr;
6656
 
        MAKE_STD_ZVAL(obj);
6657
 
        MAKE_STD_ZVAL(_cPtr);
6658
 
        *_cPtr = *return_value;
6659
 
        INIT_ZVAL(*return_value);
6660
 
        object_init_ex(obj,ptr_ce_swig_Geometry);
6661
 
        add_property_zval(obj,"_cPtr",_cPtr);
6662
 
        *return_value=*obj;
6663
 
    }
6664
 
    return;
6665
 
    fail:
6666
 
    zend_error(ErrorCode(),ErrorMsg());
 
7428
  char **arg1 = (char **) 0 ;
 
7429
  OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) NULL ;
 
7430
  char *val1 ;
 
7431
  zval **args[2];
 
7432
  int arg_count;
 
7433
  OGRGeometryShadow *result = 0 ;
 
7434
  
 
7435
  SWIG_ResetError();
 
7436
  arg_count = ZEND_NUM_ARGS();
 
7437
  if(arg_count<1 || arg_count>2 ||
 
7438
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
7439
  WRONG_PARAM_COUNT;
 
7440
  
 
7441
  {
 
7442
    /* %typemap(in) (char **ignorechange) */
 
7443
    convert_to_string_ex( args[0] );
 
7444
    arg1 = NULL;
 
7445
  }
 
7446
  if(arg_count > 1) {
 
7447
    {
 
7448
      if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OSRSpatialReferenceShadow, 0) < 0) {
 
7449
        SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of CreateGeometryFromWkt. Expected SWIGTYPE_p_OSRSpatialReferenceShadow");
 
7450
      }
 
7451
    }
 
7452
  }
 
7453
  result = (OGRGeometryShadow *)CreateGeometryFromWkt(arg1,arg2);
 
7454
  
 
7455
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
7456
  
 
7457
  return;
 
7458
fail:
 
7459
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
6667
7460
}
6668
7461
 
6669
7462
 
6670
7463
ZEND_NAMED_FUNCTION(_wrap_CreateGeometryFromGML) {
6671
 
    char *arg1 = (char *) 0 ;
6672
 
    OGRGeometryShadow *result;
6673
 
    zval **args[1];
6674
 
    
6675
 
    SWIG_ResetError();
6676
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
6677
 
        WRONG_PARAM_COUNT;
6678
 
    }
6679
 
    
6680
 
    {
6681
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
6682
 
        convert_to_string_ex(args[0]);
6683
 
        arg1 = (char *) Z_STRVAL_PP(args[0]);
6684
 
        /*@@*/;
6685
 
    }
6686
 
    result = (OGRGeometryShadow *)CreateGeometryFromGML((char const *)arg1);
6687
 
    
6688
 
    {
6689
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
6690
 
    }
6691
 
    /* Wrap this return value */
6692
 
    {
6693
 
        /* ALTERNATIVE Constructor, make an object wrapper */
6694
 
        zval *obj, *_cPtr;
6695
 
        MAKE_STD_ZVAL(obj);
6696
 
        MAKE_STD_ZVAL(_cPtr);
6697
 
        *_cPtr = *return_value;
6698
 
        INIT_ZVAL(*return_value);
6699
 
        object_init_ex(obj,ptr_ce_swig_Geometry);
6700
 
        add_property_zval(obj,"_cPtr",_cPtr);
6701
 
        *return_value=*obj;
6702
 
    }
6703
 
    return;
6704
 
    fail:
6705
 
    zend_error(ErrorCode(),ErrorMsg());
 
7464
  char *arg1 = (char *) 0 ;
 
7465
  zval **args[1];
 
7466
  OGRGeometryShadow *result = 0 ;
 
7467
  
 
7468
  SWIG_ResetError();
 
7469
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
7470
    WRONG_PARAM_COUNT;
 
7471
  }
 
7472
  
 
7473
  
 
7474
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
7475
  if ((*args[0])->type==IS_NULL) {
 
7476
    arg1 = (char *) 0;
 
7477
  } else {
 
7478
    convert_to_string_ex(args[0]);
 
7479
    arg1 = (char *) Z_STRVAL_PP(args[0]);
 
7480
  }
 
7481
  /*@SWIG@*/;
 
7482
  
 
7483
  result = (OGRGeometryShadow *)CreateGeometryFromGML((char const *)arg1);
 
7484
  
 
7485
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
7486
  
 
7487
  return;
 
7488
fail:
 
7489
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
7490
}
 
7491
 
 
7492
 
 
7493
ZEND_NAMED_FUNCTION(_wrap_CreateGeometryFromJson) {
 
7494
  char *arg1 = (char *) 0 ;
 
7495
  zval **args[1];
 
7496
  OGRGeometryShadow *result = 0 ;
 
7497
  
 
7498
  SWIG_ResetError();
 
7499
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
7500
    WRONG_PARAM_COUNT;
 
7501
  }
 
7502
  
 
7503
  
 
7504
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
7505
  if ((*args[0])->type==IS_NULL) {
 
7506
    arg1 = (char *) 0;
 
7507
  } else {
 
7508
    convert_to_string_ex(args[0]);
 
7509
    arg1 = (char *) Z_STRVAL_PP(args[0]);
 
7510
  }
 
7511
  /*@SWIG@*/;
 
7512
  
 
7513
  result = (OGRGeometryShadow *)CreateGeometryFromJson((char const *)arg1);
 
7514
  
 
7515
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
7516
  
 
7517
  return;
 
7518
fail:
 
7519
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
7520
}
 
7521
 
 
7522
 
 
7523
ZEND_NAMED_FUNCTION(_wrap_BuildPolygonFromEdges) {
 
7524
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
7525
  int arg2 = (int) 0 ;
 
7526
  int arg3 = (int) 0 ;
 
7527
  double arg4 = (double) 0 ;
 
7528
  zval **args[4];
 
7529
  int arg_count;
 
7530
  OGRGeometryShadow *result = 0 ;
 
7531
  
 
7532
  SWIG_ResetError();
 
7533
  arg_count = ZEND_NUM_ARGS();
 
7534
  if(arg_count<1 || arg_count>4 ||
 
7535
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
7536
  WRONG_PARAM_COUNT;
 
7537
  
 
7538
  {
 
7539
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
7540
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of BuildPolygonFromEdges. Expected SWIGTYPE_p_OGRGeometryShadow");
 
7541
    }
 
7542
  }
 
7543
  if(arg_count > 1) {
 
7544
    /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
7545
    convert_to_long_ex(args[1]);
 
7546
    arg2 = (int) Z_LVAL_PP(args[1]);
 
7547
    /*@SWIG@*/;
 
7548
    
 
7549
  }
 
7550
  if(arg_count > 2) {
 
7551
    /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
7552
    convert_to_long_ex(args[2]);
 
7553
    arg3 = (int) Z_LVAL_PP(args[2]);
 
7554
    /*@SWIG@*/;
 
7555
    
 
7556
  }
 
7557
  if(arg_count > 3) {
 
7558
    /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
7559
    convert_to_double_ex(args[3]);
 
7560
    arg4 = (double) Z_DVAL_PP(args[3]);
 
7561
    /*@SWIG@*/;
 
7562
    
 
7563
  }
 
7564
  result = (OGRGeometryShadow *)BuildPolygonFromEdges(arg1,arg2,arg3,arg4);
 
7565
  
 
7566
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
7567
  
 
7568
  return;
 
7569
fail:
 
7570
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
7571
}
 
7572
 
 
7573
 
 
7574
ZEND_NAMED_FUNCTION(_wrap_ApproximateArcAngles) {
 
7575
  double arg1 ;
 
7576
  double arg2 ;
 
7577
  double arg3 ;
 
7578
  double arg4 ;
 
7579
  double arg5 ;
 
7580
  double arg6 ;
 
7581
  double arg7 ;
 
7582
  double arg8 ;
 
7583
  double arg9 ;
 
7584
  zval **args[9];
 
7585
  OGRGeometryShadow *result = 0 ;
 
7586
  
 
7587
  SWIG_ResetError();
 
7588
  if(ZEND_NUM_ARGS() != 9 || zend_get_parameters_array_ex(9, args) != SUCCESS) {
 
7589
    WRONG_PARAM_COUNT;
 
7590
  }
 
7591
  
 
7592
  
 
7593
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
7594
  convert_to_double_ex(args[0]);
 
7595
  arg1 = (double) Z_DVAL_PP(args[0]);
 
7596
  /*@SWIG@*/;
 
7597
  
 
7598
  
 
7599
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
7600
  convert_to_double_ex(args[1]);
 
7601
  arg2 = (double) Z_DVAL_PP(args[1]);
 
7602
  /*@SWIG@*/;
 
7603
  
 
7604
  
 
7605
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
7606
  convert_to_double_ex(args[2]);
 
7607
  arg3 = (double) Z_DVAL_PP(args[2]);
 
7608
  /*@SWIG@*/;
 
7609
  
 
7610
  
 
7611
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
7612
  convert_to_double_ex(args[3]);
 
7613
  arg4 = (double) Z_DVAL_PP(args[3]);
 
7614
  /*@SWIG@*/;
 
7615
  
 
7616
  
 
7617
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
7618
  convert_to_double_ex(args[4]);
 
7619
  arg5 = (double) Z_DVAL_PP(args[4]);
 
7620
  /*@SWIG@*/;
 
7621
  
 
7622
  
 
7623
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
7624
  convert_to_double_ex(args[5]);
 
7625
  arg6 = (double) Z_DVAL_PP(args[5]);
 
7626
  /*@SWIG@*/;
 
7627
  
 
7628
  
 
7629
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
7630
  convert_to_double_ex(args[6]);
 
7631
  arg7 = (double) Z_DVAL_PP(args[6]);
 
7632
  /*@SWIG@*/;
 
7633
  
 
7634
  
 
7635
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
7636
  convert_to_double_ex(args[7]);
 
7637
  arg8 = (double) Z_DVAL_PP(args[7]);
 
7638
  /*@SWIG@*/;
 
7639
  
 
7640
  
 
7641
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
7642
  convert_to_double_ex(args[8]);
 
7643
  arg9 = (double) Z_DVAL_PP(args[8]);
 
7644
  /*@SWIG@*/;
 
7645
  
 
7646
  result = (OGRGeometryShadow *)ApproximateArcAngles(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
 
7647
  
 
7648
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
7649
  
 
7650
  return;
 
7651
fail:
 
7652
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
7653
}
 
7654
 
 
7655
 
 
7656
ZEND_NAMED_FUNCTION(_wrap_ForceToPolygon) {
 
7657
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
7658
  zval **args[1];
 
7659
  OGRGeometryShadow *result = 0 ;
 
7660
  
 
7661
  SWIG_ResetError();
 
7662
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
7663
    WRONG_PARAM_COUNT;
 
7664
  }
 
7665
  
 
7666
  {
 
7667
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
7668
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of ForceToPolygon. Expected SWIGTYPE_p_OGRGeometryShadow");
 
7669
    }
 
7670
  }
 
7671
  result = (OGRGeometryShadow *)ForceToPolygon(arg1);
 
7672
  
 
7673
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
7674
  
 
7675
  return;
 
7676
fail:
 
7677
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
7678
}
 
7679
 
 
7680
 
 
7681
ZEND_NAMED_FUNCTION(_wrap_ForceToMultiPolygon) {
 
7682
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
7683
  zval **args[1];
 
7684
  OGRGeometryShadow *result = 0 ;
 
7685
  
 
7686
  SWIG_ResetError();
 
7687
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
7688
    WRONG_PARAM_COUNT;
 
7689
  }
 
7690
  
 
7691
  {
 
7692
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
7693
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of ForceToMultiPolygon. Expected SWIGTYPE_p_OGRGeometryShadow");
 
7694
    }
 
7695
  }
 
7696
  result = (OGRGeometryShadow *)ForceToMultiPolygon(arg1);
 
7697
  
 
7698
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
7699
  
 
7700
  return;
 
7701
fail:
 
7702
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
7703
}
 
7704
 
 
7705
 
 
7706
ZEND_NAMED_FUNCTION(_wrap_ForceToMultiPoint) {
 
7707
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
7708
  zval **args[1];
 
7709
  OGRGeometryShadow *result = 0 ;
 
7710
  
 
7711
  SWIG_ResetError();
 
7712
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
7713
    WRONG_PARAM_COUNT;
 
7714
  }
 
7715
  
 
7716
  {
 
7717
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
7718
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of ForceToMultiPoint. Expected SWIGTYPE_p_OGRGeometryShadow");
 
7719
    }
 
7720
  }
 
7721
  result = (OGRGeometryShadow *)ForceToMultiPoint(arg1);
 
7722
  
 
7723
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
7724
  
 
7725
  return;
 
7726
fail:
 
7727
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
7728
}
 
7729
 
 
7730
 
 
7731
ZEND_NAMED_FUNCTION(_wrap_ForceToMultiLineString) {
 
7732
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
7733
  zval **args[1];
 
7734
  OGRGeometryShadow *result = 0 ;
 
7735
  
 
7736
  SWIG_ResetError();
 
7737
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
7738
    WRONG_PARAM_COUNT;
 
7739
  }
 
7740
  
 
7741
  {
 
7742
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
7743
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of ForceToMultiLineString. Expected SWIGTYPE_p_OGRGeometryShadow");
 
7744
    }
 
7745
  }
 
7746
  result = (OGRGeometryShadow *)ForceToMultiLineString(arg1);
 
7747
  
 
7748
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
7749
  
 
7750
  return;
 
7751
fail:
 
7752
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
6706
7753
}
6707
7754
 
6708
7755
 
6709
7756
/* This function is designed to be called by the zend list destructors */
6710
7757
/* to typecast and do the actual destruction */
6711
 
void __wrap_delete_Geometry(zend_rsrc_list_entry *rsrc, const char *type_name TSRMLS_DC) {
6712
 
    swig_object_wrapper *value=(swig_object_wrapper *) rsrc->ptr ;
6713
 
    void *ptr=value->ptr ;
6714
 
    int newobject=value->newobject ;
6715
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
6716
 
    
6717
 
    efree(value);
6718
 
    if (! newobject) return; /* can't delete it! */
6719
 
    SWIG_ZTS_ConvertResourceData(ptr,rsrc->type,type_name,(void **) &arg1,SWIGTYPE_p_OGRGeometryShadow TSRMLS_CC);
6720
 
    if (! arg1) zend_error(E_ERROR, "OGRGeometryShadow resource already free'd");
6721
 
    delete_OGRGeometryShadow(arg1);
6722
 
    
 
7758
static void __wrap_delete_Geometry(zend_rsrc_list_entry *rsrc, const char *type_name TSRMLS_DC) {
 
7759
  swig_object_wrapper *value=(swig_object_wrapper *) rsrc->ptr ;
 
7760
  void *ptr=value->ptr ;
 
7761
  int newobject=value->newobject ;
 
7762
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
7763
  
 
7764
  efree(value);
 
7765
  if (! newobject) return; /* can't delete it! */
 
7766
  arg1 = (OGRGeometryShadow *)SWIG_ZTS_ConvertResourceData(ptr,type_name,SWIGTYPE_p_OGRGeometryShadow TSRMLS_CC);
 
7767
  if (! arg1) zend_error(E_ERROR, "OGRGeometryShadow resource already free'd");
 
7768
  delete_OGRGeometryShadow(arg1);
 
7769
  return;
 
7770
fail:
 
7771
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
6723
7772
}
6724
7773
 
6725
7774
 
6726
7775
ZEND_NAMED_FUNCTION(_wrap_new_Geometry) {
6727
 
    OGRwkbGeometryType arg1 = (OGRwkbGeometryType) wkbUnknown ;
6728
 
    char *arg2 = (char *) 0 ;
6729
 
    int arg3 = (int) 0 ;
6730
 
    char *arg4 = (char *) 0 ;
6731
 
    char *arg5 = (char *) 0 ;
6732
 
    OGRGeometryShadow *result;
6733
 
    zval **args[5];
6734
 
    int arg_count;
6735
 
    
6736
 
    SWIG_ResetError();
6737
 
    /* NATIVE Constructor */
6738
 
    arg_count = ZEND_NUM_ARGS();
6739
 
    if(arg_count<0 || arg_count>5)
6740
 
    WRONG_PARAM_COUNT;
6741
 
    
6742
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
6743
 
    WRONG_PARAM_COUNT;
6744
 
    
6745
 
    if(arg_count > 0) {
6746
 
        {
6747
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
6748
 
            convert_to_long_ex(args[0]);
6749
 
            arg1 = (OGRwkbGeometryType) Z_LVAL_PP(args[0]);
6750
 
            /*@@*/;
6751
 
        }
6752
 
    }
6753
 
    if(arg_count > 1) {
6754
 
        {
6755
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
6756
 
            convert_to_string_ex(args[1]);
6757
 
            arg2 = (char *) Z_STRVAL_PP(args[1]);
6758
 
            /*@@*/;
6759
 
        }
6760
 
    }
6761
 
    if(arg_count > 2) {
6762
 
        {
6763
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
6764
 
            convert_to_long_ex(args[2]);
6765
 
            arg3 = (int) Z_LVAL_PP(args[2]);
6766
 
            /*@@*/;
6767
 
        }
6768
 
    }
6769
 
    if(arg_count > 3) {
6770
 
        {
6771
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
6772
 
            convert_to_string_ex(args[3]);
6773
 
            arg4 = (char *) Z_STRVAL_PP(args[3]);
6774
 
            /*@@*/;
6775
 
        }
6776
 
    }
6777
 
    if(arg_count > 4) {
6778
 
        {
6779
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
6780
 
            convert_to_string_ex(args[4]);
6781
 
            arg5 = (char *) Z_STRVAL_PP(args[4]);
6782
 
            /*@@*/;
6783
 
        }
6784
 
    }
6785
 
    result = (OGRGeometryShadow *)new_OGRGeometryShadow(arg1,arg2,arg3,arg4,arg5);
6786
 
    
 
7776
  OGRwkbGeometryType arg1 = (OGRwkbGeometryType) wkbUnknown ;
 
7777
  char *arg2 = (char *) 0 ;
 
7778
  int arg3 = (int) 0 ;
 
7779
  char *arg4 = (char *) 0 ;
 
7780
  char *arg5 = (char *) 0 ;
 
7781
  zval **args[4];
 
7782
  int arg_count;
 
7783
  OGRGeometryShadow *result = 0 ;
 
7784
  
 
7785
  SWIG_ResetError();
 
7786
  arg_count = ZEND_NUM_ARGS();
 
7787
  if(arg_count<0 || arg_count>4 ||
 
7788
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
7789
  WRONG_PARAM_COUNT;
 
7790
  
 
7791
  if(arg_count > 0) {
 
7792
    /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
7793
    convert_to_long_ex(args[0]);
 
7794
    arg1 = (OGRwkbGeometryType) Z_LVAL_PP(args[0]);
 
7795
    /*@SWIG@*/;
 
7796
    
 
7797
  }
 
7798
  if(arg_count > 1) {
 
7799
    /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
7800
    if ((*args[1])->type==IS_NULL) {
 
7801
      arg2 = (char *) 0;
 
7802
    } else {
 
7803
      convert_to_string_ex(args[1]);
 
7804
      arg2 = (char *) Z_STRVAL_PP(args[1]);
 
7805
    }
 
7806
    /*@SWIG@*/;
 
7807
    
 
7808
  }
 
7809
  if(arg_count > 2) {
6787
7810
    {
6788
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
6789
 
    }
6790
 
    /* Wrap this return value */
6791
 
    if (this_ptr) {
6792
 
        /* NATIVE Constructor, use this_ptr */
6793
 
        zval *_cPtr; MAKE_STD_ZVAL(_cPtr);
6794
 
        *_cPtr = *return_value;
6795
 
        INIT_ZVAL(*return_value);
6796
 
        add_property_zval(this_ptr,"_cPtr",_cPtr);
6797
 
    } else if (! this_ptr) {
6798
 
        /* ALTERNATIVE Constructor, make an object wrapper */
6799
 
        zval *obj, *_cPtr;
6800
 
        MAKE_STD_ZVAL(obj);
6801
 
        MAKE_STD_ZVAL(_cPtr);
6802
 
        *_cPtr = *return_value;
6803
 
        INIT_ZVAL(*return_value);
6804
 
        object_init_ex(obj,ptr_ce_swig_Geometry);
6805
 
        add_property_zval(obj,"_cPtr",_cPtr);
6806
 
        *return_value=*obj;
6807
 
    }
6808
 
    return;
6809
 
    fail:
6810
 
    zend_error(ErrorCode(),ErrorMsg());
 
7811
      /* %typemap(in,numinputs=1) (int nLen, char *pBuf ) */
 
7812
      convert_to_string_ex(args[2]);
 
7813
      arg4 = Z_STRVAL_PP(args[2]);
 
7814
      arg3 = Z_STRLEN_PP(args[2]);
 
7815
    }
 
7816
  }
 
7817
  if(arg_count > 3) {
 
7818
    /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
7819
    if ((*args[3])->type==IS_NULL) {
 
7820
      arg5 = (char *) 0;
 
7821
    } else {
 
7822
      convert_to_string_ex(args[3]);
 
7823
      arg5 = (char *) Z_STRVAL_PP(args[3]);
 
7824
    }
 
7825
    /*@SWIG@*/;
 
7826
    
 
7827
  }
 
7828
  result = (OGRGeometryShadow *)new_OGRGeometryShadow(arg1,arg2,arg3,arg4,arg5);
 
7829
  
 
7830
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
7831
  
 
7832
  return;
 
7833
fail:
 
7834
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
6811
7835
}
6812
7836
 
6813
7837
 
6814
7838
ZEND_NAMED_FUNCTION(_wrap_Geometry_ExportToWkt) {
6815
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
6816
 
    char *result;
6817
 
    zval **args[0];
6818
 
    
6819
 
    SWIG_ResetError();
6820
 
    /* This function uses a this_ptr*/
6821
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
6822
 
        WRONG_PARAM_COUNT;
6823
 
    }
6824
 
    
6825
 
    {
6826
 
        /* typemap(in) SWIGTYPE * */
6827
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
6828
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_ExportToWkt. Expected SWIGTYPE_p_p_OGRGeometryShadow");
6829
 
        }
6830
 
    }
6831
 
    result = (char *)OGRGeometryShadow_ExportToWkt(arg1);
6832
 
    
6833
 
    {
6834
 
        if(!result) {
6835
 
            ZVAL_NULL(return_value);
6836
 
        } else {
6837
 
            ZVAL_STRING(return_value,result, 1);
6838
 
        }
6839
 
    }
6840
 
    return;
6841
 
    fail:
6842
 
    zend_error(ErrorCode(),ErrorMsg());
 
7839
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
7840
  char **arg2 = (char **) 0 ;
 
7841
  char *argout2 = 0 ;
 
7842
  zval **args[1];
 
7843
  OGRErr result;
 
7844
  
 
7845
  {
 
7846
    /* %typemap(in,numinputs=0) (char **argout2) */
 
7847
    arg2 = &argout2;
 
7848
  }
 
7849
  SWIG_ResetError();
 
7850
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
7851
    WRONG_PARAM_COUNT;
 
7852
  }
 
7853
  
 
7854
  {
 
7855
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
7856
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_ExportToWkt. Expected SWIGTYPE_p_OGRGeometryShadow");
 
7857
    }
 
7858
  }
 
7859
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
7860
  result = (OGRErr)OGRGeometryShadow_ExportToWkt(arg1,arg2);
 
7861
  {
 
7862
    /* %typemap(out) OGRErr */
 
7863
    if (result != 0 ) {
 
7864
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
7865
    }
 
7866
  }
 
7867
  {
 
7868
    /* %typemap(argout) (char **argout) */
 
7869
    zval *t;
 
7870
    MAKE_STD_ZVAL(t);
 
7871
    if ( arg2 ) {
 
7872
      ZVAL_STRING(t,*arg2,strlen(*arg2));
 
7873
    }
 
7874
    else {
 
7875
      ZVAL_NULL(t);
 
7876
    }
 
7877
    t_output_helper(&return_value, t);
 
7878
  }
 
7879
  {
 
7880
    /* %typemap(freearg) (char **argout) */
 
7881
    if ( *arg2 )
 
7882
    CPLFree( *arg2 );
 
7883
  }
 
7884
  {
 
7885
    /* %typemap(ret) OGRErr */
 
7886
    RETVAL_LONG(0);
 
7887
  }
 
7888
  return;
 
7889
fail:
 
7890
  {
 
7891
    /* %typemap(freearg) (char **argout) */
 
7892
    if ( *arg2 )
 
7893
    CPLFree( *arg2 );
 
7894
  }
 
7895
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
6843
7896
}
6844
7897
 
6845
7898
 
6846
7899
ZEND_NAMED_FUNCTION(_wrap_Geometry_ExportToWkb) {
6847
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
6848
 
    int *arg2 = (int *) 0 ;
6849
 
    char **arg3 = (char **) 0 ;
6850
 
    OGRwkbByteOrder arg4 = (OGRwkbByteOrder) wkbXDR ;
6851
 
    OGRErr result;
6852
 
    int nLen2 = 0 ;
6853
 
    char *pBuf2 = 0 ;
6854
 
    zval **args[1];
6855
 
    int arg_count;
6856
 
    
6857
 
    {
6858
 
        /* %typemap(in,numinputs=0) (int *nLen2, char **pBuf2 ) */
6859
 
        arg2 = &nLen2;
6860
 
        arg3 = &pBuf2;
6861
 
    }
6862
 
    SWIG_ResetError();
6863
 
    /* This function uses a this_ptr*/
6864
 
    arg_count = ZEND_NUM_ARGS();
6865
 
    if(arg_count<1 || arg_count>2)
6866
 
    WRONG_PARAM_COUNT;
6867
 
    
6868
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
6869
 
    WRONG_PARAM_COUNT;
6870
 
    
6871
 
    {
6872
 
        /* typemap(in) SWIGTYPE * */
6873
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
6874
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_ExportToWkb. Expected SWIGTYPE_p_p_OGRGeometryShadow");
6875
 
        }
6876
 
    }
6877
 
    if(arg_count > 1) {
6878
 
        {
6879
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
6880
 
            convert_to_long_ex(args[0]);
6881
 
            arg4 = (OGRwkbByteOrder) Z_LVAL_PP(args[0]);
6882
 
            /*@@*/;
6883
 
        }
6884
 
    }
6885
 
    result = (OGRErr)OGRGeometryShadow_ExportToWkb(arg1,arg2,arg3,arg4);
6886
 
    
6887
 
    {
6888
 
        /* %typemap(out) OGRErr */
6889
 
        if (result != 0 ) {
6890
 
            SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
6891
 
        }
6892
 
    }
6893
 
    {
6894
 
        /* %typemap(argout) (int *nLen, char **pBuf ) */
6895
 
        ZVAL_STRINGL( return_value, *arg3, *arg2, 1 );
6896
 
    }
6897
 
    {
6898
 
        /* %typemap(freearg) (int *nLen, char **pBuf ) */
6899
 
        if( *arg2 ) {
6900
 
            free( *arg3 );
6901
 
        }
6902
 
    }
6903
 
    {
6904
 
        /* %typemap(ret) OGRErr */
6905
 
        RETVAL_LONG(0);
6906
 
    }
6907
 
    return;
6908
 
    fail:
6909
 
    {
6910
 
        /* %typemap(freearg) (int *nLen, char **pBuf ) */
6911
 
        if( *arg2 ) {
6912
 
            free( *arg3 );
6913
 
        }
6914
 
    }
6915
 
    zend_error(ErrorCode(),ErrorMsg());
 
7900
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
7901
  int *arg2 = (int *) 0 ;
 
7902
  char **arg3 = (char **) 0 ;
 
7903
  OGRwkbByteOrder arg4 = (OGRwkbByteOrder) wkbXDR ;
 
7904
  int nLen2 = 0 ;
 
7905
  char *pBuf2 = 0 ;
 
7906
  zval **args[2];
 
7907
  int arg_count;
 
7908
  OGRErr result;
 
7909
  
 
7910
  {
 
7911
    /* %typemap(in,numinputs=0) (int *nLen2, char **pBuf2 ) */
 
7912
    arg2 = &nLen2;
 
7913
    arg3 = &pBuf2;
 
7914
  }
 
7915
  SWIG_ResetError();
 
7916
  arg_count = ZEND_NUM_ARGS();
 
7917
  if(arg_count<1 || arg_count>2 ||
 
7918
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
7919
  WRONG_PARAM_COUNT;
 
7920
  
 
7921
  {
 
7922
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
7923
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_ExportToWkb. Expected SWIGTYPE_p_OGRGeometryShadow");
 
7924
    }
 
7925
  }
 
7926
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
7927
  if(arg_count > 1) {
 
7928
    /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
7929
    convert_to_long_ex(args[1]);
 
7930
    arg4 = (OGRwkbByteOrder) Z_LVAL_PP(args[1]);
 
7931
    /*@SWIG@*/;
 
7932
    
 
7933
  }
 
7934
  result = (OGRErr)OGRGeometryShadow_ExportToWkb(arg1,arg2,arg3,arg4);
 
7935
  {
 
7936
    /* %typemap(out) OGRErr */
 
7937
    if (result != 0 ) {
 
7938
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
7939
    }
 
7940
  }
 
7941
  {
 
7942
    /* %typemap(argout) (int *nLen, char **pBuf ) */
 
7943
    ZVAL_STRINGL( return_value, *arg3, *arg2, 1 );
 
7944
  }
 
7945
  {
 
7946
    /* %typemap(freearg) (int *nLen, char **pBuf ) */
 
7947
    if( *arg2 ) {
 
7948
      free( *arg3 );
 
7949
    }
 
7950
  }
 
7951
  {
 
7952
    /* %typemap(ret) OGRErr */
 
7953
    RETVAL_LONG(0);
 
7954
  }
 
7955
  return;
 
7956
fail:
 
7957
  {
 
7958
    /* %typemap(freearg) (int *nLen, char **pBuf ) */
 
7959
    if( *arg2 ) {
 
7960
      free( *arg3 );
 
7961
    }
 
7962
  }
 
7963
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
6916
7964
}
6917
7965
 
6918
7966
 
6919
7967
ZEND_NAMED_FUNCTION(_wrap_Geometry_ExportToGML) {
6920
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
6921
 
    char *result;
6922
 
    zval **args[0];
6923
 
    
6924
 
    SWIG_ResetError();
6925
 
    /* This function uses a this_ptr*/
6926
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
6927
 
        WRONG_PARAM_COUNT;
6928
 
    }
6929
 
    
6930
 
    {
6931
 
        /* typemap(in) SWIGTYPE * */
6932
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
6933
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_ExportToGML. Expected SWIGTYPE_p_p_OGRGeometryShadow");
6934
 
        }
6935
 
    }
6936
 
    result = (char *)OGRGeometryShadow_ExportToGML(arg1);
6937
 
    
6938
 
    {
6939
 
        if(!result) {
6940
 
            ZVAL_NULL(return_value);
6941
 
        } else {
6942
 
            ZVAL_STRING(return_value,result, 1);
6943
 
        }
6944
 
    }
6945
 
    return;
6946
 
    fail:
6947
 
    zend_error(ErrorCode(),ErrorMsg());
 
7968
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
7969
  zval **args[1];
 
7970
  char *result = 0 ;
 
7971
  
 
7972
  SWIG_ResetError();
 
7973
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
7974
    WRONG_PARAM_COUNT;
 
7975
  }
 
7976
  
 
7977
  {
 
7978
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
7979
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_ExportToGML. Expected SWIGTYPE_p_OGRGeometryShadow");
 
7980
    }
 
7981
  }
 
7982
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
7983
  result = (char *)OGRGeometryShadow_ExportToGML(arg1);
 
7984
  {
 
7985
    if(!result) {
 
7986
      ZVAL_NULL(return_value);
 
7987
    } else {
 
7988
      ZVAL_STRING(return_value, (char *)result, 1);
 
7989
    }
 
7990
  }
 
7991
  return;
 
7992
fail:
 
7993
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
7994
}
 
7995
 
 
7996
 
 
7997
ZEND_NAMED_FUNCTION(_wrap_Geometry_ExportToKML) {
 
7998
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
7999
  char *arg2 = (char *) NULL ;
 
8000
  zval **args[2];
 
8001
  int arg_count;
 
8002
  char *result = 0 ;
 
8003
  
 
8004
  SWIG_ResetError();
 
8005
  arg_count = ZEND_NUM_ARGS();
 
8006
  if(arg_count<1 || arg_count>2 ||
 
8007
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
8008
  WRONG_PARAM_COUNT;
 
8009
  
 
8010
  {
 
8011
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8012
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_ExportToKML. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8013
    }
 
8014
  }
 
8015
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8016
  if(arg_count > 1) {
 
8017
    /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
8018
    if ((*args[1])->type==IS_NULL) {
 
8019
      arg2 = (char *) 0;
 
8020
    } else {
 
8021
      convert_to_string_ex(args[1]);
 
8022
      arg2 = (char *) Z_STRVAL_PP(args[1]);
 
8023
    }
 
8024
    /*@SWIG@*/;
 
8025
    
 
8026
  }
 
8027
  result = (char *)OGRGeometryShadow_ExportToKML(arg1,(char const *)arg2);
 
8028
  {
 
8029
    if(!result) {
 
8030
      ZVAL_NULL(return_value);
 
8031
    } else {
 
8032
      ZVAL_STRING(return_value, (char *)result, 1);
 
8033
    }
 
8034
  }
 
8035
  return;
 
8036
fail:
 
8037
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
8038
}
 
8039
 
 
8040
 
 
8041
ZEND_NAMED_FUNCTION(_wrap_Geometry_ExportToJson) {
 
8042
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8043
  zval **args[1];
 
8044
  char *result = 0 ;
 
8045
  
 
8046
  SWIG_ResetError();
 
8047
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
8048
    WRONG_PARAM_COUNT;
 
8049
  }
 
8050
  
 
8051
  {
 
8052
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8053
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_ExportToJson. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8054
    }
 
8055
  }
 
8056
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8057
  result = (char *)OGRGeometryShadow_ExportToJson(arg1);
 
8058
  {
 
8059
    if(!result) {
 
8060
      ZVAL_NULL(return_value);
 
8061
    } else {
 
8062
      ZVAL_STRING(return_value, (char *)result, 1);
 
8063
    }
 
8064
  }
 
8065
  return;
 
8066
fail:
 
8067
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
6948
8068
}
6949
8069
 
6950
8070
 
6951
8071
ZEND_NAMED_FUNCTION(_wrap_Geometry_AddPoint) {
6952
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
6953
 
    double arg2 ;
6954
 
    double arg3 ;
6955
 
    double arg4 = (double) 0 ;
6956
 
    zval **args[3];
6957
 
    int arg_count;
6958
 
    
6959
 
    SWIG_ResetError();
6960
 
    /* This function uses a this_ptr*/
6961
 
    arg_count = ZEND_NUM_ARGS();
6962
 
    if(arg_count<3 || arg_count>4)
6963
 
    WRONG_PARAM_COUNT;
6964
 
    
6965
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
6966
 
    WRONG_PARAM_COUNT;
6967
 
    
6968
 
    {
6969
 
        /* typemap(in) SWIGTYPE * */
6970
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
6971
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_AddPoint. Expected SWIGTYPE_p_p_OGRGeometryShadow");
6972
 
        }
6973
 
    }
6974
 
    {
6975
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,13,CONVERT_FLOAT_IN@*/
6976
 
        convert_to_double_ex(args[0]);
6977
 
        arg2 = (double) Z_DVAL_PP(args[0]);
6978
 
        /*@@*/;
6979
 
    }
6980
 
    {
6981
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,13,CONVERT_FLOAT_IN@*/
6982
 
        convert_to_double_ex(args[1]);
6983
 
        arg3 = (double) Z_DVAL_PP(args[1]);
6984
 
        /*@@*/;
6985
 
    }
6986
 
    if(arg_count > 3) {
6987
 
        {
6988
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,13,CONVERT_FLOAT_IN@*/
6989
 
            convert_to_double_ex(args[2]);
6990
 
            arg4 = (double) Z_DVAL_PP(args[2]);
6991
 
            /*@@*/;
6992
 
        }
6993
 
    }
6994
 
    OGRGeometryShadow_AddPoint(arg1,arg2,arg3,arg4);
6995
 
    
6996
 
    
6997
 
    return;
6998
 
    fail:
6999
 
    zend_error(ErrorCode(),ErrorMsg());
 
8072
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8073
  double arg2 ;
 
8074
  double arg3 ;
 
8075
  double arg4 = (double) 0 ;
 
8076
  zval **args[4];
 
8077
  int arg_count;
 
8078
  
 
8079
  SWIG_ResetError();
 
8080
  arg_count = ZEND_NUM_ARGS();
 
8081
  if(arg_count<3 || arg_count>4 ||
 
8082
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
8083
  WRONG_PARAM_COUNT;
 
8084
  
 
8085
  {
 
8086
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8087
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_AddPoint. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8088
    }
 
8089
  }
 
8090
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8091
  
 
8092
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
8093
  convert_to_double_ex(args[1]);
 
8094
  arg2 = (double) Z_DVAL_PP(args[1]);
 
8095
  /*@SWIG@*/;
 
8096
  
 
8097
  
 
8098
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
8099
  convert_to_double_ex(args[2]);
 
8100
  arg3 = (double) Z_DVAL_PP(args[2]);
 
8101
  /*@SWIG@*/;
 
8102
  
 
8103
  if(arg_count > 3) {
 
8104
    /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
8105
    convert_to_double_ex(args[3]);
 
8106
    arg4 = (double) Z_DVAL_PP(args[3]);
 
8107
    /*@SWIG@*/;
 
8108
    
 
8109
  }
 
8110
  OGRGeometryShadow_AddPoint(arg1,arg2,arg3,arg4);
 
8111
  
 
8112
  return;
 
8113
fail:
 
8114
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
8115
}
 
8116
 
 
8117
 
 
8118
ZEND_NAMED_FUNCTION(_wrap_Geometry_AddPoint_2D) {
 
8119
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8120
  double arg2 ;
 
8121
  double arg3 ;
 
8122
  zval **args[3];
 
8123
  
 
8124
  SWIG_ResetError();
 
8125
  if(ZEND_NUM_ARGS() != 3 || zend_get_parameters_array_ex(3, args) != SUCCESS) {
 
8126
    WRONG_PARAM_COUNT;
 
8127
  }
 
8128
  
 
8129
  {
 
8130
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8131
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_AddPoint_2D. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8132
    }
 
8133
  }
 
8134
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8135
  
 
8136
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
8137
  convert_to_double_ex(args[1]);
 
8138
  arg2 = (double) Z_DVAL_PP(args[1]);
 
8139
  /*@SWIG@*/;
 
8140
  
 
8141
  
 
8142
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
8143
  convert_to_double_ex(args[2]);
 
8144
  arg3 = (double) Z_DVAL_PP(args[2]);
 
8145
  /*@SWIG@*/;
 
8146
  
 
8147
  OGRGeometryShadow_AddPoint_2D(arg1,arg2,arg3);
 
8148
  
 
8149
  return;
 
8150
fail:
 
8151
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7000
8152
}
7001
8153
 
7002
8154
 
7003
8155
ZEND_NAMED_FUNCTION(_wrap_Geometry_AddGeometryDirectly) {
7004
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7005
 
    OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
7006
 
    OGRErr result;
7007
 
    zval **args[1];
7008
 
    
7009
 
    SWIG_ResetError();
7010
 
    /* This function uses a this_ptr*/
7011
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
7012
 
        WRONG_PARAM_COUNT;
7013
 
    }
7014
 
    
7015
 
    {
7016
 
        /* typemap(in) SWIGTYPE * */
7017
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7018
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_AddGeometryDirectly. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7019
 
        }
7020
 
    }
7021
 
    {
7022
 
        /* typemap(in) SWIGTYPE *DISOWN */
7023
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_DISOWN ) < 0) {
7024
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_AddGeometryDirectly. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7025
 
        }
7026
 
    }
7027
 
    result = (OGRErr)OGRGeometryShadow_AddGeometryDirectly(arg1,arg2);
7028
 
    
7029
 
    {
7030
 
        /* %typemap(out) OGRErr */
7031
 
        if (result != 0 ) {
7032
 
            SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
7033
 
        }
7034
 
    }
7035
 
    {
7036
 
        /* %typemap(ret) OGRErr */
7037
 
        RETVAL_LONG(0);
7038
 
    }
7039
 
    return;
7040
 
    fail:
7041
 
    zend_error(ErrorCode(),ErrorMsg());
 
8156
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8157
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
 
8158
  zval **args[2];
 
8159
  OGRErr result;
 
8160
  
 
8161
  SWIG_ResetError();
 
8162
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
8163
    WRONG_PARAM_COUNT;
 
8164
  }
 
8165
  
 
8166
  {
 
8167
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8168
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_AddGeometryDirectly. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8169
    }
 
8170
  }
 
8171
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8172
  {
 
8173
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, SWIG_POINTER_DISOWN ) < 0) {
 
8174
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_AddGeometryDirectly. Expected SWIGTYPE_p_p_OGRGeometryShadow");
 
8175
    }
 
8176
  }
 
8177
  {
 
8178
    if (!arg2) {
 
8179
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
8180
    }
 
8181
  }
 
8182
  result = (OGRErr)OGRGeometryShadow_AddGeometryDirectly(arg1,arg2);
 
8183
  {
 
8184
    /* %typemap(out) OGRErr */
 
8185
    if (result != 0 ) {
 
8186
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
8187
    }
 
8188
  }
 
8189
  {
 
8190
    /* %typemap(ret) OGRErr */
 
8191
    RETVAL_LONG(0);
 
8192
  }
 
8193
  return;
 
8194
fail:
 
8195
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7042
8196
}
7043
8197
 
7044
8198
 
7045
8199
ZEND_NAMED_FUNCTION(_wrap_Geometry_AddGeometry) {
7046
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7047
 
    OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
7048
 
    OGRErr result;
7049
 
    zval **args[1];
7050
 
    
7051
 
    SWIG_ResetError();
7052
 
    /* This function uses a this_ptr*/
7053
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
7054
 
        WRONG_PARAM_COUNT;
7055
 
    }
7056
 
    
7057
 
    {
7058
 
        /* typemap(in) SWIGTYPE * */
7059
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7060
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_AddGeometry. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7061
 
        }
7062
 
    }
7063
 
    {
7064
 
        /* typemap(in) SWIGTYPE * */
7065
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7066
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_AddGeometry. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7067
 
        }
7068
 
    }
7069
 
    result = (OGRErr)OGRGeometryShadow_AddGeometry(arg1,arg2);
7070
 
    
7071
 
    {
7072
 
        /* %typemap(out) OGRErr */
7073
 
        if (result != 0 ) {
7074
 
            SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
7075
 
        }
7076
 
    }
7077
 
    {
7078
 
        /* %typemap(ret) OGRErr */
7079
 
        RETVAL_LONG(0);
7080
 
    }
7081
 
    return;
7082
 
    fail:
7083
 
    zend_error(ErrorCode(),ErrorMsg());
 
8200
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8201
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
 
8202
  zval **args[2];
 
8203
  OGRErr result;
 
8204
  
 
8205
  SWIG_ResetError();
 
8206
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
8207
    WRONG_PARAM_COUNT;
 
8208
  }
 
8209
  
 
8210
  {
 
8211
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8212
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_AddGeometry. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8213
    }
 
8214
  }
 
8215
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8216
  {
 
8217
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8218
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_AddGeometry. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8219
    }
 
8220
  }
 
8221
  {
 
8222
    if (!arg2) {
 
8223
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
8224
    }
 
8225
  }
 
8226
  result = (OGRErr)OGRGeometryShadow_AddGeometry(arg1,arg2);
 
8227
  {
 
8228
    /* %typemap(out) OGRErr */
 
8229
    if (result != 0 ) {
 
8230
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
8231
    }
 
8232
  }
 
8233
  {
 
8234
    /* %typemap(ret) OGRErr */
 
8235
    RETVAL_LONG(0);
 
8236
  }
 
8237
  return;
 
8238
fail:
 
8239
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7084
8240
}
7085
8241
 
7086
8242
 
7087
 
ZEND_NAMED_FUNCTION(_wrap_Geometry_Clone) {
7088
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7089
 
    OGRGeometryShadow *result;
7090
 
    zval **args[0];
7091
 
    
7092
 
    SWIG_ResetError();
7093
 
    /* This function uses a this_ptr*/
7094
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
7095
 
        WRONG_PARAM_COUNT;
7096
 
    }
7097
 
    
7098
 
    {
7099
 
        /* typemap(in) SWIGTYPE * */
7100
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7101
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Clone. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7102
 
        }
7103
 
    }
7104
 
    result = (OGRGeometryShadow *)OGRGeometryShadow_Clone(arg1);
7105
 
    
7106
 
    {
7107
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
7108
 
    }
7109
 
    /* Wrap this return value */
7110
 
    {
7111
 
        /* ALTERNATIVE Constructor, make an object wrapper */
7112
 
        zval *obj, *_cPtr;
7113
 
        MAKE_STD_ZVAL(obj);
7114
 
        MAKE_STD_ZVAL(_cPtr);
7115
 
        *_cPtr = *return_value;
7116
 
        INIT_ZVAL(*return_value);
7117
 
        object_init_ex(obj,ptr_ce_swig_Geometry);
7118
 
        add_property_zval(obj,"_cPtr",_cPtr);
7119
 
        *return_value=*obj;
7120
 
    }
7121
 
    return;
7122
 
    fail:
7123
 
    zend_error(ErrorCode(),ErrorMsg());
 
8243
ZEND_NAMED_FUNCTION(_wrap_Geometry_c_Clone) {
 
8244
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8245
  zval **args[1];
 
8246
  OGRGeometryShadow *result = 0 ;
 
8247
  
 
8248
  SWIG_ResetError();
 
8249
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
8250
    WRONG_PARAM_COUNT;
 
8251
  }
 
8252
  
 
8253
  {
 
8254
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8255
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_c_Clone. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8256
    }
 
8257
  }
 
8258
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8259
  result = (OGRGeometryShadow *)OGRGeometryShadow_Clone(arg1);
 
8260
  
 
8261
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
8262
  
 
8263
  return;
 
8264
fail:
 
8265
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7124
8266
}
7125
8267
 
7126
8268
 
7127
8269
ZEND_NAMED_FUNCTION(_wrap_Geometry_GetGeometryType) {
7128
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7129
 
    OGRwkbGeometryType result;
7130
 
    zval **args[0];
7131
 
    
7132
 
    SWIG_ResetError();
7133
 
    /* This function uses a this_ptr*/
7134
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
7135
 
        WRONG_PARAM_COUNT;
7136
 
    }
7137
 
    
7138
 
    {
7139
 
        /* typemap(in) SWIGTYPE * */
7140
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7141
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetGeometryType. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7142
 
        }
7143
 
    }
7144
 
    result = (OGRwkbGeometryType)OGRGeometryShadow_GetGeometryType(arg1);
7145
 
    
7146
 
    {
7147
 
        ZVAL_LONG(return_value,result);
7148
 
    }
7149
 
    return;
7150
 
    fail:
7151
 
    zend_error(ErrorCode(),ErrorMsg());
 
8270
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8271
  zval **args[1];
 
8272
  OGRwkbGeometryType result;
 
8273
  
 
8274
  SWIG_ResetError();
 
8275
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
8276
    WRONG_PARAM_COUNT;
 
8277
  }
 
8278
  
 
8279
  {
 
8280
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8281
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetGeometryType. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8282
    }
 
8283
  }
 
8284
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8285
  result = (OGRwkbGeometryType)OGRGeometryShadow_GetGeometryType(arg1);
 
8286
  {
 
8287
    ZVAL_LONG(return_value,result);
 
8288
  }
 
8289
  return;
 
8290
fail:
 
8291
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7152
8292
}
7153
8293
 
7154
8294
 
7155
8295
ZEND_NAMED_FUNCTION(_wrap_Geometry_GetGeometryName) {
7156
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7157
 
    char *result;
7158
 
    zval **args[0];
7159
 
    
7160
 
    SWIG_ResetError();
7161
 
    /* This function uses a this_ptr*/
7162
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
7163
 
        WRONG_PARAM_COUNT;
7164
 
    }
7165
 
    
7166
 
    {
7167
 
        /* typemap(in) SWIGTYPE * */
7168
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7169
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetGeometryName. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7170
 
        }
7171
 
    }
7172
 
    result = (char *)OGRGeometryShadow_GetGeometryName(arg1);
7173
 
    
7174
 
    {
7175
 
        if(!result) {
7176
 
            ZVAL_NULL(return_value);
7177
 
        } else {
7178
 
            ZVAL_STRING(return_value,result, 1);
7179
 
        }
7180
 
    }
7181
 
    return;
7182
 
    fail:
7183
 
    zend_error(ErrorCode(),ErrorMsg());
 
8296
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8297
  zval **args[1];
 
8298
  char *result = 0 ;
 
8299
  
 
8300
  SWIG_ResetError();
 
8301
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
8302
    WRONG_PARAM_COUNT;
 
8303
  }
 
8304
  
 
8305
  {
 
8306
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8307
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetGeometryName. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8308
    }
 
8309
  }
 
8310
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8311
  result = (char *)OGRGeometryShadow_GetGeometryName(arg1);
 
8312
  {
 
8313
    if(!result) {
 
8314
      ZVAL_NULL(return_value);
 
8315
    } else {
 
8316
      ZVAL_STRING(return_value, (char *)result, 1);
 
8317
    }
 
8318
  }
 
8319
  return;
 
8320
fail:
 
8321
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
8322
}
 
8323
 
 
8324
 
 
8325
ZEND_NAMED_FUNCTION(_wrap_Geometry_Length) {
 
8326
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8327
  zval **args[1];
 
8328
  double result;
 
8329
  
 
8330
  SWIG_ResetError();
 
8331
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
8332
    WRONG_PARAM_COUNT;
 
8333
  }
 
8334
  
 
8335
  {
 
8336
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8337
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Length. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8338
    }
 
8339
  }
 
8340
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8341
  result = (double)OGRGeometryShadow_Length(arg1);
 
8342
  {
 
8343
    ZVAL_DOUBLE(return_value,result);
 
8344
  }
 
8345
  return;
 
8346
fail:
 
8347
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
8348
}
 
8349
 
 
8350
 
 
8351
ZEND_NAMED_FUNCTION(_wrap_Geometry_Area) {
 
8352
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8353
  zval **args[1];
 
8354
  double result;
 
8355
  
 
8356
  SWIG_ResetError();
 
8357
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
8358
    WRONG_PARAM_COUNT;
 
8359
  }
 
8360
  
 
8361
  {
 
8362
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8363
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Area. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8364
    }
 
8365
  }
 
8366
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8367
  result = (double)OGRGeometryShadow_Area(arg1);
 
8368
  {
 
8369
    ZVAL_DOUBLE(return_value,result);
 
8370
  }
 
8371
  return;
 
8372
fail:
 
8373
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7184
8374
}
7185
8375
 
7186
8376
 
7187
8377
ZEND_NAMED_FUNCTION(_wrap_Geometry_GetArea) {
7188
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7189
 
    double result;
7190
 
    zval **args[0];
7191
 
    
7192
 
    SWIG_ResetError();
7193
 
    /* This function uses a this_ptr*/
7194
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
7195
 
        WRONG_PARAM_COUNT;
7196
 
    }
7197
 
    
7198
 
    {
7199
 
        /* typemap(in) SWIGTYPE * */
7200
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7201
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetArea. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7202
 
        }
7203
 
    }
7204
 
    result = (double)OGRGeometryShadow_GetArea(arg1);
7205
 
    
7206
 
    {
7207
 
        ZVAL_DOUBLE(return_value,result);
7208
 
    }
7209
 
    return;
7210
 
    fail:
7211
 
    zend_error(ErrorCode(),ErrorMsg());
 
8378
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8379
  zval **args[1];
 
8380
  double result;
 
8381
  
 
8382
  SWIG_ResetError();
 
8383
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
8384
    WRONG_PARAM_COUNT;
 
8385
  }
 
8386
  
 
8387
  {
 
8388
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8389
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetArea. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8390
    }
 
8391
  }
 
8392
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8393
  result = (double)OGRGeometryShadow_GetArea(arg1);
 
8394
  {
 
8395
    ZVAL_DOUBLE(return_value,result);
 
8396
  }
 
8397
  return;
 
8398
fail:
 
8399
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7212
8400
}
7213
8401
 
7214
8402
 
7215
8403
ZEND_NAMED_FUNCTION(_wrap_Geometry_GetPointCount) {
7216
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7217
 
    int result;
7218
 
    zval **args[0];
7219
 
    
7220
 
    SWIG_ResetError();
7221
 
    /* This function uses a this_ptr*/
7222
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
7223
 
        WRONG_PARAM_COUNT;
7224
 
    }
7225
 
    
7226
 
    {
7227
 
        /* typemap(in) SWIGTYPE * */
7228
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7229
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetPointCount. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7230
 
        }
7231
 
    }
7232
 
    result = (int)OGRGeometryShadow_GetPointCount(arg1);
7233
 
    
7234
 
    {
7235
 
        ZVAL_LONG(return_value,result);
7236
 
    }
7237
 
    return;
7238
 
    fail:
7239
 
    zend_error(ErrorCode(),ErrorMsg());
 
8404
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8405
  zval **args[1];
 
8406
  int result;
 
8407
  
 
8408
  SWIG_ResetError();
 
8409
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
8410
    WRONG_PARAM_COUNT;
 
8411
  }
 
8412
  
 
8413
  {
 
8414
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8415
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetPointCount. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8416
    }
 
8417
  }
 
8418
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8419
  result = (int)OGRGeometryShadow_GetPointCount(arg1);
 
8420
  {
 
8421
    ZVAL_LONG(return_value,result);
 
8422
  }
 
8423
  return;
 
8424
fail:
 
8425
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7240
8426
}
7241
8427
 
7242
8428
 
7243
8429
ZEND_NAMED_FUNCTION(_wrap_Geometry_GetX) {
7244
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7245
 
    int arg2 = (int) 0 ;
7246
 
    double result;
7247
 
    zval **args[1];
7248
 
    int arg_count;
7249
 
    
7250
 
    SWIG_ResetError();
7251
 
    /* This function uses a this_ptr*/
7252
 
    arg_count = ZEND_NUM_ARGS();
7253
 
    if(arg_count<1 || arg_count>2)
7254
 
    WRONG_PARAM_COUNT;
7255
 
    
7256
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
7257
 
    WRONG_PARAM_COUNT;
7258
 
    
7259
 
    {
7260
 
        /* typemap(in) SWIGTYPE * */
7261
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7262
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetX. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7263
 
        }
7264
 
    }
7265
 
    if(arg_count > 1) {
7266
 
        {
7267
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
7268
 
            convert_to_long_ex(args[0]);
7269
 
            arg2 = (int) Z_LVAL_PP(args[0]);
7270
 
            /*@@*/;
7271
 
        }
7272
 
    }
7273
 
    result = (double)OGRGeometryShadow_GetX(arg1,arg2);
7274
 
    
7275
 
    {
7276
 
        ZVAL_DOUBLE(return_value,result);
7277
 
    }
7278
 
    return;
7279
 
    fail:
7280
 
    zend_error(ErrorCode(),ErrorMsg());
 
8430
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8431
  int arg2 = (int) 0 ;
 
8432
  zval **args[2];
 
8433
  int arg_count;
 
8434
  double result;
 
8435
  
 
8436
  SWIG_ResetError();
 
8437
  arg_count = ZEND_NUM_ARGS();
 
8438
  if(arg_count<1 || arg_count>2 ||
 
8439
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
8440
  WRONG_PARAM_COUNT;
 
8441
  
 
8442
  {
 
8443
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8444
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetX. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8445
    }
 
8446
  }
 
8447
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8448
  if(arg_count > 1) {
 
8449
    /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
8450
    convert_to_long_ex(args[1]);
 
8451
    arg2 = (int) Z_LVAL_PP(args[1]);
 
8452
    /*@SWIG@*/;
 
8453
    
 
8454
  }
 
8455
  result = (double)OGRGeometryShadow_GetX(arg1,arg2);
 
8456
  {
 
8457
    ZVAL_DOUBLE(return_value,result);
 
8458
  }
 
8459
  return;
 
8460
fail:
 
8461
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7281
8462
}
7282
8463
 
7283
8464
 
7284
8465
ZEND_NAMED_FUNCTION(_wrap_Geometry_GetY) {
7285
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7286
 
    int arg2 = (int) 0 ;
7287
 
    double result;
7288
 
    zval **args[1];
7289
 
    int arg_count;
7290
 
    
7291
 
    SWIG_ResetError();
7292
 
    /* This function uses a this_ptr*/
7293
 
    arg_count = ZEND_NUM_ARGS();
7294
 
    if(arg_count<1 || arg_count>2)
7295
 
    WRONG_PARAM_COUNT;
7296
 
    
7297
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
7298
 
    WRONG_PARAM_COUNT;
7299
 
    
7300
 
    {
7301
 
        /* typemap(in) SWIGTYPE * */
7302
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7303
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetY. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7304
 
        }
7305
 
    }
7306
 
    if(arg_count > 1) {
7307
 
        {
7308
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
7309
 
            convert_to_long_ex(args[0]);
7310
 
            arg2 = (int) Z_LVAL_PP(args[0]);
7311
 
            /*@@*/;
7312
 
        }
7313
 
    }
7314
 
    result = (double)OGRGeometryShadow_GetY(arg1,arg2);
7315
 
    
7316
 
    {
7317
 
        ZVAL_DOUBLE(return_value,result);
7318
 
    }
7319
 
    return;
7320
 
    fail:
7321
 
    zend_error(ErrorCode(),ErrorMsg());
 
8466
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8467
  int arg2 = (int) 0 ;
 
8468
  zval **args[2];
 
8469
  int arg_count;
 
8470
  double result;
 
8471
  
 
8472
  SWIG_ResetError();
 
8473
  arg_count = ZEND_NUM_ARGS();
 
8474
  if(arg_count<1 || arg_count>2 ||
 
8475
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
8476
  WRONG_PARAM_COUNT;
 
8477
  
 
8478
  {
 
8479
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8480
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetY. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8481
    }
 
8482
  }
 
8483
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8484
  if(arg_count > 1) {
 
8485
    /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
8486
    convert_to_long_ex(args[1]);
 
8487
    arg2 = (int) Z_LVAL_PP(args[1]);
 
8488
    /*@SWIG@*/;
 
8489
    
 
8490
  }
 
8491
  result = (double)OGRGeometryShadow_GetY(arg1,arg2);
 
8492
  {
 
8493
    ZVAL_DOUBLE(return_value,result);
 
8494
  }
 
8495
  return;
 
8496
fail:
 
8497
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7322
8498
}
7323
8499
 
7324
8500
 
7325
8501
ZEND_NAMED_FUNCTION(_wrap_Geometry_GetZ) {
7326
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7327
 
    int arg2 = (int) 0 ;
7328
 
    double result;
7329
 
    zval **args[1];
7330
 
    int arg_count;
7331
 
    
7332
 
    SWIG_ResetError();
7333
 
    /* This function uses a this_ptr*/
7334
 
    arg_count = ZEND_NUM_ARGS();
7335
 
    if(arg_count<1 || arg_count>2)
7336
 
    WRONG_PARAM_COUNT;
7337
 
    
7338
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
7339
 
    WRONG_PARAM_COUNT;
7340
 
    
7341
 
    {
7342
 
        /* typemap(in) SWIGTYPE * */
7343
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7344
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetZ. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7345
 
        }
7346
 
    }
7347
 
    if(arg_count > 1) {
7348
 
        {
7349
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
7350
 
            convert_to_long_ex(args[0]);
7351
 
            arg2 = (int) Z_LVAL_PP(args[0]);
7352
 
            /*@@*/;
7353
 
        }
7354
 
    }
7355
 
    result = (double)OGRGeometryShadow_GetZ(arg1,arg2);
7356
 
    
7357
 
    {
7358
 
        ZVAL_DOUBLE(return_value,result);
7359
 
    }
7360
 
    return;
7361
 
    fail:
7362
 
    zend_error(ErrorCode(),ErrorMsg());
 
8502
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8503
  int arg2 = (int) 0 ;
 
8504
  zval **args[2];
 
8505
  int arg_count;
 
8506
  double result;
 
8507
  
 
8508
  SWIG_ResetError();
 
8509
  arg_count = ZEND_NUM_ARGS();
 
8510
  if(arg_count<1 || arg_count>2 ||
 
8511
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
8512
  WRONG_PARAM_COUNT;
 
8513
  
 
8514
  {
 
8515
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8516
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetZ. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8517
    }
 
8518
  }
 
8519
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8520
  if(arg_count > 1) {
 
8521
    /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
8522
    convert_to_long_ex(args[1]);
 
8523
    arg2 = (int) Z_LVAL_PP(args[1]);
 
8524
    /*@SWIG@*/;
 
8525
    
 
8526
  }
 
8527
  result = (double)OGRGeometryShadow_GetZ(arg1,arg2);
 
8528
  {
 
8529
    ZVAL_DOUBLE(return_value,result);
 
8530
  }
 
8531
  return;
 
8532
fail:
 
8533
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
8534
}
 
8535
 
 
8536
 
 
8537
ZEND_NAMED_FUNCTION(_wrap_Geometry_GetPoint) {
 
8538
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8539
  int arg2 = (int) 0 ;
 
8540
  double *arg3 = (double *) (double *)NULL ;
 
8541
  double argout3[3] ;
 
8542
  zval **args[2];
 
8543
  int arg_count;
 
8544
  
 
8545
  {
 
8546
    /* %typemap(in,numinputs=0) (double argout3[ANY]) */
 
8547
    arg3 = argout3;
 
8548
  }
 
8549
  SWIG_ResetError();
 
8550
  arg_count = ZEND_NUM_ARGS();
 
8551
  if(arg_count<1 || arg_count>2 ||
 
8552
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
8553
  WRONG_PARAM_COUNT;
 
8554
  
 
8555
  {
 
8556
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8557
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetPoint. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8558
    }
 
8559
  }
 
8560
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8561
  if(arg_count > 1) {
 
8562
    /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
8563
    convert_to_long_ex(args[1]);
 
8564
    arg2 = (int) Z_LVAL_PP(args[1]);
 
8565
    /*@SWIG@*/;
 
8566
    
 
8567
  }
 
8568
  OGRGeometryShadow_GetPoint(arg1,arg2,arg3);
 
8569
  
 
8570
  {
 
8571
    /* %typemap(argout) (double argout[ANY]) */
 
8572
    zval *t = CreateTupleFromDoubleArray( arg3, 3 );
 
8573
    t_output_helper( &return_value, t );
 
8574
  }
 
8575
  return;
 
8576
fail:
 
8577
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
8578
}
 
8579
 
 
8580
 
 
8581
ZEND_NAMED_FUNCTION(_wrap_Geometry_GetPoint_2D) {
 
8582
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8583
  int arg2 = (int) 0 ;
 
8584
  double *arg3 = (double *) (double *)NULL ;
 
8585
  double argout3[2] ;
 
8586
  zval **args[2];
 
8587
  int arg_count;
 
8588
  
 
8589
  {
 
8590
    /* %typemap(in,numinputs=0) (double argout3[ANY]) */
 
8591
    arg3 = argout3;
 
8592
  }
 
8593
  SWIG_ResetError();
 
8594
  arg_count = ZEND_NUM_ARGS();
 
8595
  if(arg_count<1 || arg_count>2 ||
 
8596
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
8597
  WRONG_PARAM_COUNT;
 
8598
  
 
8599
  {
 
8600
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8601
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetPoint_2D. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8602
    }
 
8603
  }
 
8604
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8605
  if(arg_count > 1) {
 
8606
    /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
8607
    convert_to_long_ex(args[1]);
 
8608
    arg2 = (int) Z_LVAL_PP(args[1]);
 
8609
    /*@SWIG@*/;
 
8610
    
 
8611
  }
 
8612
  OGRGeometryShadow_GetPoint_2D(arg1,arg2,arg3);
 
8613
  
 
8614
  {
 
8615
    /* %typemap(argout) (double argout[ANY]) */
 
8616
    zval *t = CreateTupleFromDoubleArray( arg3, 2 );
 
8617
    t_output_helper( &return_value, t );
 
8618
  }
 
8619
  return;
 
8620
fail:
 
8621
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7363
8622
}
7364
8623
 
7365
8624
 
7366
8625
ZEND_NAMED_FUNCTION(_wrap_Geometry_GetGeometryCount) {
7367
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7368
 
    int result;
7369
 
    zval **args[0];
7370
 
    
7371
 
    SWIG_ResetError();
7372
 
    /* This function uses a this_ptr*/
7373
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
7374
 
        WRONG_PARAM_COUNT;
7375
 
    }
7376
 
    
7377
 
    {
7378
 
        /* typemap(in) SWIGTYPE * */
7379
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7380
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetGeometryCount. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7381
 
        }
7382
 
    }
7383
 
    result = (int)OGRGeometryShadow_GetGeometryCount(arg1);
7384
 
    
7385
 
    {
7386
 
        ZVAL_LONG(return_value,result);
7387
 
    }
7388
 
    return;
7389
 
    fail:
7390
 
    zend_error(ErrorCode(),ErrorMsg());
 
8626
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8627
  zval **args[1];
 
8628
  int result;
 
8629
  
 
8630
  SWIG_ResetError();
 
8631
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
8632
    WRONG_PARAM_COUNT;
 
8633
  }
 
8634
  
 
8635
  {
 
8636
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8637
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetGeometryCount. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8638
    }
 
8639
  }
 
8640
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8641
  result = (int)OGRGeometryShadow_GetGeometryCount(arg1);
 
8642
  {
 
8643
    ZVAL_LONG(return_value,result);
 
8644
  }
 
8645
  return;
 
8646
fail:
 
8647
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7391
8648
}
7392
8649
 
7393
8650
 
7394
8651
ZEND_NAMED_FUNCTION(_wrap_Geometry_SetPoint) {
7395
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7396
 
    int arg2 ;
7397
 
    double arg3 ;
7398
 
    double arg4 ;
7399
 
    double arg5 = (double) 0 ;
7400
 
    zval **args[4];
7401
 
    int arg_count;
7402
 
    
7403
 
    SWIG_ResetError();
7404
 
    /* This function uses a this_ptr*/
7405
 
    arg_count = ZEND_NUM_ARGS();
7406
 
    if(arg_count<4 || arg_count>5)
7407
 
    WRONG_PARAM_COUNT;
7408
 
    
7409
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
7410
 
    WRONG_PARAM_COUNT;
7411
 
    
7412
 
    {
7413
 
        /* typemap(in) SWIGTYPE * */
7414
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7415
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_SetPoint. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7416
 
        }
7417
 
    }
7418
 
    {
7419
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
7420
 
        convert_to_long_ex(args[0]);
7421
 
        arg2 = (int) Z_LVAL_PP(args[0]);
7422
 
        /*@@*/;
7423
 
    }
7424
 
    {
7425
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,13,CONVERT_FLOAT_IN@*/
7426
 
        convert_to_double_ex(args[1]);
7427
 
        arg3 = (double) Z_DVAL_PP(args[1]);
7428
 
        /*@@*/;
7429
 
    }
7430
 
    {
7431
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,13,CONVERT_FLOAT_IN@*/
7432
 
        convert_to_double_ex(args[2]);
7433
 
        arg4 = (double) Z_DVAL_PP(args[2]);
7434
 
        /*@@*/;
7435
 
    }
7436
 
    if(arg_count > 4) {
7437
 
        {
7438
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,13,CONVERT_FLOAT_IN@*/
7439
 
            convert_to_double_ex(args[3]);
7440
 
            arg5 = (double) Z_DVAL_PP(args[3]);
7441
 
            /*@@*/;
7442
 
        }
7443
 
    }
7444
 
    OGRGeometryShadow_SetPoint(arg1,arg2,arg3,arg4,arg5);
7445
 
    
7446
 
    
7447
 
    return;
7448
 
    fail:
7449
 
    zend_error(ErrorCode(),ErrorMsg());
 
8652
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8653
  int arg2 ;
 
8654
  double arg3 ;
 
8655
  double arg4 ;
 
8656
  double arg5 = (double) 0 ;
 
8657
  zval **args[5];
 
8658
  int arg_count;
 
8659
  
 
8660
  SWIG_ResetError();
 
8661
  arg_count = ZEND_NUM_ARGS();
 
8662
  if(arg_count<4 || arg_count>5 ||
 
8663
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
8664
  WRONG_PARAM_COUNT;
 
8665
  
 
8666
  {
 
8667
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8668
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_SetPoint. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8669
    }
 
8670
  }
 
8671
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8672
  
 
8673
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
8674
  convert_to_long_ex(args[1]);
 
8675
  arg2 = (int) Z_LVAL_PP(args[1]);
 
8676
  /*@SWIG@*/;
 
8677
  
 
8678
  
 
8679
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
8680
  convert_to_double_ex(args[2]);
 
8681
  arg3 = (double) Z_DVAL_PP(args[2]);
 
8682
  /*@SWIG@*/;
 
8683
  
 
8684
  
 
8685
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
8686
  convert_to_double_ex(args[3]);
 
8687
  arg4 = (double) Z_DVAL_PP(args[3]);
 
8688
  /*@SWIG@*/;
 
8689
  
 
8690
  if(arg_count > 4) {
 
8691
    /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
8692
    convert_to_double_ex(args[4]);
 
8693
    arg5 = (double) Z_DVAL_PP(args[4]);
 
8694
    /*@SWIG@*/;
 
8695
    
 
8696
  }
 
8697
  OGRGeometryShadow_SetPoint(arg1,arg2,arg3,arg4,arg5);
 
8698
  
 
8699
  return;
 
8700
fail:
 
8701
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
8702
}
 
8703
 
 
8704
 
 
8705
ZEND_NAMED_FUNCTION(_wrap_Geometry_SetPoint_2D) {
 
8706
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8707
  int arg2 ;
 
8708
  double arg3 ;
 
8709
  double arg4 ;
 
8710
  zval **args[4];
 
8711
  
 
8712
  SWIG_ResetError();
 
8713
  if(ZEND_NUM_ARGS() != 4 || zend_get_parameters_array_ex(4, args) != SUCCESS) {
 
8714
    WRONG_PARAM_COUNT;
 
8715
  }
 
8716
  
 
8717
  {
 
8718
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8719
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_SetPoint_2D. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8720
    }
 
8721
  }
 
8722
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8723
  
 
8724
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
8725
  convert_to_long_ex(args[1]);
 
8726
  arg2 = (int) Z_LVAL_PP(args[1]);
 
8727
  /*@SWIG@*/;
 
8728
  
 
8729
  
 
8730
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
8731
  convert_to_double_ex(args[2]);
 
8732
  arg3 = (double) Z_DVAL_PP(args[2]);
 
8733
  /*@SWIG@*/;
 
8734
  
 
8735
  
 
8736
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
8737
  convert_to_double_ex(args[3]);
 
8738
  arg4 = (double) Z_DVAL_PP(args[3]);
 
8739
  /*@SWIG@*/;
 
8740
  
 
8741
  OGRGeometryShadow_SetPoint_2D(arg1,arg2,arg3,arg4);
 
8742
  
 
8743
  return;
 
8744
fail:
 
8745
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7450
8746
}
7451
8747
 
7452
8748
 
7453
8749
ZEND_NAMED_FUNCTION(_wrap_Geometry_GetGeometryRef) {
7454
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7455
 
    int arg2 ;
7456
 
    OGRGeometryShadow *result;
7457
 
    zval **args[1];
7458
 
    
7459
 
    SWIG_ResetError();
7460
 
    /* This function uses a this_ptr*/
7461
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
7462
 
        WRONG_PARAM_COUNT;
7463
 
    }
7464
 
    
7465
 
    {
7466
 
        /* typemap(in) SWIGTYPE * */
7467
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7468
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetGeometryRef. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7469
 
        }
7470
 
    }
7471
 
    {
7472
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
7473
 
        convert_to_long_ex(args[0]);
7474
 
        arg2 = (int) Z_LVAL_PP(args[0]);
7475
 
        /*@@*/;
7476
 
    }
7477
 
    result = (OGRGeometryShadow *)OGRGeometryShadow_GetGeometryRef(arg1,arg2);
7478
 
    
7479
 
    {
7480
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 0);
7481
 
    }
7482
 
    /* Wrap this return value */
7483
 
    {
7484
 
        /* ALTERNATIVE Constructor, make an object wrapper */
7485
 
        zval *obj, *_cPtr;
7486
 
        MAKE_STD_ZVAL(obj);
7487
 
        MAKE_STD_ZVAL(_cPtr);
7488
 
        *_cPtr = *return_value;
7489
 
        INIT_ZVAL(*return_value);
7490
 
        object_init_ex(obj,ptr_ce_swig_Geometry);
7491
 
        add_property_zval(obj,"_cPtr",_cPtr);
7492
 
        *return_value=*obj;
7493
 
    }
7494
 
    return;
7495
 
    fail:
7496
 
    zend_error(ErrorCode(),ErrorMsg());
 
8750
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8751
  int arg2 ;
 
8752
  zval **args[2];
 
8753
  OGRGeometryShadow *result = 0 ;
 
8754
  
 
8755
  SWIG_ResetError();
 
8756
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
8757
    WRONG_PARAM_COUNT;
 
8758
  }
 
8759
  
 
8760
  {
 
8761
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8762
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetGeometryRef. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8763
    }
 
8764
  }
 
8765
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8766
  
 
8767
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
8768
  convert_to_long_ex(args[1]);
 
8769
  arg2 = (int) Z_LVAL_PP(args[1]);
 
8770
  /*@SWIG@*/;
 
8771
  
 
8772
  result = (OGRGeometryShadow *)OGRGeometryShadow_GetGeometryRef(arg1,arg2);
 
8773
  
 
8774
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 0);
 
8775
  
 
8776
  return;
 
8777
fail:
 
8778
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
8779
}
 
8780
 
 
8781
 
 
8782
ZEND_NAMED_FUNCTION(_wrap_Geometry_Simplify) {
 
8783
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8784
  double arg2 ;
 
8785
  zval **args[2];
 
8786
  OGRGeometryShadow *result = 0 ;
 
8787
  
 
8788
  SWIG_ResetError();
 
8789
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
8790
    WRONG_PARAM_COUNT;
 
8791
  }
 
8792
  
 
8793
  {
 
8794
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8795
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Simplify. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8796
    }
 
8797
  }
 
8798
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8799
  
 
8800
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
8801
  convert_to_double_ex(args[1]);
 
8802
  arg2 = (double) Z_DVAL_PP(args[1]);
 
8803
  /*@SWIG@*/;
 
8804
  
 
8805
  result = (OGRGeometryShadow *)OGRGeometryShadow_Simplify(arg1,arg2);
 
8806
  
 
8807
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
8808
  
 
8809
  return;
 
8810
fail:
 
8811
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
8812
}
 
8813
 
 
8814
 
 
8815
ZEND_NAMED_FUNCTION(_wrap_Geometry_Boundary) {
 
8816
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8817
  zval **args[1];
 
8818
  OGRGeometryShadow *result = 0 ;
 
8819
  
 
8820
  SWIG_ResetError();
 
8821
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
8822
    WRONG_PARAM_COUNT;
 
8823
  }
 
8824
  
 
8825
  {
 
8826
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8827
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Boundary. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8828
    }
 
8829
  }
 
8830
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8831
  result = (OGRGeometryShadow *)OGRGeometryShadow_Boundary(arg1);
 
8832
  
 
8833
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
8834
  
 
8835
  return;
 
8836
fail:
 
8837
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7497
8838
}
7498
8839
 
7499
8840
 
7500
8841
ZEND_NAMED_FUNCTION(_wrap_Geometry_GetBoundary) {
7501
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7502
 
    OGRGeometryShadow *result;
7503
 
    zval **args[0];
7504
 
    
7505
 
    SWIG_ResetError();
7506
 
    /* This function uses a this_ptr*/
7507
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
7508
 
        WRONG_PARAM_COUNT;
7509
 
    }
7510
 
    
7511
 
    {
7512
 
        /* typemap(in) SWIGTYPE * */
7513
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7514
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetBoundary. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7515
 
        }
7516
 
    }
7517
 
    result = (OGRGeometryShadow *)OGRGeometryShadow_GetBoundary(arg1);
7518
 
    
7519
 
    {
7520
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
7521
 
    }
7522
 
    /* Wrap this return value */
7523
 
    {
7524
 
        /* ALTERNATIVE Constructor, make an object wrapper */
7525
 
        zval *obj, *_cPtr;
7526
 
        MAKE_STD_ZVAL(obj);
7527
 
        MAKE_STD_ZVAL(_cPtr);
7528
 
        *_cPtr = *return_value;
7529
 
        INIT_ZVAL(*return_value);
7530
 
        object_init_ex(obj,ptr_ce_swig_Geometry);
7531
 
        add_property_zval(obj,"_cPtr",_cPtr);
7532
 
        *return_value=*obj;
7533
 
    }
7534
 
    return;
7535
 
    fail:
7536
 
    zend_error(ErrorCode(),ErrorMsg());
 
8842
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8843
  zval **args[1];
 
8844
  OGRGeometryShadow *result = 0 ;
 
8845
  
 
8846
  SWIG_ResetError();
 
8847
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
8848
    WRONG_PARAM_COUNT;
 
8849
  }
 
8850
  
 
8851
  {
 
8852
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8853
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetBoundary. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8854
    }
 
8855
  }
 
8856
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8857
  result = (OGRGeometryShadow *)OGRGeometryShadow_GetBoundary(arg1);
 
8858
  
 
8859
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
8860
  
 
8861
  return;
 
8862
fail:
 
8863
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7537
8864
}
7538
8865
 
7539
8866
 
7540
8867
ZEND_NAMED_FUNCTION(_wrap_Geometry_ConvexHull) {
7541
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7542
 
    OGRGeometryShadow *result;
7543
 
    zval **args[0];
7544
 
    
7545
 
    SWIG_ResetError();
7546
 
    /* This function uses a this_ptr*/
7547
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
7548
 
        WRONG_PARAM_COUNT;
7549
 
    }
7550
 
    
7551
 
    {
7552
 
        /* typemap(in) SWIGTYPE * */
7553
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7554
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_ConvexHull. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7555
 
        }
7556
 
    }
7557
 
    result = (OGRGeometryShadow *)OGRGeometryShadow_ConvexHull(arg1);
7558
 
    
7559
 
    {
7560
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
7561
 
    }
7562
 
    /* Wrap this return value */
7563
 
    {
7564
 
        /* ALTERNATIVE Constructor, make an object wrapper */
7565
 
        zval *obj, *_cPtr;
7566
 
        MAKE_STD_ZVAL(obj);
7567
 
        MAKE_STD_ZVAL(_cPtr);
7568
 
        *_cPtr = *return_value;
7569
 
        INIT_ZVAL(*return_value);
7570
 
        object_init_ex(obj,ptr_ce_swig_Geometry);
7571
 
        add_property_zval(obj,"_cPtr",_cPtr);
7572
 
        *return_value=*obj;
7573
 
    }
7574
 
    return;
7575
 
    fail:
7576
 
    zend_error(ErrorCode(),ErrorMsg());
 
8868
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8869
  zval **args[1];
 
8870
  OGRGeometryShadow *result = 0 ;
 
8871
  
 
8872
  SWIG_ResetError();
 
8873
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
8874
    WRONG_PARAM_COUNT;
 
8875
  }
 
8876
  
 
8877
  {
 
8878
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8879
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_ConvexHull. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8880
    }
 
8881
  }
 
8882
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8883
  result = (OGRGeometryShadow *)OGRGeometryShadow_ConvexHull(arg1);
 
8884
  
 
8885
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
8886
  
 
8887
  return;
 
8888
fail:
 
8889
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7577
8890
}
7578
8891
 
7579
8892
 
7580
8893
ZEND_NAMED_FUNCTION(_wrap_Geometry_Buffer) {
7581
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7582
 
    double arg2 ;
7583
 
    int arg3 = (int) 30 ;
7584
 
    OGRGeometryShadow *result;
7585
 
    zval **args[2];
7586
 
    int arg_count;
7587
 
    
7588
 
    SWIG_ResetError();
7589
 
    /* This function uses a this_ptr*/
7590
 
    arg_count = ZEND_NUM_ARGS();
7591
 
    if(arg_count<2 || arg_count>3)
7592
 
    WRONG_PARAM_COUNT;
7593
 
    
7594
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
7595
 
    WRONG_PARAM_COUNT;
7596
 
    
7597
 
    {
7598
 
        /* typemap(in) SWIGTYPE * */
7599
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7600
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Buffer. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7601
 
        }
7602
 
    }
7603
 
    {
7604
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,13,CONVERT_FLOAT_IN@*/
7605
 
        convert_to_double_ex(args[0]);
7606
 
        arg2 = (double) Z_DVAL_PP(args[0]);
7607
 
        /*@@*/;
7608
 
    }
7609
 
    if(arg_count > 2) {
7610
 
        {
7611
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
7612
 
            convert_to_long_ex(args[1]);
7613
 
            arg3 = (int) Z_LVAL_PP(args[1]);
7614
 
            /*@@*/;
7615
 
        }
7616
 
    }
7617
 
    result = (OGRGeometryShadow *)OGRGeometryShadow_Buffer(arg1,arg2,arg3);
7618
 
    
7619
 
    {
7620
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
7621
 
    }
7622
 
    /* Wrap this return value */
7623
 
    {
7624
 
        /* ALTERNATIVE Constructor, make an object wrapper */
7625
 
        zval *obj, *_cPtr;
7626
 
        MAKE_STD_ZVAL(obj);
7627
 
        MAKE_STD_ZVAL(_cPtr);
7628
 
        *_cPtr = *return_value;
7629
 
        INIT_ZVAL(*return_value);
7630
 
        object_init_ex(obj,ptr_ce_swig_Geometry);
7631
 
        add_property_zval(obj,"_cPtr",_cPtr);
7632
 
        *return_value=*obj;
7633
 
    }
7634
 
    return;
7635
 
    fail:
7636
 
    zend_error(ErrorCode(),ErrorMsg());
 
8894
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8895
  double arg2 ;
 
8896
  int arg3 = (int) 30 ;
 
8897
  zval **args[3];
 
8898
  int arg_count;
 
8899
  OGRGeometryShadow *result = 0 ;
 
8900
  
 
8901
  SWIG_ResetError();
 
8902
  arg_count = ZEND_NUM_ARGS();
 
8903
  if(arg_count<2 || arg_count>3 ||
 
8904
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
8905
  WRONG_PARAM_COUNT;
 
8906
  
 
8907
  {
 
8908
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8909
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Buffer. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8910
    }
 
8911
  }
 
8912
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8913
  
 
8914
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
8915
  convert_to_double_ex(args[1]);
 
8916
  arg2 = (double) Z_DVAL_PP(args[1]);
 
8917
  /*@SWIG@*/;
 
8918
  
 
8919
  if(arg_count > 2) {
 
8920
    /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
8921
    convert_to_long_ex(args[2]);
 
8922
    arg3 = (int) Z_LVAL_PP(args[2]);
 
8923
    /*@SWIG@*/;
 
8924
    
 
8925
  }
 
8926
  result = (OGRGeometryShadow *)OGRGeometryShadow_Buffer(arg1,arg2,arg3);
 
8927
  
 
8928
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
8929
  
 
8930
  return;
 
8931
fail:
 
8932
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7637
8933
}
7638
8934
 
7639
8935
 
7640
8936
ZEND_NAMED_FUNCTION(_wrap_Geometry_Intersection) {
7641
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7642
 
    OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
7643
 
    OGRGeometryShadow *result;
7644
 
    zval **args[1];
7645
 
    
7646
 
    SWIG_ResetError();
7647
 
    /* This function uses a this_ptr*/
7648
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
7649
 
        WRONG_PARAM_COUNT;
7650
 
    }
7651
 
    
7652
 
    {
7653
 
        /* typemap(in) SWIGTYPE * */
7654
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7655
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Intersection. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7656
 
        }
7657
 
    }
7658
 
    {
7659
 
        /* typemap(in) SWIGTYPE * */
7660
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7661
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Intersection. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7662
 
        }
7663
 
    }
7664
 
    result = (OGRGeometryShadow *)OGRGeometryShadow_Intersection(arg1,arg2);
7665
 
    
7666
 
    {
7667
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
7668
 
    }
7669
 
    /* Wrap this return value */
7670
 
    {
7671
 
        /* ALTERNATIVE Constructor, make an object wrapper */
7672
 
        zval *obj, *_cPtr;
7673
 
        MAKE_STD_ZVAL(obj);
7674
 
        MAKE_STD_ZVAL(_cPtr);
7675
 
        *_cPtr = *return_value;
7676
 
        INIT_ZVAL(*return_value);
7677
 
        object_init_ex(obj,ptr_ce_swig_Geometry);
7678
 
        add_property_zval(obj,"_cPtr",_cPtr);
7679
 
        *return_value=*obj;
7680
 
    }
7681
 
    return;
7682
 
    fail:
7683
 
    zend_error(ErrorCode(),ErrorMsg());
 
8937
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8938
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
 
8939
  zval **args[2];
 
8940
  OGRGeometryShadow *result = 0 ;
 
8941
  
 
8942
  SWIG_ResetError();
 
8943
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
8944
    WRONG_PARAM_COUNT;
 
8945
  }
 
8946
  
 
8947
  {
 
8948
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8949
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Intersection. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8950
    }
 
8951
  }
 
8952
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8953
  {
 
8954
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8955
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Intersection. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8956
    }
 
8957
  }
 
8958
  {
 
8959
    if (!arg2) {
 
8960
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
8961
    }
 
8962
  }
 
8963
  result = (OGRGeometryShadow *)OGRGeometryShadow_Intersection(arg1,arg2);
 
8964
  
 
8965
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
8966
  
 
8967
  return;
 
8968
fail:
 
8969
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7684
8970
}
7685
8971
 
7686
8972
 
7687
8973
ZEND_NAMED_FUNCTION(_wrap_Geometry_Union) {
7688
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7689
 
    OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
7690
 
    OGRGeometryShadow *result;
7691
 
    zval **args[1];
7692
 
    
7693
 
    SWIG_ResetError();
7694
 
    /* This function uses a this_ptr*/
7695
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
7696
 
        WRONG_PARAM_COUNT;
7697
 
    }
7698
 
    
7699
 
    {
7700
 
        /* typemap(in) SWIGTYPE * */
7701
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7702
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Union. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7703
 
        }
7704
 
    }
7705
 
    {
7706
 
        /* typemap(in) SWIGTYPE * */
7707
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7708
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Union. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7709
 
        }
7710
 
    }
7711
 
    result = (OGRGeometryShadow *)OGRGeometryShadow_Union(arg1,arg2);
7712
 
    
7713
 
    {
7714
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
7715
 
    }
7716
 
    /* Wrap this return value */
7717
 
    {
7718
 
        /* ALTERNATIVE Constructor, make an object wrapper */
7719
 
        zval *obj, *_cPtr;
7720
 
        MAKE_STD_ZVAL(obj);
7721
 
        MAKE_STD_ZVAL(_cPtr);
7722
 
        *_cPtr = *return_value;
7723
 
        INIT_ZVAL(*return_value);
7724
 
        object_init_ex(obj,ptr_ce_swig_Geometry);
7725
 
        add_property_zval(obj,"_cPtr",_cPtr);
7726
 
        *return_value=*obj;
7727
 
    }
7728
 
    return;
7729
 
    fail:
7730
 
    zend_error(ErrorCode(),ErrorMsg());
 
8974
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
8975
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
 
8976
  zval **args[2];
 
8977
  OGRGeometryShadow *result = 0 ;
 
8978
  
 
8979
  SWIG_ResetError();
 
8980
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
8981
    WRONG_PARAM_COUNT;
 
8982
  }
 
8983
  
 
8984
  {
 
8985
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8986
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Union. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8987
    }
 
8988
  }
 
8989
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
8990
  {
 
8991
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
8992
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Union. Expected SWIGTYPE_p_OGRGeometryShadow");
 
8993
    }
 
8994
  }
 
8995
  {
 
8996
    if (!arg2) {
 
8997
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
8998
    }
 
8999
  }
 
9000
  result = (OGRGeometryShadow *)OGRGeometryShadow_Union(arg1,arg2);
 
9001
  
 
9002
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
9003
  
 
9004
  return;
 
9005
fail:
 
9006
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
9007
}
 
9008
 
 
9009
 
 
9010
ZEND_NAMED_FUNCTION(_wrap_Geometry_UnionCascaded) {
 
9011
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9012
  zval **args[1];
 
9013
  OGRGeometryShadow *result = 0 ;
 
9014
  
 
9015
  SWIG_ResetError();
 
9016
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
9017
    WRONG_PARAM_COUNT;
 
9018
  }
 
9019
  
 
9020
  {
 
9021
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9022
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_UnionCascaded. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9023
    }
 
9024
  }
 
9025
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9026
  result = (OGRGeometryShadow *)OGRGeometryShadow_UnionCascaded(arg1);
 
9027
  
 
9028
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
9029
  
 
9030
  return;
 
9031
fail:
 
9032
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7731
9033
}
7732
9034
 
7733
9035
 
7734
9036
ZEND_NAMED_FUNCTION(_wrap_Geometry_Difference) {
7735
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7736
 
    OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
7737
 
    OGRGeometryShadow *result;
7738
 
    zval **args[1];
7739
 
    
7740
 
    SWIG_ResetError();
7741
 
    /* This function uses a this_ptr*/
7742
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
7743
 
        WRONG_PARAM_COUNT;
7744
 
    }
7745
 
    
7746
 
    {
7747
 
        /* typemap(in) SWIGTYPE * */
7748
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7749
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Difference. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7750
 
        }
7751
 
    }
7752
 
    {
7753
 
        /* typemap(in) SWIGTYPE * */
7754
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7755
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Difference. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7756
 
        }
7757
 
    }
7758
 
    result = (OGRGeometryShadow *)OGRGeometryShadow_Difference(arg1,arg2);
7759
 
    
7760
 
    {
7761
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
7762
 
    }
7763
 
    /* Wrap this return value */
7764
 
    {
7765
 
        /* ALTERNATIVE Constructor, make an object wrapper */
7766
 
        zval *obj, *_cPtr;
7767
 
        MAKE_STD_ZVAL(obj);
7768
 
        MAKE_STD_ZVAL(_cPtr);
7769
 
        *_cPtr = *return_value;
7770
 
        INIT_ZVAL(*return_value);
7771
 
        object_init_ex(obj,ptr_ce_swig_Geometry);
7772
 
        add_property_zval(obj,"_cPtr",_cPtr);
7773
 
        *return_value=*obj;
7774
 
    }
7775
 
    return;
7776
 
    fail:
7777
 
    zend_error(ErrorCode(),ErrorMsg());
 
9037
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9038
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
 
9039
  zval **args[2];
 
9040
  OGRGeometryShadow *result = 0 ;
 
9041
  
 
9042
  SWIG_ResetError();
 
9043
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
9044
    WRONG_PARAM_COUNT;
 
9045
  }
 
9046
  
 
9047
  {
 
9048
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9049
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Difference. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9050
    }
 
9051
  }
 
9052
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9053
  {
 
9054
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9055
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Difference. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9056
    }
 
9057
  }
 
9058
  {
 
9059
    if (!arg2) {
 
9060
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
9061
    }
 
9062
  }
 
9063
  result = (OGRGeometryShadow *)OGRGeometryShadow_Difference(arg1,arg2);
 
9064
  
 
9065
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
9066
  
 
9067
  return;
 
9068
fail:
 
9069
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
9070
}
 
9071
 
 
9072
 
 
9073
ZEND_NAMED_FUNCTION(_wrap_Geometry_SymDifference) {
 
9074
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9075
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
 
9076
  zval **args[2];
 
9077
  OGRGeometryShadow *result = 0 ;
 
9078
  
 
9079
  SWIG_ResetError();
 
9080
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
9081
    WRONG_PARAM_COUNT;
 
9082
  }
 
9083
  
 
9084
  {
 
9085
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9086
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_SymDifference. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9087
    }
 
9088
  }
 
9089
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9090
  {
 
9091
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9092
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_SymDifference. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9093
    }
 
9094
  }
 
9095
  {
 
9096
    if (!arg2) {
 
9097
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
9098
    }
 
9099
  }
 
9100
  result = (OGRGeometryShadow *)OGRGeometryShadow_SymDifference(arg1,arg2);
 
9101
  
 
9102
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
9103
  
 
9104
  return;
 
9105
fail:
 
9106
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7778
9107
}
7779
9108
 
7780
9109
 
7781
9110
ZEND_NAMED_FUNCTION(_wrap_Geometry_SymmetricDifference) {
7782
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7783
 
    OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
7784
 
    OGRGeometryShadow *result;
7785
 
    zval **args[1];
7786
 
    
7787
 
    SWIG_ResetError();
7788
 
    /* This function uses a this_ptr*/
7789
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
7790
 
        WRONG_PARAM_COUNT;
7791
 
    }
7792
 
    
7793
 
    {
7794
 
        /* typemap(in) SWIGTYPE * */
7795
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7796
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_SymmetricDifference. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7797
 
        }
7798
 
    }
7799
 
    {
7800
 
        /* typemap(in) SWIGTYPE * */
7801
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7802
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_SymmetricDifference. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7803
 
        }
7804
 
    }
7805
 
    result = (OGRGeometryShadow *)OGRGeometryShadow_SymmetricDifference(arg1,arg2);
7806
 
    
7807
 
    {
7808
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
7809
 
    }
7810
 
    /* Wrap this return value */
7811
 
    {
7812
 
        /* ALTERNATIVE Constructor, make an object wrapper */
7813
 
        zval *obj, *_cPtr;
7814
 
        MAKE_STD_ZVAL(obj);
7815
 
        MAKE_STD_ZVAL(_cPtr);
7816
 
        *_cPtr = *return_value;
7817
 
        INIT_ZVAL(*return_value);
7818
 
        object_init_ex(obj,ptr_ce_swig_Geometry);
7819
 
        add_property_zval(obj,"_cPtr",_cPtr);
7820
 
        *return_value=*obj;
7821
 
    }
7822
 
    return;
7823
 
    fail:
7824
 
    zend_error(ErrorCode(),ErrorMsg());
 
9111
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9112
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
 
9113
  zval **args[2];
 
9114
  OGRGeometryShadow *result = 0 ;
 
9115
  
 
9116
  SWIG_ResetError();
 
9117
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
9118
    WRONG_PARAM_COUNT;
 
9119
  }
 
9120
  
 
9121
  {
 
9122
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9123
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_SymmetricDifference. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9124
    }
 
9125
  }
 
9126
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9127
  {
 
9128
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9129
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_SymmetricDifference. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9130
    }
 
9131
  }
 
9132
  {
 
9133
    if (!arg2) {
 
9134
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
9135
    }
 
9136
  }
 
9137
  result = (OGRGeometryShadow *)OGRGeometryShadow_SymmetricDifference(arg1,arg2);
 
9138
  
 
9139
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
9140
  
 
9141
  return;
 
9142
fail:
 
9143
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7825
9144
}
7826
9145
 
7827
9146
 
7828
9147
ZEND_NAMED_FUNCTION(_wrap_Geometry_Distance) {
7829
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7830
 
    OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
7831
 
    double result;
7832
 
    zval **args[1];
7833
 
    
7834
 
    SWIG_ResetError();
7835
 
    /* This function uses a this_ptr*/
7836
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
7837
 
        WRONG_PARAM_COUNT;
7838
 
    }
7839
 
    
7840
 
    {
7841
 
        /* typemap(in) SWIGTYPE * */
7842
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7843
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Distance. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7844
 
        }
7845
 
    }
7846
 
    {
7847
 
        /* typemap(in) SWIGTYPE * */
7848
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7849
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Distance. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7850
 
        }
7851
 
    }
7852
 
    result = (double)OGRGeometryShadow_Distance(arg1,arg2);
7853
 
    
7854
 
    {
7855
 
        ZVAL_DOUBLE(return_value,result);
7856
 
    }
7857
 
    return;
7858
 
    fail:
7859
 
    zend_error(ErrorCode(),ErrorMsg());
7860
 
}
7861
 
 
7862
 
 
7863
 
ZEND_NAMED_FUNCTION(_wrap_Geometry_Empty) {
7864
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7865
 
    zval **args[0];
7866
 
    
7867
 
    SWIG_ResetError();
7868
 
    /* This function uses a this_ptr*/
7869
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
7870
 
        WRONG_PARAM_COUNT;
7871
 
    }
7872
 
    
7873
 
    {
7874
 
        /* typemap(in) SWIGTYPE * */
7875
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7876
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Empty. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7877
 
        }
7878
 
    }
7879
 
    OGRGeometryShadow_Empty(arg1);
7880
 
    
7881
 
    
7882
 
    return;
7883
 
    fail:
7884
 
    zend_error(ErrorCode(),ErrorMsg());
 
9148
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9149
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
 
9150
  zval **args[2];
 
9151
  double result;
 
9152
  
 
9153
  SWIG_ResetError();
 
9154
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
9155
    WRONG_PARAM_COUNT;
 
9156
  }
 
9157
  
 
9158
  {
 
9159
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9160
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Distance. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9161
    }
 
9162
  }
 
9163
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9164
  {
 
9165
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9166
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Distance. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9167
    }
 
9168
  }
 
9169
  {
 
9170
    if (!arg2) {
 
9171
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
9172
    }
 
9173
  }
 
9174
  result = (double)OGRGeometryShadow_Distance(arg1,arg2);
 
9175
  {
 
9176
    ZVAL_DOUBLE(return_value,result);
 
9177
  }
 
9178
  return;
 
9179
fail:
 
9180
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
9181
}
 
9182
 
 
9183
 
 
9184
ZEND_NAMED_FUNCTION(_wrap_Geometry_c_Empty) {
 
9185
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9186
  zval **args[1];
 
9187
  
 
9188
  SWIG_ResetError();
 
9189
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
9190
    WRONG_PARAM_COUNT;
 
9191
  }
 
9192
  
 
9193
  {
 
9194
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9195
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_c_Empty. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9196
    }
 
9197
  }
 
9198
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9199
  OGRGeometryShadow_Empty(arg1);
 
9200
  
 
9201
  return;
 
9202
fail:
 
9203
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
9204
}
 
9205
 
 
9206
 
 
9207
ZEND_NAMED_FUNCTION(_wrap_Geometry_IsEmpty) {
 
9208
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9209
  zval **args[1];
 
9210
  bool result;
 
9211
  
 
9212
  SWIG_ResetError();
 
9213
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
9214
    WRONG_PARAM_COUNT;
 
9215
  }
 
9216
  
 
9217
  {
 
9218
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9219
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_IsEmpty. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9220
    }
 
9221
  }
 
9222
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9223
  result = (bool)OGRGeometryShadow_IsEmpty(arg1);
 
9224
  {
 
9225
    ZVAL_BOOL(return_value,(result)?1:0);
 
9226
  }
 
9227
  return;
 
9228
fail:
 
9229
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
9230
}
 
9231
 
 
9232
 
 
9233
ZEND_NAMED_FUNCTION(_wrap_Geometry_IsValid) {
 
9234
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9235
  zval **args[1];
 
9236
  bool result;
 
9237
  
 
9238
  SWIG_ResetError();
 
9239
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
9240
    WRONG_PARAM_COUNT;
 
9241
  }
 
9242
  
 
9243
  {
 
9244
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9245
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_IsValid. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9246
    }
 
9247
  }
 
9248
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9249
  result = (bool)OGRGeometryShadow_IsValid(arg1);
 
9250
  {
 
9251
    ZVAL_BOOL(return_value,(result)?1:0);
 
9252
  }
 
9253
  return;
 
9254
fail:
 
9255
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
9256
}
 
9257
 
 
9258
 
 
9259
ZEND_NAMED_FUNCTION(_wrap_Geometry_IsSimple) {
 
9260
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9261
  zval **args[1];
 
9262
  bool result;
 
9263
  
 
9264
  SWIG_ResetError();
 
9265
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
9266
    WRONG_PARAM_COUNT;
 
9267
  }
 
9268
  
 
9269
  {
 
9270
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9271
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_IsSimple. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9272
    }
 
9273
  }
 
9274
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9275
  result = (bool)OGRGeometryShadow_IsSimple(arg1);
 
9276
  {
 
9277
    ZVAL_BOOL(return_value,(result)?1:0);
 
9278
  }
 
9279
  return;
 
9280
fail:
 
9281
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
9282
}
 
9283
 
 
9284
 
 
9285
ZEND_NAMED_FUNCTION(_wrap_Geometry_IsRing) {
 
9286
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9287
  zval **args[1];
 
9288
  bool result;
 
9289
  
 
9290
  SWIG_ResetError();
 
9291
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
9292
    WRONG_PARAM_COUNT;
 
9293
  }
 
9294
  
 
9295
  {
 
9296
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9297
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_IsRing. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9298
    }
 
9299
  }
 
9300
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9301
  result = (bool)OGRGeometryShadow_IsRing(arg1);
 
9302
  {
 
9303
    ZVAL_BOOL(return_value,(result)?1:0);
 
9304
  }
 
9305
  return;
 
9306
fail:
 
9307
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
9308
}
 
9309
 
 
9310
 
 
9311
ZEND_NAMED_FUNCTION(_wrap_Geometry_Intersects) {
 
9312
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9313
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
 
9314
  zval **args[2];
 
9315
  bool result;
 
9316
  
 
9317
  SWIG_ResetError();
 
9318
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
9319
    WRONG_PARAM_COUNT;
 
9320
  }
 
9321
  
 
9322
  {
 
9323
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9324
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Intersects. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9325
    }
 
9326
  }
 
9327
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9328
  {
 
9329
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9330
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Intersects. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9331
    }
 
9332
  }
 
9333
  {
 
9334
    if (!arg2) {
 
9335
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
9336
    }
 
9337
  }
 
9338
  result = (bool)OGRGeometryShadow_Intersects(arg1,arg2);
 
9339
  {
 
9340
    ZVAL_BOOL(return_value,(result)?1:0);
 
9341
  }
 
9342
  return;
 
9343
fail:
 
9344
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7885
9345
}
7886
9346
 
7887
9347
 
7888
9348
ZEND_NAMED_FUNCTION(_wrap_Geometry_Intersect) {
7889
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7890
 
    OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
7891
 
    int result;
7892
 
    zval **args[1];
7893
 
    
7894
 
    SWIG_ResetError();
7895
 
    /* This function uses a this_ptr*/
7896
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
7897
 
        WRONG_PARAM_COUNT;
7898
 
    }
7899
 
    
7900
 
    {
7901
 
        /* typemap(in) SWIGTYPE * */
7902
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7903
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Intersect. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7904
 
        }
7905
 
    }
7906
 
    {
7907
 
        /* typemap(in) SWIGTYPE * */
7908
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7909
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Intersect. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7910
 
        }
7911
 
    }
7912
 
    result = (int)OGRGeometryShadow_Intersect(arg1,arg2);
7913
 
    
7914
 
    {
7915
 
        ZVAL_LONG(return_value,result);
7916
 
    }
7917
 
    return;
7918
 
    fail:
7919
 
    zend_error(ErrorCode(),ErrorMsg());
 
9349
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9350
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
 
9351
  zval **args[2];
 
9352
  bool result;
 
9353
  
 
9354
  SWIG_ResetError();
 
9355
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
9356
    WRONG_PARAM_COUNT;
 
9357
  }
 
9358
  
 
9359
  {
 
9360
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9361
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Intersect. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9362
    }
 
9363
  }
 
9364
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9365
  {
 
9366
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9367
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Intersect. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9368
    }
 
9369
  }
 
9370
  {
 
9371
    if (!arg2) {
 
9372
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
9373
    }
 
9374
  }
 
9375
  result = (bool)OGRGeometryShadow_Intersect(arg1,arg2);
 
9376
  {
 
9377
    ZVAL_BOOL(return_value,(result)?1:0);
 
9378
  }
 
9379
  return;
 
9380
fail:
 
9381
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
9382
}
 
9383
 
 
9384
 
 
9385
ZEND_NAMED_FUNCTION(_wrap_Geometry_Equals) {
 
9386
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9387
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
 
9388
  zval **args[2];
 
9389
  bool result;
 
9390
  
 
9391
  SWIG_ResetError();
 
9392
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
9393
    WRONG_PARAM_COUNT;
 
9394
  }
 
9395
  
 
9396
  {
 
9397
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9398
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Equals. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9399
    }
 
9400
  }
 
9401
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9402
  {
 
9403
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9404
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Equals. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9405
    }
 
9406
  }
 
9407
  {
 
9408
    if (!arg2) {
 
9409
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
9410
    }
 
9411
  }
 
9412
  result = (bool)OGRGeometryShadow_Equals(arg1,arg2);
 
9413
  {
 
9414
    ZVAL_BOOL(return_value,(result)?1:0);
 
9415
  }
 
9416
  return;
 
9417
fail:
 
9418
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7920
9419
}
7921
9420
 
7922
9421
 
7923
9422
ZEND_NAMED_FUNCTION(_wrap_Geometry_Equal) {
7924
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7925
 
    OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
7926
 
    int result;
7927
 
    zval **args[1];
7928
 
    
7929
 
    SWIG_ResetError();
7930
 
    /* This function uses a this_ptr*/
7931
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
7932
 
        WRONG_PARAM_COUNT;
7933
 
    }
7934
 
    
7935
 
    {
7936
 
        /* typemap(in) SWIGTYPE * */
7937
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7938
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Equal. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7939
 
        }
7940
 
    }
7941
 
    {
7942
 
        /* typemap(in) SWIGTYPE * */
7943
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7944
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Equal. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7945
 
        }
7946
 
    }
7947
 
    result = (int)OGRGeometryShadow_Equal(arg1,arg2);
7948
 
    
7949
 
    {
7950
 
        ZVAL_LONG(return_value,result);
7951
 
    }
7952
 
    return;
7953
 
    fail:
7954
 
    zend_error(ErrorCode(),ErrorMsg());
 
9423
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9424
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
 
9425
  zval **args[2];
 
9426
  bool result;
 
9427
  
 
9428
  SWIG_ResetError();
 
9429
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
9430
    WRONG_PARAM_COUNT;
 
9431
  }
 
9432
  
 
9433
  {
 
9434
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9435
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Equal. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9436
    }
 
9437
  }
 
9438
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9439
  {
 
9440
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9441
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Equal. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9442
    }
 
9443
  }
 
9444
  {
 
9445
    if (!arg2) {
 
9446
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
9447
    }
 
9448
  }
 
9449
  result = (bool)OGRGeometryShadow_Equal(arg1,arg2);
 
9450
  {
 
9451
    ZVAL_BOOL(return_value,(result)?1:0);
 
9452
  }
 
9453
  return;
 
9454
fail:
 
9455
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7955
9456
}
7956
9457
 
7957
9458
 
7958
9459
ZEND_NAMED_FUNCTION(_wrap_Geometry_Disjoint) {
7959
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7960
 
    OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
7961
 
    int result;
7962
 
    zval **args[1];
7963
 
    
7964
 
    SWIG_ResetError();
7965
 
    /* This function uses a this_ptr*/
7966
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
7967
 
        WRONG_PARAM_COUNT;
7968
 
    }
7969
 
    
7970
 
    {
7971
 
        /* typemap(in) SWIGTYPE * */
7972
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7973
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Disjoint. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7974
 
        }
7975
 
    }
7976
 
    {
7977
 
        /* typemap(in) SWIGTYPE * */
7978
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
7979
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Disjoint. Expected SWIGTYPE_p_p_OGRGeometryShadow");
7980
 
        }
7981
 
    }
7982
 
    result = (int)OGRGeometryShadow_Disjoint(arg1,arg2);
7983
 
    
7984
 
    {
7985
 
        ZVAL_LONG(return_value,result);
7986
 
    }
7987
 
    return;
7988
 
    fail:
7989
 
    zend_error(ErrorCode(),ErrorMsg());
 
9460
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9461
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
 
9462
  zval **args[2];
 
9463
  bool result;
 
9464
  
 
9465
  SWIG_ResetError();
 
9466
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
9467
    WRONG_PARAM_COUNT;
 
9468
  }
 
9469
  
 
9470
  {
 
9471
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9472
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Disjoint. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9473
    }
 
9474
  }
 
9475
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9476
  {
 
9477
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9478
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Disjoint. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9479
    }
 
9480
  }
 
9481
  {
 
9482
    if (!arg2) {
 
9483
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
9484
    }
 
9485
  }
 
9486
  result = (bool)OGRGeometryShadow_Disjoint(arg1,arg2);
 
9487
  {
 
9488
    ZVAL_BOOL(return_value,(result)?1:0);
 
9489
  }
 
9490
  return;
 
9491
fail:
 
9492
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
7990
9493
}
7991
9494
 
7992
9495
 
7993
9496
ZEND_NAMED_FUNCTION(_wrap_Geometry_Touches) {
7994
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
7995
 
    OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
7996
 
    int result;
7997
 
    zval **args[1];
7998
 
    
7999
 
    SWIG_ResetError();
8000
 
    /* This function uses a this_ptr*/
8001
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
8002
 
        WRONG_PARAM_COUNT;
8003
 
    }
8004
 
    
8005
 
    {
8006
 
        /* typemap(in) SWIGTYPE * */
8007
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
8008
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Touches. Expected SWIGTYPE_p_p_OGRGeometryShadow");
8009
 
        }
8010
 
    }
8011
 
    {
8012
 
        /* typemap(in) SWIGTYPE * */
8013
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
8014
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Touches. Expected SWIGTYPE_p_p_OGRGeometryShadow");
8015
 
        }
8016
 
    }
8017
 
    result = (int)OGRGeometryShadow_Touches(arg1,arg2);
8018
 
    
8019
 
    {
8020
 
        ZVAL_LONG(return_value,result);
8021
 
    }
8022
 
    return;
8023
 
    fail:
8024
 
    zend_error(ErrorCode(),ErrorMsg());
 
9497
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9498
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
 
9499
  zval **args[2];
 
9500
  bool result;
 
9501
  
 
9502
  SWIG_ResetError();
 
9503
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
9504
    WRONG_PARAM_COUNT;
 
9505
  }
 
9506
  
 
9507
  {
 
9508
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9509
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Touches. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9510
    }
 
9511
  }
 
9512
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9513
  {
 
9514
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9515
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Touches. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9516
    }
 
9517
  }
 
9518
  {
 
9519
    if (!arg2) {
 
9520
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
9521
    }
 
9522
  }
 
9523
  result = (bool)OGRGeometryShadow_Touches(arg1,arg2);
 
9524
  {
 
9525
    ZVAL_BOOL(return_value,(result)?1:0);
 
9526
  }
 
9527
  return;
 
9528
fail:
 
9529
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
8025
9530
}
8026
9531
 
8027
9532
 
8028
9533
ZEND_NAMED_FUNCTION(_wrap_Geometry_Crosses) {
8029
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8030
 
    OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
8031
 
    int result;
8032
 
    zval **args[1];
8033
 
    
8034
 
    SWIG_ResetError();
8035
 
    /* This function uses a this_ptr*/
8036
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
8037
 
        WRONG_PARAM_COUNT;
8038
 
    }
8039
 
    
8040
 
    {
8041
 
        /* typemap(in) SWIGTYPE * */
8042
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
8043
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Crosses. Expected SWIGTYPE_p_p_OGRGeometryShadow");
8044
 
        }
8045
 
    }
8046
 
    {
8047
 
        /* typemap(in) SWIGTYPE * */
8048
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
8049
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Crosses. Expected SWIGTYPE_p_p_OGRGeometryShadow");
8050
 
        }
8051
 
    }
8052
 
    result = (int)OGRGeometryShadow_Crosses(arg1,arg2);
8053
 
    
8054
 
    {
8055
 
        ZVAL_LONG(return_value,result);
8056
 
    }
8057
 
    return;
8058
 
    fail:
8059
 
    zend_error(ErrorCode(),ErrorMsg());
 
9534
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9535
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
 
9536
  zval **args[2];
 
9537
  bool result;
 
9538
  
 
9539
  SWIG_ResetError();
 
9540
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
9541
    WRONG_PARAM_COUNT;
 
9542
  }
 
9543
  
 
9544
  {
 
9545
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9546
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Crosses. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9547
    }
 
9548
  }
 
9549
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9550
  {
 
9551
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9552
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Crosses. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9553
    }
 
9554
  }
 
9555
  {
 
9556
    if (!arg2) {
 
9557
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
9558
    }
 
9559
  }
 
9560
  result = (bool)OGRGeometryShadow_Crosses(arg1,arg2);
 
9561
  {
 
9562
    ZVAL_BOOL(return_value,(result)?1:0);
 
9563
  }
 
9564
  return;
 
9565
fail:
 
9566
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
8060
9567
}
8061
9568
 
8062
9569
 
8063
9570
ZEND_NAMED_FUNCTION(_wrap_Geometry_Within) {
8064
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8065
 
    OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
8066
 
    int result;
8067
 
    zval **args[1];
8068
 
    
8069
 
    SWIG_ResetError();
8070
 
    /* This function uses a this_ptr*/
8071
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
8072
 
        WRONG_PARAM_COUNT;
8073
 
    }
8074
 
    
8075
 
    {
8076
 
        /* typemap(in) SWIGTYPE * */
8077
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
8078
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Within. Expected SWIGTYPE_p_p_OGRGeometryShadow");
8079
 
        }
8080
 
    }
8081
 
    {
8082
 
        /* typemap(in) SWIGTYPE * */
8083
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
8084
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Within. Expected SWIGTYPE_p_p_OGRGeometryShadow");
8085
 
        }
8086
 
    }
8087
 
    result = (int)OGRGeometryShadow_Within(arg1,arg2);
8088
 
    
8089
 
    {
8090
 
        ZVAL_LONG(return_value,result);
8091
 
    }
8092
 
    return;
8093
 
    fail:
8094
 
    zend_error(ErrorCode(),ErrorMsg());
 
9571
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9572
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
 
9573
  zval **args[2];
 
9574
  bool result;
 
9575
  
 
9576
  SWIG_ResetError();
 
9577
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
9578
    WRONG_PARAM_COUNT;
 
9579
  }
 
9580
  
 
9581
  {
 
9582
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9583
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Within. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9584
    }
 
9585
  }
 
9586
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9587
  {
 
9588
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9589
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Within. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9590
    }
 
9591
  }
 
9592
  {
 
9593
    if (!arg2) {
 
9594
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
9595
    }
 
9596
  }
 
9597
  result = (bool)OGRGeometryShadow_Within(arg1,arg2);
 
9598
  {
 
9599
    ZVAL_BOOL(return_value,(result)?1:0);
 
9600
  }
 
9601
  return;
 
9602
fail:
 
9603
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
8095
9604
}
8096
9605
 
8097
9606
 
8098
9607
ZEND_NAMED_FUNCTION(_wrap_Geometry_Contains) {
8099
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8100
 
    OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
8101
 
    int result;
8102
 
    zval **args[1];
8103
 
    
8104
 
    SWIG_ResetError();
8105
 
    /* This function uses a this_ptr*/
8106
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
8107
 
        WRONG_PARAM_COUNT;
8108
 
    }
8109
 
    
8110
 
    {
8111
 
        /* typemap(in) SWIGTYPE * */
8112
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
8113
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Contains. Expected SWIGTYPE_p_p_OGRGeometryShadow");
8114
 
        }
8115
 
    }
8116
 
    {
8117
 
        /* typemap(in) SWIGTYPE * */
8118
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
8119
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Contains. Expected SWIGTYPE_p_p_OGRGeometryShadow");
8120
 
        }
8121
 
    }
8122
 
    result = (int)OGRGeometryShadow_Contains(arg1,arg2);
8123
 
    
8124
 
    {
8125
 
        ZVAL_LONG(return_value,result);
8126
 
    }
8127
 
    return;
8128
 
    fail:
8129
 
    zend_error(ErrorCode(),ErrorMsg());
 
9608
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9609
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
 
9610
  zval **args[2];
 
9611
  bool result;
 
9612
  
 
9613
  SWIG_ResetError();
 
9614
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
9615
    WRONG_PARAM_COUNT;
 
9616
  }
 
9617
  
 
9618
  {
 
9619
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9620
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Contains. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9621
    }
 
9622
  }
 
9623
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9624
  {
 
9625
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9626
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Contains. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9627
    }
 
9628
  }
 
9629
  {
 
9630
    if (!arg2) {
 
9631
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
9632
    }
 
9633
  }
 
9634
  result = (bool)OGRGeometryShadow_Contains(arg1,arg2);
 
9635
  {
 
9636
    ZVAL_BOOL(return_value,(result)?1:0);
 
9637
  }
 
9638
  return;
 
9639
fail:
 
9640
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
8130
9641
}
8131
9642
 
8132
9643
 
8133
9644
ZEND_NAMED_FUNCTION(_wrap_Geometry_Overlaps) {
8134
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8135
 
    OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
8136
 
    int result;
8137
 
    zval **args[1];
8138
 
    
8139
 
    SWIG_ResetError();
8140
 
    /* This function uses a this_ptr*/
8141
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
8142
 
        WRONG_PARAM_COUNT;
8143
 
    }
8144
 
    
8145
 
    {
8146
 
        /* typemap(in) SWIGTYPE * */
8147
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
8148
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Overlaps. Expected SWIGTYPE_p_p_OGRGeometryShadow");
8149
 
        }
8150
 
    }
8151
 
    {
8152
 
        /* typemap(in) SWIGTYPE * */
8153
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
8154
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Overlaps. Expected SWIGTYPE_p_p_OGRGeometryShadow");
8155
 
        }
8156
 
    }
8157
 
    result = (int)OGRGeometryShadow_Overlaps(arg1,arg2);
8158
 
    
8159
 
    {
8160
 
        ZVAL_LONG(return_value,result);
8161
 
    }
8162
 
    return;
8163
 
    fail:
8164
 
    zend_error(ErrorCode(),ErrorMsg());
 
9645
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9646
  OGRGeometryShadow *arg2 = (OGRGeometryShadow *) 0 ;
 
9647
  zval **args[2];
 
9648
  bool result;
 
9649
  
 
9650
  SWIG_ResetError();
 
9651
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
9652
    WRONG_PARAM_COUNT;
 
9653
  }
 
9654
  
 
9655
  {
 
9656
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9657
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Overlaps. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9658
    }
 
9659
  }
 
9660
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9661
  {
 
9662
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9663
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Overlaps. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9664
    }
 
9665
  }
 
9666
  {
 
9667
    if (!arg2) {
 
9668
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
9669
    }
 
9670
  }
 
9671
  result = (bool)OGRGeometryShadow_Overlaps(arg1,arg2);
 
9672
  {
 
9673
    ZVAL_BOOL(return_value,(result)?1:0);
 
9674
  }
 
9675
  return;
 
9676
fail:
 
9677
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
8165
9678
}
8166
9679
 
8167
9680
 
8168
9681
ZEND_NAMED_FUNCTION(_wrap_Geometry_TransformTo) {
8169
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8170
 
    OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
8171
 
    OGRErr result;
8172
 
    zval **args[1];
8173
 
    
8174
 
    SWIG_ResetError();
8175
 
    /* This function uses a this_ptr*/
8176
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
8177
 
        WRONG_PARAM_COUNT;
8178
 
    }
8179
 
    
8180
 
    {
8181
 
        /* typemap(in) SWIGTYPE * */
8182
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
8183
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_TransformTo. Expected SWIGTYPE_p_p_OGRGeometryShadow");
8184
 
        }
8185
 
    }
8186
 
    {
8187
 
        /* typemap(in) SWIGTYPE * */
8188
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OSRSpatialReferenceShadow, 0) < 0) {
8189
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_TransformTo. Expected SWIGTYPE_p_p_OSRSpatialReferenceShadow");
8190
 
        }
8191
 
    }
8192
 
    result = (OGRErr)OGRGeometryShadow_TransformTo(arg1,arg2);
8193
 
    
8194
 
    {
8195
 
        /* %typemap(out) OGRErr */
8196
 
        if (result != 0 ) {
8197
 
            SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
8198
 
        }
8199
 
    }
8200
 
    {
8201
 
        /* %typemap(ret) OGRErr */
8202
 
        RETVAL_LONG(0);
8203
 
    }
8204
 
    return;
8205
 
    fail:
8206
 
    zend_error(ErrorCode(),ErrorMsg());
 
9682
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9683
  OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
 
9684
  zval **args[2];
 
9685
  OGRErr result;
 
9686
  
 
9687
  SWIG_ResetError();
 
9688
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
9689
    WRONG_PARAM_COUNT;
 
9690
  }
 
9691
  
 
9692
  {
 
9693
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9694
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_TransformTo. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9695
    }
 
9696
  }
 
9697
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9698
  {
 
9699
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OSRSpatialReferenceShadow, 0) < 0) {
 
9700
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_TransformTo. Expected SWIGTYPE_p_OSRSpatialReferenceShadow");
 
9701
    }
 
9702
  }
 
9703
  {
 
9704
    if (!arg2) {
 
9705
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
9706
    }
 
9707
  }
 
9708
  result = (OGRErr)OGRGeometryShadow_TransformTo(arg1,arg2);
 
9709
  {
 
9710
    /* %typemap(out) OGRErr */
 
9711
    if (result != 0 ) {
 
9712
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
9713
    }
 
9714
  }
 
9715
  {
 
9716
    /* %typemap(ret) OGRErr */
 
9717
    RETVAL_LONG(0);
 
9718
  }
 
9719
  return;
 
9720
fail:
 
9721
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
8207
9722
}
8208
9723
 
8209
9724
 
8210
9725
ZEND_NAMED_FUNCTION(_wrap_Geometry_Transform) {
8211
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8212
 
    OSRCoordinateTransformationShadow *arg2 = (OSRCoordinateTransformationShadow *) 0 ;
8213
 
    OGRErr result;
8214
 
    zval **args[1];
8215
 
    
8216
 
    SWIG_ResetError();
8217
 
    /* This function uses a this_ptr*/
8218
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
8219
 
        WRONG_PARAM_COUNT;
8220
 
    }
8221
 
    
8222
 
    {
8223
 
        /* typemap(in) SWIGTYPE * */
8224
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
8225
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Transform. Expected SWIGTYPE_p_p_OGRGeometryShadow");
8226
 
        }
8227
 
    }
8228
 
    {
8229
 
        /* typemap(in) SWIGTYPE * */
8230
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OSRCoordinateTransformationShadow, 0) < 0) {
8231
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Transform. Expected SWIGTYPE_p_p_OSRCoordinateTransformationShadow");
8232
 
        }
8233
 
    }
8234
 
    result = (OGRErr)OGRGeometryShadow_Transform(arg1,arg2);
8235
 
    
8236
 
    {
8237
 
        /* %typemap(out) OGRErr */
8238
 
        if (result != 0 ) {
8239
 
            SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
8240
 
        }
8241
 
    }
8242
 
    {
8243
 
        /* %typemap(ret) OGRErr */
8244
 
        RETVAL_LONG(0);
8245
 
    }
8246
 
    return;
8247
 
    fail:
8248
 
    zend_error(ErrorCode(),ErrorMsg());
 
9726
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9727
  OSRCoordinateTransformationShadow *arg2 = (OSRCoordinateTransformationShadow *) 0 ;
 
9728
  zval **args[2];
 
9729
  OGRErr result;
 
9730
  
 
9731
  SWIG_ResetError();
 
9732
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
9733
    WRONG_PARAM_COUNT;
 
9734
  }
 
9735
  
 
9736
  {
 
9737
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9738
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Transform. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9739
    }
 
9740
  }
 
9741
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9742
  {
 
9743
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OSRCoordinateTransformationShadow, 0) < 0) {
 
9744
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_Transform. Expected SWIGTYPE_p_OSRCoordinateTransformationShadow");
 
9745
    }
 
9746
  }
 
9747
  {
 
9748
    if (!arg2) {
 
9749
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
9750
    }
 
9751
  }
 
9752
  result = (OGRErr)OGRGeometryShadow_Transform(arg1,arg2);
 
9753
  {
 
9754
    /* %typemap(out) OGRErr */
 
9755
    if (result != 0 ) {
 
9756
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
9757
    }
 
9758
  }
 
9759
  {
 
9760
    /* %typemap(ret) OGRErr */
 
9761
    RETVAL_LONG(0);
 
9762
  }
 
9763
  return;
 
9764
fail:
 
9765
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
8249
9766
}
8250
9767
 
8251
9768
 
8252
9769
ZEND_NAMED_FUNCTION(_wrap_Geometry_GetSpatialReference) {
8253
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8254
 
    OSRSpatialReferenceShadow *result;
8255
 
    zval **args[0];
8256
 
    
8257
 
    SWIG_ResetError();
8258
 
    /* This function uses a this_ptr*/
8259
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
8260
 
        WRONG_PARAM_COUNT;
8261
 
    }
8262
 
    
8263
 
    {
8264
 
        /* typemap(in) SWIGTYPE * */
8265
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
8266
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetSpatialReference. Expected SWIGTYPE_p_p_OGRGeometryShadow");
8267
 
        }
8268
 
    }
8269
 
    result = (OSRSpatialReferenceShadow *)OGRGeometryShadow_GetSpatialReference(arg1);
8270
 
    
8271
 
    {
8272
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OSRSpatialReferenceShadow, 0);
8273
 
    }
8274
 
    /* Wrap this return value */
8275
 
    {
8276
 
        /* ALTERNATIVE Constructor, make an object wrapper */
8277
 
        zval *obj, *_cPtr;
8278
 
        MAKE_STD_ZVAL(obj);
8279
 
        MAKE_STD_ZVAL(_cPtr);
8280
 
        *_cPtr = *return_value;
8281
 
        INIT_ZVAL(*return_value);
8282
 
        object_init_ex(obj,ptr_ce_swig_SpatialReference);
8283
 
        add_property_zval(obj,"_cPtr",_cPtr);
8284
 
        *return_value=*obj;
8285
 
    }
8286
 
    return;
8287
 
    fail:
8288
 
    zend_error(ErrorCode(),ErrorMsg());
 
9770
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9771
  zval **args[1];
 
9772
  OSRSpatialReferenceShadow *result = 0 ;
 
9773
  
 
9774
  SWIG_ResetError();
 
9775
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
9776
    WRONG_PARAM_COUNT;
 
9777
  }
 
9778
  
 
9779
  {
 
9780
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9781
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetSpatialReference. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9782
    }
 
9783
  }
 
9784
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9785
  result = (OSRSpatialReferenceShadow *)OGRGeometryShadow_GetSpatialReference(arg1);
 
9786
  
 
9787
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OSRSpatialReferenceShadow, 1);
 
9788
  
 
9789
  return;
 
9790
fail:
 
9791
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
8289
9792
}
8290
9793
 
8291
9794
 
8292
9795
ZEND_NAMED_FUNCTION(_wrap_Geometry_AssignSpatialReference) {
8293
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8294
 
    OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
8295
 
    zval **args[1];
8296
 
    
8297
 
    SWIG_ResetError();
8298
 
    /* This function uses a this_ptr*/
8299
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
8300
 
        WRONG_PARAM_COUNT;
8301
 
    }
8302
 
    
8303
 
    {
8304
 
        /* typemap(in) SWIGTYPE * */
8305
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
8306
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_AssignSpatialReference. Expected SWIGTYPE_p_p_OGRGeometryShadow");
8307
 
        }
8308
 
    }
8309
 
    {
8310
 
        /* typemap(in) SWIGTYPE * */
8311
 
        if(SWIG_ConvertPtr(*args[0], (void **) &arg2, SWIGTYPE_p_OSRSpatialReferenceShadow, 0) < 0) {
8312
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_AssignSpatialReference. Expected SWIGTYPE_p_p_OSRSpatialReferenceShadow");
8313
 
        }
8314
 
    }
8315
 
    OGRGeometryShadow_AssignSpatialReference(arg1,arg2);
8316
 
    
8317
 
    
8318
 
    return;
8319
 
    fail:
8320
 
    zend_error(ErrorCode(),ErrorMsg());
 
9796
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9797
  OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
 
9798
  zval **args[2];
 
9799
  
 
9800
  SWIG_ResetError();
 
9801
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
9802
    WRONG_PARAM_COUNT;
 
9803
  }
 
9804
  
 
9805
  {
 
9806
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9807
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_AssignSpatialReference. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9808
    }
 
9809
  }
 
9810
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9811
  {
 
9812
    if(SWIG_ConvertPtr(*args[1], (void **) &arg2, SWIGTYPE_p_OSRSpatialReferenceShadow, 0) < 0) {
 
9813
      SWIG_PHP_Error(E_ERROR, "Type error in argument 2 of Geometry_AssignSpatialReference. Expected SWIGTYPE_p_OSRSpatialReferenceShadow");
 
9814
    }
 
9815
  }
 
9816
  OGRGeometryShadow_AssignSpatialReference(arg1,arg2);
 
9817
  
 
9818
  return;
 
9819
fail:
 
9820
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
8321
9821
}
8322
9822
 
8323
9823
 
8324
9824
ZEND_NAMED_FUNCTION(_wrap_Geometry_CloseRings) {
8325
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8326
 
    zval **args[0];
8327
 
    
8328
 
    SWIG_ResetError();
8329
 
    /* This function uses a this_ptr*/
8330
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
8331
 
        WRONG_PARAM_COUNT;
8332
 
    }
8333
 
    
8334
 
    {
8335
 
        /* typemap(in) SWIGTYPE * */
8336
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
8337
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_CloseRings. Expected SWIGTYPE_p_p_OGRGeometryShadow");
8338
 
        }
8339
 
    }
8340
 
    OGRGeometryShadow_CloseRings(arg1);
8341
 
    
8342
 
    
8343
 
    return;
8344
 
    fail:
8345
 
    zend_error(ErrorCode(),ErrorMsg());
 
9825
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9826
  zval **args[1];
 
9827
  
 
9828
  SWIG_ResetError();
 
9829
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
9830
    WRONG_PARAM_COUNT;
 
9831
  }
 
9832
  
 
9833
  {
 
9834
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9835
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_CloseRings. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9836
    }
 
9837
  }
 
9838
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9839
  OGRGeometryShadow_CloseRings(arg1);
 
9840
  
 
9841
  return;
 
9842
fail:
 
9843
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
8346
9844
}
8347
9845
 
8348
9846
 
8349
9847
ZEND_NAMED_FUNCTION(_wrap_Geometry_FlattenTo2D) {
8350
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8351
 
    zval **args[0];
8352
 
    
8353
 
    SWIG_ResetError();
8354
 
    /* This function uses a this_ptr*/
8355
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
8356
 
        WRONG_PARAM_COUNT;
8357
 
    }
8358
 
    
8359
 
    {
8360
 
        /* typemap(in) SWIGTYPE * */
8361
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
8362
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_FlattenTo2D. Expected SWIGTYPE_p_p_OGRGeometryShadow");
8363
 
        }
8364
 
    }
8365
 
    OGRGeometryShadow_FlattenTo2D(arg1);
8366
 
    
8367
 
    
8368
 
    return;
8369
 
    fail:
8370
 
    zend_error(ErrorCode(),ErrorMsg());
 
9848
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9849
  zval **args[1];
 
9850
  
 
9851
  SWIG_ResetError();
 
9852
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
9853
    WRONG_PARAM_COUNT;
 
9854
  }
 
9855
  
 
9856
  {
 
9857
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9858
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_FlattenTo2D. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9859
    }
 
9860
  }
 
9861
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9862
  OGRGeometryShadow_FlattenTo2D(arg1);
 
9863
  
 
9864
  return;
 
9865
fail:
 
9866
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
9867
}
 
9868
 
 
9869
 
 
9870
ZEND_NAMED_FUNCTION(_wrap_Geometry_Segmentize) {
 
9871
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9872
  double arg2 ;
 
9873
  zval **args[2];
 
9874
  
 
9875
  SWIG_ResetError();
 
9876
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
9877
    WRONG_PARAM_COUNT;
 
9878
  }
 
9879
  
 
9880
  {
 
9881
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9882
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Segmentize. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9883
    }
 
9884
  }
 
9885
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9886
  
 
9887
  /*@SWIG:/usr/share/swig1.3/php/utils.i,16,CONVERT_FLOAT_IN@*/
 
9888
  convert_to_double_ex(args[1]);
 
9889
  arg2 = (double) Z_DVAL_PP(args[1]);
 
9890
  /*@SWIG@*/;
 
9891
  
 
9892
  OGRGeometryShadow_Segmentize(arg1,arg2);
 
9893
  
 
9894
  return;
 
9895
fail:
 
9896
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
8371
9897
}
8372
9898
 
8373
9899
 
8374
9900
ZEND_NAMED_FUNCTION(_wrap_Geometry_GetEnvelope) {
8375
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8376
 
    double *arg2 ;
8377
 
    double argout2[4] ;
8378
 
    zval **args[0];
8379
 
    
8380
 
    {
8381
 
        /* %typemap(in,numinputs=0) (double argout2[ANY]) */
8382
 
        arg2 = argout2;
8383
 
    }
8384
 
    SWIG_ResetError();
8385
 
    /* This function uses a this_ptr*/
8386
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
8387
 
        WRONG_PARAM_COUNT;
8388
 
    }
8389
 
    
8390
 
    {
8391
 
        /* typemap(in) SWIGTYPE * */
8392
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
8393
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetEnvelope. Expected SWIGTYPE_p_p_OGRGeometryShadow");
8394
 
        }
8395
 
    }
8396
 
    OGRGeometryShadow_GetEnvelope(arg1,arg2);
8397
 
    
8398
 
    
8399
 
    {
8400
 
        /* %typemap(argout) (double argout[ANY]) */
8401
 
        zval *t = CreateTupleFromDoubleArray( arg2, 4 );
8402
 
        t_output_helper( &return_value, t );
8403
 
    }
8404
 
    return;
8405
 
    fail:
8406
 
    zend_error(ErrorCode(),ErrorMsg());
 
9901
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9902
  double *arg2 ;
 
9903
  double argout2[4] ;
 
9904
  zval **args[1];
 
9905
  
 
9906
  {
 
9907
    /* %typemap(in,numinputs=0) (double argout2[ANY]) */
 
9908
    arg2 = argout2;
 
9909
  }
 
9910
  SWIG_ResetError();
 
9911
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
9912
    WRONG_PARAM_COUNT;
 
9913
  }
 
9914
  
 
9915
  {
 
9916
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9917
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetEnvelope. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9918
    }
 
9919
  }
 
9920
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9921
  OGRGeometryShadow_GetEnvelope(arg1,arg2);
 
9922
  
 
9923
  {
 
9924
    /* %typemap(argout) (double argout[ANY]) */
 
9925
    zval *t = CreateTupleFromDoubleArray( arg2, 4 );
 
9926
    t_output_helper( &return_value, t );
 
9927
  }
 
9928
  return;
 
9929
fail:
 
9930
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
8407
9931
}
8408
9932
 
8409
9933
 
8410
9934
ZEND_NAMED_FUNCTION(_wrap_Geometry_Centroid) {
8411
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8412
 
    OGRGeometryShadow *result;
8413
 
    zval **args[0];
8414
 
    
8415
 
    SWIG_ResetError();
8416
 
    /* This function uses a this_ptr*/
8417
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
8418
 
        WRONG_PARAM_COUNT;
8419
 
    }
8420
 
    
8421
 
    {
8422
 
        /* typemap(in) SWIGTYPE * */
8423
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
8424
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Centroid. Expected SWIGTYPE_p_p_OGRGeometryShadow");
8425
 
        }
8426
 
    }
8427
 
    result = (OGRGeometryShadow *)OGRGeometryShadow_Centroid(arg1);
8428
 
    
8429
 
    {
8430
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
8431
 
    }
8432
 
    /* Wrap this return value */
8433
 
    {
8434
 
        /* ALTERNATIVE Constructor, make an object wrapper */
8435
 
        zval *obj, *_cPtr;
8436
 
        MAKE_STD_ZVAL(obj);
8437
 
        MAKE_STD_ZVAL(_cPtr);
8438
 
        *_cPtr = *return_value;
8439
 
        INIT_ZVAL(*return_value);
8440
 
        object_init_ex(obj,ptr_ce_swig_Geometry);
8441
 
        add_property_zval(obj,"_cPtr",_cPtr);
8442
 
        *return_value=*obj;
8443
 
    }
8444
 
    return;
8445
 
    fail:
8446
 
    zend_error(ErrorCode(),ErrorMsg());
 
9935
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9936
  zval **args[1];
 
9937
  OGRGeometryShadow *result = 0 ;
 
9938
  
 
9939
  SWIG_ResetError();
 
9940
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
9941
    WRONG_PARAM_COUNT;
 
9942
  }
 
9943
  
 
9944
  {
 
9945
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9946
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_Centroid. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9947
    }
 
9948
  }
 
9949
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9950
  result = (OGRGeometryShadow *)OGRGeometryShadow_Centroid(arg1);
 
9951
  
 
9952
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRGeometryShadow, 1);
 
9953
  
 
9954
  return;
 
9955
fail:
 
9956
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
8447
9957
}
8448
9958
 
8449
9959
 
8450
9960
ZEND_NAMED_FUNCTION(_wrap_Geometry_WkbSize) {
8451
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8452
 
    int result;
8453
 
    zval **args[0];
8454
 
    
8455
 
    SWIG_ResetError();
8456
 
    /* This function uses a this_ptr*/
8457
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
8458
 
        WRONG_PARAM_COUNT;
8459
 
    }
8460
 
    
8461
 
    {
8462
 
        /* typemap(in) SWIGTYPE * */
8463
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
8464
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_WkbSize. Expected SWIGTYPE_p_p_OGRGeometryShadow");
8465
 
        }
8466
 
    }
8467
 
    result = (int)OGRGeometryShadow_WkbSize(arg1);
8468
 
    
8469
 
    {
8470
 
        ZVAL_LONG(return_value,result);
8471
 
    }
8472
 
    return;
8473
 
    fail:
8474
 
    zend_error(ErrorCode(),ErrorMsg());
 
9961
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9962
  zval **args[1];
 
9963
  int result;
 
9964
  
 
9965
  SWIG_ResetError();
 
9966
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
9967
    WRONG_PARAM_COUNT;
 
9968
  }
 
9969
  
 
9970
  {
 
9971
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9972
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_WkbSize. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9973
    }
 
9974
  }
 
9975
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
9976
  result = (int)OGRGeometryShadow_WkbSize(arg1);
 
9977
  {
 
9978
    ZVAL_LONG(return_value,result);
 
9979
  }
 
9980
  return;
 
9981
fail:
 
9982
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
8475
9983
}
8476
9984
 
8477
9985
 
8478
9986
ZEND_NAMED_FUNCTION(_wrap_Geometry_GetCoordinateDimension) {
8479
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8480
 
    int result;
8481
 
    zval **args[0];
8482
 
    
8483
 
    SWIG_ResetError();
8484
 
    /* This function uses a this_ptr*/
8485
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
8486
 
        WRONG_PARAM_COUNT;
8487
 
    }
8488
 
    
8489
 
    {
8490
 
        /* typemap(in) SWIGTYPE * */
8491
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
8492
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetCoordinateDimension. Expected SWIGTYPE_p_p_OGRGeometryShadow");
8493
 
        }
8494
 
    }
8495
 
    result = (int)OGRGeometryShadow_GetCoordinateDimension(arg1);
8496
 
    
8497
 
    {
8498
 
        ZVAL_LONG(return_value,result);
8499
 
    }
8500
 
    return;
8501
 
    fail:
8502
 
    zend_error(ErrorCode(),ErrorMsg());
 
9987
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
9988
  zval **args[1];
 
9989
  int result;
 
9990
  
 
9991
  SWIG_ResetError();
 
9992
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
9993
    WRONG_PARAM_COUNT;
 
9994
  }
 
9995
  
 
9996
  {
 
9997
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
9998
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetCoordinateDimension. Expected SWIGTYPE_p_OGRGeometryShadow");
 
9999
    }
 
10000
  }
 
10001
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
10002
  result = (int)OGRGeometryShadow_GetCoordinateDimension(arg1);
 
10003
  {
 
10004
    ZVAL_LONG(return_value,result);
 
10005
  }
 
10006
  return;
 
10007
fail:
 
10008
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
10009
}
 
10010
 
 
10011
 
 
10012
ZEND_NAMED_FUNCTION(_wrap_Geometry_SetCoordinateDimension) {
 
10013
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
10014
  int arg2 ;
 
10015
  zval **args[2];
 
10016
  
 
10017
  SWIG_ResetError();
 
10018
  if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
 
10019
    WRONG_PARAM_COUNT;
 
10020
  }
 
10021
  
 
10022
  {
 
10023
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
10024
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_SetCoordinateDimension. Expected SWIGTYPE_p_OGRGeometryShadow");
 
10025
    }
 
10026
  }
 
10027
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
10028
  
 
10029
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
10030
  convert_to_long_ex(args[1]);
 
10031
  arg2 = (int) Z_LVAL_PP(args[1]);
 
10032
  /*@SWIG@*/;
 
10033
  
 
10034
  OGRGeometryShadow_SetCoordinateDimension(arg1,arg2);
 
10035
  
 
10036
  return;
 
10037
fail:
 
10038
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
8503
10039
}
8504
10040
 
8505
10041
 
8506
10042
ZEND_NAMED_FUNCTION(_wrap_Geometry_GetDimension) {
8507
 
    OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
8508
 
    int result;
8509
 
    zval **args[0];
8510
 
    
8511
 
    SWIG_ResetError();
8512
 
    /* This function uses a this_ptr*/
8513
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
8514
 
        WRONG_PARAM_COUNT;
8515
 
    }
8516
 
    
8517
 
    {
8518
 
        /* typemap(in) SWIGTYPE * */
8519
 
        if(SWIG_ConvertPtr(*&this_ptr, (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
8520
 
            SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetDimension. Expected SWIGTYPE_p_p_OGRGeometryShadow");
8521
 
        }
8522
 
    }
8523
 
    result = (int)OGRGeometryShadow_GetDimension(arg1);
8524
 
    
8525
 
    {
8526
 
        ZVAL_LONG(return_value,result);
8527
 
    }
8528
 
    return;
8529
 
    fail:
8530
 
    zend_error(ErrorCode(),ErrorMsg());
8531
 
}
8532
 
 
8533
 
 
8534
 
/* property handler for class Geometry */
8535
 
static pval _wrap_propget_Geometry(zend_property_reference *property_reference) {
8536
 
  pval result;
8537
 
  pval **_result;
8538
 
  zend_llist_element *element = property_reference->elements_list->head;
8539
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
8540
 
  result.type = IS_NULL;
8541
 
  if (_propget_Geometry(property_reference, &result)==SUCCESS) return result;
8542
 
  /* return it ourselves */
8543
 
  if (zend_hash_find(Z_OBJPROP_P(property_reference->object),Z_STRVAL_P(&(property->element)),1+Z_STRLEN_P(&(property->element)),(void**)&_result)==SUCCESS) {
8544
 
  zval *_value;
8545
 
  MAKE_STD_ZVAL(_value);  *_value=**_result;
8546
 
  INIT_PZVAL(_value);
8547
 
  zval_copy_ctor(_value);
8548
 
  return *_value;
8549
 
  }
8550
 
  result.type = IS_NULL;
8551
 
  return result;
8552
 
}
8553
 
static int _propget_Geometry(zend_property_reference *property_reference, pval *value) {
8554
 
  /* get the property name */
8555
 
  zend_llist_element *element = property_reference->elements_list->head;
8556
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
8557
 
  char *propname=Z_STRVAL_P(&(property->element));
8558
 
  return FAILURE;
8559
 
}
8560
 
 
8561
 
static int _wrap_propset_Geometry(zend_property_reference *property_reference, pval *value) { 
8562
 
  zval * _value;
8563
 
  zend_llist_element *element = property_reference->elements_list->head;
8564
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
8565
 
  if (_propset_Geometry(property_reference, value)==SUCCESS) return SUCCESS;
8566
 
  /* set it ourselves as it is Geometry */
8567
 
  MAKE_STD_ZVAL(_value);
8568
 
  *_value=*value;
8569
 
  INIT_PZVAL(_value);
8570
 
  zval_copy_ctor(_value);
8571
 
  return add_property_zval_ex(property_reference->object,Z_STRVAL_P(&(property->element)),1+Z_STRLEN_P(&(property->element)),_value);
8572
 
}
8573
 
static int _propset_Geometry(zend_property_reference *property_reference, pval *value) {
8574
 
  /* get the property name */
8575
 
  zend_llist_element *element = property_reference->elements_list->head;
8576
 
  zend_overloaded_element *property=(zend_overloaded_element *)element->data;
8577
 
  char *propname=Z_STRVAL_P(&(property->element));
8578
 
  return FAILURE;
8579
 
}
 
10043
  OGRGeometryShadow *arg1 = (OGRGeometryShadow *) 0 ;
 
10044
  zval **args[1];
 
10045
  int result;
 
10046
  
 
10047
  SWIG_ResetError();
 
10048
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
10049
    WRONG_PARAM_COUNT;
 
10050
  }
 
10051
  
 
10052
  {
 
10053
    if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_OGRGeometryShadow, 0) < 0) {
 
10054
      SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of Geometry_GetDimension. Expected SWIGTYPE_p_OGRGeometryShadow");
 
10055
    }
 
10056
  }
 
10057
  if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
 
10058
  result = (int)OGRGeometryShadow_GetDimension(arg1);
 
10059
  {
 
10060
    ZVAL_LONG(return_value,result);
 
10061
  }
 
10062
  return;
 
10063
fail:
 
10064
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
10065
}
 
10066
 
8580
10067
 
8581
10068
ZEND_NAMED_FUNCTION(_wrap_OGRGetDriverCount) {
8582
 
    int result;
8583
 
    zval **args[0];
8584
 
    
8585
 
    SWIG_ResetError();
8586
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
8587
 
        WRONG_PARAM_COUNT;
8588
 
    }
8589
 
    
8590
 
    result = (int)OGRGetDriverCount();
8591
 
    
8592
 
    {
8593
 
        ZVAL_LONG(return_value,result);
8594
 
    }
8595
 
    return;
8596
 
    fail:
8597
 
    zend_error(ErrorCode(),ErrorMsg());
 
10069
  int result;
 
10070
  
 
10071
  SWIG_ResetError();
 
10072
  if(ZEND_NUM_ARGS() != 0) {
 
10073
    WRONG_PARAM_COUNT;
 
10074
  }
 
10075
  
 
10076
  result = (int)OGRGetDriverCount();
 
10077
  {
 
10078
    ZVAL_LONG(return_value,result);
 
10079
  }
 
10080
  return;
 
10081
fail:
 
10082
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
8598
10083
}
8599
10084
 
8600
10085
 
8601
10086
ZEND_NAMED_FUNCTION(_wrap_OGRGetOpenDSCount) {
8602
 
    int result;
8603
 
    zval **args[0];
8604
 
    
8605
 
    SWIG_ResetError();
8606
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
8607
 
        WRONG_PARAM_COUNT;
8608
 
    }
8609
 
    
8610
 
    result = (int)OGRGetOpenDSCount();
8611
 
    
8612
 
    {
8613
 
        ZVAL_LONG(return_value,result);
8614
 
    }
8615
 
    return;
8616
 
    fail:
8617
 
    zend_error(ErrorCode(),ErrorMsg());
 
10087
  int result;
 
10088
  
 
10089
  SWIG_ResetError();
 
10090
  if(ZEND_NUM_ARGS() != 0) {
 
10091
    WRONG_PARAM_COUNT;
 
10092
  }
 
10093
  
 
10094
  result = (int)OGRGetOpenDSCount();
 
10095
  {
 
10096
    ZVAL_LONG(return_value,result);
 
10097
  }
 
10098
  return;
 
10099
fail:
 
10100
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
8618
10101
}
8619
10102
 
8620
10103
 
8621
10104
ZEND_NAMED_FUNCTION(_wrap_OGRSetGenerate_DB2_V72_BYTE_ORDER) {
8622
 
    int arg1 ;
8623
 
    OGRErr result;
8624
 
    zval **args[1];
8625
 
    
8626
 
    SWIG_ResetError();
8627
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
8628
 
        WRONG_PARAM_COUNT;
8629
 
    }
8630
 
    
8631
 
    {
8632
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
8633
 
        convert_to_long_ex(args[0]);
8634
 
        arg1 = (int) Z_LVAL_PP(args[0]);
8635
 
        /*@@*/;
8636
 
    }
8637
 
    result = (OGRErr)OGRSetGenerate_DB2_V72_BYTE_ORDER(arg1);
8638
 
    
8639
 
    {
8640
 
        /* %typemap(out) OGRErr */
8641
 
        if (result != 0 ) {
8642
 
            SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
8643
 
        }
8644
 
    }
8645
 
    {
8646
 
        /* %typemap(ret) OGRErr */
8647
 
        RETVAL_LONG(0);
8648
 
    }
8649
 
    return;
8650
 
    fail:
8651
 
    zend_error(ErrorCode(),ErrorMsg());
 
10105
  int arg1 ;
 
10106
  zval **args[1];
 
10107
  OGRErr result;
 
10108
  
 
10109
  SWIG_ResetError();
 
10110
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
10111
    WRONG_PARAM_COUNT;
 
10112
  }
 
10113
  
 
10114
  
 
10115
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
10116
  convert_to_long_ex(args[0]);
 
10117
  arg1 = (int) Z_LVAL_PP(args[0]);
 
10118
  /*@SWIG@*/;
 
10119
  
 
10120
  result = (OGRErr)OGRSetGenerate_DB2_V72_BYTE_ORDER(arg1);
 
10121
  {
 
10122
    /* %typemap(out) OGRErr */
 
10123
    if (result != 0 ) {
 
10124
      SWIG_PHP_Error(E_ERROR,OGRErrMessages(result));
 
10125
    }
 
10126
  }
 
10127
  {
 
10128
    /* %typemap(ret) OGRErr */
 
10129
    RETVAL_LONG(0);
 
10130
  }
 
10131
  return;
 
10132
fail:
 
10133
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
8652
10134
}
8653
10135
 
8654
10136
 
8655
10137
ZEND_NAMED_FUNCTION(_wrap_OGRRegisterAll) {
8656
 
    zval **args[0];
8657
 
    
8658
 
    SWIG_ResetError();
8659
 
    if(((ZEND_NUM_ARGS() )!= 0) || (zend_get_parameters_array_ex(0, args)!= SUCCESS)) {
8660
 
        WRONG_PARAM_COUNT;
8661
 
    }
8662
 
    
8663
 
    OGRRegisterAll();
8664
 
    
8665
 
    
8666
 
    return;
8667
 
    fail:
8668
 
    zend_error(ErrorCode(),ErrorMsg());
 
10138
  SWIG_ResetError();
 
10139
  if(ZEND_NUM_ARGS() != 0) {
 
10140
    WRONG_PARAM_COUNT;
 
10141
  }
 
10142
  
 
10143
  OGRRegisterAll();
 
10144
  
 
10145
  return;
 
10146
fail:
 
10147
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
10148
}
 
10149
 
 
10150
 
 
10151
ZEND_NAMED_FUNCTION(_wrap_GeometryTypeToName) {
 
10152
  OGRwkbGeometryType arg1 ;
 
10153
  zval **args[1];
 
10154
  char *result = 0 ;
 
10155
  
 
10156
  SWIG_ResetError();
 
10157
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
10158
    WRONG_PARAM_COUNT;
 
10159
  }
 
10160
  
 
10161
  
 
10162
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
10163
  convert_to_long_ex(args[0]);
 
10164
  arg1 = (OGRwkbGeometryType) Z_LVAL_PP(args[0]);
 
10165
  /*@SWIG@*/;
 
10166
  
 
10167
  result = (char *)OGRGeometryTypeToName(arg1);
 
10168
  {
 
10169
    if(!result) {
 
10170
      ZVAL_NULL(return_value);
 
10171
    } else {
 
10172
      ZVAL_STRING(return_value, (char *)result, 1);
 
10173
    }
 
10174
  }
 
10175
  return;
 
10176
fail:
 
10177
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
10178
}
 
10179
 
 
10180
 
 
10181
ZEND_NAMED_FUNCTION(_wrap_GetFieldTypeName) {
 
10182
  OGRFieldType arg1 ;
 
10183
  zval **args[1];
 
10184
  char *result = 0 ;
 
10185
  
 
10186
  SWIG_ResetError();
 
10187
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
10188
    WRONG_PARAM_COUNT;
 
10189
  }
 
10190
  
 
10191
  
 
10192
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
10193
  convert_to_long_ex(args[0]);
 
10194
  arg1 = (OGRFieldType) Z_LVAL_PP(args[0]);
 
10195
  /*@SWIG@*/;
 
10196
  
 
10197
  result = (char *)OGR_GetFieldTypeName(arg1);
 
10198
  {
 
10199
    if(!result) {
 
10200
      ZVAL_NULL(return_value);
 
10201
    } else {
 
10202
      ZVAL_STRING(return_value, (char *)result, 1);
 
10203
    }
 
10204
  }
 
10205
  return;
 
10206
fail:
 
10207
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
8669
10208
}
8670
10209
 
8671
10210
 
8672
10211
ZEND_NAMED_FUNCTION(_wrap_GetOpenDS) {
8673
 
    int arg1 ;
8674
 
    OGRDataSourceShadow *result;
8675
 
    zval **args[1];
8676
 
    
8677
 
    SWIG_ResetError();
8678
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
8679
 
        WRONG_PARAM_COUNT;
8680
 
    }
8681
 
    
8682
 
    {
8683
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
8684
 
        convert_to_long_ex(args[0]);
8685
 
        arg1 = (int) Z_LVAL_PP(args[0]);
8686
 
        /*@@*/;
8687
 
    }
8688
 
    result = (OGRDataSourceShadow *)GetOpenDS(arg1);
8689
 
    
8690
 
    {
8691
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRDataSourceShadow, 0);
8692
 
    }
8693
 
    /* Wrap this return value */
8694
 
    {
8695
 
        /* ALTERNATIVE Constructor, make an object wrapper */
8696
 
        zval *obj, *_cPtr;
8697
 
        MAKE_STD_ZVAL(obj);
8698
 
        MAKE_STD_ZVAL(_cPtr);
8699
 
        *_cPtr = *return_value;
8700
 
        INIT_ZVAL(*return_value);
8701
 
        object_init_ex(obj,ptr_ce_swig_DataSource);
8702
 
        add_property_zval(obj,"_cPtr",_cPtr);
8703
 
        *return_value=*obj;
8704
 
    }
8705
 
    return;
8706
 
    fail:
8707
 
    zend_error(ErrorCode(),ErrorMsg());
 
10212
  int arg1 ;
 
10213
  zval **args[1];
 
10214
  OGRDataSourceShadow *result = 0 ;
 
10215
  
 
10216
  SWIG_ResetError();
 
10217
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
10218
    WRONG_PARAM_COUNT;
 
10219
  }
 
10220
  
 
10221
  
 
10222
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
10223
  convert_to_long_ex(args[0]);
 
10224
  arg1 = (int) Z_LVAL_PP(args[0]);
 
10225
  /*@SWIG@*/;
 
10226
  
 
10227
  result = (OGRDataSourceShadow *)GetOpenDS(arg1);
 
10228
  
 
10229
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRDataSourceShadow, 0);
 
10230
  
 
10231
  return;
 
10232
fail:
 
10233
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
8708
10234
}
8709
10235
 
8710
10236
 
8711
10237
ZEND_NAMED_FUNCTION(_wrap_Open) {
8712
 
    char *arg1 = (char *) 0 ;
8713
 
    int arg2 = (int) 0 ;
8714
 
    OGRDataSourceShadow *result;
8715
 
    zval **args[2];
8716
 
    int arg_count;
8717
 
    
8718
 
    SWIG_ResetError();
8719
 
    arg_count = ZEND_NUM_ARGS();
8720
 
    if(arg_count<1 || arg_count>2)
8721
 
    WRONG_PARAM_COUNT;
8722
 
    
8723
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
8724
 
    WRONG_PARAM_COUNT;
8725
 
    
8726
 
    {
8727
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
8728
 
        convert_to_string_ex(args[0]);
8729
 
        arg1 = (char *) Z_STRVAL_PP(args[0]);
8730
 
        /*@@*/;
8731
 
    }
8732
 
    if(arg_count > 1) {
8733
 
        {
8734
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
8735
 
            convert_to_long_ex(args[1]);
8736
 
            arg2 = (int) Z_LVAL_PP(args[1]);
8737
 
            /*@@*/;
8738
 
        }
8739
 
    }
8740
 
    result = (OGRDataSourceShadow *)Open((char const *)arg1,arg2);
8741
 
    
8742
 
    {
8743
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRDataSourceShadow, 1);
8744
 
    }
8745
 
    /* Wrap this return value */
8746
 
    {
8747
 
        /* ALTERNATIVE Constructor, make an object wrapper */
8748
 
        zval *obj, *_cPtr;
8749
 
        MAKE_STD_ZVAL(obj);
8750
 
        MAKE_STD_ZVAL(_cPtr);
8751
 
        *_cPtr = *return_value;
8752
 
        INIT_ZVAL(*return_value);
8753
 
        object_init_ex(obj,ptr_ce_swig_DataSource);
8754
 
        add_property_zval(obj,"_cPtr",_cPtr);
8755
 
        *return_value=*obj;
8756
 
    }
8757
 
    return;
8758
 
    fail:
8759
 
    zend_error(ErrorCode(),ErrorMsg());
 
10238
  char *arg1 = (char *) 0 ;
 
10239
  int arg2 = (int) 0 ;
 
10240
  zval **args[2];
 
10241
  int arg_count;
 
10242
  OGRDataSourceShadow *result = 0 ;
 
10243
  
 
10244
  SWIG_ResetError();
 
10245
  arg_count = ZEND_NUM_ARGS();
 
10246
  if(arg_count<1 || arg_count>2 ||
 
10247
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
10248
  WRONG_PARAM_COUNT;
 
10249
  
 
10250
  
 
10251
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
10252
  if ((*args[0])->type==IS_NULL) {
 
10253
    arg1 = (char *) 0;
 
10254
  } else {
 
10255
    convert_to_string_ex(args[0]);
 
10256
    arg1 = (char *) Z_STRVAL_PP(args[0]);
 
10257
  }
 
10258
  /*@SWIG@*/;
 
10259
  
 
10260
  if(arg_count > 1) {
 
10261
    /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
10262
    convert_to_long_ex(args[1]);
 
10263
    arg2 = (int) Z_LVAL_PP(args[1]);
 
10264
    /*@SWIG@*/;
 
10265
    
 
10266
  }
 
10267
  result = (OGRDataSourceShadow *)Open((char const *)arg1,arg2);
 
10268
  
 
10269
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRDataSourceShadow, 1);
 
10270
  
 
10271
  return;
 
10272
fail:
 
10273
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
8760
10274
}
8761
10275
 
8762
10276
 
8763
10277
ZEND_NAMED_FUNCTION(_wrap_OpenShared) {
8764
 
    char *arg1 = (char *) 0 ;
8765
 
    int arg2 = (int) 0 ;
8766
 
    OGRDataSourceShadow *result;
8767
 
    zval **args[2];
8768
 
    int arg_count;
8769
 
    
8770
 
    SWIG_ResetError();
8771
 
    arg_count = ZEND_NUM_ARGS();
8772
 
    if(arg_count<1 || arg_count>2)
8773
 
    WRONG_PARAM_COUNT;
8774
 
    
8775
 
    if(zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
8776
 
    WRONG_PARAM_COUNT;
8777
 
    
8778
 
    {
8779
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
8780
 
        convert_to_string_ex(args[0]);
8781
 
        arg1 = (char *) Z_STRVAL_PP(args[0]);
8782
 
        /*@@*/;
8783
 
    }
8784
 
    if(arg_count > 1) {
8785
 
        {
8786
 
            /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
8787
 
            convert_to_long_ex(args[1]);
8788
 
            arg2 = (int) Z_LVAL_PP(args[1]);
8789
 
            /*@@*/;
8790
 
        }
8791
 
    }
8792
 
    result = (OGRDataSourceShadow *)OpenShared((char const *)arg1,arg2);
8793
 
    
8794
 
    {
8795
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRDataSourceShadow, 1);
8796
 
    }
8797
 
    /* Wrap this return value */
8798
 
    {
8799
 
        /* ALTERNATIVE Constructor, make an object wrapper */
8800
 
        zval *obj, *_cPtr;
8801
 
        MAKE_STD_ZVAL(obj);
8802
 
        MAKE_STD_ZVAL(_cPtr);
8803
 
        *_cPtr = *return_value;
8804
 
        INIT_ZVAL(*return_value);
8805
 
        object_init_ex(obj,ptr_ce_swig_DataSource);
8806
 
        add_property_zval(obj,"_cPtr",_cPtr);
8807
 
        *return_value=*obj;
8808
 
    }
8809
 
    return;
8810
 
    fail:
8811
 
    zend_error(ErrorCode(),ErrorMsg());
 
10278
  char *arg1 = (char *) 0 ;
 
10279
  int arg2 = (int) 0 ;
 
10280
  zval **args[2];
 
10281
  int arg_count;
 
10282
  OGRDataSourceShadow *result = 0 ;
 
10283
  
 
10284
  SWIG_ResetError();
 
10285
  arg_count = ZEND_NUM_ARGS();
 
10286
  if(arg_count<1 || arg_count>2 ||
 
10287
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
10288
  WRONG_PARAM_COUNT;
 
10289
  
 
10290
  
 
10291
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
10292
  if ((*args[0])->type==IS_NULL) {
 
10293
    arg1 = (char *) 0;
 
10294
  } else {
 
10295
    convert_to_string_ex(args[0]);
 
10296
    arg1 = (char *) Z_STRVAL_PP(args[0]);
 
10297
  }
 
10298
  /*@SWIG@*/;
 
10299
  
 
10300
  if(arg_count > 1) {
 
10301
    /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
10302
    convert_to_long_ex(args[1]);
 
10303
    arg2 = (int) Z_LVAL_PP(args[1]);
 
10304
    /*@SWIG@*/;
 
10305
    
 
10306
  }
 
10307
  result = (OGRDataSourceShadow *)OpenShared((char const *)arg1,arg2);
 
10308
  
 
10309
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRDataSourceShadow, 1);
 
10310
  
 
10311
  return;
 
10312
fail:
 
10313
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
8812
10314
}
8813
10315
 
8814
10316
 
8815
10317
ZEND_NAMED_FUNCTION(_wrap_GetDriverByName) {
8816
 
    char *arg1 = (char *) 0 ;
8817
 
    OGRDriverShadow *result;
8818
 
    zval **args[1];
8819
 
    
8820
 
    SWIG_ResetError();
8821
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
8822
 
        WRONG_PARAM_COUNT;
8823
 
    }
8824
 
    
8825
 
    {
8826
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,23,CONVERT_STRING_IN@*/
8827
 
        convert_to_string_ex(args[0]);
8828
 
        arg1 = (char *) Z_STRVAL_PP(args[0]);
8829
 
        /*@@*/;
8830
 
    }
8831
 
    result = (OGRDriverShadow *)GetDriverByName((char const *)arg1);
8832
 
    
8833
 
    {
8834
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRDriverShadow, 0);
8835
 
    }
8836
 
    /* Wrap this return value */
8837
 
    {
8838
 
        /* ALTERNATIVE Constructor, make an object wrapper */
8839
 
        zval *obj, *_cPtr;
8840
 
        MAKE_STD_ZVAL(obj);
8841
 
        MAKE_STD_ZVAL(_cPtr);
8842
 
        *_cPtr = *return_value;
8843
 
        INIT_ZVAL(*return_value);
8844
 
        object_init_ex(obj,ptr_ce_swig_Driver);
8845
 
        add_property_zval(obj,"_cPtr",_cPtr);
8846
 
        *return_value=*obj;
8847
 
    }
8848
 
    return;
8849
 
    fail:
8850
 
    zend_error(ErrorCode(),ErrorMsg());
 
10318
  char *arg1 = (char *) 0 ;
 
10319
  zval **args[1];
 
10320
  OGRDriverShadow *result = 0 ;
 
10321
  
 
10322
  SWIG_ResetError();
 
10323
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
10324
    WRONG_PARAM_COUNT;
 
10325
  }
 
10326
  
 
10327
  
 
10328
  /*@SWIG:/usr/share/swig1.3/php/utils.i,26,CONVERT_STRING_IN@*/
 
10329
  if ((*args[0])->type==IS_NULL) {
 
10330
    arg1 = (char *) 0;
 
10331
  } else {
 
10332
    convert_to_string_ex(args[0]);
 
10333
    arg1 = (char *) Z_STRVAL_PP(args[0]);
 
10334
  }
 
10335
  /*@SWIG@*/;
 
10336
  
 
10337
  {
 
10338
    if (!arg1) {
 
10339
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
 
10340
    }
 
10341
  }
 
10342
  result = (OGRDriverShadow *)GetDriverByName((char const *)arg1);
 
10343
  
 
10344
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRDriverShadow, 0);
 
10345
  
 
10346
  return;
 
10347
fail:
 
10348
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
8851
10349
}
8852
10350
 
8853
10351
 
8854
10352
ZEND_NAMED_FUNCTION(_wrap_GetDriver) {
8855
 
    int arg1 ;
8856
 
    OGRDriverShadow *result;
8857
 
    zval **args[1];
8858
 
    
8859
 
    SWIG_ResetError();
8860
 
    if(((ZEND_NUM_ARGS() )!= 1) || (zend_get_parameters_array_ex(1, args)!= SUCCESS)) {
8861
 
        WRONG_PARAM_COUNT;
8862
 
    }
8863
 
    
8864
 
    {
8865
 
        /*@/home/kruland/opt/share/swig/1.3.26/php4/utils.i,4,CONVERT_INT_IN@*/
8866
 
        convert_to_long_ex(args[0]);
8867
 
        arg1 = (int) Z_LVAL_PP(args[0]);
8868
 
        /*@@*/;
8869
 
    }
8870
 
    result = (OGRDriverShadow *)GetDriver(arg1);
8871
 
    
8872
 
    {
8873
 
        SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRDriverShadow, 0);
8874
 
    }
8875
 
    /* Wrap this return value */
8876
 
    {
8877
 
        /* ALTERNATIVE Constructor, make an object wrapper */
8878
 
        zval *obj, *_cPtr;
8879
 
        MAKE_STD_ZVAL(obj);
8880
 
        MAKE_STD_ZVAL(_cPtr);
8881
 
        *_cPtr = *return_value;
8882
 
        INIT_ZVAL(*return_value);
8883
 
        object_init_ex(obj,ptr_ce_swig_Driver);
8884
 
        add_property_zval(obj,"_cPtr",_cPtr);
8885
 
        *return_value=*obj;
8886
 
    }
8887
 
    return;
8888
 
    fail:
8889
 
    zend_error(ErrorCode(),ErrorMsg());
8890
 
}
8891
 
 
8892
 
 
8893
 
/* NEW Destructor style */
 
10353
  int arg1 ;
 
10354
  zval **args[1];
 
10355
  OGRDriverShadow *result = 0 ;
 
10356
  
 
10357
  SWIG_ResetError();
 
10358
  if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {
 
10359
    WRONG_PARAM_COUNT;
 
10360
  }
 
10361
  
 
10362
  
 
10363
  /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
10364
  convert_to_long_ex(args[0]);
 
10365
  arg1 = (int) Z_LVAL_PP(args[0]);
 
10366
  /*@SWIG@*/;
 
10367
  
 
10368
  result = (OGRDriverShadow *)GetDriver(arg1);
 
10369
  
 
10370
  SWIG_SetPointerZval(return_value, (void *)result, SWIGTYPE_p_OGRDriverShadow, 0);
 
10371
  
 
10372
  return;
 
10373
fail:
 
10374
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
10375
}
 
10376
 
 
10377
 
 
10378
ZEND_NAMED_FUNCTION(_wrap_GeneralCmdLineProcessor) {
 
10379
  char **arg1 = (char **) 0 ;
 
10380
  int arg2 = (int) 0 ;
 
10381
  zval **args[2];
 
10382
  int arg_count;
 
10383
  char **result = 0 ;
 
10384
  
 
10385
  SWIG_ResetError();
 
10386
  arg_count = ZEND_NUM_ARGS();
 
10387
  if(arg_count<1 || arg_count>2 ||
 
10388
    zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
 
10389
  WRONG_PARAM_COUNT;
 
10390
  
 
10391
  {
 
10392
    /* %typemap(in) char **options */
 
10393
    zend_error(E_ERROR,"Typemap (in) char **options not properly defined");
 
10394
    //  int size = PySequence_Size(args[0]);
 
10395
    //  for (int i = 0; i < size; i++) {
 
10396
    //    char *pszItem = NULL;
 
10397
    //    if ( ! PyArg_Parse( PySequence_GetItem(args[0],i), "s", &pszItem ) ) {
 
10398
    //      PyErr_SetString(PyExc_TypeError,"sequence must contain strings");
 
10399
    //      SWIG_fail;
 
10400
    //    }
 
10401
    //    arg1 = CSLAddString( arg1, pszItem );
 
10402
    //  }
 
10403
  }
 
10404
  if(arg_count > 1) {
 
10405
    /*@SWIG:/usr/share/swig1.3/php/utils.i,7,CONVERT_INT_IN@*/
 
10406
    convert_to_long_ex(args[1]);
 
10407
    arg2 = (int) Z_LVAL_PP(args[1]);
 
10408
    /*@SWIG@*/;
 
10409
    
 
10410
  }
 
10411
  result = (char **)GeneralCmdLineProcessor(arg1,arg2);
 
10412
  {
 
10413
    /* %typemap(out) char ** -> ( string ) */
 
10414
    char **stringarray = result;
 
10415
    if ( stringarray == NULL ) {
 
10416
      RETVAL_NULL();
 
10417
    }
 
10418
    else {
 
10419
      int len = CSLCount( stringarray );
 
10420
      array_init(return_value);
 
10421
      for ( int i = 0; i < len; ++i, ++stringarray ) {
 
10422
        add_next_index_string( return_value, *stringarray, 1 );
 
10423
      }
 
10424
    }
 
10425
  }
 
10426
  {
 
10427
    /* %typemap(freearg) char **options */
 
10428
    CSLDestroy( arg1 );
 
10429
  }
 
10430
  return;
 
10431
fail:
 
10432
  {
 
10433
    /* %typemap(freearg) char **options */
 
10434
    CSLDestroy( arg1 );
 
10435
  }
 
10436
  zend_error_noreturn(SWIG_ErrorCode(),"%s",SWIG_ErrorMsg());
 
10437
}
 
10438
 
 
10439
 
8894
10440
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_GIntBig) {
8895
 
  /* bah! No destructor for this simple type!! */
 
10441
  /* No destructor for simple type _p_GIntBig */
 
10442
  efree(rsrc->ptr);
8896
10443
}
8897
 
/* NEW Destructor style */
8898
10444
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_double) {
8899
 
  /* bah! No destructor for this simple type!! */
8900
 
}
8901
 
/* NEW Destructor style */
 
10445
  /* No destructor for simple type _p_double */
 
10446
  efree(rsrc->ptr);
 
10447
}
 
10448
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_p_double) {
 
10449
  /* No destructor for simple type _p_p_double */
 
10450
  efree(rsrc->ptr);
 
10451
}
8902
10452
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_p_char) {
8903
 
  /* bah! No destructor for this simple type!! */
 
10453
  /* No destructor for simple type _p_p_char */
 
10454
  efree(rsrc->ptr);
8904
10455
}
8905
 
/* NEW Destructor style */
8906
10456
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_char) {
8907
 
  /* bah! No destructor for this simple type!! */
8908
 
}
8909
 
/* NEW Destructor style */
8910
 
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_p_OGRGeometryShadow) {
8911
 
  /* bah! No destructor for this simple type!! */
8912
 
}
8913
 
/* NEW Destructor style */
 
10457
  /* No destructor for simple type _p_char */
 
10458
  efree(rsrc->ptr);
 
10459
}
 
10460
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_p_p_char) {
 
10461
  /* No destructor for simple type _p_p_p_char */
 
10462
  efree(rsrc->ptr);
 
10463
}
 
10464
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_OGRFeatureShadow) {
 
10465
  __wrap_delete_Feature(rsrc, SWIGTYPE_p_OGRFeatureShadow->name TSRMLS_CC);
 
10466
}
8914
10467
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_OGRGeometryShadow) {
8915
 
  /* has destructor: __wrap_delete_Geometry */
8916
10468
  __wrap_delete_Geometry(rsrc, SWIGTYPE_p_OGRGeometryShadow->name TSRMLS_CC);
8917
10469
}
8918
 
/* NEW Destructor style */
8919
 
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_p_OSRSpatialReferenceShadow) {
8920
 
  /* bah! No destructor for this simple type!! */
8921
 
}
8922
 
/* NEW Destructor style */
8923
10470
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_OSRSpatialReferenceShadow) {
8924
 
  /* bah! No destructor for this wrapped class!! */
8925
 
}
8926
 
/* NEW Destructor style */
8927
 
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_p_OGRDataSourceShadow) {
8928
 
  /* bah! No destructor for this simple type!! */
8929
 
}
8930
 
/* NEW Destructor style */
 
10471
  /* No destructor for class SpatialReference */
 
10472
  efree(rsrc->ptr);
 
10473
}
8931
10474
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_OGRDataSourceShadow) {
8932
 
  /* has destructor: __wrap_delete_DataSource */
8933
10475
  __wrap_delete_DataSource(rsrc, SWIGTYPE_p_OGRDataSourceShadow->name TSRMLS_CC);
8934
10476
}
8935
 
/* NEW Destructor style */
8936
 
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_OGRFeatureShadow) {
8937
 
  /* has destructor: __wrap_delete_Feature */
8938
 
  __wrap_delete_Feature(rsrc, SWIGTYPE_p_OGRFeatureShadow->name TSRMLS_CC);
8939
 
}
8940
 
/* NEW Destructor style */
8941
 
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_p_OGRFeatureShadow) {
8942
 
  /* bah! No destructor for this simple type!! */
8943
 
}
8944
 
/* NEW Destructor style */
 
10477
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_p_OGRGeometryShadow) {
 
10478
  /* No destructor for simple type _p_p_OGRGeometryShadow */
 
10479
  efree(rsrc->ptr);
 
10480
}
8945
10481
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_int) {
8946
 
  /* bah! No destructor for this simple type!! */
 
10482
  /* No destructor for simple type _int */
 
10483
  efree(rsrc->ptr);
8947
10484
}
8948
 
/* NEW Destructor style */
8949
10485
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_int) {
8950
 
  /* bah! No destructor for this simple type!! */
8951
 
}
8952
 
/* NEW Destructor style */
 
10486
  /* No destructor for simple type _p_int */
 
10487
  efree(rsrc->ptr);
 
10488
}
 
10489
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_OGRFieldDefnShadow) {
 
10490
  __wrap_delete_FieldDefn(rsrc, SWIGTYPE_p_OGRFieldDefnShadow->name TSRMLS_CC);
 
10491
}
 
10492
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_OGRFeatureDefnShadow) {
 
10493
  __wrap_delete_FeatureDefn(rsrc, SWIGTYPE_p_OGRFeatureDefnShadow->name TSRMLS_CC);
 
10494
}
8953
10495
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_p_OGRLayerShadow) {
8954
 
  /* bah! No destructor for this simple type!! */
 
10496
  /* No destructor for simple type _p_p_OGRLayerShadow */
 
10497
  efree(rsrc->ptr);
8955
10498
}
8956
 
/* NEW Destructor style */
8957
10499
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_OGRLayerShadow) {
8958
 
  /* bah! No destructor for this wrapped class!! */
8959
 
}
8960
 
/* NEW Destructor style */
8961
 
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_p_OGRDriverShadow) {
8962
 
  /* bah! No destructor for this simple type!! */
8963
 
}
8964
 
/* NEW Destructor style */
 
10500
  /* No destructor for class Layer */
 
10501
  efree(rsrc->ptr);
 
10502
}
8965
10503
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_OGRDriverShadow) {
8966
 
  /* bah! No destructor for this wrapped class!! */
8967
 
}
8968
 
/* NEW Destructor style */
8969
 
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_OGRFeatureDefnShadow) {
8970
 
  /* has destructor: __wrap_delete_FeatureDefn */
8971
 
  __wrap_delete_FeatureDefn(rsrc, SWIGTYPE_p_OGRFeatureDefnShadow->name TSRMLS_CC);
8972
 
}
8973
 
/* NEW Destructor style */
8974
 
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_OGRFieldDefnShadow) {
8975
 
  /* has destructor: __wrap_delete_FieldDefn */
8976
 
  __wrap_delete_FieldDefn(rsrc, SWIGTYPE_p_OGRFieldDefnShadow->name TSRMLS_CC);
8977
 
}
8978
 
/* NEW Destructor style */
8979
 
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_p_OGRFieldDefnShadow) {
8980
 
  /* bah! No destructor for this simple type!! */
8981
 
}
8982
 
/* NEW Destructor style */
8983
 
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_p_OGRFeatureDefnShadow) {
8984
 
  /* bah! No destructor for this simple type!! */
8985
 
}
8986
 
/* NEW Destructor style */
 
10504
  /* No destructor for class Driver */
 
10505
  efree(rsrc->ptr);
 
10506
}
 
10507
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_p_int) {
 
10508
  /* No destructor for simple type _p_p_int */
 
10509
  efree(rsrc->ptr);
 
10510
}
8987
10511
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_OSRCoordinateTransformationShadow) {
8988
 
  /* bah! No destructor for this wrapped class!! */
8989
 
}
8990
 
/* NEW Destructor style */
8991
 
static ZEND_RSRC_DTOR_FUNC(_wrap_destroy_p_p_OSRCoordinateTransformationShadow) {
8992
 
  /* bah! No destructor for this simple type!! */
 
10512
  /* No destructor for class CoordinateTransformation */
 
10513
  efree(rsrc->ptr);
8993
10514
}
8994
10515
/* end wrapper section */
 
10516
/* class entry subsection */
 
10517
 
 
10518
 
 
10519
/* entry subsection */
 
10520
/* Every non-class user visible function must have an entry here */
 
10521
static zend_function_entry ogr_functions[] = {
 
10522
 SWIG_ZEND_NAMED_FE(driver_name_get,_wrap_Driver_name_get,NULL)
 
10523
 SWIG_ZEND_NAMED_FE(driver_createdatasource,_wrap_Driver_CreateDataSource,NULL)
 
10524
 SWIG_ZEND_NAMED_FE(driver_copydatasource,_wrap_Driver_CopyDataSource,NULL)
 
10525
 SWIG_ZEND_NAMED_FE(driver_open,_wrap_Driver_Open,NULL)
 
10526
 SWIG_ZEND_NAMED_FE(driver_deletedatasource,_wrap_Driver_DeleteDataSource,NULL)
 
10527
 SWIG_ZEND_NAMED_FE(driver_testcapability,_wrap_Driver_TestCapability,NULL)
 
10528
 SWIG_ZEND_NAMED_FE(driver_getname,_wrap_Driver_GetName,NULL)
 
10529
 SWIG_ZEND_NAMED_FE(driver_register,_wrap_Driver_Register,NULL)
 
10530
 SWIG_ZEND_NAMED_FE(driver_deregister,_wrap_Driver_Deregister,NULL)
 
10531
 SWIG_ZEND_NAMED_FE(datasource_name_get,_wrap_DataSource_name_get,NULL)
 
10532
 SWIG_ZEND_NAMED_FE(datasource_getrefcount,_wrap_DataSource_GetRefCount,NULL)
 
10533
 SWIG_ZEND_NAMED_FE(datasource_getsummaryrefcount,_wrap_DataSource_GetSummaryRefCount,NULL)
 
10534
 SWIG_ZEND_NAMED_FE(datasource_getlayercount,_wrap_DataSource_GetLayerCount,NULL)
 
10535
 SWIG_ZEND_NAMED_FE(datasource_getdriver,_wrap_DataSource_GetDriver,NULL)
 
10536
 SWIG_ZEND_NAMED_FE(datasource_getname,_wrap_DataSource_GetName,NULL)
 
10537
 SWIG_ZEND_NAMED_FE(datasource_deletelayer,_wrap_DataSource_DeleteLayer,NULL)
 
10538
 SWIG_ZEND_NAMED_FE(datasource_createlayer,_wrap_DataSource_CreateLayer,NULL)
 
10539
 SWIG_ZEND_NAMED_FE(datasource_copylayer,_wrap_DataSource_CopyLayer,NULL)
 
10540
 SWIG_ZEND_NAMED_FE(datasource_getlayerbyindex,_wrap_DataSource_GetLayerByIndex,NULL)
 
10541
 SWIG_ZEND_NAMED_FE(datasource_getlayerbyname,_wrap_DataSource_GetLayerByName,NULL)
 
10542
 SWIG_ZEND_NAMED_FE(datasource_testcapability,_wrap_DataSource_TestCapability,NULL)
 
10543
 SWIG_ZEND_NAMED_FE(datasource_executesql,_wrap_DataSource_ExecuteSQL,NULL)
 
10544
 SWIG_ZEND_NAMED_FE(datasource_releaseresultset,_wrap_DataSource_ReleaseResultSet,NULL)
 
10545
 SWIG_ZEND_NAMED_FE(layer_getrefcount,_wrap_Layer_GetRefCount,NULL)
 
10546
 SWIG_ZEND_NAMED_FE(layer_setspatialfilter,_wrap_Layer_SetSpatialFilter,NULL)
 
10547
 SWIG_ZEND_NAMED_FE(layer_setspatialfilterrect,_wrap_Layer_SetSpatialFilterRect,NULL)
 
10548
 SWIG_ZEND_NAMED_FE(layer_getspatialfilter,_wrap_Layer_GetSpatialFilter,NULL)
 
10549
 SWIG_ZEND_NAMED_FE(layer_setattributefilter,_wrap_Layer_SetAttributeFilter,NULL)
 
10550
 SWIG_ZEND_NAMED_FE(layer_resetreading,_wrap_Layer_ResetReading,NULL)
 
10551
 SWIG_ZEND_NAMED_FE(layer_getname,_wrap_Layer_GetName,NULL)
 
10552
 SWIG_ZEND_NAMED_FE(layer_getgeomtype,_wrap_Layer_GetGeomType,NULL)
 
10553
 SWIG_ZEND_NAMED_FE(layer_getgeometrycolumn,_wrap_Layer_GetGeometryColumn,NULL)
 
10554
 SWIG_ZEND_NAMED_FE(layer_getfidcolumn,_wrap_Layer_GetFIDColumn,NULL)
 
10555
 SWIG_ZEND_NAMED_FE(layer_getfeature,_wrap_Layer_GetFeature,NULL)
 
10556
 SWIG_ZEND_NAMED_FE(layer_getnextfeature,_wrap_Layer_GetNextFeature,NULL)
 
10557
 SWIG_ZEND_NAMED_FE(layer_setnextbyindex,_wrap_Layer_SetNextByIndex,NULL)
 
10558
 SWIG_ZEND_NAMED_FE(layer_setfeature,_wrap_Layer_SetFeature,NULL)
 
10559
 SWIG_ZEND_NAMED_FE(layer_createfeature,_wrap_Layer_CreateFeature,NULL)
 
10560
 SWIG_ZEND_NAMED_FE(layer_deletefeature,_wrap_Layer_DeleteFeature,NULL)
 
10561
 SWIG_ZEND_NAMED_FE(layer_synctodisk,_wrap_Layer_SyncToDisk,NULL)
 
10562
 SWIG_ZEND_NAMED_FE(layer_getlayerdefn,_wrap_Layer_GetLayerDefn,NULL)
 
10563
 SWIG_ZEND_NAMED_FE(layer_getfeaturecount,_wrap_Layer_GetFeatureCount,NULL)
 
10564
 SWIG_ZEND_NAMED_FE(layer_getextent,_wrap_Layer_GetExtent,NULL)
 
10565
 SWIG_ZEND_NAMED_FE(layer_testcapability,_wrap_Layer_TestCapability,NULL)
 
10566
 SWIG_ZEND_NAMED_FE(layer_createfield,_wrap_Layer_CreateField,NULL)
 
10567
 SWIG_ZEND_NAMED_FE(layer_starttransaction,_wrap_Layer_StartTransaction,NULL)
 
10568
 SWIG_ZEND_NAMED_FE(layer_committransaction,_wrap_Layer_CommitTransaction,NULL)
 
10569
 SWIG_ZEND_NAMED_FE(layer_rollbacktransaction,_wrap_Layer_RollbackTransaction,NULL)
 
10570
 SWIG_ZEND_NAMED_FE(layer_getspatialref,_wrap_Layer_GetSpatialRef,NULL)
 
10571
 SWIG_ZEND_NAMED_FE(layer_getfeaturesread,_wrap_Layer_GetFeaturesRead,NULL)
 
10572
 SWIG_ZEND_NAMED_FE(layer_setignoredfields,_wrap_Layer_SetIgnoredFields,NULL)
 
10573
 SWIG_ZEND_NAMED_FE(new_feature,_wrap_new_Feature,NULL)
 
10574
 SWIG_ZEND_NAMED_FE(feature_getdefnref,_wrap_Feature_GetDefnRef,NULL)
 
10575
 SWIG_ZEND_NAMED_FE(feature_setgeometry,_wrap_Feature_SetGeometry,NULL)
 
10576
 SWIG_ZEND_NAMED_FE(feature_setgeometrydirectly,_wrap_Feature_SetGeometryDirectly,NULL)
 
10577
 SWIG_ZEND_NAMED_FE(feature_getgeometryref,_wrap_Feature_GetGeometryRef,NULL)
 
10578
 SWIG_ZEND_NAMED_FE(feature_c_clone,_wrap_Feature_c_Clone,NULL)
 
10579
 SWIG_ZEND_NAMED_FE(feature_equal,_wrap_Feature_Equal,NULL)
 
10580
 SWIG_ZEND_NAMED_FE(feature_getfieldcount,_wrap_Feature_GetFieldCount,NULL)
 
10581
 SWIG_ZEND_NAMED_FE(feature_getfielddefnref,_wrap_Feature_GetFieldDefnRef,NULL)
 
10582
 SWIG_ZEND_NAMED_FE(feature_getfieldasstring,_wrap_Feature_GetFieldAsString,NULL)
 
10583
 SWIG_ZEND_NAMED_FE(feature_getfieldasinteger,_wrap_Feature_GetFieldAsInteger,NULL)
 
10584
 SWIG_ZEND_NAMED_FE(feature_getfieldasdouble,_wrap_Feature_GetFieldAsDouble,NULL)
 
10585
 SWIG_ZEND_NAMED_FE(feature_getfieldasdatetime,_wrap_Feature_GetFieldAsDateTime,NULL)
 
10586
 SWIG_ZEND_NAMED_FE(feature_getfieldasintegerlist,_wrap_Feature_GetFieldAsIntegerList,NULL)
 
10587
 SWIG_ZEND_NAMED_FE(feature_getfieldasdoublelist,_wrap_Feature_GetFieldAsDoubleList,NULL)
 
10588
 SWIG_ZEND_NAMED_FE(feature_getfieldasstringlist,_wrap_Feature_GetFieldAsStringList,NULL)
 
10589
 SWIG_ZEND_NAMED_FE(feature_isfieldset,_wrap_Feature_IsFieldSet,NULL)
 
10590
 SWIG_ZEND_NAMED_FE(feature_getfieldindex,_wrap_Feature_GetFieldIndex,NULL)
 
10591
 SWIG_ZEND_NAMED_FE(feature_getfid,_wrap_Feature_GetFID,NULL)
 
10592
 SWIG_ZEND_NAMED_FE(feature_setfid,_wrap_Feature_SetFID,NULL)
 
10593
 SWIG_ZEND_NAMED_FE(feature_dumpreadable,_wrap_Feature_DumpReadable,NULL)
 
10594
 SWIG_ZEND_NAMED_FE(feature_unsetfield,_wrap_Feature_UnsetField,NULL)
 
10595
 SWIG_ZEND_NAMED_FE(feature_setfield,_wrap_Feature_SetField,NULL)
 
10596
 SWIG_ZEND_NAMED_FE(feature_setfieldintegerlist,_wrap_Feature_SetFieldIntegerList,NULL)
 
10597
 SWIG_ZEND_NAMED_FE(feature_setfielddoublelist,_wrap_Feature_SetFieldDoubleList,NULL)
 
10598
 SWIG_ZEND_NAMED_FE(feature_setfieldstringlist,_wrap_Feature_SetFieldStringList,NULL)
 
10599
 SWIG_ZEND_NAMED_FE(feature_setfrom,_wrap_Feature_SetFrom,NULL)
 
10600
 SWIG_ZEND_NAMED_FE(feature_getstylestring,_wrap_Feature_GetStyleString,NULL)
 
10601
 SWIG_ZEND_NAMED_FE(feature_setstylestring,_wrap_Feature_SetStyleString,NULL)
 
10602
 SWIG_ZEND_NAMED_FE(feature_getfieldtype,_wrap_Feature_GetFieldType,NULL)
 
10603
 SWIG_ZEND_NAMED_FE(new_featuredefn,_wrap_new_FeatureDefn,NULL)
 
10604
 SWIG_ZEND_NAMED_FE(featuredefn_getname,_wrap_FeatureDefn_GetName,NULL)
 
10605
 SWIG_ZEND_NAMED_FE(featuredefn_getfieldcount,_wrap_FeatureDefn_GetFieldCount,NULL)
 
10606
 SWIG_ZEND_NAMED_FE(featuredefn_getfielddefn,_wrap_FeatureDefn_GetFieldDefn,NULL)
 
10607
 SWIG_ZEND_NAMED_FE(featuredefn_getfieldindex,_wrap_FeatureDefn_GetFieldIndex,NULL)
 
10608
 SWIG_ZEND_NAMED_FE(featuredefn_addfielddefn,_wrap_FeatureDefn_AddFieldDefn,NULL)
 
10609
 SWIG_ZEND_NAMED_FE(featuredefn_getgeomtype,_wrap_FeatureDefn_GetGeomType,NULL)
 
10610
 SWIG_ZEND_NAMED_FE(featuredefn_setgeomtype,_wrap_FeatureDefn_SetGeomType,NULL)
 
10611
 SWIG_ZEND_NAMED_FE(featuredefn_getreferencecount,_wrap_FeatureDefn_GetReferenceCount,NULL)
 
10612
 SWIG_ZEND_NAMED_FE(featuredefn_isgeometryignored,_wrap_FeatureDefn_IsGeometryIgnored,NULL)
 
10613
 SWIG_ZEND_NAMED_FE(featuredefn_setgeometryignored,_wrap_FeatureDefn_SetGeometryIgnored,NULL)
 
10614
 SWIG_ZEND_NAMED_FE(featuredefn_isstyleignored,_wrap_FeatureDefn_IsStyleIgnored,NULL)
 
10615
 SWIG_ZEND_NAMED_FE(featuredefn_setstyleignored,_wrap_FeatureDefn_SetStyleIgnored,NULL)
 
10616
 SWIG_ZEND_NAMED_FE(new_fielddefn,_wrap_new_FieldDefn,NULL)
 
10617
 SWIG_ZEND_NAMED_FE(fielddefn_getname,_wrap_FieldDefn_GetName,NULL)
 
10618
 SWIG_ZEND_NAMED_FE(fielddefn_getnameref,_wrap_FieldDefn_GetNameRef,NULL)
 
10619
 SWIG_ZEND_NAMED_FE(fielddefn_setname,_wrap_FieldDefn_SetName,NULL)
 
10620
 SWIG_ZEND_NAMED_FE(fielddefn_gettype,_wrap_FieldDefn_GetType,NULL)
 
10621
 SWIG_ZEND_NAMED_FE(fielddefn_settype,_wrap_FieldDefn_SetType,NULL)
 
10622
 SWIG_ZEND_NAMED_FE(fielddefn_getjustify,_wrap_FieldDefn_GetJustify,NULL)
 
10623
 SWIG_ZEND_NAMED_FE(fielddefn_setjustify,_wrap_FieldDefn_SetJustify,NULL)
 
10624
 SWIG_ZEND_NAMED_FE(fielddefn_getwidth,_wrap_FieldDefn_GetWidth,NULL)
 
10625
 SWIG_ZEND_NAMED_FE(fielddefn_setwidth,_wrap_FieldDefn_SetWidth,NULL)
 
10626
 SWIG_ZEND_NAMED_FE(fielddefn_getprecision,_wrap_FieldDefn_GetPrecision,NULL)
 
10627
 SWIG_ZEND_NAMED_FE(fielddefn_setprecision,_wrap_FieldDefn_SetPrecision,NULL)
 
10628
 SWIG_ZEND_NAMED_FE(fielddefn_gettypename,_wrap_FieldDefn_GetTypeName,NULL)
 
10629
 SWIG_ZEND_NAMED_FE(fielddefn_getfieldtypename,_wrap_FieldDefn_GetFieldTypeName,NULL)
 
10630
 SWIG_ZEND_NAMED_FE(fielddefn_isignored,_wrap_FieldDefn_IsIgnored,NULL)
 
10631
 SWIG_ZEND_NAMED_FE(fielddefn_setignored,_wrap_FieldDefn_SetIgnored,NULL)
 
10632
 SWIG_ZEND_NAMED_FE(creategeometryfromwkb,_wrap_CreateGeometryFromWkb,NULL)
 
10633
 SWIG_ZEND_NAMED_FE(creategeometryfromwkt,_wrap_CreateGeometryFromWkt,NULL)
 
10634
 SWIG_ZEND_NAMED_FE(creategeometryfromgml,_wrap_CreateGeometryFromGML,NULL)
 
10635
 SWIG_ZEND_NAMED_FE(creategeometryfromjson,_wrap_CreateGeometryFromJson,NULL)
 
10636
 SWIG_ZEND_NAMED_FE(buildpolygonfromedges,_wrap_BuildPolygonFromEdges,NULL)
 
10637
 SWIG_ZEND_NAMED_FE(approximatearcangles,_wrap_ApproximateArcAngles,NULL)
 
10638
 SWIG_ZEND_NAMED_FE(forcetopolygon,_wrap_ForceToPolygon,NULL)
 
10639
 SWIG_ZEND_NAMED_FE(forcetomultipolygon,_wrap_ForceToMultiPolygon,NULL)
 
10640
 SWIG_ZEND_NAMED_FE(forcetomultipoint,_wrap_ForceToMultiPoint,NULL)
 
10641
 SWIG_ZEND_NAMED_FE(forcetomultilinestring,_wrap_ForceToMultiLineString,NULL)
 
10642
 SWIG_ZEND_NAMED_FE(new_geometry,_wrap_new_Geometry,NULL)
 
10643
 SWIG_ZEND_NAMED_FE(geometry_exporttowkt,_wrap_Geometry_ExportToWkt,NULL)
 
10644
 SWIG_ZEND_NAMED_FE(geometry_exporttowkb,_wrap_Geometry_ExportToWkb,NULL)
 
10645
 SWIG_ZEND_NAMED_FE(geometry_exporttogml,_wrap_Geometry_ExportToGML,NULL)
 
10646
 SWIG_ZEND_NAMED_FE(geometry_exporttokml,_wrap_Geometry_ExportToKML,NULL)
 
10647
 SWIG_ZEND_NAMED_FE(geometry_exporttojson,_wrap_Geometry_ExportToJson,NULL)
 
10648
 SWIG_ZEND_NAMED_FE(geometry_addpoint,_wrap_Geometry_AddPoint,NULL)
 
10649
 SWIG_ZEND_NAMED_FE(geometry_addpoint_2d,_wrap_Geometry_AddPoint_2D,NULL)
 
10650
 SWIG_ZEND_NAMED_FE(geometry_addgeometrydirectly,_wrap_Geometry_AddGeometryDirectly,NULL)
 
10651
 SWIG_ZEND_NAMED_FE(geometry_addgeometry,_wrap_Geometry_AddGeometry,NULL)
 
10652
 SWIG_ZEND_NAMED_FE(geometry_c_clone,_wrap_Geometry_c_Clone,NULL)
 
10653
 SWIG_ZEND_NAMED_FE(geometry_getgeometrytype,_wrap_Geometry_GetGeometryType,NULL)
 
10654
 SWIG_ZEND_NAMED_FE(geometry_getgeometryname,_wrap_Geometry_GetGeometryName,NULL)
 
10655
 SWIG_ZEND_NAMED_FE(geometry_length,_wrap_Geometry_Length,NULL)
 
10656
 SWIG_ZEND_NAMED_FE(geometry_area,_wrap_Geometry_Area,NULL)
 
10657
 SWIG_ZEND_NAMED_FE(geometry_getarea,_wrap_Geometry_GetArea,NULL)
 
10658
 SWIG_ZEND_NAMED_FE(geometry_getpointcount,_wrap_Geometry_GetPointCount,NULL)
 
10659
 SWIG_ZEND_NAMED_FE(geometry_getx,_wrap_Geometry_GetX,NULL)
 
10660
 SWIG_ZEND_NAMED_FE(geometry_gety,_wrap_Geometry_GetY,NULL)
 
10661
 SWIG_ZEND_NAMED_FE(geometry_getz,_wrap_Geometry_GetZ,NULL)
 
10662
 SWIG_ZEND_NAMED_FE(geometry_getpoint,_wrap_Geometry_GetPoint,NULL)
 
10663
 SWIG_ZEND_NAMED_FE(geometry_getpoint_2d,_wrap_Geometry_GetPoint_2D,NULL)
 
10664
 SWIG_ZEND_NAMED_FE(geometry_getgeometrycount,_wrap_Geometry_GetGeometryCount,NULL)
 
10665
 SWIG_ZEND_NAMED_FE(geometry_setpoint,_wrap_Geometry_SetPoint,NULL)
 
10666
 SWIG_ZEND_NAMED_FE(geometry_setpoint_2d,_wrap_Geometry_SetPoint_2D,NULL)
 
10667
 SWIG_ZEND_NAMED_FE(geometry_getgeometryref,_wrap_Geometry_GetGeometryRef,NULL)
 
10668
 SWIG_ZEND_NAMED_FE(geometry_simplify,_wrap_Geometry_Simplify,NULL)
 
10669
 SWIG_ZEND_NAMED_FE(geometry_boundary,_wrap_Geometry_Boundary,NULL)
 
10670
 SWIG_ZEND_NAMED_FE(geometry_getboundary,_wrap_Geometry_GetBoundary,NULL)
 
10671
 SWIG_ZEND_NAMED_FE(geometry_convexhull,_wrap_Geometry_ConvexHull,NULL)
 
10672
 SWIG_ZEND_NAMED_FE(geometry_buffer,_wrap_Geometry_Buffer,NULL)
 
10673
 SWIG_ZEND_NAMED_FE(geometry_intersection,_wrap_Geometry_Intersection,NULL)
 
10674
 SWIG_ZEND_NAMED_FE(geometry_union,_wrap_Geometry_Union,NULL)
 
10675
 SWIG_ZEND_NAMED_FE(geometry_unioncascaded,_wrap_Geometry_UnionCascaded,NULL)
 
10676
 SWIG_ZEND_NAMED_FE(geometry_difference,_wrap_Geometry_Difference,NULL)
 
10677
 SWIG_ZEND_NAMED_FE(geometry_symdifference,_wrap_Geometry_SymDifference,NULL)
 
10678
 SWIG_ZEND_NAMED_FE(geometry_symmetricdifference,_wrap_Geometry_SymmetricDifference,NULL)
 
10679
 SWIG_ZEND_NAMED_FE(geometry_distance,_wrap_Geometry_Distance,NULL)
 
10680
 SWIG_ZEND_NAMED_FE(geometry_c_empty,_wrap_Geometry_c_Empty,NULL)
 
10681
 SWIG_ZEND_NAMED_FE(geometry_isempty,_wrap_Geometry_IsEmpty,NULL)
 
10682
 SWIG_ZEND_NAMED_FE(geometry_isvalid,_wrap_Geometry_IsValid,NULL)
 
10683
 SWIG_ZEND_NAMED_FE(geometry_issimple,_wrap_Geometry_IsSimple,NULL)
 
10684
 SWIG_ZEND_NAMED_FE(geometry_isring,_wrap_Geometry_IsRing,NULL)
 
10685
 SWIG_ZEND_NAMED_FE(geometry_intersects,_wrap_Geometry_Intersects,NULL)
 
10686
 SWIG_ZEND_NAMED_FE(geometry_intersect,_wrap_Geometry_Intersect,NULL)
 
10687
 SWIG_ZEND_NAMED_FE(geometry_equals,_wrap_Geometry_Equals,NULL)
 
10688
 SWIG_ZEND_NAMED_FE(geometry_equal,_wrap_Geometry_Equal,NULL)
 
10689
 SWIG_ZEND_NAMED_FE(geometry_disjoint,_wrap_Geometry_Disjoint,NULL)
 
10690
 SWIG_ZEND_NAMED_FE(geometry_touches,_wrap_Geometry_Touches,NULL)
 
10691
 SWIG_ZEND_NAMED_FE(geometry_crosses,_wrap_Geometry_Crosses,NULL)
 
10692
 SWIG_ZEND_NAMED_FE(geometry_within,_wrap_Geometry_Within,NULL)
 
10693
 SWIG_ZEND_NAMED_FE(geometry_contains,_wrap_Geometry_Contains,NULL)
 
10694
 SWIG_ZEND_NAMED_FE(geometry_overlaps,_wrap_Geometry_Overlaps,NULL)
 
10695
 SWIG_ZEND_NAMED_FE(geometry_transformto,_wrap_Geometry_TransformTo,NULL)
 
10696
 SWIG_ZEND_NAMED_FE(geometry_transform,_wrap_Geometry_Transform,NULL)
 
10697
 SWIG_ZEND_NAMED_FE(geometry_getspatialreference,_wrap_Geometry_GetSpatialReference,NULL)
 
10698
 SWIG_ZEND_NAMED_FE(geometry_assignspatialreference,_wrap_Geometry_AssignSpatialReference,NULL)
 
10699
 SWIG_ZEND_NAMED_FE(geometry_closerings,_wrap_Geometry_CloseRings,NULL)
 
10700
 SWIG_ZEND_NAMED_FE(geometry_flattento2d,_wrap_Geometry_FlattenTo2D,NULL)
 
10701
 SWIG_ZEND_NAMED_FE(geometry_segmentize,_wrap_Geometry_Segmentize,NULL)
 
10702
 SWIG_ZEND_NAMED_FE(geometry_getenvelope,_wrap_Geometry_GetEnvelope,NULL)
 
10703
 SWIG_ZEND_NAMED_FE(geometry_centroid,_wrap_Geometry_Centroid,NULL)
 
10704
 SWIG_ZEND_NAMED_FE(geometry_wkbsize,_wrap_Geometry_WkbSize,NULL)
 
10705
 SWIG_ZEND_NAMED_FE(geometry_getcoordinatedimension,_wrap_Geometry_GetCoordinateDimension,NULL)
 
10706
 SWIG_ZEND_NAMED_FE(geometry_setcoordinatedimension,_wrap_Geometry_SetCoordinateDimension,NULL)
 
10707
 SWIG_ZEND_NAMED_FE(geometry_getdimension,_wrap_Geometry_GetDimension,NULL)
 
10708
 SWIG_ZEND_NAMED_FE(ogrgetdrivercount,_wrap_OGRGetDriverCount,NULL)
 
10709
 SWIG_ZEND_NAMED_FE(ogrgetopendscount,_wrap_OGRGetOpenDSCount,NULL)
 
10710
 SWIG_ZEND_NAMED_FE(ogrsetgenerate_db2_v72_byte_order,_wrap_OGRSetGenerate_DB2_V72_BYTE_ORDER,NULL)
 
10711
 SWIG_ZEND_NAMED_FE(ogrregisterall,_wrap_OGRRegisterAll,NULL)
 
10712
 SWIG_ZEND_NAMED_FE(geometrytypetoname,_wrap_GeometryTypeToName,NULL)
 
10713
 SWIG_ZEND_NAMED_FE(getfieldtypename,_wrap_GetFieldTypeName,NULL)
 
10714
 SWIG_ZEND_NAMED_FE(getopends,_wrap_GetOpenDS,NULL)
 
10715
 SWIG_ZEND_NAMED_FE(open,_wrap_Open,NULL)
 
10716
 SWIG_ZEND_NAMED_FE(openshared,_wrap_OpenShared,NULL)
 
10717
 SWIG_ZEND_NAMED_FE(getdriverbyname,_wrap_GetDriverByName,NULL)
 
10718
 SWIG_ZEND_NAMED_FE(getdriver,_wrap_GetDriver,NULL)
 
10719
 SWIG_ZEND_NAMED_FE(generalcmdlineprocessor,_wrap_GeneralCmdLineProcessor,NULL)
 
10720
 SWIG_ZEND_NAMED_FE(swig_ogr_alter_newobject,_wrap_swig_ogr_alter_newobject,NULL)
 
10721
 SWIG_ZEND_NAMED_FE(swig_ogr_get_newobject,_wrap_swig_ogr_get_newobject,NULL)
 
10722
{NULL, NULL, NULL}
 
10723
};
 
10724
 
8995
10725
/* init section */
 
10726
#if ZEND_MODULE_API_NO <= 20090626
 
10727
#undef ZEND_MODULE_BUILD_ID
 
10728
#define ZEND_MODULE_BUILD_ID (char*)"API" ZEND_TOSTR(ZEND_MODULE_API_NO) ZEND_BUILD_TS ZEND_BUILD_DEBUG ZEND_BUILD_SYSTEM ZEND_BUILD_EXTRA
 
10729
#endif
 
10730
zend_module_entry ogr_module_entry = {
 
10731
#if ZEND_MODULE_API_NO > 20010900
 
10732
    STANDARD_MODULE_HEADER,
 
10733
#endif
 
10734
    (char*)"ogr",
 
10735
    ogr_functions,
 
10736
    PHP_MINIT(ogr),
 
10737
    PHP_MSHUTDOWN(ogr),
 
10738
    PHP_RINIT(ogr),
 
10739
    PHP_RSHUTDOWN(ogr),
 
10740
    PHP_MINFO(ogr),
 
10741
#if ZEND_MODULE_API_NO > 20010900
 
10742
    NO_VERSION_YET,
 
10743
#endif
 
10744
    STANDARD_MODULE_PROPERTIES
 
10745
};
 
10746
zend_module_entry* SWIG_module_entry = &ogr_module_entry;
 
10747
 
8996
10748
#ifdef __cplusplus
8997
10749
extern "C" {
8998
10750
#endif
8999
 
ZEND_GET_MODULE(ogr)
 
10751
SWIGEXPORT zend_module_entry *get_module(void) { return &ogr_module_entry; }
9000
10752
#ifdef __cplusplus
9001
10753
}
9002
10754
#endif
9003
10755
 
9004
10756
#define SWIG_php_minit PHP_MINIT_FUNCTION(ogr)
9005
 
/*************************************************************************
 
10757
/* -----------------------------------------------------------------------------
9006
10758
 * Type initialization:
9007
10759
 * This problem is tough by the requirement that no dynamic 
9008
10760
 * memory is used. Also, since swig_type_info structures store pointers to 
9014
10766
 * swig_module, and does all the lookup, filling in the swig_module.types
9015
10767
 * array with the correct data and linking the correct swig_cast_info
9016
10768
 * structures together.
9017
 
 
 
10769
 *
9018
10770
 * The generated swig_type_info structures are assigned staticly to an initial 
9019
 
 * array. We just loop though that array, and handle each type individually.
 
10771
 * array. We just loop through that array, and handle each type individually.
9020
10772
 * First we lookup if this type has been already loaded, and if so, use the
9021
10773
 * loaded structure instead of the generated one. Then we have to fill in the
9022
10774
 * cast linked list. The cast data is initially stored in something like a
9028
10780
 * we find the array of casts associated with the type, and loop through it 
9029
10781
 * adding the casts to the list. The one last trick we need to do is making
9030
10782
 * sure the type pointer in the swig_cast_info struct is correct.
9031
 
 
 
10783
 *
9032
10784
 * First off, we lookup the cast->type name to see if it is already loaded. 
9033
10785
 * There are three cases to handle:
9034
10786
 *  1) If the cast->type has already been loaded AND the type we are adding
9041
10793
 *  3) Finally, if cast->type has not already been loaded, then we add that
9042
10794
 *     swig_cast_info to the linked list (because the cast->type) pointer will
9043
10795
 *     be correct.
9044
 
**/
 
10796
 * ----------------------------------------------------------------------------- */
9045
10797
 
9046
10798
#ifdef __cplusplus
9047
10799
extern "C" {
9048
 
#endif
 
10800
#if 0
 
10801
} /* c-mode */
 
10802
#endif
 
10803
#endif
 
10804
 
 
10805
#if 0
 
10806
#define SWIGRUNTIME_DEBUG
 
10807
#endif
 
10808
 
9049
10809
 
9050
10810
SWIGRUNTIME void
9051
10811
SWIG_InitializeModule(void *clientdata) {
9052
 
  swig_type_info *type, *ret;
9053
 
  swig_cast_info *cast;
9054
10812
  size_t i;
9055
 
  swig_module_info *module_head;
9056
 
  static int init_run = 0;
 
10813
  swig_module_info *module_head, *iter;
 
10814
  int found, init;
9057
10815
 
9058
10816
  clientdata = clientdata;
9059
10817
 
9060
 
  if (init_run) return;
9061
 
  init_run = 1;
9062
 
 
9063
 
  /* Initialize the swig_module */
9064
 
  swig_module.type_initial = swig_type_initial;
9065
 
  swig_module.cast_initial = swig_cast_initial;
 
10818
  /* check to see if the circular list has been setup, if not, set it up */
 
10819
  if (swig_module.next==0) {
 
10820
    /* Initialize the swig_module */
 
10821
    swig_module.type_initial = swig_type_initial;
 
10822
    swig_module.cast_initial = swig_cast_initial;
 
10823
    swig_module.next = &swig_module;
 
10824
    init = 1;
 
10825
  } else {
 
10826
    init = 0;
 
10827
  }
9066
10828
 
9067
10829
  /* Try and load any already created modules */
9068
10830
  module_head = SWIG_GetModule(clientdata);
9069
 
  if (module_head) {
 
10831
  if (!module_head) {
 
10832
    /* This is the first module loaded for this interpreter */
 
10833
    /* so set the swig module into the interpreter */
 
10834
    SWIG_SetModule(clientdata, &swig_module);
 
10835
    module_head = &swig_module;
 
10836
  } else {
 
10837
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
 
10838
    found=0;
 
10839
    iter=module_head;
 
10840
    do {
 
10841
      if (iter==&swig_module) {
 
10842
        found=1;
 
10843
        break;
 
10844
      }
 
10845
      iter=iter->next;
 
10846
    } while (iter!= module_head);
 
10847
 
 
10848
    /* if the is found in the list, then all is done and we may leave */
 
10849
    if (found) return;
 
10850
    /* otherwise we must add out module into the list */
9070
10851
    swig_module.next = module_head->next;
9071
10852
    module_head->next = &swig_module;
9072
 
  } else {
9073
 
    /* This is the first module loaded */
9074
 
    swig_module.next = &swig_module;
9075
 
    SWIG_SetModule(clientdata, &swig_module);
9076
10853
  }
9077
 
                 
 
10854
 
 
10855
  /* When multiple interpeters are used, a module could have already been initialized in
 
10856
     a different interpreter, but not yet have a pointer in this interpreter.
 
10857
     In this case, we do not want to continue adding types... everything should be
 
10858
     set up already */
 
10859
  if (init == 0) return;
 
10860
 
9078
10861
  /* Now work on filling in swig_module.types */
 
10862
#ifdef SWIGRUNTIME_DEBUG
 
10863
  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
 
10864
#endif
9079
10865
  for (i = 0; i < swig_module.size; ++i) {
9080
 
    type = 0;
 
10866
    swig_type_info *type = 0;
 
10867
    swig_type_info *ret;
 
10868
    swig_cast_info *cast;
 
10869
  
 
10870
#ifdef SWIGRUNTIME_DEBUG
 
10871
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
 
10872
#endif
9081
10873
 
9082
10874
    /* if there is another module already loaded */
9083
10875
    if (swig_module.next != &swig_module) {
9085
10877
    }
9086
10878
    if (type) {
9087
10879
      /* Overwrite clientdata field */
9088
 
      if (swig_module.type_initial[i]->clientdata) type->clientdata = swig_module.type_initial[i]->clientdata;
 
10880
#ifdef SWIGRUNTIME_DEBUG
 
10881
      printf("SWIG_InitializeModule: found type %s\n", type->name);
 
10882
#endif
 
10883
      if (swig_module.type_initial[i]->clientdata) {
 
10884
        type->clientdata = swig_module.type_initial[i]->clientdata;
 
10885
#ifdef SWIGRUNTIME_DEBUG
 
10886
      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
 
10887
#endif
 
10888
      }
9089
10889
    } else {
9090
10890
      type = swig_module.type_initial[i];
9091
10891
    }
9096
10896
    
9097
10897
      /* Don't need to add information already in the list */
9098
10898
      ret = 0;
 
10899
#ifdef SWIGRUNTIME_DEBUG
 
10900
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
 
10901
#endif
9099
10902
      if (swig_module.next != &swig_module) {
9100
10903
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
9101
 
      }
9102
 
      if (ret && type == swig_module.type_initial[i]) {
9103
 
        cast->type = ret;
9104
 
        ret = 0;
9105
 
      }
9106
 
      
 
10904
#ifdef SWIGRUNTIME_DEBUG
 
10905
        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
 
10906
#endif
 
10907
      }
 
10908
      if (ret) {
 
10909
        if (type == swig_module.type_initial[i]) {
 
10910
#ifdef SWIGRUNTIME_DEBUG
 
10911
          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
 
10912
#endif
 
10913
          cast->type = ret;
 
10914
          ret = 0;
 
10915
        } else {
 
10916
          /* Check for casting already in the list */
 
10917
          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
 
10918
#ifdef SWIGRUNTIME_DEBUG
 
10919
          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
 
10920
#endif
 
10921
          if (!ocast) ret = 0;
 
10922
        }
 
10923
      }
 
10924
 
9107
10925
      if (!ret) {
 
10926
#ifdef SWIGRUNTIME_DEBUG
 
10927
        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
 
10928
#endif
9108
10929
        if (type->cast) {
9109
10930
          type->cast->prev = cast;
9110
10931
          cast->next = type->cast;
9111
10932
        }
9112
10933
        type->cast = cast;
9113
10934
      }
9114
 
 
9115
10935
      cast++;
9116
10936
    }
9117
 
 
9118
10937
    /* Set entry in modules->types array equal to the type */
9119
10938
    swig_module.types[i] = type;
9120
10939
  }
9121
10940
  swig_module.types[i] = 0;
 
10941
 
 
10942
#ifdef SWIGRUNTIME_DEBUG
 
10943
  printf("**** SWIG_InitializeModule: Cast List ******\n");
 
10944
  for (i = 0; i < swig_module.size; ++i) {
 
10945
    int j = 0;
 
10946
    swig_cast_info *cast = swig_module.cast_initial[i];
 
10947
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
 
10948
    while (cast->type) {
 
10949
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
 
10950
      cast++;
 
10951
      ++j;
 
10952
    }
 
10953
  printf("---- Total casts: %d\n",j);
 
10954
  }
 
10955
  printf("**** SWIG_InitializeModule: Cast List ******\n");
 
10956
#endif
9122
10957
}
9123
10958
 
9124
10959
/* This function will propagate the clientdata field of type to
9150
10985
}
9151
10986
 
9152
10987
#ifdef __cplusplus
 
10988
#if 0
 
10989
{ /* c-mode */
 
10990
#endif
9153
10991
}
9154
10992
#endif
9155
10993
 
9157
10995
  SWIG_php_minit {
9158
10996
    SWIG_InitializeModule(0);
9159
10997
 
9160
 
 
9161
 
  if ( OGRGetDriverCount() == 0 ) {
9162
 
    OGRRegisterAll();
9163
 
  }
9164
 
 
9165
10998
/* oinit subsection */
9166
10999
ZEND_INIT_MODULE_GLOBALS(ogr, ogr_init_globals, ogr_destroy_globals);
9167
 
/* Define class Driver */
9168
 
INIT_OVERLOADED_CLASS_ENTRY(ce_swig_Driver,"driver",Driver_functions,NULL,_wrap_propget_Driver,_wrap_propset_Driver);
9169
 
if (! (ptr_ce_swig_Driver=zend_register_internal_class_ex(&ce_swig_Driver,NULL,NULL))) zend_error(E_ERROR,"Error registering wrapper for class Driver");
9170
 
 
9171
 
/* Define class DataSource */
9172
 
INIT_OVERLOADED_CLASS_ENTRY(ce_swig_DataSource,"datasource",DataSource_functions,NULL,_wrap_propget_DataSource,_wrap_propset_DataSource);
9173
 
if (! (ptr_ce_swig_DataSource=zend_register_internal_class_ex(&ce_swig_DataSource,NULL,NULL))) zend_error(E_ERROR,"Error registering wrapper for class DataSource");
9174
 
 
9175
 
/* Define class Layer */
9176
 
INIT_OVERLOADED_CLASS_ENTRY(ce_swig_Layer,"layer",Layer_functions,NULL,_wrap_propget_Layer,_wrap_propset_Layer);
9177
 
if (! (ptr_ce_swig_Layer=zend_register_internal_class_ex(&ce_swig_Layer,NULL,NULL))) zend_error(E_ERROR,"Error registering wrapper for class Layer");
9178
 
 
9179
 
/* Define class Feature */
9180
 
INIT_OVERLOADED_CLASS_ENTRY(ce_swig_Feature,"feature",Feature_functions,NULL,_wrap_propget_Feature,_wrap_propset_Feature);
9181
 
if (! (ptr_ce_swig_Feature=zend_register_internal_class_ex(&ce_swig_Feature,NULL,NULL))) zend_error(E_ERROR,"Error registering wrapper for class Feature");
9182
 
 
9183
 
/* Define class FeatureDefn */
9184
 
INIT_OVERLOADED_CLASS_ENTRY(ce_swig_FeatureDefn,"featuredefn",FeatureDefn_functions,NULL,_wrap_propget_FeatureDefn,_wrap_propset_FeatureDefn);
9185
 
if (! (ptr_ce_swig_FeatureDefn=zend_register_internal_class_ex(&ce_swig_FeatureDefn,NULL,NULL))) zend_error(E_ERROR,"Error registering wrapper for class FeatureDefn");
9186
 
 
9187
 
/* Define class FieldDefn */
9188
 
INIT_OVERLOADED_CLASS_ENTRY(ce_swig_FieldDefn,"fielddefn",FieldDefn_functions,NULL,_wrap_propget_FieldDefn,_wrap_propset_FieldDefn);
9189
 
if (! (ptr_ce_swig_FieldDefn=zend_register_internal_class_ex(&ce_swig_FieldDefn,NULL,NULL))) zend_error(E_ERROR,"Error registering wrapper for class FieldDefn");
9190
 
 
9191
 
/* Define class Geometry */
9192
 
INIT_OVERLOADED_CLASS_ENTRY(ce_swig_Geometry,"geometry",Geometry_functions,NULL,_wrap_propget_Geometry,_wrap_propset_Geometry);
9193
 
if (! (ptr_ce_swig_Geometry=zend_register_internal_class_ex(&ce_swig_Geometry,NULL,NULL))) zend_error(E_ERROR,"Error registering wrapper for class Geometry");
9194
 
 
9195
11000
 
9196
11001
/* Register resource destructors for pointer types */
9197
11002
le_swig__p_GIntBig=zend_register_list_destructors_ex(_wrap_destroy_p_GIntBig,NULL,(char *)(SWIGTYPE_p_GIntBig->name),module_number);
9198
11003
SWIG_TypeClientData(SWIGTYPE_p_GIntBig,&le_swig__p_GIntBig);
9199
11004
le_swig__p_double=zend_register_list_destructors_ex(_wrap_destroy_p_double,NULL,(char *)(SWIGTYPE_p_double->name),module_number);
9200
11005
SWIG_TypeClientData(SWIGTYPE_p_double,&le_swig__p_double);
 
11006
le_swig__p_p_double=zend_register_list_destructors_ex(_wrap_destroy_p_p_double,NULL,(char *)(SWIGTYPE_p_p_double->name),module_number);
 
11007
SWIG_TypeClientData(SWIGTYPE_p_p_double,&le_swig__p_p_double);
9201
11008
le_swig__p_p_char=zend_register_list_destructors_ex(_wrap_destroy_p_p_char,NULL,(char *)(SWIGTYPE_p_p_char->name),module_number);
9202
11009
SWIG_TypeClientData(SWIGTYPE_p_p_char,&le_swig__p_p_char);
9203
11010
le_swig__p_char=zend_register_list_destructors_ex(_wrap_destroy_p_char,NULL,(char *)(SWIGTYPE_p_char->name),module_number);
9204
11011
SWIG_TypeClientData(SWIGTYPE_p_char,&le_swig__p_char);
9205
 
le_swig__p_p_OGRGeometryShadow=zend_register_list_destructors_ex(_wrap_destroy_p_p_OGRGeometryShadow,NULL,(char *)(SWIGTYPE_p_p_OGRGeometryShadow->name),module_number);
9206
 
SWIG_TypeClientData(SWIGTYPE_p_p_OGRGeometryShadow,&le_swig__p_p_OGRGeometryShadow);
 
11012
le_swig__p_p_p_char=zend_register_list_destructors_ex(_wrap_destroy_p_p_p_char,NULL,(char *)(SWIGTYPE_p_p_p_char->name),module_number);
 
11013
SWIG_TypeClientData(SWIGTYPE_p_p_p_char,&le_swig__p_p_p_char);
 
11014
le_swig__p_OGRFeatureShadow=zend_register_list_destructors_ex(_wrap_destroy_p_OGRFeatureShadow,NULL,(char *)(SWIGTYPE_p_OGRFeatureShadow->name),module_number);
 
11015
SWIG_TypeClientData(SWIGTYPE_p_OGRFeatureShadow,&le_swig__p_OGRFeatureShadow);
9207
11016
le_swig__p_OGRGeometryShadow=zend_register_list_destructors_ex(_wrap_destroy_p_OGRGeometryShadow,NULL,(char *)(SWIGTYPE_p_OGRGeometryShadow->name),module_number);
9208
11017
SWIG_TypeClientData(SWIGTYPE_p_OGRGeometryShadow,&le_swig__p_OGRGeometryShadow);
9209
 
le_swig__p_p_OSRSpatialReferenceShadow=zend_register_list_destructors_ex(_wrap_destroy_p_p_OSRSpatialReferenceShadow,NULL,(char *)(SWIGTYPE_p_p_OSRSpatialReferenceShadow->name),module_number);
9210
 
SWIG_TypeClientData(SWIGTYPE_p_p_OSRSpatialReferenceShadow,&le_swig__p_p_OSRSpatialReferenceShadow);
9211
11018
le_swig__p_OSRSpatialReferenceShadow=zend_register_list_destructors_ex(_wrap_destroy_p_OSRSpatialReferenceShadow,NULL,(char *)(SWIGTYPE_p_OSRSpatialReferenceShadow->name),module_number);
9212
11019
SWIG_TypeClientData(SWIGTYPE_p_OSRSpatialReferenceShadow,&le_swig__p_OSRSpatialReferenceShadow);
9213
 
le_swig__p_p_OGRDataSourceShadow=zend_register_list_destructors_ex(_wrap_destroy_p_p_OGRDataSourceShadow,NULL,(char *)(SWIGTYPE_p_p_OGRDataSourceShadow->name),module_number);
9214
 
SWIG_TypeClientData(SWIGTYPE_p_p_OGRDataSourceShadow,&le_swig__p_p_OGRDataSourceShadow);
9215
11020
le_swig__p_OGRDataSourceShadow=zend_register_list_destructors_ex(_wrap_destroy_p_OGRDataSourceShadow,NULL,(char *)(SWIGTYPE_p_OGRDataSourceShadow->name),module_number);
9216
11021
SWIG_TypeClientData(SWIGTYPE_p_OGRDataSourceShadow,&le_swig__p_OGRDataSourceShadow);
9217
 
le_swig__p_OGRFeatureShadow=zend_register_list_destructors_ex(_wrap_destroy_p_OGRFeatureShadow,NULL,(char *)(SWIGTYPE_p_OGRFeatureShadow->name),module_number);
9218
 
SWIG_TypeClientData(SWIGTYPE_p_OGRFeatureShadow,&le_swig__p_OGRFeatureShadow);
9219
 
le_swig__p_p_OGRFeatureShadow=zend_register_list_destructors_ex(_wrap_destroy_p_p_OGRFeatureShadow,NULL,(char *)(SWIGTYPE_p_p_OGRFeatureShadow->name),module_number);
9220
 
SWIG_TypeClientData(SWIGTYPE_p_p_OGRFeatureShadow,&le_swig__p_p_OGRFeatureShadow);
 
11022
le_swig__p_p_OGRGeometryShadow=zend_register_list_destructors_ex(_wrap_destroy_p_p_OGRGeometryShadow,NULL,(char *)(SWIGTYPE_p_p_OGRGeometryShadow->name),module_number);
 
11023
SWIG_TypeClientData(SWIGTYPE_p_p_OGRGeometryShadow,&le_swig__p_p_OGRGeometryShadow);
9221
11024
le_swig__int=zend_register_list_destructors_ex(_wrap_destroy_int,NULL,(char *)(SWIGTYPE_int->name),module_number);
9222
11025
SWIG_TypeClientData(SWIGTYPE_int,&le_swig__int);
9223
11026
le_swig__p_int=zend_register_list_destructors_ex(_wrap_destroy_p_int,NULL,(char *)(SWIGTYPE_p_int->name),module_number);
9224
11027
SWIG_TypeClientData(SWIGTYPE_p_int,&le_swig__p_int);
 
11028
le_swig__p_OGRFieldDefnShadow=zend_register_list_destructors_ex(_wrap_destroy_p_OGRFieldDefnShadow,NULL,(char *)(SWIGTYPE_p_OGRFieldDefnShadow->name),module_number);
 
11029
SWIG_TypeClientData(SWIGTYPE_p_OGRFieldDefnShadow,&le_swig__p_OGRFieldDefnShadow);
 
11030
le_swig__p_OGRFeatureDefnShadow=zend_register_list_destructors_ex(_wrap_destroy_p_OGRFeatureDefnShadow,NULL,(char *)(SWIGTYPE_p_OGRFeatureDefnShadow->name),module_number);
 
11031
SWIG_TypeClientData(SWIGTYPE_p_OGRFeatureDefnShadow,&le_swig__p_OGRFeatureDefnShadow);
9225
11032
le_swig__p_p_OGRLayerShadow=zend_register_list_destructors_ex(_wrap_destroy_p_p_OGRLayerShadow,NULL,(char *)(SWIGTYPE_p_p_OGRLayerShadow->name),module_number);
9226
11033
SWIG_TypeClientData(SWIGTYPE_p_p_OGRLayerShadow,&le_swig__p_p_OGRLayerShadow);
9227
11034
le_swig__p_OGRLayerShadow=zend_register_list_destructors_ex(_wrap_destroy_p_OGRLayerShadow,NULL,(char *)(SWIGTYPE_p_OGRLayerShadow->name),module_number);
9228
11035
SWIG_TypeClientData(SWIGTYPE_p_OGRLayerShadow,&le_swig__p_OGRLayerShadow);
9229
 
le_swig__p_p_OGRDriverShadow=zend_register_list_destructors_ex(_wrap_destroy_p_p_OGRDriverShadow,NULL,(char *)(SWIGTYPE_p_p_OGRDriverShadow->name),module_number);
9230
 
SWIG_TypeClientData(SWIGTYPE_p_p_OGRDriverShadow,&le_swig__p_p_OGRDriverShadow);
9231
11036
le_swig__p_OGRDriverShadow=zend_register_list_destructors_ex(_wrap_destroy_p_OGRDriverShadow,NULL,(char *)(SWIGTYPE_p_OGRDriverShadow->name),module_number);
9232
11037
SWIG_TypeClientData(SWIGTYPE_p_OGRDriverShadow,&le_swig__p_OGRDriverShadow);
9233
 
le_swig__p_OGRFeatureDefnShadow=zend_register_list_destructors_ex(_wrap_destroy_p_OGRFeatureDefnShadow,NULL,(char *)(SWIGTYPE_p_OGRFeatureDefnShadow->name),module_number);
9234
 
SWIG_TypeClientData(SWIGTYPE_p_OGRFeatureDefnShadow,&le_swig__p_OGRFeatureDefnShadow);
9235
 
le_swig__p_OGRFieldDefnShadow=zend_register_list_destructors_ex(_wrap_destroy_p_OGRFieldDefnShadow,NULL,(char *)(SWIGTYPE_p_OGRFieldDefnShadow->name),module_number);
9236
 
SWIG_TypeClientData(SWIGTYPE_p_OGRFieldDefnShadow,&le_swig__p_OGRFieldDefnShadow);
9237
 
le_swig__p_p_OGRFieldDefnShadow=zend_register_list_destructors_ex(_wrap_destroy_p_p_OGRFieldDefnShadow,NULL,(char *)(SWIGTYPE_p_p_OGRFieldDefnShadow->name),module_number);
9238
 
SWIG_TypeClientData(SWIGTYPE_p_p_OGRFieldDefnShadow,&le_swig__p_p_OGRFieldDefnShadow);
9239
 
le_swig__p_p_OGRFeatureDefnShadow=zend_register_list_destructors_ex(_wrap_destroy_p_p_OGRFeatureDefnShadow,NULL,(char *)(SWIGTYPE_p_p_OGRFeatureDefnShadow->name),module_number);
9240
 
SWIG_TypeClientData(SWIGTYPE_p_p_OGRFeatureDefnShadow,&le_swig__p_p_OGRFeatureDefnShadow);
 
11038
le_swig__p_p_int=zend_register_list_destructors_ex(_wrap_destroy_p_p_int,NULL,(char *)(SWIGTYPE_p_p_int->name),module_number);
 
11039
SWIG_TypeClientData(SWIGTYPE_p_p_int,&le_swig__p_p_int);
9241
11040
le_swig__p_OSRCoordinateTransformationShadow=zend_register_list_destructors_ex(_wrap_destroy_p_OSRCoordinateTransformationShadow,NULL,(char *)(SWIGTYPE_p_OSRCoordinateTransformationShadow->name),module_number);
9242
11041
SWIG_TypeClientData(SWIGTYPE_p_OSRCoordinateTransformationShadow,&le_swig__p_OSRCoordinateTransformationShadow);
9243
 
le_swig__p_p_OSRCoordinateTransformationShadow=zend_register_list_destructors_ex(_wrap_destroy_p_p_OSRCoordinateTransformationShadow,NULL,(char *)(SWIGTYPE_p_p_OSRCoordinateTransformationShadow->name),module_number);
9244
 
SWIG_TypeClientData(SWIGTYPE_p_p_OSRCoordinateTransformationShadow,&le_swig__p_p_OSRCoordinateTransformationShadow);
9245
11042
CG(active_class_entry) = NULL;
9246
11043
/* end oinit subsection */
9247
11044
 
 
11045
/* cinit subsection */
 
11046
SWIG_LONG_CONSTANT(wkb25DBit, 0x80000000);
 
11047
SWIG_LONG_CONSTANT(wkb25Bit, 0x80000000);
 
11048
SWIG_LONG_CONSTANT(wkbUnknown, 0);
 
11049
SWIG_LONG_CONSTANT(wkbPoint, 1);
 
11050
SWIG_LONG_CONSTANT(wkbLineString, 2);
 
11051
SWIG_LONG_CONSTANT(wkbPolygon, 3);
 
11052
SWIG_LONG_CONSTANT(wkbMultiPoint, 4);
 
11053
SWIG_LONG_CONSTANT(wkbMultiLineString, 5);
 
11054
SWIG_LONG_CONSTANT(wkbMultiPolygon, 6);
 
11055
SWIG_LONG_CONSTANT(wkbGeometryCollection, 7);
 
11056
SWIG_LONG_CONSTANT(wkbNone, 100);
 
11057
SWIG_LONG_CONSTANT(wkbLinearRing, 101);
 
11058
SWIG_LONG_CONSTANT(wkbPoint25D, wkbPoint+wkb25DBit);
 
11059
SWIG_LONG_CONSTANT(wkbLineString25D, wkbLineString+wkb25DBit);
 
11060
SWIG_LONG_CONSTANT(wkbPolygon25D, wkbPolygon+wkb25DBit);
 
11061
SWIG_LONG_CONSTANT(wkbMultiPoint25D, wkbMultiPoint+wkb25DBit);
 
11062
SWIG_LONG_CONSTANT(wkbMultiLineString25D, wkbMultiLineString+wkb25DBit);
 
11063
SWIG_LONG_CONSTANT(wkbMultiPolygon25D, wkbMultiPolygon+wkb25DBit);
 
11064
SWIG_LONG_CONSTANT(wkbGeometryCollection25D, wkbGeometryCollection+wkb25DBit);
 
11065
SWIG_LONG_CONSTANT(OFTInteger, 0);
 
11066
SWIG_LONG_CONSTANT(OFTIntegerList, 1);
 
11067
SWIG_LONG_CONSTANT(OFTReal, 2);
 
11068
SWIG_LONG_CONSTANT(OFTRealList, 3);
 
11069
SWIG_LONG_CONSTANT(OFTString, 4);
 
11070
SWIG_LONG_CONSTANT(OFTStringList, 5);
 
11071
SWIG_LONG_CONSTANT(OFTWideString, 6);
 
11072
SWIG_LONG_CONSTANT(OFTWideStringList, 7);
 
11073
SWIG_LONG_CONSTANT(OFTBinary, 8);
 
11074
SWIG_LONG_CONSTANT(OFTDate, 9);
 
11075
SWIG_LONG_CONSTANT(OFTTime, 10);
 
11076
SWIG_LONG_CONSTANT(OFTDateTime, 11);
 
11077
SWIG_LONG_CONSTANT(OJUndefined, 0);
 
11078
SWIG_LONG_CONSTANT(OJLeft, 1);
 
11079
SWIG_LONG_CONSTANT(OJRight, 2);
 
11080
SWIG_LONG_CONSTANT(wkbXDR, 0);
 
11081
SWIG_LONG_CONSTANT(wkbNDR, 1);
 
11082
SWIG_LONG_CONSTANT(NullFID, -1);
 
11083
SWIG_STRING_CONSTANT(OLCRandomRead, "RandomRead");
 
11084
SWIG_STRING_CONSTANT(OLCSequentialWrite, "SequentialWrite");
 
11085
SWIG_STRING_CONSTANT(OLCRandomWrite, "RandomWrite");
 
11086
SWIG_STRING_CONSTANT(OLCFastSpatialFilter, "FastSpatialFilter");
 
11087
SWIG_STRING_CONSTANT(OLCFastFeatureCount, "FastFeatureCount");
 
11088
SWIG_STRING_CONSTANT(OLCFastGetExtent, "FastGetExtent");
 
11089
SWIG_STRING_CONSTANT(OLCCreateField, "CreateField");
 
11090
SWIG_STRING_CONSTANT(OLCTransactions, "Transactions");
 
11091
SWIG_STRING_CONSTANT(OLCDeleteFeature, "DeleteFeature");
 
11092
SWIG_STRING_CONSTANT(OLCFastSetNextByIndex, "FastSetNextByIndex");
 
11093
SWIG_STRING_CONSTANT(OLCStringsAsUTF8, "StringsAsUTF8");
 
11094
SWIG_STRING_CONSTANT(OLCIgnoreFields, "IgnoreFields");
 
11095
SWIG_STRING_CONSTANT(ODsCCreateLayer, "CreateLayer");
 
11096
SWIG_STRING_CONSTANT(ODsCDeleteLayer, "DeleteLayer");
 
11097
SWIG_STRING_CONSTANT(ODrCCreateDataSource, "CreateDataSource");
 
11098
SWIG_STRING_CONSTANT(ODrCDeleteDataSource, "DeleteDataSource");
 
11099
/* end cinit subsection */
 
11100
 
9248
11101
    return SUCCESS;
9249
11102
}
 
11103
 
9250
11104
PHP_RINIT_FUNCTION(ogr)
9251
11105
{
9252
11106
/* rinit section */
9253
11107
 
9254
 
/* cinit subsection */
9255
 
REGISTER_LONG_CONSTANT( "wkb25Bit", wkb25DBit, CONST_CS | CONST_PERSISTENT);
9256
 
REGISTER_LONG_CONSTANT( "wkbUnknown", 0, CONST_CS | CONST_PERSISTENT);
9257
 
REGISTER_LONG_CONSTANT( "wkbPoint", 1, CONST_CS | CONST_PERSISTENT);
9258
 
REGISTER_LONG_CONSTANT( "wkbLineString", 2, CONST_CS | CONST_PERSISTENT);
9259
 
REGISTER_LONG_CONSTANT( "wkbPolygon", 3, CONST_CS | CONST_PERSISTENT);
9260
 
REGISTER_LONG_CONSTANT( "wkbMultiPoint", 4, CONST_CS | CONST_PERSISTENT);
9261
 
REGISTER_LONG_CONSTANT( "wkbMultiLineString", 5, CONST_CS | CONST_PERSISTENT);
9262
 
REGISTER_LONG_CONSTANT( "wkbMultiPolygon", 6, CONST_CS | CONST_PERSISTENT);
9263
 
REGISTER_LONG_CONSTANT( "wkbGeometryCollection", 7, CONST_CS | CONST_PERSISTENT);
9264
 
REGISTER_LONG_CONSTANT( "wkbNone", 100, CONST_CS | CONST_PERSISTENT);
9265
 
REGISTER_LONG_CONSTANT( "wkbLinearRing", 101, CONST_CS | CONST_PERSISTENT);
9266
 
REGISTER_LONG_CONSTANT( "wkbPoint25D", wkbPoint+wkb25DBit, CONST_CS | CONST_PERSISTENT);
9267
 
REGISTER_LONG_CONSTANT( "wkbLineString25D", wkbLineString+wkb25DBit, CONST_CS | CONST_PERSISTENT);
9268
 
REGISTER_LONG_CONSTANT( "wkbPolygon25D", wkbPolygon+wkb25DBit, CONST_CS | CONST_PERSISTENT);
9269
 
REGISTER_LONG_CONSTANT( "wkbMultiPoint25D", wkbMultiPoint+wkb25DBit, CONST_CS | CONST_PERSISTENT);
9270
 
REGISTER_LONG_CONSTANT( "wkbMultiLineString25D", wkbMultiLineString+wkb25DBit, CONST_CS | CONST_PERSISTENT);
9271
 
REGISTER_LONG_CONSTANT( "wkbMultiPolygon25D", wkbMultiPolygon+wkb25DBit, CONST_CS | CONST_PERSISTENT);
9272
 
REGISTER_LONG_CONSTANT( "wkbGeometryCollection25D", wkbGeometryCollection+wkb25DBit, CONST_CS | CONST_PERSISTENT);
9273
 
REGISTER_LONG_CONSTANT( "OFTInteger", 0, CONST_CS | CONST_PERSISTENT);
9274
 
REGISTER_LONG_CONSTANT( "OFTIntegerList", 1, CONST_CS | CONST_PERSISTENT);
9275
 
REGISTER_LONG_CONSTANT( "OFTReal", 2, CONST_CS | CONST_PERSISTENT);
9276
 
REGISTER_LONG_CONSTANT( "OFTRealList", 3, CONST_CS | CONST_PERSISTENT);
9277
 
REGISTER_LONG_CONSTANT( "OFTString", 4, CONST_CS | CONST_PERSISTENT);
9278
 
REGISTER_LONG_CONSTANT( "OFTStringList", 5, CONST_CS | CONST_PERSISTENT);
9279
 
REGISTER_LONG_CONSTANT( "OFTWideString", 6, CONST_CS | CONST_PERSISTENT);
9280
 
REGISTER_LONG_CONSTANT( "OFTWideStringList", 7, CONST_CS | CONST_PERSISTENT);
9281
 
REGISTER_LONG_CONSTANT( "OFTBinary", 8, CONST_CS | CONST_PERSISTENT);
9282
 
REGISTER_LONG_CONSTANT( "OJUndefined", 0, CONST_CS | CONST_PERSISTENT);
9283
 
REGISTER_LONG_CONSTANT( "OJLeft", 1, CONST_CS | CONST_PERSISTENT);
9284
 
REGISTER_LONG_CONSTANT( "OJRight", 2, CONST_CS | CONST_PERSISTENT);
9285
 
REGISTER_LONG_CONSTANT( "wkbXDR", 0, CONST_CS | CONST_PERSISTENT);
9286
 
REGISTER_LONG_CONSTANT( "wkbNDR", 1, CONST_CS | CONST_PERSISTENT);
9287
 
REGISTER_STRING_CONSTANT("OLCRandomRead", "RandomRead", CONST_CS | CONST_PERSISTENT);
9288
 
REGISTER_STRING_CONSTANT("OLCSequentialWrite", "SequentialWrite", CONST_CS | CONST_PERSISTENT);
9289
 
REGISTER_STRING_CONSTANT("OLCRandomWrite", "RandomWrite", CONST_CS | CONST_PERSISTENT);
9290
 
REGISTER_STRING_CONSTANT("OLCFastSpatialFilter", "FastSpatialFilter", CONST_CS | CONST_PERSISTENT);
9291
 
REGISTER_STRING_CONSTANT("OLCFastFeatureCount", "FastFeatureCount", CONST_CS | CONST_PERSISTENT);
9292
 
REGISTER_STRING_CONSTANT("OLCFastGetExtent", "FastGetExtent", CONST_CS | CONST_PERSISTENT);
9293
 
REGISTER_STRING_CONSTANT("OLCCreateField", "CreateField", CONST_CS | CONST_PERSISTENT);
9294
 
REGISTER_STRING_CONSTANT("OLCTransactions", "Transactions", CONST_CS | CONST_PERSISTENT);
9295
 
REGISTER_STRING_CONSTANT("OLCDeleteFeature", "DeleteFeature", CONST_CS | CONST_PERSISTENT);
9296
 
REGISTER_STRING_CONSTANT("OLCFastSetNextByIndex", "FastSetNextByIndex", CONST_CS | CONST_PERSISTENT);
9297
 
REGISTER_STRING_CONSTANT("ODsCCreateLayer", "CreateLayer", CONST_CS | CONST_PERSISTENT);
9298
 
REGISTER_STRING_CONSTANT("ODsCDeleteLayer", "DeleteLayer", CONST_CS | CONST_PERSISTENT);
9299
 
REGISTER_STRING_CONSTANT("ODrCCreateDataSource", "CreateDataSource", CONST_CS | CONST_PERSISTENT);
9300
 
REGISTER_STRING_CONSTANT("ODrCDeleteDataSource", "DeleteDataSource", CONST_CS | CONST_PERSISTENT);
9301
 
/* end cinit subsection */
9302
 
 
9303
11108
/* vinit subsection */
9304
11109
/* end vinit subsection */
9305
11110
 
9306
11111
    return SUCCESS;
9307
11112
}
 
11113
 
9308
11114
PHP_MSHUTDOWN_FUNCTION(ogr)
9309
11115
{
9310
11116
/* shutdown section */
9311
 
 
 
11117
#ifdef ZTS
 
11118
    ts_free_id(ogr_globals_id);
 
11119
#endif
9312
11120
    return SUCCESS;
9313
11121
}
 
11122
 
9314
11123
PHP_RSHUTDOWN_FUNCTION(ogr)
9315
11124
{
9316
11125
/* rshutdown section */
9317
11126
 
9318
11127
    return SUCCESS;
9319
11128
}
 
11129
 
9320
11130
PHP_MINFO_FUNCTION(ogr)
9321
11131
{
9322
11132
}