qgsexpressionutils.cpp

Go to the documentation of this file.

/***************************************************************************
                               qgsexpressionutils.cpp
                             -------------------
    begin                : May 2017
    copyright            : (C) 2017 Matthias Kuhn
    email                : [email protected]
 ***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#include "qgsexpressionutils.h"
 
#include <memory>
 
#include "qgscolorrampimpl.h"
#include "qgsproject.h"
#include "qgsproviderregistry.h"
#include "qgssymbollayerutils.h"
#include "qgsvariantutils.h"
#include "qgsvectorlayer.h"
#include "qgsvectorlayerfeatureiterator.h"
 
#include <QString>
 
using namespace Qt::StringLiterals;

 
QgsExpressionUtils::TVL QgsExpressionUtils::AND[3][3] =
{
  // false  true    unknown
  { False, False,   False },   // false
  { False, True,    Unknown }, // true
  { False, Unknown, Unknown }  // unknown
};
QgsExpressionUtils::TVL QgsExpressionUtils::OR[3][3] =
{
  { False,   True, Unknown },  // false
  { True,    True, True },     // true
  { Unknown, True, Unknown }   // unknown
};
 
QgsExpressionUtils::TVL QgsExpressionUtils::NOT[3] = { True, False, Unknown };
 
 
QColor QgsExpressionUtils::getColorValue( const QVariant &value, QgsExpression *parent, bool &isQColor )
{
  isQColor = value.userType() == QMetaType::Type::QColor;
  QColor color = isQColor ? value.value<QColor>() : QgsSymbolLayerUtils::decodeColor( value.toString() );
  if ( ! color.isValid() )
  {
    parent->setEvalErrorString( isQColor ? QObject::tr( "Input color is invalid" )
                                : QObject::tr( "Cannot convert '%1' to color" ).arg( value.toString() ) );
  }
 
  return color;
}
 
QgsGradientColorRamp QgsExpressionUtils::getRamp( const QVariant &value, QgsExpression *parent, bool report_error )
{
  if ( value.userType() == qMetaTypeId<QgsGradientColorRamp>() )
    return value.value<QgsGradientColorRamp>();
 
  // If we get here then we can't convert so we just error and return invalid.
  if ( report_error )
    parent->setEvalErrorString( QObject::tr( "Cannot convert '%1' to gradient ramp" ).arg( value.toString() ) );
 
  return QgsGradientColorRamp();
}
 
QgsMapLayer *QgsExpressionUtils::getMapLayer( const QVariant &value, const QgsExpressionContext *context, QgsExpression *parent )
{
  return getMapLayerPrivate( value, context, parent );
}
 
QgsMapLayer *QgsExpressionUtils::getMapLayerPrivate( const QVariant &value, const QgsExpressionContext *context, QgsExpression * )
{
  // First check if we already received a layer pointer
  QPointer< QgsMapLayer > ml = value.value< QgsWeakMapLayerPointer >().data();
 
  // clang analyzer gets this function absolutely 100% wrong
#ifdef __clang_analyzer__
  ( void )context;
#else
 
  if ( !ml )
  {
    ml = value.value< QgsMapLayer * >();
#ifdef QGISDEBUG
    if ( ml )
    {
      qWarning( "Raw map layer pointer stored in expression evaluation, switch to QgsWeakMapLayerPointer instead" );
    }
#endif
  }
  if ( ml )
    return ml;
 
  const QString identifier = value.toString();
 
  // check through layer stores from context
  if ( context )
  {
    const QList< QgsMapLayerStore * > stores = context->layerStores();
    for ( QgsMapLayerStore *store : stores )
    {
      auto findLayerInStoreFunction = [ storePointer = QPointer< QgsMapLayerStore >( store ), &ml, identifier ]
      {
        if ( QgsMapLayerStore *store = storePointer.data() )
        {
          // look for matching layer by id
          ml = store->mapLayer( identifier );
 
          if ( ml )
            return;
 
          // Still nothing? Check for layer name
          ml = store->mapLayersByName( identifier ).value( 0 );
        }
      };
 
      // Make sure we only deal with the store on the thread where it lives.
      // Anything else risks a crash.
      if ( QThread::currentThread() == store->thread() )
        findLayerInStoreFunction();
      else
        QMetaObject::invokeMethod( store, std::move( findLayerInStoreFunction ), Qt::BlockingQueuedConnection );
      if ( ml )
        return ml;
    }
  }
 
  // last resort - QgsProject instance. This is bad, we need to remove this!
  auto getMapLayerFromProjectInstance = [ &ml, identifier ]
  {
    QgsProject *project = QgsProject::instance(); // skip-keyword-check
 
    // No pointer yet, maybe it's a layer id?
    ml = project->mapLayer( identifier );
    if ( ml )
      return;
 
    // Still nothing? Check for layer name
    ml = project->mapLayersByName( identifier ).value( 0 );
  };
 
  if ( QThread::currentThread() == qApp->thread() )
    getMapLayerFromProjectInstance();
  else
    QMetaObject::invokeMethod( qApp, std::move( getMapLayerFromProjectInstance ), Qt::BlockingQueuedConnection );
#endif
 
  return ml;
}
 
QgsCoordinateReferenceSystem QgsExpressionUtils::getCrsValue( const QVariant &value, QgsExpression *parent )
{
  if ( QgsVariantUtils::isNull( value ) )
  {
    return QgsCoordinateReferenceSystem();
  }
 
  const bool isCrs = value.userType() == qMetaTypeId<QgsCoordinateReferenceSystem>();
 
  if ( !isCrs && value.toString().isEmpty() )
  {
    return QgsCoordinateReferenceSystem();
  }
 
  QgsCoordinateReferenceSystem crs = isCrs ? value.value<QgsCoordinateReferenceSystem>() : QgsCoordinateReferenceSystem( value.toString() );
  if ( !crs.isValid() )
  {
    parent->setEvalErrorString( isCrs ? QObject::tr( "Input CRS is invalid" )
                                : QObject::tr( "Cannot convert '%1' to CRS" ).arg( value.toString() ) );
  }
 
  return crs;
}
 
QTimeZone QgsExpressionUtils::getTimeZoneValue( const QVariant &value, QgsExpression *parent )
{
  if ( QgsVariantUtils::isNull( value ) )
  {
    return QTimeZone();
  }
 
  QTimeZone tz;
  bool isTz = false;
  if ( value.userType() == qMetaTypeId< QTimeZone>() )
  {
    isTz = true;
    tz = value.value<QTimeZone>();
  }
 
  if ( !tz.isValid() )
  {
    parent->setEvalErrorString( isTz ? QObject::tr( "Input time zone is invalid" )
                                : QObject::tr( "Cannot convert '%1' to a time zone" ).arg( value.toString() ) );
  }
  return tz;
}
 
void QgsExpressionUtils::executeLambdaForMapLayer( const QVariant &value, const QgsExpressionContext *context, QgsExpression *expression, const std::function<void ( QgsMapLayer * )> &function, bool &foundLayer )
{
  foundLayer = false;
 
  // clang analyzer gets this function absolutely 100% wrong
#ifndef __clang_analyzer__
 
  // First check if we already received a layer pointer
  QPointer< QgsMapLayer > ml = value.value< QgsWeakMapLayerPointer >().data();
  if ( !ml )
  {
    ml = value.value< QgsMapLayer * >();
#ifdef QGISDEBUG
    if ( ml )
    {
      qWarning( "Raw map layer pointer stored in expression evaluation, switch to QgsWeakMapLayerPointer instead" );
    }
#endif
  }
  if ( ml )
  {
    auto runFunction = [ layerPointer = QPointer< QgsMapLayer >( ml ), &function, &foundLayer ]
    {
      if ( QgsMapLayer *layer = layerPointer.data() )
      {
        foundLayer = true;
        function( layer );
      }
    };
 
    // Make sure we only deal with the layer on the thread where it lives.
    // Anything else risks a crash.
 
    if ( QThread::currentThread() == ml->thread() )
      runFunction();
    else
      QMetaObject::invokeMethod( ml, std::move( runFunction ), Qt::BlockingQueuedConnection );
 
    return;
  }
 
  if ( !context || context->layerStores().empty() )
  {
    // if no layer stores, then this is only for layers in project and therefore associated with the main thread
    auto runFunction = [ value, context, expression, &function, &foundLayer ]
    {
      if ( QgsMapLayer *layer = getMapLayerPrivate( value, context, expression ) )
      {
        foundLayer = true;
        function( layer );
      }
      else
      {
        foundLayer = false;
      }
    };
 
    // Make sure we only deal with the project on the thread where it lives.
    // Anything else risks a crash.
    if ( QThread::currentThread() == QgsProject::instance()->thread() ) // skip-keyword-check
      runFunction();
    else
      QMetaObject::invokeMethod( QgsProject::instance(), runFunction, Qt::BlockingQueuedConnection ); // skip-keyword-check
  }
  else
  {
    // if layer stores, then we can't be certain in advance of which thread the layer will have affinity with.
    // So we need to fetch the layer and then run the function on the layer's thread.
 
    const QString identifier = value.toString();
 
    // check through layer stores from context
    const QList< QgsMapLayerStore * > stores = context->layerStores();
 
    for ( QgsMapLayerStore *store : stores )
    {
      QPointer< QgsMapLayerStore > storePointer( store );
      auto findLayerInStoreFunction = [ storePointer = std::move( storePointer ), identifier, function, &foundLayer ]
      {
        QgsMapLayer *ml = nullptr;
        if ( QgsMapLayerStore *store = storePointer.data() )
        {
          // look for matching layer by id
          ml = store->mapLayer( identifier );
          if ( !ml )
          {
            // Still nothing? Check for layer name
            ml = store->mapLayersByName( identifier ).value( 0 );
          }
 
          if ( ml )
          {
            function( ml );
            foundLayer = true;
          }
        }
      };
 
      // Make sure we only deal with the store on the thread where it lives.
      // Anything else risks a crash.
      if ( QThread::currentThread() == store->thread() )
        findLayerInStoreFunction();
      else
        QMetaObject::invokeMethod( store, std::move( findLayerInStoreFunction ), Qt::BlockingQueuedConnection );
 
      if ( foundLayer )
        return;
    }
 
    // last resort - QgsProject instance. This is bad, we need to remove this!
    auto getMapLayerFromProjectInstance = [ value, identifier, &function, &foundLayer ]
    {
      QgsProject *project = QgsProject::instance(); // skip-keyword-check
 
      // maybe it's a layer id?
      QgsMapLayer *ml = project->mapLayer( identifier );
 
      // Still nothing? Check for layer name
      if ( !ml )
      {
        ml = project->mapLayersByName( identifier ).value( 0 );
      }
 
      if ( ml )
      {
        foundLayer = true;
        function( ml );
      }
    };
 
    if ( QThread::currentThread() == QgsProject::instance()->thread() ) // skip-keyword-check
      getMapLayerFromProjectInstance();
    else
      QMetaObject::invokeMethod( QgsProject::instance(), getMapLayerFromProjectInstance, Qt::BlockingQueuedConnection ); // skip-keyword-check
  }
#endif
}
 
QVariant QgsExpressionUtils::runMapLayerFunctionThreadSafe( const QVariant &value, const QgsExpressionContext *context, QgsExpression *expression, const std::function<QVariant( QgsMapLayer * )> &function, bool &foundLayer )
{
  QVariant res;
  foundLayer = false;
 
  executeLambdaForMapLayer( value, context, expression, [&res, function]( QgsMapLayer * layer )
  {
    if ( layer )
      res = function( layer );
  }, foundLayer );
 
  return res;
}
 
std::unique_ptr<QgsVectorLayerFeatureSource> QgsExpressionUtils::getFeatureSource( const QVariant &value, const QgsExpressionContext *context, QgsExpression *e, bool &foundLayer )
{
  std::unique_ptr<QgsVectorLayerFeatureSource> featureSource;
 
  executeLambdaForMapLayer( value, context, e, [&featureSource]( QgsMapLayer * layer )
  {
    if ( QgsVectorLayer *vl = qobject_cast< QgsVectorLayer *>( layer ) )
    {
      featureSource = std::make_unique<QgsVectorLayerFeatureSource>( vl );
    }
  }, foundLayer );
 
  return featureSource;
}
 
QgsVectorLayer *QgsExpressionUtils::getVectorLayer( const QVariant &value, const QgsExpressionContext *context, QgsExpression *e )
{
  return qobject_cast<QgsVectorLayer *>( getMapLayerPrivate( value, context, e ) );
}
 
QString QgsExpressionUtils::getFilePathValue( const QVariant &value, const QgsExpressionContext *context, QgsExpression *parent )
{
  // if it's a map layer, return the file path of that layer...
  QString res;
  Q_NOWARN_DEPRECATED_PUSH
  if ( QgsMapLayer *layer = getMapLayer( value, context, parent ) )
  {
    const QVariantMap parts = QgsProviderRegistry::instance()->decodeUri( layer->providerType(), layer->source() );
    res = parts.value( u"path"_s ).toString();
  }
  Q_NOWARN_DEPRECATED_POP
 
  if ( res.isEmpty() )
    res = value.toString();
 
  if ( res.isEmpty() && !QgsVariantUtils::isNull( value ) )
  {
    parent->setEvalErrorString( QObject::tr( "Cannot convert value to a file path" ) );
  }
  return res;
}

 
std::tuple<QMetaType::Type, int> QgsExpressionUtils::determineResultType( const QString &expression, const QgsVectorLayer *layer, const QgsFeatureRequest &r, const QgsExpressionContext &c, bool *foundFeatures )
{
  QgsExpressionContext context = c;
  QgsFeatureRequest request = r;
  QgsExpression exp( expression );
  request.setFlags( ( exp.needsGeometry() ) ?
                    Qgis::FeatureRequestFlag::NoFlags :
                    Qgis::FeatureRequestFlag::NoGeometry );
  request.setLimit( 10 );
  request.setExpressionContext( context );
 
  // avoid endless recursion by removing virtual fields while going through features
  // to determine result type
  QgsAttributeList attributes;
  const QgsFields fields = layer->fields();
  for ( int i = 0; i < fields.count(); i++ )
  {
    if ( fields.fieldOrigin( i ) != Qgis::FieldOrigin::Expression )
      attributes << i;
  }
  request.setSubsetOfAttributes( attributes );
 
  QVariant value;
  QgsFeature f;
  QgsFeatureIterator it = layer->getFeatures( request );
  bool hasFeature = it.nextFeature( f );
  if ( foundFeatures )
    *foundFeatures = hasFeature;
  while ( hasFeature )
  {
    context.setFeature( f );
    const QVariant value = exp.evaluate( &context );
    if ( !QgsVariantUtils::isNull( value ) )
    {
      return std::make_tuple( static_cast<QMetaType::Type>( value.userType() ), value.userType() );
    }
    hasFeature = it.nextFeature( f );
  }
  value = QVariant();
  return std::make_tuple( static_cast<QMetaType::Type>( value.userType() ), value.userType() );
}