Config.hpp

Idź do dokumentacji tego pliku.

#if defined(_MSC_VER) && (_MSC_VER >= 1200)
#pragma once
#endif
#ifndef COMMON_CONFIG_H_
#define COMMON_CONFIG_H_

#include <typeinfo>

namespace common
{

class Stream;


class Config_pimpl;

class Item
{
public:
        virtual ~Item() { }
};

class Value : public Item
{
public:
        tstring Data;

        Value() { }
        Value(const tstring &s) : Data(s) { }
};

class List : public Item
{
public:
        STRING_VECTOR Data;
};


class Config : public Item
{
        DECLARE_NO_COPY_CLASS(Config)
        friend class Config_pimpl;

private:
        scoped_ptr<Config_pimpl> pimpl;

public:

        static const uint4 CM_MUST_EXIST     = 0x02;
        static const uint4 CM_MUST_NOT_EXIST = 0x04;
        static const uint4 CM_CREATE_PATH    = 0x08;
        static const uint4 CM_SAME_TYPE      = 0x10;

        Config();
        ~Config();

        void LoadFromString(const tstring &S);
        void LoadFromStream(Stream *S);
        void LoadFromFile(const tstring &FileName);
        void SaveToString(tstring *S) const;
        void SaveToStream(Stream *S) const;
        void SaveToFile(const tstring &FileName) const;

        Item * GetItem(const tstring &Path);
        Item * MustGetItem(const tstring &Path);

        bool GetData(const tstring &Path, tstring *Data);

        void MustGetData(const tstring &Path, tstring *Data);

        bool ItemExists(const tstring &Path);
        void ItemMustExists(const tstring &Path);

        bool SetItem(const tstring &Path, Item *a_Item, uint4 CreateMode);
        void MustSetItem(const tstring &Path, Item *a_Item, uint4 CreateMode);
        bool SetData(const tstring &Path, const tstring &Data, uint4 CreateMode);
        void MustSetData(const tstring &Path, const tstring &Data, uint4 CreateMode);

        bool DeleteItem(const tstring &Path);
        void MustDeleteItem(const tstring &Path);

        void GetElementNames(STRING_VECTOR *OutNames);


        template <typename T> T * GetItemEx(const tstring &Path);

        template <typename T> T * MustGetItemEx(const tstring &Path);

        template <typename T> bool GetDataEx(const tstring &Path, T *Data);

        template <typename T> void MustGetDataEx(const tstring &Path, T *Data);
        template <typename T> bool ItemExistsEx(const tstring &Path);
        template <typename T> void ItemMustExistsEx(const tstring &Path);

        template <typename T> bool SetDataEx(const tstring &Path, const T &Data, uint4 CreateMode);

        template <typename T> void MustSetDataEx(const tstring &Path, const T &Data, uint4 CreateMode);
};

template <typename T>
inline T * Config::GetItemEx(const tstring &Path)
{
        Item *i = GetItem(Path);
        if (i == 0)
                return 0;
        if (dynamic_cast<T*>(i) == 0)
                return 0;
        return i;
}

template <typename T>
inline T * Config::MustGetItemEx(const tstring &Path)
{
        Item *i = MustGetItem(Path);
        T *R;
        if ((R = dynamic_cast<T*>(i)) == 0)
                throw Error(_T("Cannot read configuration element from path \"") + Path + _T("\". Element type other than expected."));
        return R;
}

template <typename T>
inline bool Config::GetDataEx(const tstring &Path, T *Data)
{
        tstring s;
        if (!GetData(Path, &s))
                return false;
        if (!StrToSth<T>(Data, s))
                return false;
        return true;
}

template <typename T>
inline void Config::MustGetDataEx(const tstring &Path, T *Data)
{
        tstring s;
        MustGetData(Path, &s);
        if (!StrToSth<T>(Data, s))
                throw Error(_T("Cannot read configuration data from path: \"") + Path + _T("\". Conversion error."));
}

template <typename T>
inline bool Config::ItemExistsEx(const tstring &Path)
{
        Item *i = GetItem(Path);
        if (i == 0)
                return false;
        if (dynamic_cast<T*>(i) == 0)
                return false;
        return true;
}

template <typename T>
inline void Config::ItemMustExistsEx(const tstring &Path)
{
        Item *i = GetItem(Path);
        if (i == 0)
                throw Error(_T("Configuration element with path \"") + Path + _T("\" does not exist."));
        if (dynamic_cast<T*>(i) == 0)
                throw Error(_T("Configuration element with path \"") + Path + _T("\" has invalid type."));
}

template <typename T>
inline bool Config::SetDataEx(const tstring &Path, const T &Data, uint4 CreateMode)
{
        tstring s;
        SthToStr<T>(&s, Data);
        return SetData(Path, s, CreateMode);
}

template <typename T>
inline void Config::MustSetDataEx(const tstring &Path, const T &Data, uint4 CreateMode)
{
        tstring s;
        SthToStr<T>(&s, Data);
        MustSetData(Path, s, CreateMode);
}

extern scoped_ptr<Config> g_Config;

// code config

} // namespace common

#endif

---