errorhandling.h

Go to the documentation of this file.

#ifndef REFLECTIVE_RAPIDJSON_JSON_ERROR_HANDLING_H
#define REFLECTIVE_RAPIDJSON_JSON_ERROR_HANDLING_H
 
#include <c++utilities/misc/traits.h>
 
#include <rapidjson/rapidjson.h>
 
#include <cstdint>
#include <limits>
#include <list>
#include <string>
#include <vector>
 
namespace ReflectiveRapidJSON {
 
enum class JsonDeserializationErrorKind : std::uint8_t {
    TypeMismatch, 
    ArraySizeMismatch, 
    ConversionError, 
    UnexpectedDuplicate, 
    InvalidVariantObject, 
    InvalidVariantIndex, 
};
 
enum class JsonType : std::uint8_t {
    Null,
    Number,
    Bool,
    String,
    Array,
    Object,
};
 
// define helper functions which return the JsonType for the C++ type specified as template parameter
 
template <typename Type,
    Traits::EnableIf<Traits::Not<std::is_same<Type, bool>>, Traits::Any<std::is_integral<Type>, std::is_floating_point<Type>>> * = nullptr>
constexpr JsonType jsonType()
{
    return JsonType::Number;
}
 
template <typename Type, Traits::EnableIfAny<std::is_same<Type, bool>> * = nullptr> constexpr JsonType jsonType()
{
    return JsonType::Bool;
}
 
template <typename Type, Traits::EnableIfAny<Traits::IsString<Type>, Traits::IsCString<Type>> * = nullptr> constexpr JsonType jsonType()
{
    return JsonType::String;
}
 
template <typename Type,
    Traits::EnableIf<Traits::IsIteratable<Type>,
        Traits::Not<Traits::Any<Traits::IsString<Type>, Traits::IsSpecializationOf<Type, std::map>,
            Traits::IsSpecializationOf<Type, std::unordered_map>>>> * = nullptr>
constexpr JsonType jsonType()
{
    return JsonType::Array;
}
 
template <typename Type,
    Traits::DisableIfAny<std::is_integral<Type>, std::is_floating_point<Type>, Traits::IsString<Type>, Traits::IsCString<Type>,
        Traits::All<Traits::IsIteratable<Type>,
            Traits::Not<Traits::Any<Traits::IsString<Type>, Traits::IsSpecializationOf<Type, std::map>,
                Traits::IsSpecializationOf<Type, std::unordered_map>>>>> * = nullptr>
constexpr JsonType jsonType()
{
    return JsonType::Object;
}
 
constexpr JsonType jsonType(RAPIDJSON_NAMESPACE::Type type)
{
    switch (type) {
    case RAPIDJSON_NAMESPACE::kFalseType:
    case RAPIDJSON_NAMESPACE::kTrueType:
        return JsonType::Bool;
    case RAPIDJSON_NAMESPACE::kObjectType:
        return JsonType::Object;
    case RAPIDJSON_NAMESPACE::kArrayType:
        return JsonType::Array;
    case RAPIDJSON_NAMESPACE::kStringType:
        return JsonType::String;
    case RAPIDJSON_NAMESPACE::kNumberType:
        return JsonType::Number;
    default:
        return JsonType::Null;
    }
}
 
struct JsonDeserializationError {
    JsonDeserializationError(JsonDeserializationErrorKind kind, JsonType expectedType, JsonType actualType, const char *record,
        const char *member = nullptr, std::size_t index = noIndex);
 
    JsonDeserializationErrorKind kind;
    JsonType expectedType;
    JsonType actualType;
    const char *record;
    const char *member;
    std::size_t index;
 
    static constexpr std::size_t noIndex = std::numeric_limits<std::size_t>::max();
};
 
inline JsonDeserializationError::JsonDeserializationError(
    JsonDeserializationErrorKind kind, JsonType expectedType, JsonType actualType, const char *record, const char *member, std::size_t index)
    : kind(kind)
    , expectedType(expectedType)
    , actualType(actualType)
    , record(record)
    , member(member)
    , index(index)
{
}
 
struct JsonDeserializationErrors : public std::vector<JsonDeserializationError> {
    JsonDeserializationErrors();
 
    template <typename ExpectedType> void reportTypeMismatch(RAPIDJSON_NAMESPACE::Type presentType);
    void reportArraySizeMismatch();
    void reportConversionError(JsonType jsonType);
    void reportUnexpectedDuplicate(JsonType jsonType);
 
    const char *currentRecord;
    const char *currentMember;
    std::size_t currentIndex;
    enum class ThrowOn : std::uint8_t {
        None = 0,
        TypeMismatch = 0x1,
        ArraySizeMismatch = 0x2,
        ConversionError = 0x4,
        UnexpectedDuplicate = 0x8,
        All = 0xFF,
    } throwOn;
 
private:
    void throwMaybe(ThrowOn on) const;
};
 
inline JsonDeserializationErrors::JsonDeserializationErrors()
    : currentRecord("[document]")
    , currentMember(nullptr)
    , currentIndex(JsonDeserializationError::noIndex)
    , throwOn(ThrowOn::None)
{
}
 
constexpr JsonDeserializationErrors::ThrowOn operator|(JsonDeserializationErrors::ThrowOn lhs, JsonDeserializationErrors::ThrowOn rhs)
{
    return static_cast<JsonDeserializationErrors::ThrowOn>(static_cast<std::uint8_t>(lhs) | static_cast<std::uint8_t>(rhs));
}
 
inline void JsonDeserializationErrors::throwMaybe(ThrowOn on) const
{
    if (static_cast<std::uint8_t>(throwOn) & static_cast<std::uint8_t>(on)) {
        throw back();
    }
}
 
template <typename ExpectedType> inline void JsonDeserializationErrors::reportTypeMismatch(RAPIDJSON_NAMESPACE::Type presentType)
{
    emplace_back(
        JsonDeserializationErrorKind::TypeMismatch, jsonType<ExpectedType>(), jsonType(presentType), currentRecord, currentMember, currentIndex);
    throwMaybe(ThrowOn::TypeMismatch);
}
 
inline void JsonDeserializationErrors::reportArraySizeMismatch()
{
    emplace_back(JsonDeserializationErrorKind::ArraySizeMismatch, JsonType::Array, JsonType::Array, currentRecord, currentMember, currentIndex);
    throwMaybe(ThrowOn::ArraySizeMismatch);
}
 
inline void JsonDeserializationErrors::reportConversionError(JsonType jsonType)
{
    emplace_back(JsonDeserializationErrorKind::ConversionError, jsonType, jsonType, currentRecord, currentMember, currentIndex);
    throwMaybe(ThrowOn::ConversionError);
}
 
inline void JsonDeserializationErrors::reportUnexpectedDuplicate(JsonType jsonType)
{
    emplace_back(JsonDeserializationErrorKind::UnexpectedDuplicate, jsonType, jsonType, currentRecord, currentMember, currentIndex);
    throwMaybe(ThrowOn::UnexpectedDuplicate);
}
 
} // namespace ReflectiveRapidJSON
 
#endif // REFLECTIVE_RAPIDJSON_JSON_REFLECTOR_H