ZSettings.h

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2015 Bob Dinitto
 *
 * Filename:   ZSettings.h
 * Created on: 5/16/2015
 * Author:     Bob Dinitto
 *
 * Zuble is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#ifndef ZSETTINGS_H
#define ZSETTINGS_H

#include <QObject>
#include <QSettings>
#include <QFileSystemWatcher>
#include "zblcore_global.h"
#include "zglobal.h"

namespace Zbl
{

class ZFileSystemWatcher;

class ZBLCORESHARED_EXPORT ZSettings : public QObject
{
    Q_OBJECT

    class SettingsBundle
    {
    public:
        SettingsBundle(){}

        SettingsBundle(const QString& dataPath)
            : m_dataPath(dataPath){}

        SettingsBundle(const QString& metaPath, const QString& dataPath)
            : m_metaPath(metaPath),
              m_dataPath(dataPath){}

        SettingsBundle(const QString& meta, const QString& dataPath, bool metaAtomic)
            :m_dataPath(dataPath){if(metaAtomic) m_metaData = meta; else m_metaPath = meta;}

        SettingsBundle(const QString& metaPath,
                       QSettings::Scope scope = QSettings::UserScope,
                       const QString& organization = QString(),
                       const QString& application = QString())
            : m_metaPath(metaPath),
              m_organization(organization),
              m_application(application),
              m_scope(scope){}

        QString m_metaPath;
        QString m_metaData;
        QString m_dataPath;
        QString m_organization;
        QString m_application;
        QSettings::Scope m_scope;
    };

    typedef QMap<QString, SettingsBundle> bundleMap;



public:
    explicit ZSettings(QObject *parent = nullptr);
    virtual ~ZSettings();

    static void registerType();

    static void zInit();


    Q_PROPERTY(QVariant tags READ getTags)

    
    Q_PROPERTY(QVariant fileName READ getFileName CONSTANT)



    Q_PROPERTY(QStringList allKeys READ getAllKeys)

    Q_PROPERTY(QStringList childKeys READ getChildKeys)

    Q_PROPERTY(QStringList childGroups READ getChildGroups)

    Q_PROPERTY(bool isWritable READ getWritable)

    Q_PROPERTY(int format READ getFormat)

    Q_PROPERTY(int scope READ getScope)

    Q_PROPERTY(QString organizationName READ getOrganizationName)

    Q_PROPERTY(QString applicationName READ getApplicationName)




    QVariant getTags();
    QString getFileName() const;

    QStringList getAllKeys() const;
    QStringList getChildKeys() const;
    QStringList getChildGroups() const;
    bool getWritable() const;
    int getFormat() const;
    int getScope() const;
    QString getOrganizationName() const;
    QString getApplicationName() const;

    //void setFallbacksEnabled(bool b);
    //bool fallbacksEnabled() const;



    static bool readFunc(QIODevice &device, QSettings::SettingsMap &map);

    static bool writeFunc(QIODevice &device, const QSettings::SettingsMap &map);

    Q_INVOKABLE bool open(int scope = static_cast<int>(QSettings::UserScope),
              const QString& application = QString(),
              const QString& organization = QString());

    Q_INVOKABLE bool open(const QString& filePath);

    Q_INVOKABLE bool setFileWatcher(bool enabled);


    Q_INVOKABLE void clear();
    Q_INVOKABLE void sync();
    Q_INVOKABLE int status() const;

    Q_INVOKABLE void setValue(const QString &key, const QVariant &value);
    Q_INVOKABLE QVariant value(const QString &key, const QVariant &defaultValue = QVariant()) const;

    Q_INVOKABLE void remove(const QString &key);
    Q_INVOKABLE bool contains(const QString &key) const;

    Q_INVOKABLE void beginGroup(const QString &prefix);
    Q_INVOKABLE void endGroup();
    Q_INVOKABLE QString group() const;

    Q_INVOKABLE int beginReadArray(const QString &prefix);
    Q_INVOKABLE void beginWriteArray(const QString &prefix, int size = -1);
    Q_INVOKABLE void endArray();
    Q_INVOKABLE void setArrayIndex(int i);


    static bool containsBundle(const QString& id);

    static bool insertBundle(
            const QString& id,
            const QString& metaPath,
            QSettings::Scope scope = QSettings::UserScope,
            const QString organization = QString(),
            const QString application = QString());

    static bool insertBundle(
            const QString& id,
            const QString& meta,
            const QString& dataPath,
            bool metaAtomic = false);

    static QVariant getBundle(const QString& id);

    static ZSettings* getBundleSettings(const QString& id);
    static QString getBundleMetapath(const QString& id);
    static QString getBundleMetadata(const QString& id);
    static QVariant getAllBundles();

    static bool mapConfigSettings(const char* configFilePath);

    //static bool realizeSettings(const QString& settingsMetafilePath);

    static bool realizeSettings(const QString& id, const SettingsBundle& settingsBundle);

    static QString scopeToText(QSettings::Scope scope);
    static QSettings::Scope textToScope(const QString& text);


    Q_INVOKABLE bool hasBundle(const QString& id) const;
    Q_INVOKABLE bool insertBundle(const QString& id, QVariant bundle);
    Q_INVOKABLE QVariant bundle(const QString& id) const;
    Q_INVOKABLE QVariant allBundles() const;




/*

    //void beginGroup(const QString &prefix);
    //void endGroup();
    //QString group() const;

    //int beginReadArray(const QString &prefix);
    //void beginWriteArray(const QString &prefix, int size = -1);
    //void endArray();
    //void setArrayIndex(int i);

    QStringList allKeys() const;
    QStringList childKeys() const;
    QStringList childGroups() const;
    bool isWritable() const;


    void setFallbacksEnabled(bool b);
    bool fallbacksEnabled() const;

    //QString fileName() const;
    Format format() const;
    Scope scope() const;
    QString organizationName() const;
    QString applicationName() const;



//#ifndef QT_NO_TEXTCODEC
//    void setIniCodec(QTextCodec *codec);
//    void setIniCodec(const char *codecName);
//    QTextCodec *iniCodec() const;
//#endif


    static void setDefaultFormat(Format format);
    static Format defaultFormat();
    static void setSystemIniPath(const QString &dir); // ### Qt 6: remove (use setPath() instead)
    static void setUserIniPath(const QString &dir);   // ### Qt 6: remove (use setPath() instead)
    static void setPath(Format format, Scope scope, const QString &path);

*/

signals:

    void settingsModified(const QString& path);

    void updateValue(
            const QString& settingPath,
            const QString& settingName,
            QVariant oldValue,
            QVariant newValue);

public slots:

protected:

    //static bool insertBundle(const QString& id, const SettingsBundle& bundle);


    static void createTags();

    static void dumpMap(const QSettings::SettingsMap &map);
    static void dumpGroup(const QString& groupKey, const QVariant& group);
    inline void validateStatus() const;
    bool open(const SettingsBundle& settingsBundle);
    bool validateOpen();
    static QString rectifySettingsDataPath(const QString& dataPath);
    static bool ensureFileExists(const QString& filePath);
    inline void validateWatcher() const;

    void onFileChanged(const QString &path);


    static QVariant m_tags;

    QSettings* m_s;

    static QSettings::Format m_format;

    static const QString m_ext;

    static qint64 m_maxFileSize;

    static bundleMap m_bundles;

    static ZFileSystemWatcher* m_watcher;

    bool m_watching;

    ZBL_DECLARE_LOGGED_OBJECT
};

typedef QScopedPointer<ZSettings> ZScopedSettings;

inline void ZSettings::validateStatus() const
{
    if(!m_s)
        throw ZblException("Settings object not initialized. "
                           "Use ZSettings::open method to open the settings object.");
}

inline void ZSettings::validateWatcher() const
{
    if(!m_watcher)
        throw ZblException("Settings watcher not initialized.");
}




} // Zbl

#endif // ZSETTINGS_H