move typed_array from visitor to cursor

Author: danielaparker

include/jsoncons/reflect/decode_traits.hpp

@@ -422,6 +422,7 @@ struct decode_traits<T,
                 if (cursor.is_typed_array())
                 {
                     read_typed_array(cursor.typed_array(), cursor.element_type(), v);
+                    cursor.clear_typed_array();
                 }
                 else
                 {
@@ -484,20 +485,16 @@ struct decode_traits<T,
     {
         std::error_code ec;
 
-        cursor.array_expected(ec);
-        if (JSONCONS_UNLIKELY(ec))
-        {
-            return result_type(jsoncons::unexpect, ec, cursor.line(), cursor.column());
-        }
-        if (cursor.is_typed_array())
+        if (cursor.current().event_type() == staj_events::begin_array)
         {
-            std::cout << "IS TYPED ARRAY 3\n";
-        }
-        switch (cursor.current().event_type())
-        {
-            case staj_events::begin_array:
+            T v = jsoncons::make_obj_using_allocator<T>(aset.get_allocator());
+            if (cursor.is_typed_array())
+            {
+                read_typed_array(cursor.typed_array(), cursor.element_type(), v);
+                cursor.clear_typed_array();
+            }
+            else
             {
-                T v = jsoncons::make_obj_using_allocator<T>(aset.get_allocator());
                 if (cursor.current().size() > 0)
                 {
                     reserve_storage(typename std::integral_constant<bool, ext_traits::has_reserve<T>::value>::type(), v, cursor.current().size());
@@ -518,12 +515,12 @@ struct decode_traits<T,
                 {
                     return result_type{jsoncons::unexpect, conv_errc::not_vector, cursor.line(), cursor.column()}; 
                 }
-                return result_type{std::move(v)};
-            }
-            default:
-            {
-                return result_type(jsoncons::unexpect, conv_errc::not_vector, cursor.line(), cursor.column()); 
             }
+            return result_type{std::move(v)};
+        }
+        else
+        {
+            return result_type(jsoncons::unexpect, conv_errc::not_vector, cursor.line(), cursor.column()); 
         }
     }
 

include/jsoncons/staj_cursor.hpp

@@ -315,10 +315,14 @@ class basic_staj_cursor
         return typed_array_element_type{};
     }
 
-    virtual jsoncons::span<uint8_t> typed_array()  
+    virtual jsoncons::span<uint8_t> typed_array() const 
     {
         return jsoncons::span<uint8_t>{};
     }
+
+    virtual void clear_typed_array() 
+    {
+    }
 };
 
 template <typename CharT>

include/jsoncons/typed_array.hpp

@@ -24,222 +24,11 @@
 
 namespace jsoncons {
 
-struct uint8_array_arg_t {explicit uint8_array_arg_t() = default; };
-constexpr uint8_array_arg_t uint8_array_arg = uint8_array_arg_t();
-struct uint16_array_arg_t {explicit uint16_array_arg_t() = default; };
-struct uint32_array_arg_t {explicit uint32_array_arg_t() = default; };
-constexpr uint32_array_arg_t uint32_array_arg = uint32_array_arg_t();
-struct uint64_array_arg_t {explicit uint64_array_arg_t() = default; };
-constexpr uint64_array_arg_t uint64_array_arg = uint64_array_arg_t();
-struct int8_array_arg_t {explicit int8_array_arg_t() = default; };
-constexpr int8_array_arg_t int8_array_arg = int8_array_arg_t();
-struct int16_array_arg_t {explicit int16_array_arg_t() = default; };
-constexpr int16_array_arg_t int16_array_arg = int16_array_arg_t();
-struct int32_array_arg_t {explicit int32_array_arg_t() = default; };
-constexpr int32_array_arg_t int32_array_arg = int32_array_arg_t();
-struct int64_array_arg_t {explicit int64_array_arg_t() = default; };
-constexpr int64_array_arg_t int64_array_arg = int64_array_arg_t();
-constexpr uint16_array_arg_t uint16_array_arg = uint16_array_arg_t();
-struct half_array_arg_t {explicit half_array_arg_t() = default; };
-constexpr half_array_arg_t half_array_arg = half_array_arg_t();
-struct float_array_arg_t {explicit float_array_arg_t() = default; };
-constexpr float_array_arg_t float_array_arg = float_array_arg_t();
-struct double_array_arg_t {explicit double_array_arg_t() = default; };
-constexpr double_array_arg_t double_array_arg = double_array_arg_t();
-struct float128_array_arg_t {explicit float128_array_arg_t() = default; };
-constexpr float128_array_arg_t float128_array_arg = float128_array_arg_t();
-
-enum class typed_array_element_type{
+enum class typed_array_element_type
+{
     uint8=1,uint16,uint32,uint64,
     int8,int16,int32,int64, 
-    half_float, float32, float64};
-
-class typed_array_view
-{
-    typed_array_element_type type_;
-    union 
-    {
-        const uint8_t* uint8_data_;
-        const uint16_t* uint16_data_;
-        const uint32_t* uint32_data_;
-        const uint64_t* uint64_data_;
-        const int8_t* int8_data_;
-        const int16_t* int16_data_;
-        const int32_t* int32_data_;
-        const int64_t* int64_data_;
-        const float* float_data_;
-        const double* double_data_;
-    } data_;
-    std::size_t size_{0};
-public:
-
-    typed_array_view()
-        : type_(), data_()
-    {
-    }
-
-    typed_array_view(const typed_array_view& other)
-        : type_(other.type_), data_(other.data_), size_(other.size())
-    {
-    }
-
-    typed_array_view(typed_array_view&& other) noexcept
-    {
-        swap(*this,other);
-    }
-
-    typed_array_view(const uint8_t* data, std::size_t size)
-        : type_(typed_array_element_type::uint8), size_(size)
-    {
-        data_.uint8_data_ = data;
-    }
-
-    typed_array_view(const uint16_t* data, std::size_t size)
-        : type_(typed_array_element_type::uint16), size_(size)
-    {
-        data_.uint16_data_ = data;
-    }
-
-    typed_array_view(const uint32_t* data, std::size_t size)
-        : type_(typed_array_element_type::uint32), size_(size)
-    {
-        data_.uint32_data_ = data;
-    }
-
-    typed_array_view(const uint64_t* data, std::size_t size)
-        : type_(typed_array_element_type::uint64), size_(size)
-    {
-        data_.uint64_data_ = data;
-    }
-
-    typed_array_view(const int8_t* data, std::size_t size)
-        : type_(typed_array_element_type::int8), size_(size)
-    {
-        data_.int8_data_ = data;
-    }
-
-    typed_array_view(const int16_t* data, std::size_t size)
-        : type_(typed_array_element_type::int16), size_(size)
-    {
-        data_.int16_data_ = data;
-    }
-
-    typed_array_view(const int32_t* data, std::size_t size)
-        : type_(typed_array_element_type::int32), size_(size)
-    {
-        data_.int32_data_ = data;
-    }
-
-    typed_array_view(const int64_t* data, std::size_t size)
-        : type_(typed_array_element_type::int64), size_(size)
-    {
-        data_.int64_data_ = data;
-    }
-
-    typed_array_view(half_array_arg_t, const uint16_t* data, std::size_t size)
-        : type_(typed_array_element_type::half_float), size_(size)
-    {
-        data_.uint16_data_ = data;
-    }
-
-    typed_array_view(const float* data, std::size_t size)
-        : type_(typed_array_element_type::float32), size_(size)
-    {
-        data_.float_data_ = data;
-    }
-
-    typed_array_view(const double* data, std::size_t size)
-        : type_(typed_array_element_type::float64), size_(size)
-    {
-        data_.double_data_ = data;
-    }
-
-    typed_array_view& operator=(const typed_array_view& other)
-    {
-        typed_array_view temp(other);
-        swap(*this,temp);
-        return *this;
-    }
-
-    typed_array_element_type type() const {return type_;}
-
-    std::size_t size() const
-    {
-        return size_;
-    }
-
-    jsoncons::span<const uint8_t> data(uint8_array_arg_t) const
-    {
-        JSONCONS_ASSERT(type_ == typed_array_element_type::uint8);
-        return jsoncons::span<const uint8_t>(data_.uint8_data_, size_);
-    }
-
-    jsoncons::span<const uint16_t> data(uint16_array_arg_t) const
-    {
-        JSONCONS_ASSERT(type_ == typed_array_element_type::uint16);
-        return jsoncons::span<const uint16_t>(data_.uint16_data_, size_);
-    }
-
-    jsoncons::span<const uint32_t> data(uint32_array_arg_t) const
-    {
-        JSONCONS_ASSERT(type_ == typed_array_element_type::uint32);
-        return jsoncons::span<const uint32_t>(data_.uint32_data_, size_);
-    }
-
-    jsoncons::span<const uint64_t> data(uint64_array_arg_t) const
-    {
-        JSONCONS_ASSERT(type_ == typed_array_element_type::uint64);
-        return jsoncons::span<const uint64_t>(data_.uint64_data_, size_);
-    }
-
-    jsoncons::span<const int8_t> data(int8_array_arg_t) const
-    {
-        JSONCONS_ASSERT(type_ == typed_array_element_type::int8);
-        return jsoncons::span<const int8_t>(data_.int8_data_, size_);
-    }
-
-    jsoncons::span<const int16_t> data(int16_array_arg_t) const
-    {
-        JSONCONS_ASSERT(type_ == typed_array_element_type::int16);
-        return jsoncons::span<const int16_t>(data_.int16_data_, size_);
-    }
-
-    jsoncons::span<const int32_t> data(int32_array_arg_t) const
-    {
-        JSONCONS_ASSERT(type_ == typed_array_element_type::int32);
-        return jsoncons::span<const int32_t>(data_.int32_data_, size_);
-    }
-
-    jsoncons::span<const int64_t> data(int64_array_arg_t) const
-    {
-        JSONCONS_ASSERT(type_ == typed_array_element_type::int64);
-        return jsoncons::span<const int64_t>(data_.int64_data_, size_);
-    }
-
-    jsoncons::span<const uint16_t> data(half_array_arg_t) const
-    {
-        JSONCONS_ASSERT(type_ == typed_array_element_type::half_float);
-        return jsoncons::span<const uint16_t>(data_.uint16_data_, size_);
-    }
-
-    jsoncons::span<const float> data(float_array_arg_t) const
-    {
-        JSONCONS_ASSERT(type_ == typed_array_element_type::float32);
-        return jsoncons::span<const float>(data_.float_data_, size_);
-    }
-
-    jsoncons::span<const double> data(double_array_arg_t) const
-    {
-        JSONCONS_ASSERT(type_ == typed_array_element_type::float64);
-        return jsoncons::span<const double>(data_.double_data_, size_);
-    }
-
-    friend void swap(typed_array_view& a, typed_array_view& b) noexcept
-    {
-        std::swap(a.data_,b.data_);
-        std::swap(a.type_,b.type_);
-        std::swap(a.size_,b.size_);
-    }
+    half_float, float32, float64
 };
 
 template <typename T>

include/jsoncons_ext/cbor/cbor_cursor.hpp

@@ -173,11 +173,16 @@ class basic_cbor_cursor : public basic_staj_cursor<char>, private virtual ser_co
         return parser_.element_type();
     }
 
-    jsoncons::span<uint8_t> typed_array() final
+    jsoncons::span<uint8_t> typed_array() const final
     {
         return parser_.typed_array();
     }
 
+    void clear_typed_array() final
+    {
+        parser_.clear_typed_array();
+    }
+
     const staj_event& current() const override
     {
         return cursor_visitor_.event();

include/jsoncons_ext/cbor/cbor_parser.hpp

@@ -289,11 +289,15 @@ class basic_cbor_parser : public ser_context
         return element_type_;
     }
 
-    jsoncons::span<uint8_t> typed_array()
+    jsoncons::span<uint8_t> typed_array() const
+    {
+        return typed_array_;
+    }
+
+    void clear_typed_array()
     {
         is_typed_array_ = false;
         state_stack_.pop_back();
-        return typed_array_;
     }
 
     void parse(item_event_visitor& visitor, std::error_code& ec)

test/cbor/src/cbor_typed_array_tests.cpp

@@ -58,7 +58,7 @@ struct my_cbor_visitor : public default_json_visitor
         JSONCONS_VISITOR_RETURN;
     }
 };
-#if 0
+
 TEST_CASE("cbor multi dim row major cursor tests")
 {
     SECTION("Tag 86, float64, little endian")
@@ -104,10 +104,9 @@ TEST_CASE("cbor typed array cursor tests")
         //}
     }
 }
-#endif
+
 TEST_CASE("cbor typed array tests")
 {
-#if 0
     SECTION("Tag 64 (uint8 Typed Array)")
     {
         //std::cout << "CBOR typed array Tag 64 (uint8 Typed Array)" << '\n';
@@ -319,7 +318,7 @@ TEST_CASE("cbor typed array tests")
         check_native(std::integral_constant<bool, jsoncons::endian::native == jsoncons::endian::little>(),
             input, buf);
     }
-#endif
+
     SECTION("Tag 71 (uint64,little endian)")
     {
         //std::cout << "CBOR typed array Tag 71 (uint64,little endian)" << '\n';