catch2/include/internal/catch_tostring.h

/*
 *  Created by Phil on 8/5/2012.
 *  Copyright 2012 Two Blue Cubes Ltd. All rights reserved.
 *
 *  Distributed under the Boost Software License, Version 1.0. (See accompanying
 *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */
#ifndef TWOBLUECUBES_CATCH_TOSTRING_H_INCLUDED
#define TWOBLUECUBES_CATCH_TOSTRING_H_INCLUDED

#include "catch_common.h"

#include <sstream>
#include <iomanip>
#include <limits>
#include <vector>
#include <cstddef>

#ifdef __OBJC__
#include "catch_objc_arc.hpp"
#endif

#include <tuple>

#include <type_traits>

#include <string>

// We need a dummy global operator<< so we can bring it into Catch namespace later
struct Catch_global_namespace_dummy;
std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);

namespace Catch {
    // Bring in operator<< from global namespace into Catch namespace
    using ::operator<<;

    namespace Detail {
        std::string rawMemoryToString( const void *object, std::size_t size );

        template<typename T>
        std::string rawMemoryToString( const T& object ) {
          return rawMemoryToString( &object, sizeof(object) );
        }

        template<typename T>
        class IsStreamInsertable {
            template<typename SS, typename TT>
            static auto test(int)
                -> decltype(std::declval<SS&>() << std::declval<TT>(), std::true_type());

            template<typename, typename>
            static auto test(...)->std::false_type;

        public:
            static const bool value = decltype(test<std::ostream, const T&>(0))::value;
        };
    
    } // namespace Detail

    // If we decide for C++14, change these to enable_if_ts
    template <typename T>
    struct StringMaker {
        template <typename Fake = T>
        typename std::enable_if<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
            operator()(const Fake& t) {
            std::stringstream sstr;
            sstr << t;
            return sstr.str();
        }

        template <typename Fake = T>
        typename std::enable_if<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
            operator()(const Fake&) {
            return "{?}";
        }
    };

    namespace Detail {

        extern const std::string unprintableString;

        // This function dispatches all stringification requests inside of Catch.
        // Should be preferably called fully qualified, like ::Catch::Detail::stringify
        template <typename T>
        std::string stringify(const T& e) {
            return ::Catch::StringMaker<typename std::remove_cv<typename std::remove_reference<T>::type>::type>{}(e);
        }

    } // namespace Detail


    // Some predefined specializations

    template<>
    struct StringMaker<std::string> {
        std::string operator()(const std::string& str);
    };
    template<>
    struct StringMaker<std::wstring> {
        std::string operator()(const std::wstring& wstr);
    };

    template<>
    struct StringMaker<char const *> {
        std::string operator()(char const * str);
    };
    template<>
    struct StringMaker<char *> {
        std::string operator()(char * str);
    };
    template<>
    struct StringMaker<wchar_t const *> {
        std::string operator()(wchar_t const * str);
    };
    template<>
    struct StringMaker<wchar_t *> {
        std::string operator()(wchar_t * str);
    };

    template<int SZ>
    struct StringMaker<char[SZ]> {
        std::string operator()(const char* str) {
            return ::Catch::Detail::stringify(std::string{ str });
        }
    };
    template<int SZ>
    struct StringMaker<signed char[SZ]> {
        std::string operator()(const char* str) {
            return ::Catch::Detail::stringify(std::string{ str });
        }
    };
    template<int SZ>
    struct StringMaker<unsigned char[SZ]> {
        std::string operator()(const char* str) {
            return ::Catch::Detail::stringify(std::string{ str });
        }
    };

    template<>
    struct StringMaker<int> {
        std::string operator()(int value);
    };
    template<>
    struct StringMaker<long> {
        std::string operator()(long value);
    };
    template<>
    struct StringMaker<long long> {
        std::string operator()(long long value);
    };
    template<>
    struct StringMaker<unsigned int> {
        std::string operator()(unsigned int value);
    };
    template<>
    struct StringMaker<unsigned long> {
        std::string operator()(unsigned long value);
    };
    template<>
    struct StringMaker<unsigned long long> {
        std::string operator()(unsigned long long value);
    };

    template<>
    struct StringMaker<bool> {
        std::string operator()(bool b);
    };

    template<>
    struct StringMaker<char> {
        std::string operator()(char c);
    };
    template<>
    struct StringMaker<signed char> {
        std::string operator()(signed char c);
    };
    template<>
    struct StringMaker<unsigned char> {
        std::string operator()(unsigned char c);
    };

    template<>
    struct StringMaker<std::nullptr_t> {
        std::string operator()(std::nullptr_t);
    };

    template<>
    struct StringMaker<float> {
        std::string operator()(float value);
    };
    template<>
    struct StringMaker<double> {
        std::string operator()(double value);
    };

    template <typename T>
    struct StringMaker<T*> {
        template <typename U>
        std::string operator()(U* p) {
            if (p) {
                return ::Catch::Detail::rawMemoryToString(p);
            } else {
                return "nullptr";
            }
        }
    };

    template <typename R, typename C>
    struct StringMaker<R C::*> {
        std::string operator()(R C::* p) {
            if (p) {
                return ::Catch::Detail::rawMemoryToString(p);
            } else {
                return "nullptr";
            }
        }
    };

    namespace Detail {
        template<typename InputIterator>
        std::string rangeToString(InputIterator first, InputIterator last) {
            std::ostringstream oss;
            oss << "{ ";
            if (first != last) {
                oss << ::Catch::Detail::stringify(*first);
                for (++first; first != last; ++first)
                    oss << ", " << ::Catch::Detail::stringify(*first);
            }
            oss << " }";
            return oss.str();
        }
    }

    template<typename T, typename Allocator>
    struct StringMaker<std::vector<T, Allocator> > {
        std::string operator()( std::vector<T,Allocator> const& v ) {
            return ::Catch::Detail::rangeToString( v.begin(), v.end() );
        }
    };

    // === Pair ===
    template<typename T1, typename T2>
    struct StringMaker<std::pair<T1, T2> > {
        std::string operator()(const std::pair<T1, T2>& pair) {
            std::ostringstream oss;
            oss << "{ "
                << ::Catch::Detail::stringify(pair.first)
                << ", "
                << ::Catch::Detail::stringify(pair.second)
                << " }";
            return oss.str();
        }
    };



    namespace Detail {
        template<
            typename Tuple,
            std::size_t N = 0,
            bool = (N < std::tuple_size<Tuple>::value)
            >
            struct TupleElementPrinter {
            static void print(const Tuple& tuple, std::ostream& os) {
                os << (N ? ", " : " ")
                    << ::Catch::Detail::stringify(std::get<N>(tuple));
                TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
            }
        };

        template<
            typename Tuple,
            std::size_t N
        >
            struct TupleElementPrinter<Tuple, N, false> {
            static void print(const Tuple&, std::ostream&) {}
        };

    }


    template<typename ...Types>
    struct StringMaker<std::tuple<Types...>> {
        std::string operator()(const std::tuple<Types...>& tuple) {
            std::ostringstream os;
            os << '{';
            Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, os);
            os << " }";
            return os.str();
        }
    };


    template<typename T>
    struct EnumStringMaker {
        std::string operator()(const T& t) {
            return ::Catch::Detail::stringify(static_cast<typename std::underlying_type<T>::type>(t));
        }
    };

#ifdef __OBJC__
    template<>
    struct StringMaker<NSString const *> {
        std::string operator()(NSString const* const& nsstring);
    };
    template<>
    struct StringMaker<NSString * CATCH_ARC_STRONG> {
        std::string operator()(NSString * CATCH_ARC_STRONG const& nsstring);
    };
    template<>
    struct StringMaker<NSObject *> {
        std::string operator()(NSObject* const& nsObject);
    };
#endif


} // namespace Catch

#endif // TWOBLUECUBES_CATCH_TOSTRING_H_INCLUDED