---

inifile.h

Go to the documentation of this file.

//
// Copyright (C) 2000
// Ralf Westram
// (Coded@ReallySoft.de)
//
// Permission to use, copy, modify, distribute and sell this software
// and its documentation for any purpose is hereby granted without fee,
// provided that the above copyright notice appear in all copies and
// that both that copyright notice and this permission notice appear
// in supporting documentation.  Ralf Westram makes no
// representations about the suitability of this software for any
// purpose.  It is provided "as is" without express or implied warranty.
//
// This code is part of my library.
// You may find a more recent version at http://www.reallysoft.de/
//

#ifndef INIFILE_H
#define INIFILE_H

#ifndef __MAP__
#include <map>
#endif

#ifndef ERR_H
#include "Err.h"
#endif
#ifndef TOOLS_H
#include "Tools.h"
#endif
#ifndef SMARTPTR_H
#include <smartptr.h>
#endif

namespace rs {

    namespace ini {

        //  ----------------------
        //      class Comment
        //  ----------------------

        const char comment_char = ';';

        enum ChangesState {
            NO_CHANGES,
            MINOR_CHANGES,
            MAJOR_CHANGES
        };

        extern bool need_check_for_changes;

        class Comment {
        private:
            std::string text;
            Comment *next;

            void split_multiline();

        public:
            Comment(const std::string& text_) : text(text_), next(0) { split_multiline(); }
            virtual ~Comment() { delete next; }

            void append(Comment *comment);

            void append(const std::string& text_) { append(new Comment(text_)); }

            void dump(std::ostream& out) const;
        };

        //  --------------------------
        //      class Commentable
        //  --------------------------

        class Commentable {
        private:
            Comment *comment;

        public:
            Commentable() : comment(0) {}
            virtual ~Commentable() { delete comment; }

            void append(Comment *cmt) {
                if (comment) comment->append(cmt);
                else comment = cmt;
            }

            void append(const std::string& text) { append(new Comment(text)); }

            void dump(std::ostream& out) const {
                if (comment) {
                    out << '\n';
                    comment->dump(out);
                }
            }

            bool comment_exists() const { return comment != 0; }
        };

#define UNDEFINED_FILEPOSITION (-1UL)

        // ----------------------------
        //      class FilePosition
        // ----------------------------
        class FilePosition {
        private:
            unsigned long lineNumber;

        public:
//             FilePosition() : lineNumber(UNDEFINED_FILEPOSITION) {}

            FilePosition(unsigned long lineNumber_) : lineNumber(lineNumber_) {}
            virtual ~FilePosition() {}

            bool is_defined() const { return lineNumber != UNDEFINED_FILEPOSITION; }

            unsigned long LineNumber() const { assert(is_defined()); return lineNumber; }

            void throw_Error(const std::string& filename, const std::string& message) const;
        };


        // --------------------------------------------------------------------------------
        //     class Entry
        // --------------------------------------------------------------------------------

        class Section;

        class Entry : public Commentable, public FilePosition {
        private:
            std::string  name;
            std::string  content;
            bool         changed;
            Section     *my_section;

            void set_changed() { changed = true; }

            friend class Section;

        public:

            Entry(const std::string& name_, const std::string& content_, unsigned long line_number = UNDEFINED_FILEPOSITION)
                : FilePosition(line_number), name(name_), content(content_), changed(false), my_section(0)
            {}
            virtual ~Entry() {}

            const Section *mySection() const { return my_section; }

            bool changesMade() const { return changed; }

            const std::string& getName() const { return name; }

            const std::string& getContent() const { return content; }

            void setContent(const std::string& content_) {
                if (content_ != content) {
                    content = content_;
                    set_changed();
                }
            }

            double getNumericContent() const;

            long getIntegerContent() const;


            void setNumericContent(double content_) {
                setContent(rs::str::strf("%f", content_));
            }

            void mark_obsolete() { name = std::string("obsoleteEntry_")+name; set_changed(); }

            bool operator<(const Entry& other) const { return str::stricmp(name, other.name) < 0; }

            void dump(std::ostream& out) const {
                Commentable::dump(out);
                out << getName() << '=' << getContent() << "\n";
            }
//             virtual void dump(ostream& out) const = 0;

            DECLARE_STREAM_OP(Entry);

            void throw_Error(const std::string& message) const;
        };

        typedef SmartPtr<Entry> EntryPtr;

        // --------------------------------------------------------------------------------
        //     class Section
        // --------------------------------------------------------------------------------

        struct ltistr {
            bool operator()(const std::string& s1, const std::string& s2) const {
                return s1<s2;
            }
        };

        typedef std::map<std::string, EntryPtr, ltistr > Entries;

        class Inifile;

        class Section : public Commentable, public FilePosition {
        private:
            std::string           name;
            Entries               entries;
            mutable ChangesState  changes_made;
            Inifile              *my_inifile;

            void set_changes_made(ChangesState mode) {
                if (mode>changes_made) {
                    changes_made           = mode;
                    need_check_for_changes = true;
                }
            }

            friend class Inifile;

            EntryPtr expectEntry(const std::string& name_) const;

        public:
            Section(const std::string& name_, unsigned long line_number) : FilePosition(line_number), name(name_), changes_made(NO_CHANGES), my_inifile(0) {}
            virtual ~Section() {}

            const Inifile *myInifile() const { return my_inifile; }

            const std::string& getName() const { return name; }

            void insertEntry(EntryPtr entry, ChangesState mode=MINOR_CHANGES) {
                assert(entry->my_section == 0);
                entry->my_section     = this;
                entry->set_changed();

                entries[entry->getName()] = entry;
                set_changes_made(mode);
            }

            const EntryPtr findEntry(const std::string& name_) const {
                return const_cast<Section&>(*this).findEntry(name_);
            }
            EntryPtr findEntry(const std::string& name_) {
                Entries::iterator e = entries.find(name_);
                if (e==entries.end()) return EntryPtr();
                return e->second;
            }

            EntryPtr findOrCreateEntry(const std::string& name_, const std::string& content, ChangesState mode=MINOR_CHANGES, const char *add_comment=0);

            EntryPtr findOrCreateEntry(const std::string& name_, long default_value, ChangesState mode=MINOR_CHANGES, const char *add_comment=0);

            EntryPtr findOrCreateEntry(const std::string& name_, std::string (*get_content)(), ChangesState mode = MINOR_CHANGES, const char *add_comment=0);

            const std::string& findStringEntry(const std::string& name_) const;

            double findNumericEntry(const std::string& name_) const;

            long findIntegerEntry(const std::string& name_) const;

            Entries::const_iterator begin() const { return entries.begin(); }
            Entries::const_iterator end() const { return entries.end(); }

            void clearEntries() { entries.clear(); }

            void dump(std::ostream& out) const {
                Commentable::dump(out);
                out << '[' << name << ']' << "\n";
                for (Entries::const_iterator e=entries.begin(); e!=entries.end(); ++e) {
                    out << *(e->second);
                }
                out << "\n";
            }
            DECLARE_STREAM_OP(Section);

            ChangesState changesMade() const;

            void fixState() { changes_made = NO_CHANGES; }

            void throw_Error(const std::string& message) const;
        };

        typedef SmartPtr<Section> SectionPtr;

        typedef std::map<std::string, SectionPtr, ltistr > Sections;

        // -----------------------
        //      class Inifile
        // -----------------------

        class Inifile
        {
        private:
            Sections sections;

            mutable ChangesState changes_made;

            std::string loaded_from_file;

            void set_changes_made(ChangesState mode) { if (mode>changes_made) changes_made = mode; }

        public:
            Inifile(const std::string& loaded_from_file_) : changes_made(NO_CHANGES), loaded_from_file(loaded_from_file_) {}
            virtual ~Inifile() {}

            Sections::const_iterator begin() const { return sections.begin(); }

            Sections::const_iterator end() const { return sections.end(); }

            const std::string& loadedFrom() const { return loaded_from_file; }

            void insertSection(SectionPtr section, ChangesState mode=MINOR_CHANGES) {
                assert(section->my_inifile == 0);
                section->my_inifile = this;
                section->set_changes_made(mode);

                sections[section->getName()] = section;
                set_changes_made(mode);
            }

            const SectionPtr findSection(const std::string& name_) const {
                return const_cast<Inifile&>(*this).findSection(name_);
            }
            SectionPtr findSection(const std::string& name_);

            SectionPtr expectSection(const std::string& name_) const;

            SectionPtr findOrCreateSection(const std::string& name_, ChangesState mode=MINOR_CHANGES);

            const EntryPtr findEntry(const std::string& section, const std::string& entry) const;

            EntryPtr findEntry(const std::string& section, const std::string& entry) {
                return const_cast<const Inifile*>(this)->findEntry(section, entry);
            }

            const std::string& findStringEntry(const std::string& section, const std::string& entry) const;

            double findNumericEntry(const std::string& section, const std::string& entry) const;

            long findIntegerEntry(const std::string& section, const std::string& entry) const;

            void dump(std::ostream& out) const {
                for (Sections::const_iterator s = sections.begin(); s!=sections.end(); ++s) {
                    out << *(s->second);
                }
            }
            DECLARE_STREAM_OP(Inifile);

            ChangesState changesMade() const;

            void fixState();
        };

        typedef SmartPtr<Inifile> InifilePtr;

        InifilePtr readInifile(const std::string& filename);

        void writeInifile(const std::string& filename, InifilePtr ini);

        typedef void (*InifileCompleter)(InifilePtr);

        InifilePtr readOrCreateInifile(const std::string& inifilename, InifileCompleter complete_ini);

    };
};

#else
#error inifile.h included twice
#endif // INIFILE_H

---

Contact me in case of errors or questions. This documentation is powered by .

(C) 2000-2002