/src/gdal/ogr/ogrsf_frmts/generic/ogrsfdriverregistrar.cpp

Source (jump to first uncovered line)
/******************************************************************************
 *
 * Project:  OpenGIS Simple Features Reference Implementation
 * Purpose:  The OGRSFDriverRegistrar class implementation.
 * Author:   Frank Warmerdam, warmerdam@pobox.com
 *
 ******************************************************************************
 * Copyright (c) 1999,  Les Technologies SoftMap Inc.
 * Copyright (c) 2008-2012, Even Rouault <even dot rouault at spatialys.com>
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/

#include "ogrsf_frmts.h"
#include "ogr_api.h"
#include "ograpispy.h"

/************************************************************************/
/*                         OGRSFDriverRegistrar                         */
/************************************************************************/

/**
 * \brief Constructor
 *
 * Normally the driver registrar is constructed by the
 * OGRSFDriverRegistrar::GetRegistrar() accessor which ensures singleton
 * status.
 */

OGRSFDriverRegistrar::OGRSFDriverRegistrar()
{
}

/************************************************************************/
/*                       ~OGRSFDriverRegistrar()                        */
/************************************************************************/

OGRSFDriverRegistrar::~OGRSFDriverRegistrar()
{
}

//! @cond Doxygen_Suppress
/************************************************************************/
/*                           GetRegistrar()                             */
/************************************************************************/

OGRSFDriverRegistrar *OGRSFDriverRegistrar::GetRegistrar()
{
    static OGRSFDriverRegistrar oSingleton;
    return &oSingleton;
}

/************************************************************************/
/*                           OGRCleanupAll()                            */
/************************************************************************/

/**
 * \brief Cleanup all OGR related resources.
 *
 * \see GDALDestroy()
 * \deprecated Use GDALDestroy() instead
 */
void OGRCleanupAll()

{
    GDALDestroyDriverManager();
}

/************************************************************************/
/*                              OGROpen()                               */
/************************************************************************/

OGRDataSourceH OGROpen(const char *pszName, int bUpdate,
                       OGRSFDriverH *pahDriverList)

{
    VALIDATE_POINTER1(pszName, "OGROpen", nullptr);

    GDALDatasetH hDS =
        GDALOpenEx(pszName, GDAL_OF_VECTOR | ((bUpdate) ? GDAL_OF_UPDATE : 0),
                   nullptr, nullptr, nullptr);
    if (hDS != nullptr && pahDriverList != nullptr)
        *pahDriverList =
            reinterpret_cast<OGRSFDriverH>(GDALGetDatasetDriver(hDS));

    return reinterpret_cast<OGRDataSourceH>(hDS);
}

/************************************************************************/
/*                           OGROpenShared()                            */
/************************************************************************/

OGRDataSourceH OGROpenShared(const char *pszName, int bUpdate,
                             OGRSFDriverH *pahDriverList)

{
    VALIDATE_POINTER1(pszName, "OGROpenShared", nullptr);

    GDALDatasetH hDS = GDALOpenEx(
        pszName,
        GDAL_OF_VECTOR | ((bUpdate) ? GDAL_OF_UPDATE : 0) | GDAL_OF_SHARED,
        nullptr, nullptr, nullptr);
    if (hDS != nullptr && pahDriverList != nullptr)
        *pahDriverList =
            reinterpret_cast<OGRSFDriverH>(GDALGetDatasetDriver(hDS));
    return reinterpret_cast<OGRDataSourceH>(hDS);
}

/************************************************************************/
/*                        OGRReleaseDataSource()                        */
/************************************************************************/

OGRErr OGRReleaseDataSource(OGRDataSourceH hDS)

{
    VALIDATE_POINTER1(hDS, "OGRReleaseDataSource", OGRERR_INVALID_HANDLE);

    GDALClose(reinterpret_cast<GDALDatasetH>(hDS));

    return OGRERR_NONE;
}

/************************************************************************/
/*                           GetOpenDSCount()                           */
/************************************************************************/

int OGRSFDriverRegistrar::GetOpenDSCount()
{
    CPLError(CE_Failure, CPLE_AppDefined, "Stub implementation in GDAL 2.0");
    return 0;
}

/************************************************************************/
/*                         OGRGetOpenDSCount()                          */
/************************************************************************/

int OGRGetOpenDSCount()

{
    return OGRSFDriverRegistrar::GetRegistrar()->GetOpenDSCount();
}

/************************************************************************/
/*                             GetOpenDS()                              */
/************************************************************************/

OGRDataSource *OGRSFDriverRegistrar::GetOpenDS(CPL_UNUSED int iDS)
{
    CPLError(CE_Failure, CPLE_AppDefined, "Stub implementation in GDAL 2.0");
    return nullptr;
}

/************************************************************************/
/*                            OGRGetOpenDS()                            */
/************************************************************************/

OGRDataSourceH OGRGetOpenDS(int iDS)

{
    return reinterpret_cast<OGRDataSourceH>(
        OGRSFDriverRegistrar::GetRegistrar()->GetOpenDS(iDS));
}

/************************************************************************/
/*                          OpenWithDriverArg()                         */
/************************************************************************/

GDALDataset *OGRSFDriverRegistrar::OpenWithDriverArg(GDALDriver *poDriver,
                                                     GDALOpenInfo *poOpenInfo)
{
    OGRDataSource *poDS = reinterpret_cast<OGRDataSource *>(
        reinterpret_cast<OGRSFDriver *>(poDriver)->Open(
            poOpenInfo->pszFilename, poOpenInfo->eAccess == GA_Update));
    if (poDS != nullptr)
        poDS->SetDescription(poDS->GetName());
    return poDS;
}

/************************************************************************/
/*                          CreateVectorOnly()                          */
/************************************************************************/

GDALDataset *OGRSFDriverRegistrar::CreateVectorOnly(GDALDriver *poDriver,
                                                    const char *pszName,
                                                    char **papszOptions)
{
    OGRDataSource *poDS = reinterpret_cast<OGRDataSource *>(
        reinterpret_cast<OGRSFDriver *>(poDriver)->CreateDataSource(
            pszName, papszOptions));
    if (poDS != nullptr && poDS->GetName() != nullptr)
        poDS->SetDescription(poDS->GetName());
    return poDS;
}

/************************************************************************/
/*                          DeleteDataSource()                          */
/************************************************************************/

CPLErr OGRSFDriverRegistrar::DeleteDataSource(GDALDriver *poDriver,
                                              const char *pszName)
{
    if (reinterpret_cast<OGRSFDriver *>(poDriver)->DeleteDataSource(pszName) ==
        OGRERR_NONE)
        return CE_None;
    else
        return CE_Failure;
}

/************************************************************************/
/*                           RegisterDriver()                           */
/************************************************************************/

void OGRSFDriverRegistrar::RegisterDriver(OGRSFDriver *poDriver)

{
    GDALDriver *poGDALDriver =
        GDALDriver::FromHandle(GDALGetDriverByName(poDriver->GetName()));
    if (poGDALDriver == nullptr)
    {
        poDriver->SetDescription(poDriver->GetName());
        poDriver->SetMetadataItem("OGR_DRIVER", "YES");

        if (poDriver->GetMetadataItem(GDAL_DMD_LONGNAME) == nullptr)
            poDriver->SetMetadataItem(GDAL_DMD_LONGNAME, poDriver->GetName());

        poDriver->pfnOpenWithDriverArg = OpenWithDriverArg;

        if (poDriver->TestCapability(ODrCCreateDataSource))
        {
            poDriver->SetMetadataItem(GDAL_DCAP_CREATE, "YES");
            poDriver->pfnCreateVectorOnly = CreateVectorOnly;
        }
        if (poDriver->TestCapability(ODrCDeleteDataSource))
        {
            poDriver->pfnDeleteDataSource = DeleteDataSource;
        }

        poDriver->SetMetadataItem(GDAL_DCAP_VECTOR, "YES");

        GetGDALDriverManager()->RegisterDriver(poDriver);
    }
    else
    {
        if (poGDALDriver->GetMetadataItem("OGR_DRIVER") == nullptr)
        {
            CPLError(CE_Failure, CPLE_AppDefined,
                     "A non OGR driver is registered with the same name: %s",
                     poDriver->GetName());
        }
        delete poDriver;
    }
}

/************************************************************************/
/*                         OGRRegisterDriver()                          */
/************************************************************************/

void OGRRegisterDriver(OGRSFDriverH hDriver)

{
    VALIDATE_POINTER0(hDriver, "OGRRegisterDriver");

    GetGDALDriverManager()->RegisterDriver(GDALDriver::FromHandle(hDriver));
}

/************************************************************************/
/*                        OGRDeregisterDriver()                         */
/************************************************************************/

void OGRDeregisterDriver(OGRSFDriverH hDriver)

{
    VALIDATE_POINTER0(hDriver, "OGRDeregisterDriver");

    GetGDALDriverManager()->DeregisterDriver(GDALDriver::FromHandle(hDriver));
}

/************************************************************************/
/*                           GetDriverCount()                           */
/************************************************************************/

int OGRSFDriverRegistrar::GetDriverCount()

{
    /* We must be careful only to return drivers that are actual OGRSFDriver* */
    GDALDriverManager *poDriverManager = GetGDALDriverManager();
    int nTotal = poDriverManager->GetDriverCount();
    int nOGRDriverCount = 0;
    for (int i = 0; i < nTotal; i++)
    {
        GDALDriver *poDriver = poDriverManager->GetDriver(i);
        if (poDriver->GetMetadataItem(GDAL_DCAP_VECTOR) != nullptr)
            nOGRDriverCount++;
    }
    return nOGRDriverCount;
}

/************************************************************************/
/*                         OGRGetDriverCount()                          */
/************************************************************************/

int OGRGetDriverCount()

{
    return OGRSFDriverRegistrar::GetRegistrar()->GetDriverCount();
}

/************************************************************************/
/*                             GetDriver()                              */
/************************************************************************/

GDALDriver *OGRSFDriverRegistrar::GetDriver(int iDriver)

{
    /* We must be careful only to return drivers that are actual OGRSFDriver* */
    GDALDriverManager *poDriverManager = GetGDALDriverManager();
    int nTotal = poDriverManager->GetDriverCount();
    int nOGRDriverCount = 0;
    for (int i = 0; i < nTotal; i++)
    {
        GDALDriver *poDriver = poDriverManager->GetDriver(i);
        if (poDriver->GetMetadataItem(GDAL_DCAP_VECTOR) != nullptr)
        {
            if (nOGRDriverCount == iDriver)
                return poDriver;
            nOGRDriverCount++;
        }
    }
    return nullptr;
}

/************************************************************************/
/*                            OGRGetDriver()                            */
/************************************************************************/

OGRSFDriverH OGRGetDriver(int iDriver)

{
    return reinterpret_cast<OGRSFDriverH>(
        OGRSFDriverRegistrar::GetRegistrar()->GetDriver(iDriver));
}

/************************************************************************/
/*                          GetDriverByName()                           */
/************************************************************************/

GDALDriver *OGRSFDriverRegistrar::GetDriverByName(const char *pszName)

{
    GDALDriverManager *poDriverManager = GetGDALDriverManager();
    GDALDriver *poGDALDriver =
        poDriverManager->GetDriverByName(CPLSPrintf("OGR_%s", pszName));
    if (poGDALDriver == nullptr)
        poGDALDriver = poDriverManager->GetDriverByName(pszName);
    if (poGDALDriver == nullptr ||
        poGDALDriver->GetMetadataItem(GDAL_DCAP_VECTOR) == nullptr)
        return nullptr;
    return poGDALDriver;
}

/************************************************************************/
/*                         OGRGetDriverByName()                         */
/************************************************************************/

OGRSFDriverH OGRGetDriverByName(const char *pszName)

{
    VALIDATE_POINTER1(pszName, "OGRGetDriverByName", nullptr);

    return reinterpret_cast<OGRSFDriverH>(
        OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(pszName));
}

//! @endcond

Coverage Report

Created: 2025-06-13 06:18

Line	Count	Source (jump to first uncovered line)
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		OGRSFDriverRegistrar::OGRSFDriverRegistrar()
31	0	{
32	0	}
33
34		/************************************************************************/
35		/* ~OGRSFDriverRegistrar() */
36		/************************************************************************/
37
38		OGRSFDriverRegistrar::~OGRSFDriverRegistrar()
39	0	{
40	0	}
41
42		//! @cond Doxygen_Suppress
43		/************************************************************************/
44		/* GetRegistrar() */
45		/************************************************************************/
46
47		OGRSFDriverRegistrar *OGRSFDriverRegistrar::GetRegistrar()
48	0	{
49	0	static OGRSFDriverRegistrar oSingleton;
50	0	return &oSingleton;
51	0	}
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		void OGRCleanupAll()
64
65	0	{
66	0	GDALDestroyDriverManager();
67	0	}
68
69		/************************************************************************/
70		/* OGROpen() */
71		/************************************************************************/
72
73		OGRDataSourceH OGROpen(const char *pszName, int bUpdate,
74		OGRSFDriverH *pahDriverList)
75
76	0	{
77	0	VALIDATE_POINTER1(pszName, "OGROpen", nullptr);
78
79	0	GDALDatasetH hDS =
80	0	GDALOpenEx(pszName, GDAL_OF_VECTOR \| ((bUpdate) ? GDAL_OF_UPDATE : 0),
81	0	nullptr, nullptr, nullptr);
82	0	if (hDS != nullptr && pahDriverList != nullptr)
83	0	*pahDriverList =
84	0	reinterpret_cast<OGRSFDriverH>(GDALGetDatasetDriver(hDS));
85
86	0	return reinterpret_cast<OGRDataSourceH>(hDS);
87	0	}
88
89		/************************************************************************/
90		/* OGROpenShared() */
91		/************************************************************************/
92
93		OGRDataSourceH OGROpenShared(const char *pszName, int bUpdate,
94		OGRSFDriverH *pahDriverList)
95
96	0	{
97	0	VALIDATE_POINTER1(pszName, "OGROpenShared", nullptr);
98
99	0	GDALDatasetH hDS = GDALOpenEx(
100	0	pszName,
101	0	GDAL_OF_VECTOR \| ((bUpdate) ? GDAL_OF_UPDATE : 0) \| GDAL_OF_SHARED,
102	0	nullptr, nullptr, nullptr);
103	0	if (hDS != nullptr && pahDriverList != nullptr)
104	0	*pahDriverList =
105	0	reinterpret_cast<OGRSFDriverH>(GDALGetDatasetDriver(hDS));
106	0	return reinterpret_cast<OGRDataSourceH>(hDS);
107	0	}
108
109		/************************************************************************/
110		/* OGRReleaseDataSource() */
111		/************************************************************************/
112
113		OGRErr OGRReleaseDataSource(OGRDataSourceH hDS)
114
115	0	{
116	0	VALIDATE_POINTER1(hDS, "OGRReleaseDataSource", OGRERR_INVALID_HANDLE);
117
118	0	GDALClose(reinterpret_cast<GDALDatasetH>(hDS));
119
120	0	return OGRERR_NONE;
121	0	}
122
123		/************************************************************************/
124		/* GetOpenDSCount() */
125		/************************************************************************/
126
127		int OGRSFDriverRegistrar::GetOpenDSCount()
128	0	{
129	0	CPLError(CE_Failure, CPLE_AppDefined, "Stub implementation in GDAL 2.0");
130	0	return 0;
131	0	}
132
133		/************************************************************************/
134		/* OGRGetOpenDSCount() */
135		/************************************************************************/
136
137		int OGRGetOpenDSCount()
138
139	0	{
140	0	return OGRSFDriverRegistrar::GetRegistrar()->GetOpenDSCount();
141	0	}
142
143		/************************************************************************/
144		/* GetOpenDS() */
145		/************************************************************************/
146
147		OGRDataSource *OGRSFDriverRegistrar::GetOpenDS(CPL_UNUSED int iDS)
148	0	{
149	0	CPLError(CE_Failure, CPLE_AppDefined, "Stub implementation in GDAL 2.0");
150	0	return nullptr;
151	0	}
152
153		/************************************************************************/
154		/* OGRGetOpenDS() */
155		/************************************************************************/
156
157		OGRDataSourceH OGRGetOpenDS(int iDS)
158
159	0	{
160	0	return reinterpret_cast<OGRDataSourceH>(
161	0	OGRSFDriverRegistrar::GetRegistrar()->GetOpenDS(iDS));
162	0	}
163
164		/************************************************************************/
165		/* OpenWithDriverArg() */
166		/************************************************************************/
167
168		GDALDataset OGRSFDriverRegistrar::OpenWithDriverArg(GDALDriver poDriver,
169		GDALOpenInfo *poOpenInfo)
170	0	{
171	0	OGRDataSource poDS = reinterpret_cast<OGRDataSource >(
172	0	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	0	}
178
179		/************************************************************************/
180		/* CreateVectorOnly() */
181		/************************************************************************/
182
183		GDALDataset OGRSFDriverRegistrar::CreateVectorOnly(GDALDriver poDriver,
184		const char *pszName,
185		char **papszOptions)
186	0	{
187	0	OGRDataSource poDS = reinterpret_cast<OGRDataSource >(
188	0	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	0	}
194
195		/************************************************************************/
196		/* DeleteDataSource() */
197		/************************************************************************/
198
199		CPLErr OGRSFDriverRegistrar::DeleteDataSource(GDALDriver *poDriver,
200		const char *pszName)
201	0	{
202	0	if (reinterpret_cast<OGRSFDriver *>(poDriver)->DeleteDataSource(pszName) ==
203	0	OGRERR_NONE)
204	0	return CE_None;
205	0	else
206	0	return CE_Failure;
207	0	}
208
209		/************************************************************************/
210		/* RegisterDriver() */
211		/************************************************************************/
212
213		void OGRSFDriverRegistrar::RegisterDriver(OGRSFDriver *poDriver)
214
215	0	{
216	0	GDALDriver *poGDALDriver =
217	0	GDALDriver::FromHandle(GDALGetDriverByName(poDriver->GetName()));
218	0	if (poGDALDriver == nullptr)
219	0	{
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	0	{
230	0	poDriver->SetMetadataItem(GDAL_DCAP_CREATE, "YES");
231	0	poDriver->pfnCreateVectorOnly = CreateVectorOnly;
232	0	}
233	0	if (poDriver->TestCapability(ODrCDeleteDataSource))
234	0	{
235	0	poDriver->pfnDeleteDataSource = DeleteDataSource;
236	0	}
237
238	0	poDriver->SetMetadataItem(GDAL_DCAP_VECTOR, "YES");
239
240	0	GetGDALDriverManager()->RegisterDriver(poDriver);
241	0	}
242	0	else
243	0	{
244	0	if (poGDALDriver->GetMetadataItem("OGR_DRIVER") == nullptr)
245	0	{
246	0	CPLError(CE_Failure, CPLE_AppDefined,
247	0	"A non OGR driver is registered with the same name: %s",
248	0	poDriver->GetName());
249	0	}
250	0	delete poDriver;
251	0	}
252	0	}
253
254		/************************************************************************/
255		/* OGRRegisterDriver() */
256		/************************************************************************/
257
258		void OGRRegisterDriver(OGRSFDriverH hDriver)
259
260	0	{
261	0	VALIDATE_POINTER0(hDriver, "OGRRegisterDriver");
262
263	0	GetGDALDriverManager()->RegisterDriver(GDALDriver::FromHandle(hDriver));
264	0	}
265
266		/************************************************************************/
267		/* OGRDeregisterDriver() */
268		/************************************************************************/
269
270		void OGRDeregisterDriver(OGRSFDriverH hDriver)
271
272	0	{
273	0	VALIDATE_POINTER0(hDriver, "OGRDeregisterDriver");
274
275	0	GetGDALDriverManager()->DeregisterDriver(GDALDriver::FromHandle(hDriver));
276	0	}
277
278		/************************************************************************/
279		/* GetDriverCount() */
280		/************************************************************************/
281
282		int OGRSFDriverRegistrar::GetDriverCount()
283
284	0	{
285		/* We must be careful only to return drivers that are actual OGRSFDriver* */
286	0	GDALDriverManager *poDriverManager = GetGDALDriverManager();
287	0	int nTotal = poDriverManager->GetDriverCount();
288	0	int nOGRDriverCount = 0;
289	0	for (int i = 0; i < nTotal; i++)
290	0	{
291	0	GDALDriver *poDriver = poDriverManager->GetDriver(i);
292	0	if (poDriver->GetMetadataItem(GDAL_DCAP_VECTOR) != nullptr)
293	0	nOGRDriverCount++;
294	0	}
295	0	return nOGRDriverCount;
296	0	}
297
298		/************************************************************************/
299		/* OGRGetDriverCount() */
300		/************************************************************************/
301
302		int OGRGetDriverCount()
303
304	0	{
305	0	return OGRSFDriverRegistrar::GetRegistrar()->GetDriverCount();
306	0	}
307
308		/************************************************************************/
309		/* GetDriver() */
310		/************************************************************************/
311
312		GDALDriver *OGRSFDriverRegistrar::GetDriver(int iDriver)
313
314	0	{
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	0	{
321	0	GDALDriver *poDriver = poDriverManager->GetDriver(i);
322	0	if (poDriver->GetMetadataItem(GDAL_DCAP_VECTOR) != nullptr)
323	0	{
324	0	if (nOGRDriverCount == iDriver)
325	0	return poDriver;
326	0	nOGRDriverCount++;
327	0	}
328	0	}
329	0	return nullptr;
330	0	}
331
332		/************************************************************************/
333		/* OGRGetDriver() */
334		/************************************************************************/
335
336		OGRSFDriverH OGRGetDriver(int iDriver)
337
338	0	{
339	0	return reinterpret_cast<OGRSFDriverH>(
340	0	OGRSFDriverRegistrar::GetRegistrar()->GetDriver(iDriver));
341	0	}
342
343		/************************************************************************/
344		/* GetDriverByName() */
345		/************************************************************************/
346
347		GDALDriver OGRSFDriverRegistrar::GetDriverByName(const char pszName)
348
349	0	{
350	0	GDALDriverManager *poDriverManager = GetGDALDriverManager();
351	0	GDALDriver *poGDALDriver =
352	0	poDriverManager->GetDriverByName(CPLSPrintf("OGR_%s", pszName));
353	0	if (poGDALDriver == nullptr)
354	0	poGDALDriver = poDriverManager->GetDriverByName(pszName);
355	0	if (poGDALDriver == nullptr \|\|
356	0	poGDALDriver->GetMetadataItem(GDAL_DCAP_VECTOR) == nullptr)
357	0	return nullptr;
358	0	return poGDALDriver;
359	0	}
360
361		/************************************************************************/
362		/* OGRGetDriverByName() */
363		/************************************************************************/
364
365		OGRSFDriverH OGRGetDriverByName(const char *pszName)
366
367	0	{
368	0	VALIDATE_POINTER1(pszName, "OGRGetDriverByName", nullptr);
369
370	0	return reinterpret_cast<OGRSFDriverH>(
371	0	OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(pszName));
372	0	}
373
374		//! @endcond