IniProfile.h

Go to the documentation of this file.

#pragma once
#include <fstream>
#include <map>
#include <misc/gen/TStrings.h>
#include <misc/gen/TVector.h>
#include <misc/global.h>
#include <string>
#include <unordered_map>
 
namespace sf
{
 
class _MISC_CLASS IniProfile
{
  protected:
    class _MISC_CLASS Entry;
    class _MISC_CLASS Section;
 
  public:
    typedef TVector<Entry*> EntryVector;
 
    static constexpr size_t npos = EntryVector::npos;
 
    typedef EntryVector::size_type size_type;
 
    IniProfile();
 
    explicit IniProfile(const std::string& path);
 
    IniProfile(const IniProfile&) = delete;
 
    IniProfile(const IniProfile&&) = delete;
 
    IniProfile& operator=(IniProfile&) = delete;
 
    IniProfile& operator=(IniProfile&&) = delete;
 
    IniProfile(const std::string& section, const std::string& path);
 
    explicit IniProfile(const std::string_view& data);
 
    explicit IniProfile(std::istream& is);
 
    virtual ~IniProfile();
 
    bool getStringByRef(const std::string& key, std::string& value, const std::string& defaultString = {}) const;
 
    void flush();
 
    void setKeyPrefix(const std::string& prefix = {});
 
    std::string getString(const std::string& key, const std::string& defaultString = {}) const;
 
    bool setString(const std::string& key, const std::string& value);
 
    bool setInt(const std::string& key, int value);
 
    int getInt(const std::string& key, int defaultInt = 0) const;
 
    bool setFloat(const std::string& key, double value);
 
    double getFloat(const std::string& key, double defaultFloat = 0.0) const;
 
    bool setBool(const std::string& key, bool value);
 
    bool getBool(const std::string& key, bool defaultBool = false) const;
 
    bool setSection(const std::string& section, bool create = true);
 
    bool selectSection(const std::string& section) const;
 
    bool setSection(size_type index);
 
    [[nodiscard]] inline size_type getSectionCount() const;
 
    [[nodiscard]] std::string getSection(size_type p = npos) const;
 
    [[nodiscard]] string_list getSections() const;
 
    [[nodiscard]] size_type findSection(const std::string& section) const;
 
    [[nodiscard]] bool sectionExists(const std::string& section) const
    {
      return findSection(section) != npos;
    }
 
    bool keyExists(const std::string& key) const
    {
      // Lookup the key in current section and set the entry
      return _sections.empty() ? npos : _sections[_sectionIndex]->findEntry(key) != npos;
    }
 
    inline bool removeSection(const std::string& section);
 
    bool removeSection(size_type p);
 
    bool removeKeys(size_type section = npos);
 
    bool insertComment(const std::string& key, const std::string& comment);
 
    [[nodiscard]] size_type getEntryCount() const;
 
    size_type findEntry(const std::string& key);
 
    std::string getEntryKey(size_type p);
    string_list getKeys(const std::string& section) const;
 
    string_list getKeys(size_type section = npos) const;
 
    typedef std::unordered_map<std::string, std::string> KeyValueMap;
 
    void setMap(const KeyValueMap& map, size_type section = npos);
 
    KeyValueMap getMap(size_type section = npos) const;
 
    std::string getEntryValue(size_type p);
 
    bool removeKey(const std::string& key);
 
    bool removeEntry(size_type p);
 
    bool setFilepath(const std::string& path);
 
    const std::string& getFilepath() const;
 
    bool exists() const;
 
    void setWriteOnDirty(bool enable)
    {
      _writeOnDirty = enable;
    }
 
    bool sync();
 
    virtual std::ostream& write(std::ostream& os) const;
 
    std::ostream& writeSection(std::ostream& os) const;
 
    bool isDirty() const
    {
      return _dirty;
    }
 
    bool read(std::istream& is);
 
  protected:
    void initialize();
 
    bool load(const std::string& path);
 
    bool load(std::istream& is);
 
    class Entry
    {
      public:
        Entry() = default;
 
        Entry(const std::string& key, const std::string& value);
 
        explicit Entry(const std::string& comment);
 
        bool setLine(const std::string&);
 
        std::ostream& write(std::ostream& os);
 
        bool read(std::istream& is);
 
        [[nodiscard]] inline bool isValid() const;
 
      private:
        bool _cmtFlag{false};
        std::string _key;
        std::string _value;
 
        friend class IniProfile;
    };
 
    class Section
    {
      public:
        Section()
          : _entries(0)
        {}
 
        ~Section();
 
        IniProfile::EntryVector::size_type findEntry(const std::string& key);
 
        int setEntry(const std::string& key, const std::string& value);
 
        std::string getEntry(const std::string& key, const std::string& defValue);
 
        bool removeEntry(EntryVector::size_type index);
 
        bool insertComment(const std::string& key, const std::string& comment);
 
        std::ostream& write(std::ostream& os);
 
        bool read(std::istream& is);
 
        std::string _name;
 
        EntryVector _entries;
    };
 
    typedef TVector<Section*> SectionVector;
 
    Entry* getEntry(EntryVector::size_type p);
 
    SectionVector _sections;
    SectionVector::size_type _sectionIndex{npos};
    std::string _path;
    bool _dirty{false};
    bool _flagClearOnRead{true};
    bool _writeOnDirty{true};
    std::string _prefix;
};
 
inline IniProfile::size_type IniProfile::getSectionCount() const
{
  return _sections.count();
}
 
inline bool IniProfile::Entry::isValid() const
{
  return !_key.empty();
}
 
inline bool IniProfile::removeSection(const std::string& section)
{
  return removeSection(findSection(section));
}
 
inline std::ostream& operator<<(std::ostream& os, const IniProfile& profile)
{
  return profile.write(os);
}
 
}// namespace sf