qgsdataprovider.h

Go to the documentation of this file.

/***************************************************************************
                qgsdataprovider.h - DataProvider Interface class
                     --------------------------------------
    Date                 : 09-Sep-2003
    Copyright            : (C) 2003 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 QQGSDATAPROVIDER_H
#define QQGSDATAPROVIDER_H
 
#include "qgis_core.h"
#include <QDateTime>
#include <QObject>
#include <QString>
#include <QStringList>
#include <QMutex>
 
#include "qgsdatasourceuri.h"
#include "qgscoordinatetransformcontext.h"
#include "qgslayermetadata.h"
#include "qgserror.h"
#include "qgsdataproviderelevationproperties.h"
 
class QgsRectangle;
class QgsCoordinateReferenceSystem;
class QgsDataProviderTemporalCapabilities;
 
 
class CORE_EXPORT QgsDataProvider : public QObject
{
 
#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    if ( qobject_cast<QgsVectorDataProvider *>( sipCpp ) )
    {
      sipType = sipType_QgsVectorDataProvider;
    }
    else if ( qobject_cast<QgsRasterDataProvider *>( sipCpp ) )
    {
      sipType = sipType_QgsRasterDataProvider;
    }
    else if ( qobject_cast<QgsMeshDataProvider *>( sipCpp ) )
    {
      sipType = sipType_QgsMeshDataProvider;
    }
    else if ( qobject_cast<QgsPointCloudDataProvider *>( sipCpp ) )
    {
      sipType = sipType_QgsPointCloudDataProvider;
    }
    else
    {
      sipType = 0;
    }
    SIP_END
#endif
    Q_OBJECT
 
  public:
 
    enum ProviderProperty
    {
      EvaluateDefaultValues,       
      CustomData   = 3000          
    };
 
    struct ProviderOptions
    {
 
      QgsCoordinateTransformContext transformContext;
 
    };
 
    QgsDataProvider( const QString &uri = QString(),
                     const QgsDataProvider::ProviderOptions &providerOptions = QgsDataProvider::ProviderOptions(),
                     Qgis::DataProviderReadFlags flags = Qgis::DataProviderReadFlags() );
 
    virtual QgsCoordinateReferenceSystem crs() const = 0;
 
    virtual void setDataSourceUri( const QString &uri )
    {
      mDataSourceURI = uri;
    }
 
    virtual QString dataSourceUri( bool expandAuthConfig = false ) const
    {
      if ( expandAuthConfig && mDataSourceURI.contains( QLatin1String( "authcfg" ) ) )
      {
        const QgsDataSourceUri uri( mDataSourceURI );
        return uri.uri( expandAuthConfig );
      }
      else
      {
        return mDataSourceURI;
      }
    }
 
    virtual QString dataComment() const { return QString(); };
 
    virtual QString htmlMetadata() const;
 
    void setUri( const QgsDataSourceUri &uri )
    {
      mDataSourceURI = uri.uri( true );
    }
 
    void setUri( const QString &uri )
    {
      mDataSourceURI = uri;
    }
 
    QgsDataSourceUri uri() const
    {
      return QgsDataSourceUri( mDataSourceURI );
    }
 
    virtual Qgis::DataProviderFlags flags() const;
 
    virtual QgsDataProviderTemporalCapabilities *temporalCapabilities();
 
    virtual const QgsDataProviderTemporalCapabilities *temporalCapabilities() const SIP_SKIP;
 
    virtual QgsDataProviderElevationProperties *elevationProperties();
 
    virtual const QgsDataProviderElevationProperties *elevationProperties() const SIP_SKIP;
 
    virtual QgsRectangle extent() const = 0;
 
    virtual QgsBox3D extent3D() const
    {
      return extent().toBox3d( std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN() );
    }
 
    virtual bool isValid() const = 0;
 
    virtual void updateExtents()
    {
      // NOP by default
    }
 
    virtual QString subsetStringDialect() const;
 
    virtual QString subsetStringHelpUrl() const;
 
    virtual bool setSubsetString( const QString &subset, bool updateFeatureCount = true );
 
    virtual bool supportsSubsetString() const;
 
    virtual QString subsetString() const;
 
    virtual QStringList subLayers() const
    {
      return QStringList();  // Empty
    }
 
    virtual QStringList subLayerStyles() const
    {
      return QStringList();  // Empty
    }
 
 
    virtual uint subLayerCount() const
    {
      return 0;
    }
 
 
    virtual void setLayerOrder( const QStringList &layers )
    {
      //prevent unused var warnings
      if ( layers.count() < 1 )
      {
        return;
      }
      // NOOP
    }
 
 
    virtual void setSubLayerVisibility( const QString &name, bool vis )
    {
      //prevent unused var warnings
      if ( name.isEmpty() || !vis )
      {
        return;
      }
      // NOOP
    }
 
 
    // TODO? Instead of being pure virtual, might be better to generalize this
    // behavior and presume that none of the sub-classes are going to do
    // anything strange with regards to their name or description?
 
    virtual QString name() const = 0;
 
 
    virtual QString description() const = 0;
 
 
    virtual QString fileVectorFilters() const
    {
      return QString();
    }
 
 
    virtual QString fileRasterFilters() const
    {
      return QString();
    }
 
    // TODO QGIS 4 -> Make `reloadData()` non virtual. This should be implemented in `reloadProviderData()`.
 
    virtual void reloadData();
 
    virtual QDateTime timestamp() const { return mTimestamp; }
 
    virtual QDateTime dataTimestamp() const { return QDateTime(); }
 
    virtual QgsError error() const { return mError; }
 
    virtual void invalidateConnections( const QString &connection ) { Q_UNUSED( connection ) }
 
    virtual bool enterUpdateMode() { return true; }
 
    virtual bool leaveUpdateMode() { return true; }
 
    void setProviderProperty( ProviderProperty property, const QVariant &value );
 
    void setProviderProperty( int property, const QVariant &value ); // SIP_SKIP
 
    QVariant providerProperty( ProviderProperty property, const QVariant &defaultValue = QVariant() ) const;
 
    QVariant providerProperty( int property, const QVariant &defaultValue ) const; // SIP_SKIP
 
    virtual void setListening( bool isListening );
 
#ifndef SIP_RUN
 
    struct PreviewContext
    {
      double lastRenderingTimeMs = -1;
 
      double maxRenderingTimeMs = MAXIMUM_LAYER_PREVIEW_TIME_MS;
    };
#endif
 
    virtual bool renderInPreview( const QgsDataProvider::PreviewContext &context ); // SIP_SKIP
 
    virtual QgsLayerMetadata layerMetadata() const { return QgsLayerMetadata(); }
 
    virtual bool writeLayerMetadata( const QgsLayerMetadata &metadata ) { Q_UNUSED( metadata ) return false; }
 
    QgsCoordinateTransformContext transformContext() const SIP_SKIP;
 
    virtual void setTransformContext( const QgsCoordinateTransformContext &transformContext ) SIP_SKIP;
 
    static QString sublayerSeparator();
 
    virtual Qgis::ProviderStyleStorageCapabilities styleStorageCapabilities() const;
 
  signals:
 
    void fullExtentCalculated();
 
    void dataChanged();
 
    void notify( const QString &msg );
 
 
  protected:
 
    QDateTime mTimestamp;
 
    QgsError mError;
 
    void appendError( const QgsErrorMessage &message ) { mError.append( message ); }
 
    void setError( const QgsError &error ) { mError = error;}
 
    Qgis::DataProviderReadFlags mReadFlags;
 
  private:
 
    QString mDataSourceURI;
 
    QgsDataProvider::ProviderOptions mOptions;
 
    QMap< int, QVariant > mProviderProperties;
 
    mutable QMutex mOptionsMutex;
 
    virtual void reloadProviderData() {}
 
    friend class TestQgsProject;
};
 
#endif