qgsprovidermetadata.h

Go to the documentation of this file.

/***************************************************************************
                    qgsprovidermetadata.h  -  Metadata class for
                    describing a data provider.
                             -------------------
    begin                : Sat Jan 10 2004
    copyright            : (C) 2004 by Gary E.Sherman
    email                : sherman at mrcc.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 QGSPROVIDERMETADATA_H
#define QGSPROVIDERMETADATA_H
 
 
#include <QString>
#include <QVariantMap>
#include <QMap>
#include <QList>
#include <memory>
#include <QPair>
 
#include "qgis_sip.h"
#include "qgsdataprovider.h"
#include "qgis_core.h"
#include <functional>
#include "qgsabstractproviderconnection.h"
#include "qgsabstractlayermetadataprovider.h"
#include "qgsfields.h"
#include "qgsexception.h"
 
class QgsDataItem;
class QgsDataItemProvider;
class QgsTransaction;
 
class QgsRasterDataProvider;
class QgsMeshDataProvider;
class QgsAbstractDatabaseProviderConnection;
class QgsLayerMetadata;
class QgsProviderSublayerDetails;
class QgsFeedback;
 
struct QgsMesh;
 
class CORE_EXPORT QgsMeshDriverMetadata
{
    Q_GADGET
 
  public:
 
    enum MeshDriverCapability
    {
      CanWriteFaceDatasets = 1 << 0, 
      CanWriteVertexDatasets = 1 << 1, 
      CanWriteEdgeDatasets = 1 << 2, 
      CanWriteMeshData = 1 << 3, 
    };
 
    Q_ENUM( MeshDriverCapability )
    Q_DECLARE_FLAGS( MeshDriverCapabilities, MeshDriverCapability )
    Q_FLAG( MeshDriverCapabilities )
 
    
    QgsMeshDriverMetadata();
 
    Q_DECL_DEPRECATED QgsMeshDriverMetadata( const QString &name,
        const QString &description,
        const MeshDriverCapabilities &capabilities,
        const QString &writeDatasetOnFileSuffix ) SIP_DEPRECATED;
 
    QgsMeshDriverMetadata( const QString &name,
                           const QString &description,
                           const MeshDriverCapabilities &capabilities,
                           const QString &writeDatasetOnFileSuffix,
                           const QString &writeMeshFrameOnFileSuffix,
                           int maxVerticesPerface );
 
    MeshDriverCapabilities capabilities() const;
 
    QString name() const;
 
    QString description() const;
 
    QString writeDatasetOnFileSuffix() const;
 
    QString writeMeshFrameOnFileSuffix() const;
 
    int maximumVerticesCountPerFace() const;
 
  private:
    QString mName;
    QString mDescription;
    MeshDriverCapabilities mCapabilities;
    QString mWriteDatasetOnFileSuffix;
    QString mWriteMeshFrameOnFileSuffix;
    int mMaxVerticesPerFace = -1;
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsMeshDriverMetadata::MeshDriverCapabilities )
 
class CORE_EXPORT QgsProviderMetadata : public QObject
{
    Q_OBJECT
 
  public:
 
    enum ProviderMetadataCapability
    {
      PriorityForUri = 1 << 0, 
      LayerTypesForUri = 1 << 1, 
      QuerySublayers = 1 << 2, 
      CreateDatabase = 1 << 3, 
    };
    Q_DECLARE_FLAGS( ProviderMetadataCapabilities, ProviderMetadataCapability )
 
    
    enum ProviderCapability
    {
      FileBasedUris = 1 << 0, 
      SaveLayerMetadata = 1 << 1, 
    };
    Q_DECLARE_FLAGS( ProviderCapabilities, ProviderCapability )
 
    
    SIP_SKIP typedef std::function < QgsDataProvider*( const QString &, const QgsDataProvider::ProviderOptions &, QgsDataProvider::ReadFlags & ) > CreateDataProviderFunction;
 
    QgsProviderMetadata( const QString &key, const QString &description, const QString &library = QString() );
 
    SIP_SKIP Q_DECL_DEPRECATED QgsProviderMetadata( const QString &key, const QString &description, const QgsProviderMetadata::CreateDataProviderFunction &createFunc );
 
    virtual ~QgsProviderMetadata();
 
    QString key() const;
 
    QString description() const;
 
    virtual QIcon icon() const;
 
    virtual QgsProviderMetadata::ProviderMetadataCapabilities capabilities() const;
 
    virtual QgsProviderMetadata::ProviderCapabilities providerCapabilities() const;
 
#ifndef SIP_RUN
    virtual QList< QgsMapLayerType > supportedLayerTypes() const;
#else
    SIP_PYOBJECT supportedLayerTypes() const SIP_TYPEHINT( List[QgsMapLayerType] );
    % MethodCode
    // adapted from the qpymultimedia_qlist.sip file from the PyQt6 sources
 
    const QList< QgsMapLayerType > cppRes = sipCpp->supportedLayerTypes();
 
    PyObject *l = PyList_New( cppRes.size() );
 
    if ( !l )
      sipIsErr = 1;
    else
    {
      for ( int i = 0; i < cppRes.size(); ++i )
      {
        PyObject *eobj = sipConvertFromEnum( static_cast<int>( cppRes.at( i ) ),
                                             sipType_QgsMapLayerType );
 
        if ( !eobj )
        {
          sipIsErr = 1;
        }
 
        PyList_SetItem( l, i, eobj );
      }
 
      if ( !sipIsErr )
      {
        sipRes = l;
      }
      else
      {
        Py_DECREF( l );
      }
    }
    % End
#endif
 
    Q_DECL_DEPRECATED QString library() const SIP_DEPRECATED;
 
    SIP_SKIP Q_DECL_DEPRECATED CreateDataProviderFunction createFunction() const;
 
    virtual void initProvider();
 
    virtual void cleanupProvider();
 
    enum class FilterType
    {
      FilterVector = 1, 
      FilterRaster, 
      FilterMesh, 
      FilterMeshDataset, 
      FilterPointCloud, 
    };
 
    virtual QString filters( FilterType type );
 
    virtual QList<QgsMeshDriverMetadata> meshDriversMetadata();
 
    virtual int priorityForUri( const QString &uri ) const;
 
    virtual QList< QgsMapLayerType > validLayerTypesForUri( const QString &uri ) const;
 
    virtual bool uriIsBlocklisted( const QString &uri ) const;
 
    virtual QStringList sidecarFilesForUri( const QString &uri ) const;
 
    virtual QList< QgsProviderSublayerDetails > querySublayers( const QString &uri, Qgis::SublayerQueryFlags flags = Qgis::SublayerQueryFlags(), QgsFeedback *feedback = nullptr ) const;
 
    virtual QgsDataProvider *createProvider( const QString &uri,
        const QgsDataProvider::ProviderOptions &options,
        QgsDataProvider::ReadFlags flags = QgsDataProvider::ReadFlags() ) SIP_FACTORY;
 
    static void setBoolParameter( QVariantMap &uri, const QString &parameter, const QVariant &value );
 
    static bool boolParameter( const QVariantMap &uri, const QString &parameter, bool defaultValue = false );
 
 
#ifndef SIP_RUN
 
    virtual Qgis::VectorExportResult createEmptyLayer( const QString &uri,
        const QgsFields &fields,
        QgsWkbTypes::Type wkbType,
        const QgsCoordinateReferenceSystem &srs,
        bool overwrite,
        QMap<int, int> &oldToNewAttrIdxMap,
        QString &errorMessage,
        const QMap<QString, QVariant> *options );
#endif
 
    virtual bool createDatabase( const QString &uri, QString &errorMessage SIP_OUT );
 
    virtual QgsRasterDataProvider *createRasterDataProvider(
      const QString &uri,
      const QString &format,
      int nBands,
      Qgis::DataType type,
      int width,
      int height,
      double *geoTransform,
      const QgsCoordinateReferenceSystem &crs,
      const QStringList &createOptions = QStringList() ) SIP_FACTORY;
 
    virtual bool createMeshData(
      const QgsMesh &mesh,
      const QString &fileName,
      const QString &driverName,
      const QgsCoordinateReferenceSystem &crs ) const;
 
    virtual bool createMeshData(
      const QgsMesh &mesh,
      const QString &uri,
      const QgsCoordinateReferenceSystem &crs ) const;
 
    virtual QList<QPair<QString, QString> > pyramidResamplingMethods();
 
    virtual QVariantMap decodeUri( const QString &uri ) const;
 
    virtual QString encodeUri( const QVariantMap &parts ) const;
 
    virtual QList< QgsDataItemProvider * > dataItemProviders() const SIP_FACTORY;
 
    virtual int listStyles( const QString &uri, QStringList &ids, QStringList &names,
                            QStringList &descriptions, QString &errCause );
 
    virtual bool styleExists( const QString &uri, const QString &styleId, QString &errorCause SIP_OUT );
 
    virtual QString getStyleById( const QString &uri, const QString &styleId, QString &errCause );
 
    virtual bool deleteStyleById( const QString &uri, const QString &styleId, QString &errCause );
 
    virtual bool saveStyle( const QString &uri, const QString &qmlStyle, const QString &sldStyle,
                            const QString &styleName, const QString &styleDescription,
                            const QString &uiFileContent, bool useAsDefault, QString &errCause );
 
    virtual QString loadStyle( const QString &uri, QString &errCause );
 
    virtual bool saveLayerMetadata( const QString &uri, const QgsLayerMetadata &metadata, QString &errorMessage SIP_OUT ) SIP_THROW( QgsNotSupportedException );
 
    virtual bool createDb( const QString &dbPath, QString &errCause );
 
    virtual QgsTransaction *createTransaction( const QString &connString ) SIP_FACTORY;
 
    virtual QMap<QString, QgsAbstractProviderConnection *> connections( bool cached = true ) SIP_THROW( QgsProviderConnectionException );
 
    QMap<QString, QgsAbstractDatabaseProviderConnection *> dbConnections( bool cached = true ) SIP_THROW( QgsProviderConnectionException );
 
    QgsAbstractProviderConnection *findConnection( const QString &name, bool cached = true ) SIP_THROW( QgsProviderConnectionException );
 
#ifndef SIP_RUN
 
    template <typename T> QMap<QString, T *>connections( bool cached = true );
 
 
#endif
 
    virtual QgsAbstractProviderConnection *createConnection( const QString &uri, const QVariantMap &configuration ) SIP_THROW( QgsProviderConnectionException ) SIP_FACTORY;
 
    virtual QgsAbstractProviderConnection *createConnection( const QString &name ) SIP_THROW( QgsProviderConnectionException ) SIP_FACTORY;
 
    virtual void deleteConnection( const QString &name ) SIP_THROW( QgsProviderConnectionException );
 
    virtual void saveConnection( const QgsAbstractProviderConnection *connection, const QString &name ) SIP_THROW( QgsProviderConnectionException );
 
#ifdef SIP_RUN
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str = QStringLiteral( "<QgsProviderMetadata: %1>" ).arg( sipCpp->key() );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#endif
 
  signals:
 
    void connectionCreated( const QString &name );
 
    void connectionDeleted( const QString &name );
 
    void connectionChanged( const QString &name );
 
  protected:
 
#ifndef SIP_RUN
 
    // Common functionality for connections management, to be moved into the class
    // when all the providers are ready
    // T_provider_conn: subclass of QgsAbstractProviderConnection,
    // T_conn: provider connection class (such as QgsOgrDbConnection or QgsPostgresConn)
    // TODO QGIS4: remove all old provider conn classes and move functionality into QgsAbstractProviderConnection subclasses
    template <class T_provider_conn, class T_conn> QMap<QString, QgsAbstractProviderConnection *> connectionsProtected( bool cached = true )
    {
      if ( ! cached || mProviderConnections.isEmpty() )
      {
        qDeleteAll( mProviderConnections );
        mProviderConnections.clear();
        const auto connNames { T_conn::connectionList() };
        for ( const auto &cname : connNames )
        {
          mProviderConnections.insert( cname, new T_provider_conn( cname ) );
        }
      }
      return mProviderConnections;
    }
 
    template <class T_provider_conn> void deleteConnectionProtected( const QString &name )
    {
      T_provider_conn conn( name );
      conn.remove( name );
      mProviderConnections.clear();
      emit connectionDeleted( name );
    }
    virtual void saveConnectionProtected( const QgsAbstractProviderConnection *connection, const QString &name );
    QMap<QString, QgsAbstractProviderConnection *> mProviderConnections;
 
 
#endif
 
  private:
 
    QString mKey;
 
    QString mDescription;
 
    QString mLibrary;
 
    CreateDataProviderFunction mCreateFunction = nullptr;
 
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsProviderMetadata::ProviderMetadataCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsProviderMetadata::ProviderCapabilities )
 
#endif //QGSPROVIDERMETADATA_H