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(object.reflectable(allocator));
}
 
template <typename T, typename WALK_FILTER, typename ALLOC>
string<ALLOC> 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>>(
            string<ALLOC>(allocator));
    detail::toJsonStream(object, stream, indent, walkFilter, allocator);
    return stream.str();
}
 
template <typename T, typename WALK_FILTER, typename ALLOC>
void toJsonFile(const T& object, const string<ALLOC>& fileName, uint8_t indent, WALK_FILTER&& walkFilter,
        const ALLOC& allocator)
{
    std::ofstream stream = std::ofstream(fileName.c_str(), 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 ReflectablePtr = IBasicReflectablePtr<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>
string<ALLOC> 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>
string<ALLOC> 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>
string<ALLOC> 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>
string<ALLOC> 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, const string<ALLOC>& 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, const string<ALLOC>& 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, const string<ALLOC>& 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 string<ALLOC>& 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>::ReflectablePtr 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(T::typeInfo(), is, allocator)));
}
 
template <typename ALLOC = std::allocator<uint8_t>>
typename detail::DebugStringTraits<ALLOC>::ReflectablePtr fromJsonString(
        const IBasicTypeInfo<ALLOC>& typeInfo, const string<ALLOC>& 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 string<ALLOC>& json, const ALLOC& allocator = ALLOC())
{
    return std::move(ReflectableUtil::getValue<T, ALLOC>(fromJsonString(T::typeInfo(), json, allocator)));
}
 
template <typename ALLOC = std::allocator<uint8_t>>
typename detail::DebugStringTraits<ALLOC>::ReflectablePtr fromJsonFile(
        const IBasicTypeInfo<ALLOC>& typeInfo, const string<ALLOC>& fileName, const ALLOC& allocator = ALLOC())
{
    std::ifstream is = std::ifstream(fileName.c_str());
    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(const string<ALLOC>& fileName, const ALLOC& allocator = ALLOC())
{
    return std::move(ReflectableUtil::getValue<T, ALLOC>(fromJsonFile(T::typeInfo(), fileName, allocator)));
}
 
} // namespace zserio
 
#endif // ZSERIO_DEBUG_STRING_UTIL_H_INC