generic-library/msgpack
1
0
Fork 0
mirror of https://github.com/msgpack/msgpack-c.git synced 2025-03-14 18:10:30 +01:00
Code Issues Projects Releases Wiki Activity

lang/c/msgpack: divide pack_raw() into pack_raw() and pack_raw_body()

Browse Source 
git-svn-id: file:///Users/frsyuki/project/msgpack-git/svn/x@74 5a5092ae-2292-43ba-b2d5-dcab9c1a2731
This commit is contained in:
frsyuki 2009-02-15 09:09:58 +00:00
parent 921b0ff62e
commit 1ad04b22d8
9 changed files with 28 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
c/bench.c
View File

@ -279,7 +279,8 @@ void bench_msgpack(void)
unsigned int i;
msgpack_pack_array(mpk, TASK_STR_LEN);
for(i=0; i < TASK_STR_LEN; ++i) {
msgpack_pack_raw(mpk, TASK_STR_PTR, i);
msgpack_pack_raw(mpk, i);
msgpack_pack_raw_body(mpk, TASK_STR_PTR, i);
}
}
show_timer(mpkbuf.length);

4
c/pack.h
View File

@ -54,8 +54,8 @@ void msgpack_pack_true(msgpack_pack_t* ctx);
void msgpack_pack_false(msgpack_pack_t* ctx);
void msgpack_pack_array(msgpack_pack_t* ctx, unsigned int n);
void msgpack_pack_map(msgpack_pack_t* ctx, unsigned int n);
void msgpack_pack_string(msgpack_pack_t* ctx, const char* b);
void msgpack_pack_raw(msgpack_pack_t* ctx, const void* b, size_t l);
void msgpack_pack_raw(msgpack_pack_t* ctx, size_t l);
void msgpack_pack_raw_body(msgpack_pack_t* ctx, const void* b, size_t l);
#ifdef __cplusplus

3
cpp/bench.cpp
View File

@ -142,7 +142,8 @@ void bench_msgpack_str()
msgpack::packer<simple_buffer> pk(buf);
pk.pack_array(TASK_STR_LEN);
for(unsigned int i=0; i < TASK_STR_LEN; ++i) {
pk.pack_raw(TASK_STR_PTR, i);
pk.pack_raw(i);
pk.pack_raw_body(TASK_STR_PTR, i);
}
}
timer.show_stat(buf.size());

3
cpp/object.hpp
View File

@ -173,7 +173,8 @@ packer<Stream>& operator<< (packer<Stream>& o, const object& v)
return o;
case type::RAW:
o.pack_raw(v.via.ref.ptr, v.via.ref.size);
o.pack_raw(v.via.ref.size);
o.pack_raw_body(v.via.ref.ptr, v.via.ref.size);
return o;
case type::ARRAY:

131
cpp/pack.hpp
View File

@ -47,7 +47,8 @@ public:
void pack_false() { pack_false_impl(m_stream); }
void pack_array(unsigned int n) { pack_array_impl(m_stream, n); }
void pack_map(unsigned int n) { pack_map_impl(m_stream, n); }
void pack_raw(const char* b, size_t l) { pack_raw_impl(m_stream, (const void*)b, l); }
void pack_raw(size_t l) { pack_raw_impl(m_stream, l); }
void pack_raw_body(const char* b, size_t l) { pack_raw_body_impl(m_stream, b, l); }
private:
static void pack_int_impl(Stream& x, int d);
@ -67,7 +68,9 @@ private:
static void pack_false_impl(Stream& x);
static void pack_array_impl(Stream& x, unsigned int n);
static void pack_map_impl(Stream& x, unsigned int n);
static void pack_raw_impl(Stream& x, const void* b, size_t l);
static void pack_raw_impl(Stream& x, size_t l);
static void pack_raw_body_impl(Stream& x, const void* b, size_t l);
static void append_buffer(Stream& x, const unsigned char* buf, unsigned int len)
{ x.write((const char*)buf, len); }
@ -90,130 +93,6 @@ template <typename Stream>
packer<Stream>::packer(Stream& s) : m_stream(s) { }
/*
class dynamic_stream {
public:
template <typename Stream>
dynamic_stream(Stream& s);
public:
void write(const char* buf, size_t len)
{ (*m_function)(m_object, buf, len); }
private:
void* m_object;
void (*m_function)(void* object, const char* buf, size_t len);
private:
struct write_trampoline;
};
class dynamic_packer {
public:
template <typename Stream>
dynamic_packer(Stream& s);
public:
void pack_int(int d) { pack_int_impl(m_stream, d); }
void pack_unsigned_int(unsigned int d) { pack_unsigned_int_impl(m_stream, d); }
void pack_uint8(uint8_t d) { pack_uint8_impl(m_stream, d); }
void pack_uint16(uint16_t d) { pack_uint16_impl(m_stream, d); }
void pack_uint32(uint32_t d) { pack_uint32_impl(m_stream, d); }
void pack_uint64(uint64_t d) { pack_uint64_impl(m_stream, d); }
void pack_int8(uint8_t d) { pack_int8_impl(m_stream, d); }
void pack_int16(uint16_t d) { pack_int16_impl(m_stream, d); }
void pack_int32(uint32_t d) { pack_int32_impl(m_stream, d); }
void pack_int64(uint64_t d) { pack_int64_impl(m_stream, d); }
void pack_float(float d) { pack_float_impl(m_stream, d); }
void pack_double(double d) { pack_double_impl(m_stream, d); }
void pack_nil() { pack_nil_impl(m_stream); }
void pack_true() { pack_true_impl(m_stream); }
void pack_false() { pack_false_impl(m_stream); }
void pack_array(unsigned int n) { pack_array_impl(m_stream, n); }
void pack_map(unsigned int n) { pack_map_impl(m_stream, n); }
void pack_string(const char* b) { pack_string_impl(m_stream, b); }
void pack_raw(const char* b, size_t l) { pack_raw_impl(m_stream, (const void*)b, l); }
private:
static void pack_int_impl(dynamic_stream& x, int d);
static void pack_unsigned_int_impl(dynamic_stream& x, unsigned int d);
static void pack_uint8_impl(dynamic_stream& x, uint8_t d);
static void pack_uint16_impl(dynamic_stream& x, uint16_t d);
static void pack_uint32_impl(dynamic_stream& x, uint32_t d);
static void pack_uint64_impl(dynamic_stream& x, uint64_t d);
static void pack_int8_impl(dynamic_stream& x, int8_t d);
static void pack_int16_impl(dynamic_stream& x, int16_t d);
static void pack_int32_impl(dynamic_stream& x, int32_t d);
static void pack_int64_impl(dynamic_stream& x, int64_t d);
static void pack_float_impl(dynamic_stream& x, float d);
static void pack_double_impl(dynamic_stream& x, double d);
static void pack_nil_impl(dynamic_stream& x);
static void pack_true_impl(dynamic_stream& x);
static void pack_false_impl(dynamic_stream& x);
static void pack_array_impl(dynamic_stream& x, unsigned int n);
static void pack_map_impl(dynamic_stream& x, unsigned int n);
static void pack_string_impl(dynamic_stream& x, const char* b);
static void pack_raw_impl(dynamic_stream& x, const void* b, size_t l);
static void append_buffer(dynamic_stream& x, const unsigned char* buf, unsigned int len)
{ x.write((const char*)buf, len); }
private:
dynamic_stream m_stream;
private:
dynamic_packer();
};
#define msgpack_pack_inline_func(name) \
inline void dynamic_packer::pack_ ## name ## _impl
#define msgpack_pack_user dynamic_stream&
#define msgpack_pack_append_buffer append_buffer
#include "msgpack/pack_template.h"
template <typename Stream>
dynamic_packer::dynamic_packer(Stream& s) : m_stream(s) { }
struct dynamic_stream::write_trampoline {
private:
template <typename R>
struct ret_type {
typedef R (*type)(void*, const char*, size_t);
};
template <typename Stream, typename R,
typename Ptr, typename Sz, R (Stream::*MemFun)(Ptr*, Sz)>
static R trampoline(void* obj, const char* buf, size_t len)
{
return (reinterpret_cast<Stream*>(obj)->*MemFun)(buf, len);
}
public:
template <typename Stream, typename R, typename Ptr, typename Sz>
static typename ret_type<R>::type get(R (Stream::*func)(Ptr*, Sz))
{
R (*f)(void*, const char*, size_t) =
&trampoline<Stream, R, Ptr, Sz, &Stream::write>;
return f;
}
};
template <typename Stream>
dynamic_stream::dynamic_stream(Stream& s)
{
m_object = reinterpret_cast<void*>(&s);
m_function = reinterpret_cast<void (*)(void*, const char*, size_t)>(
write_trampoline::get(&Stream::write)
);
}
template <typename Stream>
inline void pack(Stream& s, object o)
{
dynamic_packer pk(s);
o.pack(pk);
}
*/
} // namespace msgpack
#endif /* msgpack/pack.hpp */

6
cpp/type/raw.hpp
View File

@ -82,7 +82,8 @@ inline std::string& operator>> (object o, std::string& v)
template <typename Stream>
inline packer<Stream>& operator<< (packer<Stream>& o, const type::raw_ref& v)
{
o.pack_raw(v.ptr, v.size);
o.pack_raw(v.size);
o.pack_raw_body(v.ptr, v.size);
return o;
}
@ -90,7 +91,8 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const type::raw_ref& v)
template <typename Stream>
inline packer<Stream>& operator<< (packer<Stream>& o, const std::string& v)
{
o.pack_raw(v.data(), v.size());
o.pack_raw(v.size());
o.pack_raw_body(v.data(), v.size());
return o;
}

4
cpp/unpack.cpp
View File

@ -257,7 +257,7 @@ zone* unpacker::release_zone()
throw;
}
}
m_ctx->user(&*m_zone);
m_ctx->user(m_zone.get());
return old.release();
}
@ -268,7 +268,7 @@ object unpacker::data()
void unpacker::reset()
{
if(m_off != 0) { std::auto_ptr<zone> old(release_zone()); }
if(m_off != 0) { delete release_zone(); }
m_ctx->reset();
}

7
msgpack/pack_template.h
View File

@ -282,7 +282,7 @@ msgpack_pack_inline_func(map)(msgpack_pack_user x, unsigned int n)
* Raw
*/
msgpack_pack_inline_func(raw)(msgpack_pack_user x, const void* b, size_t l)
msgpack_pack_inline_func(raw)(msgpack_pack_user x, size_t l)
{
if(l < 32) {
unsigned char d = 0xa0 | l;
@ -296,9 +296,12 @@ msgpack_pack_inline_func(raw)(msgpack_pack_user x, const void* b, size_t l)
unsigned char buf[5] = {0xdb, STORE_BE32(d)};
msgpack_pack_append_buffer(x, buf, 5);
}
msgpack_pack_append_buffer(x, (const unsigned char*)b, l);
}
msgpack_pack_inline_func(raw_body)(msgpack_pack_user x, const void* b, size_t l)
{
msgpack_pack_append_buffer(x, (const unsigned char*)b, l);
}
#undef msgpack_pack_inline_func
#undef msgpack_pack_user

6
ruby/pack.c
View File

@ -45,7 +45,8 @@ static void msgpack_pack_true(VALUE x);
static void msgpack_pack_false(VALUE x);
static void msgpack_pack_array(VALUE x, unsigned int n);
static void msgpack_pack_map(VALUE x, unsigned int n);
static void msgpack_pack_raw(VALUE x, const void* b, size_t l);
static void msgpack_pack_raw(VALUE x, size_t l);
static void msgpack_pack_raw_body(VALUE x, const void* b, size_t l);
*/
#include "msgpack/pack_template.h"
@ -123,7 +124,8 @@ static VALUE MessagePack_Float_to_msgpack(int argc, VALUE *argv, VALUE self)
static VALUE MessagePack_String_to_msgpack(int argc, VALUE *argv, VALUE self)
{
ARG_BUFFER(out, argc, argv);
msgpack_pack_raw(out, RSTRING_PTR(self), RSTRING_LEN(self));
msgpack_pack_raw(out, RSTRING_LEN(self));
msgpack_pack_raw_body(out, RSTRING_PTR(self), RSTRING_LEN(self));
return out;
}