Compact Nullable Primitive Arrays [API-1297] (#968)

* implement compact_writer::write for nullable primitive arrays

(cherry picked from commit 9a00938)

* implement compact_reader::read for nullable primitive arrays

(cherry picked from commit feb0551)

* add tests

(cherry picked from commit 07c1b6d)

* refactor to share code on reading nullable bool array

(cherry picked from commit 68ff919)

* rename get methods to read

(cherry picked from commit e698501)

* cleanup and test fix

* address review comments

Author: sancar

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

@@ -411,6 +411,96 @@ class HAZELCAST_API compact_reader
     boost::optional<double> read_nullable_float64(
       const std::string& field_name);
 
+    /**
+     * Reads a nullable array of nullable booleans.
+     *
+     * @param field_name name of the field.
+     * @return the value of the field.
+     * @throws hazelcast_serialization if the field does not exist in the
+     * schema or the type of the field does not match with the one defined
+     * in the schema.
+     */
+    boost::optional<std::vector<boost::optional<bool>>>
+    read_array_of_nullable_boolean(const std::string& field_name);
+
+    /**
+     * Reads a nullable array of nullable 8-bit two's complement signed
+     * integers.
+     *
+     * @param field_name name of the field.
+     * @return the value of the field.
+     * @throws hazelcast_serialization if the field does not exist in the
+     * schema or the type of the field does not match with the one defined
+     * in the schema.
+     */
+    boost::optional<std::vector<boost::optional<int8_t>>>
+    read_array_of_nullable_int8(const std::string& field_name);
+
+    /**
+     * Reads a nullable array of nullable 16-bit two's complement signed
+     * integers.
+     *
+     * @param field_name name of the field.
+     * @return the value of the field.
+     * @throws hazelcast_serialization if the field does not exist in the
+     * schema or the type of the field does not match with the one defined
+     * in the schema.
+     */
+    boost::optional<std::vector<boost::optional<int16_t>>>
+    read_array_of_nullable_int16(const std::string& field_name);
+
+    /**
+     * Reads a nullable array of nullable 32-bit two's complement signed
+     * integers.
+     *
+     * @param field_name name of the field.
+     * @return the value of the field.
+     * @throws hazelcast_serialization if the field does not exist in the
+     * schema or the type of the field does not match with the one defined
+     * in the schema.
+     */
+    boost::optional<std::vector<boost::optional<int32_t>>>
+    read_array_of_nullable_int32(const std::string& field_name);
+
+    /**
+     * Reads a nullable array of nullable 64-bit two's complement signed
+     * integers.
+     *
+     * @param field_name name of the field.
+     * @return the value of the field.
+     * @throws hazelcast_serialization if the field does not exist in the
+     * schema or the type of the field does not match with the one defined
+     * in the schema.
+     */
+    boost::optional<std::vector<boost::optional<int64_t>>>
+    read_array_of_nullable_int64(const std::string& field_name);
+
+    /**
+     * Reads a nullable array of nullable 32-bit IEEE 754 floating point
+     * numbers.
+     *
+     * @param field_name name of the field.
+     * @return the value of the field.
+     * @throws hazelcast_serialization if the field does not exist in the
+     * schema or the type of the field does not match with the one defined
+     * in the schema.
+     */
+    boost::optional<std::vector<boost::optional<float>>>
+    read_array_of_nullable_float32(const std::string& field_name);
+
+    /**
+     * Reads a nullable array of nullable 64-bit IEEE 754 floating point
+     * numbers.
+     *
+     * @param field_name name of the field.
+     * @return the value of the field.
+     * @throws hazelcast_serialization if the field does not exist in the
+     * schema or the type of the field does not match with the one defined
+     * in the schema.
+     */
+    boost::optional<std::vector<boost::optional<double>>>
+    read_array_of_nullable_float64(const std::string& field_name);
+
 private:
     compact_reader(pimpl::compact_stream_serializer& compact_stream_serializer,
                    object_data_input& object_data_input,
@@ -481,6 +571,12 @@ class HAZELCAST_API compact_reader
       typename boost::optional<T>>::type
     read();
     template<typename T>
+    typename std::enable_if<
+      std::is_same<std::vector<boost::optional<bool>>,
+                   typename std::remove_cv<T>::type>::value,
+      typename boost::optional<T>>::type
+    read();
+    template<typename T>
     boost::optional<T> read_array_of_primitive(
       const std::string& field_name,
       enum pimpl::field_kind field_kind,
@@ -505,6 +601,15 @@ class HAZELCAST_API compact_reader
       const std::string& field_name,
       enum pimpl::field_kind field_kind,
       enum pimpl::field_kind nullable_field_kind);
+    template<typename T>
+    boost::optional<std::vector<boost::optional<T>>> read_array_of_nullable(
+      const std::string& field_name,
+      enum pimpl::field_kind field_kind,
+      enum pimpl::field_kind nullable_field_kind);
+    template<typename T>
+    boost::optional<std::vector<boost::optional<T>>>
+    read_primitive_array_as_nullable_array(
+      const pimpl::field_descriptor& field_descriptor);
     static std::function<
       int32_t(serialization::object_data_input&, uint32_t, uint32_t)>
     get_offset_reader(int32_t data_length);
@@ -578,39 +683,39 @@ class HAZELCAST_API compact_writer
      * Writes a 32-bit two's complement signed integer.
      *
      * @param field_name name of the field.
-     * @param value     to be written.
+     * @param value to be written.
      */
     void write_int32(const std::string& field_name, int32_t value);
 
     /**
      * Writes a 64-bit two's complement signed integer.
      *
      * @param field_name name of the field.
-     * @param value     to be written.
+     * @param value to be written.
      */
     void write_int64(const std::string& field_name, int64_t value);
 
     /**
      * Writes a 32-bit IEEE 754 floating point number.
      *
      * @param field_name name of the field.
-     * @param value     to be written.
+     * @param value to be written.
      */
     void write_float32(const std::string& field_name, float value);
 
     /**
      * Writes a 64-bit IEEE 754 floating point number.
      *
      * @param field_name name of the field.
-     * @param value     to be written.
+     * @param value to be written.
      */
     void write_float64(const std::string& field_name, double value);
 
     /**
      * Writes an UTF-8 encoded string.
      *
      * @param field_name name of the field.
-     * @param value     to be written.
+     * @param value to be written.
      */
     void write_string(const std::string& field_name,
                       const boost::optional<std::string>& value);
@@ -619,7 +724,7 @@ class HAZELCAST_API compact_writer
      * Writes a nested compact object.
      *
      * @param field_name name of the field.
-     * @param value     to be written.
+     * @param value to be written.
      */
     template<typename T>
     void write_compact(const std::string& field_name,
@@ -629,7 +734,7 @@ class HAZELCAST_API compact_writer
      * Writes an array of booleans.
      *
      * @param field_name name of the field.
-     * @param value     to be written.
+     * @param value to be written.
      */
     void write_array_of_boolean(
       const std::string& field_name,
@@ -639,7 +744,7 @@ class HAZELCAST_API compact_writer
      * Writes an array of 8-bit two's complement signed integers.
      *
      * @param field_name name of the field.
-     * @param value     to be written.
+     * @param value to be written.
      */
     void write_array_of_int8(const std::string& field_name,
                              const boost::optional<std::vector<int8_t>>& value);
@@ -708,7 +813,7 @@ class HAZELCAST_API compact_writer
      * Writes an array of nested compact objects.
      *
      * @param field_name name of the field.
-     * @param value     to be written.
+     * @param value to be written.
      */
     template<typename T>
     void write_array_of_compact(
@@ -719,7 +824,7 @@ class HAZELCAST_API compact_writer
      * Writes a nullable boolean.
      *
      * @param field_name name of the field.
-     * @param value     to be written.
+     * @param value to be written.
      */
     void write_nullable_boolean(const std::string& field_name,
                                 const boost::optional<bool>& value);
@@ -728,7 +833,7 @@ class HAZELCAST_API compact_writer
      * Writes a nullable 8-bit two's complement signed integer.
      *
      * @param field_name name of the field.
-     * @param value     to be written.
+     * @param value to be written.
      */
     void write_nullable_int8(const std::string& field_name,
                              const boost::optional<int8_t>& value);
@@ -737,7 +842,7 @@ class HAZELCAST_API compact_writer
      * Writes a nullable 16-bit two's complement signed integer.
      *
      * @param field_name name of the field.
-     * @param value     to be written.
+     * @param value to be written.
      */
     void write_nullable_int16(const std::string& field_name,
                               const boost::optional<int16_t>& value);
@@ -746,7 +851,7 @@ class HAZELCAST_API compact_writer
      * Writes a nullable 32-bit two's complement signed integer.
      *
      * @param field_name name of the field.
-     * @param value     to be written.
+     * @param value to be written.
      */
     void write_nullable_int32(const std::string& field_name,
                               const boost::optional<int32_t>& value);
@@ -755,7 +860,7 @@ class HAZELCAST_API compact_writer
      * Writes a nullable 64-bit two's complement signed integer.
      *
      * @param field_name name of the field.
-     * @param value     to be written.
+     * @param value to be written.
      */
     void write_nullable_int64(const std::string& field_name,
                               const boost::optional<int64_t>& value);
@@ -764,7 +869,7 @@ class HAZELCAST_API compact_writer
      * Writes a nullable 32-bit IEEE 754 floating point number.
      *
      * @param field_name name of the field.
-     * @param value     to be written.
+     * @param value to be written.
      */
     void write_nullable_float32(const std::string& field_name,
                                 const boost::optional<float>& value);
@@ -773,11 +878,87 @@ class HAZELCAST_API compact_writer
      * Writes a nullable 64-bit IEEE 754 floating point number.
      *
      * @param field_name name of the field.
-     * @param value     to be written.
+     * @param value to be written.
      */
     void write_nullable_float64(const std::string& field_name,
                                 const boost::optional<double>& value);
 
+    /**
+     * Writes a nullable array of nullable booleans.
+     *
+     * @param field_name name of the field.
+     * @param value to be written.
+     */
+    void write_array_of_nullable_boolean(
+      const std::string& field_name,
+      const boost::optional<std::vector<boost::optional<bool>>>& value);
+
+    /**
+     * Writes a nullable array of nullable 8-bit two's complement signed
+     * integers.
+     *
+     * @param field_name name of the field.
+     * @param value to be written.
+     */
+    void write_array_of_nullable_int8(
+      const std::string& field_name,
+      const boost::optional<std::vector<boost::optional<int8_t>>>& value);
+
+    /**
+     * Writes a nullable array of nullable 16-bit two's complement signed
+     * integers.
+     *
+     * @param field_name name of the field.
+     * @param value to be written.
+     */
+    void write_array_of_nullable_int16(
+      const std::string& field_name,
+      const boost::optional<std::vector<boost::optional<int16_t>>>& value);
+
+    /**
+     * Writes a nullable array of nullable 32-bit two's complement signed
+     * integers.
+     *
+     * @param field_name name of the field.
+     * @param value to be written.
+     */
+    void write_array_of_nullable_int32(
+      const std::string& field_name,
+      const boost::optional<std::vector<boost::optional<int32_t>>>& value);
+
+    /**
+     * Writes a nullable array of nullable 64-bit two's complement signed
+     * integers.
+     *
+     * @param field_name name of the field.
+     * @param value to be written.
+     */
+    void write_array_of_nullable_int64(
+      const std::string& field_name,
+      const boost::optional<std::vector<boost::optional<int64_t>>>& value);
+
+    /**
+     * Writes a nullable array of nullable 32-bit IEEE 754 floating point
+     * numbers.
+     *
+     * @param field_name name of the field.
+     * @param value to be written.
+     */
+    void write_array_of_nullable_float32(
+      const std::string& field_name,
+      const boost::optional<std::vector<boost::optional<float>>>& value);
+
+    /**
+     * Writes a nullable array of nullable 64-bit IEEE 754 floating point
+     * numbers.
+     *
+     * @param field_name name of the field.
+     * @param value to be written.
+     */
+    void write_array_of_nullable_float64(
+      const std::string& field_name,
+      const boost::optional<std::vector<boost::optional<double>>>& value);
+
 private:
     friend compact_writer pimpl::create_compact_writer(
       pimpl::default_compact_writer* default_compact_writer);
@@ -870,6 +1051,27 @@ class HAZELCAST_API default_compact_writer
                                 const boost::optional<float>& value);
     void write_nullable_float64(const std::string& field_name,
                                 const boost::optional<double>& value);
+    void write_array_of_nullable_boolean(
+      const std::string& field_name,
+      const boost::optional<std::vector<boost::optional<bool>>>& value);
+    void write_array_of_nullable_int8(
+      const std::string& field_name,
+      const boost::optional<std::vector<boost::optional<int8_t>>>& value);
+    void write_array_of_nullable_int16(
+      const std::string& field_name,
+      const boost::optional<std::vector<boost::optional<int16_t>>>& value);
+    void write_array_of_nullable_int32(
+      const std::string& field_name,
+      const boost::optional<std::vector<boost::optional<int32_t>>>& value);
+    void write_array_of_nullable_int64(
+      const std::string& field_name,
+      const boost::optional<std::vector<boost::optional<int64_t>>>& value);
+    void write_array_of_nullable_float32(
+      const std::string& field_name,
+      const boost::optional<std::vector<boost::optional<float>>>& value);
+    void write_array_of_nullable_float64(
+      const std::string& field_name,
+      const boost::optional<std::vector<boost::optional<double>>>& value);
     void end();
 
 private: