/************************************************************************
 * This file has been generated automatically from                      *
 *                                                                      *
 * src/core/processing/models/qgsprocessingmodelchildalgorithm.h        *
 *                                                                      *
 * Do not edit manually ! Edit header and run scripts/sipify.py again   *
 ************************************************************************/






class QgsProcessingModelChildAlgorithm : QgsProcessingModelComponent
{
%Docstring(signature="appended")
Child algorithm representing a single component of a
:py:class:`QgsProcessingModelAlgorithm`.
%End

%TypeHeaderCode
#include "qgsprocessingmodelchildalgorithm.h"
%End
  public:

    QgsProcessingModelChildAlgorithm( const QString &algorithmId = QString() );
%Docstring
Constructor for QgsProcessingModelChildAlgorithm. The ``algorithmId``
parameter should be set to a :py:class:`QgsProcessingAlgorithm`
algorithm ID.
%End

    QgsProcessingModelChildAlgorithm( const QgsProcessingModelChildAlgorithm &other );

    virtual QgsProcessingModelChildAlgorithm *clone() const /Factory/;


    void copyNonDefinitionPropertiesFromModel( QgsProcessingModelAlgorithm *model );
%Docstring
Copies all non-specific definition properties from the the matching
component from a ``model``.

This includes properties like the size and position of the component,
but not properties like the specific algorithm or input details.

.. versionadded:: 3.14
%End

    QString childId() const;
%Docstring
Returns the child algorithm's unique ID string, used the identify this
child algorithm within its parent model.

.. seealso:: :py:func:`setChildId`

.. seealso:: :py:func:`generateChildId`
%End

    void setChildId( const QString &id );
%Docstring
Sets the child algorithm's unique ``id`` string, used the identify this
child algorithm within its parent model.

.. seealso:: :py:func:`childId`

.. seealso:: :py:func:`generateChildId`
%End

    void generateChildId( const QgsProcessingModelAlgorithm &model );
%Docstring
Automatically generates a unique
:py:func:`~QgsProcessingModelChildAlgorithm.childId` for the algorithm,
avoiding child IDs which are already present in ``model``.

.. seealso:: :py:func:`childId`

.. seealso:: :py:func:`setChildId`
%End

    QString algorithmId() const;
%Docstring
Returns the underlying child algorithm's ID.

.. seealso:: :py:func:`algorithm`

.. seealso:: :py:func:`setAlgorithmId`
%End

    bool setAlgorithmId( const QString &algorithmId );
%Docstring
Sets the underlying child algorithm's ID. This should be set to an
existing :py:class:`QgsProcessingAlgorithm` algorithm ID.

Returns ``True`` if the algorithm was successfully set.

.. seealso:: :py:func:`reattach`

.. seealso:: :py:func:`algorithm`

.. seealso:: :py:func:`algorithmId`
%End

    bool reattach() const;
%Docstring
Attempts to re-attach the child to the algorithm specified by
:py:func:`~QgsProcessingModelChildAlgorithm.algorithmId`.

This can be run to relink the child to algorithms from providers which
were not originally available for the model to link to.

Returns ``True`` if the algorithm was successfully reattached.

.. seealso:: :py:func:`algorithm`

.. seealso:: :py:func:`setAlgorithmId`
%End

    QVariantMap configuration() const;
%Docstring
Returns the child algorithm's configuration map.

This map specifies configuration settings which are passed to the
algorithm, allowing it to dynamically adjust its initialized parameters
and outputs according to this configuration. This allows child
algorithms in the model to adjust their behavior at run time according
to some user configuration.

.. seealso:: :py:func:`setConfiguration`
%End

    void setConfiguration( const QVariantMap &configuration );
%Docstring
Sets the child algorithm's ``configuration`` map.

This map specifies configuration settings which are passed to the
algorithm, allowing it to dynamically adjust its initialized parameters
and outputs according to this configuration. This allows child
algorithms in the model to adjust their behavior at run time according
to some user configuration.

.. seealso:: :py:func:`configuration`
%End

    const QgsProcessingAlgorithm *algorithm() const;
%Docstring
Returns the underlying child algorithm, or ``None`` if a matching
algorithm is not available.

.. seealso:: :py:func:`reattach`

.. seealso:: :py:func:`algorithmId`
%End

    QMap< QString, QList< QgsProcessingModelChildParameterSource > > parameterSources() const;
%Docstring
Returns a map of parameter sources. The keys are the child algorithm
parameter names, the values are the sources for that parameter.

.. seealso:: :py:func:`setParameterSources`

.. seealso:: :py:func:`addParameterSources`
%End

    void setParameterSources( const QMap< QString, QList< QgsProcessingModelChildParameterSource > > &sources );
%Docstring
Sets the map of parameter ``sources``. The keys are the child algorithm
parameter names, the values are the sources for that parameter.

.. seealso:: :py:func:`parameterSources`

.. seealso:: :py:func:`addParameterSources`
%End

    void addParameterSources( const QString &name, const QList< QgsProcessingModelChildParameterSource > &source );
%Docstring
Adds a parameter source. The ``name`` argument should match one of the
child algorithm's parameter names, and the ``sources`` argument is used
to set the sources for that parameter.

Any existing parameter sources with matching name will be replaced.

.. seealso:: :py:func:`parameterSources`

.. seealso:: :py:func:`setParameterSources`
%End

    bool isActive() const;
%Docstring
Returns ``True`` if the child algorithm is active.

.. seealso:: :py:func:`setActive`
%End

    void setActive( bool active );
%Docstring
Sets whether the child algorithm is active.

.. seealso:: :py:func:`isActive`
%End

    QList< QgsProcessingModelChildDependency > dependencies() const;
%Docstring
Returns the list of child algorithms from the parent model on which this
algorithm is dependent.

.. seealso:: :py:func:`setDependencies`
%End

    void setDependencies( const QList< QgsProcessingModelChildDependency > &dependencies );
%Docstring
Sets the list of child algorithms from the parent model on which this
algorithm is dependent.

.. seealso:: :py:func:`dependencies`
%End

    QMap<QString, QgsProcessingModelOutput> modelOutputs() const;
%Docstring
Returns the map of final model outputs which are generated by this child
algorithm. The keys are the output names from this child algorithm. Only
outputs which are part of the final outputs from the model are included
in this map.

.. seealso:: :py:func:`setModelOutputs`

.. seealso:: :py:func:`modelOutput`
%End

    QgsProcessingModelOutput &modelOutput( const QString &name );
%Docstring
Returns the final model output with matching ``name``. If no output
exists with the name, a new one will be created and returned.

If child model outputs are altered by this method,
:py:func:`QgsProcessingModelAlgorithm.updateDestinationParameters()`
must be called on the parent model.

.. seealso:: :py:func:`modelOutputs`

.. seealso:: :py:func:`setModelOutputs`
%End

    void setModelOutputs( const QMap<QString, QgsProcessingModelOutput> &outputs );
%Docstring
Sets the map of final model ``outputs`` which are generated by this
child algorithm. Only outputs which are part of the final outputs from
the model should be included in this map.

If child model outputs are altered by this method,
:py:func:`QgsProcessingModelAlgorithm.updateDestinationParameters()`
must be called on the parent model.

.. seealso:: :py:func:`modelOutputs`
%End

    bool removeModelOutput( const QString &name );
%Docstring
Removes an existing output from the final model outputs.

:py:func:`QgsProcessingModelAlgorithm.updateDestinationParameters()`
must be called on the parent model.

.. seealso:: :py:func:`modelOutputs`

.. versionadded:: 3.2
%End

    QVariant toVariant() const;
%Docstring
Saves this child to a QVariant.

.. seealso:: :py:func:`loadVariant`
%End

    bool loadVariant( const QVariant &child );
%Docstring
Loads this child from a QVariant.

.. seealso:: :py:func:`toVariant`
%End

    QStringList asPythonCode( QgsProcessing::PythonOutputType outputType, const QgsStringMap &extraParameters, int currentIndent, int indentSize,
                              const QMap<QString, QString> &friendlyChildNames, const QMap<QString, QString> &friendlyOutputNames ) const;
%Docstring
Attempts to convert the child to executable Python code, and returns a
list of the generated lines of code.

The ``outputType`` argument specifies the type of script to generate.

Additional parameters to be passed to the child algorithm are specified
in the ``extraParameters`` argument.

The ``currentIndent`` and ``indentSize`` are used to set the base line
indent and size of further indented lines respectively.

The ``friendlyChildNames`` argument gives a map of child id to a
friendly algorithm name, to be used in the code to identify that
algorithm instead of the raw child id.
%End

    virtual QgsProcessingModelComment *comment();
    virtual void setComment( const QgsProcessingModelComment &comment );

};


/************************************************************************
 * This file has been generated automatically from                      *
 *                                                                      *
 * src/core/processing/models/qgsprocessingmodelchildalgorithm.h        *
 *                                                                      *
 * Do not edit manually ! Edit header and run scripts/sipify.py again   *
 ************************************************************************/