conversion.hpp

Go to the documentation of this file.

#pragma once 
 
#include "to_string.hpp"
#include "from_string.hpp"
 
#include <string>
#include <bitset>
 
#ifdef FORMAT 
#include <format>
#else
#include <sstream>
#include <iomanip>
#endif
 
namespace gz {
        bool isInt(const std::string& s);
        bool isInt(const std::string_view& s);
        bool isUInt(const std::string& s);
        bool isUInt(const std::string_view& s);
        bool isFloat(const std::string& s);
        bool isFloat(const std::string_view& s);
        int getIntOr(const std::string& s, int fallback=0) noexcept;
        inline int getIntOr(const std::string_view& s, int fallback=0) noexcept { return getIntOr(std::string(s), fallback); }
 
        unsigned int getUnsignedIntOr(const std::string& s, unsigned int fallback=0) noexcept;
        /* inline unsigned int getUnsignedIntOr(const std::string&& s, unsigned int fallback=0) { return getUnsignedIntOr(s, fallback); } */
        inline unsigned int getUnsignedIntOr(const std::string_view& s, unsigned int fallback=0) noexcept { return getUnsignedIntOr(std::string(s), fallback); }
 
        double getDoubleOr(const std::string& s, double fallback=0) noexcept;
        /* inline double getDoubleOr(const std::string&& s, double fallback=0) { return getDoubleOr(s, fallback); } */
        inline double getDoubleOr(const std::string_view& s, double fallback=0) noexcept { return getDoubleOr(std::string(s), fallback); }
 
        float getFloatOr(const std::string& s, float fallback=0) noexcept;
        /* inline float getFloatOr(const std::string&& s, float fallback=0) { return getDoubleOr(s, fallback); } */
        inline float getFloatOr(const std::string_view& s, float fallback=0) noexcept { return getDoubleOr(std::string(s), fallback); }
 
        bool getBoolOr(const std::string& s, bool fallback=false) noexcept;
        /* inline bool getBoolOr(const std::string&& s, bool fallback=false) { return getBoolOr(s, fallback); } */
        inline bool getBoolOr(const std::string_view& s, bool fallback=false) noexcept { return getBoolOr(std::string(s), fallback); }
 
        std::string getStringOr(const std::string& s, const std::string& fallback="none") noexcept;
     
    //
    // HEX/OCT
    //
 
        template<std::integral T>
        std::string toHexString(const T& t, char digits=sizeof(T)*2) {
#ifdef FORMAT
            return std::format("{:#0" + std::to_string(digits) + "x}", t);
#endif
            std::stringstream ss;
            ss << "0x" << std::setfill('0') << std::setw(digits) << std::hex << t;
            return std::string(ss.str());
        }
 
        template<std::integral T>
        T fromHexString(const std::string& s) {
            T t;
            std::stringstream ss;
            ss << std::hex << s;
            ss >> t;
            return t;
        }
 
        template<std::integral T>
        std::string toOctString(const T& t, char digits=sizeof(T)*4) {
#ifdef FORMAT
            // TODO test when possible
            return std::format("{:#0" + std::to_string(digits) + "o}", t);
#endif
            std::stringstream ss;
            ss << "0" << std::setfill('0') << std::setw(digits) << std::oct << t;
            return std::string(ss.str());
        }
 
        template<std::integral T>
        T fromOctString(const std::string& s) {
            T t;
            std::stringstream ss;
            ss << std::oct << s;
            ss >> t;
            return t;
        }
 
        template<std::integral T>
        std::string toBinString(const T& t) {
#ifdef FORMAT
            // TODO test when possible
            return std::format("{:#0" + std::to_string(digits) + "b}", t);
#endif
            return std::string("0b") + std::bitset<sizeof(T)*8>(t).to_string();
        }
 
        template<std::integral T>
        T fromBinString(const std::string& s) {
            if (s.starts_with("0b")) {
                return static_cast<T>(std::bitset<sizeof(T)*8>(s, 2).to_ullong());
            }
            else {
                return static_cast<T>(std::bitset<sizeof(T)*8>(s).to_ullong());
            }
        }
 
 
        template<util::IntegralForwardRange T>
        std::string toHexString(const T& t) {
            std::string s = "[ ";
            for (auto it = t.begin(); it != t.end(); it++) {
                s += toHexString(*it) + ", ";
            }
            if (s.size() > 2) {
                s.erase(s.size() - 2);
            }
            s += " ]";
            return s;
        }
        template<util::IntegralForwardRange T>
        std::string toOctString(const T& t) {
            std::string s = "[ ";
            for (auto it = t.begin(); it != t.end(); it++) {
                s += toOctString(*it) + ", ";
            }
            if (s.size() > 2) {
                s.erase(s.size() - 2);
            }
            s += " ]";
            return s;
        }
        template<util::IntegralForwardRange T>
        std::string toBinString(const T& t) {
            std::string s = "[ ";
            for (auto it = t.begin(); it != t.end(); it++) {
                s += toBinString(*it) + ", ";
            }
            if (s.size() > 2) {
                s.erase(s.size() - 2);
            }
            s += " ]";
            return s;
        }
 
    template<typename T>
    concept StringConvertible = ConvertibleToString<T> and ConstructibleFromString<T>;
 
} // namespace gz
 
namespace gz {
} // namespace gz