qgssettings.h

Go to the documentation of this file.

/***************************************************************************
  qgssettings.h
  --------------------------------------
  Date                 : January 2017
  Copyright            : (C) 2017 by Alessandro Pasotti
  Email                : apasotti at boundlessgeo 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 QGSSETTINGS_H
#define QGSSETTINGS_H
 
#include <QSettings>
#include <QMetaEnum>
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgslogger.h"
#include "qgssettingstreenode.h"
 
class QgsSettingsProxy;
 
class CORE_EXPORT QgsSettings : public QObject
{
    Q_OBJECT
  public:
 
    enum Section
    {
      NoSection,
      Core,
      Gui,
      Server,
      Plugins,
      Auth,
      App,
      Providers,
      Expressions,
      Misc,
      Gps, 
    };
    enum Section {…};
 
    explicit QgsSettings( const QString &organization,
                          const QString &application = QString(), QObject *parent = nullptr );
 
    QgsSettings( QSettings::Scope scope, const QString &organization,
                 const QString &application = QString(), QObject *parent = nullptr );
 
    QgsSettings( QSettings::Format format, QSettings::Scope scope, const QString &organization,
                 const QString &application = QString(), QObject *parent = nullptr );
 
    QgsSettings( const QString &fileName, QSettings::Format format, QObject *parent = nullptr );
 
    explicit QgsSettings( QObject *parent = nullptr );
    ~QgsSettings() override;
 
    void beginGroup( const QString &prefix, QgsSettings::Section section = QgsSettings::NoSection );
    void endGroup();
 
    QString group() const;
 
    QStringList allKeys() const;
    QStringList childKeys() const;
    QStringList childGroups( Qgis::SettingsOrigin origin = Qgis::SettingsOrigin::Any ) const;
    QStringList globalChildGroups() const;
    static QString globalSettingsPath();
    static bool setGlobalSettingsPath( const QString &path );
    int beginReadArray( const QString &prefix );
 
    void beginWriteArray( const QString &prefix, int size = -1 );
    void endArray();
 
    void setArrayIndex( int i );
 
    Qgis::SettingsOrigin origin( const QString &key ) const;
 
    void setValue( const QString &key, const QVariant &value, QgsSettings::Section section = QgsSettings::NoSection );
 
#ifndef SIP_RUN
    QVariant value( const QString &key, const QVariant &defaultValue = QVariant(),
                    Section section = NoSection ) const;
#else
    SIP_PYOBJECT value( const QString &key, const QVariant &defaultValue = QVariant(),
                        SIP_PYOBJECT type = 0,
                        QgsSettings::Section section = QgsSettings::NoSection ) const / ReleaseGIL /;
    % MethodCode
    typedef PyObject *( *pyqt_from_qvariant_by_type )( QVariant &value, PyObject *type );
    QVariant value;
 
    // QSettings has an internal mutex so release the GIL to avoid the possibility of deadlocks.
    Py_BEGIN_ALLOW_THREADS
    value = sipCpp->value( *a0, *a1, a3 );
    Py_END_ALLOW_THREADS
 
    pyqt_from_qvariant_by_type f = ( pyqt_from_qvariant_by_type ) sipImportSymbol( SIP_PYQT_FROM_QVARIANT_BY_TYPE );
    sipRes = f( value, a2 );
 
    sipIsErr = !sipRes;
    % End
#endif
 
 
#ifndef SIP_RUN
 
    template <class T>
    T enumValue( const QString &key, const T &defaultValue,
                 const Section section = NoSection )
    {
      const QMetaEnum metaEnum = QMetaEnum::fromType<T>();
      Q_ASSERT( metaEnum.isValid() );
      if ( !metaEnum.isValid() )
      {
        QgsDebugError( QStringLiteral( "Invalid metaenum. Enum probably misses Q_ENUM or Q_FLAG declaration." ) );
      }
 
      T v;
      bool ok = false;
 
      if ( metaEnum.isValid() )
      {
        // read as string
        QByteArray ba = value( key, metaEnum.valueToKey( static_cast<const int>( defaultValue ) ), section ).toString().toUtf8();
        const char *vs = ba.data();
        v = static_cast<T>( metaEnum.keyToValue( vs, &ok ) );
        if ( ok )
          return v;
      }
 
      // if failed, try to read as int (old behavior)
      // this code shall be removed later (probably after QGIS 3.4 LTR for 3.6)
      // then the method could be marked as const
      v = static_cast<T>( value( key, static_cast<const int>( defaultValue ), section ).toInt( &ok ) );
      if ( metaEnum.isValid() )
      {
        if ( !ok || !metaEnum.valueToKey( static_cast<int>( v ) ) )
        {
          v = defaultValue;
        }
        else
        {
          // found setting as an integer
          // convert the setting to the new form (string)
          setEnumValue( key, v, section );
        }
      }
 
      return v;
    }
    T enumValue( const QString &key, const T &defaultValue, {…}
 
    template <class T>
    void setEnumValue( const QString &key, const T &value,
                       const Section section = NoSection )
    {
      const QMetaEnum metaEnum = QMetaEnum::fromType<T>();
      Q_ASSERT( metaEnum.isValid() );
      if ( metaEnum.isValid() )
      {
        setValue( key, metaEnum.valueToKey( static_cast<const int>( value ) ), section );
      }
      else
      {
        QgsDebugError( QStringLiteral( "Invalid metaenum. Enum probably misses Q_ENUM or Q_FLAG declaration." ) );
      }
    }
    void setEnumValue( const QString &key, const T &value, {…}
 
    template <class T>
    T flagValue( const QString &key, const T &defaultValue,
                 const Section section = NoSection )
    {
      const QMetaEnum metaEnum = QMetaEnum::fromType<T>();
      Q_ASSERT( metaEnum.isValid() );
      if ( !metaEnum.isValid() )
      {
        QgsDebugError( QStringLiteral( "Invalid metaenum. Enum probably misses Q_ENUM or Q_FLAG declaration." ) );
      }
 
      T v = defaultValue;
      bool ok = false;
 
      if ( metaEnum.isValid() )
      {
        // read as string
        QByteArray ba = value( key, metaEnum.valueToKeys( static_cast< const int >( defaultValue ) ) ).toString().toUtf8();
        const char *vs = ba.data();
        v = static_cast<T>( metaEnum.keysToValue( vs, &ok ) );
      }
      if ( !ok )
      {
        // if failed, try to read as int
        const int intValue = value( key, static_cast<const int>( defaultValue ), section ).toInt( &ok );
        if ( metaEnum.isValid() )
        {
          if ( ok )
          {
            // check that the int value does correspond to a flag
            // see https://stackoverflow.com/a/68495949/1548052
            const QByteArray keys = metaEnum.valueToKeys( intValue );
            const int intValueCheck = metaEnum.keysToValue( keys );
            if ( intValue != intValueCheck )
            {
              v = defaultValue;
            }
            else
            {
              // found property as an integer
              v = T( intValue );
              // convert the property to the new form (string)
              // this code could be removed
              // then the method could be marked as const
              setFlagValue( key, v );
            }
          }
          else
          {
            v = defaultValue;
          }
        }
      }
 
      return v;
    }
    T flagValue( const QString &key, const T &defaultValue, {…}
 
    template <class T>
    void setFlagValue( const QString &key, const T &value,
                       const Section section = NoSection )
    {
      const QMetaEnum metaEnum = QMetaEnum::fromType<T>();
      Q_ASSERT( metaEnum.isValid() );
      if ( metaEnum.isValid() )
      {
        setValue( key, metaEnum.valueToKeys( static_cast< const int >( value ) ), section );
      }
      else
      {
        QgsDebugError( QStringLiteral( "Invalid metaenum. Enum probably misses Q_ENUM or Q_FLAG declaration." ) );
      }
    }
    void setFlagValue( const QString &key, const T &value, {…}
#endif
 
    bool contains( const QString &key, QgsSettings::Section section = QgsSettings::NoSection ) const;
    QString fileName() const;
 
    void sync();
    void remove( const QString &key, QgsSettings::Section section = QgsSettings::NoSection );
    QString prefixedKey( const QString &key, QgsSettings::Section section ) const;
    void clear();
 
    static void holdFlush() SIP_SKIP;
 
    static void releaseFlush() SIP_SKIP;
 
    static QgsSettingsProxy get() SIP_SKIP;
 
  private:
    void init();
    QString sanitizeKey( const QString &key ) const;
    QSettings *mUserSettings = nullptr;
    QSettings *mGlobalSettings = nullptr;
    bool mUsingGlobalArray = false;
    Q_DISABLE_COPY( QgsSettings )
 
};
class CORE_EXPORT QgsSettings : public QObject {…};
 
// as static members cannot be CORE_EXPORTed
extern thread_local QgsSettings *sQgsSettingsThreadSettings SIP_SKIP;
 
#endif // QGSSETTINGS_H