qgsprocessingmodelalgorithm.h

Go to the documentation of this file.

/***************************************************************************
                         qgsprocessingmodelalgorithm.h
                         -----------------------------
    begin                : June 2017
    copyright            : (C) 2017 by Nyall Dawson
    email                : nyall dot dawson at gmail dot com
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef QGSPROCESSINGMODELALGORITHM_H
#define QGSPROCESSINGMODELALGORITHM_H
 
#include "qgis_core.h"
#include "qgis.h"
#include "qgsprocessingmodelchildalgorithm.h"
#include "qgsprocessingalgorithm.h"
#include "qgsprocessingmodelparameter.h"
#include "qgsprocessingmodelchildparametersource.h"
#include "qgsprocessingmodelgroupbox.h"
#include "qgsprocessingmodelchilddependency.h"
 
 
class CORE_EXPORT QgsProcessingModelAlgorithm : public QgsProcessingAlgorithm
{
    Q_GADGET
 
  public:
 
    QgsProcessingModelAlgorithm( const QString &name = QString(), const QString &group = QString(), const QString &groupId = QString() );
 
    void initAlgorithm( const QVariantMap &configuration = QVariantMap() ) override;  //#spellok
 
    Qgis::ProcessingAlgorithmFlags flags() const override;
    QString name() const override;
    QString displayName() const override;
    QString group() const override;
    QString groupId() const override;
    QIcon icon() const override;
    QString svgIconPath() const override;
    QString shortHelpString() const override;
    QString shortDescription() const override;
    QString helpUrl() const override;
 
    bool canExecute( QString *errorMessage SIP_OUT = nullptr ) const override;
    QString asPythonCommand( const QVariantMap &parameters, QgsProcessingContext &context ) const override;
    QgsExpressionContext createExpressionContext( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeatureSource *source = nullptr ) const override;
 
    void setName( const QString &name );
 
    void setGroup( const QString &group );
 
    bool validate( QStringList &issues SIP_OUT ) const;
 
    QMap<QString, QgsProcessingModelChildAlgorithm> childAlgorithms() const;
 
    void setChildAlgorithms( const QMap<QString, QgsProcessingModelChildAlgorithm> &childAlgorithms );
 
    void setChildAlgorithm( const QgsProcessingModelChildAlgorithm &algorithm );
 
    QString addChildAlgorithm( QgsProcessingModelChildAlgorithm &algorithm );
 
    QgsProcessingModelChildAlgorithm &childAlgorithm( const QString &id );
 
    bool removeChildAlgorithm( const QString &id );
 
    void deactivateChildAlgorithm( const QString &id );
 
    bool activateChildAlgorithm( const QString &id );
 
    QSet< QString > dependentChildAlgorithms( const QString &childId, const QString &conditionalBranch = QString() ) const;
 
    QSet< QString > dependsOnChildAlgorithms( const QString &childId ) const;
 
    QList< QgsProcessingModelChildDependency > availableDependenciesForChildAlgorithm( const QString &childId ) const;
 
    bool validateChildAlgorithm( const QString &childId, QStringList &issues SIP_OUT ) const;
 
    void addModelParameter( QgsProcessingParameterDefinition *definition SIP_TRANSFER, const QgsProcessingModelParameter &component );
 
    void updateModelParameter( QgsProcessingParameterDefinition *definition SIP_TRANSFER );
 
    void removeModelParameter( const QString &name );
 
    void changeParameterName( const QString &oldName, const QString &newName );
 
    bool childAlgorithmsDependOnParameter( const QString &name ) const;
 
    bool otherParametersDependOnParameter( const QString &name ) const;
 
    QMap<QString, QgsProcessingModelParameter> parameterComponents() const;
 
    void setParameterComponents( const QMap<QString, QgsProcessingModelParameter> &parameterComponents );
 
    void setParameterComponent( const QgsProcessingModelParameter &component );
 
    QgsProcessingModelParameter &parameterComponent( const QString &name );
 
    QList< QgsProcessingModelParameter > orderedParameters() const;
 
    void setParameterOrder( const QStringList &order );
 
    QList< QgsProcessingModelOutput > orderedOutputs() const;
 
    void setOutputOrder( const QStringList &order );
 
    QString outputGroup() const;
 
    void setOutputGroup( const QString &group );
 
    void updateDestinationParameters();
 
    void addGroupBox( const QgsProcessingModelGroupBox &groupBox );
 
    QList< QgsProcessingModelGroupBox > groupBoxes() const;
 
    void removeGroupBox( const QString &uuid );
 
    bool toFile( const QString &path ) const;
 
    bool fromFile( const QString &path );
 
    QVariant toVariant() const;
 
    bool loadVariant( const QVariant &variant );
 
    QVariantMap &helpContent() { return mHelpContent; }
 
    SIP_SKIP QVariantMap helpContent() const;
 
    void setHelpContent( const QVariantMap &contents );
 
    QString sourceFilePath() const;
 
    void setSourceFilePath( const QString &path );
 
    bool modelNameMatchesFilePath() const;
 
    QStringList asPythonCode( QgsProcessing::PythonOutputType outputType, int indentSize ) const;
 
    QList< QgsProcessingModelChildParameterSource > availableSourcesForChild( const QString &childId, const QgsProcessingParameterDefinition *param ) const;
 
    QList< QgsProcessingModelChildParameterSource > availableSourcesForChild( const QString &childId, const QStringList &parameterTypes = QStringList(),
        const QStringList &outputTypes = QStringList(), const QList< int > &dataTypes = QList< int >() ) const;
 
    class CORE_EXPORT VariableDefinition
    {
      public:
 
        VariableDefinition( const QVariant &value = QVariant(), const QgsProcessingModelChildParameterSource &source = QgsProcessingModelChildParameterSource::fromStaticValue( QVariant() ), const QString &description = QString() )
          : value( value )
          , source( source )
          , description( description )
        {}
 
        QVariant value;
 
        QgsProcessingModelChildParameterSource source;
 
        QString description;
    };
 
    QMap< QString, QgsProcessingModelAlgorithm::VariableDefinition > variablesForChildAlgorithm( const QString &childId, QgsProcessingContext *context = nullptr, const QVariantMap &modelParameters = QVariantMap(),
        const QVariantMap &results = QVariantMap() ) const;
 
    QgsExpressionContextScope *createExpressionContextScopeForChildAlgorithm( const QString &childId, QgsProcessingContext &context, const QVariantMap &modelParameters = QVariantMap(),
        const QVariantMap &results = QVariantMap() ) const SIP_FACTORY;
 
    QVariantMap variables() const;
 
    void setVariables( const QVariantMap &variables );
 
    QVariantMap designerParameterValues() const;
 
    void setDesignerParameterValues( const QVariantMap &values ) { mDesignerParameterValues = values; }
 
    const QgsProcessingParameterDefinition *modelParameterFromChildIdAndOutputName( const QString &childId, const QString &childOutputName ) const;
 
    static QString safeName( const QString &name, bool capitalize = false );
 
#ifndef SIP_RUN
 
    enum class InternalVersion
    {
      Version1, 
      Version2, 
    };
    Q_ENUM( InternalVersion )
 
#endif
 
  protected:
 
    QgsProcessingAlgorithm *createInstance() const override SIP_FACTORY;
 
    QVariantMap processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback ) override SIP_THROW( QgsProcessingException );
 
  private:
 
    InternalVersion mInternalVersion = InternalVersion::Version2;
 
    QString mModelName;
    QString mModelGroup;
    QString mModelGroupId;
 
    QMap< QString, QgsProcessingModelChildAlgorithm > mChildAlgorithms;
 
    QMap< QString, QgsProcessingModelParameter > mParameterComponents;
 
    QVariantMap mHelpContent;
 
    QString mSourceFile;
 
    QVariantMap mResults;
 
    QVariantMap mVariables;
 
    QVariantMap mDesignerParameterValues;
 
    QMap< QString, QgsProcessingModelGroupBox > mGroupBoxes;
 
    QStringList mParameterOrder;
    QStringList mOutputOrder;
    QString mOutputGroup;
 
    void dependsOnChildAlgorithmsRecursive( const QString &childId, QSet<QString> &depends ) const;
    void dependentChildAlgorithmsRecursive( const QString &childId, QSet<QString> &depends, const QString &branch ) const;
 
    QVariantMap parametersForChildAlgorithm( const QgsProcessingModelChildAlgorithm &child, const QVariantMap &modelParameters, const QVariantMap &results, const QgsExpressionContext &expressionContext, QString &error, const QgsProcessingContext *context = nullptr ) const;
 
    bool childOutputIsRequired( const QString &childId, const QString &outputName ) const;
 
    static bool vectorOutputIsCompatibleType( const QList<int> &acceptableDataTypes, Qgis::ProcessingSourceType outputType );
 
    void reattachAlgorithms() const;
 
    friend class TestQgsProcessingModelAlgorithm;
};
 
 
#endif // QGSPROCESSINGMODELALGORITHM_H