StringConvertions.hpp

#ifndef STRINGCONVERTIONS_HPP
#define STRINGCONVERTIONS_HPP

#include <string>
#include <iomanip>
#include <sstream>
#include <vector>
#include <SFML/System/Vector2.hpp>
#include <SFML/System/Vector3.hpp>
#include <SFML/Graphics/Rect.hpp>
#include <SFML/Graphics/Color.hpp>

char operator<<(char* out, const std::string& in);

std::string& operator<<(std::string& out, char in);

unsigned char operator<<(unsigned char* out, const std::string& in);

std::string& operator<<(std::string& out, unsigned char in);


template<typename T>
void numericConvert(
    T* out,
    const std::string& in,
    typename std::enable_if<!std::is_enum<T>::value>::type* dummy = 0
) {
    T backup(*out);
    std::stringstream ss;
    ss.imbue(std::locale("C"));
    ss.str(in);
    ss >> *out;
    if(ss.fail())
        *out = backup;
}

template<typename T>
void numericConvert(
    T* out,
    const std::string& in,
    typename std::enable_if<std::is_enum<T>::value>::type* dummy = 0
) {
    T backup(*out);
    std::stringstream ss;
    ss.imbue(std::locale("C"));
    ss.str(in);
    int tmp = 0;
    ss >> tmp;
    if(!ss.fail())
        *out = static_cast<T>(tmp);
}

template<typename T>
T operator<<(T* out, const std::string& in) {
    numericConvert(out, in);
    return *out;
}

std::string& operator<<(std::string& out, sf::Color in);
sf::Color operator<<(sf::Color* out, const std::string& in);

template<typename T>
std::string numericConvert(
    const T& in,
    typename std::enable_if<!std::is_enum<T>::value>::type* dummy = 0
) {
    std::stringstream ss;
    ss.imbue(std::locale("C"));
    ss << std::setprecision(32) << in;
    return ss.str();
}

template<typename T>
std::string numericConvert(
    const T& in,
    typename std::enable_if<std::is_enum<T>::value>::type* dummy = 0
) {
    std::stringstream ss;
    ss.imbue(std::locale("C"));
    ss << std::setprecision(32) << static_cast<int>(in);
    return ss.str();
}

template<typename T>
std::string& operator<<(std::string& out, const T& in) {
    return out += numericConvert(in);
}

template<typename F, typename S>
std::string& operator<<(std::string& out, const std::pair<F,S>& in) {
    std::stringstream ss;
    ss.imbue(std::locale("C"));
    ss  << std::setprecision(32);

    if(sizeof(F) < 4) {
        ss << static_cast<long long>(in.first);
    } else {
        ss << in.first;
    }

    ss << " ";

    if(sizeof(S) < 4) {
        ss << static_cast<long long>(in.second);
    } else {
        ss << in.second;
    }
    return out += ss.str();
}

template<typename F, typename S>
std::pair<F,S> operator<<(std::pair<F,S>* out, const std::string& in) {
    std::pair<F,S> backup(*out);
    std::stringstream ss;
    ss.imbue(std::locale("C"));
    ss.str(in);
    if(!ss.good())
        return *out;

    if(sizeof(F) < 4) {
        long long i = 0;
        ss >> i;
        out->first = i;
    } else {
        ss >> out->first;
    }

    if(ss.fail())
        return (*out = backup);

    if(sizeof(S) < 4) {
        long long i = 0;
        ss >> i;
        out->second = i;
    } else {
        ss >> out->second;
    }

    if(ss.fail())
        return (*out = backup);

    return *out;
}

template<typename T>
std::string& operator<<(std::string& out, const sf::Vector2<T>& in) {
    std::stringstream ss;
    ss.imbue(std::locale("C"));
    ss << std::setprecision(32) << in.x << " " << in.y;
    return out += ss.str();
}

template<typename T>
sf::Vector2<T> operator<<(sf::Vector2<T>* out, const std::string& in) {
    sf::Vector2<T> backup(*out);
    std::stringstream ss;
    ss.imbue(std::locale("C"));
    ss.str(in);
    if(!ss.good())
        return *out;

    ss >> out->x;
    if(ss.fail())
        return (*out = backup);

    ss >> out->y;
    if(ss.fail())
        return (*out = backup);

    return *out;
}

template<typename T>
std::string& operator<<(std::string& out, const sf::Vector3<T>& in) {
    std::stringstream ss;
    ss.imbue(std::locale("C"));
    ss << std::setprecision(32) << in.x << " " << in.y << " " << in.z;
    return out += ss.str();
}

template<typename T>
sf::Vector3<T> operator<<(sf::Vector3<T>* out, const std::string& in) {
    sf::Vector3<T> backup(*out);
    std::stringstream ss;
    ss.imbue(std::locale("C"));
    ss.str(in);
    if(!ss.good())
        return *out;

    ss >> out->x;
    if(ss.fail())
        return (*out = backup);

    ss >> out->y;
    if(ss.fail())
        return (*out = backup);

    ss >> out->z;
    if(ss.fail())
        return (*out = backup);

    return *out;
}

template<typename T>
std::string& operator<<(std::string& out, const sf::Rect<T>& in) {
    std::stringstream ss;
    ss.imbue(std::locale("C"));
    ss << std::setprecision(32) << in.left << " " << in.top << " " << in.width << " " << in.height;
    return out += ss.str();
}

template<typename T>
sf::Rect<T> operator<<(sf::Rect<T>* out, const std::string& in) {
    sf::Rect<T> backup(*out);
    std::stringstream ss;
    ss.imbue(std::locale("C"));
    ss.str(in);
    if(!ss.good())
        return backup;

    ss >> out->left;
    if(ss.fail())
        return (*out = backup);

    ss >> out->top;
    if(ss.fail())
        return (*out = backup);

    ss >> out->width;
    if(ss.fail())
        return (*out = backup);

    ss >> out->height;
    if(ss.fail())
        return (*out = backup);

    return *out;
}

template<typename T>
std::string& operator<<(std::string& out, const std::vector<T>& in) {
    std::stringstream ss;
    ss.imbue(std::locale("C"));
    ss << std::setprecision(32);
    if(sizeof(T) < 4) {
        for(const auto& e : in) {
            int num = e;
            ss << num << " ";
        }
    } else {
        for(const auto& e : in) {
            ss << e << " ";
        }
    }

    return out += ss.str();
}

template<typename T>
std::string& operator<<(std::string& out, const std::vector<std::basic_string<T>>& in) {
    std::stringstream ss;
    ss.imbue(std::locale("C"));
    ss << std::setprecision(32);

    for(const auto& e : in) {
        ss << e << " ";
    }

    return out += ss.str();
}

template<typename T>
std::vector<T> operator<<(std::vector<T>* out, const std::string& in) {
    std::stringstream ss;
    ss.imbue(std::locale("C"));
    ss << std::setprecision(32);
    ss.str(in);

    if(sizeof(T) < 4) {
        while(ss.good()) {
            int tmp;
            ss >> tmp;
            if(ss.fail())
                break;

            out->push_back(tmp);
        }
    } else {
        while(ss.good()) {
            T tmp;
            ss >> tmp;
            if(ss.fail())
                break;

            out->push_back(tmp);
        }
    }

    return *out;
}

template<typename T>
std::vector<std::basic_string<T>> operator<<(std::vector<std::basic_string<T>>* out, const std::string& in) {
    std::stringstream ss;
    ss.imbue(std::locale("C"));
    ss << std::setprecision(32);
    ss.str(in);

    while(ss.good()) {
        std::basic_string<T> tmp;
        ss >> tmp;
        if(ss.fail())
            break;

        out->push_back(tmp);
    }

    return *out;
}

#endif // STRINGCONVERIONS_HPP