Settings.h

/*
 * Copyright (C) 2005-2010 by Dr. Marc Boris Duerner
 *
 * This library 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.
 *
 * As a special exception, you may use this file as part of a free
 * software library without restriction. Specifically, if other files
 * instantiate templates or use macros or inline functions from this
 * file, or you compile this file and link it with other files to
 * produce an executable, this file does not by itself cause the
 * resulting executable to be covered by the GNU General Public
 * License. This exception does not however invalidate any other
 * reasons why the executable file might be covered by the GNU Library
 * General Public License.
 *
 * 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 Pt_Settings_h
#define Pt_Settings_h
 
#include <Pt/Api.h>
#include <Pt/SerializationInfo.h>
#include <string>
#include <cstddef>
 
namespace Pt {
 
class PT_API SettingsError : public SerializationError
{
    public:
        SettingsError(const char* what, std::size_t line);
 
        ~SettingsError() throw()
        {}
 
        std::size_t line() const
        { return _line; }
 
    private:
        std::size_t _line;
};
 
class PT_API Settings : private SerializationInfo
{
    public:
        class Entry
        {
            public:
                explicit Entry(SerializationInfo* si = 0)
                : _si(si)
                {}
 
                Entry(const Entry& entry)
                : _si(entry._si)
                {}
 
                Entry& operator=(const Entry& entry)
                {
                    _si = entry._si;
                    return *this;
                }
 
                template <typename T>
                bool get(T& value) const
                {
                    if( ! _si )
                        return false;
 
                    *_si >>= value;
                    return true;
                }
 
                template <typename T>
                void set(const T& value)
                {
                    if( _si )
                    {
                        _si->setVoid();
                        *_si <<= value;
                    }
                }
 
                Entry addEntry(const std::string& name)
                {
                    if( ! _si )
                        return Entry();
 
                    SerializationInfo& si = _si->addMember(name);
                    return Entry(&si);
                }
 
                Entry addEntry(const char* name)
                {
                    if( ! _si )
                        return Entry();
 
                    SerializationInfo& si = _si->addMember(name);
                    return Entry(&si);
                }
 
                Entry addEntry()
                {
                    if( ! _si )
                        return Entry();
 
                    SerializationInfo& si = _si->addElement();
                    return Entry(&si);
                }
 
                void removeEntry(const std::string& name)
                {
                    if( _si )
                        _si->removeMember(name);
                }
                
                void removeEntry(const char* name)
                {
                    if( _si )
                        _si->removeMember(name);
                }
 
                void removeEntry(const Entry& e)
                {
                    if( ! _si || ! e._si )
                      return;
 
                    _si->removeMember( *e._si );
                }
 
                Entry begin() const
                {
                    if( ! _si )
                        return this->end();
 
                    SerializationInfo::Iterator it =_si->begin();
                    if( it == _si->end() )
                        return this->end();
 
                    SerializationInfo& si = *it;
                    return Entry(&si);
                }
 
                Entry end() const
                {
                    return Entry();
                }
 
                Entry entry(const std::string& name) const
                {
                    if( ! _si )
                        return this->end();
 
                    SerializationInfo* si = _si->findMember(name);
                    return Entry(si);
                }
                
                Entry entry(const char* name) const
                {
                    if( ! _si )
                        return this->end();
 
                    SerializationInfo* si = _si->findMember(name);
                    return Entry(si);
                }
 
                Entry makeEntry(const char* name)
                {
                    if( ! _si )
                        return this->end();
 
                    SerializationInfo* si = _si->findMember(name);
                    if( ! si )
                        si = &_si->addMember(name);
                    
                    return Entry(si);
                }
 
                Entry makeEntry(const std::string& name)
                {
                    if( ! _si )
                        return this->end();
 
                    SerializationInfo* si = _si->findMember(name);
                    if( ! si )
                        si = &_si->addMember(name);
                    
                    return Entry(si);
                }
                
                Entry operator[] (const std::string& name) const
                {
                    return this->entry(name);
                }
 
                Entry operator[] (const char* name) const
                {
                    return this->entry(name);
                }
 
                const char* name() const
                { return _si->name(); }
 
                Entry& operator*()
                { return *this; }
 
                Entry* operator->()
                { return this; }
 
                Entry& operator++()
                {
                    _si = _si->sibling();
                    return *this;
                }
 
                bool operator!=(const Entry& other) const
                { return _si != other._si; }
 
                bool operator==(const Entry& other) const
                { return _si == other._si; }
 
                bool operator!() const
                { return _si == 0; }
 
            private:
                SerializationInfo* _si;
        };
 
        class ConstEntry
        {
            public:
                explicit ConstEntry(const SerializationInfo* si = 0)
                : _si(si)
                {}
 
                template <typename T>
                bool get(T& value) const
                {
                    if( ! _si )
                        return false;
 
                    *_si >>= value;
                    return true;
                }
 
                ConstEntry begin() const
                {
                    if( ! _si )
                        return this->end();
 
                    SerializationInfo::ConstIterator it =_si->begin();
                    if(it == _si->end())
                        return this->end();
 
                    const SerializationInfo& si = *it;
                    return ConstEntry(&si);
                }
 
                ConstEntry end() const
                {
                    return ConstEntry();
                }
 
                ConstEntry entry(const std::string& name) const
                {
                    if( ! _si )
                        return end();
 
                    const SerializationInfo* si = _si->findMember(name);
                    return ConstEntry(si);
                }
 
                ConstEntry entry(const char* name) const
                {
                    if( ! _si )
                        return end();
 
                    const SerializationInfo* si = _si->findMember(name);
                    return ConstEntry(si);
                }
 
                ConstEntry operator[] (const std::string& name) const
                {
                    return this->entry(name);
                }
 
                ConstEntry operator[] (const char* name) const
                {
                    return this->entry(name);
                }
 
                const char* name() const
                { return _si->name(); }
 
                const ConstEntry& operator*() const
                { return *this; }
 
                const ConstEntry* operator->() const
                { return this; }
 
                ConstEntry& operator++()
                {
                    _si = _si->sibling();
                    return *this;
                }
 
                bool operator!=(const ConstEntry& other) const
                { return _si != other._si; }
 
                bool operator==(const ConstEntry& other) const
                { return _si == other._si; }
 
                bool operator!() const
                { return _si == 0; }
 
            private:
                const SerializationInfo* _si;
        };
 
    public:
        Settings();
 
        void clear();
 
        bool isEmpty() const;
        
        void setName(const char* name);
 
        ConstEntry begin() const
        { return root().begin(); }
 
        ConstEntry end() const
        { return root().end(); }
 
        ConstEntry root() const
        { return ConstEntry(this); }
 
        Entry begin()
        { return root().begin(); }
 
        Entry end()
        { return root().end(); }
 
        Entry root()
        { return Entry(this); }
 
        void load(std::basic_istream<Pt::Char>& is);
 
        void load(Pt::Formatter& formatter);
 
        void save(std::basic_ostream<Pt::Char>& os) const;
 
        void save(Pt::Formatter& formatter) const;
 
        ConstEntry entry(const std::string& name) const
        {
            return root().entry(name);
        }
 
        ConstEntry entry(const char* name) const
        {
            return root().entry(name);
        }
 
        ConstEntry operator[] (const std::string& name) const
        {
            return this->entry(name);
        }
 
        ConstEntry operator[] (const char* name) const
        {
            return this->entry(name);
        }
 
        Entry entry(const std::string& name)
        {
            SerializationInfo* si = this->findMember(name);
            return Entry(si);
        }
 
        Entry entry(const char* name)
        {
            SerializationInfo* si = this->findMember(name);
            return Entry(si);
        }
 
        Entry addEntry(const char* name)
        {
            return root().addEntry(name);
        }
 
        Entry addEntry(const std::string& name)
        {
            return root().addEntry(name);
        }
 
        Entry makeEntry(const char* name)
        {
            return root().makeEntry(name);
        }
 
        Entry makeEntry(const std::string& name)
        {
            return root().makeEntry(name);
        }
 
        void removeEntry(const char* name)
        {
            root().removeEntry(name);
        }
 
        void removeEntry(const std::string& name)
        {
            root().removeEntry(name);
        }
 
        Entry operator[] (const std::string& name)
        {
            return this->entry(name);
        }
 
        Entry operator[] (const char* name)
        {
            return this->entry(name);
        }
};
 
} // namespace Pt
 
#endif