← Back to branch summary

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

« back to all changes in this revision

Viewing changes to swig/csharp/gdal/gdal_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/csharp/gdal/gdal_wrap.cpp
1
1
/* ----------------------------------------------------------------------------
2
2
 * This file was automatically generated by SWIG (http://www.swig.org).
3
 
 * Version 1.3.39
 
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
201
201
static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
202
202
  { SWIG_CSharpArgumentException, NULL },
203
203
  { SWIG_CSharpArgumentNullException, NULL },
204
 
  { SWIG_CSharpArgumentOutOfRangeException, NULL },
 
204
  { SWIG_CSharpArgumentOutOfRangeException, NULL }
205
205
};
206
206
 
207
207
static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
316
316
typedef void GDALColorTableShadow;
317
317
typedef void GDALRasterAttributeTableShadow;
318
318
typedef void GDALTransformerInfoShadow;
 
319
typedef void GDALAsyncReaderShadow;
319
320
 
320
 
typedef int FALSE_IS_ERR;
 
321
/* use this to not return the int returned by GDAL */
 
322
typedef int RETURN_NONE;
321
323
 
322
324
 
323
325
 
379
381
#include <stdexcept>
380
382
 
381
383
 
382
 
    typedef char retStringAndCPLFree;
383
 
 
384
 
 
385
384
    void StringListDestroy(void *buffer_ptr) {
386
385
       CSLDestroy((char**)buffer_ptr);
387
386
    }
388
387
 
389
388
 
 
389
typedef char retStringAndCPLFree;
 
390
 
 
391
 
390
392
  void Debug( const char *msg_class, const char *message ) {
391
393
    CPLDebug( msg_class, "%s", message );
392
394
  }
426
428
}
427
429
 
428
430
 
429
 
void wrapper_VSIFileFromMemBuffer( const char* pszFilename, int nBytes, const GByte *pabyData)
 
431
void wrapper_VSIFileFromMemBuffer( const char* utf8_path, int nBytes, const GByte *pabyData)
430
432
{
431
433
    GByte* pabyDataDup = (GByte*)VSIMalloc(nBytes);
432
434
    if (pabyDataDup == NULL)
433
435
            return;
434
436
    memcpy(pabyDataDup, pabyData, nBytes);
435
 
    VSIFCloseL(VSIFileFromMemBuffer(pszFilename, (GByte*) pabyDataDup, nBytes, TRUE));
 
437
    VSIFCloseL(VSIFileFromMemBuffer(utf8_path, (GByte*) pabyDataDup, nBytes, TRUE));
436
438
}
437
439
 
438
440
 
514
516
SWIGINTERN CPLErr GDALMajorObjectShadow_SetMetadataItem(GDALMajorObjectShadow *self,char const *pszName,char const *pszValue,char const *pszDomain=""){
515
517
    return GDALSetMetadataItem( self, pszName, pszValue, pszDomain);
516
518
  }
517
 
SWIGINTERN GDALDatasetShadow *GDALDriverShadow_Create(GDALDriverShadow *self,char const *name,int xsize,int ysize,int bands=1,GDALDataType eType=GDT_Byte,char **options=0){
 
519
SWIGINTERN GDALDatasetShadow *GDALDriverShadow_Create(GDALDriverShadow *self,char const *utf8_path,int xsize,int ysize,int bands=1,GDALDataType eType=GDT_Byte,char **options=0){
518
520
 
519
521
    GDALDatasetShadow* ds = (GDALDatasetShadow*) GDALCreate(    self, 
520
 
                                                                name, 
 
522
                                                                utf8_path, 
521
523
                                                                xsize, 
522
524
                                                                ysize, 
523
525
                                                                bands, 
525
527
                                                                options );
526
528
    return ds;
527
529
  }
528
 
SWIGINTERN GDALDatasetShadow *GDALDriverShadow_CreateCopy(GDALDriverShadow *self,char const *name,GDALDatasetShadow *src,int strict=1,char **options=0,GDALProgressFunc callback=NULL,void *callback_data=NULL){
 
530
SWIGINTERN GDALDatasetShadow *GDALDriverShadow_CreateCopy(GDALDriverShadow *self,char const *utf8_path,GDALDatasetShadow *src,int strict=1,char **options=0,GDALProgressFunc callback=NULL,void *callback_data=NULL){
529
531
 
530
532
    GDALDatasetShadow *ds = (GDALDatasetShadow*) GDALCreateCopy(    self, 
531
 
                                                                    name, 
 
533
                                                                    utf8_path, 
532
534
                                                                    src, 
533
535
                                                                    strict, 
534
536
                                                                    options, 
536
538
                                                                    callback_data );
537
539
    return ds;
538
540
  }
539
 
SWIGINTERN int GDALDriverShadow_Delete(GDALDriverShadow *self,char const *name){
540
 
    return GDALDeleteDataset( self, name );
 
541
SWIGINTERN int GDALDriverShadow_Delete(GDALDriverShadow *self,char const *utf8_path){
 
542
    return GDALDeleteDataset( self, utf8_path );
541
543
  }
542
544
SWIGINTERN int GDALDriverShadow_Rename(GDALDriverShadow *self,char const *newName,char const *oldName){
543
545
    return GDALRenameDataset( self, newName, oldName );
544
546
  }
 
547
SWIGINTERN int GDALDriverShadow_CopyFiles(GDALDriverShadow *self,char const *newName,char const *oldName){
 
548
    return GDALCopyDatasetFiles( self, newName, oldName );
 
549
  }
545
550
SWIGINTERN int GDALDriverShadow_Register(GDALDriverShadow *self){
546
551
    return GDALRegisterDriver( self );
547
552
  }
683
688
 
684
689
/* Returned size is in bytes or 0 if an error occured */
685
690
static
686
 
int ComputeDatasetRasterIOSize (int buf_xsize, int buf_ysize, int nPixelSize,
 
691
GIntBig ComputeDatasetRasterIOSize (int buf_xsize, int buf_ysize, int nPixelSize,
687
692
                                int nBands, int* bandMap, int nBandMapArrayLength,
688
693
                                int nPixelSpace, int nLineSpace, int nBandSpace,
689
694
                                int bSpacingShouldBeMultipleOfPixelSize )
690
695
{
691
 
    const int MAX_INT = 0x7fffffff;
 
696
#if SIZEOF_VOIDP == 8
 
697
    const GIntBig MAX_INT = (((GIntBig)0x7fffffff) << 32) | 0xffffffff;
 
698
#else
 
699
    const GIntBig MAX_INT = 0x7fffffff;
 
700
#endif
 
701
    const GIntBig MAX_INT32 = 0x7fffffff;
692
702
    if (buf_xsize <= 0 || buf_ysize <= 0)
693
703
    {
694
704
        CPLError(CE_Failure, CPLE_IllegalArg, "Illegal values for buffer size");
717
727
 
718
728
    if( nLineSpace == 0 )
719
729
    {
720
 
        if (nPixelSpace > MAX_INT / buf_xsize)
 
730
        if (nPixelSpace > MAX_INT32 / buf_xsize)
721
731
        {
722
 
            CPLError(CE_Failure, CPLE_IllegalArg, "Integer overflow");
 
732
            CPLError(CE_Failure, CPLE_IllegalArg, "Integer overflow for nLineSpace");
723
733
            return 0;
724
734
        }
725
735
        nLineSpace = nPixelSpace * buf_xsize;
732
742
 
733
743
    if( nBandSpace == 0 )
734
744
    {
735
 
        if (nLineSpace > MAX_INT / buf_ysize)
 
745
        if (nLineSpace > MAX_INT32 / buf_ysize)
736
746
        {
737
 
            CPLError(CE_Failure, CPLE_IllegalArg, "Integer overflow");
 
747
            CPLError(CE_Failure, CPLE_IllegalArg, "Integer overflow for nBandSpace");
738
748
            return 0;
739
749
        }
740
750
        nBandSpace = nLineSpace * buf_ysize;
751
761
        return 0;
752
762
    }
753
763
 
754
 
    if ((buf_ysize - 1) > MAX_INT / nLineSpace ||
755
 
        (buf_xsize - 1) > MAX_INT / nPixelSpace ||
756
 
        (nBands - 1) > MAX_INT / nBandSpace ||
757
 
        (buf_ysize - 1) * nLineSpace > MAX_INT - (buf_xsize - 1) * nPixelSpace ||
758
 
        (buf_ysize - 1) * nLineSpace + (buf_xsize - 1) * nPixelSpace > MAX_INT - (nBands - 1) * nBandSpace ||
759
 
        (buf_ysize - 1) * nLineSpace + (buf_xsize - 1) * nPixelSpace + (nBands - 1) * nBandSpace > MAX_INT - nPixelSize)
 
764
    GIntBig nRet = (GIntBig)(buf_ysize - 1) * nLineSpace + (GIntBig)(buf_xsize - 1) * nPixelSpace + (GIntBig)(nBands - 1) * nBandSpace + nPixelSize;
 
765
    if (nRet > MAX_INT)
760
766
    {
761
767
        CPLError(CE_Failure, CPLE_IllegalArg, "Integer overflow");
762
768
        return 0;
763
769
    }
764
770
 
765
 
    return (buf_ysize - 1) * nLineSpace + (buf_xsize - 1) * nPixelSpace + (nBands - 1) * nBandSpace + nPixelSize;
766
 
}
767
 
 
 
771
    return nRet;
 
772
}
 
773
 
 
774
 
 
775
typedef struct
 
776
{
 
777
    GDALAsyncReaderH  hAsyncReader;
 
778
    void             *pyObject;
 
779
} GDALAsyncReaderWrapper;
 
780
 
 
781
typedef void* GDALAsyncReaderWrapperH;
 
782
 
 
783
static GDALAsyncReaderH AsyncReaderWrapperGetReader(GDALAsyncReaderWrapperH hWrapper)
 
784
{
 
785
    GDALAsyncReaderWrapper* psWrapper = (GDALAsyncReaderWrapper*)hWrapper;
 
786
    if (psWrapper->hAsyncReader == NULL)
 
787
    {
 
788
        CPLError(CE_Failure, CPLE_AppDefined, "AsyncReader object is defunct");
 
789
    }
 
790
    return psWrapper->hAsyncReader;
 
791
}
 
792
 
 
793
static void* AsyncReaderWrapperGetPyObject(GDALAsyncReaderWrapperH hWrapper)
 
794
{
 
795
    GDALAsyncReaderWrapper* psWrapper = (GDALAsyncReaderWrapper*)hWrapper;
 
796
    return psWrapper->pyObject;
 
797
}
 
798
 
 
799
static void DeleteAsyncReaderWrapper(GDALAsyncReaderWrapperH hWrapper)
 
800
{
 
801
    GDALAsyncReaderWrapper* psWrapper = (GDALAsyncReaderWrapper*)hWrapper;
 
802
    if (psWrapper->hAsyncReader != NULL)
 
803
    {
 
804
        CPLError(CE_Failure, CPLE_AppDefined,
 
805
                 "Native AsyncReader object will leak. EndAsyncReader() should have been called before");
 
806
    }
 
807
    CPLFree(psWrapper);
 
808
}
 
809
 
 
810
 
 
811
SWIGINTERN void delete_GDALAsyncReaderShadow(GDALAsyncReaderShadow *self){
 
812
        DeleteAsyncReaderWrapper(self);
 
813
    }
 
814
SWIGINTERN GDALAsyncStatusType GDALAsyncReaderShadow_GetNextUpdatedRegion(GDALAsyncReaderShadow *self,double timeout,int *xoff,int *yoff,int *buf_xsize,int *buf_ysize){
 
815
        GDALAsyncReaderH hReader = AsyncReaderWrapperGetReader(self);
 
816
        if (hReader == NULL)
 
817
        {
 
818
            *xoff = 0;
 
819
            *yoff = 0;
 
820
            *buf_xsize = 0;
 
821
            *buf_ysize = 0;
 
822
            return GARIO_ERROR;
 
823
        }
 
824
        return GDALARGetNextUpdatedRegion(hReader, timeout, xoff, yoff, buf_xsize, buf_ysize );
 
825
    }
 
826
SWIGINTERN int GDALAsyncReaderShadow_LockBuffer(GDALAsyncReaderShadow *self,double timeout){
 
827
        GDALAsyncReaderH hReader = AsyncReaderWrapperGetReader(self);
 
828
        if (hReader == NULL)
 
829
        {
 
830
            return 0;
 
831
        }
 
832
        return GDALARLockBuffer(hReader,timeout);
 
833
    }
 
834
SWIGINTERN void GDALAsyncReaderShadow_UnlockBuffer(GDALAsyncReaderShadow *self){
 
835
        GDALAsyncReaderH hReader = AsyncReaderWrapperGetReader(self);
 
836
        if (hReader == NULL)
 
837
        {
 
838
            return;
 
839
        }
 
840
        GDALARUnlockBuffer(hReader);
 
841
    }
768
842
SWIGINTERN void delete_GDALDatasetShadow(GDALDatasetShadow *self){
769
843
    if ( GDALDereferenceDataset( self ) <= 0 ) {
770
844
      GDALClose(self);
786
860
    return GDALSetProjection( self, prj );
787
861
  }
788
862
SWIGINTERN void GDALDatasetShadow_GetGeoTransform(GDALDatasetShadow *self,double argout[6]){
789
 
    if ( GDALGetGeoTransform( self, argout ) != 0 ) {
 
863
    if ( GDALGetGeoTransform( self, argout ) != CE_None ) {
790
864
      argout[0] = 0.0;
791
865
      argout[1] = 1.0;
792
866
      argout[2] = 0.0;
870
944
 
871
945
/* Returned size is in bytes or 0 if an error occured */
872
946
static
873
 
int ComputeBandRasterIOSize (int buf_xsize, int buf_ysize, int nPixelSize,
 
947
GIntBig ComputeBandRasterIOSize (int buf_xsize, int buf_ysize, int nPixelSize,
874
948
                             int nPixelSpace, int nLineSpace,
875
949
                             int bSpacingShouldBeMultipleOfPixelSize )
876
950
{
877
 
    const int MAX_INT = 0x7fffffff;
 
951
#if SIZEOF_VOIDP == 8
 
952
    const GIntBig MAX_INT = (((GIntBig)0x7fffffff) << 32) | 0xffffffff;
 
953
#else
 
954
    const GIntBig MAX_INT = 0x7fffffff;
 
955
#endif
 
956
    const GIntBig MAX_INT32 = 0x7fffffff;
878
957
    if (buf_xsize <= 0 || buf_ysize <= 0)
879
958
    {
880
959
        CPLError(CE_Failure, CPLE_IllegalArg, "Illegal values for buffer size");
903
982
 
904
983
    if( nLineSpace == 0 )
905
984
    {
906
 
        if (nPixelSpace > MAX_INT / buf_xsize)
 
985
        if (nPixelSpace > MAX_INT32 / buf_xsize)
907
986
        {
908
 
            CPLError(CE_Failure, CPLE_IllegalArg, "Integer overflow");
 
987
            CPLError(CE_Failure, CPLE_IllegalArg, "Integer overflow for nLineSpace");
909
988
            return 0;
910
989
        }
911
990
        nLineSpace = nPixelSpace * buf_xsize;
916
995
        return 0;
917
996
    }
918
997
 
919
 
    if ((buf_ysize - 1) > MAX_INT / nLineSpace ||
920
 
        (buf_xsize - 1) > MAX_INT / nPixelSpace ||
921
 
        (buf_ysize - 1) * nLineSpace > MAX_INT - (buf_xsize - 1) * nPixelSpace ||
922
 
        (buf_ysize - 1) * nLineSpace + (buf_xsize - 1) * nPixelSpace > MAX_INT - nPixelSize)
 
998
    GIntBig nRet = (GIntBig)(buf_ysize - 1) * nLineSpace + (GIntBig)(buf_xsize - 1) * nPixelSpace + nPixelSize;
 
999
    if (nRet > MAX_INT)
923
1000
    {
924
1001
        CPLError(CE_Failure, CPLE_IllegalArg, "Integer overflow");
925
1002
        return 0;
926
1003
    }
927
1004
 
928
 
    return (buf_ysize - 1) * nLineSpace + (buf_xsize - 1) * nPixelSpace + nPixelSize;
 
1005
    return nRet;
929
1006
}
930
1007
 
931
1008
SWIGINTERN int GDALRasterBandShadow_GetBand(GDALRasterBandShadow *self){
955
1032
SWIGINTERN char const *GDALRasterBandShadow_GetUnitType(GDALRasterBandShadow *self){
956
1033
      return GDALGetRasterUnitType( self );
957
1034
  }
 
1035
SWIGINTERN CPLErr GDALRasterBandShadow_SetUnitType(GDALRasterBandShadow *self,char const *val){
 
1036
    return GDALSetRasterUnitType( self, val );
 
1037
  }
958
1038
SWIGINTERN char **GDALRasterBandShadow_GetRasterCategoryNames(GDALRasterBandShadow *self){
959
1039
    return GDALGetRasterCategoryNames( self );
960
1040
  }
973
1053
SWIGINTERN void GDALRasterBandShadow_GetScale(GDALRasterBandShadow *self,double *val,int *hasval){
974
1054
    *val = GDALGetRasterScale( self, hasval );
975
1055
  }
 
1056
SWIGINTERN CPLErr GDALRasterBandShadow_SetOffset(GDALRasterBandShadow *self,double val){
 
1057
    return GDALSetRasterOffset( self, val );
 
1058
  }
 
1059
SWIGINTERN CPLErr GDALRasterBandShadow_SetScale(GDALRasterBandShadow *self,double val){
 
1060
    return GDALSetRasterScale( self, val );
 
1061
  }
976
1062
SWIGINTERN CPLErr GDALRasterBandShadow_GetStatistics(GDALRasterBandShadow *self,int approx_ok,int force,double *min,double *max,double *mean,double *stddev){
977
1063
    if (min) *min = 0;
978
1064
    if (max) *max = 0;
1057
1143
SWIGINTERN bool GDALRasterBandShadow_HasArbitraryOverviews(GDALRasterBandShadow *self){
1058
1144
      return (GDALHasArbitraryOverviews( self ) != 0) ? true : false;
1059
1145
  }
 
1146
SWIGINTERN char **GDALRasterBandShadow_GetCategoryNames(GDALRasterBandShadow *self){
 
1147
    return GDALGetRasterCategoryNames( self );
 
1148
  }
 
1149
SWIGINTERN CPLErr GDALRasterBandShadow_SetCategoryNames(GDALRasterBandShadow *self,char **papszCategoryNames){
 
1150
    return GDALSetRasterCategoryNames( self, papszCategoryNames );
 
1151
  }
1060
1152
SWIGINTERN CPLErr GDALRasterBandShadow_ReadRaster(GDALRasterBandShadow *self,int xOff,int yOff,int xSize,int ySize,void *buffer,int buf_xSize,int buf_ySize,GDALDataType buf_type,int pixelSpace,int lineSpace){
1061
1153
       return GDALRasterIO( self, GF_Read, xOff, yOff, xSize, ySize, 
1062
1154
                        buffer, buf_xSize, buf_ySize, buf_type, pixelSpace, lineSpace );
1165
1257
        return GDALRATGetRowOfValue( self, dfValue );
1166
1258
    }
1167
1259
 
 
1260
#include "gdalgrid.h"
 
1261
 
1168
1262
#ifdef DEBUG 
1169
1263
typedef struct OGRLayerHS OGRLayerShadow;
1170
1264
typedef struct OGRGeometryHS OGRGeometryShadow;
1374
1468
}
1375
1469
 
1376
1470
 
 
1471
int ContourGenerate( GDALRasterBandShadow *srcBand,
 
1472
                     double contourInterval,
 
1473
                     double contourBase,
 
1474
                     int fixedLevelCount,
 
1475
                     double *fixedLevels,
 
1476
                     int useNoData,
 
1477
                     double noDataValue,
 
1478
                     OGRLayerShadow* dstLayer, 
 
1479
                     int idField,
 
1480
                     int elevField,
 
1481
                     GDALProgressFunc callback = NULL,
 
1482
                     void* callback_data = NULL)
 
1483
{
 
1484
    CPLErr eErr;
 
1485
 
 
1486
    CPLErrorReset();
 
1487
 
 
1488
    eErr =  GDALContourGenerate( srcBand,
 
1489
                                 contourInterval,
 
1490
                                 contourBase,
 
1491
                                 fixedLevelCount,
 
1492
                                 fixedLevels,
 
1493
                                 useNoData,
 
1494
                                 noDataValue,
 
1495
                                 dstLayer,
 
1496
                                 idField,
 
1497
                                 elevField,
 
1498
                                 callback,
 
1499
                                 callback_data);
 
1500
 
 
1501
    return eErr;
 
1502
}
 
1503
 
 
1504
 
1377
1505
GDALDatasetShadow *AutoCreateWarpedVRT( GDALDatasetShadow *src_ds,
1378
1506
                                        const char *src_wkt = 0,
1379
1507
                                        const char *dst_wkt = 0,
1429
1557
    return nRet;
1430
1558
  }
1431
1559
 
 
1560
int wrapper_GDALGetCacheMax()
 
1561
{
 
1562
    return GDALGetCacheMax();
 
1563
}
 
1564
 
 
1565
 
 
1566
int wrapper_GDALGetCacheUsed()
 
1567
{
 
1568
    return GDALGetCacheUsed();
 
1569
}
 
1570
 
 
1571
 
 
1572
void wrapper_GDALSetCacheMax(int nBytes)
 
1573
{
 
1574
    return GDALSetCacheMax(nBytes);
 
1575
}
 
1576
 
 
1577
 
1432
1578
int GetDriverCount() {
1433
1579
  return GDALGetDriverCount();
1434
1580
}
1444
1590
}
1445
1591
 
1446
1592
 
1447
 
GDALDatasetShadow* Open( char const* name, GDALAccess eAccess = GA_ReadOnly ) {
1448
 
  CPLErrorReset();
1449
 
  GDALDatasetShadow *ds = GDALOpen( name, eAccess );
1450
 
  if( ds != NULL && CPLGetLastErrorType() == CE_Failure )
1451
 
  {
1452
 
      if ( GDALDereferenceDataset( ds ) <= 0 )
1453
 
          GDALClose(ds);
1454
 
      ds = NULL;
1455
 
  }
1456
 
  return (GDALDatasetShadow*) ds;
1457
 
}
1458
 
 
1459
 
 
1460
 
GDALDatasetShadow* OpenShared( char const* name, GDALAccess eAccess = GA_ReadOnly ) {
1461
 
  CPLErrorReset();
1462
 
  GDALDatasetShadow *ds = GDALOpenShared( name, eAccess );
1463
 
  if( ds != NULL && CPLGetLastErrorType() == CE_Failure )
1464
 
  {
1465
 
      if ( GDALDereferenceDataset( ds ) <= 0 )
1466
 
          GDALClose(ds);
1467
 
      ds = NULL;
1468
 
  }
1469
 
  return (GDALDatasetShadow*) ds;
1470
 
}
1471
 
 
1472
 
 
1473
 
GDALDriverShadow *IdentifyDriver( const char *pszDatasource, 
 
1593
GDALDatasetShadow* Open( char const* utf8_path, GDALAccess eAccess = GA_ReadOnly ) {
 
1594
  CPLErrorReset();
 
1595
  GDALDatasetShadow *ds = GDALOpen( utf8_path, eAccess );
 
1596
  if( ds != NULL && CPLGetLastErrorType() == CE_Failure )
 
1597
  {
 
1598
      if ( GDALDereferenceDataset( ds ) <= 0 )
 
1599
          GDALClose(ds);
 
1600
      ds = NULL;
 
1601
  }
 
1602
  return (GDALDatasetShadow*) ds;
 
1603
}
 
1604
 
 
1605
 
 
1606
GDALDatasetShadow* OpenShared( char const* utf8_path, GDALAccess eAccess = GA_ReadOnly ) {
 
1607
  CPLErrorReset();
 
1608
  GDALDatasetShadow *ds = GDALOpenShared( utf8_path, eAccess );
 
1609
  if( ds != NULL && CPLGetLastErrorType() == CE_Failure )
 
1610
  {
 
1611
      if ( GDALDereferenceDataset( ds ) <= 0 )
 
1612
          GDALClose(ds);
 
1613
      ds = NULL;
 
1614
  }
 
1615
  return (GDALDatasetShadow*) ds;
 
1616
}
 
1617
 
 
1618
 
 
1619
GDALDriverShadow *IdentifyDriver( const char *utf8_path, 
1474
1620
                                  char **papszSiblings = NULL ) {
1475
 
    return (GDALDriverShadow *) GDALIdentifyDriver( pszDatasource, 
 
1621
    return (GDALDriverShadow *) GDALIdentifyDriver( utf8_path, 
1476
1622
                                                    papszSiblings );
1477
1623
}
1478
1624
 
1785
1931
  int result;
1786
1932
  
1787
1933
  {
1788
 
    CPLErrorReset();
1789
 
    result = (int)CPLGetLastErrorNo();
1790
 
    CPLErr eclass = CPLGetLastErrorType();
1791
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
1792
 
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
1793
 
      
1794
 
      
1795
 
      
1796
 
    }
1797
 
    
1798
 
    
1799
 
    
1800
 
    
1801
 
    
1802
 
    
1803
 
    
1804
 
    
1805
 
    
1806
 
    
1807
 
    
 
1934
    result = CPLGetLastErrorNo();
1808
1935
  }
1809
1936
  jresult = result; 
1810
1937
  return jresult;
1813
1940
 
1814
1941
SWIGEXPORT int SWIGSTDCALL CSharp_GetLastErrorType() {
1815
1942
  int jresult ;
1816
 
  CPLErr result;
 
1943
  int result;
1817
1944
  
1818
1945
  {
1819
 
    CPLErrorReset();
1820
 
    result = (CPLErr)CPLGetLastErrorType();
1821
 
    CPLErr eclass = CPLGetLastErrorType();
1822
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
1823
 
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
1824
 
      
1825
 
      
1826
 
      
1827
 
    }
1828
 
    
1829
 
    
1830
 
    
1831
 
    
1832
 
    
1833
 
    
1834
 
    
1835
 
    
1836
 
    
1837
 
    
1838
 
    
 
1946
    result = CPLGetLastErrorType();
1839
1947
  }
1840
1948
  jresult = result; 
1841
1949
  return jresult;
1847
1955
  char *result = 0 ;
1848
1956
  
1849
1957
  {
1850
 
    CPLErrorReset();
1851
 
    result = (char *)CPLGetLastErrorMsg();
1852
 
    CPLErr eclass = CPLGetLastErrorType();
1853
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
1854
 
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
1855
 
      
1856
 
      
1857
 
      
1858
 
    }
1859
 
    
1860
 
    
1861
 
    
1862
 
    
1863
 
    
1864
 
    
1865
 
    
1866
 
    
1867
 
    
1868
 
    
1869
 
    
 
1958
    result = (char*)CPLGetLastErrorMsg();
1870
1959
  }
1871
1960
  jresult = SWIG_csharp_string_callback((const char *)result); 
1872
1961
  return jresult;
2195
2284
  arg2 = (int)jarg2; 
2196
2285
  arg3 = (GByte *)jarg3; 
2197
2286
  {
2198
 
    if (!arg1) {
2199
 
      {
2200
 
        SWIG_CSharpException(SWIG_ValueError, "Received a NULL pointer."); return ; 
2201
 
      };
2202
 
    }
2203
 
  }
2204
 
  {
2205
2287
    CPLErrorReset();
2206
2288
    wrapper_VSIFileFromMemBuffer((char const *)arg1,arg2,(GByte const *)arg3);
2207
2289
    CPLErr eclass = CPLGetLastErrorType();
2233
2315
  
2234
2316
  arg1 = (char *)jarg1; 
2235
2317
  {
2236
 
    if (!arg1) {
2237
 
      {
2238
 
        SWIG_CSharpException(SWIG_ValueError, "Received a NULL pointer."); return 0; 
2239
 
      };
2240
 
    }
2241
 
  }
2242
 
  {
2243
2318
    CPLErrorReset();
2244
2319
    result = (int)VSIUnlink((char const *)arg1);
2245
2320
    CPLErr eclass = CPLGetLastErrorType();
2297
2372
}
2298
2373
 
2299
2374
 
 
2375
SWIGEXPORT int SWIGSTDCALL CSharp_Mkdir(char * jarg1, int jarg2) {
 
2376
  int jresult ;
 
2377
  char *arg1 = (char *) 0 ;
 
2378
  int arg2 ;
 
2379
  int result;
 
2380
  
 
2381
  arg1 = (char *)jarg1; 
 
2382
  arg2 = (int)jarg2; 
 
2383
  {
 
2384
    CPLErrorReset();
 
2385
    result = (int)VSIMkdir((char const *)arg1,arg2);
 
2386
    CPLErr eclass = CPLGetLastErrorType();
 
2387
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
 
2388
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
 
2389
      
 
2390
      
 
2391
      
 
2392
    }
 
2393
    
 
2394
    
 
2395
    
 
2396
    
 
2397
    
 
2398
    
 
2399
    
 
2400
    
 
2401
    
 
2402
    
 
2403
    
 
2404
  }
 
2405
  jresult = result; 
 
2406
  return jresult;
 
2407
}
 
2408
 
 
2409
 
 
2410
SWIGEXPORT int SWIGSTDCALL CSharp_Rmdir(char * jarg1) {
 
2411
  int jresult ;
 
2412
  char *arg1 = (char *) 0 ;
 
2413
  int result;
 
2414
  
 
2415
  arg1 = (char *)jarg1; 
 
2416
  {
 
2417
    CPLErrorReset();
 
2418
    result = (int)VSIRmdir((char const *)arg1);
 
2419
    CPLErr eclass = CPLGetLastErrorType();
 
2420
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
 
2421
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
 
2422
      
 
2423
      
 
2424
      
 
2425
    }
 
2426
    
 
2427
    
 
2428
    
 
2429
    
 
2430
    
 
2431
    
 
2432
    
 
2433
    
 
2434
    
 
2435
    
 
2436
    
 
2437
  }
 
2438
  jresult = result; 
 
2439
  return jresult;
 
2440
}
 
2441
 
 
2442
 
 
2443
SWIGEXPORT int SWIGSTDCALL CSharp_Rename(char * jarg1, char * jarg2) {
 
2444
  int jresult ;
 
2445
  char *arg1 = (char *) 0 ;
 
2446
  char *arg2 = (char *) 0 ;
 
2447
  int result;
 
2448
  
 
2449
  arg1 = (char *)jarg1; 
 
2450
  arg2 = (char *)jarg2; 
 
2451
  {
 
2452
    CPLErrorReset();
 
2453
    result = (int)VSIRename((char const *)arg1,(char const *)arg2);
 
2454
    CPLErr eclass = CPLGetLastErrorType();
 
2455
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
 
2456
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
 
2457
      
 
2458
      
 
2459
      
 
2460
    }
 
2461
    
 
2462
    
 
2463
    
 
2464
    
 
2465
    
 
2466
    
 
2467
    
 
2468
    
 
2469
    
 
2470
    
 
2471
    
 
2472
  }
 
2473
  jresult = result; 
 
2474
  return jresult;
 
2475
}
 
2476
 
 
2477
 
 
2478
SWIGEXPORT void * SWIGSTDCALL CSharp_VSIFOpenL(char * jarg1, char * jarg2) {
 
2479
  void * jresult ;
 
2480
  char *arg1 = (char *) 0 ;
 
2481
  char *arg2 = (char *) 0 ;
 
2482
  VSILFILE *result = 0 ;
 
2483
  
 
2484
  arg1 = (char *)jarg1; 
 
2485
  arg2 = (char *)jarg2; 
 
2486
  {
 
2487
    CPLErrorReset();
 
2488
    result = (VSILFILE *)VSIFOpenL((char const *)arg1,(char const *)arg2);
 
2489
    CPLErr eclass = CPLGetLastErrorType();
 
2490
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
 
2491
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
 
2492
      
 
2493
      
 
2494
      
 
2495
    }
 
2496
    
 
2497
    
 
2498
    
 
2499
    
 
2500
    
 
2501
    
 
2502
    
 
2503
    
 
2504
    
 
2505
    
 
2506
    
 
2507
  }
 
2508
  jresult = (void *)result; 
 
2509
  return jresult;
 
2510
}
 
2511
 
 
2512
 
 
2513
SWIGEXPORT void SWIGSTDCALL CSharp_VSIFCloseL(void * jarg1) {
 
2514
  VSILFILE *arg1 = (VSILFILE *) 0 ;
 
2515
  
 
2516
  arg1 = (VSILFILE *)jarg1; 
 
2517
  {
 
2518
    CPLErrorReset();
 
2519
    VSIFCloseL(arg1);
 
2520
    CPLErr eclass = CPLGetLastErrorType();
 
2521
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
 
2522
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
 
2523
      
 
2524
      
 
2525
      
 
2526
    }
 
2527
    
 
2528
    
 
2529
    
 
2530
    
 
2531
    
 
2532
    
 
2533
    
 
2534
    
 
2535
    
 
2536
    
 
2537
    
 
2538
  }
 
2539
}
 
2540
 
 
2541
 
 
2542
SWIGEXPORT int SWIGSTDCALL CSharp_VSIFSeekL(void * jarg1, long jarg2, int jarg3) {
 
2543
  int jresult ;
 
2544
  VSILFILE *arg1 = (VSILFILE *) 0 ;
 
2545
  long arg2 ;
 
2546
  int arg3 ;
 
2547
  int result;
 
2548
  
 
2549
  arg1 = (VSILFILE *)jarg1; 
 
2550
  arg2 = (long)jarg2; 
 
2551
  arg3 = (int)jarg3; 
 
2552
  {
 
2553
    CPLErrorReset();
 
2554
    result = (int)VSIFSeekL(arg1,arg2,arg3);
 
2555
    CPLErr eclass = CPLGetLastErrorType();
 
2556
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
 
2557
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
 
2558
      
 
2559
      
 
2560
      
 
2561
    }
 
2562
    
 
2563
    
 
2564
    
 
2565
    
 
2566
    
 
2567
    
 
2568
    
 
2569
    
 
2570
    
 
2571
    
 
2572
    
 
2573
  }
 
2574
  jresult = result; 
 
2575
  return jresult;
 
2576
}
 
2577
 
 
2578
 
 
2579
SWIGEXPORT long SWIGSTDCALL CSharp_VSIFTellL(void * jarg1) {
 
2580
  long jresult ;
 
2581
  VSILFILE *arg1 = (VSILFILE *) 0 ;
 
2582
  long result;
 
2583
  
 
2584
  arg1 = (VSILFILE *)jarg1; 
 
2585
  {
 
2586
    CPLErrorReset();
 
2587
    result = (long)VSIFTellL(arg1);
 
2588
    CPLErr eclass = CPLGetLastErrorType();
 
2589
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
 
2590
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
 
2591
      
 
2592
      
 
2593
      
 
2594
    }
 
2595
    
 
2596
    
 
2597
    
 
2598
    
 
2599
    
 
2600
    
 
2601
    
 
2602
    
 
2603
    
 
2604
    
 
2605
    
 
2606
  }
 
2607
  jresult = result; 
 
2608
  return jresult;
 
2609
}
 
2610
 
 
2611
 
 
2612
SWIGEXPORT int SWIGSTDCALL CSharp_VSIFTruncateL(void * jarg1, long jarg2) {
 
2613
  int jresult ;
 
2614
  VSILFILE *arg1 = (VSILFILE *) 0 ;
 
2615
  long arg2 ;
 
2616
  int result;
 
2617
  
 
2618
  arg1 = (VSILFILE *)jarg1; 
 
2619
  arg2 = (long)jarg2; 
 
2620
  {
 
2621
    CPLErrorReset();
 
2622
    result = (int)VSIFTruncateL(arg1,arg2);
 
2623
    CPLErr eclass = CPLGetLastErrorType();
 
2624
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
 
2625
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
 
2626
      
 
2627
      
 
2628
      
 
2629
    }
 
2630
    
 
2631
    
 
2632
    
 
2633
    
 
2634
    
 
2635
    
 
2636
    
 
2637
    
 
2638
    
 
2639
    
 
2640
    
 
2641
  }
 
2642
  jresult = result; 
 
2643
  return jresult;
 
2644
}
 
2645
 
 
2646
 
 
2647
SWIGEXPORT int SWIGSTDCALL CSharp_VSIFWriteL(char * jarg1, int jarg2, int jarg3, void * jarg4) {
 
2648
  int jresult ;
 
2649
  char *arg1 = (char *) 0 ;
 
2650
  int arg2 ;
 
2651
  int arg3 ;
 
2652
  VSILFILE *arg4 = (VSILFILE *) 0 ;
 
2653
  int result;
 
2654
  
 
2655
  arg1 = (char *)jarg1; 
 
2656
  arg2 = (int)jarg2; 
 
2657
  arg3 = (int)jarg3; 
 
2658
  arg4 = (VSILFILE *)jarg4; 
 
2659
  {
 
2660
    CPLErrorReset();
 
2661
    result = (int)VSIFWriteL((char const *)arg1,arg2,arg3,arg4);
 
2662
    CPLErr eclass = CPLGetLastErrorType();
 
2663
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
 
2664
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
 
2665
      
 
2666
      
 
2667
      
 
2668
    }
 
2669
    
 
2670
    
 
2671
    
 
2672
    
 
2673
    
 
2674
    
 
2675
    
 
2676
    
 
2677
    
 
2678
    
 
2679
    
 
2680
  }
 
2681
  jresult = result; 
 
2682
  return jresult;
 
2683
}
 
2684
 
 
2685
 
2300
2686
SWIGEXPORT int SWIGSTDCALL CSharp_XMLNode_Type_get(void * jarg1) {
2301
2687
  int jresult ;
2302
2688
  CPLXMLNode *arg1 = (CPLXMLNode *) 0 ;
2949
3335
  arg1 = (GDALMajorObjectShadow *)jarg1; 
2950
3336
  arg2 = (char *)jarg2; 
2951
3337
  {
 
3338
    if (!arg2) {
 
3339
      {
 
3340
        SWIG_CSharpException(SWIG_ValueError, "Received a NULL pointer."); return ; 
 
3341
      };
 
3342
    }
 
3343
  }
 
3344
  {
2952
3345
    CPLErrorReset();
2953
3346
    GDALMajorObjectShadow_SetDescription(arg1,(char const *)arg2);
2954
3347
    CPLErr eclass = CPLGetLastErrorType();
3093
3486
  arg2 = (char *)jarg2; 
3094
3487
  arg3 = (char *)jarg3; 
3095
3488
  {
 
3489
    if (!arg2) {
 
3490
      {
 
3491
        SWIG_CSharpException(SWIG_ValueError, "Received a NULL pointer."); return 0; 
 
3492
      };
 
3493
    }
 
3494
  }
 
3495
  {
3096
3496
    CPLErrorReset();
3097
3497
    result = (char *)GDALMajorObjectShadow_GetMetadataItem(arg1,(char const *)arg2,(char const *)arg3);
3098
3498
    CPLErr eclass = CPLGetLastErrorType();
3132
3532
  arg3 = (char *)jarg3; 
3133
3533
  arg4 = (char *)jarg4; 
3134
3534
  {
 
3535
    if (!arg2) {
 
3536
      {
 
3537
        SWIG_CSharpException(SWIG_ValueError, "Received a NULL pointer."); return 0; 
 
3538
      };
 
3539
    }
 
3540
  }
 
3541
  {
3135
3542
    CPLErrorReset();
3136
3543
    result = (CPLErr)GDALMajorObjectShadow_SetMetadataItem(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4);
3137
3544
    CPLErr eclass = CPLGetLastErrorType();
3276
3683
  arg6 = (GDALDataType)jarg6; 
3277
3684
  arg7 = (char **)jarg7; 
3278
3685
  {
3279
 
    if (!arg2) {
3280
 
      {
3281
 
        SWIG_CSharpException(SWIG_ValueError, "Received a NULL pointer."); return 0; 
3282
 
      };
3283
 
    }
3284
 
  }
3285
 
  {
3286
3686
    CPLErrorReset();
3287
3687
    result = (GDALDatasetShadow *)GDALDriverShadow_Create(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7);
3288
3688
    CPLErr eclass = CPLGetLastErrorType();
3328
3728
  arg6 = (GDALProgressFunc)jarg6; 
3329
3729
  arg7 = (void *)jarg7; 
3330
3730
  {
3331
 
    if (!arg2) {
3332
 
      {
3333
 
        SWIG_CSharpException(SWIG_ValueError, "Received a NULL pointer."); return 0; 
3334
 
      };
3335
 
    }
3336
 
  }
3337
 
  {
3338
3731
    if (!arg3) {
3339
3732
      {
3340
3733
        SWIG_CSharpException(SWIG_ValueError, "Received a NULL pointer."); return 0; 
3377
3770
  arg1 = (GDALDriverShadow *)jarg1; 
3378
3771
  arg2 = (char *)jarg2; 
3379
3772
  {
3380
 
    if (!arg2) {
3381
 
      {
3382
 
        SWIG_CSharpException(SWIG_ValueError, "Received a NULL pointer."); return 0; 
3383
 
      };
3384
 
    }
3385
 
  }
3386
 
  {
3387
3773
    CPLErrorReset();
3388
3774
    result = (int)GDALDriverShadow_Delete(arg1,(char const *)arg2);
3389
3775
    CPLErr eclass = CPLGetLastErrorType();
3461
3847
}
3462
3848
 
3463
3849
 
 
3850
SWIGEXPORT int SWIGSTDCALL CSharp_Driver_CopyFiles(void * jarg1, char * jarg2, char * jarg3) {
 
3851
  int jresult ;
 
3852
  GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
 
3853
  char *arg2 = (char *) 0 ;
 
3854
  char *arg3 = (char *) 0 ;
 
3855
  int result;
 
3856
  
 
3857
  arg1 = (GDALDriverShadow *)jarg1; 
 
3858
  arg2 = (char *)jarg2; 
 
3859
  arg3 = (char *)jarg3; 
 
3860
  {
 
3861
    if (!arg2) {
 
3862
      {
 
3863
        SWIG_CSharpException(SWIG_ValueError, "Received a NULL pointer."); return 0; 
 
3864
      };
 
3865
    }
 
3866
  }
 
3867
  {
 
3868
    if (!arg3) {
 
3869
      {
 
3870
        SWIG_CSharpException(SWIG_ValueError, "Received a NULL pointer."); return 0; 
 
3871
      };
 
3872
    }
 
3873
  }
 
3874
  {
 
3875
    CPLErrorReset();
 
3876
    result = (int)GDALDriverShadow_CopyFiles(arg1,(char const *)arg2,(char const *)arg3);
 
3877
    CPLErr eclass = CPLGetLastErrorType();
 
3878
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
 
3879
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
 
3880
      
 
3881
      
 
3882
      
 
3883
    }
 
3884
    
 
3885
    
 
3886
    
 
3887
    
 
3888
    
 
3889
    
 
3890
    
 
3891
    
 
3892
    
 
3893
    
 
3894
    
 
3895
  }
 
3896
  jresult = result; 
 
3897
  return jresult;
 
3898
}
 
3899
 
 
3900
 
3464
3901
SWIGEXPORT int SWIGSTDCALL CSharp_Driver_Register(void * jarg1) {
3465
3902
  int jresult ;
3466
3903
  GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
5297
5734
  GDAL_GCP *arg2 = (GDAL_GCP *) 0 ;
5298
5735
  double *arg3 ;
5299
5736
  int arg4 = (int) 1 ;
5300
 
  FALSE_IS_ERR result;
 
5737
  RETURN_NONE result;
5301
5738
  
5302
5739
  arg1 = (int)jarg1; 
5303
5740
  arg2 = (GDAL_GCP *)jarg2; 
5333
5770
}
5334
5771
 
5335
5772
 
 
5773
SWIGEXPORT void SWIGSTDCALL CSharp_delete_AsyncReader(void * jarg1) {
 
5774
  GDALAsyncReaderShadow *arg1 = (GDALAsyncReaderShadow *) 0 ;
 
5775
  
 
5776
  arg1 = (GDALAsyncReaderShadow *)jarg1; 
 
5777
  {
 
5778
    CPLErrorReset();
 
5779
    delete_GDALAsyncReaderShadow(arg1);
 
5780
    CPLErr eclass = CPLGetLastErrorType();
 
5781
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
 
5782
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
 
5783
      
 
5784
      
 
5785
      
 
5786
    }
 
5787
    
 
5788
    
 
5789
    
 
5790
    
 
5791
    
 
5792
    
 
5793
    
 
5794
    
 
5795
    
 
5796
    
 
5797
    
 
5798
  }
 
5799
}
 
5800
 
 
5801
 
 
5802
SWIGEXPORT int SWIGSTDCALL CSharp_AsyncReader_GetNextUpdatedRegion(void * jarg1, double jarg2, int * jarg3, int * jarg4, int * jarg5, int * jarg6) {
 
5803
  int jresult ;
 
5804
  GDALAsyncReaderShadow *arg1 = (GDALAsyncReaderShadow *) 0 ;
 
5805
  double arg2 ;
 
5806
  int *arg3 = (int *) 0 ;
 
5807
  int *arg4 = (int *) 0 ;
 
5808
  int *arg5 = (int *) 0 ;
 
5809
  int *arg6 = (int *) 0 ;
 
5810
  GDALAsyncStatusType result;
 
5811
  
 
5812
  arg1 = (GDALAsyncReaderShadow *)jarg1; 
 
5813
  arg2 = (double)jarg2; 
 
5814
  arg3 = (int *)jarg3; 
 
5815
  arg4 = (int *)jarg4; 
 
5816
  arg5 = (int *)jarg5; 
 
5817
  arg6 = (int *)jarg6; 
 
5818
  {
 
5819
    CPLErrorReset();
 
5820
    result = (GDALAsyncStatusType)GDALAsyncReaderShadow_GetNextUpdatedRegion(arg1,arg2,arg3,arg4,arg5,arg6);
 
5821
    CPLErr eclass = CPLGetLastErrorType();
 
5822
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
 
5823
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
 
5824
      
 
5825
      
 
5826
      
 
5827
    }
 
5828
    
 
5829
    
 
5830
    
 
5831
    
 
5832
    
 
5833
    
 
5834
    
 
5835
    
 
5836
    
 
5837
    
 
5838
    
 
5839
  }
 
5840
  jresult = result; 
 
5841
  return jresult;
 
5842
}
 
5843
 
 
5844
 
 
5845
SWIGEXPORT int SWIGSTDCALL CSharp_AsyncReader_LockBuffer(void * jarg1, double jarg2) {
 
5846
  int jresult ;
 
5847
  GDALAsyncReaderShadow *arg1 = (GDALAsyncReaderShadow *) 0 ;
 
5848
  double arg2 ;
 
5849
  int result;
 
5850
  
 
5851
  arg1 = (GDALAsyncReaderShadow *)jarg1; 
 
5852
  arg2 = (double)jarg2; 
 
5853
  {
 
5854
    CPLErrorReset();
 
5855
    result = (int)GDALAsyncReaderShadow_LockBuffer(arg1,arg2);
 
5856
    CPLErr eclass = CPLGetLastErrorType();
 
5857
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
 
5858
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
 
5859
      
 
5860
      
 
5861
      
 
5862
    }
 
5863
    
 
5864
    
 
5865
    
 
5866
    
 
5867
    
 
5868
    
 
5869
    
 
5870
    
 
5871
    
 
5872
    
 
5873
    
 
5874
  }
 
5875
  jresult = result; 
 
5876
  return jresult;
 
5877
}
 
5878
 
 
5879
 
 
5880
SWIGEXPORT void SWIGSTDCALL CSharp_AsyncReader_UnlockBuffer(void * jarg1) {
 
5881
  GDALAsyncReaderShadow *arg1 = (GDALAsyncReaderShadow *) 0 ;
 
5882
  
 
5883
  arg1 = (GDALAsyncReaderShadow *)jarg1; 
 
5884
  {
 
5885
    CPLErrorReset();
 
5886
    GDALAsyncReaderShadow_UnlockBuffer(arg1);
 
5887
    CPLErr eclass = CPLGetLastErrorType();
 
5888
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
 
5889
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
 
5890
      
 
5891
      
 
5892
      
 
5893
    }
 
5894
    
 
5895
    
 
5896
    
 
5897
    
 
5898
    
 
5899
    
 
5900
    
 
5901
    
 
5902
    
 
5903
    
 
5904
    
 
5905
  }
 
5906
}
 
5907
 
 
5908
 
5336
5909
SWIGEXPORT int SWIGSTDCALL CSharp_Dataset_RasterXSize_get(void * jarg1) {
5337
5910
  int jresult ;
5338
5911
  GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
5604
6177
  arg1 = (GDALDatasetShadow *)jarg1; 
5605
6178
  arg2 = (char *)jarg2; 
5606
6179
  {
 
6180
    if (!arg2) {
 
6181
      {
 
6182
        SWIG_CSharpException(SWIG_ValueError, "Received a NULL pointer."); return 0; 
 
6183
      };
 
6184
    }
 
6185
  }
 
6186
  {
5607
6187
    CPLErrorReset();
5608
6188
    result = (CPLErr)GDALDatasetShadow_SetProjection(arg1,(char const *)arg2);
5609
6189
    CPLErr eclass = CPLGetLastErrorType();
6687
7267
}
6688
7268
 
6689
7269
 
 
7270
SWIGEXPORT int SWIGSTDCALL CSharp_Band_SetUnitType(void * jarg1, char * jarg2) {
 
7271
  int jresult ;
 
7272
  GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
 
7273
  char *arg2 = (char *) 0 ;
 
7274
  CPLErr result;
 
7275
  
 
7276
  arg1 = (GDALRasterBandShadow *)jarg1; 
 
7277
  arg2 = (char *)jarg2; 
 
7278
  {
 
7279
    CPLErrorReset();
 
7280
    result = (CPLErr)GDALRasterBandShadow_SetUnitType(arg1,(char const *)arg2);
 
7281
    CPLErr eclass = CPLGetLastErrorType();
 
7282
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
 
7283
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
 
7284
      
 
7285
      
 
7286
      
 
7287
    }
 
7288
    
 
7289
    
 
7290
    
 
7291
    
 
7292
    
 
7293
    
 
7294
    
 
7295
    
 
7296
    
 
7297
    
 
7298
    
 
7299
  }
 
7300
  jresult = result; 
 
7301
  return jresult;
 
7302
}
 
7303
 
 
7304
 
6690
7305
SWIGEXPORT void * SWIGSTDCALL CSharp_Band_GetRasterCategoryNames(void * jarg1) {
6691
7306
  void * jresult ;
6692
7307
  GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
6911
7526
}
6912
7527
 
6913
7528
 
 
7529
SWIGEXPORT int SWIGSTDCALL CSharp_Band_SetOffset(void * jarg1, double jarg2) {
 
7530
  int jresult ;
 
7531
  GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
 
7532
  double arg2 ;
 
7533
  CPLErr result;
 
7534
  
 
7535
  arg1 = (GDALRasterBandShadow *)jarg1; 
 
7536
  arg2 = (double)jarg2; 
 
7537
  {
 
7538
    CPLErrorReset();
 
7539
    result = (CPLErr)GDALRasterBandShadow_SetOffset(arg1,arg2);
 
7540
    CPLErr eclass = CPLGetLastErrorType();
 
7541
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
 
7542
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
 
7543
      
 
7544
      
 
7545
      
 
7546
    }
 
7547
    
 
7548
    
 
7549
    
 
7550
    
 
7551
    
 
7552
    
 
7553
    
 
7554
    
 
7555
    
 
7556
    
 
7557
    
 
7558
  }
 
7559
  jresult = result; 
 
7560
  return jresult;
 
7561
}
 
7562
 
 
7563
 
 
7564
SWIGEXPORT int SWIGSTDCALL CSharp_Band_SetScale(void * jarg1, double jarg2) {
 
7565
  int jresult ;
 
7566
  GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
 
7567
  double arg2 ;
 
7568
  CPLErr result;
 
7569
  
 
7570
  arg1 = (GDALRasterBandShadow *)jarg1; 
 
7571
  arg2 = (double)jarg2; 
 
7572
  {
 
7573
    CPLErrorReset();
 
7574
    result = (CPLErr)GDALRasterBandShadow_SetScale(arg1,arg2);
 
7575
    CPLErr eclass = CPLGetLastErrorType();
 
7576
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
 
7577
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
 
7578
      
 
7579
      
 
7580
      
 
7581
    }
 
7582
    
 
7583
    
 
7584
    
 
7585
    
 
7586
    
 
7587
    
 
7588
    
 
7589
    
 
7590
    
 
7591
    
 
7592
    
 
7593
  }
 
7594
  jresult = result; 
 
7595
  return jresult;
 
7596
}
 
7597
 
 
7598
 
6914
7599
SWIGEXPORT int SWIGSTDCALL CSharp_Band_GetStatistics(void * jarg1, int jarg2, int jarg3, double * jarg4, double * jarg5, double * jarg6, double * jarg7) {
6915
7600
  int jresult ;
6916
7601
  GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
7799
8484
}
7800
8485
 
7801
8486
 
 
8487
SWIGEXPORT void * SWIGSTDCALL CSharp_Band_GetCategoryNames(void * jarg1) {
 
8488
  void * jresult ;
 
8489
  GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
 
8490
  char **result = 0 ;
 
8491
  
 
8492
  arg1 = (GDALRasterBandShadow *)jarg1; 
 
8493
  {
 
8494
    CPLErrorReset();
 
8495
    result = (char **)GDALRasterBandShadow_GetCategoryNames(arg1);
 
8496
    CPLErr eclass = CPLGetLastErrorType();
 
8497
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
 
8498
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
 
8499
      
 
8500
      
 
8501
      
 
8502
    }
 
8503
    
 
8504
    
 
8505
    
 
8506
    
 
8507
    
 
8508
    
 
8509
    
 
8510
    
 
8511
    
 
8512
    
 
8513
    
 
8514
  }
 
8515
  jresult = result; 
 
8516
  return jresult;
 
8517
}
 
8518
 
 
8519
 
 
8520
SWIGEXPORT int SWIGSTDCALL CSharp_Band_SetCategoryNames(void * jarg1, void * jarg2) {
 
8521
  int jresult ;
 
8522
  GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
 
8523
  char **arg2 = (char **) 0 ;
 
8524
  CPLErr result;
 
8525
  
 
8526
  arg1 = (GDALRasterBandShadow *)jarg1; 
 
8527
  arg2 = (char **)jarg2; 
 
8528
  {
 
8529
    CPLErrorReset();
 
8530
    result = (CPLErr)GDALRasterBandShadow_SetCategoryNames(arg1,arg2);
 
8531
    CPLErr eclass = CPLGetLastErrorType();
 
8532
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
 
8533
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
 
8534
      
 
8535
      
 
8536
      
 
8537
    }
 
8538
    
 
8539
    
 
8540
    
 
8541
    
 
8542
    
 
8543
    
 
8544
    
 
8545
    
 
8546
    
 
8547
    
 
8548
    
 
8549
  }
 
8550
  jresult = result; 
 
8551
  return jresult;
 
8552
}
 
8553
 
 
8554
 
7802
8555
SWIGEXPORT int SWIGSTDCALL CSharp_Band_ReadRaster(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5, void * jarg6, int jarg7, int jarg8, int jarg9, int jarg10, int jarg11) {
7803
8556
  int jresult ;
7804
8557
  GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
9527
10280
}
9528
10281
 
9529
10282
 
 
10283
SWIGEXPORT int SWIGSTDCALL CSharp_ContourGenerate(void * jarg1, double jarg2, double jarg3, int jarg4, void * jarg5, int jarg6, double jarg7, void * jarg8, int jarg9, int jarg10, void * jarg11, void * jarg12) {
 
10284
  int jresult ;
 
10285
  GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
 
10286
  double arg2 ;
 
10287
  double arg3 ;
 
10288
  int arg4 ;
 
10289
  double *arg5 = (double *) 0 ;
 
10290
  int arg6 ;
 
10291
  double arg7 ;
 
10292
  OGRLayerShadow *arg8 = (OGRLayerShadow *) 0 ;
 
10293
  int arg9 ;
 
10294
  int arg10 ;
 
10295
  GDALProgressFunc arg11 = (GDALProgressFunc) NULL ;
 
10296
  void *arg12 = (void *) NULL ;
 
10297
  int result;
 
10298
  
 
10299
  arg1 = (GDALRasterBandShadow *)jarg1; 
 
10300
  arg2 = (double)jarg2; 
 
10301
  arg3 = (double)jarg3; 
 
10302
  arg4 = (int)jarg4; 
 
10303
  arg5 = (double *)jarg5; 
 
10304
  arg6 = (int)jarg6; 
 
10305
  arg7 = (double)jarg7; 
 
10306
  arg8 = (OGRLayerShadow *)jarg8; 
 
10307
  arg9 = (int)jarg9; 
 
10308
  arg10 = (int)jarg10; 
 
10309
  arg11 = (GDALProgressFunc)jarg11; 
 
10310
  arg12 = (void *)jarg12; 
 
10311
  {
 
10312
    if (!arg1) {
 
10313
      {
 
10314
        SWIG_CSharpException(SWIG_ValueError, "Received a NULL pointer."); return 0; 
 
10315
      };
 
10316
    }
 
10317
  }
 
10318
  {
 
10319
    if (!arg8) {
 
10320
      {
 
10321
        SWIG_CSharpException(SWIG_ValueError, "Received a NULL pointer."); return 0; 
 
10322
      };
 
10323
    }
 
10324
  }
 
10325
  {
 
10326
    CPLErrorReset();
 
10327
    result = (int)ContourGenerate(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
 
10328
    CPLErr eclass = CPLGetLastErrorType();
 
10329
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
 
10330
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
 
10331
      
 
10332
      
 
10333
      
 
10334
    }
 
10335
    
 
10336
    
 
10337
    
 
10338
    
 
10339
    
 
10340
    
 
10341
    
 
10342
    
 
10343
    
 
10344
    
 
10345
    
 
10346
  }
 
10347
  jresult = result; 
 
10348
  return jresult;
 
10349
}
 
10350
 
 
10351
 
9530
10352
SWIGEXPORT void * SWIGSTDCALL CSharp_AutoCreateWarpedVRT(void * jarg1, char * jarg2, char * jarg3, int jarg4, double jarg5) {
9531
10353
  void * jresult ;
9532
10354
  GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
9962
10784
  
9963
10785
  {
9964
10786
    CPLErrorReset();
9965
 
    result = (int)GDALGetCacheMax();
 
10787
    result = (int)wrapper_GDALGetCacheMax();
 
10788
    CPLErr eclass = CPLGetLastErrorType();
 
10789
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
 
10790
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
 
10791
      
 
10792
      
 
10793
      
 
10794
    }
 
10795
    
 
10796
    
 
10797
    
 
10798
    
 
10799
    
 
10800
    
 
10801
    
 
10802
    
 
10803
    
 
10804
    
 
10805
    
 
10806
  }
 
10807
  jresult = result; 
 
10808
  return jresult;
 
10809
}
 
10810
 
 
10811
 
 
10812
SWIGEXPORT int SWIGSTDCALL CSharp_GetCacheUsed() {
 
10813
  int jresult ;
 
10814
  int result;
 
10815
  
 
10816
  {
 
10817
    CPLErrorReset();
 
10818
    result = (int)wrapper_GDALGetCacheUsed();
9966
10819
    CPLErr eclass = CPLGetLastErrorType();
9967
10820
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9968
10821
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
9993
10846
  arg1 = (int)jarg1; 
9994
10847
  {
9995
10848
    CPLErrorReset();
9996
 
    GDALSetCacheMax(arg1);
9997
 
    CPLErr eclass = CPLGetLastErrorType();
9998
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
9999
 
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
10000
 
      
10001
 
      
10002
 
      
10003
 
    }
10004
 
    
10005
 
    
10006
 
    
10007
 
    
10008
 
    
10009
 
    
10010
 
    
10011
 
    
10012
 
    
10013
 
    
10014
 
    
10015
 
  }
10016
 
}
10017
 
 
10018
 
 
10019
 
SWIGEXPORT int SWIGSTDCALL CSharp_GetCacheUsed() {
10020
 
  int jresult ;
10021
 
  int result;
10022
 
  
10023
 
  {
10024
 
    CPLErrorReset();
10025
 
    result = (int)GDALGetCacheUsed();
10026
 
    CPLErr eclass = CPLGetLastErrorType();
10027
 
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
10028
 
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
10029
 
      
10030
 
      
10031
 
      
10032
 
    }
10033
 
    
10034
 
    
10035
 
    
10036
 
    
10037
 
    
10038
 
    
10039
 
    
10040
 
    
10041
 
    
10042
 
    
10043
 
    
10044
 
  }
10045
 
  jresult = result; 
10046
 
  return jresult;
 
10849
    wrapper_GDALSetCacheMax(arg1);
 
10850
    CPLErr eclass = CPLGetLastErrorType();
 
10851
    if ( eclass == CE_Failure || eclass == CE_Fatal ) {
 
10852
      SWIG_CSharpException(SWIG_RuntimeError, CPLGetLastErrorMsg());
 
10853
      
 
10854
      
 
10855
      
 
10856
    }
 
10857
    
 
10858
    
 
10859
    
 
10860
    
 
10861
    
 
10862
    
 
10863
    
 
10864
    
 
10865
    
 
10866
    
 
10867
    
 
10868
  }
10047
10869
}
10048
10870
 
10049
10871
 
10538
11360
  arg1 = (char *)jarg1; 
10539
11361
  arg2 = (GDALAccess)jarg2; 
10540
11362
  {
10541
 
    if (!arg1) {
10542
 
      {
10543
 
        SWIG_CSharpException(SWIG_ValueError, "Received a NULL pointer."); return 0; 
10544
 
      };
10545
 
    }
10546
 
  }
10547
 
  {
10548
11363
    CPLErrorReset();
10549
11364
    result = (GDALDatasetShadow *)Open((char const *)arg1,arg2);
10550
11365
    CPLErr eclass = CPLGetLastErrorType();
10580
11395
  arg1 = (char *)jarg1; 
10581
11396
  arg2 = (GDALAccess)jarg2; 
10582
11397
  {
10583
 
    if (!arg1) {
10584
 
      {
10585
 
        SWIG_CSharpException(SWIG_ValueError, "Received a NULL pointer."); return 0; 
10586
 
      };
10587
 
    }
10588
 
  }
10589
 
  {
10590
11398
    CPLErrorReset();
10591
11399
    result = (GDALDatasetShadow *)OpenShared((char const *)arg1,arg2);
10592
11400
    CPLErr eclass = CPLGetLastErrorType();