config-manager.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef COMMON_CONFIG_MANAGER_H
#define COMMON_CONFIG_MANAGER_H

#include "common/array.h"
#include "common/hashmap.h"
#include "common/path.h"
#include "common/singleton.h"
#include "common/str.h"
#include "common/hash-str.h"

namespace Common {

class WriteStream;
class SeekableReadStream;

class ConfigManager : public Singleton<ConfigManager> {

public:

    class Domain {
    private:
        StringMap _entries;
        StringMap _keyValueComments;
        String _domainComment;

    public:
        typedef StringMap::const_iterator const_iterator;
        const_iterator begin() const { return _entries.begin(); } 
        const_iterator end()   const { return _entries.end(); }   
        bool           empty() const { return _entries.empty(); } 
        bool           contains(const String &key) const { return _entries.contains(key); } 
        const String &operator[](const String &key) const { return _entries[key]; }

        void           setVal(const String &key, const String &value) { _entries.setVal(key, value); } 
        String &getOrCreateVal(const String &key) { return _entries.getOrCreateVal(key); }
        String        &getVal(const String &key) { return _entries.getVal(key); } 
        const String  &getVal(const String &key) const { return _entries.getVal(key); } 
        const String &getValOrDefault(const String &key) const { return _entries.getValOrDefault(key); }
        bool tryGetVal(const String &key, String &out) const { return _entries.tryGetVal(key, out); }

        void           clear() { _entries.clear(); } 
        void           erase(const String &key) { _entries.erase(key); } 
        void           setDomainComment(const String &comment); 
        const String  &getDomainComment() const; 
        void           setKVComment(const String &key, const String &comment); 
        const String  &getKVComment(const String &key) const; 
        bool           hasKVComment(const String &key) const; 
    };

    typedef HashMap<String, Domain, IgnoreCase_Hash, IgnoreCase_EqualTo> DomainMap;

    static char const *const kApplicationDomain;

    static char const *const kTransientDomain;

    static char const *const kKeymapperDomain;

    static char const *const kSessionDomain; 

#ifdef USE_CLOUD

    static char const *const kCloudDomain;
#endif

    bool                     loadDefaultConfigFile(const Path &fallbackFilename); 
    bool                     loadConfigFile(const Path &filename, const Path &fallbackFilename); 
    Domain *            getDomain(const String &domName);
    const Domain            *getDomain(const String &domName) const; 
    bool                     hasKey(const String &key) const; 
    const String            &get(const String &key) const;    
    void                     set(const String &key, const String &value); 
    bool                     hasDefault(const String &key) const;

    void                setAndFlush(const String &key, const Common::String &value);

#if 1

    bool                     hasKey(const String &key, const String &domName) const; 
    const String            &get(const String &key, const String &domName) const; 
    void                     set(const String &key, const String &value, const String &domName); 
    void                     removeKey(const String &key, const String &domName); 
#endif

    int                      getInt(const String &key, const String &domName = String()) const; 
    bool                     getBool(const String &key, const String &domName = String()) const; 
    Path                     getPath(const String &key, const String &domName = String()) const; 
    void                     setInt(const String &key, int value, const String &domName = String()); 
    void                     setBool(const String &key, bool value, const String &domName = String()); 
    void                     setPath(const String &key, const Path &value, const String &domName = String()); 
    void                     registerDefault(const String &key, const String &value); 
    void                     registerDefault(const String &key, const char *value); 
    void                     registerDefault(const String &key, int value); 
    void                     registerDefault(const String &key, bool value); 
    void                     registerDefault(const String &key, const Path &value); 
    void                     flushToDisk(); 
    void                     setActiveDomain(const String &domName); 
    Domain                  *getActiveDomain() { return _activeDomain; } 
    const Domain            *getActiveDomain() const { return _activeDomain; } 
    const String            &getActiveDomainName() const { return _activeDomainName; } 
    void                     addGameDomain(const String &domName); 
    void                     removeGameDomain(const String &domName); 
    void                     renameGameDomain(const String &oldName, const String &newName); 
    void                     addMiscDomain(const String &domName); 
    void                     removeMiscDomain(const String &domName); 
    void                     renameMiscDomain(const String &oldName, const String &newName); 
    bool                     hasGameDomain(const String &domName) const; 
    bool                     hasMiscDomain(const String &domName) const; 
    bool                     isKeyTemporary(const String &key) const; 
    const DomainMap         &getGameDomains() const { return _gameDomains; } 
    DomainMap::iterator      beginGameDomains() { return _gameDomains.begin(); } 
    DomainMap::iterator      endGameDomains() { return _gameDomains.end(); } 
    const Path              &getCustomConfigFileName() { return _filename; } 
    static void              defragment(); 
    void                     copyFrom(ConfigManager &source); 
private:
    friend class Singleton<SingletonBaseType>;
    ConfigManager();

    bool            loadFallbackConfigFile(const Path &filename);
    bool            loadFromStream(SeekableReadStream &stream);
    void            addDomain(const String &domainName, const Domain &domain);
    void            writeDomain(WriteStream &stream, const String &name, const Domain &domain);
    void            renameDomain(const String &oldName, const String &newName, DomainMap &map);

    Domain          _transientDomain;
    DomainMap       _gameDomains;
    DomainMap       _miscDomains; // Any other domains
    Domain          _appDomain;
    Domain          _defaultsDomain;

    Domain          _keymapperDomain;

    Domain          _sessionDomain;     

#ifdef USE_CLOUD
    Domain          _cloudDomain;
#endif

    Array<String>   _domainSaveOrder;

    String          _activeDomainName;
    Domain *        _activeDomain;

    Path            _filename;
};

} // End of namespace Common

#define ConfMan     Common::ConfigManager::instance()

#endif