Branch data     Line data    Source code

       1                 :            : /***************************************************************************
       2                 :            :                          qgsprocessingmodelchildparametersource.cpp
       3                 :            :                          ------------------------------------------
       4                 :            :     begin                : June 2017
       5                 :            :     copyright            : (C) 2017 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 "qgsprocessingmodelchildparametersource.h"
      19                 :            : #include "qgsprocessingparameters.h"
      20                 :            : #include "qgsprocessingcontext.h"
      21                 :            : #include "qgsprocessingmodelalgorithm.h"
      22                 :            : 
      23                 :            : ///@cond NOT_STABLE
      24                 :            : 
      25                 :          0 : bool QgsProcessingModelChildParameterSource::operator==( const QgsProcessingModelChildParameterSource &other ) const
      26                 :            : {
      27                 :          0 :   if ( mSource != other.mSource )
      28                 :          0 :     return false;
      29                 :            : 
      30                 :          0 :   switch ( mSource )
      31                 :            :   {
      32                 :            :     case StaticValue:
      33                 :          0 :       return mStaticValue == other.mStaticValue;
      34                 :            :     case ChildOutput:
      35                 :          0 :       return mChildId == other.mChildId && mOutputName == other.mOutputName;
      36                 :            :     case ModelParameter:
      37                 :          0 :       return mParameterName == other.mParameterName;
      38                 :            :     case Expression:
      39                 :          0 :       return mExpression == other.mExpression;
      40                 :            :     case ExpressionText:
      41                 :          0 :       return mExpressionText == other.mExpressionText;
      42                 :            :     case ModelOutput:
      43                 :          0 :       return true;
      44                 :            :   }
      45                 :          0 :   return false;
      46                 :          0 : }
      47                 :            : 
      48                 :          0 : QgsProcessingModelChildParameterSource QgsProcessingModelChildParameterSource::fromStaticValue( const QVariant &value )
      49                 :            : {
      50                 :          0 :   QgsProcessingModelChildParameterSource src;
      51                 :          0 :   src.mSource = StaticValue;
      52                 :          0 :   src.mStaticValue = value;
      53                 :          0 :   return src;
      54                 :          0 : }
      55                 :            : 
      56                 :          0 : QgsProcessingModelChildParameterSource QgsProcessingModelChildParameterSource::fromModelParameter( const QString &parameterName )
      57                 :            : {
      58                 :          0 :   QgsProcessingModelChildParameterSource src;
      59                 :          0 :   src.mSource = ModelParameter;
      60                 :          0 :   src.mParameterName = parameterName;
      61                 :          0 :   return src;
      62                 :          0 : }
      63                 :            : 
      64                 :          0 : QgsProcessingModelChildParameterSource QgsProcessingModelChildParameterSource::fromChildOutput( const QString &childId, const QString &outputName )
      65                 :            : {
      66                 :          0 :   QgsProcessingModelChildParameterSource src;
      67                 :          0 :   src.mSource = ChildOutput;
      68                 :          0 :   src.mChildId = childId;
      69                 :          0 :   src.mOutputName = outputName;
      70                 :          0 :   return src;
      71                 :          0 : }
      72                 :            : 
      73                 :          0 : QgsProcessingModelChildParameterSource QgsProcessingModelChildParameterSource::fromExpression( const QString &expression )
      74                 :            : {
      75                 :          0 :   QgsProcessingModelChildParameterSource src;
      76                 :          0 :   src.mSource = Expression;
      77                 :          0 :   src.mExpression = expression;
      78                 :          0 :   return src;
      79                 :          0 : }
      80                 :            : 
      81                 :          0 : QgsProcessingModelChildParameterSource QgsProcessingModelChildParameterSource::fromExpressionText( const QString &text )
      82                 :            : {
      83                 :          0 :   QgsProcessingModelChildParameterSource src;
      84                 :          0 :   src.mSource = ExpressionText;
      85                 :          0 :   src.mExpressionText = text;
      86                 :          0 :   return src;
      87                 :          0 : }
      88                 :            : 
      89                 :          0 : QgsProcessingModelChildParameterSource::Source QgsProcessingModelChildParameterSource::source() const
      90                 :            : {
      91                 :          0 :   return mSource;
      92                 :            : }
      93                 :            : 
      94                 :          0 : void QgsProcessingModelChildParameterSource::setSource( QgsProcessingModelChildParameterSource::Source source )
      95                 :            : {
      96                 :          0 :   mSource = source;
      97                 :          0 : }
      98                 :            : 
      99                 :          0 : QVariant QgsProcessingModelChildParameterSource::toVariant() const
     100                 :            : {
     101                 :          0 :   QVariantMap map;
     102                 :          0 :   map.insert( QStringLiteral( "source" ), mSource );
     103                 :          0 :   switch ( mSource )
     104                 :            :   {
     105                 :            :     case ModelParameter:
     106                 :          0 :       map.insert( QStringLiteral( "parameter_name" ), mParameterName );
     107                 :          0 :       break;
     108                 :            : 
     109                 :            :     case ChildOutput:
     110                 :          0 :       map.insert( QStringLiteral( "child_id" ), mChildId );
     111                 :          0 :       map.insert( QStringLiteral( "output_name" ), mOutputName );
     112                 :          0 :       break;
     113                 :            : 
     114                 :            :     case StaticValue:
     115                 :          0 :       map.insert( QStringLiteral( "static_value" ), mStaticValue );
     116                 :          0 :       break;
     117                 :            : 
     118                 :            :     case Expression:
     119                 :          0 :       map.insert( QStringLiteral( "expression" ), mExpression );
     120                 :          0 :       break;
     121                 :            : 
     122                 :            :     case ExpressionText:
     123                 :          0 :       map.insert( QStringLiteral( "expression_text" ), mExpressionText );
     124                 :          0 :       break;
     125                 :            : 
     126                 :            :     case ModelOutput:
     127                 :          0 :       break;
     128                 :            :   }
     129                 :          0 :   return map;
     130                 :          0 : }
     131                 :            : 
     132                 :          0 : bool QgsProcessingModelChildParameterSource::loadVariant( const QVariantMap &map )
     133                 :            : {
     134                 :          0 :   mSource = static_cast< Source >( map.value( QStringLiteral( "source" ) ).toInt() );
     135                 :          0 :   switch ( mSource )
     136                 :            :   {
     137                 :            :     case ModelParameter:
     138                 :          0 :       mParameterName = map.value( QStringLiteral( "parameter_name" ) ).toString();
     139                 :          0 :       break;
     140                 :            : 
     141                 :            :     case ChildOutput:
     142                 :          0 :       mChildId = map.value( QStringLiteral( "child_id" ) ).toString();
     143                 :          0 :       mOutputName = map.value( QStringLiteral( "output_name" ) ).toString();
     144                 :          0 :       break;
     145                 :            : 
     146                 :            :     case StaticValue:
     147                 :          0 :       mStaticValue = map.value( QStringLiteral( "static_value" ) );
     148                 :          0 :       break;
     149                 :            : 
     150                 :            :     case Expression:
     151                 :          0 :       mExpression = map.value( QStringLiteral( "expression" ) ).toString();
     152                 :          0 :       break;
     153                 :            : 
     154                 :            :     case ExpressionText:
     155                 :          0 :       mExpressionText = map.value( QStringLiteral( "expression_text" ) ).toString();
     156                 :          0 :       break;
     157                 :            : 
     158                 :            :     case ModelOutput:
     159                 :          0 :       break;
     160                 :            :   }
     161                 :          0 :   return true;
     162                 :          0 : }
     163                 :            : 
     164                 :          0 : QString QgsProcessingModelChildParameterSource::asPythonCode( const QgsProcessing::PythonOutputType, const QgsProcessingParameterDefinition *definition, const QMap< QString, QString > &friendlyChildNames ) const
     165                 :            : {
     166                 :          0 :   switch ( mSource )
     167                 :            :   {
     168                 :            :     case ModelParameter:
     169                 :          0 :       return QStringLiteral( "parameters['%1']" ).arg( mParameterName );
     170                 :            : 
     171                 :            :     case ChildOutput:
     172                 :          0 :       return QStringLiteral( "outputs['%1']['%2']" ).arg( friendlyChildNames.value( mChildId, mChildId ), mOutputName );
     173                 :            : 
     174                 :            :     case StaticValue:
     175                 :          0 :       if ( definition )
     176                 :            :       {
     177                 :          0 :         QgsProcessingContext c;
     178                 :          0 :         return definition->valueAsPythonString( mStaticValue, c );
     179                 :          0 :       }
     180                 :            :       else
     181                 :            :       {
     182                 :          0 :         return QgsProcessingUtils::variantToPythonLiteral( mStaticValue );
     183                 :            :       }
     184                 :            : 
     185                 :            :     case Expression:
     186                 :          0 :       return QStringLiteral( "QgsExpression(%1).evaluate()" ).arg( QgsProcessingUtils::stringToPythonLiteral( mExpression ) );
     187                 :            : 
     188                 :            :     case ExpressionText:
     189                 :          0 :       return mExpressionText;
     190                 :            : 
     191                 :            :     case ModelOutput:
     192                 :          0 :       return QString();
     193                 :            :   }
     194                 :          0 :   return QString();
     195                 :          0 : }
     196                 :            : 
     197                 :          0 : QString QgsProcessingModelChildParameterSource::asPythonComment( const QgsProcessingParameterDefinition *definition ) const
     198                 :            : {
     199                 :          0 :   switch ( mSource )
     200                 :            :   {
     201                 :            :     case ModelParameter:
     202                 :            :     case ChildOutput:
     203                 :            :     case Expression:
     204                 :            :     case ExpressionText:
     205                 :            :     case ModelOutput:
     206                 :          0 :       return QString();
     207                 :            : 
     208                 :            :     case StaticValue:
     209                 :          0 :       if ( definition )
     210                 :            :       {
     211                 :          0 :         QgsProcessingContext c;
     212                 :          0 :         return definition->valueAsPythonComment( mStaticValue, c );
     213                 :          0 :       }
     214                 :            :       else
     215                 :            :       {
     216                 :          0 :         return QString();
     217                 :            :       }
     218                 :            :   }
     219                 :          0 :   return QString();
     220                 :          0 : }
     221                 :            : 
     222                 :          0 : QString QgsProcessingModelChildParameterSource::friendlyIdentifier( QgsProcessingModelAlgorithm *model ) const
     223                 :            : {
     224                 :          0 :   switch ( mSource )
     225                 :            :   {
     226                 :            :     case ModelParameter:
     227                 :          0 :       return model ? model->parameterDefinition( mParameterName )->description() : mParameterName;
     228                 :            : 
     229                 :            :     case ChildOutput:
     230                 :            :     {
     231                 :          0 :       if ( model )
     232                 :            :       {
     233                 :          0 :         const QgsProcessingModelChildAlgorithm &alg = model->childAlgorithm( mChildId );
     234                 :          0 :         QString outputName = alg.algorithm() && alg.algorithm()->outputDefinition( mOutputName ) ? alg.algorithm()->outputDefinition( mOutputName )->description() : mOutputName;
     235                 :            :         // see if this output has been named by the model designer -- if so, we use that friendly name
     236                 :          0 :         const QMap<QString, QgsProcessingModelOutput> outputs = alg.modelOutputs();
     237                 :          0 :         for ( auto it = outputs.constBegin(); it != outputs.constEnd(); ++it )
     238                 :            :         {
     239                 :          0 :           if ( it.value().childOutputName() == mOutputName )
     240                 :            :           {
     241                 :          0 :             outputName = it.key();
     242                 :          0 :             break;
     243                 :            :           }
     244                 :          0 :         }
     245                 :          0 :         return QObject::tr( "'%1' from algorithm '%2'" ).arg( outputName, alg.description() );
     246                 :          0 :       }
     247                 :            :       else
     248                 :            :       {
     249                 :          0 :         return QObject::tr( "'%1' from algorithm '%2'" ).arg( mOutputName, mChildId );
     250                 :            :       }
     251                 :            :     }
     252                 :            : 
     253                 :            :     case StaticValue:
     254                 :          0 :       return mStaticValue.toString();
     255                 :            : 
     256                 :            :     case Expression:
     257                 :          0 :       return mExpression;
     258                 :            : 
     259                 :            :     case ExpressionText:
     260                 :          0 :       return mExpressionText;
     261                 :            : 
     262                 :            :     case ModelOutput:
     263                 :          0 :       return QString();
     264                 :            :   }
     265                 :          0 :   return QString();
     266                 :          0 : }
     267                 :            : 
     268                 :          0 : QDataStream &operator<<( QDataStream &out, const QgsProcessingModelChildParameterSource &source )
     269                 :            : {
     270                 :          0 :   out << source.source();
     271                 :          0 :   out << source.staticValue();
     272                 :          0 :   out << source.parameterName();
     273                 :          0 :   out << source.outputChildId();
     274                 :          0 :   out << source.outputName();
     275                 :          0 :   out << source.expression();
     276                 :          0 :   out << source.expressionText();
     277                 :          0 :   return out;
     278                 :          0 : }
     279                 :            : 
     280                 :          0 : QDataStream &operator>>( QDataStream &in, QgsProcessingModelChildParameterSource &source )
     281                 :            : {
     282                 :            :   int sourceType;
     283                 :          0 :   QVariant staticValue;
     284                 :          0 :   QString parameterName;
     285                 :          0 :   QString outputChildId;
     286                 :          0 :   QString outputName;
     287                 :          0 :   QString expression;
     288                 :          0 :   QString expressionText;
     289                 :            : 
     290                 :          0 :   in >> sourceType >> staticValue >> parameterName >> outputChildId >> outputName >> expression >> expressionText;
     291                 :            : 
     292                 :          0 :   source.setStaticValue( staticValue );
     293                 :          0 :   source.setParameterName( parameterName );
     294                 :          0 :   source.setOutputChildId( outputChildId );
     295                 :          0 :   source.setOutputName( outputName );
     296                 :          0 :   source.setExpression( expression );
     297                 :          0 :   source.setExpressionText( expressionText );
     298                 :          0 :   source.setSource( static_cast<QgsProcessingModelChildParameterSource::Source>( sourceType ) );
     299                 :          0 :   return in;
     300                 :          0 : }
     301                 :            : 
     302                 :            : ///@endcond