libraries/pyshapelib/dbflibmodule.c

/* SWIG (www.swig.org) interface file for the dbf interface of shapelib
 *
 * At the moment (Dec 2000) this file is only useful to generate Python
 * bindings. Invoke swig as follows:
 *
 *      swig -python -shadow dbflib.i
 *
 * to generate dbflib_wrap.c and dbflib.py. dbflib_wrap.c defines a
 * bunch of Python-functions that wrap the appripriate dbflib functions
 * and dbflib.py contains an object oriented wrapper around
 * dbflib_wrap.c.
 *
 * This module defines one object type: DBFFile.
 */

/* this is the dbflib module */
%module dbflib

/* first a %{,%} block. These blocks are copied verbatim to the
 * dbflib_wrap.c file and are not parsed by SWIG. This is the place to
 * import headerfiles and define helper-functions that are needed by the
 * automatically generated wrappers.
 */

%{
#include "shapefil.h"

/* the read_record method. Return the record record as a dictionary with
 * whose keys are the names of the fields, and their values as the
 * appropriate Python type.
 * 
 * In case of error, set a python exception and return NULL. Since that
 * value will be returned to the python interpreter as is, the
 * interpreter should recognize the exception.
 */

static PyObject *
DBFInfo_read_record(DBFInfo * handle, int record)
{
    int num_fields;
    int i;
    int type, width;
    char name[12];
    PyObject *dict;
    PyObject *value;

    if (record < 0 || record >= DBFGetRecordCount(handle))
    {
        PyErr_Format(PyExc_ValueError,
                     "record index %d out of bounds (record count: %d)",
                     record, DBFGetRecordCount(handle));
        return NULL;
    }

    dict = PyDict_New();
    if (!dict)
        return NULL;
        
    num_fields = DBFGetFieldCount(handle);
    for (i = 0; i < num_fields; i++)
    {
        type = DBFGetFieldInfo(handle, i, name, &width, NULL);
        /* For strings NULL and the empty string are indistinguishable
         * in DBF files. We prefer empty strings instead for backwards
         * compatibility reasons because older wrapper versions returned
         * emtpy strings as empty strings.
         */
        if (type != FTString && DBFIsAttributeNULL(handle, record, i))
        {
            value = Py_None;
            Py_INCREF(value);
        }
        else
        {
            switch (type)
            {
            case FTString:
            {
                const char * temp = DBFReadStringAttribute(handle, record, i);
                if (temp)
                {
                    value = PyString_FromString(temp);
                }
                else
                {
                    PyErr_Format(PyExc_IOError,
                                 "Can't read value for row %d column %d",
                                 record, i);
                    value = NULL;
                }
                break;
            }
            case FTInteger:
                value = PyInt_FromLong(DBFReadIntegerAttribute(handle, record,
                                                               i));
                break;
            case FTDouble:
                value = PyFloat_FromDouble(DBFReadDoubleAttribute(handle,
                                                                  record, i));
                break;
            default:
                PyErr_Format(PyExc_TypeError, "Invalid field data type %d",
                             type);
                value = NULL;
            }
        }
        if (!value)
            goto fail;
        PyDict_SetItemString(dict, name, value);
        Py_DECREF(value);
    }

    return dict;
 fail:
    Py_XDECREF(dict);
    return NULL;
}

/* the write_record method. Write the record record given wither as a
 * dictionary or a sequence (i.e. a list or a tuple).
 *
 * If it's a dictionary the keys must be the names of the fields and
 * their value must have a suitable type. Only the fields actually
 * contained in the dictionary are written. Fields for which there's no
 * item in the dict are not modified.
 *
 * If it's a sequence, all fields must be present in the right order.
 *
 * In case of error, set a python exception and return NULL. Since that
 * value will be returned to the python interpreter as is, the
 * interpreter should recognize the exception.
 *
 * The method is implemented with two c-functions, write_field to write
 * a single field and DBFInfo_write_record as the front-end.
 */


/* write a single field of a record. */
static int
write_field(DBFHandle handle, int record, int field, int type,
            PyObject * value)
{
    char * string_value;
    int int_value;
    double double_value;

    if (value == Py_None)
    {
        if (!DBFWriteNULLAttribute(handle, record, field))
        {
            PyErr_Format(PyExc_IOError,
                         "can't write NULL field %d of record %d",
                         field, record);
            return 0;
        }
    }
    else
    {
        switch (type)
        {
        case FTString:
            string_value = PyString_AsString(value);
            if (!string_value)
                return 0;
            if (!DBFWriteStringAttribute(handle, record, field, string_value))
            {
                PyErr_Format(PyExc_IOError,
                             "can't write field %d of record %d",
                             field, record);
                return 0;
            }
            break;

        case FTInteger:
            int_value = PyInt_AsLong(value);
            if (int_value == -1 && PyErr_Occurred())
                return 0;
            if (!DBFWriteIntegerAttribute(handle, record, field, int_value))
            {
                PyErr_Format(PyExc_IOError,
                             "can't write field %d of record %d",
                             field, record);
                return 0;
            }
            break;

        case FTDouble:
            double_value = PyFloat_AsDouble(value);
            if (double_value == -1 && PyErr_Occurred())
                return 0;
            if (!DBFWriteDoubleAttribute(handle, record, field, double_value))
            {
                PyErr_Format(PyExc_IOError,
                             "can't write field %d of record %d",
                             field, record);
                return 0;
            }
            break;

        default:
            PyErr_Format(PyExc_TypeError, "Invalid field data type %d", type);
            return 0;
        }
    }

    return 1;
}

static
PyObject *
DBFInfo_write_record(DBFHandle handle, int record, PyObject *record_object)
{
    int num_fields;
    int i, length;
    int type, width;
    char name[12];
    PyObject * value = NULL;

    num_fields = DBFGetFieldCount(handle);

    /* We used to use PyMapping_Check to test whether record_object is a
     * dictionary like object instead of PySequence_Check to test
     * whether it's a sequence. Unfortunately in Python 2.3
     * PyMapping_Check returns true for lists and tuples too so the old
     * approach doesn't work anymore.
     */
    if (PySequence_Check(record_object))
    {
        /* It's a sequence object. Iterate through all items in the
         * sequence and write them to the appropriate field.
         */
        length = PySequence_Length(record_object);
        if (length != num_fields)
        {
            PyErr_SetString(PyExc_TypeError,
                            "record must have one item for each field");
            goto fail;
        }
        for (i = 0; i < length; i++)
        {
            type = DBFGetFieldInfo(handle, i, name, &width, NULL); 
            value = PySequence_GetItem(record_object, i);
            if (value)
            {
                if (!write_field(handle, record, i, type, value))
                    goto fail;
                Py_DECREF(value);
            }
            else
            {
                goto fail;
            }
        }
    }
    else
    {
        /* It's a dictionary-like object. Iterate over the names of the
         * known fields and write the corresponding item
         */
        for (i = 0; i < num_fields; i++)
        {
            type = DBFGetFieldInfo(handle, i, name, &width, NULL);

            /* if the dictionary has the key name write that object to
             * the appropriate field, other wise just clear the python
             * exception and do nothing.
             */
            value = PyMapping_GetItemString(record_object, name);
            if (value)
            {
                if (!write_field(handle, record, i, type, value))
                    goto fail;
                Py_DECREF(value);
            }
            else
            {
                PyErr_Clear();
            }
        }
    }

    Py_INCREF(Py_None);
    return Py_None;

 fail:
    Py_XDECREF(value);
    return NULL;
}
%}


/*
 * The SWIG Interface definition.
 */

/* include some common SWIG type definitions and standard exception
   handling code */
%include typemaps.i
%include exception.i

/* As for ShapeFile in shapelib.i, We define a new C-struct that holds
 * the DBFHandle. This is mainly done so we can separate the close()
 * method from the destructor but it also helps with exception handling.
 *
 * After the DBFFile has been opened or created the handle is not NULL.
 * The close() method closes the file and sets handle to NULL as an
 * indicator that the file has been closed.
 */

%{
    typedef struct {
        DBFHandle handle;
    } DBFFile;
%}


/* The first argument to the DBFFile methods is a DBFFile pointer.
 * We have to check whether handle is not NULL in most methods but not
 * all. In the destructor and the close method, it's OK for handle to be
 * NULL. We achieve this by checking whether the preprocessor macro
 * NOCHECK_$name is defined. SWIG replaces $name with the name of the
 * function for which the code is inserted. In the %{,%}-block below we
 * define the macros for the destructor and the close() method.
 */

%typemap(python,check) DBFFile *{
%#ifndef NOCHECK_$name
    if (!$target || !$target->handle)
        SWIG_exception(SWIG_TypeError, "dbffile already closed");
%#endif
}

%{
#define NOCHECK_delete_DBFFile
#define NOCHECK_DBFFile_close
%}


/* An exception handle for the constructor and the module level open()
 * and create() functions.
 *
 * Annoyingly, we *have* to put braces around the SWIG_exception()
 * calls, at least in the python case, because of the way the macro is
 * written. Of course, always putting braces around the branches of an
 * if-statement is often considered good practice.
 */
%typemap(python,except) DBFFile * {
    $function;
    if (!$source)
    {
        SWIG_exception(SWIG_MemoryError, "no memory");
    }
    else if (!$source->handle)
    {
        SWIG_exception(SWIG_IOError, "$name failed");
    }
}

/* Exception handler for the add_field method */
%typemap(python,except) int DBFFile_add_field {
    $function;
    if ($source < 0)
    {
        SWIG_exception(SWIG_RuntimeError, "add_field failed");
    }
}

/* define and use some typemaps for the field_info() method whose
 * C-implementation has three output parameters that are returned
 * through pointers passed into the function. SWIG already has
 * definitions for common types such as int* and we can use those for
 * the last two parameters:
 */

%apply int * OUTPUT { int * output_width }
%apply int * OUTPUT { int * output_decimals }

/* the fieldname has to be defined manually: */
%typemap(python,ignore) char *fieldname_out(char temp[12]) {
    $target = temp;
}

%typemap(python,argout) char *fieldname_out() {
    PyObject * string = PyString_FromString($source);
    $target = t_output_helper($target,string);
}


/*
 * The SWIG-version of the DBFFile struct 
 */

typedef struct
{
    %addmethods {
        DBFFile(const char *file, const char * mode = "rb") {
            DBFFile * self = malloc(sizeof(DBFFile));
            if (self)
                self->handle = DBFOpen(file, mode);
            return self;
        }
            
        ~DBFFile() {
            if (self->handle)
                DBFClose(self->handle);
            free(self);
        }

        void close() {
            if (self->handle)
                DBFClose(self->handle);
            self->handle = NULL;
        }

        int field_count() {
            return DBFGetFieldCount(self->handle);
        }

        int record_count() {
            return DBFGetRecordCount(self->handle);
        }

        int field_info(int iField, char * fieldname_out,
                       int * output_width, int * output_decimals) {
            return DBFGetFieldInfo(self->handle, iField, fieldname_out,
                                   output_width, output_decimals);
        }
            
        PyObject * read_record(int record) {
            return DBFInfo_read_record(self->handle, record);
        }

        int add_field(const char * pszFieldName, DBFFieldType eType,
                      int nWidth, int nDecimals) {
            return DBFAddField(self->handle, pszFieldName, eType, nWidth,
                               nDecimals);
        }

        PyObject *write_record(int record, PyObject *dict_or_sequence) {
            return DBFInfo_write_record(self->handle, record,
                                        dict_or_sequence);
        }

        int commit() {
            return DBFCommit(self->handle);
        }

    }
} DBFFile;


/*
 * Two module level functions, open() and create() that correspond to
 * DBFOpen and DBFCreate respectively. open() is equivalent to the
 * DBFFile constructor.
 */


%{
    DBFFile * open_DBFFile(const char * file, const char * mode)
    {
        DBFFile * self = malloc(sizeof(DBFFile));
        if (self)
            self->handle = DBFOpen(file, mode);
        return self;
    }
%}

%name(open) %new DBFFile * open_DBFFile(const char * file,
                                        const char * mode = "rb");

%{
    DBFFile * create_DBFFile(const char * file)
    {
        DBFFile * self = malloc(sizeof(DBFFile));
        if (self)
            self->handle = DBFCreate(file);
        return self;
    }
%}
%name(create) %new DBFFile * create_DBFFile(const char * file);


/* constant definitions copied from shapefil.h */
typedef enum {
  FTString,
  FTInteger,
  FTDouble,
  FTInvalid
} DBFFieldType;
1	/* SWIG (www.swig.org) interface file for the dbf interface of shapelib
2	*
3	* At the moment (Dec 2000) this file is only useful to generate Python
4	* bindings. Invoke swig as follows:
5	*
6	* swig -python -shadow dbflib.i
7	*
8	* to generate dbflib_wrap.c and dbflib.py. dbflib_wrap.c defines a
9	* bunch of Python-functions that wrap the appripriate dbflib functions
10	* and dbflib.py contains an object oriented wrapper around
11	* dbflib_wrap.c.
12	*
13	* This module defines one object type: DBFFile.
14	*/
15
16	/* this is the dbflib module */
17	%module dbflib
18
19	/* first a %{,%} block. These blocks are copied verbatim to the
20	* dbflib_wrap.c file and are not parsed by SWIG. This is the place to
21	* import headerfiles and define helper-functions that are needed by the
22	* automatically generated wrappers.
23	*/
24
25	%{
26	#include "shapefil.h"
27
28	/* the read_record method. Return the record record as a dictionary with
29	* whose keys are the names of the fields, and their values as the
30	* appropriate Python type.
31	*
32	* In case of error, set a python exception and return NULL. Since that
33	* value will be returned to the python interpreter as is, the
34	* interpreter should recognize the exception.
35	*/
36
37	static PyObject *
38	DBFInfo_read_record(DBFInfo * handle, int record)
39	{
40	int num_fields;
41	int i;
42	int type, width;
43	char name[12];
44	PyObject *dict;
45	PyObject *value;
46
47	if (record < 0 \|\| record >= DBFGetRecordCount(handle))
48	{
49	PyErr_Format(PyExc_ValueError,
50	"record index %d out of bounds (record count: %d)",
51	record, DBFGetRecordCount(handle));
52	return NULL;
53	}
54
55	dict = PyDict_New();
56	if (!dict)
57	return NULL;
58
59	num_fields = DBFGetFieldCount(handle);
60	for (i = 0; i < num_fields; i++)
61	{
62	type = DBFGetFieldInfo(handle, i, name, &width, NULL);
63	/* For strings NULL and the empty string are indistinguishable
64	* in DBF files. We prefer empty strings instead for backwards
65	* compatibility reasons because older wrapper versions returned
66	* emtpy strings as empty strings.
67	*/
68	if (type != FTString && DBFIsAttributeNULL(handle, record, i))
69	{
70	value = Py_None;
71	Py_INCREF(value);
72	}
73	else
74	{
75	switch (type)
76	{
77	case FTString:
78	{
79	const char * temp = DBFReadStringAttribute(handle, record, i);
80	if (temp)
81	{
82	value = PyString_FromString(temp);
83	}
84	else
85	{
86	PyErr_Format(PyExc_IOError,
87	"Can't read value for row %d column %d",
88	record, i);
89	value = NULL;
90	}
91	break;
92	}
93	case FTInteger:
94	value = PyInt_FromLong(DBFReadIntegerAttribute(handle, record,
95	i));
96	break;
97	case FTDouble:
98	value = PyFloat_FromDouble(DBFReadDoubleAttribute(handle,
99	record, i));
100	break;
101	default:
102	PyErr_Format(PyExc_TypeError, "Invalid field data type %d",
103	type);
104	value = NULL;
105	}
106	}
107	if (!value)
108	goto fail;
109	PyDict_SetItemString(dict, name, value);
110	Py_DECREF(value);
111	}
112
113	return dict;
114	fail:
115	Py_XDECREF(dict);
116	return NULL;
117	}
118
119	/* the write_record method. Write the record record given wither as a
120	* dictionary or a sequence (i.e. a list or a tuple).
121	*
122	* If it's a dictionary the keys must be the names of the fields and
123	* their value must have a suitable type. Only the fields actually
124	* contained in the dictionary are written. Fields for which there's no
125	* item in the dict are not modified.
126	*
127	* If it's a sequence, all fields must be present in the right order.
128	*
129	* In case of error, set a python exception and return NULL. Since that
130	* value will be returned to the python interpreter as is, the
131	* interpreter should recognize the exception.
132	*
133	* The method is implemented with two c-functions, write_field to write
134	* a single field and DBFInfo_write_record as the front-end.
135	*/
136
137
138	/* write a single field of a record. */
139	static int
140	write_field(DBFHandle handle, int record, int field, int type,
141	PyObject * value)
142	{
143	char * string_value;
144	int int_value;
145	double double_value;
146
147	if (value == Py_None)
148	{
149	if (!DBFWriteNULLAttribute(handle, record, field))
150	{
151	PyErr_Format(PyExc_IOError,
152	"can't write NULL field %d of record %d",
153	field, record);
154	return 0;
155	}
156	}
157	else
158	{
159	switch (type)
160	{
161	case FTString:
162	string_value = PyString_AsString(value);
163	if (!string_value)
164	return 0;
165	if (!DBFWriteStringAttribute(handle, record, field, string_value))
166	{
167	PyErr_Format(PyExc_IOError,
168	"can't write field %d of record %d",
169	field, record);
170	return 0;
171	}
172	break;
173
174	case FTInteger:
175	int_value = PyInt_AsLong(value);
176	if (int_value == -1 && PyErr_Occurred())
177	return 0;
178	if (!DBFWriteIntegerAttribute(handle, record, field, int_value))
179	{
180	PyErr_Format(PyExc_IOError,
181	"can't write field %d of record %d",
182	field, record);
183	return 0;
184	}
185	break;
186
187	case FTDouble:
188	double_value = PyFloat_AsDouble(value);
189	if (double_value == -1 && PyErr_Occurred())
190	return 0;
191	if (!DBFWriteDoubleAttribute(handle, record, field, double_value))
192	{
193	PyErr_Format(PyExc_IOError,
194	"can't write field %d of record %d",
195	field, record);
196	return 0;
197	}
198	break;
199
200	default:
201	PyErr_Format(PyExc_TypeError, "Invalid field data type %d", type);
202	return 0;
203	}
204	}
205
206	return 1;
207	}
208
209	static
210	PyObject *
211	DBFInfo_write_record(DBFHandle handle, int record, PyObject *record_object)
212	{
213	int num_fields;
214	int i, length;
215	int type, width;
216	char name[12];
217	PyObject * value = NULL;
218
219	num_fields = DBFGetFieldCount(handle);
220
221	/* We used to use PyMapping_Check to test whether record_object is a
222	* dictionary like object instead of PySequence_Check to test
223	* whether it's a sequence. Unfortunately in Python 2.3
224	* PyMapping_Check returns true for lists and tuples too so the old
225	* approach doesn't work anymore.
226	*/
227	if (PySequence_Check(record_object))
228	{
229	/* It's a sequence object. Iterate through all items in the
230	* sequence and write them to the appropriate field.
231	*/
232	length = PySequence_Length(record_object);
233	if (length != num_fields)
234	{
235	PyErr_SetString(PyExc_TypeError,
236	"record must have one item for each field");
237	goto fail;
238	}
239	for (i = 0; i < length; i++)
240	{
241	type = DBFGetFieldInfo(handle, i, name, &width, NULL);
242	value = PySequence_GetItem(record_object, i);
243	if (value)
244	{
245	if (!write_field(handle, record, i, type, value))
246	goto fail;
247	Py_DECREF(value);
248	}
249	else
250	{
251	goto fail;
252	}
253	}
254	}
255	else
256	{
257	/* It's a dictionary-like object. Iterate over the names of the
258	* known fields and write the corresponding item
259	*/
260	for (i = 0; i < num_fields; i++)
261	{
262	type = DBFGetFieldInfo(handle, i, name, &width, NULL);
263
264	/* if the dictionary has the key name write that object to
265	* the appropriate field, other wise just clear the python
266	* exception and do nothing.
267	*/
268	value = PyMapping_GetItemString(record_object, name);
269	if (value)
270	{
271	if (!write_field(handle, record, i, type, value))
272	goto fail;
273	Py_DECREF(value);
274	}
275	else
276	{
277	PyErr_Clear();
278	}
279	}
280	}
281
282	Py_INCREF(Py_None);
283	return Py_None;
284
285	fail:
286	Py_XDECREF(value);
287	return NULL;
288	}
289	%}
290
291
292	/*
293	* The SWIG Interface definition.
294	*/
295
296	/* include some common SWIG type definitions and standard exception
297	handling code */
298	%include typemaps.i
299	%include exception.i
300
301	/* As for ShapeFile in shapelib.i, We define a new C-struct that holds
302	* the DBFHandle. This is mainly done so we can separate the close()
303	* method from the destructor but it also helps with exception handling.
304	*
305	* After the DBFFile has been opened or created the handle is not NULL.
306	* The close() method closes the file and sets handle to NULL as an
307	* indicator that the file has been closed.
308	*/
309
310	%{
311	typedef struct {
312	DBFHandle handle;
313	} DBFFile;
314	%}
315
316
317	/* The first argument to the DBFFile methods is a DBFFile pointer.
318	* We have to check whether handle is not NULL in most methods but not
319	* all. In the destructor and the close method, it's OK for handle to be
320	* NULL. We achieve this by checking whether the preprocessor macro
321	* NOCHECK_$name is defined. SWIG replaces $name with the name of the
322	* function for which the code is inserted. In the %{,%}-block below we
323	* define the macros for the destructor and the close() method.
324	*/
325
326	%typemap(python,check) DBFFile *{
327	%#ifndef NOCHECK_$name
328	if (!$target \|\| !$target->handle)
329	SWIG_exception(SWIG_TypeError, "dbffile already closed");
330	%#endif
331	}
332
333	%{
334	#define NOCHECK_delete_DBFFile
335	#define NOCHECK_DBFFile_close
336	%}
337
338
339	/* An exception handle for the constructor and the module level open()
340	* and create() functions.
341	*
342	* Annoyingly, we have to put braces around the SWIG_exception()
343	* calls, at least in the python case, because of the way the macro is
344	* written. Of course, always putting braces around the branches of an
345	* if-statement is often considered good practice.
346	*/
347	%typemap(python,except) DBFFile * {
348	$function;
349	if (!$source)
350	{
351	SWIG_exception(SWIG_MemoryError, "no memory");
352	}
353	else if (!$source->handle)
354	{
355	SWIG_exception(SWIG_IOError, "$name failed");
356	}
357	}
358
359	/* Exception handler for the add_field method */
360	%typemap(python,except) int DBFFile_add_field {
361	$function;
362	if ($source < 0)
363	{
364	SWIG_exception(SWIG_RuntimeError, "add_field failed");
365	}
366	}
367
368	/* define and use some typemaps for the field_info() method whose
369	* C-implementation has three output parameters that are returned
370	* through pointers passed into the function. SWIG already has
371	* definitions for common types such as int* and we can use those for
372	* the last two parameters:
373	*/
374
375	%apply int * OUTPUT { int * output_width }
376	%apply int * OUTPUT { int * output_decimals }
377
378	/* the fieldname has to be defined manually: */
379	%typemap(python,ignore) char *fieldname_out(char temp[12]) {
380	$target = temp;
381	}
382
383	%typemap(python,argout) char *fieldname_out() {
384	PyObject * string = PyString_FromString($source);
385	$target = t_output_helper($target,string);
386	}
387
388
389
390	/*
391	* The SWIG-version of the DBFFile struct
392	*/
393
394	typedef struct
395	{
396	%addmethods {
397	DBFFile(const char file, const char mode = "rb") {
398	DBFFile * self = malloc(sizeof(DBFFile));
399	if (self)
400	self->handle = DBFOpen(file, mode);
401	return self;
402	}
403
404	~DBFFile() {
405	if (self->handle)
406	DBFClose(self->handle);
407	free(self);
408	}
409
410	void close() {
411	if (self->handle)
412	DBFClose(self->handle);
413	self->handle = NULL;
414	}
415
416	int field_count() {
417	return DBFGetFieldCount(self->handle);
418	}
419
420	int record_count() {
421	return DBFGetRecordCount(self->handle);
422	}
423
424	int field_info(int iField, char * fieldname_out,
425	int * output_width, int * output_decimals) {
426	return DBFGetFieldInfo(self->handle, iField, fieldname_out,
427	output_width, output_decimals);
428	}
429
430	PyObject * read_record(int record) {
431	return DBFInfo_read_record(self->handle, record);
432	}
433
434	int add_field(const char * pszFieldName, DBFFieldType eType,
435	int nWidth, int nDecimals) {
436	return DBFAddField(self->handle, pszFieldName, eType, nWidth,
437	nDecimals);
438	}
439
440	PyObject write_record(int record, PyObject dict_or_sequence) {
441	return DBFInfo_write_record(self->handle, record,
442	dict_or_sequence);
443	}
444
445	int commit() {
446	return DBFCommit(self->handle);
447	}
448
449	}
450	} DBFFile;
451
452
453	/*
454	* Two module level functions, open() and create() that correspond to
455	* DBFOpen and DBFCreate respectively. open() is equivalent to the
456	* DBFFile constructor.
457	*/
458
459
460	%{
461	DBFFile * open_DBFFile(const char * file, const char * mode)
462	{
463	DBFFile * self = malloc(sizeof(DBFFile));
464	if (self)
465	self->handle = DBFOpen(file, mode);
466	return self;
467	}
468	%}
469
470	%name(open) %new DBFFile * open_DBFFile(const char * file,
471	const char * mode = "rb");
472
473	%{
474	DBFFile * create_DBFFile(const char * file)
475	{
476	DBFFile * self = malloc(sizeof(DBFFile));
477	if (self)
478	self->handle = DBFCreate(file);
479	return self;
480	}
481	%}
482	%name(create) %new DBFFile * create_DBFFile(const char * file);
483
484
485
486	/* constant definitions copied from shapefil.h */
487	typedef enum {
488	FTString,
489	FTInteger,
490	FTDouble,
491	FTInvalid
492	} DBFFieldType;
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision