1 // Copyright 2003 (c) Barry Rowlingson
2 // Modified 2006 Roger Bivand
3 // OGR data source interface
4 //
5 //  note: the following objects must be deleted or memory leaks:
6 // OGRDataSource
7 // OGRFeature
8 //
9 //  the following objects are owned by their parents, and so
10 //  shouldnt be deleted (they get cleaned up when their parent is deleted)
11 // OGRLayer
12 // OGRGeometry
13 // OGRFeatureDefn
14 // OGRSpatialReference
15 //
16 // see ogrsf_frmts.dox for authoritative notes!
17 
18 #include "ogrsf_frmts.h"
19 
20 // R headers moved outside extern "C" 070808 RSB re. note from BDR
21 //extern "C" {
22 #include <R.h>
23 #include <Rinternals.h>
24 #include <Rdefines.h>
25 //}
26 #include "rgdal.h"
27 
28 #ifdef __cplusplus
29 extern "C" {
30 #endif
31 
32 //#define EJP
33 
34 // extern "C" {
RGDAL_ogrInfo(SEXP ogrsourcename,SEXP Layer)35   SEXP RGDAL_ogrInfo(SEXP ogrsourcename, SEXP Layer){
36     // return FIDs, nFields, fieldInfo
37 
38     SEXP ans, vec1, vec2, vec3,/*mat,*/drv, dvec;
39     SEXP itemlist, itemnames, itemwidth, itemtype, itemTypeNames;
40     SEXP itemlistmaxcount;
41 #ifdef GDALV2
42     SEXP dFIDs;
43 #endif
44     /*SEXP geotype;*/
45 
46     int nFIDs, nFields, iField, *nCount, pc=0;
47 
48 #ifdef GDALV2
49     GDALDriver *poDriver;
50     GDALDataset *poDS;
51 #else
52     OGRDataSource *poDS;
53     OGRSFDriver *poDriver;
54 #endif
55     OGRLayer *poLayer;
56     OGRFeature *poFeature;
57     OGRFeatureDefn *poDefn;
58   /*  OGRGeometry *poGeom;*/
59 
60     installErrorHandler();
61 #ifdef GDALV2
62     poDS=(GDALDataset*) GDALOpenEx(CHAR(STRING_ELT(ogrsourcename, 0)), GDAL_OF_VECTOR, NULL, NULL, NULL);
63     if(poDS==NULL){
64       uninstallErrorHandlerAndTriggerError();
65       error("Cannot open data source");
66     }
67     poDriver = poDS->GetDriver();
68 #else
69     poDS=OGRSFDriverRegistrar::Open(CHAR(STRING_ELT(ogrsourcename, 0)),
70 	FALSE, &poDriver);
71 #endif
72     uninstallErrorHandlerAndTriggerError();
73 
74     if(poDS==NULL){
75       installErrorHandler();
76 #ifdef GDALV2
77       GDALClose( poDS );
78 #else
79       OGRDataSource::DestroyDataSource( poDS );
80 #endif
81       uninstallErrorHandlerAndTriggerError();
82 //    delete poDS;
83       error("Cannot open file");
84     }
85 
86     installErrorHandler();
87     poLayer = poDS->GetLayerByName(CHAR(STRING_ELT(Layer, 0)));
88     uninstallErrorHandlerAndTriggerError();
89 
90     if(poLayer == NULL){
91       installErrorHandler();
92 #ifdef GDALV2
93       GDALClose( poDS );
94 #else
95       OGRDataSource::DestroyDataSource( poDS );
96 #endif
97       uninstallErrorHandlerAndTriggerError();
98 //    delete poDS;
99       error("Cannot open layer");
100     }
101 
102     // allocate a list for return values
103     PROTECT(ans=allocVector(VECSXP,6)); pc++;
104 
105     PROTECT(drv=allocVector(STRSXP,1)); pc++;
106     installErrorHandler();
107 #ifdef GDALV2
108     SET_STRING_ELT(drv, 0, mkChar(poDriver->GetDescription()));
109 #else
110     SET_STRING_ELT(drv, 0, mkChar(poDriver->GetName()));
111 #endif
112     uninstallErrorHandlerAndTriggerError();
113     SET_VECTOR_ELT(ans,3,drv);
114 
115     PROTECT(vec1=allocVector(INTSXP,1)); pc++;
116     installErrorHandler();
117 #ifdef GDALV2
118     GIntBig nFIDs64 = poLayer->GetFeatureCount();
119     nFIDs = (nFIDs64 > INT_MAX) ? INT_MAX :
120         (nFIDs64 < INT_MIN) ? INT_MIN : (int) nFIDs64;
121     if ((GIntBig) nFIDs != nFIDs64){
122         warning("ogrInfo: feature count overflow");
123         INTEGER(vec1)[0]=NA_INTEGER;
124         PROTECT(dFIDs=NEW_NUMERIC(1)); pc++;
125         NUMERIC_POINTER(dFIDs)[0] = (double) nFIDs64;
126         setAttrib(vec1, install("dFIDs"), dFIDs);
127     } else {
128     // store number of FIDs
129         INTEGER(vec1)[0]=nFIDs;
130     }
131 #else
132     nFIDs   = poLayer->GetFeatureCount();
133     // store number of FIDs
134     INTEGER(vec1)[0]=nFIDs;
135 #endif
136     uninstallErrorHandlerAndTriggerError();
137 
138     if (nFIDs == -1) {
139       int i=0;
140       installErrorHandler();
141       while( ((poFeature = poLayer->GetNextFeature()) != NULL) && i <= INT_MAX){
142         i++;
143         OGRFeature::DestroyFeature( poFeature );
144 //    delete poFeature;
145       }
146       uninstallErrorHandlerAndTriggerError();
147       if (i == INT_MAX) {
148         error("ogrInfo: undeclared feature count overflow");
149       } else {
150         nFIDs = i;
151         warning("ogrInfo: feature count not given; %d counted", nFIDs);
152       }
153       installErrorHandler();
154       poLayer->ResetReading();
155       uninstallErrorHandlerAndTriggerError();
156 
157       INTEGER(vec1)[0]=nFIDs;
158     }
159 
160     SET_VECTOR_ELT(ans,0,vec1);
161 
162 
163 
164     // store other stuff....
165     installErrorHandler();
166     poDefn = poLayer->GetLayerDefn();
167     nFields =  poDefn->GetFieldCount();
168     uninstallErrorHandlerAndTriggerError();
169 
170     // store number of fields
171     PROTECT(vec2=allocVector(INTSXP,1)); pc++;
172     INTEGER(vec2)[0]=nFields;
173     SET_VECTOR_ELT(ans,1,vec2);
174     installErrorHandler();
175     OGREnvelope oExt;
176     if (poLayer->GetExtent(&oExt, TRUE) == OGRERR_NONE) {
177         PROTECT(dvec=allocVector(REALSXP,4)); pc++;
178         REAL(dvec)[0] = oExt.MinX;
179         REAL(dvec)[1] = oExt.MinY;
180         REAL(dvec)[2] = oExt.MaxX;
181         REAL(dvec)[3] = oExt.MaxY;
182         SET_VECTOR_ELT(ans,4,dvec);
183     }
184     uninstallErrorHandlerAndTriggerError();
185 
186     PROTECT(itemnames=allocVector(STRSXP,nFields)); pc++;
187     PROTECT(itemtype=allocVector(INTSXP,nFields)); pc++;
188     PROTECT(itemwidth=allocVector(INTSXP,nFields)); pc++;
189 // try List types
190     PROTECT(itemlistmaxcount=allocVector(INTSXP,nFields)); pc++;
191     PROTECT(itemTypeNames=allocVector(STRSXP,nFields)); pc++;
192     int listFieldCount=0;
193 
194     installErrorHandler();
195     for(iField=0;iField<nFields;iField++){
196       OGRFieldDefn *poField = poDefn->GetFieldDefn(iField);
197       SET_STRING_ELT(itemnames,iField,mkChar(poField->GetNameRef()));
198       INTEGER(itemtype)[iField]=poField->GetType();
199       if (INTEGER(itemtype)[iField] == OFTIntegerList ||
200 #ifdef GDALV2
201          INTEGER(itemtype)[iField] == OFTInteger64List ||
202 #endif
203          INTEGER(itemtype)[iField] == OFTRealList ||
204          INTEGER(itemtype)[iField] == OFTStringList) listFieldCount++;
205       INTEGER(itemwidth)[iField]=poField->GetWidth();
206       SET_STRING_ELT(itemTypeNames,iField,mkChar(poField->GetFieldTypeName(
207         poField->GetType())));
208       INTEGER(itemlistmaxcount)[iField] = 0;
209     }
210     uninstallErrorHandlerAndTriggerError();
211 
212     PROTECT(vec3=allocVector(INTSXP,1)); pc++;
213     INTEGER(vec3)[0]=listFieldCount;
214     SET_VECTOR_ELT(ans,5,vec3);
215     PROTECT(itemlist=allocVector(VECSXP,5)); pc++;
216     SET_VECTOR_ELT(itemlist,0,itemnames);
217     SET_VECTOR_ELT(itemlist,1,itemtype);
218     SET_VECTOR_ELT(itemlist,2,itemwidth);
219     SET_VECTOR_ELT(itemlist,3,itemTypeNames);
220 // try List types
221     if (listFieldCount > 0) {
222 
223         poLayer->ResetReading();
224         OGRFeature* poFeature;
225 
226         nCount = (int *) R_alloc((size_t) nFields, sizeof(int));
227         for (iField=0; iField<nFields; iField++) nCount[iField] = 0;
228         installErrorHandler();
229         OGRField* psField;
230         while( (poFeature = poLayer->GetNextFeature()) != NULL ){
231             for(iField=0; iField<nFields; iField++){
232                 psField = poFeature->GetRawFieldRef(iField);
233                 if (INTEGER(itemtype)[iField] == OFTIntegerList) {
234                     nCount[iField] = psField->IntegerList.nCount;
235                     if (nCount[iField] > INTEGER(itemlistmaxcount)[iField])
236                         INTEGER(itemlistmaxcount)[iField] = nCount[iField];
237                 } else if (INTEGER(itemtype)[iField] == OFTRealList) {
238                     nCount[iField] = psField->RealList.nCount;
239                     if (nCount[iField] > INTEGER(itemlistmaxcount)[iField])
240                         INTEGER(itemlistmaxcount)[iField] = nCount[iField];
241                 } else if (INTEGER(itemtype)[iField] == OFTStringList) {
242                     nCount[iField] = psField->StringList.nCount;
243                     if (nCount[iField] > INTEGER(itemlistmaxcount)[iField])
244                         INTEGER(itemlistmaxcount)[iField] = nCount[iField];
245 #ifdef GDALV2
246                 } else if (INTEGER(itemtype)[iField] == OFTInteger64List) {
247                     nCount[iField] = psField->StringList.nCount;
248                     if (nCount[iField] > INTEGER(itemlistmaxcount)[iField])
249                         INTEGER(itemlistmaxcount)[iField] = nCount[iField];
250 #endif
251                 }
252             }
253             OGRFeature::DestroyFeature( poFeature );
254 //    delete poFeature;
255         }
256         uninstallErrorHandlerAndTriggerError();
257 
258     }
259     SET_VECTOR_ELT(itemlist,4,itemlistmaxcount);
260     SET_VECTOR_ELT(ans,2,itemlist);
261 
262 
263     installErrorHandler();
264 #ifdef GDALV2
265     GDALClose( poDS );
266 #else
267     OGRDataSource::DestroyDataSource( poDS );
268 #endif
269     uninstallErrorHandlerAndTriggerError();
270 //    delete poDS;
271     UNPROTECT(pc);
272     return(ans);
273 
274   }
275 // }
276 #ifdef __cplusplus
277 }
278 #endif
279 
280 
281 #ifdef __cplusplus
282 extern "C" {
283 #endif
284 //extern "C" {
RGDAL_ogrFIDs(SEXP filename,SEXP layer)285   SEXP RGDAL_ogrFIDs(SEXP filename, SEXP layer){
286   SEXP fids, nf, ii;
287   int /*layerNum,*/i;
288   int nFeatures, pc=0;
289   OGRLayer *poLayer;
290   OGRFeature *poFeature;
291 #ifdef GDALV2
292     GDALDataset *poDS;
293 #else
294     OGRDataSource *poDS;
295     OGRSFDriver *poDriver;
296 #endif
297 
298   installErrorHandler();
299 #ifdef GDALV2
300     poDS=(GDALDataset*) GDALOpenEx(CHAR(STRING_ELT(filename, 0)), GDAL_OF_VECTOR, NULL, NULL, NULL);
301 #else
302   poDS=OGRSFDriverRegistrar::Open(CHAR(STRING_ELT(filename, 0)),
303 	FALSE, &poDriver);
304 #endif
305   uninstallErrorHandlerAndTriggerError();
306 
307   if(poDS==NULL){
308     error("Cannot open file");
309   }
310 
311   installErrorHandler();
312   poLayer = poDS->GetLayerByName(CHAR(STRING_ELT(layer, 0)));
313   uninstallErrorHandlerAndTriggerError();
314 
315   if(poLayer == NULL){
316     error("Cannot open layer");
317   }
318   installErrorHandler();
319 #ifdef GDALV2
320   GIntBig nFIDs64 = poLayer->GetFeatureCount();
321   nFeatures = (nFIDs64 > INT_MAX) ? INT_MAX :
322         (nFIDs64 < INT_MIN) ? INT_MIN : (int) nFIDs64;
323   if ((GIntBig) nFeatures != nFIDs64){
324         uninstallErrorHandlerAndTriggerError();
325         error("ogrFIDs: feature count overflow");
326   }
327 #else
328   nFeatures=poLayer->GetFeatureCount();
329 #endif
330   uninstallErrorHandlerAndTriggerError();
331 
332   if (nFeatures == -1) {
333     i=0;
334     installErrorHandler();
335     while( ((poFeature = poLayer->GetNextFeature()) != NULL) && i <= INT_MAX){
336       i++;
337       OGRFeature::DestroyFeature( poFeature );
338 //    delete poFeature;
339     }
340     uninstallErrorHandlerAndTriggerError();
341     installErrorHandler();
342     poLayer->ResetReading();
343     uninstallErrorHandlerAndTriggerError();
344     if (i == INT_MAX) {
345       error("ogrFIDs: feature count overflow");
346     } else {
347       nFeatures = i;
348     }
349   }
350 
351   PROTECT(fids=allocVector(INTSXP,nFeatures)); pc++;
352   PROTECT(nf = NEW_INTEGER(1)); pc++;
353   INTEGER_POINTER(nf)[0] = nFeatures;
354   PROTECT(ii = NEW_INTEGER(1)); pc++;
355 
356   installErrorHandler();
357   poLayer->ResetReading();
358   uninstallErrorHandlerAndTriggerError();
359 
360 
361   i=0;
362   installErrorHandler();
363   while( (poFeature = poLayer->GetNextFeature()) != NULL ){
364     INTEGER(fids)[i]= (int) poFeature->GetFID();
365     i++;
366     OGRFeature::DestroyFeature( poFeature );
367 //    delete poFeature;
368   }
369   uninstallErrorHandlerAndTriggerError();
370 
371   INTEGER_POINTER(ii)[0] = i;
372   setAttrib(fids, install("nf"), nf);
373   setAttrib(fids, install("i"), ii);
374 
375   installErrorHandler();
376 #ifdef GDALV2
377   GDALClose( poDS );
378 #else
379   OGRDataSource::DestroyDataSource( poDS );
380 #endif
381   uninstallErrorHandlerAndTriggerError();
382 //  delete poDS;
383 
384   UNPROTECT(pc);
385   return(fids);
386 
387   }
388 // }
389 #ifdef __cplusplus
390 }
391 #endif
392 
393 #ifdef __cplusplus
394 extern "C" {
395 #endif
396 // extern "C" {
397 
ogrReadColumn(OGRLayer * poLayer,SEXP FIDs,int iField,int int64)398   SEXP ogrReadColumn(OGRLayer *poLayer, SEXP FIDs, int iField, int int64){
399     // read feature data and return something according to the type
400     OGRFeatureDefn *poDefn;
401     OGRFieldDefn *poField;
402     OGRFeature *poFeature;
403     int iRow, nRows, warn_int64=0;
404     double dbl_max_int64 = pow(2.0, 53);
405     SEXP ans = R_NilValue;
406 
407     nRows=length(FIDs);
408     // get field data from layer
409     installErrorHandler();
410     poDefn = poLayer->GetLayerDefn();
411     poField = poDefn->GetFieldDefn(iField);
412     uninstallErrorHandlerAndTriggerError();
413     if(poField == NULL){
414       error("Error getting field %d ",iField);
415     }
416     // allocate an object for the result depending on the feature type:
417     installErrorHandler();
418     switch(poField->GetType()){
419     case OFTInteger:
420       PROTECT(ans=allocVector(INTSXP,nRows));
421       break;
422 #ifdef GDALV2
423     case OFTInteger64:
424       if (int64 == 4) {
425           PROTECT(ans=allocVector(REALSXP,nRows));
426       } else if (int64 ==3) {
427           PROTECT(ans=allocVector(STRSXP,nRows));
428       } else {
429          PROTECT(ans=allocVector(INTSXP,nRows));
430       }
431       break;
432 #endif
433     case OFTReal:
434       PROTECT(ans=allocVector(REALSXP,nRows));
435       break;
436     case OFTString:
437       PROTECT(ans=allocVector(STRSXP,nRows));
438       break;
439       case OFTDate:
440 	PROTECT(ans=allocVector(STRSXP,nRows));
441 	break;
442       case OFTDateTime:
443 	PROTECT(ans=allocVector(STRSXP,nRows));
444 	break;
445       case OFTTime:
446 	PROTECT(ans=allocVector(STRSXP,nRows));
447 	break;
448     default:
449         const char *desc = poField->GetFieldTypeName(poField->GetType());
450         uninstallErrorHandlerAndTriggerError();
451         error("unsupported field type: %s", desc);
452 	break;
453     }
454     uninstallErrorHandlerAndTriggerError();
455 
456     // now go over each row and retrieve data. iRow is an index in a
457     // vector of FIDs
458 /*#ifndef EJP
459     installErrorHandler();
460     for(iRow=0;iRow<nRows;iRow++){
461       poFeature=poLayer->GetFeature(INTEGER(FIDs)[iRow]);
462       if(poFeature == NULL){
463 	error("Error getting feature FID: %d",(INTEGER(FIDs)[iRow]));
464       }
465     }
466     uninstallErrorHandlerAndTriggerError();
467 #else*/
468     // EJP, changed into:
469     installErrorHandler();
470     poLayer->ResetReading();
471     iRow = 0;
472     while((poFeature = poLayer->GetNextFeature()) != NULL) {
473 //#endif
474       // now get the value using the right type:
475       switch(poField->GetType()){
476       case OFTInteger:
477 #if ((GDAL_VERSION_MAJOR == 2 && GDAL_VERSION_MINOR >= 2) || GDAL_VERSION_MAJOR > 2)
478         if (poFeature->IsFieldSetAndNotNull(iField))
479 #else
480 	if (poFeature->IsFieldSet(iField))
481 #endif
482           INTEGER(ans)[iRow]=poFeature->GetFieldAsInteger(iField);
483 	else INTEGER(ans)[iRow]=NA_INTEGER;
484 	break;
485 #ifdef GDALV2
486       case OFTInteger64:
487 #if (GDAL_VERSION_MINOR >= 2 || GDAL_VERSION_MAJOR > 2)
488         if (poFeature->IsFieldSetAndNotNull(iField)) {
489 #else
490 	if (poFeature->IsFieldSet(iField)) {
491 #endif
492             if (int64 == 4) {
493                     REAL(ans)[iRow] = poFeature->GetFieldAsDouble(iField);
494                     if (REAL(ans)[iRow] > dbl_max_int64) warn_int64 = 1;
495             } else if (int64 == 3) {
496                 SET_STRING_ELT(ans, iRow,
497                     mkChar(poFeature->GetFieldAsString(iField)));
498             } else {
499                 GIntBig nVal64 = poFeature->GetFieldAsInteger64(iField);
500                 int nVal = (nVal64 > INT_MAX) ? INT_MAX :
501                     (nVal64 < INT_MIN) ? INT_MIN : (int) nVal64;
502                 INTEGER(ans)[iRow]=nVal;
503                 if (((GIntBig)nVal != nVal64) && int64 == 2) {
504                     warning("Integer64 value clamped: feature %d", iRow);
505                 }
506             }
507         } else {
508             if (int64 == 3) {
509                 SET_STRING_ELT(ans, iRow, NA_STRING);
510             } else {
511                 INTEGER(ans)[iRow]=NA_INTEGER;
512             }
513         }
514 	break;
515 #endif
516       case OFTReal:
517 #if ((GDAL_VERSION_MAJOR == 2 && GDAL_VERSION_MINOR >= 2) || GDAL_VERSION_MAJOR > 2)
518         if (poFeature->IsFieldSetAndNotNull(iField))
519 #else
520 	if (poFeature->IsFieldSet(iField))
521 #endif
522           REAL(ans)[iRow]=poFeature->GetFieldAsDouble(iField);
523 	else REAL(ans)[iRow]=NA_REAL;
524 	break;
525       case OFTString:
526 #if ((GDAL_VERSION_MAJOR == 2 && GDAL_VERSION_MINOR >= 2) || GDAL_VERSION_MAJOR > 2)
527         if (poFeature->IsFieldSetAndNotNull(iField))
528 #else
529 	if (poFeature->IsFieldSet(iField))
530 #endif
531           SET_STRING_ELT(ans,iRow,mkChar(poFeature->GetFieldAsString(iField)));
532 	else SET_STRING_ELT(ans, iRow, NA_STRING);
533 	break;
534       case OFTDate:
535 #if ((GDAL_VERSION_MAJOR == 2 && GDAL_VERSION_MINOR >= 2) || GDAL_VERSION_MAJOR > 2)
536         if (poFeature->IsFieldSetAndNotNull(iField))
537 #else
538 	if (poFeature->IsFieldSet(iField))
539 #endif
540           SET_STRING_ELT(ans,iRow,mkChar(poFeature->GetFieldAsString(iField)));
541 	else SET_STRING_ELT(ans, iRow, NA_STRING);
542 	break;
543       case OFTDateTime:
544 #if ((GDAL_VERSION_MAJOR == 2 && GDAL_VERSION_MINOR >= 2) || GDAL_VERSION_MAJOR > 2)
545         if (poFeature->IsFieldSetAndNotNull(iField))
546 #else
547 	if (poFeature->IsFieldSet(iField))
548 #endif
549           SET_STRING_ELT(ans,iRow,mkChar(poFeature->GetFieldAsString(iField)));
550 	else SET_STRING_ELT(ans, iRow, NA_STRING);
551 	break;
552       case OFTTime:
553 #if ((GDAL_VERSION_MAJOR == 2 && GDAL_VERSION_MINOR >= 2) || GDAL_VERSION_MAJOR > 2)
554         if (poFeature->IsFieldSetAndNotNull(iField))
555 #else
556 	if (poFeature->IsFieldSet(iField))
557 #endif
558           SET_STRING_ELT(ans,iRow,mkChar(poFeature->GetFieldAsString(iField)));
559 	else SET_STRING_ELT(ans, iRow, NA_STRING);
560 	break;
561 
562       default:
563         OGRFeature::DestroyFeature( poFeature );
564 //        delete poFeature;
565         uninstallErrorHandlerAndTriggerError();
566 	error("Unsupported field type. should have been caught before");
567       }
568       OGRFeature::DestroyFeature( poFeature );
569 //      delete poFeature;
570 //#ifdef EJP
571       // according to tutorial: OGRFeature::DestroyFeature(poFeature);
572       // see comment FW in OGR tutorial: We could just "delete" it,
573       // but this can cause problems in windows builds where the GDAL DLL
574       // has a different "heap" from the main program. To be on the safe
575       // side we use a GDAL function to delete the feature.
576       iRow++;
577 //#endif
578     }
579     if (warn_int64 == 1) {
580         warning("Integer64 values larger than %g lost significance after conversion to double", dbl_max_int64);
581     }
582     uninstallErrorHandlerAndTriggerError();
583     UNPROTECT(1);
584     return(ans);
585   }
586 // }
587 #ifdef __cplusplus
588 }
589 #endif
590 
591 
592 #ifdef __cplusplus
593 extern "C" {
594 #endif
595 // extern "C" {
596 
ogrReadListColumn(OGRLayer * poLayer,SEXP FIDs,int iField,int k,int int64)597   SEXP ogrReadListColumn(OGRLayer *poLayer, SEXP FIDs, int iField, int k, int int64){
598     // read feature data and return something according to the type
599     OGRFeatureDefn *poDefn;
600     OGRFieldDefn *poField;
601     OGRFeature *poFeature;
602     int iRow,nRows,nlist;
603     SEXP ans = R_NilValue;
604 
605     nRows=length(FIDs);
606     // get field data from layer
607     installErrorHandler();
608     poDefn = poLayer->GetLayerDefn();
609     poField = poDefn->GetFieldDefn(iField);
610     uninstallErrorHandlerAndTriggerError();
611     if(poField == NULL){
612       error("Error getting field %d ",iField);
613     }
614     // allocate an object for the result depending on the feature type:
615     installErrorHandler();
616     switch(poField->GetType()){
617     case OFTIntegerList:
618       PROTECT(ans=allocVector(INTSXP,nRows));
619       break;
620 #ifdef GDALV2
621     case OFTInteger64List:
622       if (int64 == 4) {
623           PROTECT(ans=allocVector(REALSXP,nRows));
624       } else if (int64 == 3) {
625           PROTECT(ans=allocVector(STRSXP,nRows));
626       } else {
627           PROTECT(ans=allocVector(INTSXP,nRows));
628       }
629       break;
630 #endif
631     case OFTRealList:
632       PROTECT(ans=allocVector(REALSXP,nRows));
633       break;
634     case OFTStringList:
635       PROTECT(ans=allocVector(STRSXP,nRows));
636       break;
637     default:
638         const char *desc = poField->GetFieldTypeName(poField->GetType());
639         uninstallErrorHandlerAndTriggerError();
640         error("unsupported field type: %s", desc);
641 	break;
642     }
643     uninstallErrorHandlerAndTriggerError();
644 
645     // now go over each row and retrieve data. iRow is an index in a
646     // vector of FIDs
647     installErrorHandler();
648     poLayer->ResetReading();
649     OGRField* psField;
650     iRow = 0;
651     double DINT_MAX = 2251799813685248.0;
652     double DINT_MIN = -2251799813685248.0;
653 
654     while((poFeature = poLayer->GetNextFeature()) != NULL) {
655 #if ((GDAL_VERSION_MAJOR == 2 && GDAL_VERSION_MINOR >= 2) || GDAL_VERSION_MAJOR > 2)
656         if (poFeature->IsFieldSetAndNotNull(iField)) {
657 #else
658 	if (poFeature->IsFieldSet(iField)) {
659 #endif
660 
661       // now get the value using the right type:
662         psField = poFeature->GetRawFieldRef(iField);
663 
664         switch(poField->GetType()){
665         case OFTIntegerList:
666           nlist = psField->IntegerList.nCount;
667 	  if (k < nlist)
668             INTEGER(ans)[iRow] = psField->IntegerList.paList[k];
669 	  else INTEGER(ans)[iRow]=NA_INTEGER;
670 	  break;
671 #ifdef GDALV2
672         case OFTInteger64List:
673           nlist = psField->Integer64List.nCount;
674 	  if (k < nlist) {
675             GIntBig nVal64 = psField->Integer64List.paList[k];
676             if (int64 == 4) {
677                     REAL(ans)[iRow] = (double) nVal64;
678             } else if (int64 == 3) {
679                 double dnval = (double) nVal64;
680                 if (dnval > DINT_MAX || dnval < DINT_MIN)
681                     warning("Integer64 value clamped: feature %d", iRow);
682                 char szItem[32];
683 // CPL FORMAT assumes > ISO C++98
684                 snprintf(szItem, sizeof(szItem), "%.0f", dnval);
685                 SET_STRING_ELT(ans, iRow, mkChar(szItem));
686             } else {
687                 int nVal = (nVal64 > INT_MAX) ? INT_MAX :
688                     (nVal64 < INT_MIN) ? INT_MIN : (int) nVal64;
689                 if (((GIntBig)nVal != nVal64) && int64 == 2) {
690                     warning("Integer64 value clamped: feature %d", iRow);
691                 }
692                 INTEGER(ans)[iRow]=nVal;
693             }
694           } else {
695             if (int64 == 3) {
696                 SET_STRING_ELT(ans, iRow, NA_STRING);
697             } else {
698                 INTEGER(ans)[iRow]=NA_INTEGER;
699             }
700           }
701 	  break;
702 #endif
703 
704         case OFTRealList:
705           nlist = psField->RealList.nCount;
706 	  if (k < nlist)
707             REAL(ans)[iRow] = psField->RealList.paList[k];
708 	  else REAL(ans)[iRow]=NA_REAL;
709 	  break;
710 
711         case OFTStringList:
712           nlist = psField->StringList.nCount;
713 	  if (k < nlist)
714             SET_STRING_ELT(ans,iRow,mkChar(psField->StringList.paList[k]));
715 	  else SET_STRING_ELT(ans, iRow, NA_STRING);
716 	  break;
717 
718         default:
719           OGRFeature::DestroyFeature( poFeature );
720 //        delete poFeature;
721           uninstallErrorHandlerAndTriggerError();
722 	  error("Unsupported field type. should have been caught before");
723         }
724       }
725       OGRFeature::DestroyFeature( poFeature );
726 //      delete poFeature;
727       iRow++;
728     }
729     uninstallErrorHandlerAndTriggerError();
730     UNPROTECT(1);
731     return(ans);
732   }
733 // }
734 #ifdef __cplusplus
735 }
736 #endif
737 
738 
739 #ifdef __cplusplus
740 extern "C" {
741 #endif
742 // extern "C" {
ogrDataFrame(SEXP ogrSource,SEXP Layer,SEXP FIDs,SEXP iFields)743   SEXP ogrDataFrame(SEXP ogrSource, SEXP Layer, SEXP FIDs, SEXP iFields){
744     // query an OGR data source and return a list
745     SEXP ans;
746     SEXP nListFields, ListFields=R_NilValue, int64;
747     OGRLayer *poLayer;
748 #ifdef GDALV2
749     GDALDataset *poDS;
750 #else
751     OGRDataSource *poDS;
752     OGRSFDriver *poDriver;
753 #endif
754 
755     int iField, nflds=length(iFields), j=0, k;
756     int pc=0;
757 
758     // open the data source layer or error
759     installErrorHandler();
760 #ifdef GDALV2
761     poDS=(GDALDataset*) GDALOpenEx(CHAR(STRING_ELT(ogrSource, 0)), GDAL_OF_VECTOR, NULL, NULL, NULL);
762 #else
763     poDS=OGRSFDriverRegistrar::Open(CHAR(STRING_ELT(ogrSource,0)),
764       FALSE, &poDriver);
765 #endif
766     uninstallErrorHandlerAndTriggerError();
767 
768     if(poDS==NULL){
769       error("Cannot open file");
770     }
771 
772     installErrorHandler();
773     poLayer = poDS->GetLayerByName(CHAR(STRING_ELT(Layer, 0)));
774     uninstallErrorHandlerAndTriggerError();
775 
776     if(poLayer == NULL){
777       error("Cannot open layer");
778     }
779 
780     PROTECT(int64 = getAttrib(iFields, install("int64"))); pc++;
781     PROTECT(nListFields = getAttrib(iFields, install("nListFields"))); pc++;
782 
783     // reserve a list for the result
784     if (INTEGER_POINTER(nListFields)[0] == 0) {
785         PROTECT(ans=allocVector(VECSXP,length(iFields))); pc++;
786     } else {
787         nflds = INTEGER_POINTER(getAttrib(iFields, install("nflds")))[0];
788         PROTECT(ans=allocVector(VECSXP,nflds)); pc++;
789         PROTECT(ListFields = getAttrib(iFields, install("ListFields"))); pc++;
790     }
791     // now set each element of the list
792     installErrorHandler();
793     if (INTEGER_POINTER(nListFields)[0] == 0) {
794       for(iField=0;iField<length(iFields);iField++){
795         SET_VECTOR_ELT(ans,iField,ogrReadColumn(poLayer, FIDs, INTEGER(iFields)[iField], INTEGER(int64)[0]));
796       }
797     } else {
798         j=0;
799         for(iField=0;iField<length(iFields);iField++){
800             if (INTEGER_POINTER(ListFields)[iField] == 0) {
801                 SET_VECTOR_ELT(ans, j,
802                     ogrReadColumn(poLayer, FIDs, INTEGER(iFields)[iField], INTEGER(int64)[0]));
803                 j++;
804             } else {
805                 for (k=0; k < INTEGER_POINTER(ListFields)[iField]; k++) {
806                     SET_VECTOR_ELT(ans, j,
807                         ogrReadListColumn(poLayer, FIDs,
808                         INTEGER(iFields)[iField], k, INTEGER(int64)[0]));
809                     j++;
810                 }
811             }
812         }
813     }
814     uninstallErrorHandlerAndTriggerError();
815     // clean up and return
816     installErrorHandler();
817 #ifdef GDALV2
818     GDALClose( poDS );
819 #else
820     OGRDataSource::DestroyDataSource( poDS );
821 #endif
822 //    delete poDS;
823     uninstallErrorHandlerAndTriggerError();
824     UNPROTECT(pc);
825     return(ans);
826   }
827 
828 // }
829 #ifdef __cplusplus
830 }
831 #endif
832 
833 
834 #ifdef __cplusplus
835 extern "C" {
836 #endif
837 // extern "C" {
838 /*  SEXP OGRFeatureInfo (SEXP ogrSource, SEXP Layer){ unused function
839     SEXP ans=NULL;
840     OGRLayer *poLayer;
841     OGRDataSource *poDS;
842     OGRFeatureDefn *poDefn;
843     OGRSFDriver *poDriver;
844 
845     installErrorHandler();
846     poDS=OGRSFDriverRegistrar::Open(CHAR(STRING_ELT(ogrSource,0)),
847 	FALSE, &poDriver);
848     uninstallErrorHandlerAndTriggerError();
849 
850     if(poDS==NULL){
851       error("Cannot open file");
852     }
853 
854     installErrorHandler();
855     poLayer = poDS->GetLayerByName(CHAR(STRING_ELT(Layer, 0)));
856     uninstallErrorHandlerAndTriggerError();
857 
858     if(poLayer == NULL){
859       error("Cannot open layer");
860     }
861     installErrorHandler();
862     poDefn = poLayer->GetLayerDefn();
863     uninstallErrorHandlerAndTriggerError();
864     installErrorHandler();
865     for( int iAttr = 0; iAttr < poDefn->GetFieldCount(); iAttr++ )
866       {
867 	OGRFieldDefn    *poField = poDefn->GetFieldDefn( iAttr );
868 
869 	Rprintf( "%s: %s (%d.%d)\n",
870 		poField->GetNameRef(),
871 		poField->GetFieldTypeName( poField->GetType() ),
872 		poField->GetWidth(),
873 		poField->GetPrecision() );
874       }
875     uninstallErrorHandlerAndTriggerError();
876 
877 
878 //    PROTECT(ans=allocVector(INTSXP,1));
879 //    INTEGER(ans)[0]=999;
880 
881     installErrorHandler();
882     OGRDataSource::DestroyDataSource( poDS );
883 //    delete poDS;
884     uninstallErrorHandlerAndTriggerError();
885 //    UNPROTECT(1);
886     return(R_NilValue);
887   }*/
888 
889 
ogrCheckExists(SEXP ogrSource,SEXP Layer)890 SEXP ogrCheckExists (SEXP ogrSource, SEXP Layer) {
891     OGRLayer *poLayer;
892 #ifdef GDALV2
893     GDALDataset *poDS;
894     GDALDriver *poDriver;
895 #else
896     OGRDataSource *poDS;
897     OGRSFDriver *poDriver;
898 #endif
899     SEXP ans, drv;
900     int pc=0;
901     PROTECT(ans=NEW_LOGICAL(1)); pc++;
902 
903     installErrorHandler();
904 #ifdef GDALV2
905     poDS=(GDALDataset*) GDALOpenEx(CHAR(STRING_ELT(ogrSource, 0)), GDAL_OF_VECTOR, NULL, NULL, NULL);
906     if (poDS != NULL) poDriver = poDS->GetDriver();
907 #else
908     poDS=OGRSFDriverRegistrar::Open(CHAR(STRING_ELT(ogrSource, 0)),
909 	FALSE, &poDriver);
910 #endif
911     uninstallErrorHandlerAndTriggerError();
912 
913     if (poDS==NULL){
914 //      installErrorHandler();
915 //      OGRDataSource::DestroyDataSource( poDS );
916 //      uninstallErrorHandlerAndTriggerError();
917 //    delete poDS;
918       LOGICAL_POINTER(ans)[0] = FALSE;
919       UNPROTECT(pc);
920       return(ans);
921     }
922 
923     installErrorHandler();
924     poLayer = poDS->GetLayerByName(CHAR(STRING_ELT(Layer, 0)));
925     uninstallErrorHandlerAndTriggerError();
926 
927     if (poLayer == NULL){
928       installErrorHandler();
929 #ifdef GDALV2
930       GDALClose( poDS );
931 #else
932       OGRDataSource::DestroyDataSource( poDS );
933 #endif
934       uninstallErrorHandlerAndTriggerError();
935 //    delete poDS;
936       LOGICAL_POINTER(ans)[0] = FALSE;
937       UNPROTECT(pc);
938       return(ans);
939     }
940 
941     LOGICAL_POINTER(ans)[0] = TRUE;
942 
943     PROTECT(drv=allocVector(STRSXP,1)); pc++;
944     installErrorHandler();
945 #ifdef GDALV2
946     SET_STRING_ELT(drv, 0, mkChar(poDriver->GetDescription()));
947 #else
948     SET_STRING_ELT(drv, 0, mkChar(poDriver->GetName()));
949 #endif
950     uninstallErrorHandlerAndTriggerError();
951     setAttrib(ans, install("driver"), drv);
952 
953     installErrorHandler();
954 #ifdef GDALV2
955     GDALClose( poDS );
956 #else
957     OGRDataSource::DestroyDataSource( poDS );
958 #endif
959     uninstallErrorHandlerAndTriggerError();
960 //    delete poDS;
961     UNPROTECT(pc);
962     return(ans);
963 }
964 
965 
RGDAL_ogrDeleteLayer(SEXP ogrSource,SEXP Layer,SEXP ogrDriver)966 SEXP RGDAL_ogrDeleteLayer (SEXP ogrSource, SEXP Layer, SEXP ogrDriver) {
967     OGRLayer *poLayer;
968 #ifdef GDALV2
969     GDALDataset *poDS;
970     GDALDriver *poDriver;
971 #else
972     OGRDataSource *poDS;
973     OGRSFDriver *poDriver;
974 #endif
975     int iLayer = -1;
976     int flag = 0;
977 
978     installErrorHandler();
979 #ifdef GDALV2
980     poDriver = GetGDALDriverManager()->GetDriverByName(CHAR(STRING_ELT(ogrDriver, 0)));
981 #else
982     poDriver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(
983                 CHAR(STRING_ELT(ogrDriver, 0)) );
984 #endif
985     uninstallErrorHandlerAndTriggerError();
986     if (poDriver == NULL) {
987         error("Driver not available");
988     }
989 
990     installErrorHandler();
991 #ifdef GDALV2
992     poDS=(GDALDataset*) GDALOpenEx(CHAR(STRING_ELT(ogrSource, 0)), GDAL_OF_VECTOR, NULL, NULL, NULL);
993     if(poDS==NULL){
994       error("Cannot open data source");
995     }
996     if (!EQUAL(CHAR(STRING_ELT(ogrDriver, 0)),
997         poDS->GetDriver()->GetDescription())) {
998         GDALClose( poDS );
999         poDS = NULL;
1000     }
1001 #else
1002     poDS = poDriver->Open(CHAR(STRING_ELT(ogrSource, 0)),
1003 	TRUE);
1004 #endif
1005     uninstallErrorHandlerAndTriggerError();
1006 
1007     if (poDS==NULL)
1008         error("Cannot open data source for update");
1009 
1010     installErrorHandler();
1011     for(iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++) {
1012         poLayer = poDS->GetLayer(iLayer);
1013 #ifdef GDALV2
1014         if (poLayer != NULL && EQUAL(poLayer->GetName(),
1015             CHAR(STRING_ELT(Layer, 0)))) {
1016             flag = 1;
1017             break;
1018         }
1019 #else
1020         if (poLayer != NULL && EQUAL(poLayer->GetLayerDefn()->GetName(),
1021             CHAR(STRING_ELT(Layer, 0)))) {
1022             flag = 1;
1023             break;
1024         }
1025 #endif
1026     }
1027     uninstallErrorHandlerAndTriggerError();
1028     installErrorHandler();
1029     if (flag != 0) {
1030         int res = poDS->DeleteLayer(iLayer);
1031         if (res != OGRERR_NONE) {
1032 #ifdef GDALV2
1033             GDALClose( poDS );
1034 #else
1035             OGRDataSource::DestroyDataSource( poDS );
1036 #endif
1037             uninstallErrorHandlerAndTriggerError();
1038             error("ogrDeleteLayer: failed to delete layer");
1039         }
1040     } else {
1041         warning("ogrDeleteLayer: no such layer");
1042     }
1043 #ifdef GDALV2
1044     GDALClose( poDS );
1045 #else
1046     OGRDataSource::DestroyDataSource( poDS );
1047 #endif
1048     uninstallErrorHandlerAndTriggerError();
1049     return(R_NilValue);
1050 }
1051 
RGDAL_ogrDeleteDataSource(SEXP ogrSource,SEXP ogrDriver)1052 SEXP RGDAL_ogrDeleteDataSource (SEXP ogrSource, SEXP ogrDriver) {
1053 #ifdef GDALV2
1054     GDALDriver *poDriver;
1055 #else
1056     OGRSFDriver *poDriver;
1057 #endif
1058 
1059     installErrorHandler();
1060 #ifdef GDALV2
1061     poDriver = GetGDALDriverManager()->GetDriverByName(CHAR(STRING_ELT(ogrDriver, 0)));
1062 #else
1063     poDriver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(
1064                 CHAR(STRING_ELT(ogrDriver, 0)) );
1065 #endif
1066     uninstallErrorHandlerAndTriggerError();
1067     if (poDriver == NULL) {
1068         error("Driver not available");
1069     }
1070     installErrorHandler();
1071 #ifdef GDALV2
1072     poDriver->Delete(CHAR(STRING_ELT(ogrSource, 0)));
1073 #else
1074     if (poDriver->TestCapability(ODrCDeleteDataSource)) {
1075         if (poDriver->DeleteDataSource(CHAR(STRING_ELT(ogrSource, 0)))
1076             != OGRERR_NONE) {
1077             uninstallErrorHandlerAndTriggerError();
1078             error("Data source could not be deleted");
1079         }
1080     } else {
1081         uninstallErrorHandlerAndTriggerError();
1082         error("This driver is not capable of data source deletion");
1083     }
1084 #endif
1085     uninstallErrorHandlerAndTriggerError();
1086     return(R_NilValue);
1087 }
1088 
1089 
RGDAL_ogrListLayers(SEXP ogrSource)1090 SEXP RGDAL_ogrListLayers (SEXP ogrSource) {
1091 #ifdef GDALV2
1092     GDALDataset *poDS;
1093     GDALDriver *poDriver;
1094 #else
1095     OGRDataSource *poDS;
1096     OGRSFDriver *poDriver;
1097 #endif
1098     OGRLayer *poLayer;
1099     int i, nlayers;
1100     SEXP ans, debug;
1101     int pc=0;
1102 
1103     installErrorHandler();
1104 #ifdef GDALV2
1105     poDS=(GDALDataset*) GDALOpenEx(CHAR(STRING_ELT(ogrSource, 0)), GDAL_OF_VECTOR, NULL, NULL, NULL);
1106     if(poDS==NULL){
1107       uninstallErrorHandlerAndTriggerError();
1108       error("Cannot open data source");
1109     }
1110     poDriver = poDS->GetDriver();
1111 #else
1112     poDS=OGRSFDriverRegistrar::Open(CHAR(STRING_ELT(ogrSource, 0)),
1113 	FALSE, &poDriver);
1114 #endif
1115     uninstallErrorHandlerAndTriggerError();
1116 
1117     if(poDS==NULL){
1118       error("Cannot open data source");
1119     }
1120 
1121     PROTECT(debug = getAttrib(ogrSource, install("debug"))); pc++;
1122     installErrorHandler();
1123     nlayers = poDS->GetLayerCount();
1124     uninstallErrorHandlerAndTriggerError();
1125     if (LOGICAL_POINTER(debug)[0] == TRUE)
1126         Rprintf("ogrListLayers: nlayers %d\n", nlayers);
1127 
1128     PROTECT(ans=NEW_CHARACTER(nlayers+1)); pc++;
1129 
1130     for (i=0; i<nlayers; i++) {
1131         installErrorHandler();
1132         poLayer = poDS->GetLayer(i);
1133 
1134         if(poLayer == NULL){
1135             if (LOGICAL_POINTER(debug)[0] == TRUE) {
1136                 SET_STRING_ELT(ans, i, mkChar(""));
1137                 Rprintf("ogrListLayers: NULL layer %d\n", i);
1138             } else {
1139                 uninstallErrorHandlerAndTriggerError();
1140                 error("Cannot open layer");
1141             }
1142         } else {
1143             SET_STRING_ELT(ans, i, mkChar(poLayer->GetLayerDefn()->GetName()));
1144         }
1145         uninstallErrorHandlerAndTriggerError();
1146     }
1147 
1148     installErrorHandler();
1149 #ifdef GDALV2
1150     SET_STRING_ELT(ans, nlayers, mkChar(poDriver->GetDescription()));
1151 #else
1152     SET_STRING_ELT(ans, nlayers, mkChar(poDriver->GetName()));
1153 #endif
1154     uninstallErrorHandlerAndTriggerError();
1155 
1156     installErrorHandler();
1157 #ifdef GDALV2
1158     GDALClose( poDS );
1159 #else
1160     OGRDataSource::DestroyDataSource( poDS );
1161 #endif
1162     uninstallErrorHandlerAndTriggerError();
1163 
1164     UNPROTECT(pc);
1165     return(ans);
1166 
1167 }
1168 
1169 //}
1170 
1171 
1172 #ifdef __cplusplus
1173 }
1174 #endif
1175 
1176