keydata.h

Go to the documentation of this file.

// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
// Copyright (C) 2015 Cherokees of Idaho.
//
// This file is part of GNU uCommon C++.
//
// GNU uCommon C++ 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 3 of the License, or
// (at your option) any later version.
//
// GNU uCommon C++ 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 GNU uCommon C++.  If not, see <http://www.gnu.org/licenses/>.
 
#ifndef _UCOMMON_KEYDATA_H_
#define _UCOMMON_KEYDATA_H_
 
#ifndef _UCOMMON_CONFIG_H_
#include <ucommon/platform.h>
#endif
 
#ifndef  _UCOMMON_LINKED_H_
#include <ucommon/linked.h>
#endif
 
#ifndef  _UCOMMON_MEMORY_H_
#include <ucommon/memory.h>
#endif
 
namespace ucommon {
 
class keyfile;
 
class __EXPORT keydata : public OrderedObject
{
private:
    friend class keyfile;
 
    OrderedIndex index;
    const char *name;
    keyfile *root;
 
    keydata(keyfile *file);
    keydata(keyfile *file, const char *id);
    __DELETE_COPY(keydata);
 
public:
    class __LOCAL keyvalue : public OrderedObject
    {
    private:
        friend class keydata;
        friend class keyfile;
        keyvalue(keyfile *allocator, keydata *section, const char *key, const char *data);
        __DELETE_COPY(keyvalue);
 
    public:
        const char *id;
        const char *value;
    };
 
    friend class keyvalue;
 
    const char *get(const char *id) const;
 
    inline const char *operator()(const char *id) const {
        return get(id);
    }
 
    void set(const char *id, const char *value);
 
    void clear(const char *id);
 
    inline const char *get(void) const {
        return name;
    }
 
    inline keyvalue *begin(void) const {
        return (keyvalue *)index.begin();
    }
 
    inline keyvalue *end(void) const {
        return (keyvalue*)index.end();
    }
 
    typedef linked_pointer<keyvalue> pointer;
};
 
class __EXPORT keyfile : public memalloc
{
private:
    friend class keydata;
    OrderedIndex index;
    keydata *defaults;
    int errcode;
 
protected:
    keydata *create(const char *section);
 
#ifdef  _MSWINDOWS_
    void load(HKEY root, keydata *section = NULL, const char *path = NULL);
    bool save(HKEY root, keydata *section = NULL, const char *path = NULL);
#endif
 
public:
    keyfile(size_t pagesize = 0);
 
    keyfile(const char *path, size_t pagesize = 0);
 
    keyfile(const keyfile &copy, size_t pagesize = 0);
 
    void load(const char *path);
 
    bool save(const char *path);
 
    void load(const keyfile *source);
 
    void load(const keydata *source);
 
    void release(void);
 
    keydata *get(const char *section) const;
 
    inline keydata *operator()(const char *section) const {
        return get(section);
    }
 
    inline keydata *operator[](const char *section) const {
        return get(section);
    }
 
    inline keydata *get(void) const {
        return defaults;
    }
 
    inline keydata *begin(void) const {
        return (keydata *)index.begin();
    }
 
    inline keydata *end(void) const {
        return (keydata *)index.end();
    }
 
    typedef linked_pointer<keydata> pointer;
 
    inline int err(void) const {
        return errcode;
    }
 
    void assign(keyfile& source);
 
    inline keyfile& operator=(keyfile& source) {
        assign(source);
        return *this;
    }
};
 
} // namespace ucommon
 
#endif