sharpetronics/QGIS
1
0
Fork 0
mirror of https://github.com/qgis/QGIS.git synced 2025-10-16 00:05:45 -04:00
Code Issues Packages Projects Releases Wiki Activity

auto fix analysis

Browse Source
This commit is contained in:
Julien Cabieces 2024-04-11 14:17:46 +02:00 committed by Nyall Dawson
parent 483851b357
commit f105eeaeb8
70 changed files with 307 additions and 307 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/analysis/interpolation/qgstriangulation.cpp
View File

@ -18,6 +18,6 @@
QgsFields QgsTriangulation::triangulationFields()
{
QgsFields fields;
fields.append( QgsField( QStringLiteral( "type" ), QVariant::String, QStringLiteral( "String" ) ) );
fields.append( QgsField( QStringLiteral( "type" ), QMetaType::Type::QString, QStringLiteral( "String" ) ) );
return fields;
}

2
src/analysis/processing/qgsalgorithmaddincrementalfield.cpp
View File

@ -103,7 +103,7 @@ void QgsAddIncrementalFieldAlgorithm::initParameters( const QVariantMap & )
QgsFields QgsAddIncrementalFieldAlgorithm::outputFields( const QgsFields &inputFields ) const
{
QgsFields outFields = inputFields;
outFields.append( QgsField( mFieldName, QVariant::LongLong ) );
outFields.append( QgsField( mFieldName, QMetaType::Type::LongLong ) );
mFields = outFields;
return outFields;
}

52
src/analysis/processing/qgsalgorithmaddtablefield.cpp
View File

@ -81,19 +81,19 @@ void QgsAddTableFieldAlgorithm::initParameters( const QVariantMap & )
typeStrings.reserve( 11 );
icons.reserve( 11 );
for ( const auto &type :
std::vector < std::pair< QVariant::Type, QVariant::Type > >
std::vector < std::pair< QMetaType::Type, QMetaType::Type > >
{
{QVariant::Int, QVariant::Invalid },
{QVariant::Double, QVariant::Invalid },
{QVariant::String, QVariant::Invalid },
{QVariant::Bool, QVariant::Invalid },
{QVariant::Date, QVariant::Invalid },
{QVariant::Time, QVariant::Invalid },
{QVariant::DateTime, QVariant::Invalid },
{QVariant::ByteArray, QVariant::Invalid },
{QVariant::StringList, QVariant::Invalid },
{QVariant::List, QVariant::Int },
{QVariant::List, QVariant::Double }
{QMetaType::Type::Int, QMetaType::Type::UnknownType },
{QMetaType::Type::Double, QMetaType::Type::UnknownType },
{QMetaType::Type::QString, QMetaType::Type::UnknownType },
{QMetaType::Type::Bool, QMetaType::Type::UnknownType },
{QMetaType::Type::QDate, QMetaType::Type::UnknownType },
{QMetaType::Type::QTime, QMetaType::Type::UnknownType },
{QMetaType::Type::QDateTime, QMetaType::Type::UnknownType },
{QMetaType::Type::QByteArray, QMetaType::Type::UnknownType },
{QMetaType::Type::QStringList, QMetaType::Type::UnknownType },
{QMetaType::Type::QVariantList, QMetaType::Type::Int },
{QMetaType::Type::QVariantList, QMetaType::Type::Double }
} )
{
typeStrings << QgsVariantUtils::typeToDisplayString( type.first, type.second );
@ -148,40 +148,40 @@ bool QgsAddTableFieldAlgorithm::prepareAlgorithm( const QVariantMap &parameters,
switch ( type )
{
case 0: // Integer
mField.setType( QVariant::Int );
mField.setType( QMetaType::Type::Int );
break;
case 1: // Float
mField.setType( QVariant::Double );
mField.setType( QMetaType::Type::Double );
break;
case 2: // String
mField.setType( QVariant::String );
mField.setType( QMetaType::Type::QString );
break;
case 3: // Boolean
mField.setType( QVariant::Bool );
mField.setType( QMetaType::Type::Bool );
break;
case 4: // Date
mField.setType( QVariant::Date );
mField.setType( QMetaType::Type::QDate );
break;
case 5: // Time
mField.setType( QVariant::Time );
mField.setType( QMetaType::Type::QTime );
break;
case 6: // DateTime
mField.setType( QVariant::DateTime );
mField.setType( QMetaType::Type::QDateTime );
break;
case 7: // Binary
mField.setType( QVariant::ByteArray );
mField.setType( QMetaType::Type::QByteArray );
break;
case 8: // StringList
mField.setType( QVariant::StringList );
mField.setSubType( QVariant::String );
mField.setType( QMetaType::Type::QStringList );
mField.setSubType( QMetaType::Type::QString );
break;
case 9: // IntegerList
mField.setType( QVariant::List );
mField.setSubType( QVariant::Int );
mField.setType( QMetaType::Type::QVariantList );
mField.setSubType( QMetaType::Type::Int );
break;
case 10: // DoubleList
mField.setType( QVariant::List );
mField.setSubType( QVariant::Double );
mField.setType( QMetaType::Type::QVariantList );
mField.setSubType( QMetaType::Type::Double );
break;
}

4
src/analysis/processing/qgsalgorithmaddxyfields.cpp
View File

@ -104,8 +104,8 @@ QgsFields QgsAddXYFieldsAlgorithm::outputFields( const QgsFields &inputFields )
const QString yFieldName = mPrefix + 'y';
QgsFields outFields = inputFields;
outFields.append( QgsField( xFieldName, QVariant::Double, QString(), 20, 10 ) );
outFields.append( QgsField( yFieldName, QVariant::Double, QString(), 20, 10 ) );
outFields.append( QgsField( xFieldName, QMetaType::Type::Double, QString(), 20, 10 ) );
outFields.append( QgsField( yFieldName, QMetaType::Type::Double, QString(), 20, 10 ) );
return outFields;
}
}

6
src/analysis/processing/qgsalgorithmaggregate.cpp
View File

@ -92,9 +92,9 @@ bool QgsAggregateAlgorithm::prepareAlgorithm( const QVariantMap &parameters, Qgs
if ( name.isEmpty() )
throw QgsProcessingException( QObject::tr( "Field name cannot be empty" ) );
const QVariant::Type type = static_cast< QVariant::Type >( aggregateDef.value( QStringLiteral( "type" ) ).toInt() );
const QMetaType::Type type = static_cast< QMetaType::Type >( aggregateDef.value( QStringLiteral( "type" ) ).toInt() );
const QString typeName = aggregateDef.value( QStringLiteral( "type_name" ) ).toString();
const QVariant::Type subType = static_cast< QVariant::Type >( aggregateDef.value( QStringLiteral( "sub_type" ) ).toInt() );
const QMetaType::Type subType = static_cast< QMetaType::Type >( aggregateDef.value( QStringLiteral( "sub_type" ) ).toInt() );
const int length = aggregateDef.value( QStringLiteral( "length" ), 0 ).toInt();
const int precision = aggregateDef.value( QStringLiteral( "precision" ), 0 ).toInt();
@ -163,7 +163,7 @@ QVariantMap QgsAggregateAlgorithm::processAlgorithm( const QVariantMap &paramete
}
// upgrade group by value to a list, so that we get correct behavior with the QHash
const QVariantList key = groupByValue.type() == QVariant::List ? groupByValue.toList() : ( QVariantList() << groupByValue );
const QVariantList key = groupByValue.userType() == QMetaType::Type::QVariantList ? groupByValue.toList() : ( QVariantList() << groupByValue );
const auto groupIt = groups.find( key );
if ( groupIt == groups.end() )

2
src/analysis/processing/qgsalgorithmangletonearest.cpp
View File

@ -196,7 +196,7 @@ QVariantMap QgsAngleToNearestAlgorithm::processAlgorithm( const QVariantMap &par
}
else
{
outFields.append( QgsField( fieldName, QVariant::Double ) );
outFields.append( QgsField( fieldName, QMetaType::Type::Double ) );
}
QString dest;

4
src/analysis/processing/qgsalgorithmarrayoffsetlines.cpp
View File

@ -172,8 +172,8 @@ QgsFeatureList QgsCreateArrayOffsetLinesAlgorithm::processFeature( const QgsFeat
QgsFields QgsCreateArrayOffsetLinesAlgorithm::outputFields( const QgsFields &inputFields ) const
{
QgsFields output = inputFields;
output.append( QgsField( QStringLiteral( "instance" ), QVariant::Int ) );
output.append( QgsField( QStringLiteral( "offset" ), QVariant::Double ) );
output.append( QgsField( QStringLiteral( "instance" ), QMetaType::Type::Int ) );
output.append( QgsField( QStringLiteral( "offset" ), QMetaType::Type::Double ) );
return output;
}

2
src/analysis/processing/qgsalgorithmarraytranslatedfeatures.cpp
View File

@ -212,7 +212,7 @@ Qgis::WkbType QgsArrayTranslatedFeaturesAlgorithm::outputWkbType( Qgis::WkbType
QgsFields QgsArrayTranslatedFeaturesAlgorithm::outputFields( const QgsFields &inputFields ) const
{
QgsFields output;
output.append( QgsField( QStringLiteral( "instance" ), QVariant::Int ) );
output.append( QgsField( QStringLiteral( "instance" ), QMetaType::Type::Int ) );
return QgsProcessingUtils::combineFields( inputFields, output );
}

8
src/analysis/processing/qgsalgorithmboundingbox.cpp
View File

@ -64,10 +64,10 @@ QgsBoundingBoxAlgorithm *QgsBoundingBoxAlgorithm::createInstance() const
QgsFields QgsBoundingBoxAlgorithm::outputFields( const QgsFields &inputFields ) const
{
QgsFields fields = inputFields;
fields.append( QgsField( QStringLiteral( "width" ), QVariant::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "height" ), QVariant::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "area" ), QVariant::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "perimeter" ), QVariant::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "width" ), QMetaType::Type::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "height" ), QMetaType::Type::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "area" ), QMetaType::Type::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "perimeter" ), QMetaType::Type::Double, QString(), 20, 6 ) );
return fields;
}

4
src/analysis/processing/qgsalgorithmcalculateoverlaps.cpp
View File

@ -100,8 +100,8 @@ bool QgsCalculateVectorOverlapsAlgorithm::prepareAlgorithm( const QVariantMap &p
{
mLayerNames << layer->name();
mOverlayerSources.emplace_back( std::make_unique< QgsVectorLayerFeatureSource >( vl ) );
mOutputFields.append( QgsField( QStringLiteral( "%1_area" ).arg( vl->name() ), QVariant::Double ) );
mOutputFields.append( QgsField( QStringLiteral( "%1_pc" ).arg( vl->name() ), QVariant::Double ) );
mOutputFields.append( QgsField( QStringLiteral( "%1_area" ).arg( vl->name() ), QMetaType::Type::Double ) );
mOutputFields.append( QgsField( QStringLiteral( "%1_pc" ).arg( vl->name() ), QMetaType::Type::Double ) );
}
}

4
src/analysis/processing/qgsalgorithmcategorizeusingstyle.cpp
View File

@ -187,14 +187,14 @@ QVariantMap QgsCategorizeUsingStyleAlgorithm::processAlgorithm( const QVariantMa
}
QgsFields nonMatchingCategoryFields;
nonMatchingCategoryFields.append( QgsField( QStringLiteral( "category" ), QVariant::String ) );
nonMatchingCategoryFields.append( QgsField( QStringLiteral( "category" ), QMetaType::Type::QString ) );
QString nonMatchingCategoriesDest;
std::unique_ptr< QgsFeatureSink > nonMatchingCategoriesSink( parameterAsSink( parameters, QStringLiteral( "NON_MATCHING_CATEGORIES" ), context, nonMatchingCategoriesDest, nonMatchingCategoryFields, Qgis::WkbType::NoGeometry ) );
if ( !nonMatchingCategoriesSink && parameters.contains( QStringLiteral( "NON_MATCHING_CATEGORIES" ) ) && parameters.value( QStringLiteral( "NON_MATCHING_CATEGORIES" ) ).isValid() )
throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "NON_MATCHING_CATEGORIES" ) ) );
QgsFields nonMatchingSymbolFields;
nonMatchingSymbolFields.append( QgsField( QStringLiteral( "name" ), QVariant::String ) );
nonMatchingSymbolFields.append( QgsField( QStringLiteral( "name" ), QMetaType::Type::QString ) );
QString nonMatchingSymbolsDest;
std::unique_ptr< QgsFeatureSink > nonMatchingSymbolsSink( parameterAsSink( parameters, QStringLiteral( "NON_MATCHING_SYMBOLS" ), context, nonMatchingSymbolsDest, nonMatchingSymbolFields, Qgis::WkbType::NoGeometry ) );
if ( !nonMatchingSymbolsSink && parameters.contains( QStringLiteral( "NON_MATCHING_SYMBOLS" ) ) && parameters.value( QStringLiteral( "NON_MATCHING_SYMBOLS" ) ).isValid() )

4
src/analysis/processing/qgsalgorithmconvexhull.cpp
View File

@ -64,8 +64,8 @@ QgsConvexHullAlgorithm *QgsConvexHullAlgorithm::createInstance() const
QgsFields QgsConvexHullAlgorithm::outputFields( const QgsFields &inputFields ) const
{
QgsFields fields = inputFields;
fields.append( QgsField( QStringLiteral( "area" ), QVariant::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "perimeter" ), QVariant::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "area" ), QMetaType::Type::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "perimeter" ), QMetaType::Type::Double, QString(), 20, 6 ) );
return fields;
}

4
src/analysis/processing/qgsalgorithmdbscanclustering.cpp
View File

@ -120,9 +120,9 @@ QVariantMap QgsDbscanClusteringAlgorithm::processAlgorithm( const QVariantMap &p
QgsFields outputFields = source->fields();
QgsFields newFields;
const QString clusterFieldName = parameterAsString( parameters, QStringLiteral( "FIELD_NAME" ), context );
newFields.append( QgsField( clusterFieldName, QVariant::Int ) );
newFields.append( QgsField( clusterFieldName, QMetaType::Type::Int ) );
const QString clusterSizeFieldName = parameterAsString( parameters, QStringLiteral( "SIZE_FIELD_NAME" ), context );
newFields.append( QgsField( clusterSizeFieldName, QVariant::Int ) );
newFields.append( QgsField( clusterSizeFieldName, QMetaType::Type::Int ) );
outputFields = QgsProcessingUtils::combineFields( outputFields, newFields );
QString dest;

8
src/analysis/processing/qgsalgorithmdelaunaytriangulation.cpp
View File

@ -82,13 +82,13 @@ QVariantMap QgsDelaunayTriangulationAlgorithm::processAlgorithm( const QVariantM
QgsFields fields;
if ( addAttributes )
{
fields.append( QgsField( QStringLiteral( "POINTA" ), QVariant::LongLong ) );
fields.append( QgsField( QStringLiteral( "POINTB" ), QVariant::LongLong ) );
fields.append( QgsField( QStringLiteral( "POINTC" ), QVariant::LongLong ) );
fields.append( QgsField( QStringLiteral( "POINTA" ), QMetaType::Type::LongLong ) );
fields.append( QgsField( QStringLiteral( "POINTB" ), QMetaType::Type::LongLong ) );
fields.append( QgsField( QStringLiteral( "POINTC" ), QMetaType::Type::LongLong ) );
}
else
{
fields.append( QgsField( QStringLiteral( "id" ), QVariant::LongLong ) );
fields.append( QgsField( QStringLiteral( "id" ), QMetaType::Type::LongLong ) );
}
QString dest;

2
src/analysis/processing/qgsalgorithmexplodehstore.cpp
View File

@ -125,7 +125,7 @@ QVariantMap QgsExplodeHstoreAlgorithm::processAlgorithm( const QVariantMap &para
QgsFields hstoreFields;
for ( const QString &fieldName : fieldsToAdd )
{
hstoreFields.append( QgsField( fieldName, QVariant::String ) );
hstoreFields.append( QgsField( fieldName, QMetaType::Type::QString ) );
}
QgsFields outFields = QgsProcessingUtils::combineFields( source->fields(), hstoreFields );

18
src/analysis/processing/qgsalgorithmexportlayersinformation.cpp
View File

@ -94,15 +94,15 @@ bool QgsExportLayersInformationAlgorithm::prepareAlgorithm( const QVariantMap &p
QVariantMap QgsExportLayersInformationAlgorithm::processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
{
QgsFields outFields;
outFields.append( QgsField( QStringLiteral( "name" ), QVariant::String ) );
outFields.append( QgsField( QStringLiteral( "source" ), QVariant::String ) );
outFields.append( QgsField( QStringLiteral( "crs" ), QVariant::String ) );
outFields.append( QgsField( QStringLiteral( "provider" ), QVariant::String ) );
outFields.append( QgsField( QStringLiteral( "file_path" ), QVariant::String ) );
outFields.append( QgsField( QStringLiteral( "layer_name" ), QVariant::String ) );
outFields.append( QgsField( QStringLiteral( "subset" ), QVariant::String ) );
outFields.append( QgsField( QStringLiteral( "abstract" ), QVariant::String ) );
outFields.append( QgsField( QStringLiteral( "attribution" ), QVariant::String ) );
outFields.append( QgsField( QStringLiteral( "name" ), QMetaType::Type::QString ) );
outFields.append( QgsField( QStringLiteral( "source" ), QMetaType::Type::QString ) );
outFields.append( QgsField( QStringLiteral( "crs" ), QMetaType::Type::QString ) );
outFields.append( QgsField( QStringLiteral( "provider" ), QMetaType::Type::QString ) );
outFields.append( QgsField( QStringLiteral( "file_path" ), QMetaType::Type::QString ) );
outFields.append( QgsField( QStringLiteral( "layer_name" ), QMetaType::Type::QString ) );
outFields.append( QgsField( QStringLiteral( "subset" ), QMetaType::Type::QString ) );
outFields.append( QgsField( QStringLiteral( "abstract" ), QMetaType::Type::QString ) );
outFields.append( QgsField( QStringLiteral( "attribution" ), QMetaType::Type::QString ) );
QString outputDest;
std::unique_ptr< QgsFeatureSink > outputSink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, outputDest, outFields,

24
src/analysis/processing/qgsalgorithmexportmesh.cpp
View File

@ -41,18 +41,18 @@ static QgsFields createFields( const QList<QgsMeshDatasetGroupMetadata> &groupMe
{
if ( vectorOption == 0 || vectorOption == 2 )
{
fields.append( QgsField( QStringLiteral( "%1_x" ).arg( meta.name() ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "%1_y" ).arg( meta.name() ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "%1_x" ).arg( meta.name() ), QMetaType::Type::Double ) );
fields.append( QgsField( QStringLiteral( "%1_y" ).arg( meta.name() ), QMetaType::Type::Double ) );
}
if ( vectorOption == 1 || vectorOption == 2 )
{
fields.append( QgsField( QStringLiteral( "%1_mag" ).arg( meta.name() ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "%1_dir" ).arg( meta.name() ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "%1_mag" ).arg( meta.name() ), QMetaType::Type::Double ) );
fields.append( QgsField( QStringLiteral( "%1_dir" ).arg( meta.name() ), QMetaType::Type::Double ) );
}
}
else
fields.append( QgsField( meta.name(), QVariant::Double ) );
fields.append( QgsField( meta.name(), QMetaType::Type::Double ) );
}
return fields;
}
@ -1083,13 +1083,13 @@ QVariantMap QgsMeshContoursAlgorithm::processAlgorithm( const QVariantMap &param
// Create vector layers
QgsFields polygonFields;
QgsFields lineFields;
polygonFields.append( QgsField( QObject::tr( "group" ), QVariant::String ) );
polygonFields.append( QgsField( QObject::tr( "time" ), QVariant::String ) );
polygonFields.append( QgsField( QObject::tr( "min_value" ), QVariant::Double ) );
polygonFields.append( QgsField( QObject::tr( "max_value" ), QVariant::Double ) );
lineFields.append( QgsField( QObject::tr( "group" ), QVariant::String ) );
lineFields.append( QgsField( QObject::tr( "time" ), QVariant::String ) );
lineFields.append( QgsField( QObject::tr( "value" ), QVariant::Double ) );
polygonFields.append( QgsField( QObject::tr( "group" ), QMetaType::Type::QString ) );
polygonFields.append( QgsField( QObject::tr( "time" ), QMetaType::Type::QString ) );
polygonFields.append( QgsField( QObject::tr( "min_value" ), QMetaType::Type::Double ) );
polygonFields.append( QgsField( QObject::tr( "max_value" ), QMetaType::Type::Double ) );
lineFields.append( QgsField( QObject::tr( "group" ), QMetaType::Type::QString ) );
lineFields.append( QgsField( QObject::tr( "time" ), QMetaType::Type::QString ) );
lineFields.append( QgsField( QObject::tr( "value" ), QMetaType::Type::Double ) );
QgsCoordinateReferenceSystem outputCrs = parameterAsCrs( parameters, QStringLiteral( "CRS_OUTPUT" ), context );

2
src/analysis/processing/qgsalgorithmexporttospreadsheet.cpp
View File

@ -56,7 +56,7 @@ class FieldValueConverter : public QgsVectorFileWriter::FieldValueConverter
const int idx = mLayer->fields().indexFromName( field.name() );
if ( mFormatters.contains( idx ) )
{
return QgsField( field.name(), QVariant::String );
return QgsField( field.name(), QMetaType::Type::QString );
}
return field;
}

20
src/analysis/processing/qgsalgorithmextentfromlayer.cpp
View File

@ -90,16 +90,16 @@ QVariantMap QgsExtentFromLayerAlgorithm::processAlgorithm( const QVariantMap &pa
const double roundTo = parameterAsDouble( parameters, QStringLiteral( "ROUND_TO" ), context );
QgsFields fields;
fields.append( QgsField( QStringLiteral( "MINX" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "MINY" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "MAXX" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "MAXY" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "CNTX" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "CNTY" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "AREA" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "PERIM" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "HEIGHT" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "WIDTH" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "MINX" ), QMetaType::Type::Double ) );
fields.append( QgsField( QStringLiteral( "MINY" ), QMetaType::Type::Double ) );
fields.append( QgsField( QStringLiteral( "MAXX" ), QMetaType::Type::Double ) );
fields.append( QgsField( QStringLiteral( "MAXY" ), QMetaType::Type::Double ) );
fields.append( QgsField( QStringLiteral( "CNTX" ), QMetaType::Type::Double ) );
fields.append( QgsField( QStringLiteral( "CNTY" ), QMetaType::Type::Double ) );
fields.append( QgsField( QStringLiteral( "AREA" ), QMetaType::Type::Double ) );
fields.append( QgsField( QStringLiteral( "PERIM" ), QMetaType::Type::Double ) );
fields.append( QgsField( QStringLiteral( "HEIGHT" ), QMetaType::Type::Double ) );
fields.append( QgsField( QStringLiteral( "WIDTH" ), QMetaType::Type::Double ) );
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::Polygon, layer->crs() ) );

2
src/analysis/processing/qgsalgorithmextenttolayer.cpp
View File

@ -48,7 +48,7 @@ QVariantMap QgsExtentToLayerAlgorithm::processAlgorithm( const QVariantMap &para
const QgsGeometry geom = parameterAsExtentGeometry( parameters, QStringLiteral( "INPUT" ), context );
QgsFields fields;
fields.append( QgsField( QStringLiteral( "id" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "id" ), QMetaType::Type::Int ) );
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::Polygon, crs ) );

4
src/analysis/processing/qgsalgorithmextractbyattribute.cpp
View File

@ -106,9 +106,9 @@ QVariantMap QgsExtractByAttributeAlgorithm::processAlgorithm( const QVariantMap
if ( idx < 0 )
throw QgsProcessingException( QObject::tr( "Field '%1' was not found in INPUT source" ).arg( fieldName ) );
const QVariant::Type fieldType = source->fields().at( idx ).type();
const QMetaType::Type fieldType = source->fields().at( idx ).type();
if ( fieldType != QVariant::String && ( op == BeginsWith || op == Contains || op == DoesNotContain ) )
if ( fieldType != QMetaType::Type::QString && ( op == BeginsWith || op == Contains || op == DoesNotContain ) )
{
QString method;
switch ( op )

46
src/analysis/processing/qgsalgorithmextractlabels.cpp
View File

@ -351,29 +351,29 @@ QVariantMap QgsExtractLabelsAlgorithm::processAlgorithm( const QVariantMap &para
const QSize imageSize = calculator.calculateImageSize( extent, scale ).toSize();
QgsFields fields;
fields.append( QgsField( QStringLiteral( "Layer" ), QVariant::String, QString(), 0, 0 ) );
fields.append( QgsField( QStringLiteral( "FeatureID" ), QVariant::LongLong, QString(), 20 ) );
fields.append( QgsField( QStringLiteral( "LabelText" ), QVariant::String, QString(), 0, 0 ) );
fields.append( QgsField( QStringLiteral( "LabelWidth" ), QVariant::Double, QString(), 20, 8 ) );
fields.append( QgsField( QStringLiteral( "LabelHeight" ), QVariant::Double, QString(), 20, 8 ) );
fields.append( QgsField( QStringLiteral( "LabelRotation" ), QVariant::Double, QString(), 20, 2 ) );
fields.append( QgsField( QStringLiteral( "LabelUnplaced" ), QVariant::Bool, QString(), 1, 0 ) );
fields.append( QgsField( QStringLiteral( "Family" ), QVariant::String, QString(), 0, 0 ) );
fields.append( QgsField( QStringLiteral( "Size" ), QVariant::Double, QString(), 20, 4 ) );
fields.append( QgsField( QStringLiteral( "Italic" ), QVariant::Bool, QString(), 1, 0 ) );
fields.append( QgsField( QStringLiteral( "Bold" ), QVariant::Bool, QString(), 1, 0 ) );
fields.append( QgsField( QStringLiteral( "Underline" ), QVariant::Bool, QString(), 1, 0 ) );
fields.append( QgsField( QStringLiteral( "FontStyle" ), QVariant::String, QString(), 0, 0 ) );
fields.append( QgsField( QStringLiteral( "FontLetterSpacing" ), QVariant::Double, QString(), 20, 4 ) );
fields.append( QgsField( QStringLiteral( "FontWordSpacing" ), QVariant::Double, QString(), 20, 4 ) );
fields.append( QgsField( QStringLiteral( "MultiLineAlignment" ), QVariant::String, QString(), 0, 0 ) );
fields.append( QgsField( QStringLiteral( "MultiLineHeight" ), QVariant::Double, QString(), 20, 2 ) );
fields.append( QgsField( QStringLiteral( "Color" ), QVariant::String, QString(), 7, 0 ) );
fields.append( QgsField( QStringLiteral( "FontOpacity" ), QVariant::Double, QString(), 20, 1 ) );
fields.append( QgsField( QStringLiteral( "BufferDraw" ), QVariant::Bool, QString(), 1, 0 ) );
fields.append( QgsField( QStringLiteral( "BufferSize" ), QVariant::Double, QString(), 20, 4 ) );
fields.append( QgsField( QStringLiteral( "BufferColor" ), QVariant::String, QString(), 7, 0 ) );
fields.append( QgsField( QStringLiteral( "BufferOpacity" ), QVariant::Double, QString(), 20, 1 ) );
fields.append( QgsField( QStringLiteral( "Layer" ), QMetaType::Type::QString, QString(), 0, 0 ) );
fields.append( QgsField( QStringLiteral( "FeatureID" ), QMetaType::Type::LongLong, QString(), 20 ) );
fields.append( QgsField( QStringLiteral( "LabelText" ), QMetaType::Type::QString, QString(), 0, 0 ) );
fields.append( QgsField( QStringLiteral( "LabelWidth" ), QMetaType::Type::Double, QString(), 20, 8 ) );
fields.append( QgsField( QStringLiteral( "LabelHeight" ), QMetaType::Type::Double, QString(), 20, 8 ) );
fields.append( QgsField( QStringLiteral( "LabelRotation" ), QMetaType::Type::Double, QString(), 20, 2 ) );
fields.append( QgsField( QStringLiteral( "LabelUnplaced" ), QMetaType::Type::Bool, QString(), 1, 0 ) );
fields.append( QgsField( QStringLiteral( "Family" ), QMetaType::Type::QString, QString(), 0, 0 ) );
fields.append( QgsField( QStringLiteral( "Size" ), QMetaType::Type::Double, QString(), 20, 4 ) );
fields.append( QgsField( QStringLiteral( "Italic" ), QMetaType::Type::Bool, QString(), 1, 0 ) );
fields.append( QgsField( QStringLiteral( "Bold" ), QMetaType::Type::Bool, QString(), 1, 0 ) );
fields.append( QgsField( QStringLiteral( "Underline" ), QMetaType::Type::Bool, QString(), 1, 0 ) );
fields.append( QgsField( QStringLiteral( "FontStyle" ), QMetaType::Type::QString, QString(), 0, 0 ) );
fields.append( QgsField( QStringLiteral( "FontLetterSpacing" ), QMetaType::Type::Double, QString(), 20, 4 ) );
fields.append( QgsField( QStringLiteral( "FontWordSpacing" ), QMetaType::Type::Double, QString(), 20, 4 ) );
fields.append( QgsField( QStringLiteral( "MultiLineAlignment" ), QMetaType::Type::QString, QString(), 0, 0 ) );
fields.append( QgsField( QStringLiteral( "MultiLineHeight" ), QMetaType::Type::Double, QString(), 20, 2 ) );
fields.append( QgsField( QStringLiteral( "Color" ), QMetaType::Type::QString, QString(), 7, 0 ) );
fields.append( QgsField( QStringLiteral( "FontOpacity" ), QMetaType::Type::Double, QString(), 20, 1 ) );
fields.append( QgsField( QStringLiteral( "BufferDraw" ), QMetaType::Type::Bool, QString(), 1, 0 ) );
fields.append( QgsField( QStringLiteral( "BufferSize" ), QMetaType::Type::Double, QString(), 20, 4 ) );
fields.append( QgsField( QStringLiteral( "BufferColor" ), QMetaType::Type::QString, QString(), 7, 0 ) );
fields.append( QgsField( QStringLiteral( "BufferOpacity" ), QMetaType::Type::Double, QString(), 20, 1 ) );
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::Point, mCrs, QgsFeatureSink::RegeneratePrimaryKey ) );

10
src/analysis/processing/qgsalgorithmextractlayoutmapextent.cpp
View File

@ -144,11 +144,11 @@ bool QgsLayoutMapExtentToLayerAlgorithm::prepareAlgorithm( const QVariantMap &pa
QVariantMap QgsLayoutMapExtentToLayerAlgorithm::processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
{
QgsFields fields;
fields.append( QgsField( QStringLiteral( "map" ), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "width" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "height" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "scale" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "rotation" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "map" ), QMetaType::Type::QString ) );
fields.append( QgsField( QStringLiteral( "width" ), QMetaType::Type::Double ) );
fields.append( QgsField( QStringLiteral( "height" ), QMetaType::Type::Double ) );
fields.append( QgsField( QStringLiteral( "scale" ), QMetaType::Type::Double ) );
fields.append( QgsField( QStringLiteral( "rotation" ), QMetaType::Type::Double ) );
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::Polygon, mCrs ) );

14
src/analysis/processing/qgsalgorithmextractspecificvertices.cpp
View File

@ -82,16 +82,16 @@ Qgis::ProcessingSourceType QgsExtractSpecificVerticesAlgorithm::outputLayerType(
QgsFields QgsExtractSpecificVerticesAlgorithm::outputFields( const QgsFields &inputFields ) const
{
QgsFields outputFields = inputFields;
outputFields.append( QgsField( QStringLiteral( "vertex_pos" ), QVariant::Int ) );
outputFields.append( QgsField( QStringLiteral( "vertex_index" ), QVariant::Int ) );
outputFields.append( QgsField( QStringLiteral( "vertex_part" ), QVariant::Int ) );
outputFields.append( QgsField( QStringLiteral( "vertex_pos" ), QMetaType::Type::Int ) );
outputFields.append( QgsField( QStringLiteral( "vertex_index" ), QMetaType::Type::Int ) );
outputFields.append( QgsField( QStringLiteral( "vertex_part" ), QMetaType::Type::Int ) );
if ( mGeometryType == Qgis::GeometryType::Polygon )
{
outputFields.append( QgsField( QStringLiteral( "vertex_part_ring" ), QVariant::Int ) );
outputFields.append( QgsField( QStringLiteral( "vertex_part_ring" ), QMetaType::Type::Int ) );
}
outputFields.append( QgsField( QStringLiteral( "vertex_part_index" ), QVariant::Int ) );
outputFields.append( QgsField( QStringLiteral( "distance" ), QVariant::Double ) );
outputFields.append( QgsField( QStringLiteral( "angle" ), QVariant::Double ) );
outputFields.append( QgsField( QStringLiteral( "vertex_part_index" ), QMetaType::Type::Int ) );
outputFields.append( QgsField( QStringLiteral( "distance" ), QMetaType::Type::Double ) );
outputFields.append( QgsField( QStringLiteral( "angle" ), QMetaType::Type::Double ) );
return outputFields;
}

12
src/analysis/processing/qgsalgorithmextractvertices.cpp
View File

@ -72,15 +72,15 @@ Qgis::ProcessingSourceType QgsExtractVerticesAlgorithm::outputLayerType() const
QgsFields QgsExtractVerticesAlgorithm::outputFields( const QgsFields &inputFields ) const
{
QgsFields outputFields = inputFields;
outputFields.append( QgsField( QStringLiteral( "vertex_index" ), QVariant::Int, QString(), 10, 0 ) );
outputFields.append( QgsField( QStringLiteral( "vertex_part" ), QVariant::Int, QString(), 10, 0 ) );
outputFields.append( QgsField( QStringLiteral( "vertex_index" ), QMetaType::Type::Int, QString(), 10, 0 ) );
outputFields.append( QgsField( QStringLiteral( "vertex_part" ), QMetaType::Type::Int, QString(), 10, 0 ) );
if ( mGeometryType == Qgis::GeometryType::Polygon )
{
outputFields.append( QgsField( QStringLiteral( "vertex_part_ring" ), QVariant::Int, QString(), 10, 0 ) );
outputFields.append( QgsField( QStringLiteral( "vertex_part_ring" ), QMetaType::Type::Int, QString(), 10, 0 ) );
}
outputFields.append( QgsField( QStringLiteral( "vertex_part_index" ), QVariant::Int, QString(), 10, 0 ) );
outputFields.append( QgsField( QStringLiteral( "distance" ), QVariant::Double, QString(), 20, 14 ) );
outputFields.append( QgsField( QStringLiteral( "angle" ), QVariant::Double, QString(), 20, 14 ) );
outputFields.append( QgsField( QStringLiteral( "vertex_part_index" ), QMetaType::Type::Int, QString(), 10, 0 ) );
outputFields.append( QgsField( QStringLiteral( "distance" ), QMetaType::Type::Double, QString(), 20, 14 ) );
outputFields.append( QgsField( QStringLiteral( "angle" ), QMetaType::Type::Double, QString(), 20, 14 ) );
return outputFields;
}

2
src/analysis/processing/qgsalgorithmextractzmvalues.cpp
View File

@ -96,7 +96,7 @@ bool QgsExtractZMValuesAlgorithmBase::prepareAlgorithm( const QVariantMap &param
{
mStats |= STATS.at( s );
mSelectedStats << STATS.at( s );
mNewFields.append( QgsField( mPrefix + QgsStatisticalSummary::shortName( STATS.at( s ) ), STATS.at( s ) == Qgis::Statistic::Count || STATS.at( s ) == Qgis::Statistic::Variety ? QVariant::Int : QVariant::Double ) );
mNewFields.append( QgsField( mPrefix + QgsStatisticalSummary::shortName( STATS.at( s ) ), STATS.at( s ) == Qgis::Statistic::Count || STATS.at( s ) == Qgis::Statistic::Variety ? QMetaType::Type::Int : QMetaType::Type::Double ) );
}
return true;

56
src/analysis/processing/qgsalgorithmfieldcalculator.cpp
View File

@ -71,19 +71,19 @@ void QgsFieldCalculatorAlgorithm::initParameters( const QVariantMap &configurati
fieldTypes.reserve( 11 );
icons.reserve( 11 );
for ( const auto &type :
std::vector < std::pair< QVariant::Type, QVariant::Type > >
std::vector < std::pair< QMetaType::Type, QMetaType::Type > >
{
{QVariant::Double, QVariant::Invalid },
{QVariant::Int, QVariant::Invalid },
{QVariant::String, QVariant::Invalid },
{QVariant::Date, QVariant::Invalid },
{QVariant::Time, QVariant::Invalid },
{QVariant::DateTime, QVariant::Invalid },
{QVariant::Bool, QVariant::Invalid },
{QVariant::ByteArray, QVariant::Invalid },
{QVariant::StringList, QVariant::Invalid },
{QVariant::List, QVariant::Int },
{QVariant::List, QVariant::Double }
{QMetaType::Type::Double, QMetaType::Type::UnknownType },
{QMetaType::Type::Int, QMetaType::Type::UnknownType },
{QMetaType::Type::QString, QMetaType::Type::UnknownType },
{QMetaType::Type::QDate, QMetaType::Type::UnknownType },
{QMetaType::Type::QTime, QMetaType::Type::UnknownType },
{QMetaType::Type::QDateTime, QMetaType::Type::UnknownType },
{QMetaType::Type::Bool, QMetaType::Type::UnknownType },
{QMetaType::Type::QByteArray, QMetaType::Type::UnknownType },
{QMetaType::Type::QStringList, QMetaType::Type::UnknownType },
{QMetaType::Type::QVariantList, QMetaType::Type::Int },
{QMetaType::Type::QVariantList, QMetaType::Type::Double }
} )
{
fieldTypes << QgsVariantUtils::typeToDisplayString( type.first, type.second );
@ -149,45 +149,45 @@ bool QgsFieldCalculatorAlgorithm::prepareAlgorithm( const QVariantMap &parameter
const int fieldPrecision = parameterAsInt( parameters, QStringLiteral( "FIELD_PRECISION" ), context );
const QString fieldName = parameterAsString( parameters, QStringLiteral( "FIELD_NAME" ), context );
QVariant::Type fieldType = QVariant::Type::String;
QVariant::Type fieldSubType = QVariant::Type::Invalid;
QMetaType::Type fieldType = QMetaType::Type::QString;
QMetaType::Type fieldSubType = QMetaType::Type::UnknownType;
switch ( fieldTypeIdx )
{
case 0: // Float
fieldType = QVariant::Double;
fieldType = QMetaType::Type::Double;
break;
case 1: // Integer
fieldType = QVariant::Int;
fieldType = QMetaType::Type::Int;
break;
case 2: // String
fieldType = QVariant::String;
fieldType = QMetaType::Type::QString;
break;
case 3: // Date
fieldType = QVariant::Date;
fieldType = QMetaType::Type::QDate;
break;
case 4: // Time
fieldType = QVariant::Time;
fieldType = QMetaType::Type::QTime;
break;
case 5: // DateTime
fieldType = QVariant::DateTime;
fieldType = QMetaType::Type::QDateTime;
break;
case 6: // Boolean
fieldType = QVariant::Bool;
fieldType = QMetaType::Type::Bool;
break;
case 7: // Binary
fieldType = QVariant::ByteArray;
fieldType = QMetaType::Type::QByteArray;
break;
case 8: // StringList
fieldType = QVariant::StringList;
fieldSubType = QVariant::String;
fieldType = QMetaType::Type::QStringList;
fieldSubType = QMetaType::Type::QString;
break;
case 9: // IntegerList
fieldType = QVariant::List;
fieldSubType = QVariant::Int;
fieldType = QMetaType::Type::QVariantList;
fieldSubType = QMetaType::Type::Int;
break;
case 10: // DoubleList
fieldType = QVariant::List;
fieldSubType = QVariant::Double;
fieldType = QMetaType::Type::QVariantList;
fieldSubType = QMetaType::Type::Double;
break;
}

14
src/analysis/processing/qgsalgorithmgrid.cpp
View File

@ -114,19 +114,19 @@ QVariantMap QgsGridAlgorithm::processAlgorithm( const QVariantMap &parameters, Q
throw QgsProcessingException( QObject::tr( "Invalid overlay: horizontal: '%1', vertical: '%2'" ).arg( mHOverlay ).arg( mVOverlay ) );
QgsFields fields = QgsFields();
fields.append( QgsField( QStringLiteral( "id" ), QVariant::LongLong ) );
fields.append( QgsField( QStringLiteral( "left" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "top" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "right" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "bottom" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "id" ), QMetaType::Type::LongLong ) );
fields.append( QgsField( QStringLiteral( "left" ), QMetaType::Type::Double ) );
fields.append( QgsField( QStringLiteral( "top" ), QMetaType::Type::Double ) );
fields.append( QgsField( QStringLiteral( "right" ), QMetaType::Type::Double ) );
fields.append( QgsField( QStringLiteral( "bottom" ), QMetaType::Type::Double ) );
switch ( mIdx )
{
case 0: //point
case 2: //rectangle
case 4: //hexagon
fields.append( QgsField( QStringLiteral( "row_index" ), QVariant::LongLong ) );
fields.append( QgsField( QStringLiteral( "col_index" ), QVariant::LongLong ) );
fields.append( QgsField( QStringLiteral( "row_index" ), QMetaType::Type::LongLong ) );
fields.append( QgsField( QStringLiteral( "col_index" ), QMetaType::Type::LongLong ) );
break;
default:
break;

28
src/analysis/processing/qgsalgorithmimportphotos.cpp
View File

@ -148,7 +148,7 @@ QVariant QgsImportPhotosAlgorithm::extractAltitudeFromMetadata( const QVariantMa
{
double alt = metadata.value( QStringLiteral( "EXIF_GPSAltitude" ) ).toDouble();
if ( metadata.contains( QStringLiteral( "EXIF_GPSAltitudeRef" ) ) &&
( ( metadata.value( QStringLiteral( "EXIF_GPSAltitudeRef" ) ).type() == QVariant::String && metadata.value( QStringLiteral( "EXIF_GPSAltitudeRef" ) ).toString().right( 1 ) == QLatin1String( "1" ) )
( ( metadata.value( QStringLiteral( "EXIF_GPSAltitudeRef" ) ).userType() == QMetaType::Type::QString && metadata.value( QStringLiteral( "EXIF_GPSAltitudeRef" ) ).toString().right( 1 ) == QLatin1String( "1" ) )
|| metadata.value( QStringLiteral( "EXIF_GPSAltitudeRef" ) ).toDouble() < 0 ) )
alt = -alt;
altitude = alt;
@ -317,24 +317,24 @@ QVariantMap QgsImportPhotosAlgorithm::processAlgorithm( const QVariantMap &param
const bool recurse = parameterAsBoolean( parameters, QStringLiteral( "RECURSIVE" ), context );
QgsFields outFields;
outFields.append( QgsField( QStringLiteral( "photo" ), QVariant::String ) );
outFields.append( QgsField( QStringLiteral( "filename" ), QVariant::String ) );
outFields.append( QgsField( QStringLiteral( "directory" ), QVariant::String ) );
outFields.append( QgsField( QStringLiteral( "altitude" ), QVariant::Double ) );
outFields.append( QgsField( QStringLiteral( "direction" ), QVariant::Double ) );
outFields.append( QgsField( QStringLiteral( "rotation" ), QVariant::Int ) );
outFields.append( QgsField( QStringLiteral( "longitude" ), QVariant::String ) );
outFields.append( QgsField( QStringLiteral( "latitude" ), QVariant::String ) );
outFields.append( QgsField( QStringLiteral( "timestamp" ), QVariant::DateTime ) );
outFields.append( QgsField( QStringLiteral( "photo" ), QMetaType::Type::QString ) );
outFields.append( QgsField( QStringLiteral( "filename" ), QMetaType::Type::QString ) );
outFields.append( QgsField( QStringLiteral( "directory" ), QMetaType::Type::QString ) );
outFields.append( QgsField( QStringLiteral( "altitude" ), QMetaType::Type::Double ) );
outFields.append( QgsField( QStringLiteral( "direction" ), QMetaType::Type::Double ) );
outFields.append( QgsField( QStringLiteral( "rotation" ), QMetaType::Type::Int ) );
outFields.append( QgsField( QStringLiteral( "longitude" ), QMetaType::Type::QString ) );
outFields.append( QgsField( QStringLiteral( "latitude" ), QMetaType::Type::QString ) );
outFields.append( QgsField( QStringLiteral( "timestamp" ), QMetaType::Type::QDateTime ) );
QString outputDest;
std::unique_ptr< QgsFeatureSink > outputSink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, outputDest, outFields,
Qgis::WkbType::PointZ, QgsCoordinateReferenceSystem( QStringLiteral( "EPSG:4326" ) ) ) );
QgsFields invalidFields;
invalidFields.append( QgsField( QStringLiteral( "photo" ), QVariant::String ) );
invalidFields.append( QgsField( QStringLiteral( "filename" ), QVariant::String ) );
invalidFields.append( QgsField( QStringLiteral( "directory" ), QVariant::String ) );
invalidFields.append( QgsField( QStringLiteral( "readable" ), QVariant::Bool ) );
invalidFields.append( QgsField( QStringLiteral( "photo" ), QMetaType::Type::QString ) );
invalidFields.append( QgsField( QStringLiteral( "filename" ), QMetaType::Type::QString ) );
invalidFields.append( QgsField( QStringLiteral( "directory" ), QMetaType::Type::QString ) );
invalidFields.append( QgsField( QStringLiteral( "readable" ), QMetaType::Type::Bool ) );
QString invalidDest;
std::unique_ptr< QgsFeatureSink > invalidSink( parameterAsSink( parameters, QStringLiteral( "INVALID" ), context, invalidDest, invalidFields ) );

74
src/analysis/processing/qgsalgorithmjoinbylocationsummary.cpp
View File

@ -179,12 +179,12 @@ QVariantMap QgsJoinByLocationSummaryAlgorithm::processAlgorithm( const QVariantM
};
// Adds a field to the output, with a specified type
auto addFieldWithType = [&fieldsToJoin]( const QgsField & original, const QString & statistic, QVariant::Type type )
auto addFieldWithType = [&fieldsToJoin]( const QgsField & original, const QString & statistic, QMetaType::Type type )
{
QgsField field = QgsField( original );
field.setName( field.name() + '_' + statistic );
field.setType( type );
if ( type == QVariant::Double )
if ( type == QMetaType::Type::Double )
{
field.setLength( 20 );
field.setPrecision( 6 );
@ -202,7 +202,7 @@ QVariantMap QgsJoinByLocationSummaryAlgorithm::processAlgorithm( const QVariantM
struct FieldStatistic
{
FieldStatistic( int enumIndex, const QString &name, QVariant::Type type )
FieldStatistic( int enumIndex, const QString &name, QMetaType::Type type )
: enumIndex( enumIndex )
, name( name )
, type( type )
@ -210,45 +210,45 @@ QVariantMap QgsJoinByLocationSummaryAlgorithm::processAlgorithm( const QVariantM
int enumIndex = 0;
QString name;
QVariant::Type type;
QMetaType::Type type;
};
static const QVector< FieldStatistic > sNumericStats
{
FieldStatistic( 0, QStringLiteral( "count" ), QVariant::LongLong ),
FieldStatistic( 1, QStringLiteral( "unique" ), QVariant::LongLong ),
FieldStatistic( 2, QStringLiteral( "min" ), QVariant::Double ),
FieldStatistic( 3, QStringLiteral( "max" ), QVariant::Double ),
FieldStatistic( 4, QStringLiteral( "range" ), QVariant::Double ),
FieldStatistic( 5, QStringLiteral( "sum" ), QVariant::Double ),
FieldStatistic( 6, QStringLiteral( "mean" ), QVariant::Double ),
FieldStatistic( 7, QStringLiteral( "median" ), QVariant::Double ),
FieldStatistic( 8, QStringLiteral( "stddev" ), QVariant::Double ),
FieldStatistic( 9, QStringLiteral( "minority" ), QVariant::Double ),
FieldStatistic( 10, QStringLiteral( "majority" ), QVariant::Double ),
FieldStatistic( 11, QStringLiteral( "q1" ), QVariant::Double ),
FieldStatistic( 12, QStringLiteral( "q3" ), QVariant::Double ),
FieldStatistic( 13, QStringLiteral( "iqr" ), QVariant::Double ),
FieldStatistic( 0, QStringLiteral( "count" ), QMetaType::Type::LongLong ),
FieldStatistic( 1, QStringLiteral( "unique" ), QMetaType::Type::LongLong ),
FieldStatistic( 2, QStringLiteral( "min" ), QMetaType::Type::Double ),
FieldStatistic( 3, QStringLiteral( "max" ), QMetaType::Type::Double ),
FieldStatistic( 4, QStringLiteral( "range" ), QMetaType::Type::Double ),
FieldStatistic( 5, QStringLiteral( "sum" ), QMetaType::Type::Double ),
FieldStatistic( 6, QStringLiteral( "mean" ), QMetaType::Type::Double ),
FieldStatistic( 7, QStringLiteral( "median" ), QMetaType::Type::Double ),
FieldStatistic( 8, QStringLiteral( "stddev" ), QMetaType::Type::Double ),
FieldStatistic( 9, QStringLiteral( "minority" ), QMetaType::Type::Double ),
FieldStatistic( 10, QStringLiteral( "majority" ), QMetaType::Type::Double ),
FieldStatistic( 11, QStringLiteral( "q1" ), QMetaType::Type::Double ),
FieldStatistic( 12, QStringLiteral( "q3" ), QMetaType::Type::Double ),
FieldStatistic( 13, QStringLiteral( "iqr" ), QMetaType::Type::Double ),
};
static const QVector< FieldStatistic > sDateTimeStats
{
FieldStatistic( 0, QStringLiteral( "count" ), QVariant::LongLong ),
FieldStatistic( 1, QStringLiteral( "unique" ), QVariant::LongLong ),
FieldStatistic( 14, QStringLiteral( "empty" ), QVariant::LongLong ),
FieldStatistic( 15, QStringLiteral( "filled" ), QVariant::LongLong ),
FieldStatistic( 2, QStringLiteral( "min" ), QVariant::Invalid ),
FieldStatistic( 3, QStringLiteral( "max" ), QVariant::Invalid ),
FieldStatistic( 0, QStringLiteral( "count" ), QMetaType::Type::LongLong ),
FieldStatistic( 1, QStringLiteral( "unique" ), QMetaType::Type::LongLong ),
FieldStatistic( 14, QStringLiteral( "empty" ), QMetaType::Type::LongLong ),
FieldStatistic( 15, QStringLiteral( "filled" ), QMetaType::Type::LongLong ),
FieldStatistic( 2, QStringLiteral( "min" ), QMetaType::Type::UnknownType ),
FieldStatistic( 3, QStringLiteral( "max" ), QMetaType::Type::UnknownType ),
};
static const QVector< FieldStatistic > sStringStats
{
FieldStatistic( 0, QStringLiteral( "count" ), QVariant::LongLong ),
FieldStatistic( 1, QStringLiteral( "unique" ), QVariant::LongLong ),
FieldStatistic( 14, QStringLiteral( "empty" ), QVariant::LongLong ),
FieldStatistic( 15, QStringLiteral( "filled" ), QVariant::LongLong ),
FieldStatistic( 2, QStringLiteral( "min" ), QVariant::Invalid ),
FieldStatistic( 3, QStringLiteral( "max" ), QVariant::Invalid ),
FieldStatistic( 16, QStringLiteral( "min_length" ), QVariant::Int ),
FieldStatistic( 17, QStringLiteral( "max_length" ), QVariant::Int ),
FieldStatistic( 18, QStringLiteral( "mean_length" ), QVariant::Double ),
FieldStatistic( 0, QStringLiteral( "count" ), QMetaType::Type::LongLong ),
FieldStatistic( 1, QStringLiteral( "unique" ), QMetaType::Type::LongLong ),
FieldStatistic( 14, QStringLiteral( "empty" ), QMetaType::Type::LongLong ),
FieldStatistic( 15, QStringLiteral( "filled" ), QMetaType::Type::LongLong ),
FieldStatistic( 2, QStringLiteral( "min" ), QMetaType::Type::UnknownType ),
FieldStatistic( 3, QStringLiteral( "max" ), QMetaType::Type::UnknownType ),
FieldStatistic( 16, QStringLiteral( "min_length" ), QMetaType::Type::Int ),
FieldStatistic( 17, QStringLiteral( "max_length" ), QMetaType::Type::Int ),
FieldStatistic( 18, QStringLiteral( "mean_length" ), QMetaType::Type::Double ),
};
for ( const QString &field : std::as_const( joinedFieldNames ) )
@ -265,9 +265,9 @@ QVariantMap QgsJoinByLocationSummaryAlgorithm::processAlgorithm( const QVariantM
fieldTypes.append( FieldType::Numeric );
statisticList = sNumericStats;
}
else if ( joinField.type() == QVariant::Date
|| joinField.type() == QVariant::Time
|| joinField.type() == QVariant::DateTime )
else if ( joinField.type() == QMetaType::Type::QDate
|| joinField.type() == QMetaType::Type::QTime
|| joinField.type() == QMetaType::Type::QDateTime )
{
fieldTypes.append( FieldType::DateTime );
statisticList = sDateTimeStats;
@ -282,7 +282,7 @@ QVariantMap QgsJoinByLocationSummaryAlgorithm::processAlgorithm( const QVariantM
{
if ( summaries.contains( statistic.enumIndex ) )
{
if ( statistic.type != QVariant::Invalid )
if ( statistic.type != QMetaType::Type::UnknownType )
addFieldWithType( joinField, statistic.name, statistic.type );
else
addFieldKeepType( joinField, statistic.name );

12
src/analysis/processing/qgsalgorithmjoinbynearest.cpp
View File

@ -171,12 +171,12 @@ QVariantMap QgsJoinByNearestAlgorithm::processAlgorithm( const QVariantMap &para
QgsFields outFields = QgsProcessingUtils::combineFields( input->fields(), outFields2 );
QgsFields resultFields;
resultFields.append( QgsField( QStringLiteral( "n" ), QVariant::Int ) );
resultFields.append( QgsField( QStringLiteral( "distance" ), QVariant::Double ) );
resultFields.append( QgsField( QStringLiteral( "feature_x" ), QVariant::Double ) );
resultFields.append( QgsField( QStringLiteral( "feature_y" ), QVariant::Double ) );
resultFields.append( QgsField( QStringLiteral( "nearest_x" ), QVariant::Double ) );
resultFields.append( QgsField( QStringLiteral( "nearest_y" ), QVariant::Double ) );
resultFields.append( QgsField( QStringLiteral( "n" ), QMetaType::Type::Int ) );
resultFields.append( QgsField( QStringLiteral( "distance" ), QMetaType::Type::Double ) );
resultFields.append( QgsField( QStringLiteral( "feature_x" ), QMetaType::Type::Double ) );
resultFields.append( QgsField( QStringLiteral( "feature_y" ), QMetaType::Type::Double ) );
resultFields.append( QgsField( QStringLiteral( "nearest_x" ), QMetaType::Type::Double ) );
resultFields.append( QgsField( QStringLiteral( "nearest_y" ), QMetaType::Type::Double ) );
outFields = QgsProcessingUtils::combineFields( outFields, resultFields );
QString dest;

4
src/analysis/processing/qgsalgorithmkmeansclustering.cpp
View File

@ -88,9 +88,9 @@ QVariantMap QgsKMeansClusteringAlgorithm::processAlgorithm( const QVariantMap &p
QgsFields outputFields = source->fields();
QgsFields newFields;
const QString clusterFieldName = parameterAsString( parameters, QStringLiteral( "FIELD_NAME" ), context );
newFields.append( QgsField( clusterFieldName, QVariant::Int ) );
newFields.append( QgsField( clusterFieldName, QMetaType::Type::Int ) );
const QString clusterSizeFieldName = parameterAsString( parameters, QStringLiteral( "SIZE_FIELD_NAME" ), context );
newFields.append( QgsField( clusterSizeFieldName, QVariant::Int ) );
newFields.append( QgsField( clusterSizeFieldName, QMetaType::Type::Int ) );
outputFields = QgsProcessingUtils::combineFields( outputFields, newFields );
QString dest;

4
src/analysis/processing/qgsalgorithmmeancoordinates.cpp
View File

@ -98,8 +98,8 @@ QVariantMap QgsMeanCoordinatesAlgorithm::processAlgorithm( const QVariantMap &pa
}
QgsFields fields;
fields.append( QgsField( QStringLiteral( "MEAN_X" ), QVariant::Double, QString(), 24, 15 ) );
fields.append( QgsField( QStringLiteral( "MEAN_Y" ), QVariant::Double, QString(), 24, 15 ) );
fields.append( QgsField( QStringLiteral( "MEAN_X" ), QMetaType::Type::Double, QString(), 24, 15 ) );
fields.append( QgsField( QStringLiteral( "MEAN_Y" ), QMetaType::Type::Double, QString(), 24, 15 ) );
if ( uniqueFieldIndex >= 0 )
{
const QgsField uniqueField = source->fields().at( uniqueFieldIndex );

8
src/analysis/processing/qgsalgorithmmergevector.cpp
View File

@ -165,8 +165,8 @@ QVariantMap QgsMergeVectorAlgorithm::processAlgorithm( const QVariantMap &parame
feedback->pushWarning( QObject::tr( "%1 field in layer %2 has different data type than the destination layer (%3 instead of %4). "
"%1 field will be converted to string type." )
.arg( sourceField.name(), layerName, sourceField.typeName(), destField.typeName() ) );
destField.setType( QVariant::String );
destField.setSubType( QVariant::Invalid );
destField.setType( QMetaType::Type::QString );
destField.setSubType( QMetaType::Type::UnknownType );
destField.setLength( 0 );
destField.setPrecision( 0 );
}
@ -182,13 +182,13 @@ QVariantMap QgsMergeVectorAlgorithm::processAlgorithm( const QVariantMap &parame
bool addLayerField = false;
if ( outputFields.lookupField( QStringLiteral( "layer" ) ) < 0 )
{
outputFields.append( QgsField( QStringLiteral( "layer" ), QVariant::String, QString() ) );
outputFields.append( QgsField( QStringLiteral( "layer" ), QMetaType::Type::QString, QString() ) );
addLayerField = true;
}
bool addPathField = false;
if ( outputFields.lookupField( QStringLiteral( "path" ) ) < 0 )
{
outputFields.append( QgsField( QStringLiteral( "path" ), QVariant::String, QString() ) );
outputFields.append( QgsField( QStringLiteral( "path" ), QMetaType::Type::QString, QString() ) );
addPathField = true;
}

4
src/analysis/processing/qgsalgorithmminimumenclosingcircle.cpp
View File

@ -88,8 +88,8 @@ bool QgsMinimumEnclosingCircleAlgorithm::supportInPlaceEdit( const QgsMapLayer *
QgsFields QgsMinimumEnclosingCircleAlgorithm::outputFields( const QgsFields &inputFields ) const
{
QgsFields fields = inputFields;
fields.append( QgsField( QStringLiteral( "radius" ), QVariant::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "area" ), QVariant::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "radius" ), QMetaType::Type::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "area" ), QMetaType::Type::Double, QString(), 20, 6 ) );
return fields;
}

4
src/analysis/processing/qgsalgorithmmultiringconstantbuffer.cpp
View File

@ -108,8 +108,8 @@ bool QgsMultiRingConstantBufferAlgorithm::prepareAlgorithm( const QVariantMap &p
QgsFields QgsMultiRingConstantBufferAlgorithm::outputFields( const QgsFields &inputFields ) const
{
QgsFields fields = inputFields;
fields.append( QgsField( QStringLiteral( "ringId" ), QVariant::Int, QString(), 10, 0 ) );
fields.append( QgsField( QStringLiteral( "distance" ), QVariant::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "ringId" ), QMetaType::Type::Int, QString(), 10, 0 ) );
fields.append( QgsField( QStringLiteral( "distance" ), QMetaType::Type::Double, QString(), 20, 6 ) );
return fields;
}

10
src/analysis/processing/qgsalgorithmorientedminimumboundingbox.cpp
View File

@ -82,11 +82,11 @@ bool QgsOrientedMinimumBoundingBoxAlgorithm::supportInPlaceEdit( const QgsMapLay
QgsFields QgsOrientedMinimumBoundingBoxAlgorithm::outputFields( const QgsFields &inputFields ) const
{
QgsFields fields = inputFields;
fields.append( QgsField( QStringLiteral( "width" ), QVariant::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "height" ), QVariant::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "angle" ), QVariant::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "area" ), QVariant::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "perimeter" ), QVariant::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "width" ), QMetaType::Type::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "height" ), QMetaType::Type::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "angle" ), QMetaType::Type::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "area" ), QMetaType::Type::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "perimeter" ), QMetaType::Type::Double, QString(), 20, 6 ) );
return fields;
}

10
src/analysis/processing/qgsalgorithmpackage.cpp
View File

@ -437,13 +437,13 @@ bool QgsPackageAlgorithm::packageVectorLayer( QgsVectorLayer *layer, const QStri
options.attributes = fields.allAttributesList();
if ( fidIndex >= 0 )
{
const QVariant::Type fidType { layer->fields().field( fidIndex ).type() };
const QMetaType::Type fidType { layer->fields().field( fidIndex ).type() };
if ( ! layer->fieldConstraints( fidIndex ).testFlag( QgsFieldConstraints::Constraint::ConstraintUnique )
&& ! layer->fieldConstraints( fidIndex ).testFlag( QgsFieldConstraints::Constraint::ConstraintNotNull )
&& fidType != QVariant::Int
&& fidType != QVariant::UInt
&& fidType != QVariant::LongLong
&& fidType != QVariant::ULongLong )
&& fidType != QMetaType::Type::Int
&& fidType != QMetaType::Type::UInt
&& fidType != QMetaType::Type::LongLong
&& fidType != QMetaType::Type::ULongLong )
{
options.attributes.removeAll( fidIndex );
}

6
src/analysis/processing/qgsalgorithmpixelcentroidsfrompolygons.cpp
View File

@ -77,9 +77,9 @@ QVariantMap QgsPixelCentroidsFromPolygonsAlgorithm::processAlgorithm( const QVar
throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "INPUT_VECTOR" ) ) );
QgsFields fields;
fields.append( QgsField( QStringLiteral( "id" ), QVariant::LongLong ) );
fields.append( QgsField( QStringLiteral( "poly_id" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "point_id" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "id" ), QMetaType::Type::LongLong ) );
fields.append( QgsField( QStringLiteral( "poly_id" ), QMetaType::Type::Int ) );
fields.append( QgsField( QStringLiteral( "point_id" ), QMetaType::Type::Int ) );
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::Point, rasterLayer->crs(), QgsFeatureSink::RegeneratePrimaryKey ) );

4
src/analysis/processing/qgsalgorithmpointsalonggeometry.cpp
View File

@ -89,8 +89,8 @@ Qgis::WkbType QgsPointsAlongGeometryAlgorithm::outputWkbType( Qgis::WkbType inpu
QgsFields QgsPointsAlongGeometryAlgorithm::outputFields( const QgsFields &inputFields ) const
{
QgsFields output = inputFields;
output.append( QgsField( QStringLiteral( "distance" ), QVariant::Double ) );
output.append( QgsField( QStringLiteral( "angle" ), QVariant::Double ) );
output.append( QgsField( QStringLiteral( "distance" ), QMetaType::Type::Double ) );
output.append( QgsField( QStringLiteral( "angle" ), QMetaType::Type::Double ) );
return output;
}

2
src/analysis/processing/qgsalgorithmpointsinpolygon.cpp
View File

@ -255,7 +255,7 @@ QgsFields QgsPointsInPolygonAlgorithm::outputFields( const QgsFields &inputField
QgsFields outFields = inputFields;
mDestFieldIndex = inputFields.lookupField( mFieldName );
if ( mDestFieldIndex < 0 )
outFields.append( QgsField( mFieldName, QVariant::Double ) );
outFields.append( QgsField( mFieldName, QMetaType::Type::Double ) );
mFields = outFields;
return outFields;

2
src/analysis/processing/qgsalgorithmpointstopaths.cpp
View File

@ -166,7 +166,7 @@ QVariantMap QgsPointsToPathsAlgorithm::processAlgorithm( const QVariantMap &para
QStringList requiredFields = QStringList( orderExpression.referencedColumns().values() );
orderExpression.prepare( &expressionContext );
QVariant::Type orderFieldType = QVariant::String;
QMetaType::Type orderFieldType = QMetaType::Type::QString;
if ( orderExpression.isField() )
{
const int orderFieldIndex = source->fields().indexFromName( orderExpression.referencedColumns().values().first() );

2
src/analysis/processing/qgsalgorithmpointtolayer.cpp
View File

@ -48,7 +48,7 @@ QVariantMap QgsPointToLayerAlgorithm::processAlgorithm( const QVariantMap &param
const QgsGeometry geom = QgsGeometry::fromPointXY( parameterAsPoint( parameters, QStringLiteral( "INPUT" ), context ) );
QgsFields fields;
fields.append( QgsField( QStringLiteral( "id" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "id" ), QMetaType::Type::Int ) );
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::Point, crs ) );

2
src/analysis/processing/qgsalgorithmpoleofinaccessibility.cpp
View File

@ -92,7 +92,7 @@ Qgis::WkbType QgsPoleOfInaccessibilityAlgorithm::outputWkbType( Qgis::WkbType in
QgsFields QgsPoleOfInaccessibilityAlgorithm::outputFields( const QgsFields &inputFields ) const
{
QgsFields outputFields = inputFields;
outputFields.append( QgsField( QStringLiteral( "dist_pole" ), QVariant::Double ) );
outputFields.append( QgsField( QStringLiteral( "dist_pole" ), QMetaType::Type::Double ) );
return outputFields;
}

2
src/analysis/processing/qgsalgorithmrandompointsextent.cpp
View File

@ -96,7 +96,7 @@ QVariantMap QgsRandomPointsExtentAlgorithm::processAlgorithm( const QVariantMap
{
QgsFields fields = QgsFields();
fields.append( QgsField( QStringLiteral( "id" ), QVariant::LongLong ) );
fields.append( QgsField( QStringLiteral( "id" ), QMetaType::Type::LongLong ) );
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::Point, mCrs ) );

2
src/analysis/processing/qgsalgorithmrandompointsinpolygons.cpp
View File

@ -185,7 +185,7 @@ QVariantMap QgsRandomPointsInPolygonsAlgorithm::processAlgorithm( const QVariant
throw QgsProcessingException( invalidSourceError( parameters, INPUT ) );
QgsFields fields;
fields.append( QgsField( QStringLiteral( "rand_point_id" ), QVariant::LongLong ) );
fields.append( QgsField( QStringLiteral( "rand_point_id" ), QMetaType::Type::LongLong ) );
if ( mIncludePolygonAttr )
fields.extend( polygonSource->fields() );

2
src/analysis/processing/qgsalgorithmrandompointsonlines.cpp
View File

@ -192,7 +192,7 @@ QVariantMap QgsRandomPointsOnLinesAlgorithm::processAlgorithm( const QVariantMap
throw QgsProcessingException( invalidSourceError( parameters, INPUT ) );
QgsFields fields;
fields.append( QgsField( QStringLiteral( "rand_point_id" ), QVariant::LongLong ) );
fields.append( QgsField( QStringLiteral( "rand_point_id" ), QMetaType::Type::LongLong ) );
if ( mIncludeLineAttr )
fields.extend( lineSource->fields() );

6
src/analysis/processing/qgsalgorithmrasterlayeruniquevalues.cpp
View File

@ -114,9 +114,9 @@ QVariantMap QgsRasterLayerUniqueValuesReportAlgorithm::processAlgorithm( const Q
if ( parameters.contains( QStringLiteral( "OUTPUT_TABLE" ) ) && parameters.value( QStringLiteral( "OUTPUT_TABLE" ) ).isValid() )
{
QgsFields outFields;
outFields.append( QgsField( QStringLiteral( "value" ), QVariant::Double, QString(), 20, 8 ) );
outFields.append( QgsField( QStringLiteral( "count" ), QVariant::LongLong, QString(), 20 ) );
outFields.append( QgsField( areaUnit.replace( QStringLiteral( "²" ), QStringLiteral( "2" ) ), QVariant::Double, QString(), 20, 8 ) );
outFields.append( QgsField( QStringLiteral( "value" ), QMetaType::Type::Double, QString(), 20, 8 ) );
outFields.append( QgsField( QStringLiteral( "count" ), QMetaType::Type::LongLong, QString(), 20 ) );
outFields.append( QgsField( areaUnit.replace( QStringLiteral( "²" ), QStringLiteral( "2" ) ), QQMetaType::Type::Double QString(), 20, 8 ) );
sink.reset( parameterAsSink( parameters, QStringLiteral( "OUTPUT_TABLE" ), context, tableDest, outFields, Qgis::WkbType::NoGeometry, QgsCoordinateReferenceSystem() ) );
if ( !sink )
throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT_TABLE" ) ) );

2
src/analysis/processing/qgsalgorithmrastersampling.cpp
View File

@ -98,7 +98,7 @@ QVariantMap QgsRasterSamplingAlgorithm::processAlgorithm( const QVariantMap &par
const bool intSafe = ( dataType == Qgis::DataType::Byte || dataType == Qgis::DataType::UInt16 || dataType == Qgis::DataType::Int16 || dataType == Qgis::DataType::UInt32 ||
dataType == Qgis::DataType::Int32 || dataType == Qgis::DataType::CInt16 || dataType == Qgis::DataType::CInt32 );
newFields.append( QgsField( QStringLiteral( "%1%2" ).arg( fieldPrefix, QString::number( band ) ), intSafe ? QVariant::Int : QVariant::Double ) );
newFields.append( QgsField( QStringLiteral( "%1%2" ).arg( fieldPrefix, QString::number( band ) ), intSafe ? QMetaType::Type::Int : QMetaType::Type::Double ) );
emptySampleAttributes += QVariant();
}
const QgsFields fields = QgsProcessingUtils::combineFields( source->fields(), newFields );

6
src/analysis/processing/qgsalgorithmrastersurfacevolume.cpp
View File

@ -138,9 +138,9 @@ QVariantMap QgsRasterSurfaceVolumeAlgorithm::processAlgorithm( const QVariantMap
if ( parameters.contains( QStringLiteral( "OUTPUT_TABLE" ) ) && parameters.value( QStringLiteral( "OUTPUT_TABLE" ) ).isValid() )
{
QgsFields outFields;
outFields.append( QgsField( QStringLiteral( "volume" ), QVariant::Double, QString(), 20, 8 ) );
outFields.append( QgsField( areaUnit.replace( QStringLiteral( "²" ), QStringLiteral( "2" ) ), QVariant::Double, QString(), 20, 8 ) );
outFields.append( QgsField( QStringLiteral( "pixel_count" ), QVariant::LongLong ) );
outFields.append( QgsField( QStringLiteral( "volume" ), QMetaType::Type::Double, QString(), 20, 8 ) );
outFields.append( QgsField( areaUnit.replace( QStringLiteral( "²" ), QStringLiteral( "2" ) ), QQMetaType::Type::Double QString(), 20, 8 ) );
outFields.append( QgsField( QStringLiteral( "pixel_count" ), QMetaType::Type::LongLong ) );
sink.reset( parameterAsSink( parameters, QStringLiteral( "OUTPUT_TABLE" ), context, tableDest, outFields, Qgis::WkbType::NoGeometry, QgsCoordinateReferenceSystem() ) );
if ( !sink )
throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT_TABLE" ) ) );

14
src/analysis/processing/qgsalgorithmrasterzonalstats.cpp
View File

@ -177,13 +177,13 @@ QVariantMap QgsRasterLayerZonalStatsAlgorithm::processAlgorithm( const QVariantM
if ( parameters.contains( QStringLiteral( "OUTPUT_TABLE" ) ) && parameters.value( QStringLiteral( "OUTPUT_TABLE" ) ).isValid() )
{
QgsFields outFields;
outFields.append( QgsField( QStringLiteral( "zone" ), QVariant::Double, QString(), 20, 8 ) );
outFields.append( QgsField( areaUnit.isEmpty() ? "area" : areaUnit.replace( QStringLiteral( "²" ), QStringLiteral( "2" ) ), QVariant::Double, QString(), 20, 8 ) );
outFields.append( QgsField( QStringLiteral( "sum" ), QVariant::Double, QString(), 20, 8 ) );
outFields.append( QgsField( QStringLiteral( "count" ), QVariant::LongLong, QString(), 20 ) );
outFields.append( QgsField( QStringLiteral( "min" ), QVariant::Double, QString(), 20, 8 ) );
outFields.append( QgsField( QStringLiteral( "max" ), QVariant::Double, QString(), 20, 8 ) );
outFields.append( QgsField( QStringLiteral( "mean" ), QVariant::Double, QString(), 20, 8 ) );
outFields.append( QgsField( QStringLiteral( "zone" ), QMetaType::Type::Double, QString(), 20, 8 ) );
outFields.append( QgsField( areaUnit.isEmpty() ? "area" : areaUnit.replace( QStringLiteral( "²" ), QStringLiteral( "2" ) ), QQMetaType::Type::Double QString(), 20, 8 ) );
outFields.append( QgsField( QStringLiteral( "sum" ), QMetaType::Type::Double, QString(), 20, 8 ) );
outFields.append( QgsField( QStringLiteral( "count" ), QMetaType::Type::LongLong, QString(), 20 ) );
outFields.append( QgsField( QStringLiteral( "min" ), QMetaType::Type::Double, QString(), 20, 8 ) );
outFields.append( QgsField( QStringLiteral( "max" ), QMetaType::Type::Double, QString(), 20, 8 ) );
outFields.append( QgsField( QStringLiteral( "mean" ), QMetaType::Type::Double, QString(), 20, 8 ) );
sink.reset( parameterAsSink( parameters, QStringLiteral( "OUTPUT_TABLE" ), context, tableDest, outFields, Qgis::WkbType::NoGeometry, QgsCoordinateReferenceSystem() ) );
if ( !sink )

4
src/analysis/processing/qgsalgorithmrefactorfields.cpp
View File

@ -106,9 +106,9 @@ bool QgsRefactorFieldsAlgorithm::prepareAlgorithm( const QVariantMap &parameters
if ( name.isEmpty() )
throw QgsProcessingException( QObject::tr( "Field name cannot be empty" ) );
const QVariant::Type type = static_cast< QVariant::Type >( fieldDef.value( QStringLiteral( "type" ) ).toInt() );
const QMetaType::Type type = static_cast< QMetaType::Type >( fieldDef.value( QStringLiteral( "type" ) ).toInt() );
const QString typeName = fieldDef.value( QStringLiteral( "sub_name" ) ).toString();
const QVariant::Type subType = static_cast< QVariant::Type >( fieldDef.value( QStringLiteral( "sub_type" ) ).toInt() );
const QMetaType::Type subType = static_cast< QMetaType::Type >( fieldDef.value( QStringLiteral( "sub_type" ) ).toInt() );
const int length = fieldDef.value( QStringLiteral( "length" ), 0 ).toInt();
const int precision = fieldDef.value( QStringLiteral( "precision" ), 0 ).toInt();

2
src/analysis/processing/qgsalgorithmroundness.cpp
View File

@ -79,7 +79,7 @@ Qgis::ProcessingSourceType QgsRoundnessAlgorithm::outputLayerType() const
QgsFields QgsRoundnessAlgorithm::outputFields( const QgsFields &inputFields ) const
{
QgsFields outputFields = inputFields;
outputFields.append( QgsField( QStringLiteral( "roundness" ), QVariant::Double ) );
outputFields.append( QgsField( QStringLiteral( "roundness" ), QMetaType::Type::Double ) );
return outputFields;
}

4
src/analysis/processing/qgsalgorithmserviceareafromlayer.cpp
View File

@ -123,8 +123,8 @@ QVariantMap QgsServiceAreaFromLayerAlgorithm::processAlgorithm( const QVariantMa
std::unique_ptr< QgsGraph > graph( mBuilder->takeGraph() );
QgsFields fields = startPoints->fields();
fields.append( QgsField( QStringLiteral( "type" ), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "start" ), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "type" ), QMetaType::Type::QString ) );
fields.append( QgsField( QStringLiteral( "start" ), QMetaType::Type::QString ) );
QString pointsSinkId;
std::unique_ptr< QgsFeatureSink > pointsSink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, pointsSinkId, fields,

4
src/analysis/processing/qgsalgorithmserviceareafrompoint.cpp
View File

@ -195,8 +195,8 @@ QVariantMap QgsServiceAreaFromPointAlgorithm::processAlgorithm( const QVariantMa
QVariantMap outputs;
QgsFields fields;
fields.append( QgsField( QStringLiteral( "type" ), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "start" ), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "type" ), QMetaType::Type::QString ) );
fields.append( QgsField( QStringLiteral( "start" ), QMetaType::Type::QString ) );
QgsFeature feat;
feat.setFields( fields );

2
src/analysis/processing/qgsalgorithmshortestline.cpp
View File

@ -107,7 +107,7 @@ QVariantMap QgsShortestLineAlgorithm::processAlgorithm( const QVariantMap &param
mKNeighbors = mDestination->featureCount();
QgsFields fields = QgsProcessingUtils::combineFields( mSource->fields(), mDestination->fields() );
fields.append( QgsField( QStringLiteral( "distance" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "distance" ), QMetaType::Type::Double ) );
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::MultiLineString, mSource->sourceCrs() ) );

6
src/analysis/processing/qgsalgorithmshortestpathlayertopoint.cpp
View File

@ -79,9 +79,9 @@ QVariantMap QgsShortestPathLayerToPointAlgorithm::processAlgorithm( const QVaria
throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "START_POINTS" ) ) );
QgsFields fields = startPoints->fields();
fields.append( QgsField( QStringLiteral( "start" ), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "end" ), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "cost" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "start" ), QMetaType::Type::QString ) );
fields.append( QgsField( QStringLiteral( "end" ), QMetaType::Type::QString ) );
fields.append( QgsField( QStringLiteral( "cost" ), QMetaType::Type::Double ) );
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::LineString, mNetwork->sourceCrs() ) );

6
src/analysis/processing/qgsalgorithmshortestpathpointtolayer.cpp
View File

@ -79,9 +79,9 @@ QVariantMap QgsShortestPathPointToLayerAlgorithm::processAlgorithm( const QVaria
throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "END_POINTS" ) ) );
QgsFields fields = endPoints->fields();
fields.append( QgsField( QStringLiteral( "start" ), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "end" ), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "cost" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "start" ), QMetaType::Type::QString ) );
fields.append( QgsField( QStringLiteral( "end" ), QMetaType::Type::QString ) );
fields.append( QgsField( QStringLiteral( "cost" ), QMetaType::Type::Double ) );
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::LineString, mNetwork->sourceCrs(), QgsFeatureSink::RegeneratePrimaryKey ) );

6
src/analysis/processing/qgsalgorithmshortestpathpointtopoint.cpp
View File

@ -67,9 +67,9 @@ QVariantMap QgsShortestPathPointToPointAlgorithm::processAlgorithm( const QVaria
loadCommonParams( parameters, context, feedback );
QgsFields fields;
fields.append( QgsField( QStringLiteral( "start" ), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "end" ), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "cost" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "start" ), QMetaType::Type::QString ) );
fields.append( QgsField( QStringLiteral( "end" ), QMetaType::Type::QString ) );
fields.append( QgsField( QStringLiteral( "cost" ), QMetaType::Type::Double ) );
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::LineString, mNetwork->sourceCrs() ) );

2
src/analysis/processing/qgsalgorithmsplitfeaturesbyattributecharacter.cpp
View File

@ -101,7 +101,7 @@ QgsFields QgsSplitFeaturesByAttributeCharacterAlgorithm::outputFields( const Qgs
else
{
// we need to convert the split field to a string field
outputFields.append( QgsField( inputFields.at( i ).name(), QVariant::String ) );
outputFields.append( QgsField( inputFields.at( i ).name(), QMetaType::Type::QString ) );
}
}
return outputFields;

4
src/analysis/processing/qgsalgorithmsumlinelength.cpp
View File

@ -159,11 +159,11 @@ QgsFields QgsSumLineLengthAlgorithm::outputFields( const QgsFields &inputFields
QgsFields outFields = inputFields;
mLengthFieldIndex = inputFields.lookupField( mLengthFieldName );
if ( mLengthFieldIndex < 0 )
outFields.append( QgsField( mLengthFieldName, QVariant::Double ) );
outFields.append( QgsField( mLengthFieldName, QMetaType::Type::Double ) );
mCountFieldIndex = inputFields.lookupField( mCountFieldName );
if ( mCountFieldIndex < 0 )
outFields.append( QgsField( mCountFieldName, QVariant::Double ) );
outFields.append( QgsField( mCountFieldName, QMetaType::Type::Double ) );
mFields = outFields;
return outFields;

4
src/analysis/processing/qgsalgorithmtinmeshcreation.cpp
View File

@ -88,7 +88,7 @@ void QgsTinMeshCreationAlgorithm::initAlgorithm( const QVariantMap &configuratio
bool QgsTinMeshCreationAlgorithm::prepareAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
{
const QVariant layersVariant = parameters.value( parameterDefinition( QStringLiteral( "SOURCE_DATA" ) )->name() );
if ( layersVariant.type() != QVariant::List )
if ( layersVariant.userType() != QMetaType::Type::QVariantList )
return false;
const QVariantList layersList = layersVariant.toList();
@ -102,7 +102,7 @@ bool QgsTinMeshCreationAlgorithm::prepareAlgorithm( const QVariantMap &parameter
if ( feedback && feedback->isCanceled() )
return false;
if ( layer.type() != QVariant::Map )
if ( layer.userType() != QMetaType::Type::QVariantMap )
continue;
const QVariantMap layerMap = layer.toMap();
const QString layerSource = layerMap.value( QStringLiteral( "source" ) ).toString();

12
src/analysis/processing/qgsalgorithmtransect.cpp
View File

@ -116,12 +116,12 @@ QVariantMap QgsTransectAlgorithm::processAlgorithm( const QVariantMap &parameter
QgsFields fields = source->fields();
fields.append( QgsField( QStringLiteral( "TR_FID" ), QVariant::Int, QString(), 20 ) );
fields.append( QgsField( QStringLiteral( "TR_ID" ), QVariant::Int, QString(), 20 ) );
fields.append( QgsField( QStringLiteral( "TR_SEGMENT" ), QVariant::Int, QString(), 20 ) );
fields.append( QgsField( QStringLiteral( "TR_ANGLE" ), QVariant::Double, QString(), 5, 2 ) );
fields.append( QgsField( QStringLiteral( "TR_LENGTH" ), QVariant::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "TR_ORIENT" ), QVariant::Int, QString(), 1 ) );
fields.append( QgsField( QStringLiteral( "TR_FID" ), QMetaType::Type::Int, QString(), 20 ) );
fields.append( QgsField( QStringLiteral( "TR_ID" ), QMetaType::Type::Int, QString(), 20 ) );
fields.append( QgsField( QStringLiteral( "TR_SEGMENT" ), QMetaType::Type::Int, QString(), 20 ) );
fields.append( QgsField( QStringLiteral( "TR_ANGLE" ), QMetaType::Type::Double, QString(), 5, 2 ) );
fields.append( QgsField( QStringLiteral( "TR_LENGTH" ), QMetaType::Type::Double, QString(), 20, 6 ) );
fields.append( QgsField( QStringLiteral( "TR_ORIENT" ), QMetaType::Type::Int, QString(), 1 ) );
Qgis::WkbType outputWkb = Qgis::WkbType::LineString;
if ( QgsWkbTypes::hasZ( source->wkbType() ) )

2
src/analysis/processing/qgsalgorithmuniquevalueindex.cpp
View File

@ -84,7 +84,7 @@ QVariantMap QgsAddUniqueValueIndexAlgorithm::processAlgorithm( const QVariantMap
const QString newFieldName = parameterAsString( parameters, QStringLiteral( "FIELD_NAME" ), context );
QgsFields fields = source->fields();
const QgsField newField = QgsField( newFieldName, QVariant::Int );
const QgsField newField = QgsField( newFieldName, QMetaType::Type::Int );
fields.append( newField );
QString dest;

2
src/analysis/processing/qgsalgorithmvectorize.cpp
View File

@ -69,7 +69,7 @@ QVariantMap QgsVectorizeAlgorithmBase::processAlgorithm( const QVariantMap &para
{
const QString fieldName = parameterAsString( parameters, QStringLiteral( "FIELD_NAME" ), context );
QgsFields fields;
fields.append( QgsField( fieldName, QVariant::Double, QString(), 20, 8 ) );
fields.append( QgsField( fieldName, QMetaType::Type::Double, QString(), 20, 8 ) );
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, sinkType(), mCrs ) );

2
src/analysis/processing/qgsalgorithmvoronoipolygons.cpp
View File

@ -197,7 +197,7 @@ QString QgsVoronoiPolygonsAlgorithm::voronoiWithAttributes( const QVariantMap &p
QString QgsVoronoiPolygonsAlgorithm::voronoiWithoutAttributes( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
{
QgsFields fields;
fields.append( QgsField( QStringLiteral( "id" ), QVariant::LongLong ) );
fields.append( QgsField( QStringLiteral( "id" ), QMetaType::Type::LongLong ) );
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::Polygon, mSource->sourceCrs() ) );

2
src/analysis/processing/qgsalgorithmzonalhistogram.cpp
View File

@ -170,7 +170,7 @@ QVariantMap QgsZonalHistogramAlgorithm::processAlgorithm( const QVariantMap &par
QgsFields newFields;
for ( auto it = uniqueValues.constBegin(); it != uniqueValues.constEnd(); ++it )
{
newFields.append( QgsField( QStringLiteral( "%1%2" ).arg( fieldPrefix, mHasNoDataValue && *it == mNodataValue ? QStringLiteral( "NODATA" ) : QString::number( *it ) ), QVariant::LongLong, QString(), -1, 0 ) );
newFields.append( QgsField( QStringLiteral( "%1%2" ).arg( fieldPrefix, mHasNoDataValue && *it == mNodataValue ? QStringLiteral( "NODATA" ) : QString::number( *it ) ), QMetaType::Type::LongLong, QString(), -1, 0 ) );
}
const QgsFields fields = QgsProcessingUtils::combineFields( zones->fields(), newFields );

2
src/analysis/processing/qgsalgorithmzonalstatisticsfeaturebased.cpp
View File

@ -144,7 +144,7 @@ bool QgsZonalStatisticsFeatureBasedAlgorithm::prepareAlgorithm( const QVariantMa
{
if ( mStats & stat )
{
const QgsField field = QgsField( mPrefix + QgsZonalStatistics::shortName( stat ), QVariant::Double, QStringLiteral( "double precision" ) );
const QgsField field = QgsField( mPrefix + QgsZonalStatistics::shortName( stat ), QMetaType::Type::Double, QStringLiteral( "double precision" ) );
if ( mOutputFields.names().contains( field.name() ) )
{
throw QgsProcessingException( QObject::tr( "Field %1 already exists" ).arg( field.name() ) );

4
src/analysis/processing/qgsbookmarkalgorithms.cpp
View File

@ -108,8 +108,8 @@ QVariantMap QgsBookmarksToLayerAlgorithm::processAlgorithm( const QVariantMap &p
{
const QgsCoordinateReferenceSystem crs = parameterAsCrs( parameters, QStringLiteral( "CRS" ), context );
QgsFields fields;
fields.append( QgsField( QStringLiteral( "name" ), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "group" ), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "name" ), QMetaType::Type::QString ) );
fields.append( QgsField( QStringLiteral( "group" ), QMetaType::Type::QString ) );
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, Qgis::WkbType::Polygon, crs ) );
if ( !sink )

2
src/analysis/vector/qgszonalstatistics.cpp
View File

@ -100,7 +100,7 @@ Qgis::ZonalStatisticResult QgsZonalStatistics::calculateStatistics( QgsFeedback
if ( mStatistics & stat )
{
QString fieldName = getUniqueFieldName( mAttributePrefix + QgsZonalStatistics::shortName( stat ), newFieldList );
QgsField field( fieldName, QVariant::Double, QStringLiteral( "double precision" ) );
QgsField field( fieldName, QMetaType::Type::Double, QStringLiteral( "double precision" ) );
newFieldList.push_back( field );
statFieldIndexes.insert( stat, oldFieldCount + newFieldList.count() - 1 );
}