From 0fbab63425076fa0682a79cd91fc32208313fbdf Mon Sep 17 00:00:00 2001 From: Vitalii Orazov Date: Tue, 9 Sep 2025 18:57:54 +0300 Subject: [PATCH 1/9] rename task to support build with hotkey --- .vscode/tasks.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.vscode/tasks.json b/.vscode/tasks.json index 831fefb..d599f6d 100644 --- a/.vscode/tasks.json +++ b/.vscode/tasks.json @@ -4,7 +4,7 @@ "version": "2.0.0", "tasks": [ { - "label": "build all", + "label": "build", "type": "shell", "command": "/usr/bin/cmake --build ./build --config Debug --target all -- -j8", "problemMatcher": [ From b2bca4d4ad50b24c228f22baaaf2c1b384cba39d Mon Sep 17 00:00:00 2001 From: Vitalii Orazov Date: Tue, 9 Sep 2025 18:58:03 +0300 Subject: [PATCH 2/9] fix warning --- Tests/MsgpackArrayTestsGroup.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Tests/MsgpackArrayTestsGroup.cpp b/Tests/MsgpackArrayTestsGroup.cpp index 7ccad42..ca32923 100644 --- a/Tests/MsgpackArrayTestsGroup.cpp +++ b/Tests/MsgpackArrayTestsGroup.cpp @@ -31,7 +31,7 @@ class UserDto : public MsgpackObject { class UsersList : public MsgpackObjectsArray { public: bool Validate(MsgpackObject *item) override { return Size() < maxCount && item != NULL && item->Validate(); } - MsgpackObject *CreateItem() { return new UserDto(); } + MsgpackObject *CreateItem() override { return new UserDto(); } }; class StringsList : public MsgpackArray { From 329fdf3fe493647ce2b443749148cc81a29b9633 Mon Sep 17 00:00:00 2001 From: Vitalii Orazov Date: Tue, 9 Sep 2025 19:31:34 +0300 Subject: [PATCH 3/9] build: build always as static lib --- CMakeLists.txt | 61 +++++++++++++++++++++++++++++--------------------- 1 file changed, 35 insertions(+), 26 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 8431dfd..31ab526 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -2,40 +2,49 @@ cmake_minimum_required(VERSION 3.8.0) project(MsgpackWrapper VERSION 0.1.0) set(CMAKE_CXX_STANDARD 14) -include_directories(include) +set(MSGPACK_BUILD_TESTS OFF CACHE BOOL "Disable tests") +set(MSGPACK_GEN_COVERAGE OFF CACHE BOOL "Disable coverage") +set(MSGPACK_BUILD_EXAMPLES OFF CACHE BOOL "Disable examples") +set(MSGPACK_ENABLE_SHARED OFF CACHE BOOL "Disable shared") +set(MSGPACK_ENABLE_STATIC ON CACHE BOOL "Enable static") + +add_subdirectory(msgpack-c) +get_target_property(MSGPACK_BINARY_INCLUDE_DIRS msgpack-c BINARY_DIR) + +include_directories( + include + msgpack-c/include + msgpack-c/include/msgpack + ${MSGPACK_BINARY_INCLUDE_DIRS}/include + ${MSGPACK_BINARY_INCLUDE_DIRS}/include/msgpack +) if(WIN32) add_definitions(-D_CRT_SECURE_NO_WARNINGS) endif(WIN32) set(CPP_SOURCE_FILES -src/MsgpackValueBase.cpp -src/MsgpackValue.cpp -src/MsgpackObject.cpp -src/MsgpackArrayBase.cpp -src/MsgpackArray.cpp -src/MsgpackObjectsArray.cpp + src/MsgpackValueBase.cpp + src/MsgpackValue.cpp + src/MsgpackObject.cpp + src/MsgpackArrayBase.cpp + src/MsgpackArray.cpp + src/MsgpackObjectsArray.cpp ) -if(PROJECT_IS_TOP_LEVEL) - add_executable(MsgpackWrapper main.cpp ${CPP_SOURCE_FILES}) - target_link_libraries(MsgpackWrapper PRIVATE msgpack-c) - - IF (NOT MSGPACKWRAPPER_SKIP_TESTING) - enable_testing() - add_subdirectory(Tests) - ENDIF () -ELSE () - ADD_LIBRARY(MsgpackWrapper main.cpp ${CPP_SOURCE_FILES}) - target_link_libraries(MsgpackWrapper PRIVATE msgpack-c) +add_library(MsgpackWrapper STATIC ${CPP_SOURCE_FILES}) -ENDIF () +target_link_libraries(MsgpackWrapper PUBLIC msgpack-c) -OPTION (MSGPACK_BUILD_TESTS OFF) -OPTION (MSGPACK_GEN_COVERAGE OFF) -OPTION (MSGPACK_BUILD_EXAMPLES OFF) -SET (MSGPACK_ENABLE_SHARED OFF) -SET (MSGPACK_ENABLE_STATIC ON) +target_include_directories(MsgpackWrapper PUBLIC + ${CMAKE_CURRENT_SOURCE_DIR}/include + ${CMAKE_CURRENT_SOURCE_DIR}/msgpack-c/include + ${CMAKE_CURRENT_SOURCE_DIR}/msgpack-c/include/msgpack + ${MSGPACK_BINARY_INCLUDE_DIRS}/include + ${MSGPACK_BINARY_INCLUDE_DIRS}/include/msgpack +) -target_include_directories(MsgpackWrapper PRIVATE msgpack-c/include/msgpack msgpack-c/include msgpack-c/src) -add_subdirectory(msgpack-c) \ No newline at end of file +if(PROJECT_IS_TOP_LEVEL AND NOT MSGPACKWRAPPER_SKIP_TESTING) + enable_testing() + add_subdirectory(Tests) +endif() \ No newline at end of file From f90c65273b43418d34c6b5fbe1a65d91cc8f96a7 Mon Sep 17 00:00:00 2001 From: Vitalii Orazov Date: Tue, 9 Sep 2025 19:31:52 +0300 Subject: [PATCH 4/9] tests: use precompiled lid --- Tests/CMakeLists.txt | 121 +++++++++++++------------------------------ 1 file changed, 36 insertions(+), 85 deletions(-) diff --git a/Tests/CMakeLists.txt b/Tests/CMakeLists.txt index ce42c94..ad1dd8f 100644 --- a/Tests/CMakeLists.txt +++ b/Tests/CMakeLists.txt @@ -1,98 +1,49 @@ project(MsgpackWrapperTests) - include(CTest) if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU") - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti -Wno-write-strings -Wno-overflow -Wno-conversion-null") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti -Wno-write-strings -Wno-overflow -Wno-conversion-null") endif() if(WIN32) - add_definitions("/wd4251") - add_definitions("/wd4305") - add_definitions("/wd4309") - add_definitions(-D_CRT_SECURE_NO_WARNINGS) + add_definitions("/wd4251") + add_definitions("/wd4305") + add_definitions("/wd4309") + add_definitions(-D_CRT_SECURE_NO_WARNINGS) endif(WIN32) add_subdirectory(cpputest) set(CPPUTEST_SOURCE_DIRS - cpputest/include - cpputest/src - cpputest/CppUTest - ) - -set(CPPUTEST_SOURCE_FILES - ${CMAKE_CURRENT_SOURCE_DIR}/../src/MsgpackValueBase.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/../src/MsgpackValue.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/../src/MsgpackObject.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/../src/MsgpackArrayBase.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/../src/MsgpackArray.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/../src/MsgpackObjectsArray.cpp - ) - -add_executable(MsgpackStringValueTestsGroup - ${CPPUTEST_SOURCE_FILES} - MsgpackStringValueTestsGroup.cpp) -if(WIN32) - target_link_libraries(MsgpackStringValueTestsGroup Winmm.lib) -endif(WIN32) -target_link_libraries(MsgpackStringValueTestsGroup CppUTest) -target_link_libraries(MsgpackStringValueTestsGroup msgpack-c) -target_include_directories(MsgpackStringValueTestsGroup PRIVATE ${CPPUTEST_SOURCE_DIRS}) -add_test(MsgpackStringValueTestsGroup MsgpackStringValueTestsGroup) - -add_executable(MsgpackDataValueTestsGroup - ${CPPUTEST_SOURCE_FILES} - MsgpackDataValueTestsGroup.cpp) -if(WIN32) - target_link_libraries(MsgpackDataValueTestsGroup Winmm.lib) -endif(WIN32) -target_link_libraries(MsgpackDataValueTestsGroup CppUTest) -target_link_libraries(MsgpackDataValueTestsGroup msgpack-c) -target_include_directories(MsgpackDataValueTestsGroup PRIVATE ${CPPUTEST_SOURCE_DIRS}) -add_test(MsgpackDataValueTestsGroup MsgpackDataValueTestsGroup) - -add_executable(MsgpackNumericValueTestsGroup - ${CPPUTEST_SOURCE_FILES} - MsgpackNumericValueTestsGroup.cpp) -if(WIN32) - target_link_libraries(MsgpackNumericValueTestsGroup Winmm.lib) -endif(WIN32) -target_link_libraries(MsgpackNumericValueTestsGroup CppUTest) -target_link_libraries(MsgpackNumericValueTestsGroup msgpack-c) -target_include_directories(MsgpackNumericValueTestsGroup PRIVATE ${CPPUTEST_SOURCE_DIRS}) -add_test(MsgpackNumericValueTestsGroup MsgpackNumericValueTestsGroup) - -add_executable(MsgpackObjectTestsGroup - ${CPPUTEST_SOURCE_FILES} - MsgpackObjectTestsGroup.cpp) -if(WIN32) - target_link_libraries(MsgpackObjectTestsGroup Winmm.lib) -endif(WIN32) -target_link_libraries(MsgpackObjectTestsGroup CppUTest) -target_link_libraries(MsgpackObjectTestsGroup msgpack-c) -target_include_directories(MsgpackObjectTestsGroup PRIVATE ${CPPUTEST_SOURCE_DIRS}) -add_test(MsgpackObjectTestsGroup MsgpackObjectTestsGroup) - -add_executable(MsgpackArrayTestsGroup - ${CPPUTEST_SOURCE_FILES} - MsgpackArrayTestsGroup.cpp) -if(WIN32) - target_link_libraries(MsgpackArrayTestsGroup Winmm.lib) -endif(WIN32) -target_link_libraries(MsgpackArrayTestsGroup CppUTest) -target_link_libraries(MsgpackArrayTestsGroup msgpack-c) -target_include_directories(MsgpackArrayTestsGroup PRIVATE ${CPPUTEST_SOURCE_DIRS}) -add_test(MsgpackArrayTestsGroup MsgpackArrayTestsGroup) - -add_executable(MsgpackHeavyDutyTestsGroup - ${CPPUTEST_SOURCE_FILES} - MsgpackHeavyDutyTestsGroup.cpp) -if(WIN32) - target_link_libraries(MsgpackHeavyDutyTestsGroup Winmm.lib) -endif(WIN32) -target_link_libraries(MsgpackHeavyDutyTestsGroup CppUTest) -target_link_libraries(MsgpackHeavyDutyTestsGroup msgpack-c) -target_include_directories(MsgpackHeavyDutyTestsGroup PRIVATE ${CPPUTEST_SOURCE_DIRS}) -add_test(MsgpackHeavyDutyTestsGroup MsgpackHeavyDutyTestsGroup) \ No newline at end of file + cpputest/include + cpputest/src + cpputest/CppUTest +) + +include_directories( + ${CMAKE_SOURCE_DIR}/include + ${CMAKE_SOURCE_DIR}/msgpack-c/include + ${CMAKE_SOURCE_DIR}/msgpack-c/include/msgpack + ${CMAKE_BINARY_DIR}/msgpack-c/include + ${CMAKE_BINARY_DIR}/msgpack-c/include/msgpack +) + +function(add_msgpack_test test_name test_source) + add_executable(${test_name} ${test_source}) + + if(WIN32) + target_link_libraries(${test_name} Winmm.lib) + endif(WIN32) + + target_link_libraries(${test_name} CppUTest MsgpackWrapper) + target_include_directories(${test_name} PRIVATE ${CPPUTEST_SOURCE_DIRS}) + add_test(${test_name} ${test_name}) +endfunction() + +add_msgpack_test(MsgpackStringValueTestsGroup MsgpackStringValueTestsGroup.cpp) +add_msgpack_test(MsgpackDataValueTestsGroup MsgpackDataValueTestsGroup.cpp) +add_msgpack_test(MsgpackNumericValueTestsGroup MsgpackNumericValueTestsGroup.cpp) +add_msgpack_test(MsgpackObjectTestsGroup MsgpackObjectTestsGroup.cpp) +add_msgpack_test(MsgpackArrayTestsGroup MsgpackArrayTestsGroup.cpp) +add_msgpack_test(MsgpackHeavyDutyTestsGroup MsgpackHeavyDutyTestsGroup.cpp) \ No newline at end of file From af262464182ac7914bb4ceb151f825bff538b1bf Mon Sep 17 00:00:00 2001 From: Vitalii Orazov Date: Tue, 9 Sep 2025 20:23:01 +0300 Subject: [PATCH 5/9] add Demo --- .vscode/launch.json | 2 +- CMakeLists.txt | 17 ++++- main.cpp | 149 ++++++++++---------------------------------- 3 files changed, 50 insertions(+), 118 deletions(-) diff --git a/.vscode/launch.json b/.vscode/launch.json index 9b7b675..0c56106 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -8,7 +8,7 @@ "name": "(gdb) Launch", "type": "cppdbg", "request": "launch", - "program": "${workspaceFolder}/build/MsgpackWrapper", + "program": "${workspaceFolder}/build/MsgpackWrapperDemo", "args": [], "stopAtEntry": false, "cwd": "${workspaceFolder}", diff --git a/CMakeLists.txt b/CMakeLists.txt index 31ab526..10ee7c3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -8,7 +8,10 @@ set(MSGPACK_BUILD_EXAMPLES OFF CACHE BOOL "Disable examples") set(MSGPACK_ENABLE_SHARED OFF CACHE BOOL "Disable shared") set(MSGPACK_ENABLE_STATIC ON CACHE BOOL "Enable static") +option(MSGPACKWRAPPER_BUILD_DEMO "Build demonstration application" ON) + add_subdirectory(msgpack-c) + get_target_property(MSGPACK_BINARY_INCLUDE_DIRS msgpack-c BINARY_DIR) include_directories( @@ -34,7 +37,7 @@ set(CPP_SOURCE_FILES add_library(MsgpackWrapper STATIC ${CPP_SOURCE_FILES}) -target_link_libraries(MsgpackWrapper PUBLIC msgpack-c) +target_link_libraries(MsgpackWrapper PRIVATE msgpack-c) target_include_directories(MsgpackWrapper PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include @@ -44,6 +47,18 @@ target_include_directories(MsgpackWrapper PUBLIC ${MSGPACK_BINARY_INCLUDE_DIRS}/include/msgpack ) +if(MSGPACKWRAPPER_BUILD_DEMO) + add_executable(MsgpackWrapperDemo main.cpp) + target_link_libraries(MsgpackWrapperDemo MsgpackWrapper) + target_include_directories(MsgpackWrapperDemo PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/include + ${CMAKE_CURRENT_SOURCE_DIR}/msgpack-c/include + ${CMAKE_CURRENT_SOURCE_DIR}/msgpack-c/include/msgpack + ${MSGPACK_BINARY_INCLUDE_DIRS}/include + ${MSGPACK_BINARY_INCLUDE_DIRS}/include/msgpack + ) +endif() + if(PROJECT_IS_TOP_LEVEL AND NOT MSGPACKWRAPPER_SKIP_TESTING) enable_testing() add_subdirectory(Tests) diff --git a/main.cpp b/main.cpp index 97b1c1d..06444b6 100644 --- a/main.cpp +++ b/main.cpp @@ -1,127 +1,44 @@ +#include "MsgpackWrapper.h" #include #include #include -#include "MsgpackWrapper.h" - -// int main(const int argc, const char *argv[]) { -// fprintf(stdout, "json to class object\n"); - -// return EXIT_SUCCESS; -// } - -// #include -// #include - -void print(char const *buf, size_t len) { - size_t i = 0; - for (; i < len; ++i) printf("%02x ", 0xff & buf[i]); - printf("\n"); -} -typedef enum { uAdmin, uViewer } TUserRole; +typedef enum { uAdmin = 42, uViewer } TUserRole; -class UserDto : MsgpackObject { +class UserDto : public MsgpackObject { public: - MsgpackValue Name; - MsgpackValue Role; - - UserDto(const char *name = {}, const TUserRole role = {}) - : Name(this, 0, name), // - Role(this, 1, role){}; - - size_t WriteTo(char *outBuffer, size_t outBufferSize) { - msgpack_sbuffer sbuf; - msgpack_packer packer; - msgpack_sbuffer_init(&sbuf); - msgpack_packer_init(&packer, &sbuf, msgpack_sbuffer_write); - - for (const auto &field : Fields) { - if (!field->Write(&packer)) { - msgpack_sbuffer_destroy(&sbuf); - return 0; - }; - } - - size_t size; - if (sbuf.size > outBufferSize) { - size = outBufferSize; - } else { - size = sbuf.size; - } - memcpy(outBuffer, sbuf.data, size); - - msgpack_sbuffer_destroy(&sbuf); - return size; - } - - msgpack_unpacker *BeginTryParse(const char *buffer, size_t length) { - if (buffer == NULL) { return NULL; } - - auto unpacker = msgpack_unpacker_new(length); - if (unpacker == NULL) { return NULL; } + MsgpackValue Name; + MsgpackValue Role; - msgpack_unpacked unpacked; - msgpack_unpack_return ret; - msgpack_unpacked_init(&unpacked); - ret = msgpack_unpacker_next(unpacker, &unpacked); - switch (ret) { - case MSGPACK_UNPACK_SUCCESS: - if (TryParse(&unpacked.data)) { break; } - msgpack_unpacked_destroy(&unpacked); - EndTryParse(unpacker); - return NULL; - - case MSGPACK_UNPACK_CONTINUE: - case MSGPACK_UNPACK_PARSE_ERROR: - default: - msgpack_unpacked_destroy(&unpacked); - EndTryParse(unpacker); - return NULL; - } - - msgpack_unpacked_destroy(&unpacked); - return unpacker; - } - void EndTryParse(msgpack_unpacker *unpacker) { msgpack_unpacker_free(unpacker); } + UserDto(const char *name = {}, const TUserRole role = {}) + : Name(this, 0, name), // + Role(this, 1, role) {}; }; int main(void) { - UserDto userDto; - - auto unpacker = msgpack_unpacker_new(1234); - userDto.EndTryParse(unpacker); - - msgpack_sbuffer sbuf; - msgpack_packer pk; - - /* msgpack::sbuffer is a simple buffer implementation. */ - msgpack_sbuffer_init(&sbuf); - - /* serialize values into the buffer using msgpack_sbuffer_write callback function. */ - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - - msgpack_pack_array(&pk, 3); - msgpack_pack_int(&pk, 1); - msgpack_pack_true(&pk); - msgpack_pack_str(&pk, 7); - msgpack_pack_str_body(&pk, "example", 7); - - print(sbuf.data, sbuf.size); - - msgpack_zone mempool; - msgpack_object deserialized; - /* deserialize the buffer into msgpack_object instance. */ - /* deserialized object is valid during the msgpack_zone instance alive. */ - msgpack_zone_init(&mempool, 2048); - - msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized); - - /* print the deserialized object. */ - msgpack_object_print(stdout, deserialized); - puts(""); - - msgpack_zone_destroy(&mempool); - msgpack_sbuffer_destroy(&sbuf); - - return 0; + char buffer[2048]; + + UserDto outUserDto("DemoWrapper", uAdmin); + auto writed = outUserDto.Write(buffer, sizeof(buffer)); + fprintf(stdout, + "out UserDto(%s, %u) serialized to %lu bytes\n", + outUserDto.Name.Get(), + outUserDto.Role.Get(), + writed); + + UserDto inUserDto; + auto res = inUserDto.TryParse(buffer, writed); + if (res) { + fprintf(stdout, + "in UserDto(%s, %u) deserialized successfully\n", + outUserDto.Name.Get(), + outUserDto.Role.Get()); + } else { + fprintf(stderr, + "in UserDto(%s, %u) deserialized with error\n", + outUserDto.Name.Get(), + outUserDto.Role.Get()); + } + + return 0; } From 10b913b7814b753060c9e794fbde4bcfc6a61d0f Mon Sep 17 00:00:00 2001 From: Vitalii Orazov Date: Tue, 9 Sep 2025 20:46:20 +0300 Subject: [PATCH 6/9] update clang-format --- .clang-format | 50 +- include/MsgpackWrapper.h | 154 ++--- include/lib/LibMsgpack.h | 58 +- src/MsgpackArray.cpp | 1176 +++++++++++++++++------------------ src/MsgpackArrayBase.cpp | 92 +-- src/MsgpackObject.cpp | 188 +++--- src/MsgpackObjectsArray.cpp | 158 ++--- src/MsgpackValue.cpp | 342 +++++----- src/MsgpackValueBase.cpp | 3 +- 9 files changed, 1122 insertions(+), 1099 deletions(-) diff --git a/.clang-format b/.clang-format index bbe6bc1..86f7e5e 100644 --- a/.clang-format +++ b/.clang-format @@ -1,13 +1,37 @@ -{ BasedOnStyle: LLVM, IndentWidth: 4, TabWidth: 4, UseTab: Always, Language: Cpp, AlignConsecutiveAssignments: false, -AlignTrailingComments: true, ColumnLimit: 200, -BreakBeforeTernaryOperators: true, -BreakBeforeBinaryOperators: NonAssignment, -SortIncludes: false, -NamespaceIndentation: All, IndentCaseLabels: true, -AlwaysBreakTemplateDeclarations: Yes, -AllowShortBlocksOnASingleLine: Always, -AllowShortLoopsOnASingleLine: true, -AllowShortFunctionsOnASingleLine: All, -AllowShortIfStatementsOnASingleLine: WithoutElse, -AlwaysBreakTemplateDeclarations: MultiLine, -AlignOperands: AlignAfterOperator } \ No newline at end of file +BasedOnStyle: LLVM +IndentWidth: 4 +TabWidth: 4 +UseTab: Never +Language: Cpp +BreakBeforeBraces: Attach +AlignConsecutiveAssignments: false +AlignTrailingComments: true +CommentPragmas: '[\s\S]*' +ColumnLimit: 200 +BreakBeforeTernaryOperators: true +BreakBeforeBinaryOperators: NonAssignment +SortIncludes: true +NamespaceIndentation: All +IndentCaseLabels: true +AlwaysBreakTemplateDeclarations: MultiLine +AllowShortBlocksOnASingleLine: Always +AllowShortLoopsOnASingleLine: true +AllowShortIfStatementsOnASingleLine: AllIfsAndElse +AllowShortFunctionsOnASingleLine: All +AlignOperands: AlignAfterOperator +SpacesInContainerLiterals: true +SpaceBeforeParens: Custom +Cpp11BracedListStyle: false +AlignConsecutiveMacros: + Enabled: false + AcrossEmptyLines: true + AcrossComments: true +AlignConsecutiveDeclarations: + Enabled: false + AcrossEmptyLines: true + AcrossComments: false + AlignCompound: true +AllowAllParametersOfDeclarationOnNextLine: false +BinPackParameters: false +AllowAllArgumentsOnNextLine: false +BinPackArguments: false \ No newline at end of file diff --git a/include/MsgpackWrapper.h b/include/MsgpackWrapper.h index 0b85743..8e70f93 100644 --- a/include/MsgpackWrapper.h +++ b/include/MsgpackWrapper.h @@ -4,55 +4,55 @@ typedef char TBoolArray; typedef struct { - uint8_t *Data; - size_t Size; + uint8_t *Data; + size_t Size; } TMsgpackRawData; template class MsgpackValue : public MsgpackValueBase { public: - typedef typename std::conditional::value, const char *, typename std::add_const::type>::type ConstT; + typedef typename std::conditional::value, const char *, typename std::add_const::type>::type ConstT; - MsgpackValue(MsgpackFieldsContainer *container, unsigned int id, size_t valueLen, ConstT value) : MsgpackValueBase(container, id) { InitValue(value, valueLen); } - MsgpackValue(MsgpackFieldsContainer *container, unsigned int id, ConstT value = T()) : MsgpackValue(container, id, size_t(), value) {} + MsgpackValue(MsgpackFieldsContainer *container, unsigned int id, size_t valueLen, ConstT value) : MsgpackValueBase(container, id) { InitValue(value, valueLen); } + MsgpackValue(MsgpackFieldsContainer *container, unsigned int id, ConstT value = T()) : MsgpackValue(container, id, size_t(), value) {} - virtual ~MsgpackValue() { DeleteValue(); } + virtual ~MsgpackValue() { DeleteValue(); } - bool TryParse(msgpack_object *deserialized) override final; - bool Write(msgpack_packer *packer) override final; + bool TryParse(msgpack_object *deserialized) override final; + bool Write(msgpack_packer *packer) override final; - bool Equals(MsgpackValueBase *other) override final; - void CloneTo(MsgpackValueBase *other) override final; + bool Equals(MsgpackValueBase *other) override final; + void CloneTo(MsgpackValueBase *other) override final; - ConstT Get() { return value; } + ConstT Get() { return value; } - void Set(ConstT newValue, size_t newValueLen = size_t()); + void Set(ConstT newValue, size_t newValueLen = size_t()); protected: - T value; - void InitValue(ConstT value, size_t valueLen); - void DeleteValue(); + T value; + void InitValue(ConstT value, size_t valueLen); + void DeleteValue(); }; class MsgpackObject : public MsgpackFieldsContainer { public: - virtual ~MsgpackObject(){}; + virtual ~MsgpackObject() {}; - virtual bool TryParse(msgpack_object *deserialized); - virtual bool TryParse(const char *buffer, size_t length); - msgpack_unpacked *BeginTryParse(const char *buffer, size_t length); - void EndTryParse(msgpack_unpacked *unpacked); + virtual bool TryParse(msgpack_object *deserialized); + virtual bool TryParse(const char *buffer, size_t length); + msgpack_unpacked *BeginTryParse(const char *buffer, size_t length); + void EndTryParse(msgpack_unpacked *unpacked); - bool Write(msgpack_packer *packer); - size_t Write(char *outBuffer, size_t outBufferSize); - typedef void (*TOnReady)(void *parent, const char *json, size_t size); - size_t DirectWriteTo(void *parent, TOnReady onReady); + bool Write(msgpack_packer *packer); + size_t Write(char *outBuffer, size_t outBufferSize); + typedef void (*TOnReady)(void *parent, const char *json, size_t size); + size_t DirectWriteTo(void *parent, TOnReady onReady); - virtual bool Validate() { return true; } - virtual bool Equals(MsgpackObject *other); - virtual void CloneTo(MsgpackObject *other); + virtual bool Validate() { return true; } + virtual bool Equals(MsgpackObject *other); + virtual void CloneTo(MsgpackObject *other); - friend bool operator!=(const MsgpackObject &v1, const MsgpackObject &v2); - friend bool operator==(const MsgpackObject &v1, const MsgpackObject &v2); + friend bool operator!=(const MsgpackObject &v1, const MsgpackObject &v2); + friend bool operator==(const MsgpackObject &v1, const MsgpackObject &v2); protected: private: @@ -60,72 +60,72 @@ class MsgpackObject : public MsgpackFieldsContainer { template class MsgpackArray : public MsgpackArrayBase { public: - typedef typename std::conditional::value, const char *, typename std::add_const::type>::type ConstTItem; - virtual ~MsgpackArray() { Clear(); } + typedef typename std::conditional::value, const char *, typename std::add_const::type>::type ConstTItem; + virtual ~MsgpackArray() { Clear(); } - TItem Item(size_t index) { return (TItem)Items[index]; } - size_t Size() { return Items.size(); } - typename std::vector::iterator const Begin() { return Items.begin(); } - typename std::vector::iterator const End() { return Items.end(); } - void Reserve(size_t capacity) { Items.reserve(capacity); } - bool Empty() { return Items.empty(); } + TItem Item(size_t index) { return (TItem)Items[index]; } + size_t Size() { return Items.size(); } + typename std::vector::iterator const Begin() { return Items.begin(); } + typename std::vector::iterator const End() { return Items.end(); } + void Reserve(size_t capacity) { Items.reserve(capacity); } + bool Empty() { return Items.empty(); } - bool TryParseObject(msgpack_object *deserialized) override final; - bool WriteObject(msgpack_packer *packer) override final; + bool TryParseObject(msgpack_object *deserialized) override final; + bool WriteObject(msgpack_packer *packer) override final; - virtual bool Add(ConstTItem item, size_t newValueLen = size_t()); - virtual bool Update(size_t index, ConstTItem item); - virtual bool Remove(ConstTItem item); - typename std::vector::iterator Find(ConstTItem item); + virtual bool Add(ConstTItem item, size_t newValueLen = size_t()); + virtual bool Update(size_t index, ConstTItem item); + virtual bool Remove(ConstTItem item); + typename std::vector::iterator Find(ConstTItem item); - bool Equals(MsgpackArrayBase *other) override; - void CloneTo(MsgpackArrayBase *other) override; - void Clear() override; + bool Equals(MsgpackArrayBase *other) override; + void CloneTo(MsgpackArrayBase *other) override; + void Clear() override; - friend bool operator!=(const MsgpackArray &v1, const MsgpackArray &v2) { return !((MsgpackArray *)&v1)->Equals((MsgpackArray *)&v2); } - friend bool operator==(const MsgpackArray &v1, const MsgpackArray &v2) { return !(v1 != v2); } + friend bool operator!=(const MsgpackArray &v1, const MsgpackArray &v2) { return !((MsgpackArray *)&v1)->Equals((MsgpackArray *)&v2); } + friend bool operator==(const MsgpackArray &v1, const MsgpackArray &v2) { return !(v1 != v2); } protected: - std::vector Items; - virtual bool Validate(ConstTItem item) = 0; - void AddInternal(ConstTItem item, size_t newValueLen = size_t()); - void DeleteItem(ConstTItem item); + std::vector Items; + virtual bool Validate(ConstTItem item) = 0; + void AddInternal(ConstTItem item, size_t newValueLen = size_t()); + void DeleteItem(ConstTItem item); }; class MsgpackObjectsArray : public MsgpackArrayBase { public: - virtual ~MsgpackObjectsArray(); + virtual ~MsgpackObjectsArray(); - template TItem Item(size_t index) { return (TItem)Items[index]; } - size_t Size() { return Items.size(); } - typename std::vector::iterator const Begin() { return Items.begin(); } - typename std::vector::iterator const End() { return Items.end(); } - void Reserve(size_t capacity) { Items.reserve(capacity); } - bool Empty() { return Items.empty(); } + template TItem Item(size_t index) { return (TItem)Items[index]; } + size_t Size() { return Items.size(); } + typename std::vector::iterator const Begin() { return Items.begin(); } + typename std::vector::iterator const End() { return Items.end(); } + void Reserve(size_t capacity) { Items.reserve(capacity); } + bool Empty() { return Items.empty(); } - bool TryParseObject(msgpack_object *deserialized) override final; - bool WriteObject(msgpack_packer *packer) override final; + bool TryParseObject(msgpack_object *deserialized) override final; + bool WriteObject(msgpack_packer *packer) override final; - virtual bool Add(MsgpackObject *item); - virtual bool Update(size_t index, MsgpackObject *item); - virtual bool Remove(MsgpackObject *item); + virtual bool Add(MsgpackObject *item); + virtual bool Update(size_t index, MsgpackObject *item); + virtual bool Remove(MsgpackObject *item); - typename std::vector::iterator Find(MsgpackObject *item); + typename std::vector::iterator Find(MsgpackObject *item); - bool Equals(MsgpackArrayBase *other) override; - void CloneTo(MsgpackArrayBase *other) override; - typename std::vector::iterator MoveTo(MsgpackArrayBase *other, MsgpackObject *item); - void MoveAllTo(MsgpackArrayBase *other); + bool Equals(MsgpackArrayBase *other) override; + void CloneTo(MsgpackArrayBase *other) override; + typename std::vector::iterator MoveTo(MsgpackArrayBase *other, MsgpackObject *item); + void MoveAllTo(MsgpackArrayBase *other); - void Clear() override; - virtual bool Validate(MsgpackObject *item) = 0; - virtual MsgpackObject *CreateItem() = 0; + void Clear() override; + virtual bool Validate(MsgpackObject *item) = 0; + virtual MsgpackObject *CreateItem() = 0; - friend bool operator!=(const MsgpackObjectsArray &v1, const MsgpackObjectsArray &v2); - friend bool operator==(const MsgpackObjectsArray &v1, const MsgpackObjectsArray &v2); + friend bool operator!=(const MsgpackObjectsArray &v1, const MsgpackObjectsArray &v2); + friend bool operator==(const MsgpackObjectsArray &v1, const MsgpackObjectsArray &v2); protected: - std::vector Items; - void AddInternal(MsgpackObject *item); - void DeleteItem(MsgpackObject *item); + std::vector Items; + void AddInternal(MsgpackObject *item); + void DeleteItem(MsgpackObject *item); }; \ No newline at end of file diff --git a/include/lib/LibMsgpack.h b/include/lib/LibMsgpack.h index 4ffa4ee..4908e62 100644 --- a/include/lib/LibMsgpack.h +++ b/include/lib/LibMsgpack.h @@ -1,67 +1,67 @@ #pragma once +#include #include #include #include -#include class MsgpackValueBase; template class MsgpackValue; class MsgpackArrayBase { public: - virtual ~MsgpackArrayBase(){}; + virtual ~MsgpackArrayBase() {}; - virtual bool TryParseObject(msgpack_object *deserialized) = 0; - bool TryParse(const char *buffer, size_t length); - msgpack_unpacked *BeginTryParse(const char *buffer, size_t length); - void EndTryParse(msgpack_unpacked *unpacked); + virtual bool TryParseObject(msgpack_object *deserialized) = 0; + bool TryParse(const char *buffer, size_t length); + msgpack_unpacked *BeginTryParse(const char *buffer, size_t length); + void EndTryParse(msgpack_unpacked *unpacked); - virtual bool WriteObject(msgpack_packer *packer) = 0; - size_t Write(char *outBuffer, size_t outBufferSize); - typedef void (*TOnReady)(void *parent, const char *json, size_t size); - size_t DirectWriteTo(void *parent, TOnReady onReady); + virtual bool WriteObject(msgpack_packer *packer) = 0; + size_t Write(char *outBuffer, size_t outBufferSize); + typedef void (*TOnReady)(void *parent, const char *json, size_t size); + size_t DirectWriteTo(void *parent, TOnReady onReady); - virtual bool Equals(MsgpackArrayBase *other) = 0; - virtual void CloneTo(MsgpackArrayBase *other) = 0; - virtual void Clear() = 0; + virtual bool Equals(MsgpackArrayBase *other) = 0; + virtual void CloneTo(MsgpackArrayBase *other) = 0; + virtual void Clear() = 0; protected: }; class MsgpackIdField { public: - unsigned int Id; - MsgpackIdField(unsigned int id) : Id(id) {} + unsigned int Id; + MsgpackIdField(unsigned int id) : Id(id) {} }; class FieldsCmp { public: - bool operator()(const MsgpackIdField *lfield, const MsgpackIdField *rfield) const { return lfield->Id < rfield->Id; } + bool operator()(const MsgpackIdField *lfield, const MsgpackIdField *rfield) const { return lfield->Id < rfield->Id; } }; class MsgpackFieldsContainer { public: - std::set Fields; - void Add(MsgpackValueBase *field) { Fields.insert(field); } - MsgpackValueBase *GetField(const unsigned int id); + std::set Fields; + void Add(MsgpackValueBase *field) { Fields.insert(field); } + MsgpackValueBase *GetField(const unsigned int id); }; class MsgpackValueBase : public MsgpackIdField { public: - MsgpackValueBase(MsgpackValueBase &&) = delete; - MsgpackValueBase(const MsgpackValueBase &) = delete; + MsgpackValueBase(MsgpackValueBase &&) = delete; + MsgpackValueBase(const MsgpackValueBase &) = delete; - MsgpackValueBase(MsgpackFieldsContainer *container, unsigned int id) : MsgpackIdField(id) { container->Add(this); } - virtual ~MsgpackValueBase(){}; + MsgpackValueBase(MsgpackFieldsContainer *container, unsigned int id) : MsgpackIdField(id) { container->Add(this); } + virtual ~MsgpackValueBase() {}; - virtual bool TryParse(msgpack_object *deserialized) = 0; - virtual bool Write(msgpack_packer *packer) = 0; - virtual bool Equals(MsgpackValueBase *other) = 0; - virtual void CloneTo(MsgpackValueBase *other) = 0; + virtual bool TryParse(msgpack_object *deserialized) = 0; + virtual bool Write(msgpack_packer *packer) = 0; + virtual bool Equals(MsgpackValueBase *other) = 0; + virtual void CloneTo(MsgpackValueBase *other) = 0; - friend bool operator!=(const MsgpackValueBase &v1, const MsgpackValueBase &v2) { return !((MsgpackValueBase *)&v1)->Equals((MsgpackValueBase *)&v2); } - friend bool operator==(const MsgpackValueBase &v1, const MsgpackValueBase &v2) { return !(v1 != v2); } + friend bool operator!=(const MsgpackValueBase &v1, const MsgpackValueBase &v2) { return !((MsgpackValueBase *)&v1)->Equals((MsgpackValueBase *)&v2); } + friend bool operator==(const MsgpackValueBase &v1, const MsgpackValueBase &v2) { return !(v1 != v2); } protected: }; diff --git a/src/MsgpackArray.cpp b/src/MsgpackArray.cpp index 5f40c6c..5c0767a 100644 --- a/src/MsgpackArray.cpp +++ b/src/MsgpackArray.cpp @@ -1,195 +1,195 @@ +#include "MsgpackWrapper.h" #include #include #include -#include "MsgpackWrapper.h" template <> std::vector::iterator MsgpackArray::Find(const char *item) { - for (auto iter = Items.begin(); iter != Items.end(); iter++) { - if (*iter == item) { return iter; } - if (*iter != NULL && item != NULL && strcmp(*iter, item) == 0) { return iter; } - } - return Items.end(); + for (auto iter = Items.begin(); iter != Items.end(); iter++) { + if (*iter == item) { return iter; } + if (*iter != NULL && item != NULL && strcmp(*iter, item) == 0) { return iter; } + } + return Items.end(); } template <> std::vector::iterator MsgpackArray::Find(const TBoolArray item) { - for (auto iter = Items.begin(); iter != Items.end(); iter++) { - if (*iter == item) { return iter; } - } - return Items.end(); + for (auto iter = Items.begin(); iter != Items.end(); iter++) { + if (*iter == item) { return iter; } + } + return Items.end(); } template <> std::vector::iterator MsgpackArray::Find(const int64_t item) { - for (auto iter = Items.begin(); iter != Items.end(); iter++) { - if (*iter == item) { return iter; } - } - return Items.end(); + for (auto iter = Items.begin(); iter != Items.end(); iter++) { + if (*iter == item) { return iter; } + } + return Items.end(); } template <> std::vector::iterator MsgpackArray::Find(const uint64_t item) { - for (auto iter = Items.begin(); iter != Items.end(); iter++) { - if (*iter == item) { return iter; } - } - return Items.end(); + for (auto iter = Items.begin(); iter != Items.end(); iter++) { + if (*iter == item) { return iter; } + } + return Items.end(); } template <> std::vector::iterator MsgpackArray::Find(const int32_t item) { - for (auto iter = Items.begin(); iter != Items.end(); iter++) { - if (*iter == item) { return iter; } - } - return Items.end(); + for (auto iter = Items.begin(); iter != Items.end(); iter++) { + if (*iter == item) { return iter; } + } + return Items.end(); } template <> std::vector::iterator MsgpackArray::Find(const uint32_t item) { - for (auto iter = Items.begin(); iter != Items.end(); iter++) { - if (*iter == item) { return iter; } - } - return Items.end(); + for (auto iter = Items.begin(); iter != Items.end(); iter++) { + if (*iter == item) { return iter; } + } + return Items.end(); } template <> std::vector::iterator MsgpackArray::Find(const int16_t item) { - for (auto iter = Items.begin(); iter != Items.end(); iter++) { - if (*iter == item) { return iter; } - } - return Items.end(); + for (auto iter = Items.begin(); iter != Items.end(); iter++) { + if (*iter == item) { return iter; } + } + return Items.end(); } template <> std::vector::iterator MsgpackArray::Find(const uint16_t item) { - for (auto iter = Items.begin(); iter != Items.end(); iter++) { - if (*iter == item) { return iter; } - } - return Items.end(); + for (auto iter = Items.begin(); iter != Items.end(); iter++) { + if (*iter == item) { return iter; } + } + return Items.end(); } template <> std::vector::iterator MsgpackArray::Find(const int8_t item) { - for (auto iter = Items.begin(); iter != Items.end(); iter++) { - if (*iter == item) { return iter; } - } - return Items.end(); + for (auto iter = Items.begin(); iter != Items.end(); iter++) { + if (*iter == item) { return iter; } + } + return Items.end(); } template <> std::vector::iterator MsgpackArray::Find(const uint8_t item) { - for (auto iter = Items.begin(); iter != Items.end(); iter++) { - if (*iter == item) { return iter; } - } - return Items.end(); + for (auto iter = Items.begin(); iter != Items.end(); iter++) { + if (*iter == item) { return iter; } + } + return Items.end(); } template <> std::vector::iterator MsgpackArray::Find(const double item) { - for (auto iter = Items.begin(); iter != Items.end(); iter++) { - if (*iter == item) { return iter; } - } - return Items.end(); + for (auto iter = Items.begin(); iter != Items.end(); iter++) { + if (*iter == item) { return iter; } + } + return Items.end(); } template <> std::vector::iterator MsgpackArray::Find(const float item) { - for (auto iter = Items.begin(); iter != Items.end(); iter++) { - if (*iter == item) { return iter; } - } - return Items.end(); + for (auto iter = Items.begin(); iter != Items.end(); iter++) { + if (*iter == item) { return iter; } + } + return Items.end(); } /* */ template <> bool MsgpackArray::WriteObject(msgpack_packer *packer) { - if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } - for (const auto &item : Items) { - if (item == NULL) { - if (msgpack_pack_nil(packer) != 0) { return false; } - } else { - auto sLen = strlen(item); - if (msgpack_pack_str(packer, sLen) != 0 // - || msgpack_pack_str_body(packer, item, sLen) != 0) { - return false; - } - } - } - return true; + if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } + for (const auto &item : Items) { + if (item == NULL) { + if (msgpack_pack_nil(packer) != 0) { return false; } + } else { + auto sLen = strlen(item); + if (msgpack_pack_str(packer, sLen) != 0 // + || msgpack_pack_str_body(packer, item, sLen) != 0) { + return false; + } + } + } + return true; } template <> bool MsgpackArray::WriteObject(msgpack_packer *packer) { - if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } - for (const auto &item : Items) { - if (((bool)item ? msgpack_pack_true(packer) : msgpack_pack_false(packer)) != 0) { return false; } - } - return true; + if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } + for (const auto &item : Items) { + if (((bool)item ? msgpack_pack_true(packer) : msgpack_pack_false(packer)) != 0) { return false; } + } + return true; } template <> bool MsgpackArray::WriteObject(msgpack_packer *packer) { - if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } - for (const auto &item : Items) { - if (msgpack_pack_int64(packer, item) != 0) { return false; } - } - return true; + if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } + for (const auto &item : Items) { + if (msgpack_pack_int64(packer, item) != 0) { return false; } + } + return true; } template <> bool MsgpackArray::WriteObject(msgpack_packer *packer) { - if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } - for (const auto &item : Items) { - if (msgpack_pack_uint64(packer, item) != 0) { return false; } - } - return true; + if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } + for (const auto &item : Items) { + if (msgpack_pack_uint64(packer, item) != 0) { return false; } + } + return true; } template <> bool MsgpackArray::WriteObject(msgpack_packer *packer) { - if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } - for (const auto &item : Items) { - if (msgpack_pack_int32(packer, item) != 0) { return false; } - } - return true; + if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } + for (const auto &item : Items) { + if (msgpack_pack_int32(packer, item) != 0) { return false; } + } + return true; } template <> bool MsgpackArray::WriteObject(msgpack_packer *packer) { - if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } - for (const auto &item : Items) { - if (msgpack_pack_uint32(packer, item) != 0) { return false; } - } - return true; + if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } + for (const auto &item : Items) { + if (msgpack_pack_uint32(packer, item) != 0) { return false; } + } + return true; } template <> bool MsgpackArray::WriteObject(msgpack_packer *packer) { - if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } - for (const auto &item : Items) { - if (msgpack_pack_int16(packer, item) != 0) { return false; } - } - return true; + if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } + for (const auto &item : Items) { + if (msgpack_pack_int16(packer, item) != 0) { return false; } + } + return true; } template <> bool MsgpackArray::WriteObject(msgpack_packer *packer) { - if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } - for (const auto &item : Items) { - if (msgpack_pack_uint16(packer, item) != 0) { return false; } - } - return true; + if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } + for (const auto &item : Items) { + if (msgpack_pack_uint16(packer, item) != 0) { return false; } + } + return true; } template <> bool MsgpackArray::WriteObject(msgpack_packer *packer) { - if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } - for (const auto &item : Items) { - if (msgpack_pack_int8(packer, item) != 0) { return false; } - } - return true; + if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } + for (const auto &item : Items) { + if (msgpack_pack_int8(packer, item) != 0) { return false; } + } + return true; } template <> bool MsgpackArray::WriteObject(msgpack_packer *packer) { - if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } - for (const auto &item : Items) { - if (msgpack_pack_uint8(packer, item) != 0) { return false; } - } - return true; + if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } + for (const auto &item : Items) { + if (msgpack_pack_uint8(packer, item) != 0) { return false; } + } + return true; } template <> bool MsgpackArray::WriteObject(msgpack_packer *packer) { - if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } - for (const auto &item : Items) { - if (msgpack_pack_double(packer, item) != 0) { return false; } - } - return true; + if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } + for (const auto &item : Items) { + if (msgpack_pack_double(packer, item) != 0) { return false; } + } + return true; } template <> bool MsgpackArray::WriteObject(msgpack_packer *packer) { - if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } - for (const auto &item : Items) { - if (msgpack_pack_float(packer, item) != 0) { return false; } - } - return true; + if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } + for (const auto &item : Items) { + if (msgpack_pack_float(packer, item) != 0) { return false; } + } + return true; } /* */ template <> void MsgpackArray::AddInternal(const char *item, size_t newValueLen) { - if (item == NULL) { - Items.push_back((char *)item); - } else { - size_t len = newValueLen != size_t() // - ? newValueLen // - : strlen(item); - auto newItem = new char[len + 1]; - memcpy(newItem, item, len); - newItem[len] = 0; - Items.push_back(newItem); - } + if (item == NULL) { + Items.push_back((char *)item); + } else { + size_t len = newValueLen != size_t() // + ? newValueLen // + : strlen(item); + auto newItem = new char[len + 1]; + memcpy(newItem, item, len); + newItem[len] = 0; + Items.push_back(newItem); + } } template <> void MsgpackArray::AddInternal(const TBoolArray item, size_t newValueLen) { Items.push_back(item); } template <> void MsgpackArray::AddInternal(const int64_t item, size_t newValueLen) { Items.push_back(item); } @@ -207,64 +207,64 @@ template <> void MsgpackArray::AddInternal(const float item, size_t newVa */ template <> bool MsgpackArray::Add(const char *item, size_t newValueLen) { - if (!Validate(item)) { return false; } - AddInternal(item, newValueLen); - return true; + if (!Validate(item)) { return false; } + AddInternal(item, newValueLen); + return true; } template <> bool MsgpackArray::Add(const TBoolArray item, size_t newValueLen) { - if (!Validate(item)) { return false; } - AddInternal(item, newValueLen); - return true; + if (!Validate(item)) { return false; } + AddInternal(item, newValueLen); + return true; } template <> bool MsgpackArray::Add(const int64_t item, size_t newValueLen) { - if (!Validate(item)) { return false; } - AddInternal(item, newValueLen); - return true; + if (!Validate(item)) { return false; } + AddInternal(item, newValueLen); + return true; } template <> bool MsgpackArray::Add(const uint64_t item, size_t newValueLen) { - if (!Validate(item)) { return false; } - AddInternal(item, newValueLen); - return true; + if (!Validate(item)) { return false; } + AddInternal(item, newValueLen); + return true; } template <> bool MsgpackArray::Add(const int32_t item, size_t newValueLen) { - if (!Validate(item)) { return false; } - AddInternal(item, newValueLen); - return true; + if (!Validate(item)) { return false; } + AddInternal(item, newValueLen); + return true; } template <> bool MsgpackArray::Add(const uint32_t item, size_t newValueLen) { - if (!Validate(item)) { return false; } - AddInternal(item, newValueLen); - return true; + if (!Validate(item)) { return false; } + AddInternal(item, newValueLen); + return true; } template <> bool MsgpackArray::Add(const int16_t item, size_t newValueLen) { - if (!Validate(item)) { return false; } - AddInternal(item, newValueLen); - return true; + if (!Validate(item)) { return false; } + AddInternal(item, newValueLen); + return true; } template <> bool MsgpackArray::Add(const uint16_t item, size_t newValueLen) { - if (!Validate(item)) { return false; } - AddInternal(item, newValueLen); - return true; + if (!Validate(item)) { return false; } + AddInternal(item, newValueLen); + return true; } template <> bool MsgpackArray::Add(const int8_t item, size_t newValueLen) { - if (!Validate(item)) { return false; } - AddInternal(item, newValueLen); - return true; + if (!Validate(item)) { return false; } + AddInternal(item, newValueLen); + return true; } template <> bool MsgpackArray::Add(const uint8_t item, size_t newValueLen) { - if (!Validate(item)) { return false; } - AddInternal(item, newValueLen); - return true; + if (!Validate(item)) { return false; } + AddInternal(item, newValueLen); + return true; } template <> bool MsgpackArray::Add(const double item, size_t newValueLen) { - if (!Validate(item)) { return false; } - AddInternal(item, newValueLen); - return true; + if (!Validate(item)) { return false; } + AddInternal(item, newValueLen); + return true; } template <> bool MsgpackArray::Add(const float item, size_t newValueLen) { - if (!Validate(item)) { return false; } - AddInternal(item, newValueLen); - return true; + if (!Validate(item)) { return false; } + AddInternal(item, newValueLen); + return true; } /* @@ -287,590 +287,590 @@ template <> void MsgpackArray::DeleteItem(const float item) {} */ template <> bool MsgpackArray::Remove(const char *item) { - auto iter = Find(item); - if (iter == Items.end()) { return false; } - DeleteItem(*iter); - Items.erase(iter); - return true; + auto iter = Find(item); + if (iter == Items.end()) { return false; } + DeleteItem(*iter); + Items.erase(iter); + return true; } template <> bool MsgpackArray::Remove(const TBoolArray item) { - auto iter = Find(item); - if (iter == Items.end()) { return false; } - DeleteItem(*iter); - Items.erase(iter); - return true; + auto iter = Find(item); + if (iter == Items.end()) { return false; } + DeleteItem(*iter); + Items.erase(iter); + return true; } template <> bool MsgpackArray::Remove(const int64_t item) { - auto iter = Find(item); - if (iter == Items.end()) { return false; } - DeleteItem(*iter); - Items.erase(iter); - return true; + auto iter = Find(item); + if (iter == Items.end()) { return false; } + DeleteItem(*iter); + Items.erase(iter); + return true; } template <> bool MsgpackArray::Remove(const uint64_t item) { - auto iter = Find(item); - if (iter == Items.end()) { return false; } - DeleteItem(*iter); - Items.erase(iter); - return true; + auto iter = Find(item); + if (iter == Items.end()) { return false; } + DeleteItem(*iter); + Items.erase(iter); + return true; } template <> bool MsgpackArray::Remove(const int32_t item) { - auto iter = Find(item); - if (iter == Items.end()) { return false; } - DeleteItem(*iter); - Items.erase(iter); - return true; + auto iter = Find(item); + if (iter == Items.end()) { return false; } + DeleteItem(*iter); + Items.erase(iter); + return true; } template <> bool MsgpackArray::Remove(const uint32_t item) { - auto iter = Find(item); - if (iter == Items.end()) { return false; } - DeleteItem(*iter); - Items.erase(iter); - return true; + auto iter = Find(item); + if (iter == Items.end()) { return false; } + DeleteItem(*iter); + Items.erase(iter); + return true; } template <> bool MsgpackArray::Remove(const int16_t item) { - auto iter = Find(item); - if (iter == Items.end()) { return false; } - DeleteItem(*iter); - Items.erase(iter); - return true; + auto iter = Find(item); + if (iter == Items.end()) { return false; } + DeleteItem(*iter); + Items.erase(iter); + return true; } template <> bool MsgpackArray::Remove(const uint16_t item) { - auto iter = Find(item); - if (iter == Items.end()) { return false; } - DeleteItem(*iter); - Items.erase(iter); - return true; + auto iter = Find(item); + if (iter == Items.end()) { return false; } + DeleteItem(*iter); + Items.erase(iter); + return true; } template <> bool MsgpackArray::Remove(const int8_t item) { - auto iter = Find(item); - if (iter == Items.end()) { return false; } - DeleteItem(*iter); - Items.erase(iter); - return true; + auto iter = Find(item); + if (iter == Items.end()) { return false; } + DeleteItem(*iter); + Items.erase(iter); + return true; } template <> bool MsgpackArray::Remove(const uint8_t item) { - auto iter = Find(item); - if (iter == Items.end()) { return false; } - DeleteItem(*iter); - Items.erase(iter); - return true; + auto iter = Find(item); + if (iter == Items.end()) { return false; } + DeleteItem(*iter); + Items.erase(iter); + return true; } template <> bool MsgpackArray::Remove(const double item) { - auto iter = Find(item); - if (iter == Items.end()) { return false; } - DeleteItem(*iter); - Items.erase(iter); - return true; + auto iter = Find(item); + if (iter == Items.end()) { return false; } + DeleteItem(*iter); + Items.erase(iter); + return true; } template <> bool MsgpackArray::Remove(const float item) { - auto iter = Find(item); - if (iter == Items.end()) { return false; } - DeleteItem(*iter); - Items.erase(iter); - return true; + auto iter = Find(item); + if (iter == Items.end()) { return false; } + DeleteItem(*iter); + Items.erase(iter); + return true; } /* */ template <> bool MsgpackArray::Equals(MsgpackArrayBase *other) { - if (other == NULL) { return false; } - if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } - for (size_t i = 0; i < Items.size(); i++) { - char *s1 = Items[i]; - char *s2 = ((MsgpackArray *)other)->Items[i]; + if (other == NULL) { return false; } + if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } + for (size_t i = 0; i < Items.size(); i++) { + char *s1 = Items[i]; + char *s2 = ((MsgpackArray *)other)->Items[i]; - if (s1 == s2) { continue; } - if (s1 == NULL || s2 == NULL) { return false; } - if (strcmp(s1, s2) != 0) { return false; } - } - return true; + if (s1 == s2) { continue; } + if (s1 == NULL || s2 == NULL) { return false; } + if (strcmp(s1, s2) != 0) { return false; } + } + return true; } template <> bool MsgpackArray::Equals(MsgpackArrayBase *other) { - if (other == NULL) { return false; } - if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } - for (size_t i = 0; i < Items.size(); i++) { - if (Items[i] != ((MsgpackArray *)other)->Items[i]) { return false; } - } - return true; + if (other == NULL) { return false; } + if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } + for (size_t i = 0; i < Items.size(); i++) { + if (Items[i] != ((MsgpackArray *)other)->Items[i]) { return false; } + } + return true; } template <> bool MsgpackArray::Equals(MsgpackArrayBase *other) { - if (other == NULL) { return false; } - if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } - for (size_t i = 0; i < Items.size(); i++) { - if (Items[i] != ((MsgpackArray *)other)->Items[i]) { return false; } - } - return true; + if (other == NULL) { return false; } + if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } + for (size_t i = 0; i < Items.size(); i++) { + if (Items[i] != ((MsgpackArray *)other)->Items[i]) { return false; } + } + return true; } template <> bool MsgpackArray::Equals(MsgpackArrayBase *other) { - if (other == NULL) { return false; } - if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } - for (size_t i = 0; i < Items.size(); i++) { - if (Items[i] != ((MsgpackArray *)other)->Items[i]) { return false; } - } - return true; + if (other == NULL) { return false; } + if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } + for (size_t i = 0; i < Items.size(); i++) { + if (Items[i] != ((MsgpackArray *)other)->Items[i]) { return false; } + } + return true; } template <> bool MsgpackArray::Equals(MsgpackArrayBase *other) { - if (other == NULL) { return false; } - if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } - for (size_t i = 0; i < Items.size(); i++) { - if (Items[i] != ((MsgpackArray *)other)->Items[i]) { return false; } - } - return true; + if (other == NULL) { return false; } + if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } + for (size_t i = 0; i < Items.size(); i++) { + if (Items[i] != ((MsgpackArray *)other)->Items[i]) { return false; } + } + return true; } template <> bool MsgpackArray::Equals(MsgpackArrayBase *other) { - if (other == NULL) { return false; } - if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } - for (size_t i = 0; i < Items.size(); i++) { - if (Items[i] != ((MsgpackArray *)other)->Items[i]) { return false; } - } - return true; + if (other == NULL) { return false; } + if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } + for (size_t i = 0; i < Items.size(); i++) { + if (Items[i] != ((MsgpackArray *)other)->Items[i]) { return false; } + } + return true; } template <> bool MsgpackArray::Equals(MsgpackArrayBase *other) { - if (other == NULL) { return false; } - if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } - for (size_t i = 0; i < Items.size(); i++) { - if (Items[i] != ((MsgpackArray *)other)->Items[i]) { return false; } - } - return true; + if (other == NULL) { return false; } + if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } + for (size_t i = 0; i < Items.size(); i++) { + if (Items[i] != ((MsgpackArray *)other)->Items[i]) { return false; } + } + return true; } template <> bool MsgpackArray::Equals(MsgpackArrayBase *other) { - if (other == NULL) { return false; } - if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } - for (size_t i = 0; i < Items.size(); i++) { - if (Items[i] != ((MsgpackArray *)other)->Items[i]) { return false; } - } - return true; + if (other == NULL) { return false; } + if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } + for (size_t i = 0; i < Items.size(); i++) { + if (Items[i] != ((MsgpackArray *)other)->Items[i]) { return false; } + } + return true; } template <> bool MsgpackArray::Equals(MsgpackArrayBase *other) { - if (other == NULL) { return false; } - if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } - for (size_t i = 0; i < Items.size(); i++) { - if (Items[i] != ((MsgpackArray *)other)->Items[i]) { return false; } - } - return true; + if (other == NULL) { return false; } + if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } + for (size_t i = 0; i < Items.size(); i++) { + if (Items[i] != ((MsgpackArray *)other)->Items[i]) { return false; } + } + return true; } template <> bool MsgpackArray::Equals(MsgpackArrayBase *other) { - if (other == NULL) { return false; } - if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } - for (size_t i = 0; i < Items.size(); i++) { - if (Items[i] != ((MsgpackArray *)other)->Items[i]) { return false; } - } - return true; + if (other == NULL) { return false; } + if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } + for (size_t i = 0; i < Items.size(); i++) { + if (Items[i] != ((MsgpackArray *)other)->Items[i]) { return false; } + } + return true; } template <> bool MsgpackArray::Equals(MsgpackArrayBase *other) { - if (other == NULL) { return false; } - if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } - for (size_t i = 0; i < Items.size(); i++) { - if (Items[i] != ((MsgpackArray *)other)->Items[i]) { return false; } - } - return true; + if (other == NULL) { return false; } + if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } + for (size_t i = 0; i < Items.size(); i++) { + if (Items[i] != ((MsgpackArray *)other)->Items[i]) { return false; } + } + return true; } template <> bool MsgpackArray::Equals(MsgpackArrayBase *other) { - if (other == NULL) { return false; } - if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } - for (size_t i = 0; i < Items.size(); i++) { - if (Items[i] != ((MsgpackArray *)other)->Items[i]) { return false; } - } - return true; + if (other == NULL) { return false; } + if (Items.size() != ((MsgpackArray *)other)->Items.size()) { return false; } + for (size_t i = 0; i < Items.size(); i++) { + if (Items[i] != ((MsgpackArray *)other)->Items[i]) { return false; } + } + return true; } /* */ template <> void MsgpackArray::CloneTo(MsgpackArrayBase *other) { - auto otherArray = ((MsgpackArray *)other); - for (const auto &item : otherArray->Items) { delete[] item; } - otherArray->Items.clear(); - for (const auto &item : Items) { otherArray->AddInternal(item); } + auto otherArray = ((MsgpackArray *)other); + for (const auto &item : otherArray->Items) { delete[] item; } + otherArray->Items.clear(); + for (const auto &item : Items) { otherArray->AddInternal(item); } } template <> void MsgpackArray::CloneTo(MsgpackArrayBase *other) { - auto otherArray = ((MsgpackArray *)other); - otherArray->Items.clear(); - for (const auto &item : Items) { otherArray->AddInternal(item); } + auto otherArray = ((MsgpackArray *)other); + otherArray->Items.clear(); + for (const auto &item : Items) { otherArray->AddInternal(item); } } template <> void MsgpackArray::CloneTo(MsgpackArrayBase *other) { - auto otherArray = ((MsgpackArray *)other); - otherArray->Items.clear(); - for (const auto &item : Items) { otherArray->AddInternal(item); } + auto otherArray = ((MsgpackArray *)other); + otherArray->Items.clear(); + for (const auto &item : Items) { otherArray->AddInternal(item); } } template <> void MsgpackArray::CloneTo(MsgpackArrayBase *other) { - auto otherArray = ((MsgpackArray *)other); - otherArray->Items.clear(); - for (const auto &item : Items) { otherArray->AddInternal(item); } + auto otherArray = ((MsgpackArray *)other); + otherArray->Items.clear(); + for (const auto &item : Items) { otherArray->AddInternal(item); } } template <> void MsgpackArray::CloneTo(MsgpackArrayBase *other) { - auto otherArray = ((MsgpackArray *)other); - otherArray->Items.clear(); - for (const auto &item : Items) { otherArray->AddInternal(item); } + auto otherArray = ((MsgpackArray *)other); + otherArray->Items.clear(); + for (const auto &item : Items) { otherArray->AddInternal(item); } } template <> void MsgpackArray::CloneTo(MsgpackArrayBase *other) { - auto otherArray = ((MsgpackArray *)other); - otherArray->Items.clear(); - for (const auto &item : Items) { otherArray->AddInternal(item); } + auto otherArray = ((MsgpackArray *)other); + otherArray->Items.clear(); + for (const auto &item : Items) { otherArray->AddInternal(item); } } template <> void MsgpackArray::CloneTo(MsgpackArrayBase *other) { - auto otherArray = ((MsgpackArray *)other); - otherArray->Items.clear(); - for (const auto &item : Items) { otherArray->AddInternal(item); } + auto otherArray = ((MsgpackArray *)other); + otherArray->Items.clear(); + for (const auto &item : Items) { otherArray->AddInternal(item); } } template <> void MsgpackArray::CloneTo(MsgpackArrayBase *other) { - auto otherArray = ((MsgpackArray *)other); - otherArray->Items.clear(); - for (const auto &item : Items) { otherArray->AddInternal(item); } + auto otherArray = ((MsgpackArray *)other); + otherArray->Items.clear(); + for (const auto &item : Items) { otherArray->AddInternal(item); } } template <> void MsgpackArray::CloneTo(MsgpackArrayBase *other) { - auto otherArray = ((MsgpackArray *)other); - otherArray->Items.clear(); - for (const auto &item : Items) { otherArray->AddInternal(item); } + auto otherArray = ((MsgpackArray *)other); + otherArray->Items.clear(); + for (const auto &item : Items) { otherArray->AddInternal(item); } } template <> void MsgpackArray::CloneTo(MsgpackArrayBase *other) { - auto otherArray = ((MsgpackArray *)other); - otherArray->Items.clear(); - for (const auto &item : Items) { otherArray->AddInternal(item); } + auto otherArray = ((MsgpackArray *)other); + otherArray->Items.clear(); + for (const auto &item : Items) { otherArray->AddInternal(item); } } template <> void MsgpackArray::CloneTo(MsgpackArrayBase *other) { - auto otherArray = ((MsgpackArray *)other); - otherArray->Items.clear(); - for (const auto &item : Items) { otherArray->AddInternal(item); } + auto otherArray = ((MsgpackArray *)other); + otherArray->Items.clear(); + for (const auto &item : Items) { otherArray->AddInternal(item); } } template <> void MsgpackArray::CloneTo(MsgpackArrayBase *other) { - auto otherArray = ((MsgpackArray *)other); - otherArray->Items.clear(); - for (const auto &item : Items) { otherArray->AddInternal(item); } + auto otherArray = ((MsgpackArray *)other); + otherArray->Items.clear(); + for (const auto &item : Items) { otherArray->AddInternal(item); } } /* */ template <> bool MsgpackArray::Update(size_t index, const char *item) { - if (index >= Size() || !Validate(item)) { return false; } - DeleteItem(Items[index]); - if (item == NULL) { - Items[index] = (char *)item; - } else { - auto len = strlen(item); - auto newItem = new char[len + 1]; - memcpy(newItem, item, len); - newItem[len] = 0; - Items[index] = newItem; - } - return true; + if (index >= Size() || !Validate(item)) { return false; } + DeleteItem(Items[index]); + if (item == NULL) { + Items[index] = (char *)item; + } else { + auto len = strlen(item); + auto newItem = new char[len + 1]; + memcpy(newItem, item, len); + newItem[len] = 0; + Items[index] = newItem; + } + return true; } template <> bool MsgpackArray::Update(size_t index, const TBoolArray item) { - if (index >= Size() || !Validate(item)) { return false; } - DeleteItem(Items[index]); - Items[index] = item; - return true; + if (index >= Size() || !Validate(item)) { return false; } + DeleteItem(Items[index]); + Items[index] = item; + return true; } template <> bool MsgpackArray::Update(size_t index, const int64_t item) { - if (index >= Size() || !Validate(item)) { return false; } - DeleteItem(Items[index]); - Items[index] = item; - return true; + if (index >= Size() || !Validate(item)) { return false; } + DeleteItem(Items[index]); + Items[index] = item; + return true; } template <> bool MsgpackArray::Update(size_t index, const uint64_t item) { - if (index >= Size() || !Validate(item)) { return false; } - DeleteItem(Items[index]); - Items[index] = item; - return true; + if (index >= Size() || !Validate(item)) { return false; } + DeleteItem(Items[index]); + Items[index] = item; + return true; } template <> bool MsgpackArray::Update(size_t index, const int32_t item) { - if (index >= Size() || !Validate(item)) { return false; } - DeleteItem(Items[index]); - Items[index] = item; - return true; + if (index >= Size() || !Validate(item)) { return false; } + DeleteItem(Items[index]); + Items[index] = item; + return true; } template <> bool MsgpackArray::Update(size_t index, const uint32_t item) { - if (index >= Size() || !Validate(item)) { return false; } - DeleteItem(Items[index]); - Items[index] = item; - return true; + if (index >= Size() || !Validate(item)) { return false; } + DeleteItem(Items[index]); + Items[index] = item; + return true; } template <> bool MsgpackArray::Update(size_t index, const int16_t item) { - if (index >= Size() || !Validate(item)) { return false; } - DeleteItem(Items[index]); - Items[index] = item; - return true; + if (index >= Size() || !Validate(item)) { return false; } + DeleteItem(Items[index]); + Items[index] = item; + return true; } template <> bool MsgpackArray::Update(size_t index, const uint16_t item) { - if (index >= Size() || !Validate(item)) { return false; } - DeleteItem(Items[index]); - Items[index] = item; - return true; + if (index >= Size() || !Validate(item)) { return false; } + DeleteItem(Items[index]); + Items[index] = item; + return true; } template <> bool MsgpackArray::Update(size_t index, const int8_t item) { - if (index >= Size() || !Validate(item)) { return false; } - DeleteItem(Items[index]); - Items[index] = item; - return true; + if (index >= Size() || !Validate(item)) { return false; } + DeleteItem(Items[index]); + Items[index] = item; + return true; } template <> bool MsgpackArray::Update(size_t index, const uint8_t item) { - if (index >= Size() || !Validate(item)) { return false; } - DeleteItem(Items[index]); - Items[index] = item; - return true; + if (index >= Size() || !Validate(item)) { return false; } + DeleteItem(Items[index]); + Items[index] = item; + return true; } template <> bool MsgpackArray::Update(size_t index, const double item) { - if (index >= Size() || !Validate(item)) { return false; } - DeleteItem(Items[index]); - Items[index] = item; - return true; + if (index >= Size() || !Validate(item)) { return false; } + DeleteItem(Items[index]); + Items[index] = item; + return true; } template <> bool MsgpackArray::Update(size_t index, const float item) { - if (index >= Size() || !Validate(item)) { return false; } - DeleteItem(Items[index]); - Items[index] = item; - return true; + if (index >= Size() || !Validate(item)) { return false; } + DeleteItem(Items[index]); + Items[index] = item; + return true; } /* */ template <> bool MsgpackArray::TryParseObject(msgpack_object *deserialized) { - if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } - Items.reserve(deserialized->via.array.size); - size_t i = 0; - while (i < deserialized->via.array.size) { - msgpack_object object = deserialized->via.array.ptr[i]; - if (object.type == MSGPACK_OBJECT_NIL) { - if (!Add(NULL)) { break; } - } else if (object.type == MSGPACK_OBJECT_STR) { - if (!Add(object.via.str.ptr, object.via.str.size)) { break; } - } else { - break; - } - i++; - } - Items.shrink_to_fit(); - return i == deserialized->via.array.size; + if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } + Items.reserve(deserialized->via.array.size); + size_t i = 0; + while (i < deserialized->via.array.size) { + msgpack_object object = deserialized->via.array.ptr[i]; + if (object.type == MSGPACK_OBJECT_NIL) { + if (!Add(NULL)) { break; } + } else if (object.type == MSGPACK_OBJECT_STR) { + if (!Add(object.via.str.ptr, object.via.str.size)) { break; } + } else { + break; + } + i++; + } + Items.shrink_to_fit(); + return i == deserialized->via.array.size; } template <> bool MsgpackArray::TryParseObject(msgpack_object *deserialized) { - if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } - Items.reserve(deserialized->via.array.size); - size_t i = 0; - while (i < deserialized->via.array.size) { - msgpack_object object = deserialized->via.array.ptr[i]; - if (object.type == MSGPACK_OBJECT_BOOLEAN) { - if (!Add((TBoolArray)object.via.boolean)) { break; } - } else { - break; - } - i++; - } - Items.shrink_to_fit(); - return i == deserialized->via.array.size; + if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } + Items.reserve(deserialized->via.array.size); + size_t i = 0; + while (i < deserialized->via.array.size) { + msgpack_object object = deserialized->via.array.ptr[i]; + if (object.type == MSGPACK_OBJECT_BOOLEAN) { + if (!Add((TBoolArray)object.via.boolean)) { break; } + } else { + break; + } + i++; + } + Items.shrink_to_fit(); + return i == deserialized->via.array.size; } template <> bool MsgpackArray::TryParseObject(msgpack_object *deserialized) { - if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } - Items.reserve(deserialized->via.array.size); - size_t i = 0; - while (i < deserialized->via.array.size) { - msgpack_object object = deserialized->via.array.ptr[i]; - if (object.type == MSGPACK_OBJECT_NEGATIVE_INTEGER || object.type == MSGPACK_OBJECT_POSITIVE_INTEGER) { - if (!Add(object.via.i64)) { break; } - } else { - break; - } - i++; - } - Items.shrink_to_fit(); - return i == deserialized->via.array.size; + if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } + Items.reserve(deserialized->via.array.size); + size_t i = 0; + while (i < deserialized->via.array.size) { + msgpack_object object = deserialized->via.array.ptr[i]; + if (object.type == MSGPACK_OBJECT_NEGATIVE_INTEGER || object.type == MSGPACK_OBJECT_POSITIVE_INTEGER) { + if (!Add(object.via.i64)) { break; } + } else { + break; + } + i++; + } + Items.shrink_to_fit(); + return i == deserialized->via.array.size; } template <> bool MsgpackArray::TryParseObject(msgpack_object *deserialized) { - if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } - Items.reserve(deserialized->via.array.size); - size_t i = 0; - while (i < deserialized->via.array.size) { - msgpack_object object = deserialized->via.array.ptr[i]; - if (object.type == MSGPACK_OBJECT_NEGATIVE_INTEGER || object.type == MSGPACK_OBJECT_POSITIVE_INTEGER) { - if (!Add(object.via.u64)) { break; } - } else { - break; - } - i++; - } - Items.shrink_to_fit(); - return i == deserialized->via.array.size; + if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } + Items.reserve(deserialized->via.array.size); + size_t i = 0; + while (i < deserialized->via.array.size) { + msgpack_object object = deserialized->via.array.ptr[i]; + if (object.type == MSGPACK_OBJECT_NEGATIVE_INTEGER || object.type == MSGPACK_OBJECT_POSITIVE_INTEGER) { + if (!Add(object.via.u64)) { break; } + } else { + break; + } + i++; + } + Items.shrink_to_fit(); + return i == deserialized->via.array.size; } template <> bool MsgpackArray::TryParseObject(msgpack_object *deserialized) { - if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } - Items.reserve(deserialized->via.array.size); - size_t i = 0; - while (i < deserialized->via.array.size) { - msgpack_object object = deserialized->via.array.ptr[i]; - if (object.type == MSGPACK_OBJECT_NEGATIVE_INTEGER || object.type == MSGPACK_OBJECT_POSITIVE_INTEGER) { - if (!Add((int32_t)object.via.i64)) { break; } - } else { - break; - } - i++; - } - Items.shrink_to_fit(); - return i == deserialized->via.array.size; + if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } + Items.reserve(deserialized->via.array.size); + size_t i = 0; + while (i < deserialized->via.array.size) { + msgpack_object object = deserialized->via.array.ptr[i]; + if (object.type == MSGPACK_OBJECT_NEGATIVE_INTEGER || object.type == MSGPACK_OBJECT_POSITIVE_INTEGER) { + if (!Add((int32_t)object.via.i64)) { break; } + } else { + break; + } + i++; + } + Items.shrink_to_fit(); + return i == deserialized->via.array.size; } template <> bool MsgpackArray::TryParseObject(msgpack_object *deserialized) { - if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } - Items.reserve(deserialized->via.array.size); - size_t i = 0; - while (i < deserialized->via.array.size) { - msgpack_object object = deserialized->via.array.ptr[i]; - if (object.type == MSGPACK_OBJECT_NEGATIVE_INTEGER || object.type == MSGPACK_OBJECT_POSITIVE_INTEGER) { - if (!Add((uint32_t)object.via.u64)) { break; } - } else { - break; - } - i++; - } - Items.shrink_to_fit(); - return i == deserialized->via.array.size; + if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } + Items.reserve(deserialized->via.array.size); + size_t i = 0; + while (i < deserialized->via.array.size) { + msgpack_object object = deserialized->via.array.ptr[i]; + if (object.type == MSGPACK_OBJECT_NEGATIVE_INTEGER || object.type == MSGPACK_OBJECT_POSITIVE_INTEGER) { + if (!Add((uint32_t)object.via.u64)) { break; } + } else { + break; + } + i++; + } + Items.shrink_to_fit(); + return i == deserialized->via.array.size; } template <> bool MsgpackArray::TryParseObject(msgpack_object *deserialized) { - if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } - Items.reserve(deserialized->via.array.size); - size_t i = 0; - while (i < deserialized->via.array.size) { - msgpack_object object = deserialized->via.array.ptr[i]; - if (object.type == MSGPACK_OBJECT_NEGATIVE_INTEGER || object.type == MSGPACK_OBJECT_POSITIVE_INTEGER) { - if (!Add((int16_t)object.via.i64)) { break; } - } else { - break; - } - i++; - } - Items.shrink_to_fit(); - return i == deserialized->via.array.size; + if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } + Items.reserve(deserialized->via.array.size); + size_t i = 0; + while (i < deserialized->via.array.size) { + msgpack_object object = deserialized->via.array.ptr[i]; + if (object.type == MSGPACK_OBJECT_NEGATIVE_INTEGER || object.type == MSGPACK_OBJECT_POSITIVE_INTEGER) { + if (!Add((int16_t)object.via.i64)) { break; } + } else { + break; + } + i++; + } + Items.shrink_to_fit(); + return i == deserialized->via.array.size; } template <> bool MsgpackArray::TryParseObject(msgpack_object *deserialized) { - if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } - Items.reserve(deserialized->via.array.size); - size_t i = 0; - while (i < deserialized->via.array.size) { - msgpack_object object = deserialized->via.array.ptr[i]; - if (object.type == MSGPACK_OBJECT_NEGATIVE_INTEGER || object.type == MSGPACK_OBJECT_POSITIVE_INTEGER) { - if (!Add((uint16_t)object.via.u64)) { break; } - } else { - break; - } - i++; - } - Items.shrink_to_fit(); - return i == deserialized->via.array.size; + if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } + Items.reserve(deserialized->via.array.size); + size_t i = 0; + while (i < deserialized->via.array.size) { + msgpack_object object = deserialized->via.array.ptr[i]; + if (object.type == MSGPACK_OBJECT_NEGATIVE_INTEGER || object.type == MSGPACK_OBJECT_POSITIVE_INTEGER) { + if (!Add((uint16_t)object.via.u64)) { break; } + } else { + break; + } + i++; + } + Items.shrink_to_fit(); + return i == deserialized->via.array.size; } template <> bool MsgpackArray::TryParseObject(msgpack_object *deserialized) { - if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } - Items.reserve(deserialized->via.array.size); - size_t i = 0; - while (i < deserialized->via.array.size) { - msgpack_object object = deserialized->via.array.ptr[i]; - if (object.type == MSGPACK_OBJECT_NEGATIVE_INTEGER || object.type == MSGPACK_OBJECT_POSITIVE_INTEGER) { - if (!Add((int8_t)object.via.i64)) { break; } - } else { - break; - } - i++; - } - Items.shrink_to_fit(); - return i == deserialized->via.array.size; + if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } + Items.reserve(deserialized->via.array.size); + size_t i = 0; + while (i < deserialized->via.array.size) { + msgpack_object object = deserialized->via.array.ptr[i]; + if (object.type == MSGPACK_OBJECT_NEGATIVE_INTEGER || object.type == MSGPACK_OBJECT_POSITIVE_INTEGER) { + if (!Add((int8_t)object.via.i64)) { break; } + } else { + break; + } + i++; + } + Items.shrink_to_fit(); + return i == deserialized->via.array.size; } template <> bool MsgpackArray::TryParseObject(msgpack_object *deserialized) { - if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } - Items.reserve(deserialized->via.array.size); - size_t i = 0; - while (i < deserialized->via.array.size) { - msgpack_object object = deserialized->via.array.ptr[i]; - if (object.type == MSGPACK_OBJECT_NEGATIVE_INTEGER || object.type == MSGPACK_OBJECT_POSITIVE_INTEGER) { - if (!Add((uint8_t)object.via.u64)) { break; } - } else { - break; - } - i++; - } - Items.shrink_to_fit(); - return i == deserialized->via.array.size; + if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } + Items.reserve(deserialized->via.array.size); + size_t i = 0; + while (i < deserialized->via.array.size) { + msgpack_object object = deserialized->via.array.ptr[i]; + if (object.type == MSGPACK_OBJECT_NEGATIVE_INTEGER || object.type == MSGPACK_OBJECT_POSITIVE_INTEGER) { + if (!Add((uint8_t)object.via.u64)) { break; } + } else { + break; + } + i++; + } + Items.shrink_to_fit(); + return i == deserialized->via.array.size; } template <> bool MsgpackArray::TryParseObject(msgpack_object *deserialized) { - if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } - Items.reserve(deserialized->via.array.size); - size_t i = 0; - while (i < deserialized->via.array.size) { - msgpack_object object = deserialized->via.array.ptr[i]; - if (object.type == MSGPACK_OBJECT_FLOAT64) { - if (!Add((double)object.via.f64)) { break; } - } else { - break; - } - i++; - } - Items.shrink_to_fit(); - return i == deserialized->via.array.size; + if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } + Items.reserve(deserialized->via.array.size); + size_t i = 0; + while (i < deserialized->via.array.size) { + msgpack_object object = deserialized->via.array.ptr[i]; + if (object.type == MSGPACK_OBJECT_FLOAT64) { + if (!Add((double)object.via.f64)) { break; } + } else { + break; + } + i++; + } + Items.shrink_to_fit(); + return i == deserialized->via.array.size; } template <> bool MsgpackArray::TryParseObject(msgpack_object *deserialized) { - if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } - Items.reserve(deserialized->via.array.size); - size_t i = 0; - while (i < deserialized->via.array.size) { - msgpack_object object = deserialized->via.array.ptr[i]; - if (object.type == MSGPACK_OBJECT_FLOAT32) { - if (!Add((float)object.via.f64)) { break; } - } else { - break; - } - i++; - } - Items.shrink_to_fit(); - return i == deserialized->via.array.size; + if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } + Items.reserve(deserialized->via.array.size); + size_t i = 0; + while (i < deserialized->via.array.size) { + msgpack_object object = deserialized->via.array.ptr[i]; + if (object.type == MSGPACK_OBJECT_FLOAT32) { + if (!Add((float)object.via.f64)) { break; } + } else { + break; + } + i++; + } + Items.shrink_to_fit(); + return i == deserialized->via.array.size; } /* */ template <> void MsgpackArray::Clear() { - for (const auto &item : Items) { DeleteItem(item); } - Items.clear(); + for (const auto &item : Items) { DeleteItem(item); } + Items.clear(); } template <> void MsgpackArray::Clear() { - for (const auto &item : Items) { DeleteItem(item); } - Items.clear(); + for (const auto &item : Items) { DeleteItem(item); } + Items.clear(); } template <> void MsgpackArray::Clear() { - for (const auto &item : Items) { DeleteItem(item); } - Items.clear(); + for (const auto &item : Items) { DeleteItem(item); } + Items.clear(); } template <> void MsgpackArray::Clear() { - for (const auto &item : Items) { DeleteItem(item); } - Items.clear(); + for (const auto &item : Items) { DeleteItem(item); } + Items.clear(); } template <> void MsgpackArray::Clear() { - for (const auto &item : Items) { DeleteItem(item); } - Items.clear(); + for (const auto &item : Items) { DeleteItem(item); } + Items.clear(); } template <> void MsgpackArray::Clear() { - for (const auto &item : Items) { DeleteItem(item); } - Items.clear(); + for (const auto &item : Items) { DeleteItem(item); } + Items.clear(); } template <> void MsgpackArray::Clear() { - for (const auto &item : Items) { DeleteItem(item); } - Items.clear(); + for (const auto &item : Items) { DeleteItem(item); } + Items.clear(); } template <> void MsgpackArray::Clear() { - for (const auto &item : Items) { DeleteItem(item); } - Items.clear(); + for (const auto &item : Items) { DeleteItem(item); } + Items.clear(); } template <> void MsgpackArray::Clear() { - for (const auto &item : Items) { DeleteItem(item); } - Items.clear(); + for (const auto &item : Items) { DeleteItem(item); } + Items.clear(); } template <> void MsgpackArray::Clear() { - for (const auto &item : Items) { DeleteItem(item); } - Items.clear(); + for (const auto &item : Items) { DeleteItem(item); } + Items.clear(); } template <> void MsgpackArray::Clear() { - for (const auto &item : Items) { DeleteItem(item); } - Items.clear(); + for (const auto &item : Items) { DeleteItem(item); } + Items.clear(); } template <> void MsgpackArray::Clear() { - for (const auto &item : Items) { DeleteItem(item); } - Items.clear(); + for (const auto &item : Items) { DeleteItem(item); } + Items.clear(); } \ No newline at end of file diff --git a/src/MsgpackArrayBase.cpp b/src/MsgpackArrayBase.cpp index 0fa4fd0..f40c51d 100644 --- a/src/MsgpackArrayBase.cpp +++ b/src/MsgpackArrayBase.cpp @@ -1,72 +1,72 @@ +#include "MsgpackWrapper.h" #include #include #include -#include "MsgpackWrapper.h" bool MsgpackArrayBase::TryParse(const char *buffer, size_t length) { - auto unpacker = BeginTryParse(buffer, length); - if (unpacker == NULL) { return false; } - EndTryParse(unpacker); - return true; + auto unpacker = BeginTryParse(buffer, length); + if (unpacker == NULL) { return false; } + EndTryParse(unpacker); + return true; } msgpack_unpacked *MsgpackArrayBase::BeginTryParse(const char *buffer, size_t length) { - if (buffer == NULL) { return NULL; } + if (buffer == NULL) { return NULL; } - msgpack_unpacked *unpacked = new msgpack_unpacked(); - msgpack_unpacked_init(unpacked); - msgpack_unpack_return ret = msgpack_unpack_next(unpacked, buffer, length, NULL); + msgpack_unpacked *unpacked = new msgpack_unpacked(); + msgpack_unpacked_init(unpacked); + msgpack_unpack_return ret = msgpack_unpack_next(unpacked, buffer, length, NULL); - if (ret != MSGPACK_UNPACK_SUCCESS) { - EndTryParse(unpacked); - return NULL; - } - if (!TryParseObject(&unpacked->data)) { - EndTryParse(unpacked); - return NULL; - } - return unpacked; + if (ret != MSGPACK_UNPACK_SUCCESS) { + EndTryParse(unpacked); + return NULL; + } + if (!TryParseObject(&unpacked->data)) { + EndTryParse(unpacked); + return NULL; + } + return unpacked; } void MsgpackArrayBase::EndTryParse(msgpack_unpacked *unpacked) { - msgpack_unpacked_destroy(unpacked); - delete unpacked; + msgpack_unpacked_destroy(unpacked); + delete unpacked; } size_t MsgpackArrayBase::Write(char *outBuffer, size_t outBufferSize) { - msgpack_sbuffer sbuf; - msgpack_packer packer; - msgpack_sbuffer_init(&sbuf); - msgpack_packer_init(&packer, &sbuf, msgpack_sbuffer_write); + msgpack_sbuffer sbuf; + msgpack_packer packer; + msgpack_sbuffer_init(&sbuf); + msgpack_packer_init(&packer, &sbuf, msgpack_sbuffer_write); - if (!WriteObject(&packer)) { - msgpack_sbuffer_destroy(&sbuf); - return 0; - }; + if (!WriteObject(&packer)) { + msgpack_sbuffer_destroy(&sbuf); + return 0; + }; - if (sbuf.size > outBufferSize) { - msgpack_sbuffer_destroy(&sbuf); - return 0; - } - memcpy(outBuffer, sbuf.data, sbuf.size); + if (sbuf.size > outBufferSize) { + msgpack_sbuffer_destroy(&sbuf); + return 0; + } + memcpy(outBuffer, sbuf.data, sbuf.size); - msgpack_sbuffer_destroy(&sbuf); - return sbuf.size; + msgpack_sbuffer_destroy(&sbuf); + return sbuf.size; } size_t MsgpackArrayBase::DirectWriteTo(void *parent, TOnReady onReady) { - msgpack_sbuffer sbuf; - msgpack_packer packer; - msgpack_sbuffer_init(&sbuf); - msgpack_packer_init(&packer, &sbuf, msgpack_sbuffer_write); + msgpack_sbuffer sbuf; + msgpack_packer packer; + msgpack_sbuffer_init(&sbuf); + msgpack_packer_init(&packer, &sbuf, msgpack_sbuffer_write); - if (!WriteObject(&packer)) { - msgpack_sbuffer_destroy(&sbuf); - return 0; - }; + if (!WriteObject(&packer)) { + msgpack_sbuffer_destroy(&sbuf); + return 0; + }; - onReady(parent, sbuf.data, sbuf.size); - msgpack_sbuffer_destroy(&sbuf); - return sbuf.size; + onReady(parent, sbuf.data, sbuf.size); + msgpack_sbuffer_destroy(&sbuf); + return sbuf.size; } \ No newline at end of file diff --git a/src/MsgpackObject.cpp b/src/MsgpackObject.cpp index b517114..53bd837 100644 --- a/src/MsgpackObject.cpp +++ b/src/MsgpackObject.cpp @@ -1,131 +1,131 @@ +#include "MsgpackWrapper.h" #include #include #include -#include "MsgpackWrapper.h" MsgpackValueBase *MsgpackFieldsContainer::GetField(const unsigned int id) { - for (auto item = Fields.begin(); item != Fields.end(); item++) { - auto field = *item; - if (field->Id == id) { return field; } - } - return NULL; + for (auto item = Fields.begin(); item != Fields.end(); item++) { + auto field = *item; + if (field->Id == id) { return field; } + } + return NULL; } bool MsgpackObject::TryParse(msgpack_object *deserialized) { - if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } - if (deserialized->via.array.size != Fields.size()) { return false; } - - for (auto item = Fields.begin(); item != Fields.end(); item++) { - auto field = *item; - if (!field->TryParse(deserialized)) { return false; } - } - if (!this->Validate()) { return false; } - return true; + if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } + if (deserialized->via.array.size != Fields.size()) { return false; } + + for (auto item = Fields.begin(); item != Fields.end(); item++) { + auto field = *item; + if (!field->TryParse(deserialized)) { return false; } + } + if (!this->Validate()) { return false; } + return true; } msgpack_unpacked *MsgpackObject::BeginTryParse(const char *buffer, size_t length) { - if (buffer == NULL) { return NULL; } - - msgpack_unpacked *unpacked = new msgpack_unpacked(); - msgpack_unpacked_init(unpacked); - msgpack_unpack_return ret = msgpack_unpack_next(unpacked, buffer, length, NULL); - - if (ret != MSGPACK_UNPACK_SUCCESS) { - EndTryParse(unpacked); - return NULL; - } - if (!TryParse(&unpacked->data)) { - EndTryParse(unpacked); - return NULL; - } - return unpacked; + if (buffer == NULL) { return NULL; } + + msgpack_unpacked *unpacked = new msgpack_unpacked(); + msgpack_unpacked_init(unpacked); + msgpack_unpack_return ret = msgpack_unpack_next(unpacked, buffer, length, NULL); + + if (ret != MSGPACK_UNPACK_SUCCESS) { + EndTryParse(unpacked); + return NULL; + } + if (!TryParse(&unpacked->data)) { + EndTryParse(unpacked); + return NULL; + } + return unpacked; } void MsgpackObject::EndTryParse(msgpack_unpacked *unpacked) { - msgpack_unpacked_destroy(unpacked); - delete unpacked; + msgpack_unpacked_destroy(unpacked); + delete unpacked; } bool MsgpackObject::TryParse(const char *buffer, size_t length) { - auto unpacker = BeginTryParse(buffer, length); - if (unpacker == NULL) { return false; } - EndTryParse(unpacker); - return true; + auto unpacker = BeginTryParse(buffer, length); + if (unpacker == NULL) { return false; } + EndTryParse(unpacker); + return true; } bool MsgpackObject::Write(msgpack_packer *packer) { - msgpack_pack_array(packer, Fields.size()); - for (const auto &field : Fields) { - if (!field->Write(packer)) { return false; }; - } - return true; + msgpack_pack_array(packer, Fields.size()); + for (const auto &field : Fields) { + if (!field->Write(packer)) { return false; }; + } + return true; } size_t MsgpackObject::Write(char *outBuffer, size_t outBufferSize) { - msgpack_sbuffer sbuf; - msgpack_packer packer; - msgpack_sbuffer_init(&sbuf); - msgpack_packer_init(&packer, &sbuf, msgpack_sbuffer_write); - - if (!Write(&packer)) { - msgpack_sbuffer_destroy(&sbuf); - return 0; - }; - - if (sbuf.size > outBufferSize) { - msgpack_sbuffer_destroy(&sbuf); - return 0; - } - memcpy(outBuffer, sbuf.data, sbuf.size); - - msgpack_sbuffer_destroy(&sbuf); - return sbuf.size; + msgpack_sbuffer sbuf; + msgpack_packer packer; + msgpack_sbuffer_init(&sbuf); + msgpack_packer_init(&packer, &sbuf, msgpack_sbuffer_write); + + if (!Write(&packer)) { + msgpack_sbuffer_destroy(&sbuf); + return 0; + }; + + if (sbuf.size > outBufferSize) { + msgpack_sbuffer_destroy(&sbuf); + return 0; + } + memcpy(outBuffer, sbuf.data, sbuf.size); + + msgpack_sbuffer_destroy(&sbuf); + return sbuf.size; } size_t MsgpackObject::DirectWriteTo(void *parent, TOnReady onReady) { - msgpack_sbuffer sbuf; - msgpack_packer packer; - msgpack_sbuffer_init(&sbuf); - msgpack_packer_init(&packer, &sbuf, msgpack_sbuffer_write); - - if (!Write(&packer)) { - msgpack_sbuffer_destroy(&sbuf); - return 0; - }; - - onReady(parent, sbuf.data, sbuf.size); - msgpack_sbuffer_destroy(&sbuf); - return sbuf.size; + msgpack_sbuffer sbuf; + msgpack_packer packer; + msgpack_sbuffer_init(&sbuf); + msgpack_packer_init(&packer, &sbuf, msgpack_sbuffer_write); + + if (!Write(&packer)) { + msgpack_sbuffer_destroy(&sbuf); + return 0; + }; + + onReady(parent, sbuf.data, sbuf.size); + msgpack_sbuffer_destroy(&sbuf); + return sbuf.size; } bool operator!=(const MsgpackObject &v1, const MsgpackObject &v2) { return !((MsgpackObject *)&v1)->Equals((MsgpackObject *)&v2); } bool operator==(const MsgpackObject &v1, const MsgpackObject &v2) { return !(v1 != v2); } bool MsgpackObject::Equals(MsgpackObject *other) { - if (other == NULL) { return false; } - if (Fields.size() != other->Fields.size()) { return false; } - - auto item = Fields.begin(); - auto otherItem = other->Fields.begin(); - while (item != Fields.end() && otherItem != other->Fields.end()) { - auto field = *item; - auto otherField = *otherItem; - if (!field->Equals(otherField)) { return false; } - item++; - otherItem++; - } - return true; + if (other == NULL) { return false; } + if (Fields.size() != other->Fields.size()) { return false; } + + auto item = Fields.begin(); + auto otherItem = other->Fields.begin(); + while (item != Fields.end() && otherItem != other->Fields.end()) { + auto field = *item; + auto otherField = *otherItem; + if (!field->Equals(otherField)) { return false; } + item++; + otherItem++; + } + return true; } void MsgpackObject::CloneTo(MsgpackObject *other) { - auto item = Fields.begin(); - auto otherItem = other->Fields.begin(); - while (item != Fields.end() && otherItem != other->Fields.end()) { - auto field = *item; - auto otherField = *otherItem; - field->CloneTo(otherField); - item++; - otherItem++; - } + auto item = Fields.begin(); + auto otherItem = other->Fields.begin(); + while (item != Fields.end() && otherItem != other->Fields.end()) { + auto field = *item; + auto otherField = *otherItem; + field->CloneTo(otherField); + item++; + otherItem++; + } } \ No newline at end of file diff --git a/src/MsgpackObjectsArray.cpp b/src/MsgpackObjectsArray.cpp index bbd5496..42f6140 100644 --- a/src/MsgpackObjectsArray.cpp +++ b/src/MsgpackObjectsArray.cpp @@ -1,125 +1,125 @@ +#include "MsgpackWrapper.h" #include #include #include -#include "MsgpackWrapper.h" MsgpackObjectsArray::~MsgpackObjectsArray() { - for (const auto &item : Items) { DeleteItem(item); } + for (const auto &item : Items) { DeleteItem(item); } } bool MsgpackObjectsArray::TryParseObject(msgpack_object *deserialized) { - if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } - Items.reserve(deserialized->via.array.size); - size_t i = 0; - while (i < deserialized->via.array.size) { - msgpack_object object = deserialized->via.array.ptr[i]; - if (object.type != MSGPACK_OBJECT_ARRAY) { break; } - - auto newItem = CreateItem(); - if (!newItem->TryParse(&object) || !Add(newItem)) { - delete newItem; - break; - } - i++; - } - Items.shrink_to_fit(); - return i == deserialized->via.array.size; + if (deserialized->type != MSGPACK_OBJECT_ARRAY) { return false; } + Items.reserve(deserialized->via.array.size); + size_t i = 0; + while (i < deserialized->via.array.size) { + msgpack_object object = deserialized->via.array.ptr[i]; + if (object.type != MSGPACK_OBJECT_ARRAY) { break; } + + auto newItem = CreateItem(); + if (!newItem->TryParse(&object) || !Add(newItem)) { + delete newItem; + break; + } + i++; + } + Items.shrink_to_fit(); + return i == deserialized->via.array.size; } bool MsgpackObjectsArray::Add(MsgpackObject *item) { - if (!Validate(item)) { return false; } - AddInternal(item); - return true; + if (!Validate(item)) { return false; } + AddInternal(item); + return true; } void MsgpackObjectsArray::AddInternal(MsgpackObject *item) { Items.push_back(item); } bool MsgpackObjectsArray::Update(size_t index, MsgpackObject *item) { - if (index >= Size() || !Validate(item)) { return false; } - DeleteItem(Items[index]); - Items[index] = item; - return true; + if (index >= Size() || !Validate(item)) { return false; } + DeleteItem(Items[index]); + Items[index] = item; + return true; } bool MsgpackObjectsArray::Remove(MsgpackObject *item) { - auto iter = Find(item); - if (iter == Items.end()) { return false; } - DeleteItem(*iter); - Items.erase(iter); - return true; + auto iter = Find(item); + if (iter == Items.end()) { return false; } + DeleteItem(*iter); + Items.erase(iter); + return true; } std::vector::iterator MsgpackObjectsArray::Find(MsgpackObject *item) { - if (item != NULL) { - for (auto iter = Items.begin(); iter != Items.end(); iter++) { - if (*(*iter) == *item) { return iter; } - } - } - return Items.end(); + if (item != NULL) { + for (auto iter = Items.begin(); iter != Items.end(); iter++) { + if (*(*iter) == *item) { return iter; } + } + } + return Items.end(); } void MsgpackObjectsArray::DeleteItem(MsgpackObject *item) { delete item; } bool MsgpackObjectsArray::WriteObject(msgpack_packer *packer) { - if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } - for (const auto &item : Items) { - if (!item->Write(packer)) { return false; } - } - return true; + if (msgpack_pack_array(packer, Items.size()) != 0) { return false; } + for (const auto &item : Items) { + if (!item->Write(packer)) { return false; } + } + return true; } bool operator!=(const MsgpackObjectsArray &v1, const MsgpackObjectsArray &v2) { return !((MsgpackObjectsArray *)&v1)->Equals((MsgpackObjectsArray *)&v2); } bool operator==(const MsgpackObjectsArray &v1, const MsgpackObjectsArray &v2) { return !(v1 != v2); } bool MsgpackObjectsArray::Equals(MsgpackArrayBase *other) { - if (other == NULL) { return false; } - if (Items.size() != ((MsgpackObjectsArray *)other)->Items.size()) { return false; } - for (size_t i = 0; i < Items.size(); i++) { - if (*(Items[i]) != *(((MsgpackObjectsArray *)other)->Items[i])) { return false; } - } - return true; + if (other == NULL) { return false; } + if (Items.size() != ((MsgpackObjectsArray *)other)->Items.size()) { return false; } + for (size_t i = 0; i < Items.size(); i++) { + if (*(Items[i]) != *(((MsgpackObjectsArray *)other)->Items[i])) { return false; } + } + return true; } void MsgpackObjectsArray::CloneTo(MsgpackArrayBase *other) { - auto otherArray = ((MsgpackObjectsArray *)other); - for (const auto &item : otherArray->Items) { delete item; } - otherArray->Items.clear(); - - for (const auto &item : Items) { - auto newItem = CreateItem(); - item->CloneTo(newItem); - otherArray->AddInternal(newItem); - } + auto otherArray = ((MsgpackObjectsArray *)other); + for (const auto &item : otherArray->Items) { delete item; } + otherArray->Items.clear(); + + for (const auto &item : Items) { + auto newItem = CreateItem(); + item->CloneTo(newItem); + otherArray->AddInternal(newItem); + } } typename std::vector::iterator MsgpackObjectsArray::MoveTo(MsgpackArrayBase *other, MsgpackObject *item) { - auto otherArray = ((MsgpackObjectsArray *)other); - auto iter = std::find(Items.begin(), Items.end(), item); - if (iter != Items.end()) { - if (otherArray->Validate(*iter)) { - otherArray->AddInternal(*iter); - iter = Items.erase(iter); - } else { - iter++; - } - } - return iter; + auto otherArray = ((MsgpackObjectsArray *)other); + auto iter = std::find(Items.begin(), Items.end(), item); + if (iter != Items.end()) { + if (otherArray->Validate(*iter)) { + otherArray->AddInternal(*iter); + iter = Items.erase(iter); + } else { + iter++; + } + } + return iter; } void MsgpackObjectsArray::MoveAllTo(MsgpackArrayBase *other) { - auto otherArray = ((MsgpackObjectsArray *)other); - auto iter = Items.begin(); - while (iter != Items.end()) { - if (otherArray->Validate(*iter)) { - otherArray->AddInternal(*iter); - iter = Items.erase(iter); - } else { - iter++; - } - } + auto otherArray = ((MsgpackObjectsArray *)other); + auto iter = Items.begin(); + while (iter != Items.end()) { + if (otherArray->Validate(*iter)) { + otherArray->AddInternal(*iter); + iter = Items.erase(iter); + } else { + iter++; + } + } } void MsgpackObjectsArray::Clear() { - for (const auto &item : Items) { DeleteItem(item); } - Items.clear(); + for (const auto &item : Items) { DeleteItem(item); } + Items.clear(); } \ No newline at end of file diff --git a/src/MsgpackValue.cpp b/src/MsgpackValue.cpp index 1087871..b2921b5 100644 --- a/src/MsgpackValue.cpp +++ b/src/MsgpackValue.cpp @@ -1,8 +1,8 @@ +#include "MsgpackWrapper.h" #include #include #include -#include "MsgpackWrapper.h" template <> bool MsgpackValue::Equals(MsgpackValueBase *other) { return other != NULL && Id == other->Id && value == ((MsgpackValue *)other)->value; } template <> bool MsgpackValue::Equals(MsgpackValueBase *other) { return other != NULL && Id == other->Id && value == ((MsgpackValue *)other)->value; } @@ -16,19 +16,19 @@ template <> bool MsgpackValue::Equals(MsgpackValueBase *other) { retur template <> bool MsgpackValue::Equals(MsgpackValueBase *other) { return other != NULL && Id == other->Id && value == ((MsgpackValue *)other)->value; } template <> bool MsgpackValue::Equals(MsgpackValueBase *other) { return other != NULL && Id == other->Id && value == ((MsgpackValue *)other)->value; } template <> bool MsgpackValue::Equals(MsgpackValueBase *other) { // - return other != NULL && Id == other->Id - && (value == ((MsgpackValue *)other)->value // - || (value != NULL && ((MsgpackValue *)other)->value != NULL && strcmp(value, ((MsgpackValue *)other)->value) == 0)); + return other != NULL && Id == other->Id + && (value == ((MsgpackValue *)other)->value // + || (value != NULL && ((MsgpackValue *)other)->value != NULL && strcmp(value, ((MsgpackValue *)other)->value) == 0)); } template <> bool MsgpackValue::Equals(MsgpackValueBase *other) { - return other != NULL && Id == other->Id && ((TMsgpackRawData)value).Data == ((TMsgpackRawData)(((MsgpackValue *)other)->value)).Data // - && ((TMsgpackRawData)value).Size == ((TMsgpackRawData)(((MsgpackValue *)other)->value)).Size; + return other != NULL && Id == other->Id && ((TMsgpackRawData)value).Data == ((TMsgpackRawData)(((MsgpackValue *)other)->value)).Data // + && ((TMsgpackRawData)value).Size == ((TMsgpackRawData)(((MsgpackValue *)other)->value)).Size; } template <> bool MsgpackValue::Equals(MsgpackValueBase *other) { - return other != NULL && Id == other->Id && (MsgpackObject *)value->Equals((MsgpackObject *)((MsgpackValue *)other)->value); + return other != NULL && Id == other->Id && (MsgpackObject *)value->Equals((MsgpackObject *)((MsgpackValue *)other)->value); } template <> bool MsgpackValue::Equals(MsgpackValueBase *other) { - return other != NULL && Id == other->Id && (MsgpackObject *)value->Equals((MsgpackArrayBase *)(((MsgpackValue *)other)->value)); + return other != NULL && Id == other->Id && (MsgpackObject *)value->Equals((MsgpackArrayBase *)(((MsgpackValue *)other)->value)); } /* @@ -46,21 +46,21 @@ template <> bool MsgpackValue::Write(msgpack_packer *packer) { return template <> bool MsgpackValue::Write(msgpack_packer *packer) { return msgpack_pack_float(packer, value) == 0; } template <> bool MsgpackValue::Write(msgpack_packer *packer) { return msgpack_pack_double(packer, value) == 0; } template <> bool MsgpackValue::Write(msgpack_packer *packer) { - if (value == NULL) { - return msgpack_pack_nil(packer) == 0; - } else { - auto sLen = strlen(value); - return msgpack_pack_str(packer, sLen) == 0 // - && msgpack_pack_str_body(packer, value, sLen) == 0; - } + if (value == NULL) { + return msgpack_pack_nil(packer) == 0; + } else { + auto sLen = strlen(value); + return msgpack_pack_str(packer, sLen) == 0 // + && msgpack_pack_str_body(packer, value, sLen) == 0; + } } template <> bool MsgpackValue::Write(msgpack_packer *packer) { - if (value.Data == NULL) { - return msgpack_pack_nil(packer) == 0; - } else { - return msgpack_pack_v4raw(packer, value.Size) == 0 // - && msgpack_pack_v4raw_body(packer, value.Data, value.Size) == 0; - } + if (value.Data == NULL) { + return msgpack_pack_nil(packer) == 0; + } else { + return msgpack_pack_v4raw(packer, value.Size) == 0 // + && msgpack_pack_v4raw_body(packer, value.Data, value.Size) == 0; + } } template <> bool MsgpackValue::Write(msgpack_packer *packer) { return value->Write(packer); } template <> bool MsgpackValue::Write(msgpack_packer *packer) { return value->WriteObject(packer); } @@ -99,16 +99,16 @@ template <> void MsgpackValue::InitValue(const uint64_t value, size_t template <> void MsgpackValue::InitValue(const float value, size_t valueLen) { this->value = value; } template <> void MsgpackValue::InitValue(const double value, size_t valueLen) { this->value = value; } template <> void MsgpackValue::InitValue(const char *value, size_t valueLen) { - if (value == NULL) { - this->value = NULL; - } else { - size_t len = valueLen != size_t() // - ? valueLen // - : strlen(value); - this->value = new char[len + 1]; - memcpy(this->value, value, len); - this->value[len] = 0; - } + if (value == NULL) { + this->value = NULL; + } else { + size_t len = valueLen != size_t() // + ? valueLen // + : strlen(value); + this->value = new char[len + 1]; + memcpy(this->value, value, len); + this->value[len] = 0; + } } template <> void MsgpackValue::InitValue(const TMsgpackRawData value, size_t valueLen) { this->value = value; } template <> void MsgpackValue::InitValue(MsgpackObject *value, size_t valueLen) { this->value = value; } @@ -117,205 +117,205 @@ template <> void MsgpackValue::InitValue(MsgpackArrayBase *v */ template <> void MsgpackValue::Set(const bool newValue, size_t newValueLen) { - DeleteValue(); - InitValue(newValue, newValueLen); + DeleteValue(); + InitValue(newValue, newValueLen); } template <> void MsgpackValue::Set(const int8_t newValue, size_t newValueLen) { - DeleteValue(); - InitValue(newValue, newValueLen); + DeleteValue(); + InitValue(newValue, newValueLen); } template <> void MsgpackValue::Set(const int16_t newValue, size_t newValueLen) { - DeleteValue(); - InitValue(newValue, newValueLen); + DeleteValue(); + InitValue(newValue, newValueLen); } template <> void MsgpackValue::Set(const int32_t newValue, size_t newValueLen) { - DeleteValue(); - InitValue(newValue, newValueLen); + DeleteValue(); + InitValue(newValue, newValueLen); } template <> void MsgpackValue::Set(const int64_t newValue, size_t newValueLen) { - DeleteValue(); - InitValue(newValue, newValueLen); + DeleteValue(); + InitValue(newValue, newValueLen); } template <> void MsgpackValue::Set(const uint8_t newValue, size_t newValueLen) { - DeleteValue(); - InitValue(newValue, newValueLen); + DeleteValue(); + InitValue(newValue, newValueLen); } template <> void MsgpackValue::Set(const uint16_t newValue, size_t newValueLen) { - DeleteValue(); - InitValue(newValue, newValueLen); + DeleteValue(); + InitValue(newValue, newValueLen); } template <> void MsgpackValue::Set(const uint32_t newValue, size_t newValueLen) { - DeleteValue(); - InitValue(newValue, newValueLen); + DeleteValue(); + InitValue(newValue, newValueLen); } template <> void MsgpackValue::Set(const uint64_t newValue, size_t newValueLen) { - DeleteValue(); - InitValue(newValue, newValueLen); + DeleteValue(); + InitValue(newValue, newValueLen); } template <> void MsgpackValue::Set(const float newValue, size_t newValueLen) { - DeleteValue(); - InitValue(newValue, newValueLen); + DeleteValue(); + InitValue(newValue, newValueLen); } template <> void MsgpackValue::Set(const double newValue, size_t newValueLen) { - DeleteValue(); - InitValue(newValue, newValueLen); + DeleteValue(); + InitValue(newValue, newValueLen); } template <> void MsgpackValue::Set(const char *newValue, size_t newValueLen) { - DeleteValue(); - InitValue(newValue, newValueLen); + DeleteValue(); + InitValue(newValue, newValueLen); } template <> void MsgpackValue::Set(const TMsgpackRawData newValue, size_t newValueLen) { - DeleteValue(); - InitValue(newValue, newValueLen); + DeleteValue(); + InitValue(newValue, newValueLen); } template <> void MsgpackValue::Set(MsgpackObject *newValue, size_t newValueLen) { - if (this->value == NULL) { - this->value = newValue; - } else if (newValue != NULL) { - newValue->CloneTo(this->value); - } + if (this->value == NULL) { + this->value = newValue; + } else if (newValue != NULL) { + newValue->CloneTo(this->value); + } } template <> void MsgpackValue::Set(MsgpackArrayBase *newValue, size_t newValueLen) { - if (this->value == NULL) { - this->value = newValue; - } else if (newValue != NULL) { - newValue->CloneTo(this->value); - } + if (this->value == NULL) { + this->value = newValue; + } else if (newValue != NULL) { + newValue->CloneTo(this->value); + } } /* */ template <> bool MsgpackValue::TryParse(msgpack_object *deserialized) { - if (this->Id >= deserialized->via.array.size) { return false; } - msgpack_object object = deserialized->via.array.ptr[this->Id]; - if (object.type != MSGPACK_OBJECT_BOOLEAN) { return false; } - Set(object.via.boolean); - return true; + if (this->Id >= deserialized->via.array.size) { return false; } + msgpack_object object = deserialized->via.array.ptr[this->Id]; + if (object.type != MSGPACK_OBJECT_BOOLEAN) { return false; } + Set(object.via.boolean); + return true; } template <> bool MsgpackValue::TryParse(msgpack_object *deserialized) { - if (this->Id >= deserialized->via.array.size) { return false; } - msgpack_object object = deserialized->via.array.ptr[this->Id]; - if ((object.type != MSGPACK_OBJECT_NEGATIVE_INTEGER && object.type != MSGPACK_OBJECT_POSITIVE_INTEGER) // - || object.via.i64 < INT8_MIN || object.via.i64 > INT8_MAX) { - return false; - } - Set((int8_t)object.via.i64); - return true; + if (this->Id >= deserialized->via.array.size) { return false; } + msgpack_object object = deserialized->via.array.ptr[this->Id]; + if ((object.type != MSGPACK_OBJECT_NEGATIVE_INTEGER && object.type != MSGPACK_OBJECT_POSITIVE_INTEGER) // + || object.via.i64 < INT8_MIN || object.via.i64 > INT8_MAX) { + return false; + } + Set((int8_t)object.via.i64); + return true; } template <> bool MsgpackValue::TryParse(msgpack_object *deserialized) { - if (this->Id >= deserialized->via.array.size) { return false; } - msgpack_object object = deserialized->via.array.ptr[this->Id]; - if ((object.type != MSGPACK_OBJECT_NEGATIVE_INTEGER && object.type != MSGPACK_OBJECT_POSITIVE_INTEGER) // - || object.via.i64 < INT16_MIN || object.via.i64 > INT16_MAX) { - return false; - } - Set((int16_t)object.via.i64); - return true; + if (this->Id >= deserialized->via.array.size) { return false; } + msgpack_object object = deserialized->via.array.ptr[this->Id]; + if ((object.type != MSGPACK_OBJECT_NEGATIVE_INTEGER && object.type != MSGPACK_OBJECT_POSITIVE_INTEGER) // + || object.via.i64 < INT16_MIN || object.via.i64 > INT16_MAX) { + return false; + } + Set((int16_t)object.via.i64); + return true; } template <> bool MsgpackValue::TryParse(msgpack_object *deserialized) { - if (this->Id >= deserialized->via.array.size) { return false; } - msgpack_object object = deserialized->via.array.ptr[this->Id]; - if ((object.type != MSGPACK_OBJECT_NEGATIVE_INTEGER && object.type != MSGPACK_OBJECT_POSITIVE_INTEGER) // - || object.via.i64 < INT32_MIN || object.via.i64 > INT32_MAX) { - return false; - } - Set((int32_t)object.via.i64); - return true; + if (this->Id >= deserialized->via.array.size) { return false; } + msgpack_object object = deserialized->via.array.ptr[this->Id]; + if ((object.type != MSGPACK_OBJECT_NEGATIVE_INTEGER && object.type != MSGPACK_OBJECT_POSITIVE_INTEGER) // + || object.via.i64 < INT32_MIN || object.via.i64 > INT32_MAX) { + return false; + } + Set((int32_t)object.via.i64); + return true; } template <> bool MsgpackValue::TryParse(msgpack_object *deserialized) { - if (this->Id >= deserialized->via.array.size) { return false; } - msgpack_object object = deserialized->via.array.ptr[this->Id]; - if (object.type != MSGPACK_OBJECT_NEGATIVE_INTEGER && object.type != MSGPACK_OBJECT_POSITIVE_INTEGER) { return false; } - Set(object.via.i64); - return true; + if (this->Id >= deserialized->via.array.size) { return false; } + msgpack_object object = deserialized->via.array.ptr[this->Id]; + if (object.type != MSGPACK_OBJECT_NEGATIVE_INTEGER && object.type != MSGPACK_OBJECT_POSITIVE_INTEGER) { return false; } + Set(object.via.i64); + return true; } template <> bool MsgpackValue::TryParse(msgpack_object *deserialized) { - if (this->Id >= deserialized->via.array.size) { return false; } - msgpack_object object = deserialized->via.array.ptr[this->Id]; - if (object.type != MSGPACK_OBJECT_POSITIVE_INTEGER || object.via.u64 > UINT8_MAX) { return false; } - Set((uint8_t)object.via.u64); - return true; + if (this->Id >= deserialized->via.array.size) { return false; } + msgpack_object object = deserialized->via.array.ptr[this->Id]; + if (object.type != MSGPACK_OBJECT_POSITIVE_INTEGER || object.via.u64 > UINT8_MAX) { return false; } + Set((uint8_t)object.via.u64); + return true; } template <> bool MsgpackValue::TryParse(msgpack_object *deserialized) { - if (this->Id >= deserialized->via.array.size) { return false; } - msgpack_object object = deserialized->via.array.ptr[this->Id]; - if (object.type != MSGPACK_OBJECT_POSITIVE_INTEGER || object.via.u64 > UINT16_MAX) { return false; } - Set((uint16_t)object.via.u64); - return true; + if (this->Id >= deserialized->via.array.size) { return false; } + msgpack_object object = deserialized->via.array.ptr[this->Id]; + if (object.type != MSGPACK_OBJECT_POSITIVE_INTEGER || object.via.u64 > UINT16_MAX) { return false; } + Set((uint16_t)object.via.u64); + return true; } template <> bool MsgpackValue::TryParse(msgpack_object *deserialized) { - if (this->Id >= deserialized->via.array.size) { return false; } - msgpack_object object = deserialized->via.array.ptr[this->Id]; - if (object.type != MSGPACK_OBJECT_POSITIVE_INTEGER || object.via.u64 > UINT32_MAX) { return false; } - Set((uint32_t)object.via.u64); - return true; + if (this->Id >= deserialized->via.array.size) { return false; } + msgpack_object object = deserialized->via.array.ptr[this->Id]; + if (object.type != MSGPACK_OBJECT_POSITIVE_INTEGER || object.via.u64 > UINT32_MAX) { return false; } + Set((uint32_t)object.via.u64); + return true; } template <> bool MsgpackValue::TryParse(msgpack_object *deserialized) { - if (this->Id >= deserialized->via.array.size) { return false; } - msgpack_object object = deserialized->via.array.ptr[this->Id]; - if (object.type != MSGPACK_OBJECT_POSITIVE_INTEGER) { return false; } - Set(object.via.u64); - return true; + if (this->Id >= deserialized->via.array.size) { return false; } + msgpack_object object = deserialized->via.array.ptr[this->Id]; + if (object.type != MSGPACK_OBJECT_POSITIVE_INTEGER) { return false; } + Set(object.via.u64); + return true; } template <> bool MsgpackValue::TryParse(msgpack_object *deserialized) { - if (this->Id >= deserialized->via.array.size) { return false; } - msgpack_object object = deserialized->via.array.ptr[this->Id]; - if (object.type != MSGPACK_OBJECT_FLOAT32) { return false; } - Set((float)object.via.f64); - return true; + if (this->Id >= deserialized->via.array.size) { return false; } + msgpack_object object = deserialized->via.array.ptr[this->Id]; + if (object.type != MSGPACK_OBJECT_FLOAT32) { return false; } + Set((float)object.via.f64); + return true; } template <> bool MsgpackValue::TryParse(msgpack_object *deserialized) { - if (this->Id >= deserialized->via.array.size) { return false; } - msgpack_object object = deserialized->via.array.ptr[this->Id]; - if (object.type != MSGPACK_OBJECT_FLOAT64) { return false; } - Set((double)object.via.f64); - return true; + if (this->Id >= deserialized->via.array.size) { return false; } + msgpack_object object = deserialized->via.array.ptr[this->Id]; + if (object.type != MSGPACK_OBJECT_FLOAT64) { return false; } + Set((double)object.via.f64); + return true; } template <> bool MsgpackValue::TryParse(msgpack_object *deserialized) { - if (this->Id >= deserialized->via.array.size) { return false; } - msgpack_object object = deserialized->via.array.ptr[this->Id]; - if (object.type == MSGPACK_OBJECT_NIL) { - Set(NULL); - return true; - } - if (object.type != MSGPACK_OBJECT_STR) { return false; } + if (this->Id >= deserialized->via.array.size) { return false; } + msgpack_object object = deserialized->via.array.ptr[this->Id]; + if (object.type == MSGPACK_OBJECT_NIL) { + Set(NULL); + return true; + } + if (object.type != MSGPACK_OBJECT_STR) { return false; } - Set(object.via.str.ptr, object.via.str.size); - return true; + Set(object.via.str.ptr, object.via.str.size); + return true; } template <> bool MsgpackValue::TryParse(msgpack_object *deserialized) { - if (this->Id >= deserialized->via.array.size) { return false; } - msgpack_object object = deserialized->via.array.ptr[this->Id]; - TMsgpackRawData rawData; - switch (object.type) { - case MSGPACK_OBJECT_NIL: - Set({}); - return true; + if (this->Id >= deserialized->via.array.size) { return false; } + msgpack_object object = deserialized->via.array.ptr[this->Id]; + TMsgpackRawData rawData; + switch (object.type) { + case MSGPACK_OBJECT_NIL: + Set({}); + return true; - case MSGPACK_OBJECT_BIN: - rawData = {(uint8_t *)object.via.bin.ptr, object.via.bin.size}; - Set(rawData); - return true; + case MSGPACK_OBJECT_BIN: + rawData = { (uint8_t *)object.via.bin.ptr, object.via.bin.size }; + Set(rawData); + return true; - case MSGPACK_OBJECT_STR: - rawData = {(uint8_t *)object.via.str.ptr, object.via.str.size}; - Set(rawData); - return true; - default: - break; - } + case MSGPACK_OBJECT_STR: + rawData = { (uint8_t *)object.via.str.ptr, object.via.str.size }; + Set(rawData); + return true; + default: + break; + } - return false; + return false; } template <> bool MsgpackValue::TryParse(msgpack_object *deserialized) { - if (this->Id >= deserialized->via.array.size) { return false; } - msgpack_object object = deserialized->via.array.ptr[this->Id]; - return value->TryParse(&object); + if (this->Id >= deserialized->via.array.size) { return false; } + msgpack_object object = deserialized->via.array.ptr[this->Id]; + return value->TryParse(&object); } template <> bool MsgpackValue::TryParse(msgpack_object *deserialized) { - if (this->Id >= deserialized->via.array.size) { return false; } - msgpack_object object = deserialized->via.array.ptr[this->Id]; - return value->TryParseObject(&object); + if (this->Id >= deserialized->via.array.size) { return false; } + msgpack_object object = deserialized->via.array.ptr[this->Id]; + return value->TryParseObject(&object); } /* @@ -334,12 +334,12 @@ template <> void MsgpackValue::CloneTo(MsgpackValueBase *other) { ((Msgp template <> void MsgpackValue::CloneTo(MsgpackValueBase *other) { ((MsgpackValue *)other)->Set(this->value); } template <> void MsgpackValue::CloneTo(MsgpackValueBase *other) { ((MsgpackValue *)other)->Set((TMsgpackRawData)this->value); } template <> void MsgpackValue::CloneTo(MsgpackValueBase *other) { - auto thisObject = ((MsgpackObject *)value); - auto otherObject = ((MsgpackObject *)((MsgpackValue *)other)->value); - thisObject->CloneTo(otherObject); + auto thisObject = ((MsgpackObject *)value); + auto otherObject = ((MsgpackObject *)((MsgpackValue *)other)->value); + thisObject->CloneTo(otherObject); } template <> void MsgpackValue::CloneTo(MsgpackValueBase *other) { - auto thisArray = ((MsgpackArrayBase *)value); - auto otherArray = ((MsgpackArrayBase *)((MsgpackValue *)other)->value); - thisArray->CloneTo(otherArray); + auto thisArray = ((MsgpackArrayBase *)value); + auto otherArray = ((MsgpackArrayBase *)((MsgpackValue *)other)->value); + thisArray->CloneTo(otherArray); } diff --git a/src/MsgpackValueBase.cpp b/src/MsgpackValueBase.cpp index c0f79c8..3bd1a25 100644 --- a/src/MsgpackValueBase.cpp +++ b/src/MsgpackValueBase.cpp @@ -1,6 +1,5 @@ +#include "MsgpackWrapper.h" #include #include #include -#include "MsgpackWrapper.h" - From a1ae2c29ed6c53c204f41bf4e5e50cf903abf097 Mon Sep 17 00:00:00 2001 From: Vitalii Orazov Date: Tue, 9 Sep 2025 23:24:09 +0300 Subject: [PATCH 7/9] build: add Release\Debug configs --- CMakeLists.txt | 47 +++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 43 insertions(+), 4 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 10ee7c3..da5c926 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -10,6 +10,35 @@ set(MSGPACK_ENABLE_STATIC ON CACHE BOOL "Enable static") option(MSGPACKWRAPPER_BUILD_DEMO "Build demonstration application" ON) +if(CMAKE_BUILD_TYPE STREQUAL "Release") + set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -DNDEBUG") + if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") + set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -flto -fno-rtti") + elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -flto -fno-rtti") + elseif(MSVC) + set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /O2 /GL /MP") + endif() +elseif(CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo") + set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O2 -g -DNDEBUG") +elseif(CMAKE_BUILD_TYPE STREQUAL "MinSizeRel") + set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -Os -DNDEBUG") +else() + set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g") +endif() + +if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wpedantic") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wshadow -Wconversion -Wsign-conversion") +endif() + +if(WIN32) + add_definitions(-D_CRT_SECURE_NO_WARNINGS) + if(MSVC) + add_compile_options(/W4 /WX) + endif() +endif() + add_subdirectory(msgpack-c) get_target_property(MSGPACK_BINARY_INCLUDE_DIRS msgpack-c BINARY_DIR) @@ -22,10 +51,6 @@ include_directories( ${MSGPACK_BINARY_INCLUDE_DIRS}/include/msgpack ) -if(WIN32) - add_definitions(-D_CRT_SECURE_NO_WARNINGS) -endif(WIN32) - set(CPP_SOURCE_FILES src/MsgpackValueBase.cpp src/MsgpackValue.cpp @@ -47,6 +72,20 @@ target_include_directories(MsgpackWrapper PUBLIC ${MSGPACK_BINARY_INCLUDE_DIRS}/include/msgpack ) +if(CMAKE_BUILD_TYPE STREQUAL "Release") + if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + set_target_properties(MsgpackWrapper PROPERTIES + INTERPROCEDURAL_OPTIMIZATION TRUE + LINK_FLAGS "-flto" + ) + elseif(MSVC) + set_target_properties(MsgpackWrapper PROPERTIES + INTERPROCEDURAL_OPTIMIZATION TRUE + LINK_FLAGS "/LTCG" + ) + endif() +endif() + if(MSGPACKWRAPPER_BUILD_DEMO) add_executable(MsgpackWrapperDemo main.cpp) target_link_libraries(MsgpackWrapperDemo MsgpackWrapper) From 930a8ef198d7539b9fc9685122e3671bae551c2f Mon Sep 17 00:00:00 2001 From: Vitaliy Orazov Date: Wed, 10 Sep 2025 00:10:31 +0300 Subject: [PATCH 8/9] build: fix WIN compiling --- CMakeLists.txt | 27 +++++++++++++++++++-------- 1 file changed, 19 insertions(+), 8 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index da5c926..466d2e2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -11,20 +11,31 @@ set(MSGPACK_ENABLE_STATIC ON CACHE BOOL "Enable static") option(MSGPACKWRAPPER_BUILD_DEMO "Build demonstration application" ON) if(CMAKE_BUILD_TYPE STREQUAL "Release") - set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -DNDEBUG") - if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") - set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -flto -fno-rtti") - elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang") - set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -flto -fno-rtti") + set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -DNDEBUG") + if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -flto -fno-rtti") elseif(MSVC) set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /O2 /GL /MP") endif() elseif(CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo") - set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O2 -g -DNDEBUG") + set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -DNDEBUG") + if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O2 -g -fno-rtti") + elseif(MSVC) + set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /O2 /GL /MP") + endif() elseif(CMAKE_BUILD_TYPE STREQUAL "MinSizeRel") - set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -Os -DNDEBUG") + set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -DNDEBUG") + if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -Os -g -fno-rtti") + elseif(MSVC) + set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} /O2 /GL /MP") + endif() else() - set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g") + if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g -fno-rtti") + elseif(MSVC) + endif() endif() if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") From 985a160ae4912a42000510ed9100557b670c4c8c Mon Sep 17 00:00:00 2001 From: Vitaliy Orazov Date: Wed, 10 Sep 2025 00:43:31 +0300 Subject: [PATCH 9/9] build: fix warnings --- .vscode/launch.json | 2 +- Tests/CMakeLists.txt | 3 ++ include/MsgpackWrapper.h | 2 +- main.cpp | 16 ++------ src/MsgpackArray.cpp | 77 +++++++++++++++++++++++++----------- src/MsgpackValue.cpp | 84 ++++++++++++++++++++++++++++++---------- 6 files changed, 127 insertions(+), 57 deletions(-) diff --git a/.vscode/launch.json b/.vscode/launch.json index 0c56106..51d6a5f 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -141,7 +141,7 @@ "name": "(Windows) Launch", "type": "cppvsdbg", "request": "launch", - "program": "${workspaceFolder}/build/Debug/MsgpackWrapper.exe", + "program": "${workspaceFolder}/build/Debug/MsgpackWrapperDemo.exe", "args": [], "stopAtEntry": false, "cwd": "${fileDirname}", diff --git a/Tests/CMakeLists.txt b/Tests/CMakeLists.txt index ad1dd8f..2daf4cf 100644 --- a/Tests/CMakeLists.txt +++ b/Tests/CMakeLists.txt @@ -10,6 +10,9 @@ if(WIN32) add_definitions("/wd4251") add_definitions("/wd4305") add_definitions("/wd4309") + add_definitions("/wd4611") + add_definitions("/wd4100") + add_definitions("/wd4127") add_definitions(-D_CRT_SECURE_NO_WARNINGS) endif(WIN32) diff --git a/include/MsgpackWrapper.h b/include/MsgpackWrapper.h index 8e70f93..c5b8364 100644 --- a/include/MsgpackWrapper.h +++ b/include/MsgpackWrapper.h @@ -29,7 +29,7 @@ template class MsgpackValue : public MsgpackValueBase { protected: T value; - void InitValue(ConstT value, size_t valueLen); + void InitValue(ConstT val, size_t valLen); void DeleteValue(); }; diff --git a/main.cpp b/main.cpp index 06444b6..fc51755 100644 --- a/main.cpp +++ b/main.cpp @@ -20,24 +20,14 @@ int main(void) { UserDto outUserDto("DemoWrapper", uAdmin); auto writed = outUserDto.Write(buffer, sizeof(buffer)); - fprintf(stdout, - "out UserDto(%s, %u) serialized to %lu bytes\n", - outUserDto.Name.Get(), - outUserDto.Role.Get(), - writed); + fprintf(stdout, "out UserDto(%s, %u) serialized to %u bytes\n", outUserDto.Name.Get(), outUserDto.Role.Get(), (unsigned)writed); UserDto inUserDto; auto res = inUserDto.TryParse(buffer, writed); if (res) { - fprintf(stdout, - "in UserDto(%s, %u) deserialized successfully\n", - outUserDto.Name.Get(), - outUserDto.Role.Get()); + fprintf(stdout, "in UserDto(%s, %u) deserialized successfully\n", outUserDto.Name.Get(), outUserDto.Role.Get()); } else { - fprintf(stderr, - "in UserDto(%s, %u) deserialized with error\n", - outUserDto.Name.Get(), - outUserDto.Role.Get()); + fprintf(stderr, "in UserDto(%s, %u) deserialized with error\n", outUserDto.Name.Get(), outUserDto.Role.Get()); } return 0; diff --git a/src/MsgpackArray.cpp b/src/MsgpackArray.cpp index 5c0767a..63c6f85 100644 --- a/src/MsgpackArray.cpp +++ b/src/MsgpackArray.cpp @@ -191,17 +191,50 @@ template <> void MsgpackArray::AddInternal(const char *item, size_t newV Items.push_back(newItem); } } -template <> void MsgpackArray::AddInternal(const TBoolArray item, size_t newValueLen) { Items.push_back(item); } -template <> void MsgpackArray::AddInternal(const int64_t item, size_t newValueLen) { Items.push_back(item); } -template <> void MsgpackArray::AddInternal(const uint64_t item, size_t newValueLen) { Items.push_back(item); } -template <> void MsgpackArray::AddInternal(const int32_t item, size_t newValueLen) { Items.push_back(item); } -template <> void MsgpackArray::AddInternal(const uint32_t item, size_t newValueLen) { Items.push_back(item); } -template <> void MsgpackArray::AddInternal(const int16_t item, size_t newValueLen) { Items.push_back(item); } -template <> void MsgpackArray::AddInternal(const uint16_t item, size_t newValueLen) { Items.push_back(item); } -template <> void MsgpackArray::AddInternal(const int8_t item, size_t newValueLen) { Items.push_back(item); } -template <> void MsgpackArray::AddInternal(const uint8_t item, size_t newValueLen) { Items.push_back(item); } -template <> void MsgpackArray::AddInternal(const double item, size_t newValueLen) { Items.push_back(item); } -template <> void MsgpackArray::AddInternal(const float item, size_t newValueLen) { Items.push_back(item); } +template <> void MsgpackArray::AddInternal(const TBoolArray item, size_t newValueLen) { + (void)newValueLen; + Items.push_back(item); +} +template <> void MsgpackArray::AddInternal(const int64_t item, size_t newValueLen) { + (void)newValueLen; + Items.push_back(item); +} +template <> void MsgpackArray::AddInternal(const uint64_t item, size_t newValueLen) { + (void)newValueLen; + Items.push_back(item); +} +template <> void MsgpackArray::AddInternal(const int32_t item, size_t newValueLen) { + (void)newValueLen; + Items.push_back(item); +} +template <> void MsgpackArray::AddInternal(const uint32_t item, size_t newValueLen) { + (void)newValueLen; + Items.push_back(item); +} +template <> void MsgpackArray::AddInternal(const int16_t item, size_t newValueLen) { + (void)newValueLen; + Items.push_back(item); +} +template <> void MsgpackArray::AddInternal(const uint16_t item, size_t newValueLen) { + (void)newValueLen; + Items.push_back(item); +} +template <> void MsgpackArray::AddInternal(const int8_t item, size_t newValueLen) { + (void)newValueLen; + Items.push_back(item); +} +template <> void MsgpackArray::AddInternal(const uint8_t item, size_t newValueLen) { + (void)newValueLen; + Items.push_back(item); +} +template <> void MsgpackArray::AddInternal(const double item, size_t newValueLen) { + (void)newValueLen; + Items.push_back(item); +} +template <> void MsgpackArray::AddInternal(const float item, size_t newValueLen) { + (void)newValueLen; + Items.push_back(item); +} /* @@ -271,17 +304,17 @@ template <> bool MsgpackArray::Add(const float item, size_t newValueLen) */ template <> void MsgpackArray::DeleteItem(const char *item) { delete[] item; } -template <> void MsgpackArray::DeleteItem(const TBoolArray item) {} -template <> void MsgpackArray::DeleteItem(const int64_t item) {} -template <> void MsgpackArray::DeleteItem(const uint64_t item) {} -template <> void MsgpackArray::DeleteItem(const int32_t item) {} -template <> void MsgpackArray::DeleteItem(const uint32_t item) {} -template <> void MsgpackArray::DeleteItem(const int16_t item) {} -template <> void MsgpackArray::DeleteItem(const uint16_t item) {} -template <> void MsgpackArray::DeleteItem(const int8_t item) {} -template <> void MsgpackArray::DeleteItem(const uint8_t item) {} -template <> void MsgpackArray::DeleteItem(const double item) {} -template <> void MsgpackArray::DeleteItem(const float item) {} +template <> void MsgpackArray::DeleteItem(const TBoolArray item) { (void)item; } +template <> void MsgpackArray::DeleteItem(const int64_t item) { (void)item; } +template <> void MsgpackArray::DeleteItem(const uint64_t item) { (void)item; } +template <> void MsgpackArray::DeleteItem(const int32_t item) { (void)item; } +template <> void MsgpackArray::DeleteItem(const uint32_t item) { (void)item; } +template <> void MsgpackArray::DeleteItem(const int16_t item) { (void)item; } +template <> void MsgpackArray::DeleteItem(const uint16_t item) { (void)item; } +template <> void MsgpackArray::DeleteItem(const int8_t item) { (void)item; } +template <> void MsgpackArray::DeleteItem(const uint8_t item) { (void)item; } +template <> void MsgpackArray::DeleteItem(const double item) { (void)item; } +template <> void MsgpackArray::DeleteItem(const float item) { (void)item; } /* diff --git a/src/MsgpackValue.cpp b/src/MsgpackValue.cpp index b2921b5..9f57649 100644 --- a/src/MsgpackValue.cpp +++ b/src/MsgpackValue.cpp @@ -87,32 +87,74 @@ template <> void MsgpackValue::DeleteValue() {} */ -template <> void MsgpackValue::InitValue(const bool value, size_t valueLen) { this->value = value; } -template <> void MsgpackValue::InitValue(const int8_t value, size_t valueLen) { this->value = value; } -template <> void MsgpackValue::InitValue(const int16_t value, size_t valueLen) { this->value = value; } -template <> void MsgpackValue::InitValue(const int32_t value, size_t valueLen) { this->value = value; } -template <> void MsgpackValue::InitValue(const int64_t value, size_t valueLen) { this->value = value; } -template <> void MsgpackValue::InitValue(const uint8_t value, size_t valueLen) { this->value = value; } -template <> void MsgpackValue::InitValue(const uint16_t value, size_t valueLen) { this->value = value; } -template <> void MsgpackValue::InitValue(const uint32_t value, size_t valueLen) { this->value = value; } -template <> void MsgpackValue::InitValue(const uint64_t value, size_t valueLen) { this->value = value; } -template <> void MsgpackValue::InitValue(const float value, size_t valueLen) { this->value = value; } -template <> void MsgpackValue::InitValue(const double value, size_t valueLen) { this->value = value; } -template <> void MsgpackValue::InitValue(const char *value, size_t valueLen) { - if (value == NULL) { +template <> void MsgpackValue::InitValue(const bool val, size_t valLen) { + (void)valLen; + this->value = val; +} +template <> void MsgpackValue::InitValue(const int8_t val, size_t valLen) { + (void)valLen; + this->value = val; +} +template <> void MsgpackValue::InitValue(const int16_t val, size_t valLen) { + (void)valLen; + this->value = val; +} +template <> void MsgpackValue::InitValue(const int32_t val, size_t valLen) { + (void)valLen; + this->value = val; +} +template <> void MsgpackValue::InitValue(const int64_t val, size_t valLen) { + (void)valLen; + this->value = val; +} +template <> void MsgpackValue::InitValue(const uint8_t val, size_t valLen) { + (void)valLen; + this->value = val; +} +template <> void MsgpackValue::InitValue(const uint16_t val, size_t valLen) { + (void)valLen; + this->value = val; +} +template <> void MsgpackValue::InitValue(const uint32_t val, size_t valLen) { + (void)valLen; + this->value = val; +} +template <> void MsgpackValue::InitValue(const uint64_t val, size_t valLen) { + (void)valLen; + this->value = val; +} +template <> void MsgpackValue::InitValue(const float val, size_t valLen) { + (void)valLen; + this->value = val; +} +template <> void MsgpackValue::InitValue(const double val, size_t valLen) { + (void)valLen; + this->value = val; +} +template <> void MsgpackValue::InitValue(const char *val, size_t valLen) { + if (val == NULL) { this->value = NULL; } else { - size_t len = valueLen != size_t() // - ? valueLen // - : strlen(value); + size_t len = valLen != size_t() // + ? valLen // + : strlen(val); this->value = new char[len + 1]; - memcpy(this->value, value, len); + memcpy(this->value, val, len); this->value[len] = 0; } } -template <> void MsgpackValue::InitValue(const TMsgpackRawData value, size_t valueLen) { this->value = value; } -template <> void MsgpackValue::InitValue(MsgpackObject *value, size_t valueLen) { this->value = value; } -template <> void MsgpackValue::InitValue(MsgpackArrayBase *value, size_t valueLen) { this->value = value; } +template <> void MsgpackValue::InitValue(const TMsgpackRawData val, size_t valLen) { + (void)valLen; + this->value = val; +} +template <> void MsgpackValue::InitValue(MsgpackObject *val, size_t valLen) { + (void)valLen; + this->value = val; +} +template <> void MsgpackValue::InitValue(MsgpackArrayBase *val, size_t valLen) { + (void)valLen; + this->value = val; +} /* */ @@ -169,6 +211,7 @@ template <> void MsgpackValue::Set(const TMsgpackRawData newVal InitValue(newValue, newValueLen); } template <> void MsgpackValue::Set(MsgpackObject *newValue, size_t newValueLen) { + (void)newValueLen; if (this->value == NULL) { this->value = newValue; } else if (newValue != NULL) { @@ -176,6 +219,7 @@ template <> void MsgpackValue::Set(MsgpackObject *newValue, siz } } template <> void MsgpackValue::Set(MsgpackArrayBase *newValue, size_t newValueLen) { + (void)newValueLen; if (this->value == NULL) { this->value = newValue; } else if (newValue != NULL) {