Fix build with Boost 1.86.0.

Author: BillyONeal

hazelcast/include/hazelcast/client/protocol/ClientMessage.h

@@ -56,6 +56,11 @@
 namespace hazelcast {
 namespace util {
 class ByteBuffer;
+
+template<class T>
+struct is_trivial_or_uuid : std::is_trivial<T> {};
+template<>
+struct is_trivial_or_uuid<boost::uuids::uuid> : std::true_type {};
 }
 
 namespace cp {
@@ -594,7 +599,7 @@ class HAZELCAST_API ClientMessage
         std::is_same<std::pair<typename T::value_type::first_type,
                                typename T::value_type::second_type>,
                      typename T::value_type>::value &&
-        std::is_trivial<typename T::value_type::first_type>::value &&
+        hazelcast::util::is_trivial_or_uuid<typename T::value_type::first_type>::value &&
         std::is_trivial<typename T::value_type::second_type>::value,
       T>::type
     get()
@@ -625,7 +630,7 @@ class HAZELCAST_API ClientMessage
         std::is_same<std::pair<typename T::value_type::first_type,
                                typename T::value_type::second_type>,
                      typename T::value_type>::value &&
-        std::is_trivial<typename T::value_type::first_type>::value &&
+        hazelcast::util::is_trivial_or_uuid<typename T::value_type::first_type>::value &&
         !std::is_trivial<typename T::value_type::second_type>::value,
       T>::type
     get()
@@ -1246,12 +1251,11 @@ class HAZELCAST_API ClientMessage
         set(nil);
         if (!nil) {
             boost::endian::endian_reverse_inplace<int64_t>(
-              *reinterpret_cast<int64_t*>(uuid.data));
+              *reinterpret_cast<int64_t*>(&uuid.data[0]));
             boost::endian::endian_reverse_inplace<int64_t>(
-              *reinterpret_cast<int64_t*>(uuid.data +
-                                          util::Bits::LONG_SIZE_IN_BYTES));
+              *reinterpret_cast<int64_t*>(&uuid.data[util::Bits::LONG_SIZE_IN_BYTES]));
             std::memcpy(wr_ptr(sizeof(boost::uuids::uuid)),
-                        uuid.data,
+                        &uuid.data[0],
                         sizeof(boost::uuids::uuid));
         } else {
             wr_ptr(sizeof(boost::uuids::uuid));
@@ -1525,13 +1529,13 @@ class HAZELCAST_API ClientMessage
     boost::uuids::uuid get_uuid()
     {
         boost::uuids::uuid u;
-        memcpy(&u.data,
+        memcpy(&u.data[0],
                rd_ptr(sizeof(boost::uuids::uuid)),
                sizeof(boost::uuids::uuid));
         boost::endian::endian_reverse_inplace<int64_t>(
-          *reinterpret_cast<int64_t*>(u.data));
+          *reinterpret_cast<int64_t*>(&u.data[0]));
         boost::endian::endian_reverse_inplace<int64_t>(
-          *reinterpret_cast<int64_t*>(u.data + util::Bits::LONG_SIZE_IN_BYTES));
+          *reinterpret_cast<int64_t*>(&u.data[util::Bits::LONG_SIZE_IN_BYTES]));
         return u;
     }
 

hazelcast/include/hazelcast/client/serialization/pimpl/data_input.h

@@ -182,11 +182,11 @@ class data_input
     {
         check_available(util::Bits::UUID_SIZE_IN_BYTES);
         boost::uuids::uuid u;
-        std::memcpy(&u.data, &buffer_[pos_], util::Bits::UUID_SIZE_IN_BYTES);
+        std::memcpy(&u.data[0], &buffer_[pos_], util::Bits::UUID_SIZE_IN_BYTES);
         pos_ += util::Bits::UUID_SIZE_IN_BYTES;
         if (byte_order_ == boost::endian::order::little) {
             boost::endian::endian_reverse_inplace<int64_t>(
-              *reinterpret_cast<int64_t*>(u.data));
+              *reinterpret_cast<int64_t*>(&u.data[0]));
             boost::endian::endian_reverse_inplace<int64_t>(
               *reinterpret_cast<int64_t*>(
                 &u.data[util::Bits::LONG_SIZE_IN_BYTES]));

hazelcast/include/hazelcast/client/spi/impl/ClientInvocation.h

@@ -210,22 +210,7 @@ class HAZELCAST_API ClientInvocation
       const std::string& name,
       int partition = UNASSIGNED_PARTITION,
       const std::shared_ptr<connection::Connection>& conn = nullptr,
-      boost::uuids::uuid uuid = { 0x0,
-                                  0x0,
-                                  0x0,
-                                  0x0,
-                                  0x0,
-                                  0x0,
-                                  0x0,
-                                  0x0,
-                                  0x0,
-                                  0x0,
-                                  0x0,
-                                  0x0,
-                                  0x0,
-                                  0x0,
-                                  0x0,
-                                  0x0 });
+      boost::uuids::uuid uuid = {});
 
     void invoke_on_selection();
 

hazelcast/src/hazelcast/client/protocol.cpp

@@ -376,7 +376,7 @@ operator<<(std::ostream& os, const ClientMessage& msg)
 void
 ClientMessage::set(unsigned char* /* memory */, boost::uuids::uuid uuid)
 {
-    std::memcpy(wr_ptr(uuid.size()), uuid.data, uuid.size());
+    std::memcpy(wr_ptr(uuid.size()), &uuid.data[0], uuid.size());
 }
 
 void

hazelcast/src/hazelcast/client/serialization.cpp

@@ -731,12 +731,12 @@ data_output::write(boost::uuids::uuid v)
     }
     if (byte_order_ == boost::endian::order::little) {
         boost::endian::endian_reverse_inplace<int64_t>(
-          *reinterpret_cast<int64_t*>(v.data));
+          *reinterpret_cast<int64_t*>(&v.data[0]));
         boost::endian::endian_reverse_inplace<int64_t>(
           *reinterpret_cast<int64_t*>(&v.data[util::Bits::LONG_SIZE_IN_BYTES]));
     }
     output_stream_.insert(
-      output_stream_.end(), v.data, v.data + util::Bits::UUID_SIZE_IN_BYTES);
+      output_stream_.end(), &v.data[0], &v.data[util::Bits::LONG_SIZE_IN_BYTES]);
 }
 
 template<>