generic-library/msgpack
1
0
Fork 0
mirror of https://github.com/msgpack/msgpack-c.git synced 2025-05-29 07:25:55 +02:00
Code Issues Projects Releases Wiki Activity

Fixed operator>>(object const& o, various types& v) return type and value problem.

Browse Source 
https://github.com/msgpack/msgpack-c/issues/105
This commit is contained in:
Takatoshi Kondo 2014-08-29 00:43:18 +09:00
parent 2c2df64427
commit 68bf4acb4b
27 changed files with 168 additions and 186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
erb/cpp03_define.hpp.erb
View File

@ -38,12 +38,12 @@
#define MSGPACK_ADD_ENUM(enum) \ #define MSGPACK_ADD_ENUM(enum) \
namespace msgpack { \ namespace msgpack { \
template <> \ template <> \
inline enum& operator>> (object const& o, enum& v) \ inline object const& operator>> (object const& o, enum& v) \
{ \ { \
int tmp; \ int tmp; \
o >> tmp; \ o >> tmp; \
v = static_cast<enum>(tmp); \ v = static_cast<enum>(tmp); \
return v; \ return o; \
} \ } \
template <> \ template <> \
inline void operator<< (object::with_zone& o, const enum& v) \ inline void operator<< (object::with_zone& o, const enum& v) \
@ -145,4 +145,3 @@ define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_define(A0& a0<%1.upto(i) {|j|%>,
#endif // MSGPACK_CPP03_DEFINE_HPP #endif // MSGPACK_CPP03_DEFINE_HPP

8
erb/cpp03_msgpack_tuple.hpp.erb
View File

@ -133,22 +133,22 @@ tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(typename tuple_type<A0>::tr
} // namespace type } // namespace type
inline type::tuple<>& operator>> ( inline object const& operator>> (
object const& o, object const& o,
type::tuple<>& v) { type::tuple<>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
return v; return o;
} }
<%0.upto(GENERATION_LIMIT) {|i|%> <%0.upto(GENERATION_LIMIT) {|i|%>
template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>> template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) { type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
if(o.via.array.size < <%=i+1%>) { throw type_error(); } if(o.via.array.size < <%=i+1%>) { throw type_error(); }
<%0.upto(i) {|j|%> <%0.upto(i) {|j|%>
o.via.array.ptr[<%=j%>].convert<typename type::tuple_type<A<%=j%>>::type>(v.template get<<%=j%>>());<%}%> o.via.array.ptr[<%=j%>].convert<typename type::tuple_type<A<%=j%>>::type>(v.template get<<%=j%>>());<%}%>
return v; return o;
} }
<%}%> <%}%>

5
include/msgpack/adaptor/bool.hpp
View File

@ -24,11 +24,11 @@
namespace msgpack { namespace msgpack {
inline bool& operator>> (object const& o, bool& v) inline object const& operator>> (object const& o, bool& v)
{ {
if(o.type != type::BOOLEAN) { throw type_error(); } if(o.type != type::BOOLEAN) { throw type_error(); }
v = o.via.boolean; v = o.via.boolean;
return v; return o;
} }
template <typename Stream> template <typename Stream>
@ -52,4 +52,3 @@ inline void operator<< (object::with_zone& o, bool v)
} // namespace msgpack } // namespace msgpack
#endif /* msgpack/type/bool.hpp */ #endif /* msgpack/type/bool.hpp */

4
include/msgpack/adaptor/cpp11/array.hpp
View File

@ -27,7 +27,7 @@
namespace msgpack { namespace msgpack {
template <typename T, std::size_t N> template <typename T, std::size_t N>
inline std::array<T, N>& operator>> (object const& o, std::array<T, N>& v) { inline object const& operator>> (object const& o, std::array<T, N>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
if(o.via.array.size != N) { throw type_error(); } if(o.via.array.size != N) { throw type_error(); }
if(o.via.array.size > 0) { if(o.via.array.size > 0) {
@ -40,7 +40,7 @@ inline std::array<T, N>& operator>> (object const& o, std::array<T, N>& v) {
++it; ++it;
} while(p < pend); } while(p < pend);
} }
return v; return o;
} }
template <typename Stream, typename T, std::size_t N> template <typename Stream, typename T, std::size_t N>

4
include/msgpack/adaptor/cpp11/array_char.hpp
View File

@ -24,7 +24,7 @@
namespace msgpack { namespace msgpack {
template <std::size_t N> template <std::size_t N>
inline std::array<char, N>& operator>> (object const& o, std::array<char, N>& v) inline object const& operator>> (object const& o, std::array<char, N>& v)
{ {
switch (o.type) { switch (o.type) {
case type::BIN: case type::BIN:
@ -39,7 +39,7 @@ inline std::array<char, N>& operator>> (object const& o, std::array<char, N>& v)
throw type_error(); throw type_error();
break; break;
} }
return v; return o;
} }
template <typename Stream, std::size_t N> template <typename Stream, std::size_t N>

4
include/msgpack/adaptor/cpp11/forward_list.hpp
View File

@ -27,7 +27,7 @@
namespace msgpack { namespace msgpack {
template <typename T> template <typename T>
inline std::forward_list<T>& operator>> (object const& o, std::forward_list<T>& v) inline object const& operator>> (object const& o, std::forward_list<T>& v)
{ {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
v.resize(o.via.array.size); v.resize(o.via.array.size);
@ -36,7 +36,7 @@ inline std::forward_list<T>& operator>> (object const& o, std::forward_list<T>&
p->convert(e); p->convert(e);
++p; ++p;
} }
return v; return o;
} }
template <typename Stream, typename T> template <typename Stream, typename T>

5
include/msgpack/adaptor/cpp11/tuple.hpp
View File

@ -76,13 +76,13 @@ struct StdTupleConverter<Tuple, 1> {
}; };
template <typename... Args> template <typename... Args>
std::tuple<Args...>& operator>> ( object const& operator>> (
object const& o, object const& o,
std::tuple<Args...>& v) { std::tuple<Args...>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
if(o.via.array.size < sizeof...(Args)) { throw type_error(); } if(o.via.array.size < sizeof...(Args)) { throw type_error(); }
StdTupleConverter<decltype(v), sizeof...(Args)>::convert(o, v); StdTupleConverter<decltype(v), sizeof...(Args)>::convert(o, v);
return v; return o;
} }
// --- Convert from tuple to object with zone --- // --- Convert from tuple to object with zone ---
@ -118,4 +118,3 @@ inline void operator<< (
} // msgpack } // msgpack
#endif // MSGPACK_CPP11_TUPLE_HPP #endif // MSGPACK_CPP11_TUPLE_HPP

5
include/msgpack/adaptor/deque.hpp
View File

@ -25,7 +25,7 @@ namespace msgpack {
template <typename T> template <typename T>
inline std::deque<T>& operator>> (object const& o, std::deque<T>& v) inline object const& operator>> (object const& o, std::deque<T>& v)
{ {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
v.resize(o.via.array.size); v.resize(o.via.array.size);
@ -35,7 +35,7 @@ inline std::deque<T>& operator>> (object const& o, std::deque<T>& v)
for(; p < pend; ++p, ++it) { for(; p < pend; ++p, ++it) {
p->convert(*it); p->convert(*it);
} }
return v; return o;
} }
template <typename Stream, typename T> template <typename Stream, typename T>
@ -74,4 +74,3 @@ inline void operator<< (object::with_zone& o, const std::deque<T>& v)
} // namespace msgpack } // namespace msgpack
#endif /* msgpack/type/deque.hpp */ #endif /* msgpack/type/deque.hpp */

5
include/msgpack/adaptor/detail/cpp03_define.hpp
View File

@ -38,12 +38,12 @@
#define MSGPACK_ADD_ENUM(enum) \ #define MSGPACK_ADD_ENUM(enum) \
namespace msgpack { \ namespace msgpack { \
template <> \ template <> \
inline enum& operator>> (object const& o, enum& v) \ inline object const& operator>> (object const& o, enum& v) \
{ \ { \
int tmp; \ int tmp; \
o >> tmp; \ o >> tmp; \
v = static_cast<enum>(tmp); \ v = static_cast<enum>(tmp); \
return v; \ return o; \
} \ } \
template <> \ template <> \
inline void operator<< (object::with_zone& o, const enum& v) \ inline void operator<< (object::with_zone& o, const enum& v) \
@ -3462,4 +3462,3 @@ define<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16
#endif // MSGPACK_CPP03_DEFINE_HPP #endif // MSGPACK_CPP03_DEFINE_HPP

132
include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp
View File

@ -10580,26 +10580,26 @@ tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16,
} // namespace type } // namespace type
inline type::tuple<>& operator>> ( inline object const& operator>> (
object const& o, object const& o,
type::tuple<>& v) { type::tuple<>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
return v; return o;
} }
template <typename A0> template <typename A0>
type::tuple<A0>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0>& v) { type::tuple<A0>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
if(o.via.array.size < 1) { throw type_error(); } if(o.via.array.size < 1) { throw type_error(); }
o.via.array.ptr[0].convert<typename type::tuple_type<A0>::type>(v.template get<0>()); o.via.array.ptr[0].convert<typename type::tuple_type<A0>::type>(v.template get<0>());
return v; return o;
} }
template <typename A0, typename A1> template <typename A0, typename A1>
type::tuple<A0, A1>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1>& v) { type::tuple<A0, A1>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -10607,11 +10607,11 @@ type::tuple<A0, A1>& operator>> (
o.via.array.ptr[0].convert<typename type::tuple_type<A0>::type>(v.template get<0>()); o.via.array.ptr[0].convert<typename type::tuple_type<A0>::type>(v.template get<0>());
o.via.array.ptr[1].convert<typename type::tuple_type<A1>::type>(v.template get<1>()); o.via.array.ptr[1].convert<typename type::tuple_type<A1>::type>(v.template get<1>());
return v; return o;
} }
template <typename A0, typename A1, typename A2> template <typename A0, typename A1, typename A2>
type::tuple<A0, A1, A2>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2>& v) { type::tuple<A0, A1, A2>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -10620,11 +10620,11 @@ type::tuple<A0, A1, A2>& operator>> (
o.via.array.ptr[0].convert<typename type::tuple_type<A0>::type>(v.template get<0>()); o.via.array.ptr[0].convert<typename type::tuple_type<A0>::type>(v.template get<0>());
o.via.array.ptr[1].convert<typename type::tuple_type<A1>::type>(v.template get<1>()); o.via.array.ptr[1].convert<typename type::tuple_type<A1>::type>(v.template get<1>());
o.via.array.ptr[2].convert<typename type::tuple_type<A2>::type>(v.template get<2>()); o.via.array.ptr[2].convert<typename type::tuple_type<A2>::type>(v.template get<2>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3> template <typename A0, typename A1, typename A2, typename A3>
type::tuple<A0, A1, A2, A3>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3>& v) { type::tuple<A0, A1, A2, A3>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -10634,11 +10634,11 @@ type::tuple<A0, A1, A2, A3>& operator>> (
o.via.array.ptr[1].convert<typename type::tuple_type<A1>::type>(v.template get<1>()); o.via.array.ptr[1].convert<typename type::tuple_type<A1>::type>(v.template get<1>());
o.via.array.ptr[2].convert<typename type::tuple_type<A2>::type>(v.template get<2>()); o.via.array.ptr[2].convert<typename type::tuple_type<A2>::type>(v.template get<2>());
o.via.array.ptr[3].convert<typename type::tuple_type<A3>::type>(v.template get<3>()); o.via.array.ptr[3].convert<typename type::tuple_type<A3>::type>(v.template get<3>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4> template <typename A0, typename A1, typename A2, typename A3, typename A4>
type::tuple<A0, A1, A2, A3, A4>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4>& v) { type::tuple<A0, A1, A2, A3, A4>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -10649,11 +10649,11 @@ type::tuple<A0, A1, A2, A3, A4>& operator>> (
o.via.array.ptr[2].convert<typename type::tuple_type<A2>::type>(v.template get<2>()); o.via.array.ptr[2].convert<typename type::tuple_type<A2>::type>(v.template get<2>());
o.via.array.ptr[3].convert<typename type::tuple_type<A3>::type>(v.template get<3>()); o.via.array.ptr[3].convert<typename type::tuple_type<A3>::type>(v.template get<3>());
o.via.array.ptr[4].convert<typename type::tuple_type<A4>::type>(v.template get<4>()); o.via.array.ptr[4].convert<typename type::tuple_type<A4>::type>(v.template get<4>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
type::tuple<A0, A1, A2, A3, A4, A5>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5>& v) { type::tuple<A0, A1, A2, A3, A4, A5>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -10665,11 +10665,11 @@ type::tuple<A0, A1, A2, A3, A4, A5>& operator>> (
o.via.array.ptr[3].convert<typename type::tuple_type<A3>::type>(v.template get<3>()); o.via.array.ptr[3].convert<typename type::tuple_type<A3>::type>(v.template get<3>());
o.via.array.ptr[4].convert<typename type::tuple_type<A4>::type>(v.template get<4>()); o.via.array.ptr[4].convert<typename type::tuple_type<A4>::type>(v.template get<4>());
o.via.array.ptr[5].convert<typename type::tuple_type<A5>::type>(v.template get<5>()); o.via.array.ptr[5].convert<typename type::tuple_type<A5>::type>(v.template get<5>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
type::tuple<A0, A1, A2, A3, A4, A5, A6>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -10682,11 +10682,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6>& operator>> (
o.via.array.ptr[4].convert<typename type::tuple_type<A4>::type>(v.template get<4>()); o.via.array.ptr[4].convert<typename type::tuple_type<A4>::type>(v.template get<4>());
o.via.array.ptr[5].convert<typename type::tuple_type<A5>::type>(v.template get<5>()); o.via.array.ptr[5].convert<typename type::tuple_type<A5>::type>(v.template get<5>());
o.via.array.ptr[6].convert<typename type::tuple_type<A6>::type>(v.template get<6>()); o.via.array.ptr[6].convert<typename type::tuple_type<A6>::type>(v.template get<6>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -10700,11 +10700,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7>& operator>> (
o.via.array.ptr[5].convert<typename type::tuple_type<A5>::type>(v.template get<5>()); o.via.array.ptr[5].convert<typename type::tuple_type<A5>::type>(v.template get<5>());
o.via.array.ptr[6].convert<typename type::tuple_type<A6>::type>(v.template get<6>()); o.via.array.ptr[6].convert<typename type::tuple_type<A6>::type>(v.template get<6>());
o.via.array.ptr[7].convert<typename type::tuple_type<A7>::type>(v.template get<7>()); o.via.array.ptr[7].convert<typename type::tuple_type<A7>::type>(v.template get<7>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -10719,11 +10719,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8>& operator>> (
o.via.array.ptr[6].convert<typename type::tuple_type<A6>::type>(v.template get<6>()); o.via.array.ptr[6].convert<typename type::tuple_type<A6>::type>(v.template get<6>());
o.via.array.ptr[7].convert<typename type::tuple_type<A7>::type>(v.template get<7>()); o.via.array.ptr[7].convert<typename type::tuple_type<A7>::type>(v.template get<7>());
o.via.array.ptr[8].convert<typename type::tuple_type<A8>::type>(v.template get<8>()); o.via.array.ptr[8].convert<typename type::tuple_type<A8>::type>(v.template get<8>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -10739,11 +10739,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>& operator>> (
o.via.array.ptr[7].convert<typename type::tuple_type<A7>::type>(v.template get<7>()); o.via.array.ptr[7].convert<typename type::tuple_type<A7>::type>(v.template get<7>());
o.via.array.ptr[8].convert<typename type::tuple_type<A8>::type>(v.template get<8>()); o.via.array.ptr[8].convert<typename type::tuple_type<A8>::type>(v.template get<8>());
o.via.array.ptr[9].convert<typename type::tuple_type<A9>::type>(v.template get<9>()); o.via.array.ptr[9].convert<typename type::tuple_type<A9>::type>(v.template get<9>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -10760,11 +10760,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>& operator>> (
o.via.array.ptr[8].convert<typename type::tuple_type<A8>::type>(v.template get<8>()); o.via.array.ptr[8].convert<typename type::tuple_type<A8>::type>(v.template get<8>());
o.via.array.ptr[9].convert<typename type::tuple_type<A9>::type>(v.template get<9>()); o.via.array.ptr[9].convert<typename type::tuple_type<A9>::type>(v.template get<9>());
o.via.array.ptr[10].convert<typename type::tuple_type<A10>::type>(v.template get<10>()); o.via.array.ptr[10].convert<typename type::tuple_type<A10>::type>(v.template get<10>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -10782,11 +10782,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>& operator>> (
o.via.array.ptr[9].convert<typename type::tuple_type<A9>::type>(v.template get<9>()); o.via.array.ptr[9].convert<typename type::tuple_type<A9>::type>(v.template get<9>());
o.via.array.ptr[10].convert<typename type::tuple_type<A10>::type>(v.template get<10>()); o.via.array.ptr[10].convert<typename type::tuple_type<A10>::type>(v.template get<10>());
o.via.array.ptr[11].convert<typename type::tuple_type<A11>::type>(v.template get<11>()); o.via.array.ptr[11].convert<typename type::tuple_type<A11>::type>(v.template get<11>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -10805,11 +10805,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>& operator>> (
o.via.array.ptr[10].convert<typename type::tuple_type<A10>::type>(v.template get<10>()); o.via.array.ptr[10].convert<typename type::tuple_type<A10>::type>(v.template get<10>());
o.via.array.ptr[11].convert<typename type::tuple_type<A11>::type>(v.template get<11>()); o.via.array.ptr[11].convert<typename type::tuple_type<A11>::type>(v.template get<11>());
o.via.array.ptr[12].convert<typename type::tuple_type<A12>::type>(v.template get<12>()); o.via.array.ptr[12].convert<typename type::tuple_type<A12>::type>(v.template get<12>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -10829,11 +10829,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>& operato
o.via.array.ptr[11].convert<typename type::tuple_type<A11>::type>(v.template get<11>()); o.via.array.ptr[11].convert<typename type::tuple_type<A11>::type>(v.template get<11>());
o.via.array.ptr[12].convert<typename type::tuple_type<A12>::type>(v.template get<12>()); o.via.array.ptr[12].convert<typename type::tuple_type<A12>::type>(v.template get<12>());
o.via.array.ptr[13].convert<typename type::tuple_type<A13>::type>(v.template get<13>()); o.via.array.ptr[13].convert<typename type::tuple_type<A13>::type>(v.template get<13>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -10854,11 +10854,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>& op
o.via.array.ptr[12].convert<typename type::tuple_type<A12>::type>(v.template get<12>()); o.via.array.ptr[12].convert<typename type::tuple_type<A12>::type>(v.template get<12>());
o.via.array.ptr[13].convert<typename type::tuple_type<A13>::type>(v.template get<13>()); o.via.array.ptr[13].convert<typename type::tuple_type<A13>::type>(v.template get<13>());
o.via.array.ptr[14].convert<typename type::tuple_type<A14>::type>(v.template get<14>()); o.via.array.ptr[14].convert<typename type::tuple_type<A14>::type>(v.template get<14>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -10880,11 +10880,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
o.via.array.ptr[13].convert<typename type::tuple_type<A13>::type>(v.template get<13>()); o.via.array.ptr[13].convert<typename type::tuple_type<A13>::type>(v.template get<13>());
o.via.array.ptr[14].convert<typename type::tuple_type<A14>::type>(v.template get<14>()); o.via.array.ptr[14].convert<typename type::tuple_type<A14>::type>(v.template get<14>());
o.via.array.ptr[15].convert<typename type::tuple_type<A15>::type>(v.template get<15>()); o.via.array.ptr[15].convert<typename type::tuple_type<A15>::type>(v.template get<15>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -10907,11 +10907,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
o.via.array.ptr[14].convert<typename type::tuple_type<A14>::type>(v.template get<14>()); o.via.array.ptr[14].convert<typename type::tuple_type<A14>::type>(v.template get<14>());
o.via.array.ptr[15].convert<typename type::tuple_type<A15>::type>(v.template get<15>()); o.via.array.ptr[15].convert<typename type::tuple_type<A15>::type>(v.template get<15>());
o.via.array.ptr[16].convert<typename type::tuple_type<A16>::type>(v.template get<16>()); o.via.array.ptr[16].convert<typename type::tuple_type<A16>::type>(v.template get<16>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -10935,11 +10935,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
o.via.array.ptr[15].convert<typename type::tuple_type<A15>::type>(v.template get<15>()); o.via.array.ptr[15].convert<typename type::tuple_type<A15>::type>(v.template get<15>());
o.via.array.ptr[16].convert<typename type::tuple_type<A16>::type>(v.template get<16>()); o.via.array.ptr[16].convert<typename type::tuple_type<A16>::type>(v.template get<16>());
o.via.array.ptr[17].convert<typename type::tuple_type<A17>::type>(v.template get<17>()); o.via.array.ptr[17].convert<typename type::tuple_type<A17>::type>(v.template get<17>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -10964,11 +10964,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
o.via.array.ptr[16].convert<typename type::tuple_type<A16>::type>(v.template get<16>()); o.via.array.ptr[16].convert<typename type::tuple_type<A16>::type>(v.template get<16>());
o.via.array.ptr[17].convert<typename type::tuple_type<A17>::type>(v.template get<17>()); o.via.array.ptr[17].convert<typename type::tuple_type<A17>::type>(v.template get<17>());
o.via.array.ptr[18].convert<typename type::tuple_type<A18>::type>(v.template get<18>()); o.via.array.ptr[18].convert<typename type::tuple_type<A18>::type>(v.template get<18>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -10994,11 +10994,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
o.via.array.ptr[17].convert<typename type::tuple_type<A17>::type>(v.template get<17>()); o.via.array.ptr[17].convert<typename type::tuple_type<A17>::type>(v.template get<17>());
o.via.array.ptr[18].convert<typename type::tuple_type<A18>::type>(v.template get<18>()); o.via.array.ptr[18].convert<typename type::tuple_type<A18>::type>(v.template get<18>());
o.via.array.ptr[19].convert<typename type::tuple_type<A19>::type>(v.template get<19>()); o.via.array.ptr[19].convert<typename type::tuple_type<A19>::type>(v.template get<19>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -11025,11 +11025,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
o.via.array.ptr[18].convert<typename type::tuple_type<A18>::type>(v.template get<18>()); o.via.array.ptr[18].convert<typename type::tuple_type<A18>::type>(v.template get<18>());
o.via.array.ptr[19].convert<typename type::tuple_type<A19>::type>(v.template get<19>()); o.via.array.ptr[19].convert<typename type::tuple_type<A19>::type>(v.template get<19>());
o.via.array.ptr[20].convert<typename type::tuple_type<A20>::type>(v.template get<20>()); o.via.array.ptr[20].convert<typename type::tuple_type<A20>::type>(v.template get<20>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -11057,11 +11057,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
o.via.array.ptr[19].convert<typename type::tuple_type<A19>::type>(v.template get<19>()); o.via.array.ptr[19].convert<typename type::tuple_type<A19>::type>(v.template get<19>());
o.via.array.ptr[20].convert<typename type::tuple_type<A20>::type>(v.template get<20>()); o.via.array.ptr[20].convert<typename type::tuple_type<A20>::type>(v.template get<20>());
o.via.array.ptr[21].convert<typename type::tuple_type<A21>::type>(v.template get<21>()); o.via.array.ptr[21].convert<typename type::tuple_type<A21>::type>(v.template get<21>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -11090,11 +11090,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
o.via.array.ptr[20].convert<typename type::tuple_type<A20>::type>(v.template get<20>()); o.via.array.ptr[20].convert<typename type::tuple_type<A20>::type>(v.template get<20>());
o.via.array.ptr[21].convert<typename type::tuple_type<A21>::type>(v.template get<21>()); o.via.array.ptr[21].convert<typename type::tuple_type<A21>::type>(v.template get<21>());
o.via.array.ptr[22].convert<typename type::tuple_type<A22>::type>(v.template get<22>()); o.via.array.ptr[22].convert<typename type::tuple_type<A22>::type>(v.template get<22>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -11124,11 +11124,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
o.via.array.ptr[21].convert<typename type::tuple_type<A21>::type>(v.template get<21>()); o.via.array.ptr[21].convert<typename type::tuple_type<A21>::type>(v.template get<21>());
o.via.array.ptr[22].convert<typename type::tuple_type<A22>::type>(v.template get<22>()); o.via.array.ptr[22].convert<typename type::tuple_type<A22>::type>(v.template get<22>());
o.via.array.ptr[23].convert<typename type::tuple_type<A23>::type>(v.template get<23>()); o.via.array.ptr[23].convert<typename type::tuple_type<A23>::type>(v.template get<23>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -11159,11 +11159,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
o.via.array.ptr[22].convert<typename type::tuple_type<A22>::type>(v.template get<22>()); o.via.array.ptr[22].convert<typename type::tuple_type<A22>::type>(v.template get<22>());
o.via.array.ptr[23].convert<typename type::tuple_type<A23>::type>(v.template get<23>()); o.via.array.ptr[23].convert<typename type::tuple_type<A23>::type>(v.template get<23>());
o.via.array.ptr[24].convert<typename type::tuple_type<A24>::type>(v.template get<24>()); o.via.array.ptr[24].convert<typename type::tuple_type<A24>::type>(v.template get<24>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -11195,11 +11195,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
o.via.array.ptr[23].convert<typename type::tuple_type<A23>::type>(v.template get<23>()); o.via.array.ptr[23].convert<typename type::tuple_type<A23>::type>(v.template get<23>());
o.via.array.ptr[24].convert<typename type::tuple_type<A24>::type>(v.template get<24>()); o.via.array.ptr[24].convert<typename type::tuple_type<A24>::type>(v.template get<24>());
o.via.array.ptr[25].convert<typename type::tuple_type<A25>::type>(v.template get<25>()); o.via.array.ptr[25].convert<typename type::tuple_type<A25>::type>(v.template get<25>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -11232,11 +11232,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
o.via.array.ptr[24].convert<typename type::tuple_type<A24>::type>(v.template get<24>()); o.via.array.ptr[24].convert<typename type::tuple_type<A24>::type>(v.template get<24>());
o.via.array.ptr[25].convert<typename type::tuple_type<A25>::type>(v.template get<25>()); o.via.array.ptr[25].convert<typename type::tuple_type<A25>::type>(v.template get<25>());
o.via.array.ptr[26].convert<typename type::tuple_type<A26>::type>(v.template get<26>()); o.via.array.ptr[26].convert<typename type::tuple_type<A26>::type>(v.template get<26>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -11270,11 +11270,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
o.via.array.ptr[25].convert<typename type::tuple_type<A25>::type>(v.template get<25>()); o.via.array.ptr[25].convert<typename type::tuple_type<A25>::type>(v.template get<25>());
o.via.array.ptr[26].convert<typename type::tuple_type<A26>::type>(v.template get<26>()); o.via.array.ptr[26].convert<typename type::tuple_type<A26>::type>(v.template get<26>());
o.via.array.ptr[27].convert<typename type::tuple_type<A27>::type>(v.template get<27>()); o.via.array.ptr[27].convert<typename type::tuple_type<A27>::type>(v.template get<27>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -11309,11 +11309,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
o.via.array.ptr[26].convert<typename type::tuple_type<A26>::type>(v.template get<26>()); o.via.array.ptr[26].convert<typename type::tuple_type<A26>::type>(v.template get<26>());
o.via.array.ptr[27].convert<typename type::tuple_type<A27>::type>(v.template get<27>()); o.via.array.ptr[27].convert<typename type::tuple_type<A27>::type>(v.template get<27>());
o.via.array.ptr[28].convert<typename type::tuple_type<A28>::type>(v.template get<28>()); o.via.array.ptr[28].convert<typename type::tuple_type<A28>::type>(v.template get<28>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -11349,11 +11349,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
o.via.array.ptr[27].convert<typename type::tuple_type<A27>::type>(v.template get<27>()); o.via.array.ptr[27].convert<typename type::tuple_type<A27>::type>(v.template get<27>());
o.via.array.ptr[28].convert<typename type::tuple_type<A28>::type>(v.template get<28>()); o.via.array.ptr[28].convert<typename type::tuple_type<A28>::type>(v.template get<28>());
o.via.array.ptr[29].convert<typename type::tuple_type<A29>::type>(v.template get<29>()); o.via.array.ptr[29].convert<typename type::tuple_type<A29>::type>(v.template get<29>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -11390,11 +11390,11 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
o.via.array.ptr[28].convert<typename type::tuple_type<A28>::type>(v.template get<28>()); o.via.array.ptr[28].convert<typename type::tuple_type<A28>::type>(v.template get<28>());
o.via.array.ptr[29].convert<typename type::tuple_type<A29>::type>(v.template get<29>()); o.via.array.ptr[29].convert<typename type::tuple_type<A29>::type>(v.template get<29>());
o.via.array.ptr[30].convert<typename type::tuple_type<A30>::type>(v.template get<30>()); o.via.array.ptr[30].convert<typename type::tuple_type<A30>::type>(v.template get<30>());
return v; return o;
} }
template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31> template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31>
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31>& v) { type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
@ -11432,7 +11432,7 @@ type::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15
o.via.array.ptr[29].convert<typename type::tuple_type<A29>::type>(v.template get<29>()); o.via.array.ptr[29].convert<typename type::tuple_type<A29>::type>(v.template get<29>());
o.via.array.ptr[30].convert<typename type::tuple_type<A30>::type>(v.template get<30>()); o.via.array.ptr[30].convert<typename type::tuple_type<A30>::type>(v.template get<30>());
o.via.array.ptr[31].convert<typename type::tuple_type<A31>::type>(v.template get<31>()); o.via.array.ptr[31].convert<typename type::tuple_type<A31>::type>(v.template get<31>());
return v; return o;
} }

4
include/msgpack/adaptor/detail/cpp11_define.hpp
View File

@ -40,12 +40,12 @@
#define MSGPACK_ADD_ENUM(enum) \ #define MSGPACK_ADD_ENUM(enum) \
namespace msgpack { \ namespace msgpack { \
template <> \ template <> \
inline enum& operator>> (object const& o, enum& v) \ inline object const& operator>> (object const& o, enum& v) \
{ \ { \
int tmp; \ int tmp; \
o >> tmp; \ o >> tmp; \
v = static_cast<enum>(tmp); \ v = static_cast<enum>(tmp); \
return v; \ return o; \
} \ } \
template <> \ template <> \
inline void operator<< (object::with_zone& o, const enum& v) \ inline void operator<< (object::with_zone& o, const enum& v) \

5
include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp
View File

@ -140,13 +140,13 @@ struct MsgpackTupleConverter<Tuple, 1> {
}; };
template <typename... Args> template <typename... Args>
type::tuple<Args...>& operator>> ( object const& operator>> (
object const& o, object const& o,
type::tuple<Args...>& v) { type::tuple<Args...>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
if(o.via.array.size < sizeof...(Args)) { throw type_error(); } if(o.via.array.size < sizeof...(Args)) { throw type_error(); }
MsgpackTupleConverter<decltype(v), sizeof...(Args)>::convert(o, v); MsgpackTupleConverter<decltype(v), sizeof...(Args)>::convert(o, v);
return v; return o;
} }
// --- Convert from tuple to object with zone --- // --- Convert from tuple to object with zone ---
@ -182,4 +182,3 @@ inline void operator<< (
} // msgpack } // msgpack
#endif // MSGPACK_CPP11_MSGPACK_TUPLE_HPP #endif // MSGPACK_CPP11_MSGPACK_TUPLE_HPP

33
include/msgpack/adaptor/fixint.hpp
View File

@ -54,30 +54,30 @@ typedef fix_int<int64_t> fix_int64;
} // namespace type } // namespace type
inline type::fix_int8& operator>> (object const& o, type::fix_int8& v) inline object const& operator>> (object const& o, type::fix_int8& v)
{ v = type::detail::convert_integer<int8_t>(o); return v; } { v = type::detail::convert_integer<int8_t>(o); return o; }
inline type::fix_int16& operator>> (object const& o, type::fix_int16& v) inline object const& operator>> (object const& o, type::fix_int16& v)
{ v = type::detail::convert_integer<int16_t>(o); return v; } { v = type::detail::convert_integer<int16_t>(o); return o; }
inline type::fix_int32& operator>> (object const& o, type::fix_int32& v) inline object const& operator>> (object const& o, type::fix_int32& v)
{ v = type::detail::convert_integer<int32_t>(o); return v; } { v = type::detail::convert_integer<int32_t>(o); return o; }
inline type::fix_int64& operator>> (object const& o, type::fix_int64& v) inline object const& operator>> (object const& o, type::fix_int64& v)
{ v = type::detail::convert_integer<int64_t>(o); return v; } { v = type::detail::convert_integer<int64_t>(o); return o; }
inline type::fix_uint8& operator>> (object const& o, type::fix_uint8& v) inline object const& operator>> (object const& o, type::fix_uint8& v)
{ v = type::detail::convert_integer<uint8_t>(o); return v; } { v = type::detail::convert_integer<uint8_t>(o); return o; }
inline type::fix_uint16& operator>> (object const& o, type::fix_uint16& v) inline object const& operator>> (object const& o, type::fix_uint16& v)
{ v = type::detail::convert_integer<uint16_t>(o); return v; } { v = type::detail::convert_integer<uint16_t>(o); return o; }
inline type::fix_uint32& operator>> (object const& o, type::fix_uint32& v) inline object const& operator>> (object const& o, type::fix_uint32& v)
{ v = type::detail::convert_integer<uint32_t>(o); return v; } { v = type::detail::convert_integer<uint32_t>(o); return o; }
inline type::fix_uint64& operator>> (object const& o, type::fix_uint64& v) inline object const& operator>> (object const& o, type::fix_uint64& v)
{ v = type::detail::convert_integer<uint64_t>(o); return v; } { v = type::detail::convert_integer<uint64_t>(o); return o; }
template <typename Stream> template <typename Stream>
@ -169,4 +169,3 @@ inline void operator<< (object::with_zone& o, type::fix_uint64 v)
} // namespace msgpack } // namespace msgpack
#endif /* msgpack/type/fixint.hpp */ #endif /* msgpack/type/fixint.hpp */

9
include/msgpack/adaptor/float.hpp
View File

@ -27,7 +27,7 @@ namespace msgpack {
// FIXME check overflow, underflow // FIXME check overflow, underflow
inline float& operator>> (object const& o, float& v) inline object const& operator>> (object const& o, float& v)
{ {
if(o.type == type::DOUBLE) { if(o.type == type::DOUBLE) {
v = static_cast<float>(o.via.dec); v = static_cast<float>(o.via.dec);
@ -41,7 +41,7 @@ inline float& operator>> (object const& o, float& v)
else { else {
throw type_error(); throw type_error();
} }
return v; return o;
} }
template <typename Stream> template <typename Stream>
@ -52,7 +52,7 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const float& v)
} }
inline double& operator>> (object const& o, double& v) inline object const& operator>> (object const& o, double& v)
{ {
if(o.type == type::DOUBLE) { if(o.type == type::DOUBLE) {
v = o.via.dec; v = o.via.dec;
@ -66,7 +66,7 @@ inline double& operator>> (object const& o, double& v)
else { else {
throw type_error(); throw type_error();
} }
return v; return o;
} }
template <typename Stream> template <typename Stream>
@ -99,4 +99,3 @@ inline void operator<< (object::with_zone& o, double v)
} // namespace msgpack } // namespace msgpack
#endif /* msgpack/type/float.hpp */ #endif /* msgpack/type/float.hpp */

45
include/msgpack/adaptor/int.hpp
View File

@ -117,40 +117,40 @@ namespace detail {
} // namespace detail } // namespace detail
} // namespace type } // namespace type
inline char& operator>> (object const& o, char& v) inline object const& operator>> (object const& o, char& v)
{ v = type::detail::convert_integer<char>(o); return v; } { v = type::detail::convert_integer<char>(o); return o; }
inline signed char& operator>> (object const& o, signed char& v) inline object const& operator>> (object const& o, signed char& v)
{ v = type::detail::convert_integer<signed char>(o); return v; } { v = type::detail::convert_integer<signed char>(o); return o; }
inline signed short& operator>> (object const& o, signed short& v) inline object const& operator>> (object const& o, signed short& v)
{ v = type::detail::convert_integer<signed short>(o); return v; } { v = type::detail::convert_integer<signed short>(o); return o; }
inline signed int& operator>> (object const& o, signed int& v) inline object const& operator>> (object const& o, signed int& v)
{ v = type::detail::convert_integer<signed int>(o); return v; } { v = type::detail::convert_integer<signed int>(o); return o; }
inline signed long& operator>> (object const& o, signed long& v) inline object const& operator>> (object const& o, signed long& v)
{ v = type::detail::convert_integer<signed long>(o); return v; } { v = type::detail::convert_integer<signed long>(o); return o; }
inline signed long long& operator>> (object const& o, signed long long& v) inline object const& operator>> (object const& o, signed long long& v)
{ v = type::detail::convert_integer<signed long long>(o); return v; } { v = type::detail::convert_integer<signed long long>(o); return o; }
inline unsigned char& operator>> (object const& o, unsigned char& v) inline object const& operator>> (object const& o, unsigned char& v)
{ v = type::detail::convert_integer<unsigned char>(o); return v; } { v = type::detail::convert_integer<unsigned char>(o); return o; }
inline unsigned short& operator>> (object const& o, unsigned short& v) inline object const& operator>> (object const& o, unsigned short& v)
{ v = type::detail::convert_integer<unsigned short>(o); return v; } { v = type::detail::convert_integer<unsigned short>(o); return o; }
inline unsigned int& operator>> (object const& o, unsigned int& v) inline object const& operator>> (object const& o, unsigned int& v)
{ v = type::detail::convert_integer<unsigned int>(o); return v; } { v = type::detail::convert_integer<unsigned int>(o); return o; }
inline unsigned long& operator>> (object const& o, unsigned long& v) inline object const& operator>> (object const& o, unsigned long& v)
{ v = type::detail::convert_integer<unsigned long>(o); return v; } { v = type::detail::convert_integer<unsigned long>(o); return o; }
inline unsigned long long& operator>> (object const& o, unsigned long long& v) inline object const& operator>> (object const& o, unsigned long long& v)
{ v = type::detail::convert_integer<unsigned long long>(o); return v; } { v = type::detail::convert_integer<unsigned long long>(o); return o; }
template <typename Stream> template <typename Stream>
@ -276,4 +276,3 @@ inline void operator<< (object::with_zone& o, const unsigned long long& v)
} // namespace msgpack } // namespace msgpack
#endif /* msgpack/type/int.hpp */ #endif /* msgpack/type/int.hpp */

5
include/msgpack/adaptor/list.hpp
View File

@ -25,7 +25,7 @@ namespace msgpack {
template <typename T> template <typename T>
inline std::list<T>& operator>> (object const& o, std::list<T>& v) inline object const& operator>> (object const& o, std::list<T>& v)
{ {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
v.resize(o.via.array.size); v.resize(o.via.array.size);
@ -35,7 +35,7 @@ inline std::list<T>& operator>> (object const& o, std::list<T>& v)
for(; p < pend; ++p, ++it) { for(; p < pend; ++p, ++it) {
p->convert(*it); p->convert(*it);
} }
return v; return o;
} }
template <typename Stream, typename T> template <typename Stream, typename T>
@ -74,4 +74,3 @@ inline void operator<< (object::with_zone& o, const std::list<T>& v)
} // namespace msgpack } // namespace msgpack
#endif /* msgpack/type/list.hpp */ #endif /* msgpack/type/list.hpp */

12
include/msgpack/adaptor/map.hpp
View File

@ -43,7 +43,7 @@ namespace detail {
template <typename K, typename V> template <typename K, typename V>
inline type::assoc_vector<K,V>& operator>> (object const& o, type::assoc_vector<K,V>& v) inline object const& operator>> (object const& o, type::assoc_vector<K,V>& v)
{ {
if(o.type != type::MAP) { throw type_error(); } if(o.type != type::MAP) { throw type_error(); }
v.resize(o.via.map.size); v.resize(o.via.map.size);
@ -55,7 +55,7 @@ inline type::assoc_vector<K,V>& operator>> (object const& o, type::assoc_vector<
p->val.convert(it->second); p->val.convert(it->second);
} }
std::sort(v.begin(), v.end(), type::detail::pair_first_less<K,V>()); std::sort(v.begin(), v.end(), type::detail::pair_first_less<K,V>());
return v; return o;
} }
template <typename Stream, typename K, typename V> template <typename Stream, typename K, typename V>
@ -94,7 +94,7 @@ inline void operator<< (object::with_zone& o, const type::assoc_vector<K,V>& v)
template <typename K, typename V> template <typename K, typename V>
inline std::map<K, V>& operator>> (object const& o, std::map<K, V>& v) inline object const& operator>> (object const& o, std::map<K, V>& v)
{ {
if(o.type != type::MAP) { throw type_error(); } if(o.type != type::MAP) { throw type_error(); }
object_kv* p(o.via.map.ptr); object_kv* p(o.via.map.ptr);
@ -111,7 +111,7 @@ inline std::map<K, V>& operator>> (object const& o, std::map<K, V>& v)
v.insert(it, std::pair<K,V>(key, val)); v.insert(it, std::pair<K,V>(key, val));
} }
} }
return v; return o;
} }
template <typename Stream, typename K, typename V> template <typename Stream, typename K, typename V>
@ -150,7 +150,7 @@ inline void operator<< (object::with_zone& o, const std::map<K,V>& v)
template <typename K, typename V> template <typename K, typename V>
inline std::multimap<K, V>& operator>> (object const& o, std::multimap<K, V>& v) inline object const& operator>> (object const& o, std::multimap<K, V>& v)
{ {
if(o.type != type::MAP) { throw type_error(); } if(o.type != type::MAP) { throw type_error(); }
object_kv* p(o.via.map.ptr); object_kv* p(o.via.map.ptr);
@ -161,7 +161,7 @@ inline std::multimap<K, V>& operator>> (object const& o, std::multimap<K, V>& v)
p->val.convert(value.second); p->val.convert(value.second);
v.insert(value); v.insert(value);
} }
return v; return o;
} }
template <typename Stream, typename K, typename V> template <typename Stream, typename K, typename V>

5
include/msgpack/adaptor/nil.hpp
View File

@ -29,10 +29,10 @@ struct nil { };
} // namespace type } // namespace type
inline type::nil& operator>> (object const& o, type::nil& v) inline object const& operator>> (object const& o, type::nil& v)
{ {
if(o.type != type::NIL) { throw type_error(); } if(o.type != type::NIL) { throw type_error(); }
return v; return o;
} }
template <typename Stream> template <typename Stream>
@ -62,4 +62,3 @@ inline void object::as<void>() const
} // namespace msgpack } // namespace msgpack
#endif /* msgpack/type/nil.hpp */ #endif /* msgpack/type/nil.hpp */

5
include/msgpack/adaptor/pair.hpp
View File

@ -25,13 +25,13 @@ namespace msgpack {
template <typename T1, typename T2> template <typename T1, typename T2>
inline std::pair<T1, T2>& operator>> (object const& o, std::pair<T1, T2>& v) inline object const& operator>> (object const& o, std::pair<T1, T2>& v)
{ {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
if(o.via.array.size != 2) { throw type_error(); } if(o.via.array.size != 2) { throw type_error(); }
o.via.array.ptr[0].convert(v.first); o.via.array.ptr[0].convert(v.first);
o.via.array.ptr[1].convert(v.second); o.via.array.ptr[1].convert(v.second);
return v; return o;
} }
template <typename Stream, typename T1, typename T2> template <typename Stream, typename T1, typename T2>
@ -58,4 +58,3 @@ inline void operator<< (object::with_zone& o, const std::pair<T1, T2>& v)
} // namespace msgpack } // namespace msgpack
#endif /* msgpack/type/pair.hpp */ #endif /* msgpack/type/pair.hpp */

5
include/msgpack/adaptor/raw.hpp
View File

@ -61,12 +61,12 @@ struct raw_ref {
} // namespace type } // namespace type
inline type::raw_ref& operator>> (object const& o, type::raw_ref& v) inline object const& operator>> (object const& o, type::raw_ref& v)
{ {
if(o.type != type::BIN) { throw type_error(); } if(o.type != type::BIN) { throw type_error(); }
v.ptr = o.via.bin.ptr; v.ptr = o.via.bin.ptr;
v.size = o.via.bin.size; v.size = o.via.bin.size;
return v; return o;
} }
template <typename Stream> template <typename Stream>
@ -91,4 +91,3 @@ inline void operator<< (object::with_zone& o, const type::raw_ref& v)
} // namespace msgpack } // namespace msgpack
#endif /* msgpack/type/raw.hpp */ #endif /* msgpack/type/raw.hpp */

9
include/msgpack/adaptor/set.hpp
View File

@ -25,7 +25,7 @@ namespace msgpack {
template <typename T> template <typename T>
inline std::set<T>& operator>> (object const& o, std::set<T>& v) inline object const& operator>> (object const& o, std::set<T>& v)
{ {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
object* p = o.via.array.ptr + o.via.array.size; object* p = o.via.array.ptr + o.via.array.size;
@ -34,7 +34,7 @@ inline std::set<T>& operator>> (object const& o, std::set<T>& v)
--p; --p;
v.insert(p->as<T>()); v.insert(p->as<T>());
} }
return v; return o;
} }
template <typename Stream, typename T> template <typename Stream, typename T>
@ -71,7 +71,7 @@ inline void operator<< (object::with_zone& o, const std::set<T>& v)
template <typename T> template <typename T>
inline std::multiset<T>& operator>> (object const& o, std::multiset<T>& v) inline object const& operator>> (object const& o, std::multiset<T>& v)
{ {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
object* p = o.via.array.ptr + o.via.array.size; object* p = o.via.array.ptr + o.via.array.size;
@ -80,7 +80,7 @@ inline std::multiset<T>& operator>> (object const& o, std::multiset<T>& v)
--p; --p;
v.insert(p->as<T>()); v.insert(p->as<T>());
} }
return v; return o;
} }
template <typename Stream, typename T> template <typename Stream, typename T>
@ -119,4 +119,3 @@ inline void operator<< (object::with_zone& o, const std::multiset<T>& v)
} // namespace msgpack } // namespace msgpack
#endif /* msgpack/type/set.hpp */ #endif /* msgpack/type/set.hpp */

5
include/msgpack/adaptor/string.hpp
View File

@ -24,7 +24,7 @@
namespace msgpack { namespace msgpack {
inline std::string& operator>> (object const& o, std::string& v) inline object const& operator>> (object const& o, std::string& v)
{ {
switch (o.type) { switch (o.type) {
case type::BIN: case type::BIN:
@ -37,7 +37,7 @@ inline std::string& operator>> (object const& o, std::string& v)
throw type_error(); throw type_error();
break; break;
} }
return v; return o;
} }
template <typename Stream> template <typename Stream>
@ -68,4 +68,3 @@ inline void operator<< (object& o, const std::string& v)
} // namespace msgpack } // namespace msgpack
#endif /* msgpack/type/string.hpp */ #endif /* msgpack/type/string.hpp */

8
include/msgpack/adaptor/tr1/unordered_map.hpp
View File

@ -44,7 +44,7 @@ namespace msgpack {
template <typename K, typename V> template <typename K, typename V>
inline MSGPACK_STD_TR1::unordered_map<K, V>& operator>> (object o, MSGPACK_STD_TR1::unordered_map<K, V>& v) inline object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_map<K, V>& v)
{ {
if(o.type != type::MAP) { throw type_error(); } if(o.type != type::MAP) { throw type_error(); }
object_kv* p(o.via.map.ptr); object_kv* p(o.via.map.ptr);
@ -54,7 +54,7 @@ inline MSGPACK_STD_TR1::unordered_map<K, V>& operator>> (object o, MSGPACK_STD_T
p->key.convert(key); p->key.convert(key);
p->val.convert(v[key]); p->val.convert(v[key]);
} }
return v; return o;
} }
template <typename Stream, typename K, typename V> template <typename Stream, typename K, typename V>
@ -93,7 +93,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m
template <typename K, typename V> template <typename K, typename V>
inline MSGPACK_STD_TR1::unordered_multimap<K, V>& operator>> (object o, MSGPACK_STD_TR1::unordered_multimap<K, V>& v) inline object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_multimap<K, V>& v)
{ {
if(o.type != type::MAP) { throw type_error(); } if(o.type != type::MAP) { throw type_error(); }
object_kv* p(o.via.map.ptr); object_kv* p(o.via.map.ptr);
@ -104,7 +104,7 @@ inline MSGPACK_STD_TR1::unordered_multimap<K, V>& operator>> (object o, MSGPACK_
p->val.convert(value.second); p->val.convert(value.second);
v.insert(value); v.insert(value);
} }
return v; return o;
} }
template <typename Stream, typename K, typename V> template <typename Stream, typename K, typename V>

9
include/msgpack/adaptor/tr1/unordered_set.hpp
View File

@ -43,7 +43,7 @@ namespace msgpack {
template <typename T> template <typename T>
inline MSGPACK_STD_TR1::unordered_set<T>& operator>> (object o, MSGPACK_STD_TR1::unordered_set<T>& v) inline object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_set<T>& v)
{ {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
object* p = o.via.array.ptr + o.via.array.size; object* p = o.via.array.ptr + o.via.array.size;
@ -52,7 +52,7 @@ inline MSGPACK_STD_TR1::unordered_set<T>& operator>> (object o, MSGPACK_STD_TR1:
--p; --p;
v.insert(p->as<T>()); v.insert(p->as<T>());
} }
return v; return o;
} }
template <typename Stream, typename T> template <typename Stream, typename T>
@ -89,7 +89,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_s
template <typename T> template <typename T>
inline MSGPACK_STD_TR1::unordered_multiset<T>& operator>> (object o, MSGPACK_STD_TR1::unordered_multiset<T>& v) inline object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_multiset<T>& v)
{ {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
object* p = o.via.array.ptr + o.via.array.size; object* p = o.via.array.ptr + o.via.array.size;
@ -98,7 +98,7 @@ inline MSGPACK_STD_TR1::unordered_multiset<T>& operator>> (object o, MSGPACK_STD
--p; --p;
v.insert(p->as<T>()); v.insert(p->as<T>());
} }
return v; return o;
} }
template <typename Stream, typename T> template <typename Stream, typename T>
@ -139,4 +139,3 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m
#undef MSGPACK_STD_TR1 #undef MSGPACK_STD_TR1
#endif /* msgpack/type/set.hpp */ #endif /* msgpack/type/set.hpp */

5
include/msgpack/adaptor/vector.hpp
View File

@ -25,7 +25,7 @@ namespace msgpack {
template <typename T> template <typename T>
inline std::vector<T>& operator>> (object const& o, std::vector<T>& v) inline object const& operator>> (object const& o, std::vector<T>& v)
{ {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
v.resize(o.via.array.size); v.resize(o.via.array.size);
@ -39,7 +39,7 @@ inline std::vector<T>& operator>> (object const& o, std::vector<T>& v)
++it; ++it;
} while(p < pend); } while(p < pend);
} }
return v; return o;
} }
template <typename Stream, typename T> template <typename Stream, typename T>
@ -78,4 +78,3 @@ inline void operator<< (object::with_zone& o, const std::vector<T>& v)
} // namespace msgpack } // namespace msgpack
#endif /* msgpack/type/vector.hpp */ #endif /* msgpack/type/vector.hpp */

5
include/msgpack/adaptor/vector_char.hpp
View File

@ -23,7 +23,7 @@
namespace msgpack { namespace msgpack {
inline std::vector<char>& operator>> (object const& o, std::vector<char>& v) inline object const& operator>> (object const& o, std::vector<char>& v)
{ {
switch (o.type) { switch (o.type) {
case type::BIN: case type::BIN:
@ -38,7 +38,7 @@ inline std::vector<char>& operator>> (object const& o, std::vector<char>& v)
throw type_error(); throw type_error();
break; break;
} }
return v; return o;
} }
template <typename Stream> template <typename Stream>
@ -69,4 +69,3 @@ inline void operator<< (object::with_zone& o, const std::vector<char>& v)
} // namespace msgpack } // namespace msgpack
#endif // MSGPACK_TYPE_VECTOR_CHAR_HPP #endif // MSGPACK_TYPE_VECTOR_CHAR_HPP

8
include/msgpack/object.hpp
View File

@ -188,18 +188,18 @@ inline packer<Stream>& packer<Stream>::pack(const T& v)
return *this; return *this;
} }
inline object& operator>> (object const& o, object& v) inline object const& operator>> (object const& o, object& v)
{ {
v = o; v = o;
return v; return o;
} }
// convert operator // convert operator
template <typename T> template <typename T>
inline T& operator>> (object const& o, T& v) inline object const& operator>> (object const& o, T& v)
{ {
v.msgpack_unpack(o.convert()); v.msgpack_unpack(o.convert());
return v; return o;
} }
namespace detail { namespace detail {