IniFile.h

Go to the documentation of this file.

#ifndef __IniFile_h__
#define __IniFile_h__

#include <string>
#include <map>
#include <list>
#include <vector>

#include <YCP.h>

using std::map;
using std::multimap;
using std::list;
using std::vector;
using std::string;

class IniBase
{
protected:
    string name;
    string comment;
    int read_by;
    bool dirty;

    IniBase (int rb)
        : name (), comment (), read_by (rb), dirty (false) {}
    IniBase (const string &n)
        : name (n), comment (), read_by (0), dirty (true) {}
public:
    virtual ~IniBase () {}

    const char* getName()    const { return name.c_str();    }
    const char* getComment() const { return comment.c_str(); }
    int getReadBy()          const { return read_by;   }

    virtual void clean() { dirty = false; }

    void setName(const string&c)    { dirty = true; name = c;    }
    void setComment(const string&c) { dirty = true; comment = c; }
    void setReadBy(int r)           { dirty = true; read_by = r; }
    void setDirty()                 { dirty = true; }

    void initName(const string&c)    { if (!dirty) name = c;    }
    void initComment(const string&c) { if (!dirty) comment = c; }
    void initReadBy(const int r)     { if (!dirty) read_by = r; }

    void init(const string &n,const string&c, int rb)
            {
                if (!dirty)
                    {
                        name = n;
                        comment = c;
                        read_by = rb;
                    }
            }

protected:
    virtual YCPMap getAllDoIt () {
        YCPMap m;

        m->add (YCPString ("name"), YCPString (name));
        m->add (YCPString ("type"), YCPInteger (read_by));
        m->add (YCPString ("comment"), YCPString (comment));
        return m;
    }

    bool getMapString (const YCPMap &in, const string &k, string &s) {
        YCPValue v = in->value (YCPString (k));
        if (v.isNull () || !v->isString ())
        {
            y2error ("Missing in Write (.all): %s", k.c_str ());
            return false;
        }
        s = v->asString ()->value ();
        return true;
    }

    bool getMapInteger (const YCPMap &in, const string &k, int &i) {
        YCPValue v = in->value (YCPString (k));
        if (v.isNull () || !v->isInteger ())
        {
            y2error ("Missing in Write (.all): %s", k.c_str ());
            return false;
        }
        i = v->asInteger ()->value ();
        return true;
    }

    virtual int setAllDoIt (const YCPMap &in) {
        dirty = true;

        bool ok = true;
        ok = ok && getMapString (in, "name", name);
        ok = ok && getMapInteger (in, "type", read_by);
        ok = ok && getMapString (in, "comment", comment);
        return ok? 0: -1;
    }
};

class IniEntry : public IniBase
{
private:
    string val;
public:
    IniEntry ()
        : IniBase (0), val () {}
    IniEntry (const char *u): IniBase (u) {}

    const char* getValue()   const { return val.c_str();     }

    void setValue(const string&c)   { dirty = true; val = c;     }

    void initValue(const string&c)   { if (!dirty) val = c;     }
    void initReadBy(const int r)     { if (!dirty) read_by = r; }

    void init(const string &n, const string &c, int rb, const string &v)
            {
                if (!dirty)
                    {
                        val = v;
                        IniBase::init (n, c, rb);
                    }
            }

    YCPMap getAllDoIt () {
        YCPMap m = IniBase::getAllDoIt ();
        m->add (YCPString ("kind"), YCPString ("value"));
        m->add (YCPString ("value"), YCPString (val));
        return m;
    }

    int setAllDoIt (const YCPMap &in) {
        int ret = IniBase::setAllDoIt (in);
        if (ret == 0)
        {
            string kind;
            if (!getMapString (in, "kind", kind) || kind != "value")
            {
                y2error ("Kind should be 'value'");
                return -1;
            }

            if (!getMapString (in, "value", val))
            {
                return -1;
            }
        }
        return ret;
    }
};

class IniSection;


enum IniType { VALUE, SECTION,};
struct IniContainerElement;

typedef list<IniContainerElement> IniContainer;
typedef IniContainer::iterator IniIterator;

typedef multimap<string, IniIterator> IniEntryIndex;
typedef multimap<string, IniIterator> IniSectionIndex;
typedef IniEntryIndex::iterator IniEntryIdxIterator;
typedef IniSectionIndex::iterator IniSectionIdxIterator;

class IniParser;

class IniSection : public IniBase
{
private:
    // huh??? allow_values, allow_sections and allow_subsub
    // were never actuially used

    const IniParser *ip;

    string end_comment;

    bool is_private;

    int rewrite_by;

    IniContainer container;
    // these must be kept up to date!
    IniEntryIndex ivalues;
    IniSectionIndex isections;

    void reindex ();

    int getMyValue (const YCPPath &p, YCPValue &out, int what, int depth);
    int getValue (const YCPPath&p, YCPValue&out,int what, int depth = 0);
    int getSectionProp (const YCPPath&p, YCPValue&out,int what, int depth = 0);
    int getAll (const YCPPath&p, YCPValue&out, int depth);
    YCPMap getAllDoIt ();

    int myDir (YCPList& l, IniType what);

    int dirHelper (const YCPPath&p, YCPList&out,int sections,int depth = 0);
    int setMyValue (const YCPPath &p, const YCPValue&in, int what, int depth);
    int setValue (const YCPPath&p,const YCPValue&in,int what, int depth = 0);
    int setSectionProp (const YCPPath&p,const YCPValue&in, int what, int depth);
    int setAll (const YCPPath&p, const YCPValue& in, int depth);
    int setAllDoIt (const YCPMap &in);
    int delValue (const YCPPath&p, int depth);
    int delSection (const YCPPath&p, int depth);

    void delMyValue (const string &k);
    void delValue1 (IniEntryIdxIterator exi);
    void delSection1 (IniSectionIdxIterator sxi);

    int getValueFlat (const YCPPath&p, YCPValue&out);
    int setValueFlat (const YCPPath&p, const YCPValue& in);
    int delValueFlat (const YCPPath&p);
    int dirValueFlat (const YCPPath&p, YCPList&l);
//    IniSection ();
public:
    IniSection (const char *u): IniBase (u) {}

    IniSection (const IniParser *p)
        : IniBase (-1),
          ip (p),
          end_comment (), is_private(false), rewrite_by(-1),
          container (), ivalues (), isections ()
            {}

    IniSection (const IniSection &s) :
        IniBase (s),
          ip (s.ip),
          end_comment (s.end_comment), is_private(s.is_private), rewrite_by (s.rewrite_by),
          container (s.container)
        { reindex (); }

    void operator = (const IniSection &s)
        {
            if (&s == this)
            {
                return;
            } 
            IniBase::operator = (s);
            ip = s.ip;
            end_comment = s.end_comment;
            is_private = s.is_private;
            rewrite_by = s.rewrite_by;
            container = s.container;

            reindex ();
        }

    virtual ~IniSection () {}

    IniSection (const IniParser *p, string n)
        : IniBase (n),
          ip (p),
          end_comment (), is_private(false), rewrite_by(0),
          container(), ivalues (), isections ()
            {}
    void initValue (const string&key,const string&val,const string&comment,int rb);
    IniSection& initSection (const string&name,const string&comment,int rb, int wb=-2);
    void initReadBy () { read_by = -1; }

    void setRewriteBy (int c)           { dirty = true; rewrite_by = c; }
    int getRewriteBy() { return rewrite_by; }
    int getSubSectionRewriteBy (const char*name);

    void setPrivate(bool p) { is_private = p; }
    bool isPrivate() const { return is_private; }

    void setEndComment (const char*c);
    const char* getEndComment() const { return end_comment.c_str(); }

    bool isDirty ();
    virtual void clean();

    IniSection& findSection(const vector<string>&path, int from = 0);
    int findEndFromUp(const vector<string>&path, int wanted, int found = -1, int from = 0);

    void Dump ();

    int Read (const YCPPath&p, YCPValue&out, bool rewrite);
    int Dir (const YCPPath&p, YCPList&out);
    int Write (const YCPPath&p, const YCPValue&v, bool rewrite);
    int Delete (const YCPPath&p);

    // used by IniParser::write
    IniIterator getContainerBegin ();
    IniIterator getContainerEnd ();

//unused
//    IniEntry& getEntry (const char*name);
    IniSection& getSection (const char*name);
};

class IniContainerElement
{
    IniType     _t;
    IniEntry    _e;
    IniSection  _s;

public:
    IniType t () const { return _t; }
    const IniEntry& e () const { return _e; }
          IniEntry& e ()       { return _e; }
    const IniSection& s () const { return _s; }
          IniSection& s ()       { return _s; }

    IniContainerElement (const IniEntry& e) :
        _t (VALUE),
        _e (e),
//      _s (IniSection ("uninitialized"))
        _s (IniSection ((const IniParser *)NULL))
        {}

    IniContainerElement (const IniSection& s) :
        _t (SECTION),
//      _e (IniEntry ("uninitialized")),
        _e (IniEntry ()),
        _s (s)
        {}

    IniContainerElement (const IniContainerElement& c) :
        _t (c._t),
        _e (c._e),
        _s (c._s)
        {}
};


#endif//__IniFile_h__