FromString.h

#pragma once
 
#include <string>
 
namespace mvlt
{
    template <class T>
    inline bool FromString(const std::string& stringToCopyDataFrom, T& data) noexcept { return false; }
 
    template <>
    inline bool FromString(const std::string& stringToCopyDataFrom, std::string& data) noexcept
    { 
        data = stringToCopyDataFrom;
        return true;
    }
 
    template <>
    inline bool FromString(const std::string& stringToCopyDataFrom, bool& data) noexcept
    {
        if (stringToCopyDataFrom == "true") 
        {
            data = true;
            return true;
        }
        if (stringToCopyDataFrom == "false") 
        {
            data = false;
            return true;
        }
        return false;
    }
 
    template <class T>
    inline bool FromStringDoubleAndFloat(const std::string& stringToCopyDataFrom, T& data) noexcept
    {
        if (stringToCopyDataFrom.length() == 0) return false;
 
        int integer = 0, fractional = 0;
 
        std::size_t i = 0;
        bool isNegative = false;
 
        if (stringToCopyDataFrom[0] == '-' && stringToCopyDataFrom.length() > 1) 
        {
            isNegative = true;
            i = 1;
        }
 
        for (; i < stringToCopyDataFrom.length(); ++i)
        {
            if (stringToCopyDataFrom[i] == '.') 
            {
                ++i;
                break;
            }
 
            if (stringToCopyDataFrom[i] < '0' || stringToCopyDataFrom[i] > '9') return false;
            integer *= 10;
            integer += static_cast<int>(stringToCopyDataFrom[i] - '0');
        }
 
        T coeff = 1;
        for (; i < stringToCopyDataFrom.length(); ++i)
        {
            if (stringToCopyDataFrom[i] < '0' || stringToCopyDataFrom[i] > '9') return false;
            coeff /= 10;
            fractional *= 10;
            fractional += static_cast<int>(stringToCopyDataFrom[i] - '0');
        }
 
        data = static_cast<T>(integer) + static_cast<T>(fractional) * coeff;
 
        if (isNegative) data *= -1;
 
        return true;
    }
 
    template <>
    inline bool FromString(const std::string& stringToCopyDataFrom, float& data) noexcept
    {
        return FromStringDoubleAndFloat(stringToCopyDataFrom, data);
    }
 
    template <>
    inline bool FromString(const std::string& stringToCopyDataFrom, double& data) noexcept
    {
        return FromStringDoubleAndFloat(stringToCopyDataFrom, data);
    }
 
    template <class T>
    inline bool FromStringSignedInt(const std::string& stringToCopyDataFrom, T& data) noexcept
    {
        if (stringToCopyDataFrom.length() == 0) return false;
 
        T res = 0;
        
        std::size_t i = 0;
        bool isNegative = false;
 
        if (stringToCopyDataFrom[0] == '-' && stringToCopyDataFrom.length() > 1) 
        {
            isNegative = true;
            i = 1;
        }
 
        for (; i < stringToCopyDataFrom.length(); ++i)
        {
            if (stringToCopyDataFrom[i] < '0' || stringToCopyDataFrom[i] > '9') return false;
            res *= 10;
            res += static_cast<int>(stringToCopyDataFrom[i] - '0');
        }
 
        if (isNegative) data = res * -1;
        else data = res;
 
        return true;
    }
 
    template <>
    inline bool FromString(const std::string& stringToCopyDataFrom, short& data) noexcept
    {
        return FromStringSignedInt(stringToCopyDataFrom, data);
    }
 
    template <>
    inline bool FromString(const std::string& stringToCopyDataFrom, int& data) noexcept
    {
        return FromStringSignedInt(stringToCopyDataFrom, data);
    }
 
    template <>
    inline bool FromString(const std::string& stringToCopyDataFrom, long& data) noexcept
    {
        return FromStringSignedInt(stringToCopyDataFrom, data);
    }
 
    template <>
    inline bool FromString(const std::string& stringToCopyDataFrom, long long& data) noexcept
    {
        return FromStringSignedInt(stringToCopyDataFrom, data);
    }
 
    template <class T>
    inline bool FromStringUnsignedInt(const std::string& stringToCopyDataFrom, T& data) noexcept
    {
        if (stringToCopyDataFrom.length() == 0) return false;
 
        T res = 0;
 
        for (std::size_t i = 0; i < stringToCopyDataFrom.length(); ++i)
        {
            if (stringToCopyDataFrom[i] < '0' || stringToCopyDataFrom[i] > '9') return false;
            res *= 10;
            res += static_cast<int>(stringToCopyDataFrom[i] - '0');
        }
 
        data = res;
        return true;
    }
 
    template <>
    inline bool FromString(const std::string& stringToCopyDataFrom, unsigned short& data) noexcept
    {
        return FromStringSignedInt(stringToCopyDataFrom, data);
    }
 
    template <>
    inline bool FromString(const std::string& stringToCopyDataFrom, unsigned int& data) noexcept
    {
        return FromStringSignedInt(stringToCopyDataFrom, data);
    }
 
    template <>
    inline bool FromString(const std::string& stringToCopyDataFrom, unsigned long& data) noexcept
    {
        return FromStringSignedInt(stringToCopyDataFrom, data);
    }
 
    template <>
    inline bool FromString(const std::string& stringToCopyDataFrom, unsigned long long& data) noexcept
    {
        return FromStringSignedInt(stringToCopyDataFrom, data);
    }
 
}