mirror of
https://github.com/msgpack/msgpack-c.git
synced 2025-07-03 09:15:23 +02:00
Replaced C-style casts with C++ stype casts in C++ codes.
This commit is contained in:
parent
e0b42939ba
commit
36a87b6968
@ -74,7 +74,7 @@ struct define_imp {
|
|||||||
static void unpack(msgpack::object o, Tuple& t) {
|
static void unpack(msgpack::object o, Tuple& t) {
|
||||||
define_imp<Tuple, N-1>::unpack(o, t);
|
define_imp<Tuple, N-1>::unpack(o, t);
|
||||||
const size_t size = o.via.array.size;
|
const size_t size = o.via.array.size;
|
||||||
if(size <= N-1) { return; }
|
if(size <= N-1) { return; }
|
||||||
o.via.array.ptr[N-1].convert(&std::get<N-1>(t));
|
o.via.array.ptr[N-1].convert(&std::get<N-1>(t));
|
||||||
}
|
}
|
||||||
static void object(msgpack::object* o, msgpack::zone* z, Tuple const& t) {
|
static void object(msgpack::object* o, msgpack::zone* z, Tuple const& t) {
|
||||||
@ -91,7 +91,7 @@ struct define_imp<Tuple, 1> {
|
|||||||
}
|
}
|
||||||
static void unpack(msgpack::object o, Tuple& t) {
|
static void unpack(msgpack::object o, Tuple& t) {
|
||||||
const size_t size = o.via.array.size;
|
const size_t size = o.via.array.size;
|
||||||
if(size <= 0) { return; }
|
if(size <= 0) { return; }
|
||||||
o.via.array.ptr[0].convert(&std::get<0>(t));
|
o.via.array.ptr[0].convert(&std::get<0>(t));
|
||||||
}
|
}
|
||||||
static void object(msgpack::object* o, msgpack::zone* z, Tuple const& t) {
|
static void object(msgpack::object* o, msgpack::zone* z, Tuple const& t) {
|
||||||
@ -109,24 +109,24 @@ struct define {
|
|||||||
void msgpack_pack(Packer& pk) const
|
void msgpack_pack(Packer& pk) const
|
||||||
{
|
{
|
||||||
pk.pack_array(sizeof...(Args));
|
pk.pack_array(sizeof...(Args));
|
||||||
|
|
||||||
define_imp<tuple<Args&...>, sizeof...(Args)>::pack(pk, a);
|
define_imp<tuple<Args&...>, sizeof...(Args)>::pack(pk, a);
|
||||||
}
|
}
|
||||||
void msgpack_unpack(msgpack::object o)
|
void msgpack_unpack(msgpack::object o)
|
||||||
{
|
{
|
||||||
if(o.type != type::ARRAY) { throw type_error(); }
|
if(o.type != type::ARRAY) { throw type_error(); }
|
||||||
|
|
||||||
define_imp<tuple<Args&...>, sizeof...(Args)>::unpack(o, a);
|
define_imp<tuple<Args&...>, sizeof...(Args)>::unpack(o, a);
|
||||||
}
|
}
|
||||||
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
|
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
|
||||||
{
|
{
|
||||||
o->type = type::ARRAY;
|
o->type = type::ARRAY;
|
||||||
o->via.array.ptr = (object*)z->malloc(sizeof(object)*sizeof...(Args));
|
o->via.array.ptr = static_cast<object*>(z->malloc(sizeof(object)*sizeof...(Args)));
|
||||||
o->via.array.size = sizeof...(Args);
|
o->via.array.size = sizeof...(Args);
|
||||||
|
|
||||||
define_imp<tuple<Args&...>, sizeof...(Args)>::object(o, z, a);
|
define_imp<tuple<Args&...>, sizeof...(Args)>::object(o, z, a);
|
||||||
}
|
}
|
||||||
|
|
||||||
tuple<Args&...> a;
|
tuple<Args&...> a;
|
||||||
};
|
};
|
||||||
|
|
||||||
|
@ -26,91 +26,91 @@ namespace msgpack {
|
|||||||
// --- Pack ( from tuple to packer stream ---
|
// --- Pack ( from tuple to packer stream ---
|
||||||
template <typename Stream, typename Tuple, std::size_t N>
|
template <typename Stream, typename Tuple, std::size_t N>
|
||||||
struct Packer {
|
struct Packer {
|
||||||
static void pack(
|
static void pack(
|
||||||
packer<Stream>& o,
|
packer<Stream>& o,
|
||||||
const Tuple& v) {
|
const Tuple& v) {
|
||||||
Packer<Stream, Tuple, N-1>::pack(o, v);
|
Packer<Stream, Tuple, N-1>::pack(o, v);
|
||||||
o.pack(type::get<N-1>(v));
|
o.pack(type::get<N-1>(v));
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename Stream, typename Tuple>
|
template <typename Stream, typename Tuple>
|
||||||
struct Packer<Stream, Tuple, 1> {
|
struct Packer<Stream, Tuple, 1> {
|
||||||
static void pack (
|
static void pack (
|
||||||
packer<Stream>& o,
|
packer<Stream>& o,
|
||||||
const Tuple& v) {
|
const Tuple& v) {
|
||||||
o.pack(type::get<0>(v));
|
o.pack(type::get<0>(v));
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename Stream, typename... Args>
|
template <typename Stream, typename... Args>
|
||||||
const packer<Stream>& operator<< (
|
const packer<Stream>& operator<< (
|
||||||
packer<Stream>& o,
|
packer<Stream>& o,
|
||||||
const type::tuple<Args...>& v) {
|
const type::tuple<Args...>& v) {
|
||||||
o.pack_array(sizeof...(Args));
|
o.pack_array(sizeof...(Args));
|
||||||
Packer<Stream, decltype(v), sizeof...(Args)>::pack(o, v);
|
Packer<Stream, decltype(v), sizeof...(Args)>::pack(o, v);
|
||||||
return o;
|
return o;
|
||||||
}
|
}
|
||||||
|
|
||||||
// --- Convert from tuple to object ---
|
// --- Convert from tuple to object ---
|
||||||
|
|
||||||
template <typename Tuple, std::size_t N>
|
template <typename Tuple, std::size_t N>
|
||||||
struct Converter {
|
struct Converter {
|
||||||
static void convert(
|
static void convert(
|
||||||
object o,
|
object o,
|
||||||
Tuple& v) {
|
Tuple& v) {
|
||||||
Converter<Tuple, N-1>::convert(o, v);
|
Converter<Tuple, N-1>::convert(o, v);
|
||||||
o.via.array.ptr[N-1].convert<typename std::remove_reference<decltype(type::get<N-1>(v))>::type>(&type::get<N-1>(v));
|
o.via.array.ptr[N-1].convert<typename std::remove_reference<decltype(type::get<N-1>(v))>::type>(&type::get<N-1>(v));
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename Tuple>
|
template <typename Tuple>
|
||||||
struct Converter<Tuple, 1> {
|
struct Converter<Tuple, 1> {
|
||||||
static void convert (
|
static void convert (
|
||||||
object o,
|
object o,
|
||||||
Tuple& v) {
|
Tuple& v) {
|
||||||
o.via.array.ptr[0].convert<typename std::remove_reference<decltype(type::get<0>(v))>::type>(&type::get<0>(v));
|
o.via.array.ptr[0].convert<typename std::remove_reference<decltype(type::get<0>(v))>::type>(&type::get<0>(v));
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename... Args>
|
template <typename... Args>
|
||||||
type::tuple<Args...>& operator>> (
|
type::tuple<Args...>& operator>> (
|
||||||
object o,
|
object 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(); }
|
||||||
Converter<decltype(v), sizeof...(Args)>::convert(o, v);
|
Converter<decltype(v), sizeof...(Args)>::convert(o, v);
|
||||||
return v;
|
return v;
|
||||||
}
|
}
|
||||||
|
|
||||||
// --- Convert from tuple to object with zone ---
|
// --- Convert from tuple to object with zone ---
|
||||||
template <typename Tuple, std::size_t N>
|
template <typename Tuple, std::size_t N>
|
||||||
struct TupleToObjectWithZone {
|
struct TupleToObjectWithZone {
|
||||||
static void convert(
|
static void convert(
|
||||||
object::with_zone& o,
|
object::with_zone& o,
|
||||||
const Tuple& v) {
|
const Tuple& v) {
|
||||||
TupleToObjectWithZone<Tuple, N-1>::convert(o, v);
|
TupleToObjectWithZone<Tuple, N-1>::convert(o, v);
|
||||||
o.via.array.ptr[N-1] = object(type::get<N-1>(v), o.zone);
|
o.via.array.ptr[N-1] = object(type::get<N-1>(v), o.zone);
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename Tuple>
|
template <typename Tuple>
|
||||||
struct TupleToObjectWithZone<Tuple, 1> {
|
struct TupleToObjectWithZone<Tuple, 1> {
|
||||||
static void convert (
|
static void convert (
|
||||||
object::with_zone& o,
|
object::with_zone& o,
|
||||||
const Tuple& v) {
|
const Tuple& v) {
|
||||||
o.via.array.ptr[0] = object(type::get<0>(v), o.zone);
|
o.via.array.ptr[0] = object(type::get<0>(v), o.zone);
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename... Args>
|
template <typename... Args>
|
||||||
inline void operator<< (
|
inline void operator<< (
|
||||||
object::with_zone& o,
|
object::with_zone& o,
|
||||||
type::tuple<Args...>& v) {
|
type::tuple<Args...>& v) {
|
||||||
o.type = type::ARRAY;
|
o.type = type::ARRAY;
|
||||||
o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*sizeof...(Args));
|
o.via.array.ptr = static_cast<object*>(o.zone->malloc(sizeof(object)*sizeof...(Args)));
|
||||||
o.via.array.size = sizeof...(Args);
|
o.via.array.size = sizeof...(Args);
|
||||||
TupleToObjectWithZone<decltype(v), sizeof...(Args)>::convert(o, v);
|
TupleToObjectWithZone<decltype(v), sizeof...(Args)>::convert(o, v);
|
||||||
}
|
}
|
||||||
|
|
||||||
} // msgpack
|
} // msgpack
|
||||||
|
@ -59,15 +59,15 @@ private:
|
|||||||
void push(void (*func)(void* data), void* data)
|
void push(void (*func)(void* data), void* data)
|
||||||
{
|
{
|
||||||
finalizer* fin = tail_;
|
finalizer* fin = tail_;
|
||||||
|
|
||||||
if(fin == end_) {
|
if(fin == end_) {
|
||||||
push_expand(func, data);
|
push_expand(func, data);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
fin->func_ = func;
|
fin->func_ = func;
|
||||||
fin->data_ = data;
|
fin->data_ = data;
|
||||||
|
|
||||||
++tail_;
|
++tail_;
|
||||||
}
|
}
|
||||||
void push_expand(void (*func)(void*), void* data) {
|
void push_expand(void (*func)(void*), void* data) {
|
||||||
@ -80,7 +80,7 @@ private:
|
|||||||
nnext = nused * 2;
|
nnext = nused * 2;
|
||||||
}
|
}
|
||||||
finalizer* tmp =
|
finalizer* tmp =
|
||||||
(finalizer*)::realloc(array_, sizeof(finalizer) * nnext);
|
static_cast<finalizer*>(::realloc(array_, sizeof(finalizer) * nnext));
|
||||||
if(!tmp) {
|
if(!tmp) {
|
||||||
throw std::bad_alloc();
|
throw std::bad_alloc();
|
||||||
}
|
}
|
||||||
@ -101,14 +101,14 @@ private:
|
|||||||
struct chunk_list {
|
struct chunk_list {
|
||||||
chunk_list(size_t chunk_size)
|
chunk_list(size_t chunk_size)
|
||||||
{
|
{
|
||||||
chunk* c = (chunk*)::malloc(sizeof(chunk) + chunk_size);
|
chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + chunk_size));
|
||||||
if(!c) {
|
if(!c) {
|
||||||
throw std::bad_alloc();
|
throw std::bad_alloc();
|
||||||
}
|
}
|
||||||
|
|
||||||
head_ = c;
|
head_ = c;
|
||||||
free_ = chunk_size;
|
free_ = chunk_size;
|
||||||
ptr_ = ((char*)c) + sizeof(chunk);
|
ptr_ = reinterpret_cast<char*>(c) + sizeof(chunk);
|
||||||
c->next_ = nullptr;
|
c->next_ = nullptr;
|
||||||
}
|
}
|
||||||
~chunk_list()
|
~chunk_list()
|
||||||
@ -138,7 +138,7 @@ private:
|
|||||||
}
|
}
|
||||||
head_->next_ = nullptr;
|
head_->next_ = nullptr;
|
||||||
free_ = chunk_size;
|
free_ = chunk_size;
|
||||||
ptr_ = ((char*)head_) + sizeof(chunk);
|
ptr_ = reinterpret_cast<char*>(head_) + sizeof(chunk);
|
||||||
}
|
}
|
||||||
size_t free_;
|
size_t free_;
|
||||||
char* ptr_;
|
char* ptr_;
|
||||||
@ -147,7 +147,7 @@ private:
|
|||||||
size_t chunk_size_;
|
size_t chunk_size_;
|
||||||
chunk_list chunk_list_;
|
chunk_list chunk_list_;
|
||||||
finalizer_array finalizer_array_;
|
finalizer_array finalizer_array_;
|
||||||
|
|
||||||
public:
|
public:
|
||||||
zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE);
|
zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE);
|
||||||
|
|
||||||
@ -166,7 +166,7 @@ public:
|
|||||||
|
|
||||||
void swap(zone& o);
|
void swap(zone& o);
|
||||||
|
|
||||||
|
|
||||||
template <typename T, typename... Args>
|
template <typename T, typename... Args>
|
||||||
T* allocate(Args... args);
|
T* allocate(Args... args);
|
||||||
|
|
||||||
@ -181,7 +181,7 @@ private:
|
|||||||
|
|
||||||
inline zone* zone::create(size_t chunk_size)
|
inline zone* zone::create(size_t chunk_size)
|
||||||
{
|
{
|
||||||
zone* z = (zone*)::malloc(sizeof(zone) + chunk_size);
|
zone* z = static_cast<zone*>(::malloc(sizeof(zone) + chunk_size));
|
||||||
if (!z) {
|
if (!z) {
|
||||||
return nullptr;
|
return nullptr;
|
||||||
}
|
}
|
||||||
@ -234,9 +234,9 @@ inline void* zone::malloc_expand(size_t size)
|
|||||||
sz *= 2;
|
sz *= 2;
|
||||||
}
|
}
|
||||||
|
|
||||||
chunk* c = (chunk*)::malloc(sizeof(chunk) + sz);
|
chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + sz));
|
||||||
|
|
||||||
char* ptr = ((char*)c) + sizeof(chunk);
|
char* ptr = reinterpret_cast<char*>(c) + sizeof(chunk);
|
||||||
|
|
||||||
c->next_ = cl->head_;
|
c->next_ = cl->head_;
|
||||||
cl->head_ = c;
|
cl->head_ = c;
|
||||||
|
@ -98,7 +98,7 @@ private:
|
|||||||
throw std::bad_alloc();
|
throw std::bad_alloc();
|
||||||
}
|
}
|
||||||
|
|
||||||
data_ = (char*)tmp;
|
data_ = static_cast<char*>(tmp);
|
||||||
alloc_ = nsize;
|
alloc_ = nsize;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -118,7 +118,7 @@ struct define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
|
|||||||
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
|
void msgpack_object(msgpack::object* o, msgpack::zone* z) const
|
||||||
{
|
{
|
||||||
o->type = type::ARRAY;
|
o->type = type::ARRAY;
|
||||||
o->via.array.ptr = (object*)z->malloc(sizeof(object)*<%=i+1%>);
|
o->via.array.ptr = static_cast<object*>(z->malloc(sizeof(object)*<%=i+1%>));
|
||||||
o->via.array.size = <%=i+1%>;
|
o->via.array.size = <%=i+1%>;
|
||||||
<%0.upto(i) {|j|%>
|
<%0.upto(i) {|j|%>
|
||||||
o->via.array.ptr[<%=j%>] = object(a<%=j%>, z);<%}%>
|
o->via.array.ptr[<%=j%>] = object(a<%=j%>, z);<%}%>
|
||||||
|
@ -57,7 +57,7 @@ inline void operator<< (object::with_zone& o, const std::deque<T>& v)
|
|||||||
o.via.array.ptr = NULL;
|
o.via.array.ptr = NULL;
|
||||||
o.via.array.size = 0;
|
o.via.array.size = 0;
|
||||||
} else {
|
} else {
|
||||||
object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
|
object* p = static_cast<object*>(o.zone->malloc(sizeof(object)*v.size()));
|
||||||
object* const pend = p + v.size();
|
object* const pend = p + v.size();
|
||||||
o.via.array.ptr = p;
|
o.via.array.ptr = p;
|
||||||
o.via.array.size = v.size();
|
o.via.array.size = v.size();
|
||||||
|
@ -44,7 +44,7 @@ namespace detail {
|
|||||||
throw type_error();
|
throw type_error();
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename T>
|
template <typename T>
|
||||||
struct convert_integer_sign<T, false> {
|
struct convert_integer_sign<T, false> {
|
||||||
static inline T convert(object o) {
|
static inline T convert(object o) {
|
||||||
|
@ -57,7 +57,7 @@ inline void operator<< (object::with_zone& o, const std::list<T>& v)
|
|||||||
o.via.array.ptr = NULL;
|
o.via.array.ptr = NULL;
|
||||||
o.via.array.size = 0;
|
o.via.array.size = 0;
|
||||||
} else {
|
} else {
|
||||||
object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
|
object* p = static_cast<object*>(o.zone->malloc(sizeof(object)*v.size()));
|
||||||
object* const pend = p + v.size();
|
object* const pend = p + v.size();
|
||||||
o.via.array.ptr = p;
|
o.via.array.ptr = p;
|
||||||
o.via.array.size = v.size();
|
o.via.array.size = v.size();
|
||||||
|
@ -78,7 +78,7 @@ inline void operator<< (object::with_zone& o, const type::assoc_vector<K,V>& v)
|
|||||||
o.via.map.ptr = NULL;
|
o.via.map.ptr = NULL;
|
||||||
o.via.map.size = 0;
|
o.via.map.size = 0;
|
||||||
} else {
|
} else {
|
||||||
object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size());
|
object_kv* p = static_cast<object_kv*>(o.zone->malloc(sizeof(object_kv)*v.size()));
|
||||||
object_kv* const pend = p + v.size();
|
object_kv* const pend = p + v.size();
|
||||||
o.via.map.ptr = p;
|
o.via.map.ptr = p;
|
||||||
o.via.map.size = v.size();
|
o.via.map.size = v.size();
|
||||||
@ -134,7 +134,7 @@ inline void operator<< (object::with_zone& o, const std::map<K,V>& v)
|
|||||||
o.via.map.ptr = NULL;
|
o.via.map.ptr = NULL;
|
||||||
o.via.map.size = 0;
|
o.via.map.size = 0;
|
||||||
} else {
|
} else {
|
||||||
object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size());
|
object_kv* p = static_cast<object_kv*>(o.zone->malloc(sizeof(object_kv)*v.size()));
|
||||||
object_kv* const pend = p + v.size();
|
object_kv* const pend = p + v.size();
|
||||||
o.via.map.ptr = p;
|
o.via.map.ptr = p;
|
||||||
o.via.map.size = v.size();
|
o.via.map.size = v.size();
|
||||||
@ -184,7 +184,7 @@ inline void operator<< (object::with_zone& o, const std::multimap<K,V>& v)
|
|||||||
o.via.map.ptr = NULL;
|
o.via.map.ptr = NULL;
|
||||||
o.via.map.size = 0;
|
o.via.map.size = 0;
|
||||||
} else {
|
} else {
|
||||||
object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size());
|
object_kv* p = static_cast<object_kv*>(o.zone->malloc(sizeof(object_kv)*v.size()));
|
||||||
object_kv* const pend = p + v.size();
|
object_kv* const pend = p + v.size();
|
||||||
o.via.map.ptr = p;
|
o.via.map.ptr = p;
|
||||||
o.via.map.size = v.size();
|
o.via.map.size = v.size();
|
||||||
|
@ -47,7 +47,7 @@ template <typename T1, typename T2>
|
|||||||
inline void operator<< (object::with_zone& o, const std::pair<T1, T2>& v)
|
inline void operator<< (object::with_zone& o, const std::pair<T1, T2>& v)
|
||||||
{
|
{
|
||||||
o.type = type::ARRAY;
|
o.type = type::ARRAY;
|
||||||
object* p = (object*)o.zone->malloc(sizeof(object)*2);
|
object* p = static_cast<object*>(o.zone->malloc(sizeof(object)*2));
|
||||||
o.via.array.ptr = p;
|
o.via.array.ptr = p;
|
||||||
o.via.array.size = 2;
|
o.via.array.size = 2;
|
||||||
p[0] = object(v.first, o.zone);
|
p[0] = object(v.first, o.zone);
|
||||||
|
@ -56,7 +56,7 @@ inline void operator<< (object::with_zone& o, const std::set<T>& v)
|
|||||||
o.via.array.ptr = NULL;
|
o.via.array.ptr = NULL;
|
||||||
o.via.array.size = 0;
|
o.via.array.size = 0;
|
||||||
} else {
|
} else {
|
||||||
object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
|
object* p = static_cast<object*>(o.zone->malloc(sizeof(object)*v.size()));
|
||||||
object* const pend = p + v.size();
|
object* const pend = p + v.size();
|
||||||
o.via.array.ptr = p;
|
o.via.array.ptr = p;
|
||||||
o.via.array.size = v.size();
|
o.via.array.size = v.size();
|
||||||
@ -102,7 +102,7 @@ inline void operator<< (object::with_zone& o, const std::multiset<T>& v)
|
|||||||
o.via.array.ptr = NULL;
|
o.via.array.ptr = NULL;
|
||||||
o.via.array.size = 0;
|
o.via.array.size = 0;
|
||||||
} else {
|
} else {
|
||||||
object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
|
object* p = static_cast<object*>(o.zone->malloc(sizeof(object)*v.size()));
|
||||||
object* const pend = p + v.size();
|
object* const pend = p + v.size();
|
||||||
o.via.array.ptr = p;
|
o.via.array.ptr = p;
|
||||||
o.via.array.size = v.size();
|
o.via.array.size = v.size();
|
||||||
|
@ -42,7 +42,7 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::string& v)
|
|||||||
inline void operator<< (object::with_zone& o, const std::string& v)
|
inline void operator<< (object::with_zone& o, const std::string& v)
|
||||||
{
|
{
|
||||||
o.type = type::RAW;
|
o.type = type::RAW;
|
||||||
char* ptr = (char*)o.zone->malloc(v.size());
|
char* ptr = static_cast<char*>(o.zone->malloc(v.size()));
|
||||||
o.via.raw.ptr = ptr;
|
o.via.raw.ptr = ptr;
|
||||||
o.via.raw.size = (uint32_t)v.size();
|
o.via.raw.size = (uint32_t)v.size();
|
||||||
memcpy(ptr, v.data(), v.size());
|
memcpy(ptr, v.data(), v.size());
|
||||||
|
@ -77,7 +77,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m
|
|||||||
o.via.map.ptr = NULL;
|
o.via.map.ptr = NULL;
|
||||||
o.via.map.size = 0;
|
o.via.map.size = 0;
|
||||||
} else {
|
} else {
|
||||||
object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size());
|
object_kv* p = static_cast<object_kv*>(o.zone->malloc(sizeof(object_kv)*v.size()));
|
||||||
object_kv* const pend = p + v.size();
|
object_kv* const pend = p + v.size();
|
||||||
o.via.map.ptr = p;
|
o.via.map.ptr = p;
|
||||||
o.via.map.size = v.size();
|
o.via.map.size = v.size();
|
||||||
@ -127,7 +127,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m
|
|||||||
o.via.map.ptr = NULL;
|
o.via.map.ptr = NULL;
|
||||||
o.via.map.size = 0;
|
o.via.map.size = 0;
|
||||||
} else {
|
} else {
|
||||||
object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size());
|
object_kv* p = static_cast<object_kv*>(o.zone->malloc(sizeof(object_kv)*v.size()));
|
||||||
object_kv* const pend = p + v.size();
|
object_kv* const pend = p + v.size();
|
||||||
o.via.map.ptr = p;
|
o.via.map.ptr = p;
|
||||||
o.via.map.size = v.size();
|
o.via.map.size = v.size();
|
||||||
|
@ -74,7 +74,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_s
|
|||||||
o.via.array.ptr = NULL;
|
o.via.array.ptr = NULL;
|
||||||
o.via.array.size = 0;
|
o.via.array.size = 0;
|
||||||
} else {
|
} else {
|
||||||
object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
|
object* p = static_cast<object*>(o.zone->malloc(sizeof(object)*v.size()));
|
||||||
object* const pend = p + v.size();
|
object* const pend = p + v.size();
|
||||||
o.via.array.ptr = p;
|
o.via.array.ptr = p;
|
||||||
o.via.array.size = v.size();
|
o.via.array.size = v.size();
|
||||||
@ -120,7 +120,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m
|
|||||||
o.via.array.ptr = NULL;
|
o.via.array.ptr = NULL;
|
||||||
o.via.array.size = 0;
|
o.via.array.size = 0;
|
||||||
} else {
|
} else {
|
||||||
object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
|
object* p = static_cast<object*>(o.zone->malloc(sizeof(object)*v.size()));
|
||||||
object* const pend = p + v.size();
|
object* const pend = p + v.size();
|
||||||
o.via.array.ptr = p;
|
o.via.array.ptr = p;
|
||||||
o.via.array.size = v.size();
|
o.via.array.size = v.size();
|
||||||
|
@ -184,7 +184,7 @@ inline void operator<< (
|
|||||||
object::with_zone& o,
|
object::with_zone& o,
|
||||||
const type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) {
|
const type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) {
|
||||||
o.type = type::ARRAY;
|
o.type = type::ARRAY;
|
||||||
o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*<%=i+1%>);
|
o.via.array.ptr = static_cast<object*>(o.zone->malloc(sizeof(object)*<%=i+1%>));
|
||||||
o.via.array.size = <%=i+1%>;
|
o.via.array.size = <%=i+1%>;
|
||||||
<%0.upto(i) {|j|%>
|
<%0.upto(i) {|j|%>
|
||||||
o.via.array.ptr[<%=j%>] = object(v.template get<<%=j%>>(), o.zone);<%}%>
|
o.via.array.ptr[<%=j%>] = object(v.template get<<%=j%>>(), o.zone);<%}%>
|
||||||
|
@ -61,7 +61,7 @@ inline void operator<< (object::with_zone& o, const std::vector<T>& v)
|
|||||||
o.via.array.ptr = NULL;
|
o.via.array.ptr = NULL;
|
||||||
o.via.array.size = 0;
|
o.via.array.size = 0;
|
||||||
} else {
|
} else {
|
||||||
object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
|
object* p = static_cast<object*>(o.zone->malloc(sizeof(object)*v.size()));
|
||||||
object* const pend = p + v.size();
|
object* const pend = p + v.size();
|
||||||
o.via.array.ptr = p;
|
o.via.array.ptr = p;
|
||||||
o.via.array.size = v.size();
|
o.via.array.size = v.size();
|
||||||
|
@ -56,23 +56,23 @@ private:
|
|||||||
};
|
};
|
||||||
public:
|
public:
|
||||||
vrefbuffer(size_t ref_size = MSGPACK_VREFBUFFER_REF_SIZE,
|
vrefbuffer(size_t ref_size = MSGPACK_VREFBUFFER_REF_SIZE,
|
||||||
size_t chunk_size = MSGPACK_VREFBUFFER_CHUNK_SIZE)
|
size_t chunk_size = MSGPACK_VREFBUFFER_CHUNK_SIZE)
|
||||||
:ref_size_(ref_size), chunk_size_(chunk_size)
|
:ref_size_(ref_size), chunk_size_(chunk_size)
|
||||||
{
|
{
|
||||||
size_t nfirst = (sizeof(iovec) < 72/2) ?
|
size_t nfirst = (sizeof(iovec) < 72/2) ?
|
||||||
72 / sizeof(iovec) : 8;
|
72 / sizeof(iovec) : 8;
|
||||||
|
|
||||||
iovec* array = (iovec*)::malloc(
|
iovec* array = static_cast<iovec*>(::malloc(
|
||||||
sizeof(iovec) * nfirst);
|
sizeof(iovec) * nfirst));
|
||||||
if(!array) {
|
if(!array) {
|
||||||
throw std::bad_alloc();
|
throw std::bad_alloc();
|
||||||
}
|
}
|
||||||
|
|
||||||
tail_ = array;
|
tail_ = array;
|
||||||
end_ = array + nfirst;
|
end_ = array + nfirst;
|
||||||
array_ = array;
|
array_ = array;
|
||||||
|
|
||||||
chunk* c = (chunk*)::malloc(sizeof(chunk) + chunk_size);
|
chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + chunk_size));
|
||||||
if(!c) {
|
if(!c) {
|
||||||
::free(array);
|
::free(array);
|
||||||
throw std::bad_alloc();
|
throw std::bad_alloc();
|
||||||
@ -80,10 +80,10 @@ public:
|
|||||||
inner_buffer* const ib = &inner_buffer_;
|
inner_buffer* const ib = &inner_buffer_;
|
||||||
|
|
||||||
ib->free = chunk_size;
|
ib->free = chunk_size;
|
||||||
ib->ptr = ((char*)c) + sizeof(chunk);
|
ib->ptr = reinterpret_cast<char*>(c) + sizeof(chunk);
|
||||||
ib->head = c;
|
ib->head = c;
|
||||||
c->next = nullptr;
|
c->next = nullptr;
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
~vrefbuffer()
|
~vrefbuffer()
|
||||||
@ -117,17 +117,17 @@ public:
|
|||||||
const size_t nused = tail_ - array_;
|
const size_t nused = tail_ - array_;
|
||||||
const size_t nnext = nused * 2;
|
const size_t nnext = nused * 2;
|
||||||
|
|
||||||
iovec* nvec = (iovec*)::realloc(
|
iovec* nvec = static_cast<iovec*>(::realloc(
|
||||||
array_, sizeof(iovec)*nnext);
|
array_, sizeof(iovec)*nnext));
|
||||||
if(!nvec) {
|
if(!nvec) {
|
||||||
throw std::bad_alloc();
|
throw std::bad_alloc();
|
||||||
}
|
}
|
||||||
|
|
||||||
array_ = nvec;
|
array_ = nvec;
|
||||||
end_ = nvec + nnext;
|
end_ = nvec + nnext;
|
||||||
tail_ = nvec + nused;
|
tail_ = nvec + nused;
|
||||||
}
|
}
|
||||||
|
|
||||||
tail_->iov_base = (char*)buf;
|
tail_->iov_base = (char*)buf;
|
||||||
tail_->iov_len = len;
|
tail_->iov_len = len;
|
||||||
++tail_;
|
++tail_;
|
||||||
@ -143,24 +143,26 @@ public:
|
|||||||
sz = len;
|
sz = len;
|
||||||
}
|
}
|
||||||
|
|
||||||
chunk* c = (chunk*)::malloc(sizeof(chunk) + sz);
|
chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + sz));
|
||||||
if(!c) {
|
if(!c) {
|
||||||
throw std::bad_alloc();
|
throw std::bad_alloc();
|
||||||
}
|
}
|
||||||
|
|
||||||
c->next = ib->head;
|
c->next = ib->head;
|
||||||
ib->head = c;
|
ib->head = c;
|
||||||
ib->free = sz;
|
ib->free = sz;
|
||||||
ib->ptr = ((char*)c) + sizeof(chunk);
|
ib->ptr = reinterpret_cast<char*>(c) + sizeof(chunk);
|
||||||
}
|
}
|
||||||
|
|
||||||
char* m = ib->ptr;
|
char* m = ib->ptr;
|
||||||
::memcpy(m, buf, len);
|
::memcpy(m, buf, len);
|
||||||
ib->free -= len;
|
ib->free -= len;
|
||||||
ib->ptr += len;
|
ib->ptr += len;
|
||||||
|
|
||||||
if(tail_ != array_ && m ==
|
if(tail_ != array_ && m ==
|
||||||
(const char*)((tail_ - 1)->iov_base) + (tail_ - 1)->iov_len) {
|
static_cast<const char*>(
|
||||||
|
const_cast<const void *>((tail_ - 1)->iov_base)
|
||||||
|
) + (tail_ - 1)->iov_len) {
|
||||||
(tail_ - 1)->iov_len += len;
|
(tail_ - 1)->iov_len += len;
|
||||||
return;
|
return;
|
||||||
} else {
|
} else {
|
||||||
@ -182,7 +184,7 @@ public:
|
|||||||
{
|
{
|
||||||
size_t sz = chunk_size_;
|
size_t sz = chunk_size_;
|
||||||
|
|
||||||
chunk* empty = (chunk*)::malloc(sizeof(chunk) + sz);
|
chunk* empty = static_cast<chunk*>(::malloc(sizeof(chunk) + sz));
|
||||||
if(!empty) {
|
if(!empty) {
|
||||||
throw std::bad_alloc();
|
throw std::bad_alloc();
|
||||||
}
|
}
|
||||||
@ -198,8 +200,8 @@ public:
|
|||||||
nnext *= 2;
|
nnext *= 2;
|
||||||
}
|
}
|
||||||
|
|
||||||
iovec* nvec = (iovec*)::realloc(
|
iovec* nvec = static_cast<iovec*>(::realloc(
|
||||||
to->array_, sizeof(iovec)*nnext);
|
to->array_, sizeof(iovec)*nnext));
|
||||||
if(!nvec) {
|
if(!nvec) {
|
||||||
::free(empty);
|
::free(empty);
|
||||||
throw std::bad_alloc();
|
throw std::bad_alloc();
|
||||||
@ -211,7 +213,7 @@ public:
|
|||||||
}
|
}
|
||||||
|
|
||||||
::memcpy(to->tail_, array_, sizeof(iovec)*nused);
|
::memcpy(to->tail_, array_, sizeof(iovec)*nused);
|
||||||
|
|
||||||
to->tail_ += nused;
|
to->tail_ += nused;
|
||||||
tail_ = array_;
|
tail_ = array_;
|
||||||
|
|
||||||
@ -225,18 +227,18 @@ public:
|
|||||||
}
|
}
|
||||||
last->next = toib->head;
|
last->next = toib->head;
|
||||||
toib->head = ib->head;
|
toib->head = ib->head;
|
||||||
|
|
||||||
if(toib->free < ib->free) {
|
if(toib->free < ib->free) {
|
||||||
toib->free = ib->free;
|
toib->free = ib->free;
|
||||||
toib->ptr = ib->ptr;
|
toib->ptr = ib->ptr;
|
||||||
}
|
}
|
||||||
|
|
||||||
ib->head = empty;
|
ib->head = empty;
|
||||||
ib->free = sz;
|
ib->free = sz;
|
||||||
ib->ptr = ((char*)empty) + sizeof(chunk);
|
ib->ptr = reinterpret_cast<char*>(empty) + sizeof(chunk);
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void clear()
|
void clear()
|
||||||
{
|
{
|
||||||
chunk* c = inner_buffer_.head->next;
|
chunk* c = inner_buffer_.head->next;
|
||||||
@ -251,7 +253,7 @@ public:
|
|||||||
c = ib->head;
|
c = ib->head;
|
||||||
c->next = nullptr;
|
c->next = nullptr;
|
||||||
ib->free = chunk_size_;
|
ib->free = chunk_size_;
|
||||||
ib->ptr = ((char*)c) + sizeof(chunk);
|
ib->ptr = reinterpret_cast<char*>(c) + sizeof(chunk);
|
||||||
|
|
||||||
tail_ = array_;
|
tail_ = array_;
|
||||||
}
|
}
|
||||||
|
@ -57,7 +57,7 @@ public:
|
|||||||
public:
|
public:
|
||||||
void write(const char* buf, size_t len)
|
void write(const char* buf, size_t len)
|
||||||
{
|
{
|
||||||
stream_.next_in = (Bytef*)buf;
|
stream_.next_in = reinterpret_cast<Bytef*>(const_cast<char*>(buf));
|
||||||
stream_.avail_in = len;
|
stream_.avail_in = len;
|
||||||
|
|
||||||
do {
|
do {
|
||||||
@ -115,8 +115,8 @@ public:
|
|||||||
|
|
||||||
void reset_buffer()
|
void reset_buffer()
|
||||||
{
|
{
|
||||||
stream_.avail_out += (char*)stream_.next_out - data_;
|
stream_.avail_out += reinterpret_cast<char*>(stream_.next_out) - data_;
|
||||||
stream_.next_out = (Bytef*)data_;
|
stream_.next_out = reinterpret_cast<Bytef*>(data_);
|
||||||
}
|
}
|
||||||
|
|
||||||
char* release_buffer()
|
char* release_buffer()
|
||||||
@ -131,17 +131,17 @@ public:
|
|||||||
private:
|
private:
|
||||||
bool expand()
|
bool expand()
|
||||||
{
|
{
|
||||||
size_t used = (char*)stream_.next_out - data_;
|
size_t used = reinterpret_cast<char*>(stream_.next_out) - data_;
|
||||||
size_t csize = used + stream_.avail_out;
|
size_t csize = used + stream_.avail_out;
|
||||||
size_t nsize = (csize == 0) ? init_size_ : csize * 2;
|
size_t nsize = (csize == 0) ? init_size_ : csize * 2;
|
||||||
|
|
||||||
char* tmp = (char*)::realloc(data_, nsize);
|
char* tmp = static_cast<char*>(::realloc(data_, nsize));
|
||||||
if(tmp == NULL) {
|
if(tmp == NULL) {
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
data_ = tmp;
|
data_ = tmp;
|
||||||
stream_.next_out = (Bytef*)(tmp + used);
|
stream_.next_out = reinterpret_cast<Bytef*>(tmp + used);
|
||||||
stream_.avail_out = nsize - used;
|
stream_.avail_out = nsize - used;
|
||||||
|
|
||||||
return true;
|
return true;
|
||||||
|
@ -80,7 +80,7 @@ class zone {
|
|||||||
nnext = nused * 2;
|
nnext = nused * 2;
|
||||||
}
|
}
|
||||||
finalizer* tmp =
|
finalizer* tmp =
|
||||||
(finalizer*)::realloc(array_, sizeof(finalizer) * nnext);
|
static_cast<finalizer*>(::realloc(array_, sizeof(finalizer) * nnext));
|
||||||
if(!tmp) {
|
if(!tmp) {
|
||||||
throw std::bad_alloc();
|
throw std::bad_alloc();
|
||||||
}
|
}
|
||||||
@ -101,14 +101,14 @@ class zone {
|
|||||||
struct chunk_list {
|
struct chunk_list {
|
||||||
chunk_list(size_t chunk_size)
|
chunk_list(size_t chunk_size)
|
||||||
{
|
{
|
||||||
chunk* c = (chunk*)::malloc(sizeof(chunk) + chunk_size);
|
chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + chunk_size));
|
||||||
if(!c) {
|
if(!c) {
|
||||||
throw std::bad_alloc();
|
throw std::bad_alloc();
|
||||||
}
|
}
|
||||||
|
|
||||||
head_ = c;
|
head_ = c;
|
||||||
free_ = chunk_size;
|
free_ = chunk_size;
|
||||||
ptr_ = ((char*)c) + sizeof(chunk);
|
ptr_ = reinterpret_cast<char*>(c) + sizeof(chunk);
|
||||||
c->next_ = nullptr;
|
c->next_ = nullptr;
|
||||||
}
|
}
|
||||||
~chunk_list()
|
~chunk_list()
|
||||||
@ -138,7 +138,7 @@ class zone {
|
|||||||
}
|
}
|
||||||
head_->next_ = nullptr;
|
head_->next_ = nullptr;
|
||||||
free_ = chunk_size;
|
free_ = chunk_size;
|
||||||
ptr_ = ((char*)head_) + sizeof(chunk);
|
ptr_ = reinterpret_cast<char*>(head_) + sizeof(chunk);
|
||||||
}
|
}
|
||||||
size_t free_;
|
size_t free_;
|
||||||
char* ptr_;
|
char* ptr_;
|
||||||
@ -183,7 +183,7 @@ private:
|
|||||||
|
|
||||||
inline zone* zone::create(size_t chunk_size)
|
inline zone* zone::create(size_t chunk_size)
|
||||||
{
|
{
|
||||||
zone* z = (zone*)::malloc(sizeof(zone) + chunk_size);
|
zone* z = static_cast<zone*>(::malloc(sizeof(zone) + chunk_size));
|
||||||
if (!z) {
|
if (!z) {
|
||||||
return nullptr;
|
return nullptr;
|
||||||
}
|
}
|
||||||
@ -236,9 +236,9 @@ inline void* zone::malloc_expand(size_t size)
|
|||||||
sz *= 2;
|
sz *= 2;
|
||||||
}
|
}
|
||||||
|
|
||||||
chunk* c = (chunk*)::malloc(sizeof(chunk) + sz);
|
chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + sz));
|
||||||
|
|
||||||
char* ptr = ((char*)c) + sizeof(chunk);
|
char* ptr = reinterpret_cast<char*>(c) + sizeof(chunk);
|
||||||
|
|
||||||
c->next_ = cl->head_;
|
c->next_ = cl->head_;
|
||||||
cl->head_ = c;
|
cl->head_ = c;
|
||||||
|
Loading…
x
Reference in New Issue
Block a user