From a0a798d79e5c11bae1b0b6a94b25e0dee0c19b77 Mon Sep 17 00:00:00 2001 From: frsyuki Date: Sun, 15 Feb 2009 09:09:57 +0000 Subject: [PATCH] lang/c/msgpack: C++ binding: changed calback function of packer from Stream& append(const char*, size_t) to SomeType write(SomePointerType, SomeSizeType) git-svn-id: file:///Users/frsyuki/project/msgpack-git/svn/x@62 5a5092ae-2292-43ba-b2d5-dcab9c1a2731 --- cpp/bench.cpp | 3 +-- cpp/pack.hpp | 47 ++++++++++++++++++++++++++++++++--------------- cpp/test.cpp | 5 +++-- cpp/unpack.cpp | 8 ++++---- cpp/unpack.hpp | 14 +++++++------- 5 files changed, 47 insertions(+), 30 deletions(-) diff --git a/cpp/bench.cpp b/cpp/bench.cpp index 1a9f6f92..649c0cc7 100644 --- a/cpp/bench.cpp +++ b/cpp/bench.cpp @@ -49,14 +49,13 @@ public: } public: - inline simple_buffer& append(const char* buf, size_t len) + inline void write(const void* buf, size_t len) { if(m_allocated - m_used < len) { expand_buffer(len); } memcpy(m_storage + m_used, buf, len); m_used += len; - return *this; } void clear() diff --git a/cpp/pack.hpp b/cpp/pack.hpp index ac7bb832..94b5b9af 100644 --- a/cpp/pack.hpp +++ b/cpp/pack.hpp @@ -73,7 +73,7 @@ private: static void pack_string_impl(Stream& x, const char* b); static void pack_raw_impl(Stream& x, const void* b, size_t l); static void append_buffer(Stream& x, const unsigned char* buf, unsigned int len) - { x.append((const char*)buf, len); } + { x.write((const char*)buf, len); } private: Stream& m_stream; @@ -100,14 +100,13 @@ public: template dynamic_stream(Stream& s); public: - dynamic_stream& append(const char* buf, size_t len) - { (*m_function)(m_object, buf, len); return *this; } + 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: - template - static void append_trampoline(void* object, const char* buf, size_t len); + struct write_trampoline; }; @@ -137,8 +136,6 @@ public: void pack_string(const char* b) { pack_string_impl(m_stream, b); } void pack_raw(const void* b, size_t l) { pack_raw_impl(m_stream, b, l); } -public: - private: static void pack_int_impl(dynamic_stream& x, int d); static void pack_unsigned_int_impl(dynamic_stream& x, unsigned int d); @@ -160,7 +157,7 @@ private: 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.append((const char*)buf, len); } + { x.write((const char*)buf, len); } private: dynamic_stream m_stream; @@ -181,17 +178,37 @@ private: template dynamic_packer::dynamic_packer(Stream& s) : m_stream(s) { } +struct dynamic_stream::write_trampoline { +private: + template + struct ret_type { + typedef R (*type)(void*, const char*, size_t); + }; + + template + static R trampoline(void* obj, const char* buf, size_t len) + { + return (reinterpret_cast(obj)->*MemFun)(buf, len); + } + +public: + template + static typename ret_type::type get(R (Stream::*func)(Ptr*, Sz)) + { + R (*f)(void*, const char*, size_t) = + &trampoline; + return f; + } +}; + template dynamic_stream::dynamic_stream(Stream& s) { m_object = reinterpret_cast(&s); - m_function = &dynamic_stream::append_trampoline; -} - -template -void dynamic_stream::append_trampoline(void* object, const char* buf, size_t len) -{ - (reinterpret_cast(object)->*MemFun)(buf, len); + m_function = reinterpret_cast( + write_trampoline::get(&Stream::write) + ); } diff --git a/cpp/test.cpp b/cpp/test.cpp index 7c91fbdf..b63f9a15 100644 --- a/cpp/test.cpp +++ b/cpp/test.cpp @@ -28,9 +28,10 @@ public: } try { - std::string s; + std::stringstream s; msgpack::pack(s, o); - object ro = msgpack::unpack(s.data(), s.size(), m_zone); + std::string str(s.str()); + object ro = msgpack::unpack(str.data(), str.size(), m_zone); if(ro != o) { throw std::runtime_error("NOT MATCH"); } } catch (std::runtime_error& e) { std::cout << "** REUNPACK FAILED **" << std::endl; diff --git a/cpp/unpack.cpp b/cpp/unpack.cpp index 7a0cd786..de330517 100644 --- a/cpp/unpack.cpp +++ b/cpp/unpack.cpp @@ -99,10 +99,10 @@ void unpacker::expand_buffer(size_t len) else { next_size = UNPACKER_INITIAL_BUFFER_SIZE; } while(next_size < len + m_used) { next_size *= 2; } - void* tmp = realloc(m_buffer, next_size); + char* tmp = (char*)realloc(m_buffer, next_size); if(!tmp) { throw std::bad_alloc(); } m_buffer = tmp; - //void* tmp = malloc(next_size); + //char* tmp = (char*)malloc(next_size); //if(!tmp) { throw std::bad_alloc(); } //memcpy(tmp, m_buffer, m_used); //free(m_buffer); @@ -114,9 +114,9 @@ void unpacker::expand_buffer(size_t len) size_t next_size = UNPACKER_INITIAL_BUFFER_SIZE; while(next_size < len + m_used - m_off) { next_size *= 2; } - void* tmp = malloc(next_size); + char* tmp = (char*)malloc(next_size); if(!tmp) { throw std::bad_alloc(); } - memcpy(tmp, ((char*)m_buffer)+m_off, m_used-m_off); + memcpy(tmp, m_buffer+m_off, m_used-m_off); try { m_zone->push_finalizer(&zone::finalize_free, NULL, m_buffer); diff --git a/cpp/unpack.hpp b/cpp/unpack.hpp index 452a2311..f5896f35 100644 --- a/cpp/unpack.hpp +++ b/cpp/unpack.hpp @@ -48,7 +48,7 @@ public: void reserve_buffer(size_t len); /*! 2. read data to the buffer() up to buffer_capacity() bytes */ - void* buffer(); + char* buffer(); size_t buffer_capacity() const; /*! 3. specify the number of bytes actually copied */ @@ -74,7 +74,7 @@ public: // Note that there are no parsed buffer when execute() returned true. /*! get address of buffer that is not parsed */ - void* nonparsed_buffer(); + char* nonparsed_buffer(); size_t nonparsed_size() const; /*! get the number of bytes that is already parsed */ @@ -90,7 +90,7 @@ private: struct context; context* m_ctx; - void* m_buffer; + char* m_buffer; size_t m_used; size_t m_free; size_t m_off; @@ -110,8 +110,8 @@ inline void unpacker::reserve_buffer(size_t len) expand_buffer(len); } -inline void* unpacker::buffer() - { return (void*)(((char*)m_buffer)+m_used); } +inline char* unpacker::buffer() + { return m_buffer + m_used; } inline size_t unpacker::buffer_capacity() const { return m_free; } @@ -123,8 +123,8 @@ inline void unpacker::buffer_consumed(size_t len) } -inline void* unpacker::nonparsed_buffer() - { return (void*)(((char*)m_buffer)+m_off); } +inline char* unpacker::nonparsed_buffer() + { return m_buffer + m_off; } inline size_t unpacker::nonparsed_size() const { return m_used - m_off; }