/src/gdal/ogr/ogrsf_frmts/gmlas/ogrgmlasfeatureclass.cpp

Source
/******************************************************************************
 * Project:  OGR
 * Purpose:  OGRGMLASDriver implementation
 * Author:   Even Rouault, <even dot rouault at spatialys dot com>
 *
 * Initial development funded by the European Earth observation programme
 * Copernicus
 *
 ******************************************************************************
 * Copyright (c) 2016, Even Rouault, <even dot rouault at spatialys dot com>
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/

#include "ogr_gmlas.h"

/************************************************************************/
/*                             GetTypeFromString()                      */
/************************************************************************/

GMLASFieldType GMLASField::GetTypeFromString(const CPLString &osType)
{
    if (osType == szXS_STRING || osType == szXS_TOKEN ||
        osType == szXS_NMTOKEN || osType == szXS_NCNAME ||
        osType == szXS_QNAME || osType == szXS_IDREF)
    {
        // token has special processing by XML processor: all leading/trailing
        // white space is removed
        return GMLAS_FT_STRING;
    }
    else if (osType == szXS_ID)
        return GMLAS_FT_ID;
    else if (osType == szXS_BOOLEAN)
        return GMLAS_FT_BOOLEAN;
    else if (osType == szXS_SHORT)
        return GMLAS_FT_SHORT;
    else if (osType == szXS_INT)
        return GMLAS_FT_INT32;
    else if (osType == szXS_BYTE || osType == szXS_INTEGER ||
             osType == szXS_NEGATIVE_INTEGER ||
             osType == szXS_NON_NEGATIVE_INTEGER ||
             osType == szXS_NON_POSITIVE_INTEGER ||
             osType == szXS_POSITIVE_INTEGER || osType == szXS_UNSIGNED_BYTE ||
             osType == szXS_UNSIGNED_SHORT ||
             osType == szXS_UNSIGNED_INT)  // FIXME ?
        return GMLAS_FT_INT32;
    else if (osType == szXS_LONG || osType == szXS_UNSIGNED_LONG)
        return GMLAS_FT_INT64;
    else if (osType == szXS_FLOAT)
        return GMLAS_FT_FLOAT;
    else if (osType == szXS_DOUBLE)
        return GMLAS_FT_DOUBLE;
    else if (osType == szXS_DECIMAL)
        return GMLAS_FT_DECIMAL;
    else if (osType == szXS_DATE)
        return GMLAS_FT_DATE;
    else if (osType == szXS_GYEAR)
        return GMLAS_FT_GYEAR;
    else if (osType == szXS_GYEAR_MONTH)
        return GMLAS_FT_GYEAR_MONTH;
    else if (osType == szXS_TIME)
        return GMLAS_FT_TIME;
    else if (osType == szXS_DATETIME)
        return GMLAS_FT_DATETIME;
    else if (osType == szXS_ANY_URI)
        return GMLAS_FT_ANYURI;
    else if (osType == szXS_ANY_TYPE)
        return GMLAS_FT_ANYTYPE;
    else if (osType == szXS_ANY_SIMPLE_TYPE)
        return GMLAS_FT_ANYSIMPLETYPE;
    else if (osType == szXS_DURATION)
        return GMLAS_FT_STRING;
    else if (osType == szXS_BASE64BINARY)
        return GMLAS_FT_BASE64BINARY;
    else if (osType == szXS_HEXBINARY)
        return GMLAS_FT_HEXBINARY;
    else
    {
        CPLError(CE_Warning, CPLE_AppDefined, "Unhandled type: %s",
                 osType.c_str());
        return GMLAS_FT_STRING;
    }
}

/************************************************************************/
/*                               SetType()                              */
/************************************************************************/

void GMLASField::SetType(GMLASFieldType eType, const char *pszTypeName)
{
    m_eType = eType;
    m_osTypeName = pszTypeName;
}

/************************************************************************/
/*                                 SetName()                            */
/************************************************************************/

void GMLASFeatureClass::SetName(const CPLString &osName)
{
    m_osName = osName;
}

/************************************************************************/
/*                                SetXPath()                            */
/************************************************************************/

void GMLASFeatureClass::SetXPath(const CPLString &osXPath)
{
    m_osXPath = osXPath;
}

/************************************************************************/
/*                                AddField()                            */
/************************************************************************/

void GMLASFeatureClass::AddField(const GMLASField &oField)
{
    m_aoFields.push_back(oField);
}

/************************************************************************/
/*                            PrependFields()                           */
/************************************************************************/

void GMLASFeatureClass::PrependFields(const std::vector<GMLASField> &aoFields)
{
    m_aoFields.insert(m_aoFields.begin(), aoFields.begin(), aoFields.end());
}

/************************************************************************/
/*                             AppendFields()                           */
/************************************************************************/

void GMLASFeatureClass::AppendFields(const std::vector<GMLASField> &aoFields)
{
    m_aoFields.insert(m_aoFields.end(), aoFields.begin(), aoFields.end());
}

/************************************************************************/
/*                             AddNestedClass()                         */
/************************************************************************/

void GMLASFeatureClass::AddNestedClass(const GMLASFeatureClass &oNestedClass)
{
    m_aoNestedClasses.push_back(oNestedClass);
}

Line	Count	Source
1		/******************************************************************************
2		* Project: OGR
3		* Purpose: OGRGMLASDriver implementation
4		* Author: Even Rouault, <even dot rouault at spatialys dot com>
5		*
6		* Initial development funded by the European Earth observation programme
7		* Copernicus
8		*
9		******************************************************************************
10		* Copyright (c) 2016, Even Rouault, <even dot rouault at spatialys dot com>
11		*
12		* SPDX-License-Identifier: MIT
13		****************************************************************************/
14
15		#include "ogr_gmlas.h"
16
17		/************************************************************************/
18		/* GetTypeFromString() */
19		/************************************************************************/
20
21		GMLASFieldType GMLASField::GetTypeFromString(const CPLString &osType)
22	59.4k	{
23	59.4k	if (osType == szXS_STRING \|\| osType == szXS_TOKEN \|\|
24	41.0k	osType == szXS_NMTOKEN \|\| osType == szXS_NCNAME \|\|
25	41.0k	osType == szXS_QNAME \|\| osType == szXS_IDREF)
26	18.4k	{
27		// token has special processing by XML processor: all leading/trailing
28		// white space is removed
29	18.4k	return GMLAS_FT_STRING;
30	18.4k	}
31	41.0k	else if (osType == szXS_ID)
32	39.2k	return GMLAS_FT_ID;
33	1.76k	else if (osType == szXS_BOOLEAN)
34	0	return GMLAS_FT_BOOLEAN;
35	1.76k	else if (osType == szXS_SHORT)
36	0	return GMLAS_FT_SHORT;
37	1.76k	else if (osType == szXS_INT)
38	0	return GMLAS_FT_INT32;
39	1.76k	else if (osType == szXS_BYTE \|\| osType == szXS_INTEGER \|\|
40	1.76k	osType == szXS_NEGATIVE_INTEGER \|\|
41	1.76k	osType == szXS_NON_NEGATIVE_INTEGER \|\|
42	1.76k	osType == szXS_NON_POSITIVE_INTEGER \|\|
43	1.76k	osType == szXS_POSITIVE_INTEGER \|\| osType == szXS_UNSIGNED_BYTE \|\|
44	1.76k	osType == szXS_UNSIGNED_SHORT \|\|
45	1.76k	osType == szXS_UNSIGNED_INT) // FIXME ?
46	0	return GMLAS_FT_INT32;
47	1.76k	else if (osType == szXS_LONG \|\| osType == szXS_UNSIGNED_LONG)
48	0	return GMLAS_FT_INT64;
49	1.76k	else if (osType == szXS_FLOAT)
50	0	return GMLAS_FT_FLOAT;
51	1.76k	else if (osType == szXS_DOUBLE)
52	0	return GMLAS_FT_DOUBLE;
53	1.76k	else if (osType == szXS_DECIMAL)
54	0	return GMLAS_FT_DECIMAL;
55	1.76k	else if (osType == szXS_DATE)
56	8	return GMLAS_FT_DATE;
57	1.75k	else if (osType == szXS_GYEAR)
58	0	return GMLAS_FT_GYEAR;
59	1.75k	else if (osType == szXS_GYEAR_MONTH)
60	0	return GMLAS_FT_GYEAR_MONTH;
61	1.75k	else if (osType == szXS_TIME)
62	0	return GMLAS_FT_TIME;
63	1.75k	else if (osType == szXS_DATETIME)
64	27	return GMLAS_FT_DATETIME;
65	1.73k	else if (osType == szXS_ANY_URI)
66	103	return GMLAS_FT_ANYURI;
67	1.62k	else if (osType == szXS_ANY_TYPE)
68	0	return GMLAS_FT_ANYTYPE;
69	1.62k	else if (osType == szXS_ANY_SIMPLE_TYPE)
70	1.62k	return GMLAS_FT_ANYSIMPLETYPE;
71	0	else if (osType == szXS_DURATION)
72	0	return GMLAS_FT_STRING;
73	0	else if (osType == szXS_BASE64BINARY)
74	0	return GMLAS_FT_BASE64BINARY;
75	0	else if (osType == szXS_HEXBINARY)
76	0	return GMLAS_FT_HEXBINARY;
77	0	else
78	0	{
79	0	CPLError(CE_Warning, CPLE_AppDefined, "Unhandled type: %s",
80	0	osType.c_str());
81	0	return GMLAS_FT_STRING;
82	0	}
83	59.4k	}
84
85		/************************************************************************/
86		/* SetType() */
87		/************************************************************************/
88
89		void GMLASField::SetType(GMLASFieldType eType, const char *pszTypeName)
90	279k	{
91	279k	m_eType = eType;
92	279k	m_osTypeName = pszTypeName;
93	279k	}
94
95		/************************************************************************/
96		/* SetName() */
97		/************************************************************************/
98
99		void GMLASFeatureClass::SetName(const CPLString &osName)
100	170k	{
101	170k	m_osName = osName;
102	170k	}
103
104		/************************************************************************/
105		/* SetXPath() */
106		/************************************************************************/
107
108		void GMLASFeatureClass::SetXPath(const CPLString &osXPath)
109	73.6k	{
110	73.6k	m_osXPath = osXPath;
111	73.6k	}
112
113		/************************************************************************/
114		/* AddField() */
115		/************************************************************************/
116
117		void GMLASFeatureClass::AddField(const GMLASField &oField)
118	237k	{
119	237k	m_aoFields.push_back(oField);
120	237k	}
121
122		/************************************************************************/
123		/* PrependFields() */
124		/************************************************************************/
125
126		void GMLASFeatureClass::PrependFields(const std::vector<GMLASField> &aoFields)
127	1.30k	{
128	1.30k	m_aoFields.insert(m_aoFields.begin(), aoFields.begin(), aoFields.end());
129	1.30k	}
130
131		/************************************************************************/
132		/* AppendFields() */
133		/************************************************************************/
134
135		void GMLASFeatureClass::AppendFields(const std::vector<GMLASField> &aoFields)
136	48.3k	{
137	48.3k	m_aoFields.insert(m_aoFields.end(), aoFields.begin(), aoFields.end());
138	48.3k	}
139
140		/************************************************************************/
141		/* AddNestedClass() */
142		/************************************************************************/
143
144		void GMLASFeatureClass::AddNestedClass(const GMLASFeatureClass &oNestedClass)
145	3.73k	{
146	3.73k	m_aoNestedClasses.push_back(oNestedClass);
147	3.73k	}

Coverage Report

Created: 2025-12-31 08:30