generic-library/msgpack
1
0
Fork 0
mirror of https://github.com/msgpack/msgpack-c.git synced 2025-05-31 16:14:50 +02:00
Code Issues Projects Releases Wiki Activity

Improved clock adaptor.

Browse Source
This commit is contained in:
Takatoshi Kondo 2020-06-14 18:46:44 +09:00
parent c7b7e745b3
commit 4629583662
1 changed files with 160 additions and 272 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

432
include/msgpack/v1/adaptor/cpp11/chrono.hpp
View File

@ -25,299 +25,187 @@ MSGPACK_API_VERSION_NAMESPACE(v1) {
namespace adaptor { namespace adaptor {
namespace detail { template <typename Clock>
struct as<std::chrono::time_point<Clock>> {
template <typename T> typename std::chrono::time_point<Clock> operator()(msgpack::object const& o) const {
typename T::time_point chrono_as(msgpack::object const& o) { using duration_t = typename std::chrono::time_point<Clock>::duration;
if(o.type != msgpack::type::EXT) { throw msgpack::type_error(); } if(o.type != msgpack::type::EXT) { throw msgpack::type_error(); }
if(o.via.ext.type() != -1) { throw msgpack::type_error(); } if(o.via.ext.type() != -1) { throw msgpack::type_error(); }
typename T::time_point tp; std::chrono::time_point<Clock> tp;
switch(o.via.ext.size) { switch(o.via.ext.size) {
case 4: { case 4: {
uint32_t sec; uint32_t sec;
_msgpack_load32(uint32_t, o.via.ext.data(), &sec); _msgpack_load32(uint32_t, o.via.ext.data(), &sec);
tp += std::chrono::seconds(sec); tp += std::chrono::seconds(sec);
} break; } break;
case 8: { case 8: {
uint64_t value; uint64_t value;
_msgpack_load64(uint64_t, o.via.ext.data(), &value); _msgpack_load64(uint64_t, o.via.ext.data(), &value);
uint32_t nanosec = static_cast<uint32_t>(value >> 34); uint32_t nanosec = static_cast<uint32_t>(value >> 34);
uint64_t sec = value & 0x00000003ffffffffLL; uint64_t sec = value & 0x00000003ffffffffLL;
tp += std::chrono::duration_cast<typename T::duration>( tp += std::chrono::duration_cast<duration_t>(
std::chrono::nanoseconds(nanosec)); std::chrono::nanoseconds(nanosec));
tp += std::chrono::seconds(sec); tp += std::chrono::seconds(sec);
} break; } break;
case 12: { case 12: {
uint32_t nanosec; uint32_t nanosec;
_msgpack_load32(uint32_t, o.via.ext.data(), &nanosec); _msgpack_load32(uint32_t, o.via.ext.data(), &nanosec);
int64_t sec; int64_t sec;
_msgpack_load64(int64_t, o.via.ext.data() + 4, &sec); _msgpack_load64(int64_t, o.via.ext.data() + 4, &sec);
tp += std::chrono::duration_cast<typename T::duration>( tp += std::chrono::duration_cast<duration_t>(
std::chrono::nanoseconds(nanosec)); std::chrono::nanoseconds(nanosec));
tp += std::chrono::seconds(sec); tp += std::chrono::seconds(sec);
} break; } break;
default: default:
throw msgpack::type_error(); throw msgpack::type_error();
}
return tp;
} }
return tp; };
}
template <typename T> template <typename Clock>
msgpack::object const& chrono_convert(msgpack::object const& o, typename T::time_point& v) { struct convert<std::chrono::time_point<Clock>> {
if(o.type != msgpack::type::EXT) { throw msgpack::type_error(); } msgpack::object const& operator()(msgpack::object const& o, std::chrono::time_point<Clock>& v) const {
if(o.via.ext.type() != -1) { throw msgpack::type_error(); } using duration_t = typename std::chrono::time_point<Clock>::duration;
typename T::time_point tp; if(o.type != msgpack::type::EXT) { throw msgpack::type_error(); }
switch(o.via.ext.size) { if(o.via.ext.type() != -1) { throw msgpack::type_error(); }
case 4: { std::chrono::time_point<Clock> tp;
uint32_t sec; switch(o.via.ext.size) {
_msgpack_load32(uint32_t, o.via.ext.data(), &sec); case 4: {
tp += std::chrono::seconds(sec); uint32_t sec;
v = tp; _msgpack_load32(uint32_t, o.via.ext.data(), &sec);
} break; tp += std::chrono::seconds(sec);
case 8: { v = tp;
uint64_t value; } break;
_msgpack_load64(uint64_t, o.via.ext.data(), &value); case 8: {
uint32_t nanosec = static_cast<uint32_t>(value >> 34); uint64_t value;
uint64_t sec = value & 0x00000003ffffffffLL; _msgpack_load64(uint64_t, o.via.ext.data(), &value);
tp += std::chrono::duration_cast<typename T::duration>( uint32_t nanosec = static_cast<uint32_t>(value >> 34);
std::chrono::nanoseconds(nanosec)); uint64_t sec = value & 0x00000003ffffffffLL;
tp += std::chrono::seconds(sec); tp += std::chrono::duration_cast<duration_t>(
v = tp; std::chrono::nanoseconds(nanosec));
} break; tp += std::chrono::seconds(sec);
case 12: { v = tp;
uint32_t nanosec; } break;
_msgpack_load32(uint32_t, o.via.ext.data(), &nanosec); case 12: {
int64_t sec; uint32_t nanosec;
_msgpack_load64(int64_t, o.via.ext.data() + 4, &sec); _msgpack_load32(uint32_t, o.via.ext.data(), &nanosec);
tp += std::chrono::duration_cast<typename T::duration>( int64_t sec;
std::chrono::nanoseconds(nanosec)); _msgpack_load64(int64_t, o.via.ext.data() + 4, &sec);
tp += std::chrono::seconds(sec); tp += std::chrono::duration_cast<duration_t>(
v = tp; std::chrono::nanoseconds(nanosec));
} break; tp += std::chrono::seconds(sec);
default: v = tp;
throw msgpack::type_error(); } break;
default:
throw msgpack::type_error();
}
return o;
} }
return o; };
}
template <typename T, typename Stream> template <typename Clock>
msgpack::packer<Stream>& chrono_pack(msgpack::packer<Stream>& o, const typename T::time_point& v) { struct pack<std::chrono::time_point<Clock>> {
int64_t count = static_cast<int64_t>(v.time_since_epoch().count()); template <typename Stream>
msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, std::chrono::time_point<Clock> const& v) const {
using duration_t = typename std::chrono::time_point<Clock>::duration;
int64_t count = static_cast<int64_t>(v.time_since_epoch().count());
int64_t nano_num = int64_t nano_num =
T::duration::period::ratio::num * duration_t::period::ratio::num *
(1000000000 / T::duration::period::ratio::den); (1000000000 / duration_t::period::ratio::den);
int64_t nanosec = count % (1000000000 / nano_num) * nano_num; int64_t nanosec = count % (1000000000 / nano_num) * nano_num;
int64_t sec = 0; int64_t sec = 0;
if (nanosec < 0) { if (nanosec < 0) {
nanosec = 1000000000 + nanosec; nanosec = 1000000000 + nanosec;
--sec; --sec;
} }
sec += count sec += count
* T::duration::period::ratio::num * duration_t::period::ratio::num
/ T::duration::period::ratio::den; / duration_t::period::ratio::den;
if ((sec >> 34) == 0) { if ((sec >> 34) == 0) {
uint64_t data64 = (static_cast<uint64_t>(nanosec) << 34) | static_cast<uint64_t>(sec); uint64_t data64 = (static_cast<uint64_t>(nanosec) << 34) | static_cast<uint64_t>(sec);
if ((data64 & 0xffffffff00000000L) == 0) { if ((data64 & 0xffffffff00000000L) == 0) {
// timestamp 32 // timestamp 32
o.pack_ext(4, -1); o.pack_ext(4, -1);
uint32_t data32 = static_cast<uint32_t>(data64); uint32_t data32 = static_cast<uint32_t>(data64);
char buf[4]; char buf[4];
_msgpack_store32(buf, data32); _msgpack_store32(buf, data32);
o.pack_ext_body(buf, 4); o.pack_ext_body(buf, 4);
}
else {
// timestamp 64
o.pack_ext(8, -1);
char buf[8];
_msgpack_store64(buf, data64);
o.pack_ext_body(buf, 8);
}
} }
else { else {
// timestamp 64 // timestamp 96
o.pack_ext(8, -1); o.pack_ext(12, -1);
char buf[8]; char buf[12];
_msgpack_store64(buf, data64); _msgpack_store32(&buf[0], static_cast<uint32_t>(nanosec));
o.pack_ext_body(buf, 8); _msgpack_store64(&buf[4], sec);
o.pack_ext_body(buf, 12);
} }
return o;
} }
else { };
// timestamp 96
o.pack_ext(12, -1);
char buf[12];
_msgpack_store32(&buf[0], static_cast<uint32_t>(nanosec));
_msgpack_store64(&buf[4], sec);
o.pack_ext_body(buf, 12);
}
return o;
}
template <typename T> template <typename Clock>
void chrono_object_with_zone(msgpack::object::with_zone& o, const typename T::time_point& v) { struct object_with_zone<std::chrono::time_point<Clock>> {
int64_t count = static_cast<int64_t>(v.time_since_epoch().count()); void operator()(msgpack::object::with_zone& o, const std::chrono::time_point<Clock>& v) const {
using duration_t = typename std::chrono::time_point<Clock>::duration;
int64_t count = static_cast<int64_t>(v.time_since_epoch().count());
int64_t nano_num = int64_t nano_num =
T::duration::period::ratio::num * duration_t::period::ratio::num *
(1000000000 / T::duration::period::ratio::den); (1000000000 / duration_t::period::ratio::den);
int64_t nanosec = count % (1000000000 / nano_num) * nano_num; int64_t nanosec = count % (1000000000 / nano_num) * nano_num;
int64_t sec = 0; int64_t sec = 0;
if (nanosec < 0) { if (nanosec < 0) {
nanosec = 1000000000 + nanosec; nanosec = 1000000000 + nanosec;
--sec; --sec;
} }
sec += count sec += count
* T::duration::period::ratio::num * duration_t::period::ratio::num
/ T::duration::period::ratio::den; / duration_t::period::ratio::den;
if ((sec >> 34) == 0) { if ((sec >> 34) == 0) {
uint64_t data64 = (static_cast<uint64_t>(nanosec) << 34) | static_cast<uint64_t>(sec); uint64_t data64 = (static_cast<uint64_t>(nanosec) << 34) | static_cast<uint64_t>(sec);
if ((data64 & 0xffffffff00000000L) == 0) { if ((data64 & 0xffffffff00000000L) == 0) {
// timestamp 32 // timestamp 32
o.type = msgpack::type::EXT; o.type = msgpack::type::EXT;
o.via.ext.size = 4; o.via.ext.size = 4;
char* p = static_cast<char*>(o.zone.allocate_no_align(o.via.ext.size + 1)); char* p = static_cast<char*>(o.zone.allocate_no_align(o.via.ext.size + 1));
p[0] = static_cast<char>(-1); p[0] = static_cast<char>(-1);
uint32_t data32 = static_cast<uint32_t>(data64); uint32_t data32 = static_cast<uint32_t>(data64);
_msgpack_store32(&p[1], data32); _msgpack_store32(&p[1], data32);
o.via.ext.ptr = p; o.via.ext.ptr = p;
}
else {
// timestamp 64
o.type = msgpack::type::EXT;
o.via.ext.size = 8;
char* p = static_cast<char*>(o.zone.allocate_no_align(o.via.ext.size + 1));
p[0] = static_cast<char>(-1);
_msgpack_store64(&p[1], data64);
o.via.ext.ptr = p;
}
} }
else { else {
// timestamp 64 // timestamp 96
o.type = msgpack::type::EXT; o.type = msgpack::type::EXT;
o.via.ext.size = 8; o.via.ext.size = 12;
char* p = static_cast<char*>(o.zone.allocate_no_align(o.via.ext.size + 1)); char* p = static_cast<char*>(o.zone.allocate_no_align(o.via.ext.size + 1));
p[0] = static_cast<char>(-1); p[0] = static_cast<char>(-1);
_msgpack_store64(&p[1], data64); _msgpack_store32(&p[1], static_cast<uint32_t>(nanosec));
_msgpack_store64(&p[1 + 4], sec);
o.via.ext.ptr = p; o.via.ext.ptr = p;
} }
} }
else {
// timestamp 96
o.type = msgpack::type::EXT;
o.via.ext.size = 12;
char* p = static_cast<char*>(o.zone.allocate_no_align(o.via.ext.size + 1));
p[0] = static_cast<char>(-1);
_msgpack_store32(&p[1], static_cast<uint32_t>(nanosec));
_msgpack_store64(&p[1 + 4], sec);
o.via.ext.ptr = p;
}
}
} // namespace detail
template <>
struct as<std::chrono::system_clock::time_point> {
typename std::chrono::system_clock::time_point operator()(msgpack::object const& o) const {
return detail::chrono_as<std::chrono::system_clock>(o);
}
};
template <>
struct convert<std::chrono::system_clock::time_point> {
msgpack::object const& operator()(msgpack::object const& o, std::chrono::system_clock::time_point& v) const {
return detail::chrono_convert<std::chrono::system_clock>(o, v);
}
};
template <>
struct pack<std::chrono::system_clock::time_point> {
template <typename Stream>
msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::chrono::system_clock::time_point& v) const {
return detail::chrono_pack<std::chrono::system_clock>(o, v);
}
};
template <>
struct object_with_zone<std::chrono::system_clock::time_point> {
void operator()(msgpack::object::with_zone& o, const std::chrono::system_clock::time_point& v) const {
detail::chrono_object_with_zone<std::chrono::system_clock>(o, v);
}
};
template <>
struct as<std::chrono::steady_clock::time_point> {
typename std::chrono::steady_clock::time_point operator()(msgpack::object const& o) const {
return detail::chrono_as<std::chrono::steady_clock>(o);
}
};
template <>
struct convert<std::chrono::steady_clock::time_point> {
msgpack::object const& operator()(msgpack::object const& o, std::chrono::steady_clock::time_point& v) const {
return detail::chrono_convert<std::chrono::steady_clock>(o, v);
}
};
template <>
struct pack<std::chrono::steady_clock::time_point> {
template <typename Stream>
msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::chrono::steady_clock::time_point& v) const {
return detail::chrono_pack<std::chrono::steady_clock>(o, v);
}
};
template <>
struct object_with_zone<std::chrono::steady_clock::time_point> {
void operator()(msgpack::object::with_zone& o, const std::chrono::steady_clock::time_point& v) const {
detail::chrono_object_with_zone<std::chrono::steady_clock>(o, v);
}
};
template <>
struct as<
std::chrono::high_resolution_clock::time_point,
typename std::conditional<
!std::is_same<std::chrono::high_resolution_clock, std::chrono::system_clock>::value &&
!std::is_same<std::chrono::high_resolution_clock, std::chrono::steady_clock>::value,
void,
std::nullptr_t
>::type
> {
typename std::chrono::high_resolution_clock::time_point operator()(msgpack::object const& o) const {
return detail::chrono_as<std::chrono::high_resolution_clock>(o);
}
};
template <>
struct convert<
std::chrono::high_resolution_clock::time_point,
typename std::conditional<
!std::is_same<std::chrono::high_resolution_clock, std::chrono::system_clock>::value &&
!std::is_same<std::chrono::high_resolution_clock, std::chrono::steady_clock>::value,
void,
std::nullptr_t
>::type
> {
msgpack::object const& operator()(msgpack::object const& o, std::chrono::high_resolution_clock::time_point& v) const {
return detail::chrono_convert<std::chrono::high_resolution_clock>(o, v);
}
};
template <>
struct pack<
std::chrono::high_resolution_clock::time_point,
typename std::conditional<
!std::is_same<std::chrono::high_resolution_clock, std::chrono::system_clock>::value &&
!std::is_same<std::chrono::high_resolution_clock, std::chrono::steady_clock>::value,
void,
std::nullptr_t
>::type
> {
template <typename Stream>
msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::chrono::high_resolution_clock::time_point& v) const {
return detail::chrono_pack<std::chrono::high_resolution_clock>(o, v);
}
};
template <>
struct object_with_zone<
std::chrono::high_resolution_clock::time_point,
typename std::conditional<
!std::is_same<std::chrono::high_resolution_clock, std::chrono::system_clock>::value &&
!std::is_same<std::chrono::high_resolution_clock, std::chrono::steady_clock>::value,
void,
std::nullptr_t
>::type
> {
void operator()(msgpack::object::with_zone& o, const std::chrono::high_resolution_clock::time_point& v) const {
detail::chrono_object_with_zone<std::chrono::high_resolution_clock>(o, v);
}
}; };
} // namespace adaptor } // namespace adaptor