ToStringA.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_A
#define COM_BORA_SOFTWARE__BALAU_APPLICATION__TO_STRING_A

#include <Balau/Type/StdTypes.hpp>
#include <Balau/Type/Impl/ToStringImpl.hpp>
#include <Balau/ThirdParty/Boost/Locale/EncodingUtf.hpp>

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

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

namespace Balau {

template <typename AllocatorT>
using U8String = std::basic_string<char, std::char_traits<char>, AllocatorT>;

template <typename AllocatorT>
using U16String = std::basic_string<char16_t, std::char_traits<char16_t>, AllocatorT>;

template <typename AllocatorT>
using U32String = std::basic_string<char32_t, std::char_traits<char32_t>, AllocatorT>;

template <typename AllocatorT>
using U8OStringStream = std::basic_ostringstream<char, std::char_traits<char>, AllocatorT>;

template <typename AllocatorT>
using U16OStringStream = std::basic_ostringstream<char16_t, std::char_traits<char16_t>, AllocatorT>;

template <typename AllocatorT>
using U32OStringStream = std::basic_ostringstream<char32_t, std::char_traits<char32_t>, AllocatorT>;

}

template <typename AllocatorT, typename P1, typename P2, typename ... P>
Balau::U8String<AllocatorT> toString(const P1 & p1, const P2 & p2, const P & ... p);

template <typename AllocatorT, typename P1, typename P2, typename ... P>
Balau::U16String<AllocatorT> toString16(const P1 & p1, const P2 & p2, const P & ... p);

template <typename AllocatorT, typename P1, typename P2, typename ... P>
Balau::U32String<AllocatorT> toString32(const P1 & p1, const P2 & p2, const P & ... p);


template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(const Balau::U8String<AllocatorT> & value) {
    return value;
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(const std::string & value) {
    return Balau::U8String<AllocatorT>(value.data(), value.length());
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(const std::string_view & value) {
    return Balau::U8String<AllocatorT>(value);
}

#ifndef BALAU_USE_BOOST_STRING_VIEW

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(const boost::string_view & value) {
    return Balau::U8String<AllocatorT>(value.data(), value.length());
}

#endif

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(const std::u16string & value) {
    return Balau::Boost::Locale::Conv::utf_to_utf<char, char16_t, AllocatorT>(value);
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(const std::u16string_view & value) {
    return Balau::Boost::Locale::Conv::utf_to_utf<char, char16_t, AllocatorT>(std::u16string(value));
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(const std::u32string & value) {
    return Balau::Boost::Locale::Conv::utf_to_utf<char, char32_t, AllocatorT>(value);
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(const std::u32string_view & value) {
    return Balau::Boost::Locale::Conv::utf_to_utf<char, char32_t, AllocatorT>(std::u32string(value));
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(char value) {
    Balau::U8String<AllocatorT> str;
    str += value;
    return str;
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(char16_t value) {
    Balau::U16String<AllocatorT> str;
    str += value;
    return toString<AllocatorT>(str);
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(char32_t value) {
    std::u32string str;
    str += value;
    return toString<AllocatorT>(str);
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(signed char value) {
    return Balau::Impl::toString<AllocatorT>("%d", (int) value);
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(short value) {
    return Balau::Impl::toString<AllocatorT>("%d", (int) value);
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(int value) {
    return Balau::Impl::toString<AllocatorT>("%d", (int) value);
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(long value) {
    return Balau::Impl::toString<AllocatorT>("%ld", value);
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(long long value) {
    return Balau::Impl::toString<AllocatorT>("%lld", value);
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(unsigned char value) {
    return Balau::Impl::toString<AllocatorT>("%u", (unsigned int) value);
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(unsigned short value) {
    return Balau::Impl::toString<AllocatorT>("%u", (unsigned int) value);
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(unsigned int value) {
    return Balau::Impl::toString<AllocatorT>("%u", value);
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(unsigned long value) {
    return Balau::Impl::toString<AllocatorT>("%lu", value);
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(unsigned long long value) {
    return Balau::Impl::toString<AllocatorT>("%llu", value);
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(float value) {
    return boost::lexical_cast<Balau::U8String<AllocatorT>>(value);
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(double value) {
    return boost::lexical_cast<Balau::U8String<AllocatorT>>(value);
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(long double value) {
    return boost::lexical_cast<Balau::U8String<AllocatorT>>(value);
}

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

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(bool value) {
    return value ? "true" : "false";
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(const char * value) {
    return Balau::U8String<AllocatorT>(value);
}

template <typename AllocatorT>
std::u16string toString16(const char16_t * value);

template <typename AllocatorT>
std::u32string toString32(const char32_t * value);

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(const char16_t * value) {
    return toString<AllocatorT>(toString16<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(const char32_t * value) {
    return toString<AllocatorT>(toString32<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(const void * ptr) {
    return toString<AllocatorT>((size_t) ptr);
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(std::nullptr_t) {
    return "0";
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(std::type_index value) {
    return value.name();
}

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(const std::function<Balau::U8String<AllocatorT> ()> & f) {
    return f();
}

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

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

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

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

    builder += "}";

    return builder;
}

#define BALAU_CONTAINER1_TO_STRING_A(CONTAINER_TYPE)                          \
    template <typename T, typename AllocatorT>                                 \
    inline Balau::U8String<AllocatorT> toString(const CONTAINER_TYPE<T> & c) { \
        return toStringHelper<AllocatorT>(c);                                  \
    }

#define BALAU_CONTAINER2_TO_STRING_A(CONTAINER_TYPE)                             \
    template <typename AllocatorT, typename T, typename U>                        \
    inline Balau::U8String<AllocatorT> toString(const CONTAINER_TYPE<T, U> & c) { \
        return toStringHelper<AllocatorT>(c);                                     \
    }

#define BALAU_CONTAINER3_TO_STRING_A(CONTAINER_TYPE)                                \
    template <typename AllocatorT, typename T, typename U, typename V>               \
    inline Balau::U8String<AllocatorT> toString(const CONTAINER_TYPE<T, U, V> & c) { \
        return toStringHelper<AllocatorT>(c);                                        \
    }

#define BALAU_CONTAINER4_TO_STRING_A(CONTAINER_TYPE)                                   \
    template <typename AllocatorT, typename T, typename U, typename V, typename W>      \
    inline Balau::U8String<AllocatorT> toString(const CONTAINER_TYPE<T, U, V, W> & c) { \
        return toStringHelper<AllocatorT>(c);                                           \
    }

#define BALAU_CONTAINER5_TO_STRING_A(CONTAINER_TYPE)                                          \
    template <typename AllocatorT, typename T, typename U, typename V, typename W, typename X> \
    inline Balau::U8String<AllocatorT> toString(const CONTAINER_TYPE<T, U, V, W, X> & c) {     \
        return toStringHelper<AllocatorT>(c);                                                  \
    }

BALAU_CONTAINER2_TO_STRING_A(std::deque)
BALAU_CONTAINER2_TO_STRING_A(std::forward_list)
BALAU_CONTAINER2_TO_STRING_A(std::list)
BALAU_CONTAINER2_TO_STRING_A(std::map)
BALAU_CONTAINER3_TO_STRING_A(std::multiset)
BALAU_CONTAINER4_TO_STRING_A(std::multimap)
BALAU_CONTAINER3_TO_STRING_A(std::priority_queue)
BALAU_CONTAINER2_TO_STRING_A(std::queue)
BALAU_CONTAINER2_TO_STRING_A(std::set)
BALAU_CONTAINER2_TO_STRING_A(std::stack)
BALAU_CONTAINER5_TO_STRING_A(std::unordered_map)
BALAU_CONTAINER5_TO_STRING_A(std::unordered_multimap)
BALAU_CONTAINER4_TO_STRING_A(std::unordered_multiset)
BALAU_CONTAINER3_TO_STRING_A(std::unordered_set)
BALAU_CONTAINER2_TO_STRING_A(std::vector)

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

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


template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(const Balau::U8String<AllocatorT> & value) {
    return Balau::Boost::Locale::Conv::utf_to_utf<char16_t, char, AllocatorT>(value);
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(const std::string & value) {
    return Balau::Boost::Locale::Conv::utf_to_utf<char16_t, char, AllocatorT>(Balau::U8String<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(const std::string_view & value) {
    return toString16<AllocatorT>(Balau::U8String<AllocatorT>(value));
}


#ifndef BALAU_USE_BOOST_STRING_VIEW

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(const boost::string_view & value) {
    return toString16<AllocatorT>(Balau::U8String<AllocatorT>(value.to_string()));
}

#endif

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(const Balau::U16String<AllocatorT> & value) {
    return value;
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(const std::u16string & value) {
    return Balau::U16String<AllocatorT>(value.data(), value.length());
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(const std::u16string_view & value) {
    return Balau::U16String<AllocatorT>(value);
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(const std::u32string & value) {
    return Balau::Boost::Locale::Conv::utf_to_utf<char16_t, char32_t, AllocatorT>(value);
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(char value) {
    Balau::U8String<AllocatorT> str;
    str += value;
    return toString16<AllocatorT>(str);
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(char16_t & value) {
    Balau::U16String<AllocatorT> str;
    str += value;
    return str;
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(char32_t & value) {
    Balau::U32String<AllocatorT> str;
    str += value;
    return toString16<AllocatorT>(str);
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(signed char value) {
    return toString16<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(short value) {
    return toString16<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(int value) {
    return toString16<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(long value) {
    return toString16<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(long long value) {
    return toString16<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(unsigned char value) {
    return toString16<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(unsigned short value) {
    return toString16<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(unsigned int value) {
    return toString16<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(unsigned long value) {
    return toString16<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(unsigned long long value) {
    return toString16<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(float value) {
    return toString16<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(double value) {
    return toString16<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(long double value) {
    return toString16<AllocatorT>(toString<AllocatorT>(value));
}

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

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(bool value) {
    return value ? u"true" : u"false";
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(const char * value) {
    return toString16<AllocatorT>(toString<AllocatorT>((value)));
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(const char16_t * value) {
    return std::u16string(value);
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(const char32_t * value) {
    return toString16<AllocatorT>(toString32<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(const void * ptr) {
    return toString16<AllocatorT>((size_t) ptr);
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(std::nullptr_t) {
    return u"0";
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(std::type_index value) {
    return toString16<AllocatorT>(value.name());
}

template <typename AllocatorT>
inline Balau::U16String<AllocatorT> toString16(const std::function<std::u16string ()> & f) {
    return f();
}

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

template <typename AllocatorT, 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<AllocatorT>(e);
        prefix = u", ";
        empty = false;
    }

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

    builder += u"}";

    return builder;
}

#define BALAU_CONTAINER1_TO_STRING16_A(CONTAINER_TYPE)                           \
    template <typename AllocatorT, typename T>                                    \
    inline Balau::U16String<AllocatorT> toString16(const CONTAINER_TYPE<T> & c) { \
        return toString16Helper<AllocatorT>(c);                                   \
    }

#define BALAU_CONTAINER2_TO_STRING16_A(CONTAINER_TYPE)                              \
    template <typename AllocatorT, typename T, typename U>                           \
    inline Balau::U16String<AllocatorT> toString16(const CONTAINER_TYPE<T, U> & c) { \
        return toString16Helper<AllocatorT>(c);                                      \
    }

#define BALAU_CONTAINER3_TO_STRING16_A(CONTAINER_TYPE)                                 \
    template <typename AllocatorT, typename T, typename U, typename V>                  \
    inline Balau::U16String<AllocatorT> toString16(const CONTAINER_TYPE<T, U, V> & c) { \
        return toString16Helper<AllocatorT>(c);                                         \
    }

#define BALAU_CONTAINER4_TO_STRING16_A(CONTAINER_TYPE)                                    \
    template <typename AllocatorT, typename T, typename U, typename V, typename W>         \
    inline Balau::U16String<AllocatorT> toString16(const CONTAINER_TYPE<T, U, V, W> & c) { \
        return toString16Helper<AllocatorT>(c);                                            \
    }

#define BALAU_CONTAINER5_TO_STRING16_A(CONTAINER_TYPE)                                        \
    template <typename AllocatorT, typename T, typename U, typename V, typename W, typename X> \
    inline Balau::U16String<AllocatorT> toString16(const CONTAINER_TYPE<T, U, V, W, X> & c) {  \
        return toString16Helper<AllocatorT>(c);                                                \
    }

BALAU_CONTAINER2_TO_STRING16_A(std::deque)
BALAU_CONTAINER2_TO_STRING16_A(std::forward_list)
BALAU_CONTAINER2_TO_STRING16_A(std::list)
BALAU_CONTAINER2_TO_STRING16_A(std::map)
BALAU_CONTAINER3_TO_STRING16_A(std::multiset)
BALAU_CONTAINER4_TO_STRING16_A(std::multimap)
BALAU_CONTAINER3_TO_STRING16_A(std::priority_queue)
BALAU_CONTAINER2_TO_STRING16_A(std::queue)
BALAU_CONTAINER2_TO_STRING16_A(std::set)
BALAU_CONTAINER2_TO_STRING16_A(std::stack)
BALAU_CONTAINER5_TO_STRING16_A(std::unordered_map)
BALAU_CONTAINER5_TO_STRING16_A(std::unordered_multimap)
BALAU_CONTAINER4_TO_STRING16_A(std::unordered_multiset)
BALAU_CONTAINER3_TO_STRING16_A(std::unordered_set)
BALAU_CONTAINER2_TO_STRING16_A(std::vector)

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


template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(const std::string & value) {
    return Balau::Boost::Locale::Conv::utf_to_utf<char32_t, char, AllocatorT>(Balau::U8String<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(const Balau::U8String<AllocatorT> & value) {
    return Balau::Boost::Locale::Conv::utf_to_utf<char32_t, char, AllocatorT>(value);
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(const std::string_view & value) {
    return toString32<AllocatorT>(Balau::U8String<AllocatorT>(value));
}

#ifndef BALAU_USE_BOOST_STRING_VIEW

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(const boost::string_view & value) {
    return toString32<AllocatorT>(Balau::U8String<AllocatorT>(value.to_string()));
}

#endif

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(const std::u16string & value) {
    return Balau::Boost::Locale::Conv::utf_to_utf<char32_t, char16_t, AllocatorT>(value);
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(const Balau::U32String<AllocatorT> & value) {
    return value;
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(const std::u32string & value) {
    return Balau::U8String<AllocatorT>(value.data(), value.length());
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(const std::u32string_view & value) {
    return Balau::U32String<AllocatorT>(value);
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(char value) {
    Balau::U8String<AllocatorT> str;
    str += value;
    return toString32<AllocatorT>(str);
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(char16_t & value) {
    Balau::U16String<AllocatorT> str;
    str += value;
    return toString32<AllocatorT>(str);
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(char32_t & value) {
    Balau::U32String<AllocatorT> str;
    str += value;
    return str;
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(signed char value) {
    return toString32<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(short value) {
    return toString32<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(int value) {
    return toString32<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(long value) {
    return toString32<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(long long value) {
    return toString32<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(unsigned char value) {
    return toString32<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(unsigned short value) {
    return toString32<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(unsigned int value) {
    return toString32<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(unsigned long value) {
    return toString32<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(unsigned long long value) {
    return toString32<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(float value) {
    return toString32<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(double value) {
    return toString32<AllocatorT>(toString<AllocatorT>(value));
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(long double value) {
    return toString32<AllocatorT>(toString<AllocatorT>(value));
}

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

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(bool value) {
    return value ? U"true" : U"false";
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(const char * value) {
    return toString32<AllocatorT>(toString<AllocatorT>((value)));
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(const char16_t * value) {
    return toString32<AllocatorT>(toString16<AllocatorT>((value)));
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(const char32_t * value) {
    return Balau::U32String<AllocatorT>(value);
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(const void * ptr) {
    return toString32<AllocatorT>((size_t) ptr);
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(std::nullptr_t) {
    return U"0";
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(std::type_index value) {
    return toString32<AllocatorT>(value.name());
}

template <typename AllocatorT>
inline Balau::U32String<AllocatorT> toString32(const std::function<Balau::U32String<AllocatorT> ()> & f) {
    return f();
}

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

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

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

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

    builder += U"}";

    return builder;
}

#define BALAU_CONTAINER1_TO_STRING32_A(CONTAINER_TYPE)                           \
    template <typename AllocatorT, typename T>                                    \
    inline Balau::U32String<AllocatorT> toString32(const CONTAINER_TYPE<T> & c) { \
        return toString32Helper<AllocatorT>(c);                                   \
    }

#define BALAU_CONTAINER2_TO_STRING32_A(CONTAINER_TYPE)                              \
    template <typename AllocatorT, typename T, typename U>                           \
    inline Balau::U32String<AllocatorT> toString32(const CONTAINER_TYPE<T, U> & c) { \
        return toString32Helper<AllocatorT>(c);                                      \
    }

#define BALAU_CONTAINER3_TO_STRING32_A(CONTAINER_TYPE)                                 \
    template <typename AllocatorT, typename T, typename U, typename V>                  \
    inline Balau::U32String<AllocatorT> toString32(const CONTAINER_TYPE<T, U, V> & c) { \
        return toString32Helper<AllocatorT>(c);                                         \
    }

#define BALAU_CONTAINER4_TO_STRING32_A(CONTAINER_TYPE)                                    \
    template <typename AllocatorT, typename T, typename U, typename V, typename W>         \
    inline Balau::U32String<AllocatorT> toString32(const CONTAINER_TYPE<T, U, V, W> & c) { \
        return toString32Helper<AllocatorT>(c);                                            \
    }

#define BALAU_CONTAINER5_TO_STRING32_A(CONTAINER_TYPE)                                        \
    template <typename AllocatorT, typename T, typename U, typename V, typename W, typename X> \
    inline Balau::U32String<AllocatorT> toString32(const CONTAINER_TYPE<T, U, V, W, X> & c) {  \
        return toString32Helper<AllocatorT>(c);                                                \
    }

BALAU_CONTAINER2_TO_STRING32_A(std::deque)
BALAU_CONTAINER2_TO_STRING32_A(std::forward_list)
BALAU_CONTAINER2_TO_STRING32_A(std::list)
BALAU_CONTAINER2_TO_STRING32_A(std::map)
BALAU_CONTAINER3_TO_STRING32_A(std::multiset)
BALAU_CONTAINER4_TO_STRING32_A(std::multimap)
BALAU_CONTAINER3_TO_STRING32_A(std::priority_queue)
BALAU_CONTAINER2_TO_STRING32_A(std::queue)
BALAU_CONTAINER2_TO_STRING32_A(std::set)
BALAU_CONTAINER2_TO_STRING32_A(std::stack)
BALAU_CONTAINER5_TO_STRING32_A(std::unordered_map)
BALAU_CONTAINER5_TO_STRING32_A(std::unordered_multimap)
BALAU_CONTAINER4_TO_STRING32_A(std::unordered_multiset)
BALAU_CONTAINER3_TO_STRING32_A(std::unordered_set)
BALAU_CONTAINER2_TO_STRING32_A(std::vector)

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


template <typename CharT, typename AllocatorT = std::allocator<CharT>> struct ToString;

template <typename AllocatorT> struct ToString<char, AllocatorT> {
    template <typename T> Balau::U8String<AllocatorT> operator () (const T & object) const {
        return toString<AllocatorT>(object);
    }
};

template <typename AllocatorT> struct ToString<char16_t, AllocatorT> {
    template <typename T> Balau::U16String<AllocatorT> operator () (const T & object) const {
        return toString16<AllocatorT>(object);
    }
};

template <typename AllocatorT> struct ToString<char32_t, AllocatorT> {
    template <typename T> Balau::U32String<AllocatorT> operator () (const T & object) const {
        return toString32<AllocatorT>(object);
    }
};

#endif // COM_BORA_SOFTWARE__BALAU_APPLICATION__TO_STRING_A