15985453442

Committed 30 Jun 2025 11:00PM UTC coverage: 71.093% (+0.004%) from 71.089%

Build # 15985453442

Build Type

Pull #12680

github

Committed by

web-flow

Commit Message

Merge 346c552a0 into 3996c9be8

Pull Request Pull Request #12680: Arrow/Parquet: handle list of binary and binary as JSON content (struct/list_of_list/array_of binary)

Run Details

68 of 89 new or added lines in 1 file covered. (76.4%)

37 existing lines in 20 files now uncovered.

574098 of 807529 relevant lines covered (71.09%)

250439.8 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

34.59

/frmts/null/nulldataset.cpp

/******************************************************************************
 *
 * Project:  GDAL
 * Purpose:  NULL driver.
 * Author:   Even Rouault, <even dot rouault at spatialys dot org>
 *
 ******************************************************************************
 * Copyright (c) 2012-2017, Even Rouault, <even dot rouault at spatialys dot
 *org>
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/

#include "gdal_priv.h"
#include "ogrsf_frmts.h"

extern "C" void GDALRegister_NULL();

/************************************************************************/
/*                          GDALNullDataset                             */
/************************************************************************/

class GDALNullDataset final : public GDALDataset
{
    int m_nLayers;
    OGRLayer **m_papoLayers;

    CPL_DISALLOW_COPY_ASSIGN(GDALNullDataset)

  public:
    GDALNullDataset();
    virtual ~GDALNullDataset();

    virtual int GetLayerCount() override
    {
        return m_nLayers;
    }

    virtual OGRLayer *GetLayer(int) override;

    OGRLayer *ICreateLayer(const char *pszName,
                           const OGRGeomFieldDefn *poGeomFieldDefn,
                           CSLConstList papszOptions) override;

    virtual int TestCapability(const char *) override;

    CPLErr SetSpatialRef(const OGRSpatialReference *poSRS) override;

    virtual CPLErr SetGeoTransform(const GDALGeoTransform &gt) override;

    static GDALDataset *Open(GDALOpenInfo *poOpenInfo);
    static GDALDataset *Create(const char *pszFilename, int nXSize, int nYSize,
                               int nBands, GDALDataType eType,
                               char **papszOptions);
};

/************************************************************************/
/*                           GDALNullLayer                              */
/************************************************************************/

class GDALNullRasterBand final : public GDALRasterBand
{
  public:
    explicit GDALNullRasterBand(GDALDataType eDT);

    virtual CPLErr IReadBlock(int, int, void *) override;
    virtual CPLErr IWriteBlock(int, int, void *) override;
    virtual CPLErr IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
                             int nXSize, int nYSize, void *pData, int nBufXSize,
                             int nBufYSize, GDALDataType eBufType,
                             GSpacing nPixelSpace, GSpacing nLineSpace,
                             GDALRasterIOExtraArg *psExtraArg) override;
};

/************************************************************************/
/*                           GDALNullLayer                              */
/************************************************************************/

class GDALNullLayer final : public OGRLayer
{
    OGRFeatureDefn *poFeatureDefn;
    OGRSpatialReference *poSRS = nullptr;

    CPL_DISALLOW_COPY_ASSIGN(GDALNullLayer)

  public:
    GDALNullLayer(const char *pszLayerName, const OGRSpatialReference *poSRS,
                  OGRwkbGeometryType eType);
    virtual ~GDALNullLayer();

    virtual OGRFeatureDefn *GetLayerDefn() override
    {
        return poFeatureDefn;
    }

    virtual OGRSpatialReference *GetSpatialRef() override
    {
        return poSRS;
    }

    virtual void ResetReading() override
    {
    }

    virtual int TestCapability(const char *) override;

    virtual OGRFeature *GetNextFeature() override
    {
        return nullptr;
    }

    virtual OGRErr ICreateFeature(OGRFeature *) override
    {
        return OGRERR_NONE;
    }

    virtual OGRErr CreateField(const OGRFieldDefn *poField,
                               int bApproxOK = TRUE) override;
};

/************************************************************************/
/*                           GDALNullRasterBand()                       */
/************************************************************************/

GDALNullRasterBand::GDALNullRasterBand(GDALDataType eDT)
{
    eDataType = eDT;
    nBlockXSize = 256;
    nBlockYSize = 256;
}

/************************************************************************/
/*                             IRasterIO()                              */
/************************************************************************/

CPLErr GDALNullRasterBand::IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
                                     int nXSize, int nYSize, void *pData,
                                     int nBufXSize, int nBufYSize,
                                     GDALDataType eBufType,
                                     GSpacing nPixelSpace, GSpacing nLineSpace,
                                     GDALRasterIOExtraArg *psExtraArg)
{
    if (eRWFlag == GF_Write)
        return CE_None;
    if (psExtraArg->eResampleAlg != GRIORA_NearestNeighbour &&
        (nBufXSize != nXSize || nBufYSize != nYSize))
    {
        return GDALRasterBand::IRasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize,
                                         pData, nBufXSize, nBufYSize, eBufType,
                                         nPixelSpace, nLineSpace, psExtraArg);
    }
    if (nPixelSpace == GDALGetDataTypeSizeBytes(eBufType) &&
        nLineSpace == nPixelSpace * nBufXSize)
    {
        memset(pData, 0, static_cast<size_t>(nLineSpace) * nBufYSize);
    }
    else
    {
        for (int iY = 0; iY < nBufYSize; iY++)
        {
            double dfZero = 0;
            GDALCopyWords(&dfZero, GDT_Float64, 0,
                          reinterpret_cast<GByte *>(pData) + iY * nLineSpace,
                          eBufType, static_cast<int>(nPixelSpace), nBufXSize);
        }
    }
    return CE_None;
}

/************************************************************************/
/*                             IReadBlock()                             */
/************************************************************************/

CPLErr GDALNullRasterBand::IReadBlock(int, int, void *pData)
{
    memset(pData, 0,
           static_cast<size_t>(nBlockXSize) * nBlockYSize *
               GDALGetDataTypeSizeBytes(eDataType));
    return CE_None;
}

/************************************************************************/
/*                             IWriteBlock()                            */
/************************************************************************/

CPLErr GDALNullRasterBand::IWriteBlock(int, int, void *)
{
    return CE_None;
}

/************************************************************************/
/*                          GDALNullDataset()                           */
/************************************************************************/

GDALNullDataset::GDALNullDataset() : m_nLayers(0), m_papoLayers(nullptr)
{
    eAccess = GA_Update;
}

/************************************************************************/
/*                         ~GDALNullDataset()                           */
/************************************************************************/

GDALNullDataset::~GDALNullDataset()
{
    for (int i = 0; i < m_nLayers; i++)
        delete m_papoLayers[i];
    CPLFree(m_papoLayers);
}

/************************************************************************/
/*                           ICreateLayer()                             */
/************************************************************************/

OGRLayer *GDALNullDataset::ICreateLayer(const char *pszLayerName,
                                        const OGRGeomFieldDefn *poGeomFieldDefn,
                                        CSLConstList /*papszOptions */)
{
    const auto eType = poGeomFieldDefn ? poGeomFieldDefn->GetType() : wkbNone;
    const auto poSRS =
        poGeomFieldDefn ? poGeomFieldDefn->GetSpatialRef() : nullptr;

    m_papoLayers = static_cast<OGRLayer **>(
        CPLRealloc(m_papoLayers, sizeof(OGRLayer *) * (m_nLayers + 1)));
    m_papoLayers[m_nLayers] = new GDALNullLayer(pszLayerName, poSRS, eType);
    m_nLayers++;
    return m_papoLayers[m_nLayers - 1];
}

/************************************************************************/
/*                           TestCapability()                           */
/************************************************************************/

int GDALNullDataset::TestCapability(const char *pszCap)

{
    if (EQUAL(pszCap, ODsCCreateLayer))
        return TRUE;
    if (EQUAL(pszCap, ODsCRandomLayerWrite))
        return TRUE;
    return FALSE;
}

/************************************************************************/
/*                              GetLayer()                              */
/************************************************************************/

OGRLayer *GDALNullDataset::GetLayer(int iLayer)

{
    if (iLayer < 0 || iLayer >= m_nLayers)
        return nullptr;
    else
        return m_papoLayers[iLayer];
}

/************************************************************************/
/*                           SetSpatialRef()                            */
/************************************************************************/

CPLErr GDALNullDataset::SetSpatialRef(const OGRSpatialReference *)

{
    return CE_None;
}

/************************************************************************/
/*                          SetGeoTransform()                           */
/************************************************************************/

CPLErr GDALNullDataset::SetGeoTransform(const GDALGeoTransform &)

{
    return CE_None;
}

/************************************************************************/
/*                               Open()                                 */
/************************************************************************/

GDALDataset *GDALNullDataset::Open(GDALOpenInfo *poOpenInfo)
{
    if (!STARTS_WITH_CI(poOpenInfo->pszFilename, "NULL:"))
        return nullptr;

    const char *pszStr = poOpenInfo->pszFilename + strlen("NULL:");
    char **papszTokens = CSLTokenizeString2(pszStr, ",", 0);
    int nXSize = atoi(CSLFetchNameValueDef(papszTokens, "width", "512"));
    int nYSize = atoi(CSLFetchNameValueDef(papszTokens, "height", "512"));
    int nBands = atoi(CSLFetchNameValueDef(papszTokens, "bands", "1"));
    const char *pszDTName = CSLFetchNameValueDef(papszTokens, "type", "Byte");
    GDALDataType eDT = GDT_Byte;
    for (int iType = 1; iType < GDT_TypeCount; iType++)
    {
        if (GDALGetDataTypeName(static_cast<GDALDataType>(iType)) != nullptr &&
            EQUAL(GDALGetDataTypeName(static_cast<GDALDataType>(iType)),
                  pszDTName))
        {
            eDT = static_cast<GDALDataType>(iType);
            break;
        }
    }
    CSLDestroy(papszTokens);

    return Create("", nXSize, nYSize, nBands, eDT, nullptr);
}

/************************************************************************/
/*                              Create()                                */
/************************************************************************/

GDALDataset *GDALNullDataset::Create(const char *, int nXSize, int nYSize,
                                     int nBandsIn, GDALDataType eType, char **)
{
    GDALNullDataset *poDS = new GDALNullDataset();
    poDS->nRasterXSize = nXSize;
    poDS->nRasterYSize = nYSize;
    for (int i = 0; i < nBandsIn; i++)
        poDS->SetBand(i + 1, new GDALNullRasterBand(eType));
    return poDS;
}

/************************************************************************/
/*                           GDALNullLayer()                            */
/************************************************************************/

GDALNullLayer::GDALNullLayer(const char *pszLayerName,
                             const OGRSpatialReference *poSRSIn,
                             OGRwkbGeometryType eType)
    : poFeatureDefn(new OGRFeatureDefn(pszLayerName))
{
    SetDescription(poFeatureDefn->GetName());
    poFeatureDefn->SetGeomType(eType);
    poFeatureDefn->Reference();

    if (poSRSIn)
        poSRS = poSRSIn->Clone();
}

/************************************************************************/
/*                           ~GDALNullLayer()                           */
/************************************************************************/

GDALNullLayer::~GDALNullLayer()
{
    poFeatureDefn->Release();

    if (poSRS)
        poSRS->Release();
}

/************************************************************************/
/*                           TestCapability()                           */
/************************************************************************/

int GDALNullLayer::TestCapability(const char *pszCap)

{
    if (EQUAL(pszCap, OLCSequentialWrite))
        return TRUE;
    if (EQUAL(pszCap, OLCCreateField))
        return TRUE;
    return FALSE;
}

/************************************************************************/
/*                             CreateField()                            */
/************************************************************************/

OGRErr GDALNullLayer::CreateField(const OGRFieldDefn *poField, int)
{
    poFeatureDefn->AddFieldDefn(poField);
    return OGRERR_NONE;
}

/************************************************************************/
/*                        GDALRegister_NULL()                           */
/************************************************************************/

void GDALRegister_NULL()

{
    if (GDALGetDriverByName("NULL") != nullptr)
        return;

    GDALDriver *poDriver;
    poDriver = new GDALDriver();

    poDriver->SetDescription("NULL");
    poDriver->SetMetadataItem(GDAL_DMD_CONNECTION_PREFIX, "NULL: ");
    poDriver->SetMetadataItem(GDAL_DCAP_RASTER, "YES");
    poDriver->SetMetadataItem(GDAL_DCAP_VECTOR, "YES");
    poDriver->SetMetadataItem(GDAL_DCAP_CREATE_LAYER, "YES");
    poDriver->SetMetadataItem(GDAL_DCAP_CREATE_FIELD, "YES");
    poDriver->SetMetadataItem(GDAL_DMD_LONGNAME, "NULL");

    poDriver->SetMetadataItem(GDAL_DMD_CREATIONFIELDDATATYPES,
                              "Integer Integer64 Real String Date DateTime "
                              "Binary IntegerList Integer64List "
                              "RealList StringList");

    poDriver->SetMetadataItem(GDAL_DMD_SUPPORTED_SQL_DIALECTS, "OGRSQL SQLITE");

    poDriver->pfnOpen = GDALNullDataset::Open;
    poDriver->pfnCreate = GDALNullDataset::Create;

    GetGDALDriverManager()->RegisterDriver(poDriver);
}

1	/******************************************************************************
2	*
3	* Project: GDAL
4	* Purpose: NULL driver.
5	* Author: Even Rouault, <even dot rouault at spatialys dot org>
6	*
7	******************************************************************************
8	* Copyright (c) 2012-2017, Even Rouault, <even dot rouault at spatialys dot
9	*org>
10	*
11	* SPDX-License-Identifier: MIT
12	****************************************************************************/
13
14	#include "gdal_priv.h"
15	#include "ogrsf_frmts.h"
16
17	extern "C" void GDALRegister_NULL();
18
19	/************************************************************************/
20	/* GDALNullDataset */
21	/************************************************************************/
22
23	class GDALNullDataset final : public GDALDataset
24	{
25	int m_nLayers;
26	OGRLayer **m_papoLayers;
27
28	CPL_DISALLOW_COPY_ASSIGN(GDALNullDataset)
29
30	public:
31	GDALNullDataset();
32	virtual ~GDALNullDataset();
33
34	virtual int GetLayerCount() override	×
35	{
36	return m_nLayers;	×
37	}
38
39	virtual OGRLayer *GetLayer(int) override;
40
41	OGRLayer ICreateLayer(const char pszName,
42	const OGRGeomFieldDefn *poGeomFieldDefn,
43	CSLConstList papszOptions) override;
44
45	virtual int TestCapability(const char *) override;
46
47	CPLErr SetSpatialRef(const OGRSpatialReference *poSRS) override;
48
49	virtual CPLErr SetGeoTransform(const GDALGeoTransform &gt) override;
50
51	static GDALDataset Open(GDALOpenInfo poOpenInfo);
52	static GDALDataset Create(const char pszFilename, int nXSize, int nYSize,
53	int nBands, GDALDataType eType,
54	char **papszOptions);
55	};
56
57	/************************************************************************/
58	/* GDALNullLayer */
59	/************************************************************************/
60
61	class GDALNullRasterBand final : public GDALRasterBand
62	{
63	public:
64	explicit GDALNullRasterBand(GDALDataType eDT);
65
66	virtual CPLErr IReadBlock(int, int, void *) override;
67	virtual CPLErr IWriteBlock(int, int, void *) override;
68	virtual CPLErr IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
69	int nXSize, int nYSize, void *pData, int nBufXSize,
70	int nBufYSize, GDALDataType eBufType,
71	GSpacing nPixelSpace, GSpacing nLineSpace,
72	GDALRasterIOExtraArg *psExtraArg) override;
73	};
74
75	/************************************************************************/
76	/* GDALNullLayer */
77	/************************************************************************/
78
79	class GDALNullLayer final : public OGRLayer
80	{
81	OGRFeatureDefn *poFeatureDefn;
82	OGRSpatialReference *poSRS = nullptr;
83
84	CPL_DISALLOW_COPY_ASSIGN(GDALNullLayer)
85
86	public:
87	GDALNullLayer(const char pszLayerName, const OGRSpatialReference poSRS,
88	OGRwkbGeometryType eType);
89	virtual ~GDALNullLayer();
90
91	virtual OGRFeatureDefn *GetLayerDefn() override	×
92	{
93	return poFeatureDefn;	×
94	}
95
96	virtual OGRSpatialReference *GetSpatialRef() override	×
97	{
98	return poSRS;	×
99	}
100
101	virtual void ResetReading() override	×
102	{
103	}	×
104
105	virtual int TestCapability(const char *) override;
106
107	virtual OGRFeature *GetNextFeature() override	×
108	{
109	return nullptr;	×
110	}
111
112	virtual OGRErr ICreateFeature(OGRFeature *) override	×
113	{
114	return OGRERR_NONE;	×
115	}
116
117	virtual OGRErr CreateField(const OGRFieldDefn *poField,
118	int bApproxOK = TRUE) override;
119	};
120
121	/************************************************************************/
122	/* GDALNullRasterBand() */
123	/************************************************************************/
124
125	GDALNullRasterBand::GDALNullRasterBand(GDALDataType eDT)	94✔
126	{
127	eDataType = eDT;	94✔
128	nBlockXSize = 256;	94✔
129	nBlockYSize = 256;	94✔
130	}	94✔
131
132	/************************************************************************/
133	/* IRasterIO() */
134	/************************************************************************/
135
136	CPLErr GDALNullRasterBand::IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,	25✔
137	int nXSize, int nYSize, void *pData,
138	int nBufXSize, int nBufYSize,
139	GDALDataType eBufType,
140	GSpacing nPixelSpace, GSpacing nLineSpace,
141	GDALRasterIOExtraArg *psExtraArg)
142	{
143	if (eRWFlag == GF_Write)	25✔
144	return CE_None;	25✔
145	if (psExtraArg->eResampleAlg != GRIORA_NearestNeighbour &&	×
146	(nBufXSize != nXSize \|\| nBufYSize != nYSize))	×
147	{
148	return GDALRasterBand::IRasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize,	×
149	pData, nBufXSize, nBufYSize, eBufType,
150	nPixelSpace, nLineSpace, psExtraArg);	×
151	}
152	if (nPixelSpace == GDALGetDataTypeSizeBytes(eBufType) &&	×
153	nLineSpace == nPixelSpace * nBufXSize)	×
154	{
155	memset(pData, 0, static_cast<size_t>(nLineSpace) * nBufYSize);	×
156	}
157	else
158	{
159	for (int iY = 0; iY < nBufYSize; iY++)	×
160	{
161	double dfZero = 0;	×
162	GDALCopyWords(&dfZero, GDT_Float64, 0,	×
163	reinterpret_cast<GByte >(pData) + iY nLineSpace,	×
164	eBufType, static_cast<int>(nPixelSpace), nBufXSize);
165	}
166	}
167	return CE_None;	×
168	}
169
170	/************************************************************************/
171	/* IReadBlock() */
172	/************************************************************************/
173
174	CPLErr GDALNullRasterBand::IReadBlock(int, int, void *pData)	×
175	{
176	memset(pData, 0,	×
177	static_cast<size_t>(nBlockXSize) * nBlockYSize *	×
178	GDALGetDataTypeSizeBytes(eDataType));	×
179	return CE_None;	×
180	}
181
182	/************************************************************************/
183	/* IWriteBlock() */
184	/************************************************************************/
185
186	CPLErr GDALNullRasterBand::IWriteBlock(int, int, void *)	×
187	{
188	return CE_None;	×
189	}
190
191	/************************************************************************/
192	/* GDALNullDataset() */
193	/************************************************************************/
194
195	GDALNullDataset::GDALNullDataset() : m_nLayers(0), m_papoLayers(nullptr)	50✔
196	{
197	eAccess = GA_Update;	50✔
198	}	50✔
199
200	/************************************************************************/
201	/* ~GDALNullDataset() */
202	/************************************************************************/
203
204	GDALNullDataset::~GDALNullDataset()	100✔
205	{
206	for (int i = 0; i < m_nLayers; i++)	50✔
207	delete m_papoLayers[i];	×
208	CPLFree(m_papoLayers);	50✔
209	}	100✔
210
211	/************************************************************************/
212	/* ICreateLayer() */
213	/************************************************************************/
214
215	OGRLayer GDALNullDataset::ICreateLayer(const char pszLayerName,	×
216	const OGRGeomFieldDefn *poGeomFieldDefn,
217	CSLConstList /papszOptions /)
218	{
219	const auto eType = poGeomFieldDefn ? poGeomFieldDefn->GetType() : wkbNone;	×
220	const auto poSRS =
221	poGeomFieldDefn ? poGeomFieldDefn->GetSpatialRef() : nullptr;	×
222
223	m_papoLayers = static_cast<OGRLayer **>(	×
224	CPLRealloc(m_papoLayers, sizeof(OGRLayer ) (m_nLayers + 1)));	×
225	m_papoLayers[m_nLayers] = new GDALNullLayer(pszLayerName, poSRS, eType);	×
226	m_nLayers++;	×
227	return m_papoLayers[m_nLayers - 1];	×
228	}
229
230	/************************************************************************/
231	/* TestCapability() */
232	/************************************************************************/
233
234	int GDALNullDataset::TestCapability(const char *pszCap)	×
235
236	{
237	if (EQUAL(pszCap, ODsCCreateLayer))	×
238	return TRUE;	×
239	if (EQUAL(pszCap, ODsCRandomLayerWrite))	×
240	return TRUE;	×
241	return FALSE;	×
242	}
243
244	/************************************************************************/
245	/* GetLayer() */
246	/************************************************************************/
247
248	OGRLayer *GDALNullDataset::GetLayer(int iLayer)	×
249
250	{
251	if (iLayer < 0 \|\| iLayer >= m_nLayers)	×
252	return nullptr;	×
253	else
254	return m_papoLayers[iLayer];	×
255	}
256
257	/************************************************************************/
258	/* SetSpatialRef() */
259	/************************************************************************/
260
261	CPLErr GDALNullDataset::SetSpatialRef(const OGRSpatialReference *)	50✔
262
263	{
264	return CE_None;	50✔
265	}
266
267	/************************************************************************/
268	/* SetGeoTransform() */
269	/************************************************************************/
270
271	CPLErr GDALNullDataset::SetGeoTransform(const GDALGeoTransform &)	50✔
272
273	{
274	return CE_None;	50✔
275	}
276
277	/************************************************************************/
278	/* Open() */
279	/************************************************************************/
280
281	GDALDataset GDALNullDataset::Open(GDALOpenInfo poOpenInfo)	42,639✔
282	{
283	if (!STARTS_WITH_CI(poOpenInfo->pszFilename, "NULL:"))	42,639✔
284	return nullptr;	42,640✔
285
UNCOV 286	const char *pszStr = poOpenInfo->pszFilename + strlen("NULL:");	×
UNCOV 287	char **papszTokens = CSLTokenizeString2(pszStr, ",", 0);	×
288	int nXSize = atoi(CSLFetchNameValueDef(papszTokens, "width", "512"));	×
289	int nYSize = atoi(CSLFetchNameValueDef(papszTokens, "height", "512"));	×
290	int nBands = atoi(CSLFetchNameValueDef(papszTokens, "bands", "1"));	×
291	const char *pszDTName = CSLFetchNameValueDef(papszTokens, "type", "Byte");	×
292	GDALDataType eDT = GDT_Byte;	×
293	for (int iType = 1; iType < GDT_TypeCount; iType++)	×
294	{
295	if (GDALGetDataTypeName(static_cast<GDALDataType>(iType)) != nullptr &&	×
296	EQUAL(GDALGetDataTypeName(static_cast<GDALDataType>(iType)),	×
297	pszDTName))
298	{
299	eDT = static_cast<GDALDataType>(iType);	×
300	break;	×
301	}
302	}
303	CSLDestroy(papszTokens);	×
304
305	return Create("", nXSize, nYSize, nBands, eDT, nullptr);	×
306	}
307
308	/************************************************************************/
309	/* Create() */
310	/************************************************************************/
311
312	GDALDataset GDALNullDataset::Create(const char , int nXSize, int nYSize,	50✔
313	int nBandsIn, GDALDataType eType, char **)
314	{
315	GDALNullDataset *poDS = new GDALNullDataset();	50✔
316	poDS->nRasterXSize = nXSize;	50✔
317	poDS->nRasterYSize = nYSize;	50✔
318	for (int i = 0; i < nBandsIn; i++)	144✔
319	poDS->SetBand(i + 1, new GDALNullRasterBand(eType));	94✔
320	return poDS;	50✔
321	}
322
323	/************************************************************************/
324	/* GDALNullLayer() */
325	/************************************************************************/
326
327	GDALNullLayer::GDALNullLayer(const char *pszLayerName,	×
328	const OGRSpatialReference *poSRSIn,
329	OGRwkbGeometryType eType)	×
330	: poFeatureDefn(new OGRFeatureDefn(pszLayerName))	×
331	{
332	SetDescription(poFeatureDefn->GetName());	×
333	poFeatureDefn->SetGeomType(eType);	×
334	poFeatureDefn->Reference();	×
335
336	if (poSRSIn)	×
337	poSRS = poSRSIn->Clone();	×
338	}	×
339
340	/************************************************************************/
341	/* ~GDALNullLayer() */
342	/************************************************************************/
343
344	GDALNullLayer::~GDALNullLayer()	×
345	{
346	poFeatureDefn->Release();	×
347
348	if (poSRS)	×
349	poSRS->Release();	×
350	}	×
351
352	/************************************************************************/
353	/* TestCapability() */
354	/************************************************************************/
355
356	int GDALNullLayer::TestCapability(const char *pszCap)	×
357
358	{
359	if (EQUAL(pszCap, OLCSequentialWrite))	×
360	return TRUE;	×
361	if (EQUAL(pszCap, OLCCreateField))	×
362	return TRUE;	×
363	return FALSE;	×
364	}
365
366	/************************************************************************/
367	/* CreateField() */
368	/************************************************************************/
369
370	OGRErr GDALNullLayer::CreateField(const OGRFieldDefn *poField, int)	×
371	{
372	poFeatureDefn->AddFieldDefn(poField);	×
373	return OGRERR_NONE;	×
374	}
375
376	/************************************************************************/
377	/* GDALRegister_NULL() */
378	/************************************************************************/
379
380	void GDALRegister_NULL()	1,911✔
381
382	{
383	if (GDALGetDriverByName("NULL") != nullptr)	1,911✔
384	return;	282✔
385
386	GDALDriver *poDriver;
387	poDriver = new GDALDriver();	1,629✔
388
389	poDriver->SetDescription("NULL");	1,629✔
390	poDriver->SetMetadataItem(GDAL_DMD_CONNECTION_PREFIX, "NULL: ");	1,629✔
391	poDriver->SetMetadataItem(GDAL_DCAP_RASTER, "YES");	1,629✔
392	poDriver->SetMetadataItem(GDAL_DCAP_VECTOR, "YES");	1,629✔
393	poDriver->SetMetadataItem(GDAL_DCAP_CREATE_LAYER, "YES");	1,629✔
394	poDriver->SetMetadataItem(GDAL_DCAP_CREATE_FIELD, "YES");	1,629✔
395	poDriver->SetMetadataItem(GDAL_DMD_LONGNAME, "NULL");	1,629✔
396
397	poDriver->SetMetadataItem(GDAL_DMD_CREATIONFIELDDATATYPES,	1,629✔
398	"Integer Integer64 Real String Date DateTime "
399	"Binary IntegerList Integer64List "
400	"RealList StringList");	1,629✔
401
402	poDriver->SetMetadataItem(GDAL_DMD_SUPPORTED_SQL_DIALECTS, "OGRSQL SQLITE");	1,629✔
403
404	poDriver->pfnOpen = GDALNullDataset::Open;	1,629✔
405	poDriver->pfnCreate = GDALNullDataset::Create;	1,629✔
406
407	GetGDALDriverManager()->RegisterDriver(poDriver);	1,629✔
408	}

OSGeo / gdal / 15985453442

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous