diff --git a/include/msgpack/v2/unpack.hpp b/include/msgpack/v2/unpack.hpp index b16ce781..0c6c7a04 100644 --- a/include/msgpack/v2/unpack.hpp +++ b/include/msgpack/v2/unpack.hpp @@ -283,7 +283,7 @@ public: bool m_referenced; }; -template +template class context { public: context() @@ -308,8 +308,8 @@ private: return static_cast(*p) & 0x1f; } - UnpackVisitorHolder& holder() { - return static_cast(*this); + VisitorHolder& holder() { + return static_cast(*this); } template @@ -364,38 +364,38 @@ private: } struct array_sv { - array_sv(UnpackVisitorHolder& visitor_holder):m_visitor_holder(visitor_holder) {} + array_sv(VisitorHolder& visitor_holder):m_visitor_holder(visitor_holder) {} bool operator()(uint32_t size) const { return m_visitor_holder.visitor().start_array(size); } msgpack_container_type type() const { return MSGPACK_CT_ARRAY_ITEM; } private: - UnpackVisitorHolder& m_visitor_holder; + VisitorHolder& m_visitor_holder; }; struct array_ev { - array_ev(UnpackVisitorHolder& visitor_holder):m_visitor_holder(visitor_holder) {} + array_ev(VisitorHolder& visitor_holder):m_visitor_holder(visitor_holder) {} bool operator()() const { return m_visitor_holder.visitor().end_array(); } private: - UnpackVisitorHolder& m_visitor_holder; + VisitorHolder& m_visitor_holder; }; struct map_sv { - map_sv(UnpackVisitorHolder& visitor_holder):m_visitor_holder(visitor_holder) {} + map_sv(VisitorHolder& visitor_holder):m_visitor_holder(visitor_holder) {} bool operator()(uint32_t size) const { return m_visitor_holder.visitor().start_map(size); } msgpack_container_type type() const { return MSGPACK_CT_MAP_KEY; } private: - UnpackVisitorHolder& m_visitor_holder; + VisitorHolder& m_visitor_holder; }; struct map_ev { - map_ev(UnpackVisitorHolder& visitor_holder):m_visitor_holder(visitor_holder) {} + map_ev(VisitorHolder& visitor_holder):m_visitor_holder(visitor_holder) {} bool operator()() const { return m_visitor_holder.visitor().end_map(); } private: - UnpackVisitorHolder& m_visitor_holder; + VisitorHolder& m_visitor_holder; }; struct unpack_stack { @@ -410,7 +410,7 @@ private: void push(msgpack_container_type type, uint32_t rest) { m_stack.push_back(stack_elem(type, rest)); } - unpack_return consume(UnpackVisitorHolder& visitor_holder) { + unpack_return consume(VisitorHolder& visitor_holder) { while (!m_stack.empty()) { stack_elem& e = m_stack.back(); switch (e.m_type) { @@ -431,13 +431,13 @@ private: e.m_type = MSGPACK_CT_MAP_VALUE; return UNPACK_CONTINUE; case MSGPACK_CT_MAP_VALUE: + if (!visitor_holder.visitor().end_map_value()) return UNPACK_STOP_VISITOR; if (--e.m_rest == 0) { m_stack.pop_back(); if (!visitor_holder.visitor().end_map()) return UNPACK_STOP_VISITOR; } else { e.m_type = MSGPACK_CT_MAP_KEY; - if (!visitor_holder.visitor().end_map_value()) return UNPACK_STOP_VISITOR; if (!visitor_holder.visitor().start_map_key()) return UNPACK_STOP_VISITOR; return UNPACK_CONTINUE; } @@ -470,8 +470,8 @@ inline void check_ext_size<4>(std::size_t size) { if (size == 0xffffffff) throw msgpack::ext_size_overflow("ext size overflow"); } -template -inline unpack_return context::execute(const char* data, std::size_t len, std::size_t& off) +template +inline unpack_return context::execute(const char* data, std::size_t len, std::size_t& off) { assert(len >= off); @@ -869,10 +869,10 @@ inline unpack_return context::execute(const char* data, std /// Unpacking class for a stream deserialization. -template -class basic_unpacker : public detail::context { - typedef basic_unpacker this_type; - typedef detail::context context_type; +template +class parser : public detail::context { + typedef parser this_type; + typedef detail::context context_type; public: /// Constructor /** @@ -883,15 +883,15 @@ public: * @param limit The size limit information of msgpack::object. * */ - basic_unpacker(ReferencedBufferHook& hook, - std::size_t initial_buffer_size = MSGPACK_UNPACKER_INIT_BUFFER_SIZE); + parser(ReferencedBufferHook& hook, + std::size_t initial_buffer_size = MSGPACK_UNPACKER_INIT_BUFFER_SIZE); #if !defined(MSGPACK_USE_CPP03) - basic_unpacker(this_type&& other); + parser(this_type&& other); this_type& operator=(this_type&& other); #endif // !defined(MSGPACK_USE_CPP03) - ~basic_unpacker(); + ~parser(); public: /// Reserve a buffer memory. @@ -1018,17 +1018,17 @@ private: #if defined(MSGPACK_USE_CPP03) private: - basic_unpacker(const this_type&); + parser(const this_type&); this_type& operator=(const this_type&); #else // defined(MSGPACK_USE_CPP03) public: - basic_unpacker(const this_type&) = delete; + parser(const this_type&) = delete; this_type& operator=(const this_type&) = delete; #endif // defined(MSGPACK_USE_CPP03) }; -template -inline basic_unpacker::basic_unpacker( +template +inline parser::parser( ReferencedBufferHook& hook, std::size_t initial_buffer_size) :m_referenced_buffer_hook(hook) @@ -1055,8 +1055,8 @@ inline basic_unpacker::basic_unpacker #if !defined(MSGPACK_USE_CPP03) // Move constructor and move assignment operator -template -inline basic_unpacker::basic_unpacker(this_type&& other) +template +inline parser::parser(this_type&& other) :context_type(std::move(other)), m_buffer(other.m_buffer), m_used(other.m_used), @@ -1072,9 +1072,9 @@ inline basic_unpacker::basic_unpacker other.m_parsed = 0; } -template -inline basic_unpacker& basic_unpacker::operator=(this_type&& other) { - this->~basic_unpacker(); +template +inline parser& parser::operator=(this_type&& other) { + this->~parser(); new (this) this_type(std::move(other)); return *this; } @@ -1082,26 +1082,26 @@ inline basic_unpacker& basic_unpacker #endif // !defined(MSGPACK_USE_CPP03) -template -inline basic_unpacker::~basic_unpacker() +template +inline parser::~parser() { // These checks are required for move operations. if (m_buffer) detail::decr_count(m_buffer); } -template -inline void basic_unpacker::reserve_buffer(std::size_t size) +template +inline void parser::reserve_buffer(std::size_t size) { if(m_free >= size) return; expand_buffer(size); } -template -inline void basic_unpacker::expand_buffer(std::size_t size) +template +inline void parser::expand_buffer(std::size_t size) { if(m_used == m_off && detail::get_count(m_buffer) == 1 - && static_cast(*this).visitor().referenced()) { + && static_cast(*this).visitor().referenced()) { // rewind buffer m_free += m_used - COUNTER_SIZE; m_used = COUNTER_SIZE; @@ -1150,7 +1150,7 @@ inline void basic_unpacker::expand_bu std::memcpy(tmp+COUNTER_SIZE, m_buffer + m_off, not_parsed); - if(static_cast(*this).referenced()) { + if(static_cast(*this).referenced()) { try { m_referenced_buffer_hook(m_buffer); } @@ -1158,7 +1158,7 @@ inline void basic_unpacker::expand_bu ::free(tmp); throw; } - static_cast(*this).set_referenced(false); + static_cast(*this).set_referenced(false); } else { detail::decr_count(m_buffer); } @@ -1170,34 +1170,34 @@ inline void basic_unpacker::expand_bu } } -template -inline char* basic_unpacker::buffer() +template +inline char* parser::buffer() { return m_buffer + m_used; } -template -inline std::size_t basic_unpacker::buffer_capacity() const +template +inline std::size_t parser::buffer_capacity() const { return m_free; } -template -inline void basic_unpacker::buffer_consumed(std::size_t size) +template +inline void parser::buffer_consumed(std::size_t size) { m_used += size; m_free -= size; } -template - inline bool basic_unpacker::next() +template + inline bool parser::next() { unpack_return ret = execute_imp(); return ret == UNPACK_SUCCESS; } -template -inline unpack_return basic_unpacker::execute_imp() +template +inline unpack_return parser::execute_imp() { std::size_t off = m_off; unpack_return ret = context_type::execute(m_buffer, m_used, m_off); @@ -1207,46 +1207,46 @@ inline unpack_return basic_unpacker:: return ret; } -template -inline void basic_unpacker::reset() +template +inline void parser::reset() { context_type::init(); // don't reset referenced flag m_parsed = 0; } -template -inline std::size_t basic_unpacker::message_size() const +template +inline std::size_t parser::message_size() const { return m_parsed - m_off + m_used; } -template -inline std::size_t basic_unpacker::parsed_size() const +template +inline std::size_t parser::parsed_size() const { return m_parsed; } -template -inline char* basic_unpacker::nonparsed_buffer() +template +inline char* parser::nonparsed_buffer() { return m_buffer + m_off; } -template -inline std::size_t basic_unpacker::nonparsed_size() const +template +inline std::size_t parser::nonparsed_size() const { return m_used - m_off; } -template -inline void basic_unpacker::skip_nonparsed_buffer(std::size_t size) +template +inline void parser::skip_nonparsed_buffer(std::size_t size) { m_off += size; } -template -inline void basic_unpacker::remove_nonparsed_buffer() +template +inline void parser::remove_nonparsed_buffer() { m_used = m_off; } @@ -1260,15 +1260,15 @@ struct zone_push_finalizer { msgpack::zone* m_z; }; -class unpacker : public basic_unpacker, +class unpacker : public parser, public detail::create_object_visitor { - typedef basic_unpacker basic; + typedef parser parser; public: unpacker(unpack_reference_func f = &unpacker::default_reference_func, void* user_data = nullptr, std::size_t initial_buffer_size = MSGPACK_UNPACKER_INIT_BUFFER_SIZE, unpack_limit const& limit = unpack_limit()) - :basic(m_finalizer, initial_buffer_size), + :parser(m_finalizer, initial_buffer_size), detail::create_object_visitor(f, user_data, limit), m_z(new msgpack::zone), m_finalizer(*m_z) { @@ -1318,7 +1318,7 @@ private: }; inline bool unpacker::next(msgpack::object_handle& result, bool& referenced) { - bool ret = basic::next(); + bool ret = parser::next(); if (ret) { referenced = detail::create_object_visitor::referenced(); result.zone().reset( release_zone() ); @@ -1544,33 +1544,33 @@ inline msgpack::object unpack( return msgpack::v2::unpack(z, data, len, off, referenced, f, user_data, limit); } -template -inline bool unpack_visit(const char* data, size_t len, size_t& off, UnpackVisitor& v) { - unpack_return ret = detail::unpack_visit_imp(data, len, off, v); +template +inline bool parse(const char* data, size_t len, size_t& off, Visitor& v) { + unpack_return ret = detail::parse_imp(data, len, off, v); return ret == UNPACK_SUCCESS || ret == UNPACK_EXTRA_BYTES; } -template -inline bool unpack_visit(const char* data, size_t len, UnpackVisitor& v) { +template +inline bool parse(const char* data, size_t len, Visitor& v) { std::size_t off = 0; - return unpack_visit(data, len, off, v); + return parse(data, len, off, v); } namespace detail { -template -struct unpack_helper : context > { - unpack_helper(UnpackVisitor& v):m_visitor(v) {} +template +struct parse_helper : context > { + parse_helper(Visitor& v):m_visitor(v) {} unpack_return execute(const char* data, std::size_t len, std::size_t& off) { - return context >::execute(data, len, off); + return context >::execute(data, len, off); } - UnpackVisitor& visitor() const { return m_visitor; } - UnpackVisitor& m_visitor; + Visitor& visitor() const { return m_visitor; } + Visitor& m_visitor; }; -template +template inline unpack_return -unpack_visit_imp(const char* data, size_t len, size_t& off, UnpackVisitor& v) { +parse_imp(const char* data, size_t len, size_t& off, Visitor& v) { std::size_t noff = off; if(len <= noff) { @@ -1578,7 +1578,7 @@ unpack_visit_imp(const char* data, size_t len, size_t& off, UnpackVisitor& v) { v.insufficient_bytes(noff, noff); return UNPACK_CONTINUE; } - detail::unpack_helper h(v); + detail::parse_helper h(v); unpack_return ret = h.execute(data, len, noff); switch (ret) { case UNPACK_CONTINUE: @@ -1606,7 +1606,7 @@ unpack_imp(const char* data, std::size_t len, std::size_t& off, v.set_zone(result_zone); referenced = false; v.set_referenced(referenced); - unpack_return ret = unpack_visit_imp(data, len, off, v); + unpack_return ret = parse_imp(data, len, off, v); referenced = v.referenced(); result = v.data(); return ret; diff --git a/include/msgpack/v2/unpack_decl.hpp b/include/msgpack/v2/unpack_decl.hpp index 8adeb8d7..30540c62 100644 --- a/include/msgpack/v2/unpack_decl.hpp +++ b/include/msgpack/v2/unpack_decl.hpp @@ -305,23 +305,25 @@ msgpack::object unpack( * @param data The pointer to the buffer. * @param len The length of the buffer. * @param off The offset position of the buffer. It is read and overwritten. + * @param v The visitor that satisfies visitor concept. https://github.com/msgpack/msgpack-c/wiki/v2_0_cpp_visitor#visitor-concept * * @return if unpacking process finishs without error then return true, otherwise return false. * */ -template -bool unpack_visit(const char* data, size_t len, size_t& off, UnpackVisitor&); +template +bool parse(const char* data, size_t len, size_t& off, Visitor& v); /// Unpack msgpack formatted data via a visitor /** * @param data The pointer to the buffer. * @param len The length of the buffer. + * @param v The visitor that satisfies visitor concept. https://github.com/msgpack/msgpack-c/wiki/v2_0_cpp_visitor#visitor-concept * * @return if unpacking process finishs without error then return true, otherwise return false. * */ -template -bool unpack_visit(const char* data, size_t len, UnpackVisitor& v); +template +bool parse(const char* data, size_t len, Visitor& v); namespace detail { @@ -333,7 +335,7 @@ unpack_imp(const char* data, std::size_t len, std::size_t& off, template unpack_return -unpack_visit_imp(const char* data, size_t len, size_t& off, UnpackVisitor& v); +parse_imp(const char* data, size_t len, size_t& off, UnpackVisitor& v); } // detail diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 0d0cc005..08f62c0e 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -30,9 +30,9 @@ LIST (APPEND check_PROGRAMS reference.cpp streaming.cpp streaming_c.cpp - unpack_visitor.cpp user_class.cpp version.cpp + visitor.cpp zone.cpp ) diff --git a/test/Makefile.am b/test/Makefile.am index 29c260e5..c869d8f7 100644 --- a/test/Makefile.am +++ b/test/Makefile.am @@ -25,9 +25,9 @@ check_PROGRAMS = \ reference \ streaming \ streaming_c \ - unpack_visitor \ user_class \ version \ + visitor \ zone check_PROGRAMS += \ @@ -71,9 +71,9 @@ raw_SOURCES = raw.cpp reference_SOURCES = reference.cpp streaming_SOURCES = streaming.cpp streaming_c_SOURCES = streaming_c.cpp -unpack_visitor_SOURCES = unpack_visitor.cpp user_class_SOURCES = user_class.cpp version_SOURCES = version.cpp +visitor_SOURCES = visitor.cpp zone_SOURCES = zone.cpp iterator_cpp11_SOURCES = iterator_cpp11.cpp diff --git a/test/unpack_visitor.cpp b/test/visitor.cpp similarity index 80% rename from test/unpack_visitor.cpp rename to test/visitor.cpp index 04badf2b..61e67947 100644 --- a/test/unpack_visitor.cpp +++ b/test/visitor.cpp @@ -3,14 +3,14 @@ #include // To avoid link error -TEST(unpack_visitor, dummy) +TEST(visitor, dummy) { } #if MSGPACK_DEFAULT_API_VERSION >= 2 -struct json_visitor : msgpack::v2::null_visitor { - json_visitor(std::string& s):m_s(s) {} +struct json_like_visitor : msgpack::v2::null_visitor { + json_like_visitor(std::string& s):m_s(s) {} bool visit_nil() { m_s += "null"; @@ -34,6 +34,7 @@ struct json_visitor : msgpack::v2::null_visitor { return true; } bool visit_str(const char* v, uint32_t size) { + // I omit escape process. m_s += '"' + std::string(v, size) + '"'; return true; } @@ -58,7 +59,12 @@ struct json_visitor : msgpack::v2::null_visitor { m_s += ":"; return true; } + bool end_map_value() { + m_s += ","; + return true; + } bool end_map() { + m_s.erase(m_s.size() - 1, 1); // remove the last ',' m_s += "}"; return true; } @@ -71,7 +77,7 @@ struct json_visitor : msgpack::v2::null_visitor { std::string& m_s; }; -TEST(unpack_visitor, json) +TEST(visitor, json_like) { std::stringstream ss; msgpack::packer p(ss); @@ -82,12 +88,12 @@ TEST(unpack_visitor, json) p.pack_nil(); p.pack(true); - std::string json; - json_visitor v(json); + std::string json_like; + json_like_visitor v(json_like); std::size_t off = 0; - bool ret = msgpack::v2::unpack_visit(ss.str().data(), ss.str().size(), off, v); + bool ret = msgpack::v2::parse(ss.str().data(), ss.str().size(), off, v); EXPECT_TRUE(ret); - EXPECT_EQ("{\"key\":[42,null,true]}", json); + EXPECT_EQ("{\"key\":[42,null,true]}", json_like); } struct parse_error_check_visitor : msgpack::v2::null_visitor { @@ -100,13 +106,13 @@ struct parse_error_check_visitor : msgpack::v2::null_visitor { bool& m_called; }; -TEST(unpack_visitor, parse_error) +TEST(visitor, parse_error) { bool called = false; parse_error_check_visitor v(called); std::size_t off = 0; char const data[] = { static_cast(0x93u), 0x01u, static_cast(0xc1u), 0x03u }; - bool ret = msgpack::v2::unpack_visit(data, sizeof(data), off, v); + bool ret = msgpack::v2::parse(data, sizeof(data), off, v); EXPECT_FALSE(ret); EXPECT_TRUE(called); } @@ -121,13 +127,13 @@ struct insuf_bytes_check_visitor : msgpack::v2::null_visitor { bool& m_called; }; -TEST(unpack_visitor, insuf_bytes) +TEST(visitor, insuf_bytes) { bool called = false; insuf_bytes_check_visitor v(called); std::size_t off = 0; char const data[] = { static_cast(0x93u), 0x01u, 0x01u }; - bool ret = msgpack::v2::unpack_visit(data, sizeof(data), off, v); + bool ret = msgpack::v2::parse(data, sizeof(data), off, v); EXPECT_FALSE(ret); EXPECT_TRUE(called); }