CWE-ou-minkata/Sources/Plasma/PubUtilLib/plContainer/plConfigInfo.h

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#ifndef plConfigInfo_h_inc
#define plConfigInfo_h_inc

#include "plKeysAndValues.h"
#include "hsStlUtils.h"
#include <stdarg.h>

/////////////////////////////////////////////////

typedef std::vector<std::string>    plStringList;
typedef std::vector<std::wstring>   plWStringList;

/////////////////////////////////////////////////

class plConfigSource;
class plConfigInfo
{
public:
    typedef plKeysAndValues::Keys
        Keys;
    typedef plKeysAndValues::Values
        Values;
    typedef std::map<xtl::istring, plKeysAndValues>
        Sections;

    static const std::string& GlobalSection();
    
private:
    mutable Sections fSections;
    
public:
    plConfigInfo();
    plConfigInfo(const plConfigInfo & src);
    virtual ~plConfigInfo() {}
    plConfigInfo & operator =(const plConfigInfo & src);

    // REMOVE
    // remove all sections
    void Clear();
    // remove section
    void RemoveSection(const std::string & section);
    // remove key from section
    void RemoveKey(const std::string & section, const std::string & key);
    // QUERY
    // does this section exist?
    bool HasSection(const std::string & section) const;
    // does the given section contain this key?
    bool HasKey(const std::string & section, const std::string & key);
    // does any section contain this key?
    bool HasKeyAny(const std::string & key);
    // does any of the given sections contain this key?
    bool HasKeyIn(const std::string & key, const char * section1, ... /*, nil*/);
    bool HasKeyIn(const std::string & key, const std::vector<std::string> & sections );
    // does key in section have this value?
    bool KeyHasValue(const std::string & section, const std::string & key, const std::string & value);
    bool KeyHasValue(const std::string & section, const std::string & key, int value);
    bool KeyHasValue(const std::string & section, const std::string & key, double value);
    // ADD
    // add key=value to the section
    bool AddValue(const std::string & section, const std::string & key, const std::string & value, KAddValueMode mode=kAlwaysAdd);
    bool AddValue(const std::string & section, const std::string & key, int value, KAddValueMode mode=kAlwaysAdd);
    bool AddValue(const std::string & section, const std::string & key, double value, KAddValueMode mode=kAlwaysAdd);
    bool AddValues(const std::string & section, const std::string & key, const std::vector<std::string> & values, KAddValueMode mode=kAlwaysAdd);
    // GET
    plKeysAndValues GetSection(const std::string & section, bool & found);
    std::vector<std::string> GetSectionNames();
    // get value for key from given section
    std::string GetValue(const std::string & section, const std::string & key, const std::string & defval="", bool * outFound=nil) const;
    int GetValue(const std::string & section, const std::string & key, int defval, bool * outFound=nil) const;
    double GetValue(const std::string & section, const std::string & key, double defval, bool * outFound=nil) const;
    std::vector<std::string> GetAllValues(const std::string & section, const std::string & key) const;
    // get value for key from any section
    std::string GetValueAny(const std::string & key, const std::string & defval="", bool * outFound=nil) const;
    int GetValueAny(const std::string & key, int defval, bool * outFound=nil) const;
    double GetValueAny(const std::string & key, double defval, bool * outFound=nil) const;
    std::vector<std::string> GetAllValuesAny(const std::string & key) const;
    // get value for key from one of the given sections
    std::string GetValueIn(const std::string & key, const std::string & defval, bool * outFound, const char * section1, ... /*, nil*/) const;
    std::string GetValueIn(const std::string & key, const std::string & defval, bool * outFound, const std::vector<std::string> & sections ) const;
    int GetValueIn(const std::string & key, int defval, bool * outFound, const char * section1, ... /*, nil*/) const;
    int GetValueIn(const std::string & key, int defval, bool * outFound, const std::vector<std::string> & sections ) const;
    double GetValueIn(const std::string & key, double defval, bool * outFound, const char * section1, ... /*, nil*/) const;
    double GetValueIn(const std::string & key, double defval, bool * outFound, const std::vector<std::string> & sections ) const;
    std::vector<std::string> GetAllValuesIn(const std::string & key, const char * section1, ... /*, nil*/);
    // ITERATORS
    bool GetSectionIterators(Sections::const_iterator & iter, Sections::const_iterator & end) const;
    bool GetKeyIterators(const xtl::istring & section, Keys::const_iterator & iter, Keys::const_iterator & end) const;
    bool GetValueIterators(const xtl::istring & section, const xtl::istring & key, Values::const_iterator & iter, Values::const_iterator & end) const;
    // CONFIG SOURCE
    virtual bool ReadFrom(plConfigSource * src, KAddValueMode mode=kAlwaysAdd);
    virtual bool WriteTo(plConfigSource * src);
};

class plConfigInfoLogging
{
private:
    plConfigInfo fConfigInfo;

    plConfigInfo fLog;
public:
    plConfigInfoLogging(); 
    ~plConfigInfoLogging(); 

    plConfigInfo* GetConfigInfo() { return &fConfigInfo; }
    plConfigInfo* GetConfigInfoLog() { return &fLog; }

    bool GetValue(std::string& retval, const std::string & section, const std::string & key, const std::string & desc, const std::string& defval = "");
    bool GetValue(int& retval, const std::string & section, const std::string & key, const std::string & desc, int defval);
    bool GetValue(bool& retval, const std::string & section, const std::string & key, const std::string & desc, bool defval);
    bool GetValue(float& retval, const std::string & section, const std::string & key, const std::string & desc, float defval);
    bool GetValue(double& retval, const std::string & section, const std::string & key, const std::string & desc, double defval);
    bool GetAllValues(std::vector<std::string>& values, const std::string & section, const std::string & key, const std::string & desc);

#if USE_MULT_SECTIONS
    // get value for key from any section
    bool GetValueAny(std::string& retval, const std::string & key, const std::string & desc, const std::string & defval);
    bool GetValueAny(int &retval, const std::string & key, const std::string & desc, int defval);
    bool GetValueAny(bool& retval, const std::string & key, const std::string & desc, bool defval);
    bool GetValueAny(float& retval, const std::string & key, const std::string & desc, float defval);
    bool GetValueAny(double& retval, const std::string & key, const std::string & desc, double defval);
    bool GetAllValuesAny(std::vector<std::string>& values, const std::string & key, const std::string & desc);

    // get value for key from one of the given sections
    bool GetValueIn(std::string& retval, const std::string & key,  const std::string & desc, const std::string & defval, const char * section1, ... /*, nil*/);
    bool GetValueIn(std::string& retval, const std::string & key,  const std::string & desc, const std::string & defval, std::vector<std::string> & sections );
    bool GetValueIn(int& retval, const std::string & key,  const std::string & desc, int defval, const char * section1, ... /*, nil*/);
    bool GetValueIn(int& retval, const std::string & key,  const std::string & desc, int defval, std::vector<std::string> & sections );
    bool GetValueIn(bool& retval, const std::string & key,  const std::string & desc, bool defval, const char * section1, ... /*, nil*/);
    bool GetValueIn(bool& retval, const std::string & key,  const std::string & desc, bool defval, std::vector<std::string> & sections );
    bool GetValueIn(float& retval, const std::string & key,  const std::string & desc, double defval, const char * section1, ... /*, nil*/);
    bool GetValueIn(float& retval, const std::string & key,  const std::string & desc, double defval, std::vector<std::string> & sections );
    bool GetValueIn(double& retval, const std::string & key,  const std::string & desc, double defval, const char * section1, ... /*, nil*/);
    bool GetValueIn(double& retval, const std::string & key,  const std::string & desc, double defval, std::vector<std::string> & sections );
#endif
};

/////////////////////////////////////////////////

class plConfigSource
{
protected:
    std::string     fCurrSection;       // used in parsing
    std::string     fEffectiveSection;  // used in parsing
    KAddValueMode   fAddMode;           // used in parsing
    plConfigInfo *  fConfigInfo;
    
    void SplitAt(std::string & key, std::string & value, char splitter, std::string & in);
    virtual bool ReadString(const std::string & in);
    virtual bool ReadPair(std::string & key, std::string & value);
    virtual bool ReadList(char ** list);
    virtual bool ReadSubSource( const char * name ) { return true; }
    
protected:
    virtual bool ReadInto(plConfigInfo & configInfo, KAddValueMode mode=kAlwaysAdd);
    virtual bool WriteOutOf(plConfigInfo & configInfo);

public:
    plConfigSource() {}
    virtual ~plConfigSource() {}

    friend class plConfigInfo;
};


/////////////////////////////////////////////////

class plCmdLineConfigSource : public plConfigSource
{
    int fArgc;
    char ** fArgv;
    std::string fMySection;
protected:
    bool ReadInto(plConfigInfo & configInfo, KAddValueMode mode=kAlwaysAdd);
public:
    plCmdLineConfigSource(int argc, char ** argv, const char * mySection="CmdLine");
};


/////////////////////////////////////////////////

class plEnvConfigSource : public plConfigSource
{
    char ** fEnvp;
    std::string fMySection;
protected:
    bool ReadInto(plConfigInfo & configInfo, KAddValueMode mode=kAlwaysAdd);
public:
    plEnvConfigSource(char ** envp, const char * mySection="Environment");
};


/////////////////////////////////////////////////

class plIniConfigSource : public plConfigSource
{
protected:
    std::string fFileName;
    bool ReadInto(plConfigInfo & configInfo, KAddValueMode mode=kAlwaysAdd);
    bool WriteOutOf(plConfigInfo & configInfo);
public:
    plIniConfigSource(const char * iniFileName);
};

/////////////////////////////////////////////////
// just like above, but works with hsStream-derived classes

class hsStream;
class plIniStreamConfigSource : public plConfigSource
{
protected:
    hsStream * fStream;
    bool ReadInto(plConfigInfo & configInfo, KAddValueMode mode=kAlwaysAdd);
    bool WriteOutOf(plConfigInfo & configInfo);
public:
    plIniStreamConfigSource(hsStream * stream);
};

/////////////////////////////////////////////////

// an ini file reader/writer that ignores section headers and puts all
// data in an unnamed section, or more accurately, in a section named "".
class plIniNoSectionsConfigSource : public plConfigSource
{
    std::string fFileName;
protected:
    bool ReadString(const std::string & in);
    bool ReadInto(plConfigInfo & configInfo, KAddValueMode mode=kAlwaysAdd);
    bool WriteOutOf(plConfigInfo & configInfo);
public:
    plIniNoSectionsConfigSource(const char * iniFileName);
};

/////////////////////////////////////////////////

// an ini file reader that only reads specified sections
class plIniSectionConfigSource : public plIniConfigSource
{
    typedef std::vector<xtl::istring>
        Sections;
protected:
    Sections    fSections;
    bool ReadPair(std::string & key, std::string & value);
    bool ReadSubSource( const char * name );
public:
    plIniSectionConfigSource(const char * iniFileName, std::vector<std::string> & sections);
};

/////////////////////////////////////////////////

// TODO: This would be a cool thing. not needed right now though.
class plDatabaseConfigSource : public plConfigSource
{
protected:
    bool ReadInto(plConfigInfo & configInfo, KAddValueMode mode=kAlwaysAdd);
    bool WriteOutOf(plConfigInfo & configInfo);
public:
    plDatabaseConfigSource(const char * connectString);
};


/////////////////////////////////////////////////

class plDebugConfigSource : public plConfigSource
{
protected:
    std::string fFileName;
    bool WriteOutOf(plConfigInfo & configInfo);
public:
    plDebugConfigSource(){}
};

/////////////////////////////////////////////////

class plWWWAuthenticateConfigSource : public plConfigSource
{
    const std::string& fAuth;
protected:
    bool ReadInto(plConfigInfo & configInfo, KAddValueMode mode=kAlwaysAdd);
public:
    plWWWAuthenticateConfigSource(const std::string& auth);
};

////////////////////////////////////////////////////////////////////

// NOTE: plClass _must_ appear first in a multiple-inheritance list.
class plClass
{
public:
    virtual void Unused(){}
};

////////////////////////////////////////////////////////////////////

typedef bool (plClass::*TEvaluate)();
typedef bool (plClass::*TEvaluateConst)() const;
struct plEvaluate
{
    plClass * fTarget;
    bool (plClass::*fEvaluate)();
    bool (plClass::*fEvaluateConst)() const;
    plEvaluate( plClass * target=nil, TEvaluate evaluate=nil )
    : fTarget(target)
    , fEvaluate(evaluate)
    , fEvaluateConst(nil)
    {}
    plEvaluate( plClass * target, TEvaluateConst evaluate )
    : fTarget(target)
    , fEvaluateConst(evaluate)
    , fEvaluate(nil)
    {}
    bool operator()() 
    { 
        if (fEvaluate)
            return (fTarget)?(fTarget->*fEvaluate)():true;
        else
        if (fEvaluateConst)
            return (fTarget)?(fTarget->*fEvaluateConst)():true;
        else
            return true;
    }
};

////////////////////////////////////////////////////////////////////

typedef std::string (plClass::*TModify)(const std::string & value);

struct plModify
{
    plClass * fTarget;
    std::string (plClass::*fModify)(const std::string & value);
    plModify( plClass * target=nil, TModify modify=nil )
    : fTarget(target)
    , fModify(modify)
    {}
    std::string operator()(const std::string & value) { return (fTarget)?(fTarget->*fModify)(value):value;}
    std::string operator()(const std::string & value) const { return (fTarget)?(fTarget->*fModify)(value):value;}
};

////////////////////////////////////////////////////////////////////

class plConfigValueBase
{
public:
    std::string fConfigName;
    std::string fConfigGroup;
    plEvaluate  fReadEvaluate;      // returns true if we want to read this value from options
    plEvaluate  fWriteEvaluate;     // returns true if we want to write this value to options
    plModify    fReadModify;        // may modify the value being read from options
    plModify    fWriteModify;       // may modify the value being written to options
    plModify    fGetModify;         // may modify the value when being assigned
    plModify    fSetModify;         // may modify the value when being accessed
    plConfigValueBase( const char * configName="", const char * configGroup="" )
    : fConfigName(configName)
    , fConfigGroup(configGroup)
    {}
    void SetConfigName(const char * name) { fConfigName=(name)?name:"";}
    std::string GetConfigName() const { return fConfigName;}
    void SetConfigGroup(const char * group) { fConfigGroup=group;}
    std::string GetConfigGroup() const { return fConfigGroup;}
    bool HasConfigName() { return fConfigName.length()>0;}
    bool HasConfigGroup() { return fConfigGroup.length()>0;}
    virtual void ConfigRead(plConfigInfo * opts);
    virtual void ConfigWrite(plConfigInfo * opts);
    void SetValue(const char * value);
    std::string GetValue() const;
    virtual void ISetValue(const char * value) = 0;
    virtual std::string IGetValue() const = 0;

    void SetReadEvaluate(plClass * targetObj, TEvaluate evalFunc);
    void SetWriteEvaluate(plClass * targetObj, TEvaluate evalFunc);
    void SetWriteEvaluate(plClass * targetObj, TEvaluateConst evalFunc);
    void SetReadModify(plClass * targetObj, TModify modifyFunc);
    void SetWriteModify(plClass * targetObj, TModify modifyFunc);
    void SetGetModify(plClass * targetObj, TModify modifyFunc);
    void SetSetModify(plClass * targetObj, TModify modifyFunc);
};

////////////////////////////////////////////////////////////////////

class plConfigValue : public plConfigValueBase
{
public:
    plConfigValue( const char * configName="", const char * configGroup="" )
    : plConfigValueBase(configName, configGroup)
    {}
    std::string fConfigValue;
    void ISetValue(const char * value) { fConfigValue=value;}
    std::string IGetValue() const { return fConfigValue;}
};

////////////////////////////////////////////////////////////////////

class plConfigAggregateValue : public plConfigValueBase
{
public:
    std::vector<plConfigValueBase*> fItems;
    plConfigAggregateValue(
        const char * name=nil,
        // A vararg here would not work because of a
        // multiple inheritance issue. Classes that are
        // plConfigValueBase are likely to be derived from
        // plClass also. Since plClass must be first in
        // the inheritance list, the vararg would not
        // point to the plConfigValueBase vtable that we
        // need to access.
        plConfigValueBase * item1=nil,
        plConfigValueBase * item2=nil,
        plConfigValueBase * item3=nil,
        plConfigValueBase * item4=nil,
        plConfigValueBase * item5=nil,
        plConfigValueBase * item6=nil,
        plConfigValueBase * item7=nil);
    void ISetValue(const char * value);
    std::string IGetValue() const;
    void AddItem(plConfigValueBase * item);
    void AddItems(
        plConfigValueBase * item1=nil,
        plConfigValueBase * item2=nil,
        plConfigValueBase * item3=nil,
        plConfigValueBase * item4=nil,
        plConfigValueBase * item5=nil,
        plConfigValueBase * item6=nil,
        plConfigValueBase * item7=nil);
};

////////////////////////////////////////////////////////////////////

class plConfigValueProxy : public plConfigValueBase
{
    plConfigValueBase * fConfigurable;
public:
    plConfigValueProxy(plConfigValueBase * item=nil)
    : fConfigurable(item)
    {}
    void Set(plConfigValueBase * item) { fConfigurable=item;}
    void ISetValue(const char * value) { fConfigurable->ISetValue(value);}
    std::string IGetValue() const { return fConfigurable->IGetValue();}
};

////////////////////////////////////////////////////////////////////

class plConfigGroup
{
public:
    plConfigInfo fOpts;
    std::string fGroupName;
    std::vector<plConfigValueBase*> fItems;
    plConfigGroup(const char * groupName="");
    bool Read(plConfigSource * src);
    bool Write(plConfigSource * src);
    void AddItem(plConfigValueBase * item, const char * name=nil);
};

////////////////////////////////////////////////////////////////////

#endif  // plConfigInfo_h_inc