j3d1/json
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

remove explicit keyword on udt-constructor

Browse source
This commit is contained in:
Théo DELRIEU 2016-12-04 17:52:55 +01:00 committed by Théo DELRIEU
parent c0c72b5b62
commit 1eafac7220
2 changed files with 55 additions and 53 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

64
src/json.hpp
View file

@ -257,6 +257,14 @@ struct is_compatible_integer_type_impl<true, RealIntegerType, CompatibleNumberIn
RealLimits::is_signed == CompatibleLimits::is_signed;
};
template <typename RealIntegerType, typename CompatibleNumberIntegerType>
struct is_compatible_integer_type
{
static constexpr auto value = is_compatible_integer_type_impl<
std::is_arithmetic<CompatibleNumberIntegerType>::value, RealIntegerType,
CompatibleNumberIntegerType>::value;
};
// quickfix, just trying to make things compile before refactoring
template <bool B, typename RealIntegerType, typename CompatibleEnumType>
struct is_compatible_enum_type_impl : std::false_type {};
@ -264,31 +272,20 @@ struct is_compatible_enum_type_impl : std::false_type{};
template <typename RealIntegerType, typename CompatibleEnumType>
struct is_compatible_enum_type_impl<true, RealIntegerType, CompatibleEnumType>
{
using RealLimits = std::numeric_limits<RealIntegerType>;
using CompatibleLimits = std::numeric_limits<typename std::underlying_type<CompatibleEnumType>::type>;
using Underlying = typename std::underlying_type<CompatibleEnumType>::type;
static constexpr auto value =
CompatibleLimits::is_integer and
RealLimits::is_signed == CompatibleLimits::is_signed;
is_compatible_integer_type<RealIntegerType, Underlying>::value;
};
template <typename RealIntegerType, typename CompatibleEnumType>
struct is_compatible_enum_type
{
static constexpr auto value = is_compatible_enum_type_impl<
// quickfix for all enums
std::is_enum<CompatibleEnumType>::value, RealIntegerType,
static constexpr auto value =
is_compatible_enum_type_impl<std::is_enum<CompatibleEnumType>::value,
RealIntegerType,
CompatibleEnumType>::value;
};
template <typename RealIntegerType, typename CompatibleNumberIntegerType>
struct is_compatible_integer_type
{
static constexpr auto value = is_compatible_integer_type_impl<
std::is_arithmetic<CompatibleNumberIntegerType>::value, RealIntegerType,
CompatibleNumberIntegerType>::value;
};
template <typename RealFloat, typename CompatibleFloat>
struct is_compatible_float_type
{
@ -306,6 +303,7 @@ struct is_compatible_basic_json_type
std::is_same<typename BasicJson::boolean_t, T>::value or
is_compatible_array_type<BasicJson, T>::value or
is_compatible_enum_type<T, typename BasicJson::number_integer_t>::value or
is_compatible_enum_type<T, typename BasicJson::number_unsigned_t>::value or
is_compatible_object_type<typename BasicJson::object_t, T>::value or
is_compatible_float_type<typename BasicJson::number_float_t, T>::value or
is_compatible_integer_type<typename BasicJson::number_integer_t,
@ -1627,8 +1625,8 @@ class basic_json
uncvref_t<T>, basic_json_t>::value and
not detail::is_basic_json_nested_class<uncvref_t<T>, basic_json_t, primitive_iterator_t>::value and
not std::is_same<uncvref_t<T>, typename basic_json_t::array_t::iterator>::value and
// quickfix
not std::is_enum<uncvref_t<T>>::value and
not detail::is_compatible_enum_type<number_integer_t, uncvref_t<T>>::value and
not detail::is_compatible_enum_type<number_unsigned_t, uncvref_t<T>>::value and
not std::is_same<uncvref_t<T>, typename basic_json_t::object_t::iterator>::value and
detail::has_to_json<JSONSerializer, basic_json,
uncvref_t<T>>::value,
@ -1831,16 +1829,16 @@ not std::is_enum<uncvref_t<T>>::value and
@since version 1.0.0
*/
template <
typename CompatibleNumberIntegerType,
enable_if_t<detail::is_compatible_integer_type<
template <typename CompatibleNumberIntegerType,
enable_if_t<
detail::is_compatible_integer_type<
number_integer_t, CompatibleNumberIntegerType>::value or
detail::is_compatible_enum_type<number_integer_t, CompatibleNumberIntegerType>::value,
detail::is_compatible_enum_type<
number_integer_t, CompatibleNumberIntegerType>::value,
int> = 0>
basic_json(const CompatibleNumberIntegerType val) noexcept
: m_type(value_t::number_integer),
m_value(static_cast<number_integer_t>(val))
{
m_value(static_cast<number_integer_t>(val)) {
assert_invariant();
}
@ -1892,13 +1890,15 @@ detail::is_compatible_enum_type<number_integer_t, CompatibleNumberIntegerType>::
*/
template <
typename CompatibleNumberUnsignedType,
enable_if_t<detail::is_compatible_integer_type<
number_unsigned_t, CompatibleNumberUnsignedType>::value,
enable_if_t<
detail::is_compatible_integer_type<
number_unsigned_t, CompatibleNumberUnsignedType>::value or
detail::is_compatible_enum_type<
number_integer_t, CompatibleNumberUnsignedType>::value,
int> = 0>
basic_json(const CompatibleNumberUnsignedType val) noexcept
: m_type(value_t::number_unsigned),
m_value(static_cast<number_unsigned_t>(val))
{
m_value(static_cast<number_unsigned_t>(val)) {
assert_invariant();
}
@ -8603,12 +8603,14 @@ detail::is_compatible_enum_type<number_integer_t, CompatibleNumberIntegerType>::
return lhs.m_it >= rhs.m_it;
}
friend constexpr bool operator+(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
primitive_iterator_t operator+(difference_type i)
{
return lhs.m_it + rhs.m_it;
auto result = *this;
result += i;
return result;
}
friend constexpr bool operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
{
return lhs.m_it - rhs.m_it;
}

18
test/src/unit-udt.cpp
View file

@ -85,7 +85,7 @@ namespace udt
void to_json(nlohmann::json& j, person const& p)
{
using nlohmann::json;
j = json{{"age", json{p.m_age}}, {"name", json{p.m_name}}};
j = json{{"age", p.m_age}, {"name", p.m_name}};
}
void to_json(nlohmann::json& j, address const& a)
@ -96,13 +96,13 @@ namespace udt
void to_json(nlohmann::json& j, contact const& c)
{
using nlohmann::json;
j = json{{"person", json{c.m_person}}, {"address", json{c.m_address}}};
j = json{{"person", c.m_person}, {"address", c.m_address}};
}
void to_json(nlohmann::json& j, contact_book const& cb)
{
using nlohmann::json;
j = json{{"name", json{cb.m_book_name}}, {"contacts", cb.m_contacts}};
j = json{{"name", cb.m_book_name}, {"contacts", cb.m_contacts}};
}
// operators
@ -190,15 +190,15 @@ TEST_CASE("basic usage", "[udt]")
SECTION("conversion to json via free-functions")
{
CHECK(json{a} == json(23));
CHECK(json{n} == json("theo"));
CHECK(json{sfinae_addict} == R"({"name":"theo", "age":23})"_json);
CHECK(json("Paris") == json{addr});
CHECK(json{cpp_programmer} ==
CHECK(json(a) == json(23));
CHECK(json(n) == json("theo"));
CHECK(json(sfinae_addict) == R"({"name":"theo", "age":23})"_json);
CHECK(json("Paris") == json(addr));
CHECK(json(cpp_programmer) ==
R"({"person" : {"age":23, "name":"theo"}, "address":"Paris"})"_json);
CHECK(
json{book} ==
json(book) ==
R"({"name":"C++", "contacts" : [{"person" : {"age":23, "name":"theo"}, "address":"Paris"}, {"person" : {"age":23, "name":"theo"}, "address":"Paris"}]})"_json);
}