Branch data     Line data    Source code

       1                 :            : /***************************************************************************
       2                 :            :                          qgsprocessingregistry.cpp
       3                 :            :                          --------------------------
       4                 :            :     begin                : December 2016
       5                 :            :     copyright            : (C) 2016 by Nyall Dawson
       6                 :            :     email                : nyall dot dawson at gmail dot com
       7                 :            :  ***************************************************************************/
       8                 :            : 
       9                 :            : /***************************************************************************
      10                 :            :  *                                                                         *
      11                 :            :  *   This program is free software; you can redistribute it and/or modify  *
      12                 :            :  *   it under the terms of the GNU General Public License as published by  *
      13                 :            :  *   the Free Software Foundation; either version 2 of the License, or     *
      14                 :            :  *   (at your option) any later version.                                   *
      15                 :            :  *                                                                         *
      16                 :            :  ***************************************************************************/
      17                 :            : 
      18                 :            : #include "qgsprocessingregistry.h"
      19                 :            : #include "qgsvectorfilewriter.h"
      20                 :            : #include "qgsprocessingparametertypeimpl.h"
      21                 :            : #include "qgsprocessingparametermeshdataset.h"
      22                 :            : #include "qgsprocessingparametervectortilewriterlayers.h"
      23                 :            : #include "qgsprocessingparametertininputlayers.h"
      24                 :            : #include "qgsprocessingparameterfieldmap.h"
      25                 :            : #include "qgsprocessingparameteraggregate.h"
      26                 :            : #include "qgsprocessingparameterdxflayers.h"
      27                 :            : 
      28                 :          5 : QgsProcessingRegistry::QgsProcessingRegistry( QObject *parent SIP_TRANSFERTHIS )
      29                 :          5 :   : QObject( parent )
      30                 :         10 : {
      31                 :          5 :   addParameterType( new QgsProcessingParameterTypeRasterLayer() );
      32                 :          5 :   addParameterType( new QgsProcessingParameterTypeVectorLayer() );
      33                 :          5 :   addParameterType( new QgsProcessingParameterTypeMeshLayer() );
      34                 :          5 :   addParameterType( new QgsProcessingParameterTypeMapLayer() );
      35                 :          5 :   addParameterType( new QgsProcessingParameterTypeBoolean() );
      36                 :          5 :   addParameterType( new QgsProcessingParameterTypeExpression() );
      37                 :          5 :   addParameterType( new QgsProcessingParameterTypeCrs() );
      38                 :          5 :   addParameterType( new QgsProcessingParameterTypeRange() );
      39                 :          5 :   addParameterType( new QgsProcessingParameterTypePoint() );
      40                 :          5 :   addParameterType( new QgsProcessingParameterTypeGeometry() );
      41                 :          5 :   addParameterType( new QgsProcessingParameterTypeEnum() );
      42                 :          5 :   addParameterType( new QgsProcessingParameterTypeExtent() );
      43                 :          5 :   addParameterType( new QgsProcessingParameterTypeMatrix() );
      44                 :          5 :   addParameterType( new QgsProcessingParameterTypeFile() ) ;
      45                 :          5 :   addParameterType( new QgsProcessingParameterTypeField() );
      46                 :          5 :   addParameterType( new QgsProcessingParameterTypeVectorDestination() );
      47                 :          5 :   addParameterType( new QgsProcessingParameterTypeRasterDestination() );
      48                 :          5 :   addParameterType( new QgsProcessingParameterTypeFileDestination() );
      49                 :          5 :   addParameterType( new QgsProcessingParameterTypeFolderDestination() );
      50                 :          5 :   addParameterType( new QgsProcessingParameterTypeString() );
      51                 :          5 :   addParameterType( new QgsProcessingParameterTypeAuthConfig() );
      52                 :          5 :   addParameterType( new QgsProcessingParameterTypeMultipleLayers() );
      53                 :          5 :   addParameterType( new QgsProcessingParameterTypeFeatureSource() );
      54                 :          5 :   addParameterType( new QgsProcessingParameterTypeNumber() );
      55                 :          5 :   addParameterType( new QgsProcessingParameterTypeDistance() );
      56                 :          5 :   addParameterType( new QgsProcessingParameterTypeScale() );
      57                 :          5 :   addParameterType( new QgsProcessingParameterTypeBand() );
      58                 :          5 :   addParameterType( new QgsProcessingParameterTypeFeatureSink() );
      59                 :          5 :   addParameterType( new QgsProcessingParameterTypeLayout() );
      60                 :          5 :   addParameterType( new QgsProcessingParameterTypeLayoutItem() );
      61                 :          5 :   addParameterType( new QgsProcessingParameterTypeColor() );
      62                 :          5 :   addParameterType( new QgsProcessingParameterTypeCoordinateOperation() );
      63                 :          5 :   addParameterType( new QgsProcessingParameterTypeMapTheme() );
      64                 :          5 :   addParameterType( new QgsProcessingParameterTypeDateTime() );
      65                 :          5 :   addParameterType( new QgsProcessingParameterTypeProviderConnection() );
      66                 :          5 :   addParameterType( new QgsProcessingParameterTypeDatabaseSchema() );
      67                 :          5 :   addParameterType( new QgsProcessingParameterTypeDatabaseTable() );
      68                 :          5 :   addParameterType( new QgsProcessingParameterTypeVectorTileWriterLayers() );
      69                 :          5 :   addParameterType( new QgsProcessingParameterTypeFieldMapping() );
      70                 :          5 :   addParameterType( new QgsProcessingParameterTypeAggregate() );
      71                 :          5 :   addParameterType( new QgsProcessingParameterTypeTinInputLayers() );
      72                 :          5 :   addParameterType( new QgsProcessingParameterTypeDxfLayers() );
      73                 :          5 :   addParameterType( new QgsProcessingParameterTypeMeshDatasetGroups() );
      74                 :          5 :   addParameterType( new QgsProcessingParameterTypeMeshDatasetTime() );
      75                 :          5 : }
      76                 :            : 
      77                 :         10 : QgsProcessingRegistry::~QgsProcessingRegistry()
      78                 :         10 : {
      79                 :          5 :   const auto constMProviders = mProviders;
      80                 :          5 :   for ( QgsProcessingProvider *p : constMProviders )
      81                 :            :   {
      82                 :          0 :     removeProvider( p );
      83                 :            :   }
      84                 :            : 
      85                 :          5 :   const auto parameterTypes = mParameterTypes.values();
      86                 :            : 
      87                 :        225 :   for ( QgsProcessingParameterType *type : parameterTypes )
      88                 :            :   {
      89                 :        220 :     removeParameterType( type );
      90                 :            :   }
      91                 :         10 : }
      92                 :            : 
      93                 :          0 : bool QgsProcessingRegistry::addProvider( QgsProcessingProvider *provider )
      94                 :            : {
      95                 :          0 :   if ( !provider )
      96                 :          0 :     return false;
      97                 :            : 
      98                 :          0 :   if ( mProviders.contains( provider->id() ) )
      99                 :            :   {
     100                 :          0 :     QgsLogger::warning( QStringLiteral( "Duplicate provider %1 registered" ).arg( provider->id() ) );
     101                 :          0 :     delete provider;
     102                 :          0 :     return false;
     103                 :            :   }
     104                 :            : 
     105                 :          0 :   if ( !provider->load() )
     106                 :            :   {
     107                 :          0 :     QgsLogger::warning( QStringLiteral( "Provider %1 cannot load" ).arg( provider->id() ) );
     108                 :          0 :     delete provider;
     109                 :          0 :     return false;
     110                 :            :   }
     111                 :            : 
     112                 :          0 :   provider->setParent( this );
     113                 :          0 :   mProviders[ provider->id()] = provider;
     114                 :          0 :   emit providerAdded( provider->id() );
     115                 :          0 :   return true;
     116                 :          0 : }
     117                 :            : 
     118                 :          0 : bool QgsProcessingRegistry::removeProvider( QgsProcessingProvider *provider )
     119                 :            : {
     120                 :          0 :   if ( !provider )
     121                 :          0 :     return false;
     122                 :            : 
     123                 :          0 :   QString id = provider->id();
     124                 :            : 
     125                 :          0 :   if ( !mProviders.contains( id ) )
     126                 :          0 :     return false;
     127                 :            : 
     128                 :          0 :   provider->unload();
     129                 :            : 
     130                 :          0 :   delete mProviders.take( id );
     131                 :          0 :   emit providerRemoved( id );
     132                 :          0 :   return true;
     133                 :          0 : }
     134                 :            : 
     135                 :          0 : bool QgsProcessingRegistry::removeProvider( const QString &providerId )
     136                 :            : {
     137                 :          0 :   QgsProcessingProvider *p = providerById( providerId );
     138                 :          0 :   return removeProvider( p );
     139                 :            : }
     140                 :            : 
     141                 :          0 : QgsProcessingProvider *QgsProcessingRegistry::providerById( const QString &id )
     142                 :            : {
     143                 :          0 :   return mProviders.value( id, nullptr );
     144                 :            : }
     145                 :            : 
     146                 :          0 : QList< const QgsProcessingAlgorithm * > QgsProcessingRegistry::algorithms() const
     147                 :            : {
     148                 :          0 :   QList< const QgsProcessingAlgorithm * > algs;
     149                 :          0 :   QMap<QString, QgsProcessingProvider *>::const_iterator it = mProviders.constBegin();
     150                 :          0 :   for ( ; it != mProviders.constEnd(); ++it )
     151                 :            :   {
     152                 :          0 :     algs.append( it.value()->algorithms() );
     153                 :          0 :   }
     154                 :          0 :   return algs;
     155                 :          0 : }
     156                 :            : 
     157                 :          0 : const QgsProcessingAlgorithm *QgsProcessingRegistry::algorithmById( const QString &constId ) const
     158                 :            : {
     159                 :            :   // allow mapping of algorithm via registered algorithm aliases
     160                 :          0 :   QString id = mAlgorithmAliases.value( constId, constId );
     161                 :            : 
     162                 :          0 :   QMap<QString, QgsProcessingProvider *>::const_iterator it = mProviders.constBegin();
     163                 :          0 :   for ( ; it != mProviders.constEnd(); ++it )
     164                 :            :   {
     165                 :          0 :     const auto constAlgorithms = it.value()->algorithms();
     166                 :          0 :     for ( const QgsProcessingAlgorithm *alg : constAlgorithms )
     167                 :          0 :       if ( alg->id() == id )
     168                 :          0 :         return alg;
     169                 :          0 :   }
     170                 :            : 
     171                 :            :   // try mapping 'qgis' algs to 'native' algs - this allows us to freely move algorithms
     172                 :            :   // from the python 'qgis' provider to the c++ 'native' provider without breaking API
     173                 :            :   // or existing models
     174                 :          0 :   if ( id.startsWith( QLatin1String( "qgis:" ) ) )
     175                 :            :   {
     176                 :          0 :     QString newId = QStringLiteral( "native:" ) + id.mid( 5 );
     177                 :          0 :     return algorithmById( newId );
     178                 :          0 :   }
     179                 :          0 :   return nullptr;
     180                 :          0 : }
     181                 :            : 
     182                 :          0 : QgsProcessingAlgorithm *QgsProcessingRegistry::createAlgorithmById( const QString &id, const QVariantMap &configuration ) const
     183                 :            : {
     184                 :          0 :   const QgsProcessingAlgorithm *alg = algorithmById( id );
     185                 :          0 :   if ( !alg )
     186                 :          0 :     return nullptr;
     187                 :            : 
     188                 :          0 :   std::unique_ptr< QgsProcessingAlgorithm > creation( alg->create( configuration ) );
     189                 :          0 :   return creation.release();
     190                 :          0 : }
     191                 :            : 
     192                 :          0 : void QgsProcessingRegistry::addAlgorithmAlias( const QString &aliasId, const QString &actualId )
     193                 :            : {
     194                 :          0 :   mAlgorithmAliases.insert( aliasId, actualId );
     195                 :          0 : }
     196                 :            : 
     197                 :        220 : bool QgsProcessingRegistry::addParameterType( QgsProcessingParameterType *type )
     198                 :            : {
     199                 :        220 :   if ( !mParameterTypes.contains( type->id() ) )
     200                 :            :   {
     201                 :        220 :     mParameterTypes.insert( type->id(), type );
     202                 :        220 :     emit parameterTypeAdded( type );
     203                 :        220 :     return true;
     204                 :            :   }
     205                 :            :   else
     206                 :            :   {
     207                 :          0 :     QgsLogger::warning( QStringLiteral( "Duplicate parameter type %1 (\"%2\") registered" ).arg( type->id(), type->name() ) );
     208                 :            : 
     209                 :          0 :     if ( mParameterTypes.value( type->id() ) != type )
     210                 :          0 :       delete type;
     211                 :            : 
     212                 :          0 :     return false;
     213                 :            :   }
     214                 :        220 : }
     215                 :            : 
     216                 :        220 : void QgsProcessingRegistry::removeParameterType( QgsProcessingParameterType *type )
     217                 :            : {
     218                 :        220 :   mParameterTypes.remove( type->id() );
     219                 :        220 :   emit parameterTypeRemoved( type );
     220                 :        220 :   delete type;
     221                 :        220 : }
     222                 :            : 
     223                 :          0 : QgsProcessingParameterType *QgsProcessingRegistry::parameterType( const QString &id ) const
     224                 :            : {
     225                 :          0 :   return mParameterTypes.value( id );
     226                 :            : }
     227                 :            : 
     228                 :          0 : QList<QgsProcessingParameterType *> QgsProcessingRegistry::parameterTypes() const
     229                 :            : {
     230                 :          0 :   return mParameterTypes.values();
     231                 :            : }