to_string.hpp

Go to the documentation of this file.

#pragma once
 
#include "../concepts.hpp"
 
#include <string>
#include <string_view>
#include <ranges>
 
#define GZ_UTIL_STRING_CONCEPTS
 
template<gz::util::False T>
std::string toString(const T& s);
 
namespace gz::util {
        template<typename T> 
        concept Stringy = util::IsInPack<T, std::string, std::string_view, const char*>;
 
        template<typename T> 
        concept CanConstructString = 
            !Stringy<T> && 
            requires(const T& t) {
                { std::string(t) } -> std::same_as<std::string>;
            };
 
        template<typename T>
        concept HasToStringMember = 
            !Stringy<T> &&
            !CanConstructString<T> &&
            requires(const T& t) { { t.toString() }-> Stringy; };
 
        template<typename T>
        concept HasToStringMember2 = 
            !Stringy<T> &&
            !CanConstructString<T> &&
            !HasToStringMember<T> &&
            requires(const T& t) { { t.to_string() }-> Stringy; };
 
        template<typename T>
        concept WorksWithStdToString = 
            !Stringy<T> && 
            !CanConstructString<T> &&
            !HasToStringMember<T> && 
            !HasToStringMember2<T> &&
            requires(const T& t) { { std::to_string(t) } -> Stringy; };
 
        template<typename T>
        concept ConvertibleToStringGlobal = 
            !Stringy<T> && 
            !CanConstructString<T> &&
            !HasToStringMember<T> && 
            !HasToStringMember2<T> &&
            !WorksWithStdToString<T> &&
            requires(const T& t) { 
                { ::toString(t) } -> std::same_as<std::string>; 
            };
 
        template<typename T>
        concept _ToStringBasicNoPtr = 
            Stringy<T> || 
            CanConstructString<T> ||
            HasToStringMember<T> ||
            HasToStringMember2<T> ||
            WorksWithStdToString<T> ||
            ConvertibleToStringGlobal<T>;
 
#ifndef GZ_TO_STRING_NO_VECTORS
        // VECTOR
        template<typename T>
        concept Vector2ConvertibleToString = !_ToStringBasicNoPtr<T> && 
            requires(T t) { 
                { t.x } -> _ToStringBasicNoPtr; 
                { t.y } -> _ToStringBasicNoPtr; 
                requires sizeof(t.x) * 2 == sizeof(T);
            };
        template<typename T>
        concept Vector3ConvertibleToString = !_ToStringBasicNoPtr<T> && 
            requires(T t) { 
                { t.x } -> _ToStringBasicNoPtr; 
                { t.y } -> _ToStringBasicNoPtr; 
                { t.z } -> _ToStringBasicNoPtr; 
                requires sizeof(t.x) * 3 == sizeof(T);
            };
        template<typename T>
        concept Vector4ConvertibleToString = !_ToStringBasicNoPtr<T> && 
            requires(T t) { 
                { t.x } -> _ToStringBasicNoPtr; 
                { t.y } -> _ToStringBasicNoPtr; 
                { t.z } -> _ToStringBasicNoPtr; 
                { t.w } -> _ToStringBasicNoPtr; 
                requires sizeof(t.x) * 4 == sizeof(T);
            };
 
        template<typename T>
        concept Extent2DConvertibleToString = !_ToStringBasicNoPtr<T> && 
            requires(T t) { 
                { t.width } -> _ToStringBasicNoPtr; 
                { t.height } -> _ToStringBasicNoPtr; 
                requires sizeof(t.width) * 2 == sizeof(T);
            };
        template<typename T>
        concept Extent3DConvertibleToString = !_ToStringBasicNoPtr<T> && 
            requires(T t) { 
                { t.width } -> _ToStringBasicNoPtr; 
                { t.height } -> _ToStringBasicNoPtr; 
                { t.depth } -> _ToStringBasicNoPtr; 
                requires sizeof(t.width) * 3 == sizeof(T);
            };
#endif 
 
        template<typename T>
        concept _ToStringBasicOrVectorNoPtr = 
            _ToStringBasicNoPtr<T> 
#ifndef GZ_TO_STRING_NO_VECTORS
            || Vector2ConvertibleToString<T> ||
            Vector3ConvertibleToString<T> ||
            Vector4ConvertibleToString<T> ||
            Extent2DConvertibleToString<T> ||
            Extent3DConvertibleToString<T>
#endif
            ;
 
        template<typename T>
        concept PtrToToStringBasicOrVector = 
            !_ToStringBasicOrVectorNoPtr<T> &&
            _ToStringBasicOrVectorNoPtr<std::remove_pointer_t<T>>;
}  // namespace gz::util
 
 
namespace gz {
        template<util::Stringy T>
        inline std::string toString(const T& t) {
            return static_cast<std::string>(t);
        }
 
        template<util::CanConstructString T>
        inline std::string toString(const T& t) {
            return std::string(t);
        }
 
        template<util::HasToStringMember T>
        inline std::string toString(const T& t) {
            return t.toString();
        }
 
        template<util::HasToStringMember2 T>
        inline std::string toString(const T& t) {
            return t.to_string();
        }
 
        template<util::WorksWithStdToString T>
        inline std::string toString(const T& t) {
            return std::to_string(t);
        }
 
        template<std::same_as<bool> T>
        inline std::string toString(const T& b) {
            return b ? "true" : "false";
        }
 
        template<util::ConvertibleToStringGlobal T>
        inline std::string toString(const T& t) {
            return ::toString(t);
        }
 
#ifndef GZ_TO_STRING_NO_VECTORS
        template<util::Vector2ConvertibleToString T>
        inline std::string toString(const T& t) {
            std::string s = "( ";
            s += toString(t.x) + ", ";
            s += toString(t.y) + " )";
            return s;
        }
 
        template<util::Vector3ConvertibleToString T>
        inline std::string toString(const T& t) {
            std::string s = "( ";
            s += toString(t.x) + ", ";
            s += toString(t.y) + ", ";
            s += toString(t.z) + " )";
            return s;
        }
 
        template<util::Vector4ConvertibleToString T>
        inline std::string toString(const T& t) {
            std::string s = "( ";
            s += toString(t.x) + ", ";
            s += toString(t.y) + ", ";
            s += toString(t.z) + ", ";
            s += toString(t.w) + " )";
            return s;
        }
 
        template<util::Extent2DConvertibleToString T>
        inline std::string toString(const T& t) {
            std::string s = "( ";
            s += toString(t.width) + ", ";
            s += toString(t.height) + " ) ";
            return s;
        }
 
        template<util::Extent3DConvertibleToString T>
        inline std::string toString(const T& t) {
            std::string s = "( ";
            s += toString(t.width) + ", ";
            s += toString(t.height) + ", ";
            s += toString(t.depth) + " ) ";
            return s;
        }
#endif
 
        template<util::PtrToToStringBasicOrVector T>
        inline std::string toString(const T& t) {
            return toString(*t);        
        }
}  // namespace gz
 
 
 
namespace gz::util {
        template<typename T>
        concept _ConvertibleToString = 
            requires (const T& t) {
                { gz::toString(t) } -> std::same_as<std::string>;
            };
            
 
        // CONTAINER
        template<typename T>
        concept ForwardRangeConvertibleToString = !_ConvertibleToString<T> and std::ranges::forward_range<T> and _ConvertibleToString<std::ranges::range_value_t<T>>;
 
        template<typename T>
        concept _TypeOrForwardRangeConvertibleToString = _ConvertibleToString<T> || ForwardRangeConvertibleToString<T>;
 
        template<typename T>
        concept PairConvertibleToString = !ForwardRangeConvertibleToString<T> and requires(const T& p) { 
            requires _TypeOrForwardRangeConvertibleToString<decltype(p.first)>;
            requires _TypeOrForwardRangeConvertibleToString<decltype(p.second)>;
        };
 
        template<typename T>
        concept MapConvertibleToString = !PairConvertibleToString<T> and !_TypeOrForwardRangeConvertibleToString<T> and
            std::ranges::forward_range<T> and PairConvertibleToString<std::ranges::range_reference_t<T>>;
 
        template<typename T>
        concept _ContainerTypeConvertibleToString = PairConvertibleToString<T> || ForwardRangeConvertibleToString<T> || MapConvertibleToString<T>;
 
}  // namespace gz::util
 
 
 
namespace gz {
        template<util::ForwardRangeConvertibleToString T>
        std::string toString(const T& t) {
            std::string s = "[ ";
            for (auto it = t.begin(); it != t.end(); it++) {
                s += toString(*it) + ", ";
            }
            if (s.size() > 2) {
                s.erase(s.size() - 2);
            }
            s += " ]";
            return s;
        }
 
        template<util::PairConvertibleToString T>
        inline std::string toString(const T& t) {
            return "( " + toString(t.first) + ", " + toString(t.second) + " )";
        }
 
        template<util::MapConvertibleToString T>
        std::string toString(const T& t) {
            std::string s = "{ ";
            for (const auto& [k, v] : t) {
                s += toString(k) + ": ";
                s += toString(v) + ", ";
            }
            if (s.size() > 2) {
                s.erase(s.size() - 2);
            }
            s += " }";
            return s;
        }
 
    template<typename T>
    concept ConvertibleToString =
        requires (const T& t) {
            { gz::toString(t) } -> std::same_as<std::string>;
        };
}  // namespace gz