StringConversions.h

#ifndef NEO_STRING_CONVERSIONS_H
#define NEO_STRING_CONVERSIONS_H

namespace neo
{

#pragma warning(push)
#pragma warning(disable:4996) // disable Microsoft warning about vsnprintf

#define NEO_VSNPRINTF(buf, size, fmt, ap) _vsntprintf(buf, size, fmt, ap);

inline tstring neoFormat(const TCHAR* fmt, ...)
{
    va_list ap;

    va_start(ap, fmt);
    int n = NEO_VSNPRINTF(0, 0, fmt, ap);
    va_end(ap);

    if(n < 0)
        return _T("");
    
    tstring str;
    str.resize(n+1);

    va_start(ap, fmt);
    n = NEO_VSNPRINTF(&str[0], n+1, fmt, ap);
    va_end(ap);

    // can it fail on the second try? Regardless, handle the error
    if(n < 0)
        return _T("");

    return str;
}

#pragma warning(pop) // enable warning again

//-----------------------------------------------------------------------------

// number to string
// definition for all bit lengths supported by the compiler
inline tstring neoToString(signed char value)
{ return neoFormat(_T("%hhd"), value); }
inline tstring neoToString(short value)
{ return neoFormat(_T("%hd"), value); }
inline tstring neoToString(int value)
{ return neoFormat(_T("%d"), value); }
inline tstring neoToString(long value)
{ return neoFormat(_T("%ld"), value); }
inline tstring neoToString(long long value)
{ return neoFormat(_T("%lld"), value); }

inline tstring neoToString(unsigned char value)
{ return neoFormat(_T("%hhu"), value); }
inline tstring neoToString(unsigned short value)
{ return neoFormat(_T("%hu"), value); }
inline tstring neoToString(unsigned int value)
{ return neoFormat(_T("%u"), value); }
inline tstring neoToString(unsigned long value)
{ return neoFormat(_T("%lu"), value); }
inline tstring neoToString(unsigned long long value)
{ return neoFormat(_T("%llu"), value); }

inline tstring neoToString(float value)
{ return neoFormat(_T("%.7g"), value); }
inline tstring neoToString(double value)
{ return neoFormat(_T("%.17g"), value); }
inline tstring neoToString(long double value)
{ return neoFormat(_T("%.17Lg"), value); }

// parse number
// definition for all bit lengths supported by the compiler
// this way the config will natively accept typedef'd integers like uint or LONG
inline signed char neoParseNumber(signed char, const tstring& text)
{ return std::stoi(text); }
inline short neoParseNumber(short, const tstring& text)
{ return std::stoi(text); }
inline int neoParseNumber(int, const tstring& text)
{ return std::stoi(text); }
inline long neoParseNumber(long, const tstring& text)
{ return std::stol(text); }
inline long long neoParseNumber(long long, const tstring& text)
{ return std::stoll(text); }

inline unsigned char neoParseNumber(unsigned char, const tstring& text)
{ return static_cast<unsigned char>(std::stoul(text)); }
inline unsigned short neoParseNumber(unsigned short, const tstring& text)
{ return static_cast<unsigned short>(std::stoul(text)); }
inline unsigned int neoParseNumber(unsigned int, const tstring& text)
{ return std::stoul(text); }
inline unsigned long neoParseNumber(unsigned long, const tstring& text)
{ return std::stoul(text); }
inline unsigned long long neoParseNumber(unsigned long long, const tstring& text)
{ return std::stoull(text); }

inline float neoParseNumber(float, const tstring& text)
{ return std::stof(text); }
inline double neoParseNumber(double, const tstring& text)
{ return std::stod(text); }
inline long double neoParseNumber(long double, const tstring& text)
{ return std::stold(text); }

template<typename T>
bool neoParse(const tstring& text, T& result)
{
    try
    {
        T parsed = neoParseNumber(T(), text);
        result = parsed;
        return true;
    }
    catch(...)
    {
        return false;
    }
}

//-----------------------------------------------------------------------------

inline tstring neoToString(const bool& value)
{
    return value ? _T("1") : _T("0");
}

inline bool neoParse(const tstring& text, bool& result)
{
    int i;
    if(neoParse(text, i))
    {
        result = i != 0;
        return true;
    }
    return false;
}

//-----------------------------------------------------------------------------

template<typename T>
bool configStructWrite(Config& conf, const tstring& key, const T& value)
{
    return conf.Write(key, neoToString(value));
}

template<typename T>
bool configStructRead(const Config& conf, const tstring& key, T& result)
{
    tstring text;
    return conf.Read(key, text) &&
        neoParse(text, result);
}

//-----------------------------------------------------------------------------

inline bool configStructWrite(Config& conf, const tstring& key, const Point& value)
{
    return conf.Write(key + _T(".x"), value.x) &&
        conf.Write(key + _T(".y"), value.y);
}

inline bool configStructRead(const Config& conf, const tstring& key, Point& result)
{
    LONG x,y;
    if( conf.Read(key + _T(".x"), x) &&
        conf.Read(key + _T(".y"), y))
    {
        result.x = x;
        result.y = y;
        return true;
    }
    return false;
}

//-----------------------------------------------------------------------------

inline bool configStructWrite(Config& conf, const tstring& key, const Size& value)
{
    return conf.Write(key + _T(".w"), value.cx) &&
        conf.Write(key + _T(".h"), value.cy);
}

inline bool configStructRead(const Config& conf, const tstring& key, Size& result)
{
    LONG w,h;
    if( conf.Read(key + _T(".w"), w) &&
        conf.Read(key + _T(".h"), h))
    {
        result.cx = w;
        result.cy = h;
        return true;
    }
    return false;
}

//-----------------------------------------------------------------------------

inline bool configStructWrite(Config& conf, const tstring& key, const Rect& value)
{
    return conf.Write(key + _T(".x"), value.left) &&
        conf.Write(key + _T(".y"), value.top) &&
        conf.Write(key + _T(".w"), value.Width()) &&
        conf.Write(key + _T(".h"), value.Height());
}

inline bool configStructRead(const Config& conf, const tstring& key, Rect& result)
{
    LONG x,y,w,h;
    if( conf.Read(key + _T(".x"), x) &&
        conf.Read(key + _T(".y"), y) &&
        conf.Read(key + _T(".w"), w) &&
        conf.Read(key + _T(".h"), h))
    {
        result = Rect(x, y, w, h);
        return true;
    }
    return false;
}

//-----------------------------------------------------------------------------

template<typename T>
bool configStructWrite(Config& conf, const tstring& key, const std::vector<T>& value)
{
    if(conf.Write(key + _T(".n"), value.size()))
    {
        for(size_t i = 0; i < value.size(); ++i)
        {
            conf.Write(key + _T(".") + std::to_wstring(i), value[i]);
        }
        return true;
    }
    return false;
}

template<typename T>
bool configStructRead(const Config& conf, const tstring& key, std::vector<T>& result)
{
    size_t n;
    if(!conf.Read(key + _T(".n"), n))
        return false;

    result.resize(n);
    for(size_t i = 0; i < n; ++i)
    {
        T& item = result[i];
        if(!conf.Read(key + _T(".") + std::to_wstring(i), item))
            return false;
    }
    return true;
}

} // neo

#endif