Line data    Source code

       1             : /******************************************************************************
       2             :  *
       3             :  * Project:  OpenGIS Simple Features Reference Implementation
       4             :  * Purpose:  The OGRSFDriverRegistrar class implementation.
       5             :  * Author:   Frank Warmerdam, warmerdam@pobox.com
       6             :  *
       7             :  ******************************************************************************
       8             :  * Copyright (c) 1999,  Les Technologies SoftMap Inc.
       9             :  * Copyright (c) 2008-2012, Even Rouault <even dot rouault at spatialys.com>
      10             :  *
      11             :  * SPDX-License-Identifier: MIT
      12             :  ****************************************************************************/
      13             : 
      14             : #include "ogrsf_frmts.h"
      15             : #include "ogr_api.h"
      16             : #include "ograpispy.h"
      17             : 
      18             : /************************************************************************/
      19             : /*                         OGRSFDriverRegistrar                         */
      20             : /************************************************************************/
      21             : 
      22             : /**
      23             :  * \brief Constructor
      24             :  *
      25             :  * Normally the driver registrar is constructed by the
      26             :  * OGRSFDriverRegistrar::GetRegistrar() accessor which ensures singleton
      27             :  * status.
      28             :  */
      29             : 
      30         299 : OGRSFDriverRegistrar::OGRSFDriverRegistrar()
      31             : {
      32         299 : }
      33             : 
      34             : /************************************************************************/
      35             : /*                       ~OGRSFDriverRegistrar()                        */
      36             : /************************************************************************/
      37             : 
      38         299 : OGRSFDriverRegistrar::~OGRSFDriverRegistrar()
      39             : {
      40         299 : }
      41             : 
      42             : //! @cond Doxygen_Suppress
      43             : /************************************************************************/
      44             : /*                           GetRegistrar()                             */
      45             : /************************************************************************/
      46             : 
      47        2944 : OGRSFDriverRegistrar *OGRSFDriverRegistrar::GetRegistrar()
      48             : {
      49        2944 :     static OGRSFDriverRegistrar oSingleton;
      50        2944 :     return &oSingleton;
      51             : }
      52             : 
      53             : /************************************************************************/
      54             : /*                           OGRCleanupAll()                            */
      55             : /************************************************************************/
      56             : 
      57             : /**
      58             :  * \brief Cleanup all OGR related resources.
      59             :  *
      60             :  * \see GDALDestroy()
      61             :  * \deprecated Use GDALDestroy() instead
      62             :  */
      63         805 : void OGRCleanupAll()
      64             : 
      65             : {
      66         805 :     GDALDestroyDriverManager();
      67         805 : }
      68             : 
      69             : /************************************************************************/
      70             : /*                              OGROpen()                               */
      71             : /************************************************************************/
      72             : 
      73         219 : OGRDataSourceH OGROpen(const char *pszName, int bUpdate,
      74             :                        OGRSFDriverH *pahDriverList)
      75             : 
      76             : {
      77         219 :     VALIDATE_POINTER1(pszName, "OGROpen", nullptr);
      78             : 
      79             :     GDALDatasetH hDS =
      80         219 :         GDALOpenEx(pszName, GDAL_OF_VECTOR | ((bUpdate) ? GDAL_OF_UPDATE : 0),
      81             :                    nullptr, nullptr, nullptr);
      82         219 :     if (hDS != nullptr && pahDriverList != nullptr)
      83           0 :         *pahDriverList =
      84           0 :             reinterpret_cast<OGRSFDriverH>(GDALGetDatasetDriver(hDS));
      85             : 
      86         219 :     return reinterpret_cast<OGRDataSourceH>(hDS);
      87             : }
      88             : 
      89             : /************************************************************************/
      90             : /*                           OGROpenShared()                            */
      91             : /************************************************************************/
      92             : 
      93          21 : OGRDataSourceH OGROpenShared(const char *pszName, int bUpdate,
      94             :                              OGRSFDriverH *pahDriverList)
      95             : 
      96             : {
      97          21 :     VALIDATE_POINTER1(pszName, "OGROpenShared", nullptr);
      98             : 
      99          21 :     GDALDatasetH hDS = GDALOpenEx(
     100             :         pszName,
     101             :         GDAL_OF_VECTOR | ((bUpdate) ? GDAL_OF_UPDATE : 0) | GDAL_OF_SHARED,
     102             :         nullptr, nullptr, nullptr);
     103          21 :     if (hDS != nullptr && pahDriverList != nullptr)
     104           0 :         *pahDriverList =
     105           0 :             reinterpret_cast<OGRSFDriverH>(GDALGetDatasetDriver(hDS));
     106          21 :     return reinterpret_cast<OGRDataSourceH>(hDS);
     107             : }
     108             : 
     109             : /************************************************************************/
     110             : /*                        OGRReleaseDataSource()                        */
     111             : /************************************************************************/
     112             : 
     113           0 : OGRErr OGRReleaseDataSource(OGRDataSourceH hDS)
     114             : 
     115             : {
     116           0 :     VALIDATE_POINTER1(hDS, "OGRReleaseDataSource", OGRERR_INVALID_HANDLE);
     117             : 
     118           0 :     GDALClose(reinterpret_cast<GDALDatasetH>(hDS));
     119             : 
     120           0 :     return OGRERR_NONE;
     121             : }
     122             : 
     123             : /************************************************************************/
     124             : /*                           GetOpenDSCount()                           */
     125             : /************************************************************************/
     126             : 
     127           0 : int OGRSFDriverRegistrar::GetOpenDSCount()
     128             : {
     129           0 :     CPLError(CE_Failure, CPLE_AppDefined, "Stub implementation in GDAL 2.0");
     130           0 :     return 0;
     131             : }
     132             : 
     133             : /************************************************************************/
     134             : /*                         OGRGetOpenDSCount()                          */
     135             : /************************************************************************/
     136             : 
     137           0 : int OGRGetOpenDSCount()
     138             : 
     139             : {
     140           0 :     return OGRSFDriverRegistrar::GetRegistrar()->GetOpenDSCount();
     141             : }
     142             : 
     143             : /************************************************************************/
     144             : /*                             GetOpenDS()                              */
     145             : /************************************************************************/
     146             : 
     147           1 : OGRDataSource *OGRSFDriverRegistrar::GetOpenDS(CPL_UNUSED int iDS)
     148             : {
     149           1 :     CPLError(CE_Failure, CPLE_AppDefined, "Stub implementation in GDAL 2.0");
     150           1 :     return nullptr;
     151             : }
     152             : 
     153             : /************************************************************************/
     154             : /*                            OGRGetOpenDS()                            */
     155             : /************************************************************************/
     156             : 
     157           1 : OGRDataSourceH OGRGetOpenDS(int iDS)
     158             : 
     159             : {
     160             :     return reinterpret_cast<OGRDataSourceH>(
     161           1 :         OGRSFDriverRegistrar::GetRegistrar()->GetOpenDS(iDS));
     162             : }
     163             : 
     164             : /************************************************************************/
     165             : /*                          OpenWithDriverArg()                         */
     166             : /************************************************************************/
     167             : 
     168           0 : GDALDataset *OGRSFDriverRegistrar::OpenWithDriverArg(GDALDriver *poDriver,
     169             :                                                      GDALOpenInfo *poOpenInfo)
     170             : {
     171           0 :     OGRDataSource *poDS = reinterpret_cast<OGRDataSource *>(
     172             :         reinterpret_cast<OGRSFDriver *>(poDriver)->Open(
     173           0 :             poOpenInfo->pszFilename, poOpenInfo->eAccess == GA_Update));
     174           0 :     if (poDS != nullptr)
     175           0 :         poDS->SetDescription(poDS->GetName());
     176           0 :     return poDS;
     177             : }
     178             : 
     179             : /************************************************************************/
     180             : /*                          CreateVectorOnly()                          */
     181             : /************************************************************************/
     182             : 
     183           0 : GDALDataset *OGRSFDriverRegistrar::CreateVectorOnly(GDALDriver *poDriver,
     184             :                                                     const char *pszName,
     185             :                                                     char **papszOptions)
     186             : {
     187           0 :     OGRDataSource *poDS = reinterpret_cast<OGRDataSource *>(
     188             :         reinterpret_cast<OGRSFDriver *>(poDriver)->CreateDataSource(
     189           0 :             pszName, papszOptions));
     190           0 :     if (poDS != nullptr && poDS->GetName() != nullptr)
     191           0 :         poDS->SetDescription(poDS->GetName());
     192           0 :     return poDS;
     193             : }
     194             : 
     195             : /************************************************************************/
     196             : /*                          DeleteDataSource()                          */
     197             : /************************************************************************/
     198             : 
     199           0 : CPLErr OGRSFDriverRegistrar::DeleteDataSource(GDALDriver *poDriver,
     200             :                                               const char *pszName)
     201             : {
     202           0 :     if (reinterpret_cast<OGRSFDriver *>(poDriver)->DeleteDataSource(pszName) ==
     203             :         OGRERR_NONE)
     204           0 :         return CE_None;
     205             :     else
     206           0 :         return CE_Failure;
     207             : }
     208             : 
     209             : /************************************************************************/
     210             : /*                           RegisterDriver()                           */
     211             : /************************************************************************/
     212             : 
     213           0 : void OGRSFDriverRegistrar::RegisterDriver(OGRSFDriver *poDriver)
     214             : 
     215             : {
     216             :     GDALDriver *poGDALDriver =
     217           0 :         GDALDriver::FromHandle(GDALGetDriverByName(poDriver->GetName()));
     218           0 :     if (poGDALDriver == nullptr)
     219             :     {
     220           0 :         poDriver->SetDescription(poDriver->GetName());
     221           0 :         poDriver->SetMetadataItem("OGR_DRIVER", "YES");
     222             : 
     223           0 :         if (poDriver->GetMetadataItem(GDAL_DMD_LONGNAME) == nullptr)
     224           0 :             poDriver->SetMetadataItem(GDAL_DMD_LONGNAME, poDriver->GetName());
     225             : 
     226           0 :         poDriver->pfnOpenWithDriverArg = OpenWithDriverArg;
     227             : 
     228           0 :         if (poDriver->TestCapability(ODrCCreateDataSource))
     229             :         {
     230           0 :             poDriver->SetMetadataItem(GDAL_DCAP_CREATE, "YES");
     231           0 :             poDriver->pfnCreateVectorOnly = CreateVectorOnly;
     232             :         }
     233           0 :         if (poDriver->TestCapability(ODrCDeleteDataSource))
     234             :         {
     235           0 :             poDriver->pfnDeleteDataSource = DeleteDataSource;
     236             :         }
     237             : 
     238           0 :         poDriver->SetMetadataItem(GDAL_DCAP_VECTOR, "YES");
     239             : 
     240           0 :         GetGDALDriverManager()->RegisterDriver(poDriver);
     241             :     }
     242             :     else
     243             :     {
     244           0 :         if (poGDALDriver->GetMetadataItem("OGR_DRIVER") == nullptr)
     245             :         {
     246           0 :             CPLError(CE_Failure, CPLE_AppDefined,
     247             :                      "A non OGR driver is registered with the same name: %s",
     248           0 :                      poDriver->GetName());
     249             :         }
     250           0 :         delete poDriver;
     251             :     }
     252           0 : }
     253             : 
     254             : /************************************************************************/
     255             : /*                         OGRRegisterDriver()                          */
     256             : /************************************************************************/
     257             : 
     258           0 : void OGRRegisterDriver(OGRSFDriverH hDriver)
     259             : 
     260             : {
     261           0 :     VALIDATE_POINTER0(hDriver, "OGRRegisterDriver");
     262             : 
     263           0 :     GetGDALDriverManager()->RegisterDriver(GDALDriver::FromHandle(hDriver));
     264             : }
     265             : 
     266             : /************************************************************************/
     267             : /*                        OGRDeregisterDriver()                         */
     268             : /************************************************************************/
     269             : 
     270           0 : void OGRDeregisterDriver(OGRSFDriverH hDriver)
     271             : 
     272             : {
     273           0 :     VALIDATE_POINTER0(hDriver, "OGRDeregisterDriver");
     274             : 
     275           0 :     GetGDALDriverManager()->DeregisterDriver(GDALDriver::FromHandle(hDriver));
     276             : }
     277             : 
     278             : /************************************************************************/
     279             : /*                           GetDriverCount()                           */
     280             : /************************************************************************/
     281             : 
     282         303 : int OGRSFDriverRegistrar::GetDriverCount()
     283             : 
     284             : {
     285             :     /* We must be careful only to return drivers that are actual OGRSFDriver* */
     286         303 :     GDALDriverManager *poDriverManager = GetGDALDriverManager();
     287         303 :     int nTotal = poDriverManager->GetDriverCount();
     288         303 :     int nOGRDriverCount = 0;
     289       72445 :     for (int i = 0; i < nTotal; i++)
     290             :     {
     291       72142 :         GDALDriver *poDriver = poDriverManager->GetDriver(i);
     292       72142 :         if (poDriver->GetMetadataItem(GDAL_DCAP_VECTOR) != nullptr)
     293       28179 :             nOGRDriverCount++;
     294             :     }
     295         303 :     return nOGRDriverCount;
     296             : }
     297             : 
     298             : /************************************************************************/
     299             : /*                         OGRGetDriverCount()                          */
     300             : /************************************************************************/
     301             : 
     302         303 : int OGRGetDriverCount()
     303             : 
     304             : {
     305         303 :     return OGRSFDriverRegistrar::GetRegistrar()->GetDriverCount();
     306             : }
     307             : 
     308             : /************************************************************************/
     309             : /*                             GetDriver()                              */
     310             : /************************************************************************/
     311             : 
     312           0 : GDALDriver *OGRSFDriverRegistrar::GetDriver(int iDriver)
     313             : 
     314             : {
     315             :     /* We must be careful only to return drivers that are actual OGRSFDriver* */
     316           0 :     GDALDriverManager *poDriverManager = GetGDALDriverManager();
     317           0 :     int nTotal = poDriverManager->GetDriverCount();
     318           0 :     int nOGRDriverCount = 0;
     319           0 :     for (int i = 0; i < nTotal; i++)
     320             :     {
     321           0 :         GDALDriver *poDriver = poDriverManager->GetDriver(i);
     322           0 :         if (poDriver->GetMetadataItem(GDAL_DCAP_VECTOR) != nullptr)
     323             :         {
     324           0 :             if (nOGRDriverCount == iDriver)
     325           0 :                 return poDriver;
     326           0 :             nOGRDriverCount++;
     327             :         }
     328             :     }
     329           0 :     return nullptr;
     330             : }
     331             : 
     332             : /************************************************************************/
     333             : /*                            OGRGetDriver()                            */
     334             : /************************************************************************/
     335             : 
     336           0 : OGRSFDriverH OGRGetDriver(int iDriver)
     337             : 
     338             : {
     339             :     return reinterpret_cast<OGRSFDriverH>(
     340           0 :         OGRSFDriverRegistrar::GetRegistrar()->GetDriver(iDriver));
     341             : }
     342             : 
     343             : /************************************************************************/
     344             : /*                          GetDriverByName()                           */
     345             : /************************************************************************/
     346             : 
     347        2640 : GDALDriver *OGRSFDriverRegistrar::GetDriverByName(const char *pszName)
     348             : 
     349             : {
     350        2640 :     GDALDriverManager *poDriverManager = GetGDALDriverManager();
     351             :     GDALDriver *poGDALDriver =
     352        2640 :         poDriverManager->GetDriverByName(CPLSPrintf("OGR_%s", pszName));
     353        2640 :     if (poGDALDriver == nullptr)
     354        2636 :         poGDALDriver = poDriverManager->GetDriverByName(pszName);
     355        5267 :     if (poGDALDriver == nullptr ||
     356        2627 :         poGDALDriver->GetMetadataItem(GDAL_DCAP_VECTOR) == nullptr)
     357          13 :         return nullptr;
     358        2627 :     return poGDALDriver;
     359             : }
     360             : 
     361             : /************************************************************************/
     362             : /*                         OGRGetDriverByName()                         */
     363             : /************************************************************************/
     364             : 
     365        2631 : OGRSFDriverH OGRGetDriverByName(const char *pszName)
     366             : 
     367             : {
     368        2631 :     VALIDATE_POINTER1(pszName, "OGRGetDriverByName", nullptr);
     369             : 
     370             :     return reinterpret_cast<OGRSFDriverH>(
     371        2631 :         OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(pszName));
     372             : }
     373             : 
     374             : //! @endcond