qgsprocessingoutputs.h

Go to the documentation of this file.

/***************************************************************************
                         qgsprocessingoutputs.h
                         -------------------------
    begin                : May 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 QGSPROCESSINGOUTPUTS_H
#define QGSPROCESSINGOUTPUTS_H
 
#include "qgis.h"
#include "qgis_core.h"
 
#include <QColor>
#include <QString>
 
using namespace Qt::StringLiterals;
 
class QgsProcessingContext;
 
//
// Output definitions
//

 
class CORE_EXPORT QgsProcessingOutputDefinition
{
#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    if ( sipCpp->type() == QgsProcessingOutputVectorLayer::typeName() )
      sipType = sipType_QgsProcessingOutputVectorLayer;
    else if ( sipCpp->type() == QgsProcessingOutputRasterLayer::typeName() )
      sipType = sipType_QgsProcessingOutputRasterLayer;
    else if ( sipCpp->type() == QgsProcessingOutputPointCloudLayer::typeName() )
      sipType = sipType_QgsProcessingOutputPointCloudLayer;
    else if ( sipCpp->type() == QgsProcessingOutputVectorTileLayer::typeName() )
      sipType = sipType_QgsProcessingOutputVectorTileLayer;
    else if ( sipCpp->type() == QgsProcessingOutputMapLayer::typeName() )
      sipType = sipType_QgsProcessingOutputMapLayer;
    else if ( sipCpp->type() == QgsProcessingOutputMultipleLayers::typeName() )
      sipType = sipType_QgsProcessingOutputMultipleLayers;
    else if ( sipCpp->type() == QgsProcessingOutputHtml::typeName() )
      sipType = sipType_QgsProcessingOutputHtml;
    else if ( sipCpp->type() == QgsProcessingOutputNumber::typeName() )
      sipType = sipType_QgsProcessingOutputNumber;
    else if ( sipCpp->type() == QgsProcessingOutputString::typeName() )
      sipType = sipType_QgsProcessingOutputString;
    else if ( sipCpp->type() == QgsProcessingOutputBoolean::typeName() )
      sipType = sipType_QgsProcessingOutputBoolean;
    else if ( sipCpp->type() == QgsProcessingOutputFolder::typeName() )
      sipType = sipType_QgsProcessingOutputFolder;
    else if ( sipCpp->type() == QgsProcessingOutputFile::typeName() )
      sipType = sipType_QgsProcessingOutputFile;
    else if ( sipCpp->type() == QgsProcessingOutputConditionalBranch::typeName() )
      sipType = sipType_QgsProcessingOutputConditionalBranch;
    else if ( sipCpp->type() == QgsProcessingOutputVariant::typeName() )
      sipType = sipType_QgsProcessingOutputVariant;
    else
      sipType = nullptr;
  SIP_END
#endif
 
  public:

    QgsProcessingOutputDefinition( const QString &name, const QString &description = QString() );
 
    virtual ~QgsProcessingOutputDefinition() = default;

    virtual QColor modelColor() const;

    virtual QString type() const = 0;

    QString name() const { return mName; }

    void setName( const QString &name ) { mName = name; }

    QString description() const { return mDescription; }

    void setDescription( const QString &description ) { mDescription = description; }

    void setAutoCreated( bool autoCreated ) { mAutoCreated = autoCreated; }

    bool autoCreated() const { return mAutoCreated; }

    virtual QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok SIP_OUT ) const;

    virtual QString valueAsFormattedString( const QVariant &value, QgsProcessingContext &context, bool &ok SIP_OUT ) const;

    virtual bool isMapLayer() const;
 
  protected:
    QString mName;

    QString mDescription;
 
    bool mAutoCreated = false;
};

typedef QList< const QgsProcessingOutputDefinition * > QgsProcessingOutputDefinitions;

class CORE_EXPORT QgsProcessingOutputMapLayer : public QgsProcessingOutputDefinition
{
  public:
    QgsProcessingOutputMapLayer( const QString &name, const QString &description = QString() );
 
    QColor modelColor() const override;

    static QString typeName() { return u"outputLayer"_s; }
 
    QString type() const override;
    bool isMapLayer() const override;
};

class CORE_EXPORT QgsProcessingOutputVectorLayer : public QgsProcessingOutputDefinition
{
  public:
    QgsProcessingOutputVectorLayer( const QString &name, const QString &description = QString(), Qgis::ProcessingSourceType type = Qgis::ProcessingSourceType::VectorAnyGeometry );
 
    QColor modelColor() const override;

    static QString typeName() { return u"outputVector"_s; }
    QString type() const override { return typeName(); }
    bool isMapLayer() const override;

    Qgis::ProcessingSourceType dataType() const;

    void setDataType( Qgis::ProcessingSourceType type );
 
  private:
    Qgis::ProcessingSourceType mDataType = Qgis::ProcessingSourceType::VectorAnyGeometry;
};

class CORE_EXPORT QgsProcessingOutputRasterLayer : public QgsProcessingOutputDefinition
{
  public:
    QgsProcessingOutputRasterLayer( const QString &name, const QString &description = QString() );

    static QString typeName() { return u"outputRaster"_s; }
 
    QColor modelColor() const override;
    QString type() const override { return typeName(); }
    bool isMapLayer() const override;
};

class CORE_EXPORT QgsProcessingOutputPointCloudLayer : public QgsProcessingOutputDefinition
{
  public:
    QgsProcessingOutputPointCloudLayer( const QString &name, const QString &description = QString() );

    static QString typeName() { return u"outputPointCloud"_s; }
    QString type() const override { return typeName(); }
    bool isMapLayer() const override;
};

class CORE_EXPORT QgsProcessingOutputMultipleLayers : public QgsProcessingOutputDefinition
{
  public:
    QgsProcessingOutputMultipleLayers( const QString &name, const QString &description = QString() );

    static QString typeName() { return u"outputMultilayer"_s; }
    QString type() const override;
 
    QColor modelColor() const override;
    QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok SIP_OUT ) const override;
    bool isMapLayer() const override;
};

class CORE_EXPORT QgsProcessingOutputHtml : public QgsProcessingOutputDefinition
{
  public:
    QgsProcessingOutputHtml( const QString &name, const QString &description = QString() );

    static QString typeName() { return u"outputHtml"_s; }
    QString type() const override { return typeName(); }
 
    QColor modelColor() const override;
    QString valueAsFormattedString( const QVariant &value, QgsProcessingContext &context, bool &ok SIP_OUT ) const override;
};
 

class CORE_EXPORT QgsProcessingOutputVariant : public QgsProcessingOutputDefinition
{
  public:
    QgsProcessingOutputVariant( const QString &name, const QString &description = QString() );

    static QString typeName() { return u"outputVariant"_s; }
 
    QString type() const override;
    QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok SIP_OUT ) const override;
};

class CORE_EXPORT QgsProcessingOutputNumber : public QgsProcessingOutputDefinition
{
  public:
    QgsProcessingOutputNumber( const QString &name, const QString &description = QString() );
 
    QColor modelColor() const override;

    static QString typeName() { return u"outputNumber"_s; }
    QString type() const override { return typeName(); }
    QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok SIP_OUT ) const override;
};

class CORE_EXPORT QgsProcessingOutputString : public QgsProcessingOutputDefinition
{
  public:
    QgsProcessingOutputString( const QString &name, const QString &description = QString() );

    static QString typeName() { return u"outputString"_s; }
 
    QColor modelColor() const override;
    QString type() const override { return typeName(); }
};

class CORE_EXPORT QgsProcessingOutputBoolean : public QgsProcessingOutputDefinition
{
  public:
    QgsProcessingOutputBoolean( const QString &name, const QString &description = QString() );
 
    QColor modelColor() const override;

    static QString typeName() { return u"outputBoolean"_s; }
    QString type() const override { return typeName(); }
    QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok SIP_OUT ) const override;
};

class CORE_EXPORT QgsProcessingOutputFolder : public QgsProcessingOutputDefinition
{
  public:
 
    QgsProcessingOutputFolder( const QString &name, const QString &description = QString() );

    static QString typeName() { return u"outputFolder"_s; }
    QString type() const override { return typeName(); }
 
    QColor modelColor() const override;
    QString valueAsFormattedString( const QVariant &value, QgsProcessingContext &context, bool &ok SIP_OUT ) const override;
};

class CORE_EXPORT QgsProcessingOutputFile : public QgsProcessingOutputDefinition
{
  public:
    QgsProcessingOutputFile( const QString &name, const QString &description = QString() );

    static QString typeName() { return u"outputFile"_s; }
    QString type() const override { return typeName(); }
 
    QColor modelColor() const override;
    QString valueAsFormattedString( const QVariant &value, QgsProcessingContext &context, bool &ok SIP_OUT ) const override;
};

class CORE_EXPORT QgsProcessingOutputConditionalBranch : public QgsProcessingOutputDefinition
{
  public:
    QgsProcessingOutputConditionalBranch( const QString &name, const QString &description = QString() );

    static QString typeName() { return u"outputBranch"_s; }
    QString type() const override { return typeName(); }
};

class CORE_EXPORT QgsProcessingOutputVectorTileLayer : public QgsProcessingOutputDefinition
{
  public:
    QgsProcessingOutputVectorTileLayer( const QString &name, const QString &description = QString() );

    static QString typeName() { return u"outputVectorTile"_s; }
 
    QColor modelColor() const override;
    QString type() const override { return typeName(); }
    bool isMapLayer() const override;
};
 
#endif // QGSPROCESSINGOUTPUTS_H