hotplace rev.499 grooming

sdk/base/basic/variant.cpp

@@ -114,15 +114,15 @@ variant& variant::set_uint16(uint16 value) {
 variant& variant::set_int24(int32 value) {
     _vt.type = TYPE_INT24;
     _vt.data.i32 = (value & 0x00ffffff);
-    _vt.size = 3;
+    _vt.size = RTL_FIELD_SIZE(uint24_t, data);  // 3
     _vt.flag = flag_int;
     return *this;
 }
 
 variant& variant::set_uint24(uint32 value) {
     _vt.type = TYPE_UINT24;
     _vt.data.ui32 = (value & 0x00ffffff);
-    _vt.size = 3;
+    _vt.size = RTL_FIELD_SIZE(uint24_t, data);  // 3
     _vt.flag = flag_int;
     return *this;
 }
@@ -386,7 +386,7 @@ return_t variant::dump(binary_t& target, bool change_endian) const {
         case TYPE_INT24:
         case TYPE_UINT24: {
             uint24_t temp;
-            uint32_24(temp, _vt.data.ui32);
+            i32_b24(temp, _vt.data.ui32);
             target.insert(target.end(), temp.data, temp.data + RTL_FIELD_SIZE(uint24_t, data));
         } break;
         case TYPE_INT32:

sdk/base/basic/variant.hpp

@@ -193,6 +193,12 @@ T t_variant_to_int(variant_t const& vt) {
         case TYPE_UINT16:
             i = vt.data.ui16;
             break;
+        case TYPE_INT24:
+            i = vt.data.i32;
+            break;
+        case TYPE_UINT24:
+            i = vt.data.ui32;
+            break;
         case TYPE_INT32:
             i = vt.data.i32;
             break;

sdk/base/system/types.cpp

@@ -57,7 +57,7 @@ uint128 ntoh128(uint128 value) { return hton128(value); }
 
 #endif
 
-return_t uint24_32(byte_t const* p, uint8 len, uint32& value) {
+return_t b24_i32(byte_t const* p, uint8 len, uint32& value) {
     return_t ret = errorcode_t::success;
 
     __try2 {
@@ -78,7 +78,7 @@ return_t uint24_32(byte_t const* p, uint8 len, uint32& value) {
     return ret;
 }
 
-return_t uint32_24(byte_t* p, uint8 len, uint32 value) {
+return_t i32_b24(byte_t* p, uint8 len, uint32 value) {
     return_t ret = errorcode_t::success;
 
     __try2 {
@@ -102,8 +102,8 @@ return_t uint32_24(byte_t* p, uint8 len, uint32 value) {
     return ret;
 }
 
-return_t uint24_32(uint24_t const& u, uint32& value) { return uint24_32(u.data, RTL_FIELD_SIZE(uint24_t, data), value); }
+return_t b24_i32(uint24_t const& u, uint32& value) { return b24_i32(u.data, RTL_FIELD_SIZE(uint24_t, data), value); }
 
-return_t uint32_24(uint24_t& u, uint32 value) { return uint32_24(u.data, RTL_FIELD_SIZE(uint24_t, data), value); }
+return_t i32_b24(uint24_t& u, uint32 value) { return i32_b24(u.data, RTL_FIELD_SIZE(uint24_t, data), value); }
 
 }  // namespace hotplace

sdk/base/system/types.hpp

@@ -51,16 +51,18 @@ uint128 ntoh128(uint128 value);
 /**
  * @brief   uint24 utility function (0 to 0x00ffffff)
  * @see     RFC 7540 4. HTTP Frames, Figure 1: Frame Layout
+ *          b24_i32 - from 24bits byte stream to 32 bit integer
+ *          i32_b24 - from 32 bit integer to 24bits byte stream
  */
-return_t uint24_32(byte_t const* p, uint8 len, uint32& value);
-return_t uint32_24(byte_t* p, uint8 len, uint32 value);
+return_t b24_i32(byte_t const* p, uint8 len, uint32& value);
+return_t i32_b24(byte_t* p, uint8 len, uint32 value);
 
 typedef struct _uint24_t {
     byte_t data[3];
 } uint24_t;
 
-return_t uint24_32(uint24_t const& u, uint32& value);
-return_t uint32_24(uint24_t& u, uint32 value);
+return_t b24_i32(uint24_t const& u, uint32& value);
+return_t i32_b24(uint24_t& u, uint32 value);
 
 }  // namespace hotplace
 

sdk/base/unittest/testcase.cpp

@@ -394,6 +394,8 @@ void test_case::report(uint32 top_count) {
     report_failed(stream);
     report_testtime(stream, top_count);
 
+    critical_section_guard guard(_lock);
+
     //
     // print
     //
@@ -596,4 +598,8 @@ void test_case::report_testtime(basic_stream& stream, uint32 top_count) {
 
 return_t test_case::result() { return _total._count_fail > 0 ? errorcode_t::internal_error : errorcode_t::success; }
 
+void test_case::lock() { _lock.enter(); }
+
+void test_case::unlock() { _lock.leave(); }
+
 }  // namespace hotplace

sdk/base/unittest/testcase.hpp

@@ -112,6 +112,9 @@ class test_case {
      */
     return_t result();
 
+    void lock();
+    void unlock();
+
     typedef struct _unittest_item_t {
         return_t _result;
         std::string _test_function;

sdk/io/basic/payload.cpp

@@ -129,9 +129,10 @@ payload_member& payload_member::read(byte_t* ptr, size_t size_ptr, size_t* size_
                     } break;
                     case TYPE_INT24:
                     case TYPE_UINT24: {
-                        uint32_24_t temp(ptr, size_ptr);
-                        v.set_uint32(temp.get());
-                        *size_read = 3;
+                        uint32 temp = 0;
+                        b24_i32(ptr, size_ptr, temp);
+                        v.set_uint24(temp);
+                        *size_read = size;
                     } break;
                     case TYPE_INT32:
                     case TYPE_UINT32: {
@@ -201,11 +202,7 @@ payload_member& payload_member::reserve(uint16 size) {
 
 payload::payload() {}
 
-payload::~payload() {
-    for (auto item : _members) {
-        delete item;
-    }
-}
+payload::~payload() { clear(); }
 
 payload& payload::operator<<(payload_member* member) {
     if (member) {
@@ -259,14 +256,15 @@ payload& payload::dump(binary_t& bin) {
     return *this;
 }
 
-payload& payload::read(binary_t const& bin) {
-    size_t size_input = bin.size();
+payload& payload::read(binary_t const& bin) { return read((byte_t*)&bin[0], bin.size()); }
+
+payload& payload::read(byte_t* base, size_t size) {
     size_t size_sum = 0;
     std::list<payload_member*> _size_unknown;
 
     {
-        byte_t* p = (byte_t*)&bin[0];
-        size_t len = size_input;
+        byte_t* p = base;
+        size_t len = size;
         size_t pos = 0;
         size_t size_read = 0;
         bool check = true;
@@ -288,18 +286,18 @@ payload& payload::read(binary_t const& bin) {
         }
     }
 
-    if (size_input > size_sum) {
+    if (size > size_sum) {
         if (1 == _size_unknown.size()) {
-            size_t remain = size_input - size_sum;
+            size_t remain = size - size_sum;
             payload_member* item = *(_size_unknown.begin());
             item->reserve(remain);
             _size_unknown.clear();
         }
     }
 
     if (_size_unknown.empty()) {
-        byte_t* p = (byte_t*)&bin[0];
-        size_t len = size_input;
+        byte_t* p = base;
+        size_t len = size;
         size_t pos = 0;
         size_t size_read = 0;
         bool check = true;
@@ -325,5 +323,19 @@ payload& payload::for_each(std::function<void(payload_member*)> func) {
     return *this;
 }
 
+payload_member* payload::select(std::string const& name) {
+    payload_member* item = nullptr;
+    maphint<std::string, payload_member*> hint(_members_map);
+    hint.find(name, &item);
+    return item;
+}
+
+payload& payload::clear() {
+    for (auto item : _members) {
+        delete item;
+    }
+    return *this;
+}
+
 }  // namespace io
 }  // namespace hotplace

sdk/io/basic/payload.hpp

@@ -112,7 +112,12 @@ class payload {
 
     payload& dump(binary_t& bin);
     payload& read(binary_t const& bin);
+    payload& read(byte_t* p, size_t size);
+
     payload& for_each(std::function<void(payload_member*)> func);
+    payload_member* select(std::string const& name);
+
+    payload& clear();
 
    private:
     // dump

sdk/io/system/types.cpp

@@ -39,11 +39,11 @@ uint32_24_t::uint32_24_t(uint32 value) { set(value); }
 
 uint32 uint32_24_t::get() {
     uint32 value = 0;
-    uint24_32(_value, value);
+    b24_i32(_value, value);
     return value;
 }
 
-return_t uint32_24_t::set(uint32 value) { return uint32_24(_value, value); }
+return_t uint32_24_t::set(uint32 value) { return i32_b24(_value, value); }
 
 uint32_24_t& uint32_24_t::operator=(uint32 value) {
     set(value);