ToStringS.hpp

Go to the documentation of this file.

//
// Balau core C++ library
//
// Copyright (C) 2008 Bora Software (contact@borasoftware.com)
//
// Licensed under the Boost Software License - Version 1.0 - August 17th, 2003.
// See the LICENSE file for the full license text.
//


#ifndef COM_BORA_SOFTWARE__BALAU_APPLICATION__TO_STRING_S
#define COM_BORA_SOFTWARE__BALAU_APPLICATION__TO_STRING_S

#include <Balau/Type/StdTypes.hpp>
#include <Balau/Type/Impl/ToStringImpl.hpp>

#include <boost/lexical_cast.hpp>
#include <boost/locale.hpp>

#include <complex>
#include <forward_list>
#include <list>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <stack>
#include <queue>

template <typename P1, typename P2, typename ... P>
std::string toString(const P1 & p1, const P2 & p2, const P & ... p);

template <typename P1, typename P2, typename ... P>
std::u16string toString16(const P1 & p1, const P2 & p2, const P & ... p);

template <typename P1, typename P2, typename ... P>
std::u32string toString32(const P1 & p1, const P2 & p2, const P & ... p);


inline std::string toString(const std::string & value) {
    return value;
}

inline std::string toString(const std::string_view & value) {
    return std::string(value);
}

#ifndef BALAU_USE_BOOST_STRING_VIEW

inline std::string toString(const boost::string_view & value) {
    return value.to_string();
}

#endif

inline std::string toString(const std::u16string & value) {
    return boost::locale::conv::utf_to_utf<char, char16_t>(value);
}

inline std::string toString(const std::u16string_view & value) {
    return boost::locale::conv::utf_to_utf<char, char16_t>(std::u16string(value));
}

inline std::string toString(const std::u32string & value) {
    return boost::locale::conv::utf_to_utf<char, char32_t>(value);
}

inline std::string toString(const std::u32string_view & value) {
    return boost::locale::conv::utf_to_utf<char, char32_t>(std::u32string(value));
}

inline std::string toString(char value) {
    std::string str;
    str += value;
    return str;
}

inline std::string toString(char16_t value) {
    std::u16string str;
    str += value;
    return toString(str);
}

inline std::string toString(char32_t value) {
    std::u32string str;
    str += value;
    return toString(str);
}

inline std::string toString(signed char value) {
    return Balau::Impl::toString<std::allocator<char>>("%d", (int) value);
}

inline std::string toString(short value) {
    return Balau::Impl::toString<std::allocator<char>>("%d", (int) value);
}

inline std::string toString(int value) {
    return Balau::Impl::toString<std::allocator<char>>("%d", value);
}

inline std::string toString(long value) {
    return Balau::Impl::toString<std::allocator<char>>("%ld", value);
}

inline std::string toString(long long value) {
    return Balau::Impl::toString<std::allocator<char>>("%lld", value);
}

inline std::string toString(unsigned char value) {
    return Balau::Impl::toString<std::allocator<char>>("%u", (unsigned int) value);
}

inline std::string toString(unsigned short value) {
    return Balau::Impl::toString<std::allocator<char>>("%u", (unsigned int) value);
}

inline std::string toString(unsigned int value) {
    return Balau::Impl::toString<std::allocator<char>>("%u", value);
}

inline std::string toString(unsigned long value) {
    return Balau::Impl::toString<std::allocator<char>>("%lu", value);
}

inline std::string toString(unsigned long long value) {
    return Balau::Impl::toString<std::allocator<char>>("%llu", value);
}

inline std::string toString(float value) {
    return boost::lexical_cast<std::string>(value);
}

inline std::string toString(double value) {
    return boost::lexical_cast<std::string>(value);
}

inline std::string toString(long double value) {
    return boost::lexical_cast<std::string>(value);
}

template <typename T> inline std::string toString(const std::complex<T> & value) {
    return toString(value.real(), " + j", value.imag());
}

inline std::string toString(bool value) {
    return value ? "true" : "false";
}

inline std::string toString(const char * value) {
    return std::string(value);
}

std::u16string toString16(const char16_t * value);
std::u32string toString32(const char32_t * value);

inline std::string toString(const char16_t * value) {
    return toString(toString16(value));
}

inline std::string toString(const char32_t * value) {
    return toString(toString32(value));
}

inline std::string toString(const void * ptr) {
    return toString((size_t) ptr);
}

inline std::string toString(std::nullptr_t) {
    return "0";
}

inline std::string toString(std::type_index value) {
    return value.name();
}

inline std::string toString(const std::function<std::string ()> & f) {
    return f();
}

template <typename F, typename S>
inline std::string toString(const std::pair<F, S> & p) {
    return std::string("{ ") + toString(p.first) + ", " + toString(p.second) + " }";
}

template <typename ... T, template <typename ...> class C>
inline std::string toStringHelper(const C<T ...> & c)  {
    std::string builder = "{";
    std::string prefix = " ";
    bool empty = true;

    for (const auto & e : c) {
        builder += prefix + toString(e);
        prefix = ", ";
        empty = false;
    }

    if (!empty) {
        builder += " ";
    }

    builder += "}";

    return builder;
}

#define BALAU_CONTAINER1_TO_STRING(CONTAINER_TYPE)             \
    template <typename T>                                      \
    inline std::string toString(const CONTAINER_TYPE<T> & c) { \
        return toStringHelper(c);                              \
    }

#define BALAU_CONTAINER2_TO_STRING(CONTAINER_TYPE)                \
    template <typename T, typename U>                             \
    inline std::string toString(const CONTAINER_TYPE<T, U> & c) { \
        return toStringHelper(c);                                 \
    }

#define BALAU_CONTAINER3_TO_STRING(CONTAINER_TYPE)                   \
    template <typename T, typename U, typename V>                    \
    inline std::string toString(const CONTAINER_TYPE<T, U, V> & c) { \
        return toStringHelper(c);                                    \
    }

#define BALAU_CONTAINER4_TO_STRING(CONTAINER_TYPE)                      \
    template <typename T, typename U, typename V, typename W>           \
    inline std::string toString(const CONTAINER_TYPE<T, U, V, W> & c) { \
        return toStringHelper(c);                                       \
    }

#define BALAU_CONTAINER5_TO_STRING(CONTAINER_TYPE)                         \
    template <typename T, typename U, typename V, typename W, typename X>  \
    inline std::string toString(const CONTAINER_TYPE<T, U, V, W, X> & c) { \
        return toStringHelper(c);                                          \
    }

BALAU_CONTAINER2_TO_STRING(std::deque)
BALAU_CONTAINER2_TO_STRING(std::forward_list)
BALAU_CONTAINER2_TO_STRING(std::list)
BALAU_CONTAINER2_TO_STRING(std::map)
BALAU_CONTAINER3_TO_STRING(std::multiset)
BALAU_CONTAINER4_TO_STRING(std::multimap)
BALAU_CONTAINER3_TO_STRING(std::priority_queue)
BALAU_CONTAINER2_TO_STRING(std::queue)
BALAU_CONTAINER2_TO_STRING(std::set)
BALAU_CONTAINER2_TO_STRING(std::stack)
BALAU_CONTAINER5_TO_STRING(std::unordered_map)
BALAU_CONTAINER5_TO_STRING(std::unordered_multimap)
BALAU_CONTAINER4_TO_STRING(std::unordered_multiset)
BALAU_CONTAINER3_TO_STRING(std::unordered_set)
BALAU_CONTAINER2_TO_STRING(std::vector)

template <typename T, size_t N> inline std::string toString(const std::array<T, N> & c) {
    return toStringHelper(c);
}

template <typename P1, typename P2, typename ... P>
inline std::string toString(const P1 & p1, const P2 & p2, const P & ... p) {
    return toString(p1) + toString(p2) + (std::string() + ... + toString(p));
}


inline std::u16string toString16(const std::string & value) {
    return boost::locale::conv::utf_to_utf<char16_t, char>(value);
}

inline std::u16string toString16(const std::string_view & value) {
    return toString16(std::string(value));
}

#ifndef BALAU_USE_BOOST_STRING_VIEW

inline std::u16string toString16(const boost::string_view & value) {
    return toString16(value.to_string());
}

#endif

inline std::u16string toString16(const std::u16string & value) {
    return value;
}

inline std::u16string toString16(const std::u16string_view & value) {
    return std::u16string(value);
}

inline std::u16string toString16(const std::u32string & value) {
    return boost::locale::conv::utf_to_utf<char16_t, char32_t>(value);
}

inline std::u16string toString16(char value) {
    std::string str;
    str += value;
    return toString16(str);
}

inline std::u16string toString16(char16_t & value) {
    std::u16string str;
    str += value;
    return str;
}

inline std::u16string toString16(char32_t & value) {
    std::u32string str;
    str += value;
    return toString16(str);
}

inline std::u16string toString16(signed char value) {
    return toString16(toString(value));
}

inline std::u16string toString16(short value) {
    return toString16(toString(value));
}

inline std::u16string toString16(int value) {
    return toString16(toString(value));
}

inline std::u16string toString16(long value) {
    return toString16(toString(value));
}

inline std::u16string toString16(long long value) {
    return toString16(toString(value));
}

inline std::u16string toString16(unsigned char value) {
    return toString16(toString(value));
}

inline std::u16string toString16(unsigned short value) {
    return toString16(toString(value));
}

inline std::u16string toString16(unsigned int value) {
    return toString16(toString(value));
}

inline std::u16string toString16(unsigned long value) {
    return toString16(toString(value));
}

inline std::u16string toString16(unsigned long long value) {
    return toString16(toString(value));
}

inline std::u16string toString16(float value) {
    return toString16(toString(value));
}

inline std::u16string toString16(double value) {
    return toString16(toString(value));
}

inline std::u16string toString16(long double value) {
    return toString16(toString(value));
}

template <typename T> inline std::u16string toString16(const std::complex<T> & value) {
    return toString16(value.real(), " + j", value.imag());
}

inline std::u16string toString16(bool value) {
    return value ? u"true" : u"false";
}

inline std::u16string toString16(const char * value) {
    return toString16(toString((value)));
}

inline std::u16string toString16(const char16_t * value) {
    return std::u16string(value);
}

inline std::u16string toString16(const char32_t * value) {
    return toString16(toString32(value));
}

inline std::u16string toString16(const void * ptr) {
    return toString16((size_t) ptr);
}

inline std::u16string toString16(std::nullptr_t) {
    return u"0";
}

inline std::u16string toString16(std::type_index value) {
    return toString16(value.name());
}

inline std::u16string toString16(const std::function<std::u16string ()> & f) {
    return f();
}

template <typename F, typename S>
inline std::u16string toString16(const std::pair<F, S> & p) {
    return std::u16string(u"{ ") + toString16(p.first) + u", " + toString16(p.second) + u" }";
}

template <typename ... T, template <typename ...> class C>
inline std::u16string toString16Helper(const C<T ...> & c)  {
    std::u16string builder = u"{";
    std::u16string prefix = u" ";
    bool empty = true;

    for (const auto & e : c) {
        builder += prefix + toString16(e);
        prefix = u", ";
        empty = false;
    }

    if (!empty) {
        builder += u" ";
    }

    builder += u"}";

    return builder;
}

#define BALAU_CONTAINER1_TO_STRING16(CONTAINER_TYPE)                \
    template <typename T>                                           \
    inline std::u16string toString16(const CONTAINER_TYPE<T> & c) { \
        return toString16Helper(c);                                 \
    }

#define BALAU_CONTAINER2_TO_STRING16(CONTAINER_TYPE)                   \
    template <typename T, typename U>                                  \
    inline std::u16string toString16(const CONTAINER_TYPE<T, U> & c) { \
        return toString16Helper(c);                                    \
    }

#define BALAU_CONTAINER3_TO_STRING16(CONTAINER_TYPE)                      \
    template <typename T, typename U, typename V>                         \
    inline std::u16string toString16(const CONTAINER_TYPE<T, U, V> & c) { \
        return toString16Helper(c);                                       \
    }

#define BALAU_CONTAINER4_TO_STRING16(CONTAINER_TYPE)                         \
    template <typename T, typename U, typename V, typename W>                \
    inline std::u16string toString16(const CONTAINER_TYPE<T, U, V, W> & c) { \
        return toString16Helper(c);                                          \
    }

#define BALAU_CONTAINER5_TO_STRING16(CONTAINER_TYPE)                            \
    template <typename T, typename U, typename V, typename W, typename X>       \
    inline std::u16string toString16(const CONTAINER_TYPE<T, U, V, W, X> & c) { \
        return toString16Helper(c);                                             \
    }

BALAU_CONTAINER2_TO_STRING16(std::deque)
BALAU_CONTAINER2_TO_STRING16(std::forward_list)
BALAU_CONTAINER2_TO_STRING16(std::list)
BALAU_CONTAINER2_TO_STRING16(std::map)
BALAU_CONTAINER3_TO_STRING16(std::multiset)
BALAU_CONTAINER4_TO_STRING16(std::multimap)
BALAU_CONTAINER3_TO_STRING16(std::priority_queue)
BALAU_CONTAINER2_TO_STRING16(std::queue)
BALAU_CONTAINER2_TO_STRING16(std::set)
BALAU_CONTAINER2_TO_STRING16(std::stack)
BALAU_CONTAINER5_TO_STRING16(std::unordered_map)
BALAU_CONTAINER5_TO_STRING16(std::unordered_multimap)
BALAU_CONTAINER4_TO_STRING16(std::unordered_multiset)
BALAU_CONTAINER3_TO_STRING16(std::unordered_set)
BALAU_CONTAINER2_TO_STRING16(std::vector)

template <typename P1, typename P2, typename ... P>
inline std::u16string toString16(const P1 & p1, const P2 & p2, const P & ... p) {
    return toString16(p1) + toString16(p2) + (std::u16string() + ... + toString16(p));
}


inline std::u32string toString32(const std::string & value) {
    return boost::locale::conv::utf_to_utf<char32_t, char>(value);
}

inline std::u32string toString32(const std::string_view & value) {
    return toString32(std::string(value));
}

#ifndef BALAU_USE_BOOST_STRING_VIEW

inline std::u32string toString32(const boost::string_view & value) {
    return toString32(value.to_string());
}

#endif

inline std::u32string toString32(const std::u16string & value) {
    return boost::locale::conv::utf_to_utf<char32_t, char16_t>(value);
}

inline std::u32string toString32(const std::u32string & value) {
    return value;
}

inline std::u32string toString32(const std::u32string_view & value) {
    return std::u32string(value);
}

inline std::u32string toString32(char value) {
    std::string str;
    str += value;
    return toString32(str);
}

inline std::u32string toString32(char16_t & value) {
    std::u16string str;
    str += value;
    return toString32(str);
}

inline std::u32string toString32(char32_t & value) {
    std::u32string str;
    str += value;
    return str;
}

inline std::u32string toString32(signed char value) {
    return toString32(toString(value));
}

inline std::u32string toString32(short value) {
    return toString32(toString(value));
}

inline std::u32string toString32(int value) {
    return toString32(toString(value));
}

inline std::u32string toString32(long value) {
    return toString32(toString(value));
}

inline std::u32string toString32(long long value) {
    return toString32(toString(value));
}

inline std::u32string toString32(unsigned char value) {
    return toString32(toString(value));
}

inline std::u32string toString32(unsigned short value) {
    return toString32(toString(value));
}

inline std::u32string toString32(unsigned int value) {
    return toString32(toString(value));
}

inline std::u32string toString32(unsigned long value) {
    return toString32(toString(value));
}

inline std::u32string toString32(unsigned long long value) {
    return toString32(toString(value));
}

inline std::u32string toString32(float value) {
    return toString32(toString(value));
}

inline std::u32string toString32(double value) {
    return toString32(toString(value));
}

inline std::u32string toString32(long double value) {
    return toString32(toString(value));
}

template <typename T> inline std::u32string toString32(const std::complex<T> & value) {
    return toString32(value.real(), " + j", value.imag());
}

inline std::u32string toString32(bool value) {
    return value ? U"true" : U"false";
}

inline std::u32string toString32(const char * value) {
    return toString32(toString((value)));
}

inline std::u32string toString32(const char16_t * value) {
    return toString32(toString16((value)));
}

inline std::u32string toString32(const char32_t * value) {
    return std::u32string(value);
}

inline std::u32string toString32(const void * ptr) {
    return toString32((size_t) ptr);
}

inline std::u32string toString32(std::nullptr_t) {
    return U"0";
}

inline std::u32string toString32(std::type_index value) {
    return toString32(value.name());
}

inline std::u32string toString32(const std::function<std::u32string ()> & f) {
    return f();
}

template <typename F, typename S>
inline std::u32string toString32(const std::pair<F, S> & p) {
    return std::u32string(U"{ ") + toString32(p.first) + U", " + toString32(p.second) + U" }";
}

template <typename ... T, template <typename ...> class C>
inline std::u32string toString32Helper(const C<T ...> & c)  {
    std::u32string builder = U"{";
    std::u32string prefix = U" ";
    bool empty = true;

    for (const auto & e : c) {
        builder += prefix + toString32(e);
        prefix = U", ";
        empty = false;
    }

    if (!empty) {
        builder += U" ";
    }

    builder += U"}";

    return builder;
}

#define BALAU_CONTAINER1_TO_STRING32(CONTAINER_TYPE)                \
    template <typename T>                                           \
    inline std::u32string toString32(const CONTAINER_TYPE<T> & c) { \
        return toString32Helper(c);                                 \
    }

#define BALAU_CONTAINER2_TO_STRING32(CONTAINER_TYPE)                   \
    template <typename T, typename U>                                  \
    inline std::u32string toString32(const CONTAINER_TYPE<T, U> & c) { \
        return toString32Helper(c);                                    \
    }

#define BALAU_CONTAINER3_TO_STRING32(CONTAINER_TYPE)                      \
    template <typename T, typename U, typename V>                         \
    inline std::u32string toString32(const CONTAINER_TYPE<T, U, V> & c) { \
        return toString32Helper(c);                                       \
    }

#define BALAU_CONTAINER4_TO_STRING32(CONTAINER_TYPE)                         \
    template <typename T, typename U, typename V, typename W>                \
    inline std::u32string toString32(const CONTAINER_TYPE<T, U, V, W> & c) { \
        return toString32Helper(c);                                          \
    }

#define BALAU_CONTAINER5_TO_STRING32(CONTAINER_TYPE)                            \
    template <typename T, typename U, typename V, typename W, typename X>       \
    inline std::u32string toString32(const CONTAINER_TYPE<T, U, V, W, X> & c) { \
        return toString32Helper(c);                                             \
    }

BALAU_CONTAINER2_TO_STRING32(std::deque)
BALAU_CONTAINER2_TO_STRING32(std::forward_list)
BALAU_CONTAINER2_TO_STRING32(std::list)
BALAU_CONTAINER2_TO_STRING32(std::map)
BALAU_CONTAINER3_TO_STRING32(std::multiset)
BALAU_CONTAINER4_TO_STRING32(std::multimap)
BALAU_CONTAINER3_TO_STRING32(std::priority_queue)
BALAU_CONTAINER2_TO_STRING32(std::queue)
BALAU_CONTAINER2_TO_STRING32(std::set)
BALAU_CONTAINER2_TO_STRING32(std::stack)
BALAU_CONTAINER5_TO_STRING32(std::unordered_map)
BALAU_CONTAINER5_TO_STRING32(std::unordered_multimap)
BALAU_CONTAINER4_TO_STRING32(std::unordered_multiset)
BALAU_CONTAINER3_TO_STRING32(std::unordered_set)
BALAU_CONTAINER2_TO_STRING32(std::vector)

template <typename P1, typename P2, typename ... P>
inline std::u32string toString32(const P1 & p1, const P2 & p2, const P & ... p) {
    return toString32(p1) + toString32(p2) + (std::u32string() + ... + toString32(p));
}


template <> struct ToString<char, std::allocator<char>> {
    template <typename T> std::string operator () (const T & object) const {
        return toString(object);
    }
};

template <> struct ToString<char16_t, std::allocator<char16_t>> {
    template <typename T> std::u16string operator () (const T & object) const {
        return toString16(object);
    }
};

template <> struct ToString<char32_t, std::allocator<char32_t>> {
    template <typename T> std::u32string operator () (const T & object) const {
        return toString32(object);
    }
};

#endif // COM_BORA_SOFTWARE__BALAU_APPLICATION__TO_STRING_S