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.h"
#include "qgis_core.h"
#include "qgsprocessingalgorithm.h"
#include "qgsprocessingmodelchildalgorithm.h"
#include "qgsprocessingmodelchilddependency.h"
#include "qgsprocessingmodelchildparametersource.h"
#include "qgsprocessingmodelgroupbox.h"
#include "qgsprocessingmodelparameter.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