DebugStringUtil.h

Go to the documentation of this file.

 
#ifndef ZSERIO_DEBUG_STRING_UTIL_H_INC
#define ZSERIO_DEBUG_STRING_UTIL_H_INC
 
#include <fstream>
#include <sstream>
#include <utility>
 
#include "zserio/JsonReader.h"
#include "zserio/JsonWriter.h"
#include "zserio/ReflectableUtil.h"
#include "zserio/Traits.h"
#include "zserio/Walker.h"
 
namespace zserio
{
 
namespace detail
{
 
// Implementations needs to be in detail because old MSVC compiler 2015 has problems with calling overload.
 
template <typename T, typename WALK_FILTER, typename ALLOC>
void toJsonStream(
        const T& object, std::ostream& stream, uint8_t indent, WALK_FILTER&& walkFilter, const ALLOC& allocator)
{
    // static_assert(has_reflectable<T>::value,
    //         "DebugStringUtil.toJsonStream: "
    //         "Zserio object must have reflections enabled (see zserio option -withReflectionCode)!");
 
    BasicJsonWriter<ALLOC> jsonWriter(stream, indent);
    BasicWalker<ALLOC> walker(jsonWriter, walkFilter);
    walker.walk(reflectable(object, allocator));
}
 
template <typename T, typename WALK_FILTER, typename ALLOC>
BasicString<RebindAlloc<ALLOC, char>> toJsonString(
        const T& object, uint8_t indent, WALK_FILTER&& walkFilter, const ALLOC& allocator)
{
    auto stream = std::basic_ostringstream<char, std::char_traits<char>, RebindAlloc<ALLOC, char>>(
            BasicString<RebindAlloc<ALLOC, char>>(allocator));
    detail::toJsonStream(object, stream, indent, walkFilter, allocator);
    return stream.str();
}
 
template <typename T, typename WALK_FILTER, typename ALLOC>
void toJsonFile(const T& object, std::string_view fileName, uint8_t indent, WALK_FILTER&& walkFilter,
        const ALLOC& allocator)
{
    std::ofstream stream = std::ofstream(fileName.data(), std::ios::out | std::ios::trunc);
    if (!stream)
    {
        throw CppRuntimeException("DebugStringUtil.toJsonFile: Failed to open '") << fileName << "'!";
    }
 
    detail::toJsonStream(object, stream, indent, walkFilter, allocator);
 
    if (!stream)
    {
        throw CppRuntimeException("DebugStringUtil.toJsonFile: Failed to write '") << fileName << "'!";
    }
}
 
// needed due to GCC compilation problems, GCC tries to instantiate return type even though the
// particular function template has different number of arguments, this prevents the return type instantiation
// in case that the ALLOC is not an allocator
template <typename ALLOC, typename std::enable_if<is_allocator<ALLOC>::value, int>::type = 0>
struct DebugStringTraits
{
    using ReflectableDataPtr = IBasicReflectableDataPtr<ALLOC>;
};
 
} // namespace detail
 
template <typename T, typename ALLOC = typename T::allocator_type,
        typename std::enable_if<is_allocator<ALLOC>::value, int>::type = 0>
void toJsonStream(const T& object, std::ostream& stream, const ALLOC& allocator = ALLOC())
{
    detail::toJsonStream(object, stream, 4, BasicDefaultWalkFilter<ALLOC>(), allocator);
}
 
template <typename T, typename ALLOC = typename T::allocator_type,
        typename std::enable_if<is_allocator<ALLOC>::value, int>::type = 0>
void toJsonStream(const T& object, std::ostream& stream, uint8_t indent, const ALLOC& allocator = ALLOC())
{
    detail::toJsonStream(object, stream, indent, BasicDefaultWalkFilter<ALLOC>(), allocator);
}
 
template <typename T, typename WALK_FILTER, typename ALLOC = typename T::allocator_type,
        typename std::enable_if<
                std::is_base_of<IBasicWalkFilter<ALLOC>, typename std::decay<WALK_FILTER>::type>::value,
                int>::type = 0>
void toJsonStream(
        const T& object, std::ostream& stream, WALK_FILTER&& walkFilter, const ALLOC& allocator = ALLOC())
{
    detail::toJsonStream(object, stream, 4, walkFilter, allocator);
}
 
template <typename T, typename WALK_FILTER, typename ALLOC = typename T::allocator_type,
        typename std::enable_if<
                std::is_base_of<IBasicWalkFilter<ALLOC>, typename std::decay<WALK_FILTER>::type>::value,
                int>::type = 0>
void toJsonStream(const T& object, std::ostream& stream, uint8_t indent, WALK_FILTER&& walkFilter,
        const ALLOC& allocator = ALLOC())
{
    detail::toJsonStream(object, stream, indent, walkFilter, allocator);
}
 
template <typename T, typename ALLOC = typename T::allocator_type,
        typename std::enable_if<is_allocator<ALLOC>::value, int>::type = 0>
BasicString<RebindAlloc<ALLOC, char>> toJsonString(const T& object, const ALLOC& allocator = ALLOC())
{
    return detail::toJsonString(object, 4, BasicDefaultWalkFilter<ALLOC>(), allocator);
}
 
template <typename T, typename ALLOC = typename T::allocator_type,
        typename std::enable_if<is_allocator<ALLOC>::value, int>::type = 0>
BasicString<RebindAlloc<ALLOC, char>> toJsonString(
        const T& object, uint8_t indent, const ALLOC& allocator = ALLOC())
{
    return detail::toJsonString(object, indent, BasicDefaultWalkFilter<ALLOC>(), allocator);
}
 
template <typename T, typename WALK_FILTER, typename ALLOC = typename T::allocator_type,
        typename std::enable_if<
                std::is_base_of<IBasicWalkFilter<ALLOC>, typename std::decay<WALK_FILTER>::type>::value,
                int>::type = 0>
BasicString<RebindAlloc<ALLOC, char>> toJsonString(
        const T& object, WALK_FILTER&& walkFilter, const ALLOC& allocator = ALLOC())
{
    return detail::toJsonString(object, 4, walkFilter, allocator);
}
 
template <typename T, typename WALK_FILTER, typename ALLOC = typename T::allocator_type,
        typename std::enable_if<
                std::is_base_of<IBasicWalkFilter<ALLOC>, typename std::decay<WALK_FILTER>::type>::value,
                int>::type = 0>
BasicString<RebindAlloc<ALLOC, char>> toJsonString(
        const T& object, uint8_t indent, WALK_FILTER&& walkFilter, const ALLOC& allocator = ALLOC())
{
    return detail::toJsonString(object, indent, walkFilter, allocator);
}
 
template <typename T, typename ALLOC = typename T::allocator_type,
        typename std::enable_if<is_allocator<ALLOC>::value, int>::type = 0>
void toJsonFile(const T& object, std::string_view fileName, const ALLOC& allocator = ALLOC())
{
    return detail::toJsonFile(object, fileName, 4, BasicDefaultWalkFilter<ALLOC>(), allocator);
}
 
template <typename T, typename ALLOC = typename T::allocator_type,
        typename std::enable_if<is_allocator<ALLOC>::value, int>::type = 0>
void toJsonFile(const T& object, std::string_view fileName, uint8_t indent, const ALLOC& allocator = ALLOC())
{
    return detail::toJsonFile(object, fileName, indent, BasicDefaultWalkFilter<ALLOC>(), allocator);
}
 
template <typename T, typename WALK_FILTER, typename ALLOC = typename T::allocator_type,
        typename std::enable_if<
                std::is_base_of<IBasicWalkFilter<ALLOC>, typename std::decay<WALK_FILTER>::type>::value,
                int>::type = 0>
void toJsonFile(
        const T& object, std::string_view fileName, WALK_FILTER&& walkFilter, const ALLOC& allocator = ALLOC())
{
    return detail::toJsonFile(object, fileName, 4, walkFilter, allocator);
}
 
template <typename T, typename WALK_FILTER, typename ALLOC = typename T::allocator_type,
        typename std::enable_if<
                std::is_base_of<IBasicWalkFilter<ALLOC>, typename std::decay<WALK_FILTER>::type>::value,
                int>::type = 0>
void toJsonFile(const T& object, const BasicString<RebindAlloc<ALLOC, char>>& fileName, uint8_t indent,
        WALK_FILTER&& walkFilter, const ALLOC& allocator = ALLOC())
{
    return detail::toJsonFile(object, fileName, indent, walkFilter, allocator);
}
 
template <typename ALLOC = std::allocator<uint8_t>>
typename detail::DebugStringTraits<ALLOC>::ReflectableDataPtr fromJsonStream(
        const IBasicTypeInfo<ALLOC>& typeInfo, std::istream& is, const ALLOC& allocator = ALLOC())
{
    BasicJsonReader<ALLOC> jsonReader(is, allocator);
    return jsonReader.read(typeInfo);
}
 
template <typename T, typename ALLOC = typename T::allocator_type>
T fromJsonStream(std::istream& is, const ALLOC& allocator = ALLOC())
{
    return std::move(ReflectableUtil::getValue<T, ALLOC>(fromJsonStream(typeInfo<T>(), is, allocator)));
}
 
template <typename ALLOC = std::allocator<uint8_t>>
typename detail::DebugStringTraits<ALLOC>::ReflectableDataPtr fromJsonString(
        const IBasicTypeInfo<ALLOC>& typeInfo, const BasicString<RebindAlloc<ALLOC, char>>& json,
        const ALLOC& allocator = ALLOC())
{
    std::basic_istringstream<char, std::char_traits<char>, RebindAlloc<ALLOC, char>> stream(json);
    return fromJsonStream(typeInfo, stream, allocator);
}
 
template <typename T, typename ALLOC = typename T::allocator_type>
T fromJsonString(const BasicString<RebindAlloc<ALLOC, char>>& json, const ALLOC& allocator = ALLOC())
{
    return std::move(ReflectableUtil::getValue<T, ALLOC>(fromJsonString(typeInfo<T>(), json, allocator)));
}
 
template <typename ALLOC = std::allocator<uint8_t>>
typename detail::DebugStringTraits<ALLOC>::ReflectableDataPtr fromJsonFile(
        const IBasicTypeInfo<ALLOC>& typeInfo, std::string_view fileName, const ALLOC& allocator = ALLOC())
{
    std::ifstream is = std::ifstream(fileName.data());
    if (!is)
    {
        throw CppRuntimeException("DebugStringUtil.fromJsonFile: Failed to open '") << fileName << "'!";
    }
 
    return fromJsonStream(typeInfo, is, allocator);
}
 
template <typename T, typename ALLOC = typename T::allocator_type>
T fromJsonFile(std::string_view fileName, const ALLOC& allocator = ALLOC())
{
    return std::move(ReflectableUtil::getValue<T, ALLOC>(fromJsonFile(typeInfo<T>(), fileName, allocator)));
}
 
} // namespace zserio
 
#endif // ZSERIO_DEBUG_STRING_UTIL_H_INC