typed_array_element_type -> typed_array_values

Author: danielaparker

doc/ref/corelib/basic_json_visitor.md

@@ -178,7 +178,7 @@ Member type                         |Definition
         semantic_tag tag = semantic_tag::none,
         const ser_context& context = ser_context()); (35)
 
-    bool begin_multi_dim(const span<const size_t>& shape,
+    bool begin_multi_dim(const span<const size_t>& extents,
                          semantic_tag tag,
                          const ser_context& context); (36) 
 

include/jsoncons/detail/mdspan.hpp

@@ -0,0 +1,46 @@
+// Copyright 2013-2026 Daniel Parker
+// Distributed under the Boost license, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// See https://github.com/danielaparker/jsoncons for latest version
+
+#ifndef JSONCONS_DETAIL_MDSPAN_HPP
+#define JSONCONS_DETAIL_MDSPAN_HPP
+
+#include <array>
+#include <cstddef>
+#include <iterator>
+#include <limits>
+#include <memory> // std::addressof
+#include <type_traits> // std::enable_if, std::true_type, std::false_type
+
+#include <jsoncons/utility/more_type_traits.hpp>
+
+namespace jsoncons {
+namespace detail {
+
+template< class IndexType, std::size_t Rank >
+class dextents
+{
+public:
+    using index_type = IndexType;
+    std::size_t rank = Rank;
+};
+
+struct layout_left
+{
+};
+
+struct layout_right
+{
+};
+
+template< typename T, typename Extents, typename LayoutPolicy = layout_right>
+class mdspan
+{
+};
+
+} // namespace detail
+} // namespace jsoncons
+
+#endif // JSONCONS_DETAIL_MDSPAN_HPP

include/jsoncons/json_visitor.hpp

@@ -714,14 +714,14 @@ namespace jsoncons {
             JSONCONS_VISITOR_RETURN;
         }
 
-        virtual JSONCONS_VISITOR_RETURN_TYPE visit_begin_multi_dim(const jsoncons::span<const size_t>& shape,
+        virtual JSONCONS_VISITOR_RETURN_TYPE visit_begin_multi_dim(const jsoncons::span<const size_t>& extents,
             semantic_tag tag,
             const ser_context& context, 
             std::error_code& ec) 
         {
             visit_begin_array(2, tag, context, ec);
-            visit_begin_array(shape.size(), tag, context, ec);
-            for (auto it = shape.begin(); it != shape.end(); ++it)
+            visit_begin_array(extents.size(), tag, context, ec);
+            for (auto it = extents.begin(); it != extents.end(); ++it)
             {
                 visit_uint64(*it, semantic_tag::none, context, ec);
             }

include/jsoncons/reflect/decode_traits.hpp

@@ -38,13 +38,13 @@ namespace reflect {
 
 template <typename T>
 typename std::enable_if<ext_traits::is_back_insertable<T>::value,void>::type
-read_typed_array(jsoncons::span<uint8_t> typed_array, typed_array_element_type element_type, T& v)
+read_typed_array(jsoncons::span<uint8_t> typed_array, typed_array_values element_type, T& v)
 {
     using value_type = typename T::value_type;
 
     switch (element_type)
     {
-        case typed_array_element_type::uint8:
+        case typed_array_values::uint8_value:
         {
             auto ta = typed_array_cast<const uint8_t>(typed_array);
             for (auto item : ta)
@@ -53,7 +53,7 @@ read_typed_array(jsoncons::span<uint8_t> typed_array, typed_array_element_type e
             }
             break;
         }
-        case typed_array_element_type::uint16:
+        case typed_array_values::uint16_value:
         {
             auto ta = typed_array_cast<const uint16_t>(typed_array);
             for (auto item : ta)
@@ -62,7 +62,7 @@ read_typed_array(jsoncons::span<uint8_t> typed_array, typed_array_element_type e
             }
             break;
         }
-        case typed_array_element_type::uint32:
+        case typed_array_values::uint32_value:
         {
             auto ta = typed_array_cast<const uint32_t>(typed_array);
             for (auto item : ta)
@@ -71,7 +71,7 @@ read_typed_array(jsoncons::span<uint8_t> typed_array, typed_array_element_type e
             }
             break;
         }
-        case typed_array_element_type::uint64:
+        case typed_array_values::uint64_value:
         {
             auto ta = typed_array_cast<const uint64_t>(typed_array);
             for (auto item : ta)
@@ -80,7 +80,7 @@ read_typed_array(jsoncons::span<uint8_t> typed_array, typed_array_element_type e
             }
             break;
         }
-        case typed_array_element_type::int8:
+        case typed_array_values::int8_value:
         {
             auto ta = typed_array_cast<const int8_t>(typed_array);
             for (auto item : ta)
@@ -89,7 +89,7 @@ read_typed_array(jsoncons::span<uint8_t> typed_array, typed_array_element_type e
             }
             break;
         }
-        case typed_array_element_type::int16:
+        case typed_array_values::int16_value:
         {
             auto ta = typed_array_cast<const int16_t>(typed_array);
             for (auto item : ta)
@@ -98,7 +98,7 @@ read_typed_array(jsoncons::span<uint8_t> typed_array, typed_array_element_type e
             }
             break;
         }
-        case typed_array_element_type::int32:
+        case typed_array_values::int32_value:
         {
             auto ta = typed_array_cast<const int32_t>(typed_array);
             for (auto item : ta)
@@ -107,7 +107,7 @@ read_typed_array(jsoncons::span<uint8_t> typed_array, typed_array_element_type e
             }
             break;
         }
-        case typed_array_element_type::int64:
+        case typed_array_values::int64_value:
         {
             auto ta = typed_array_cast<const int64_t>(typed_array);
             for (auto item : ta)
@@ -116,7 +116,7 @@ read_typed_array(jsoncons::span<uint8_t> typed_array, typed_array_element_type e
             }
             break;
         }
-        case typed_array_element_type::half_float:
+        case typed_array_values::half_value:
         {
             auto ta = typed_array_cast<const int16_t>(typed_array);
             for (auto item : ta)
@@ -125,7 +125,7 @@ read_typed_array(jsoncons::span<uint8_t> typed_array, typed_array_element_type e
             }
             break;
         }
-        case typed_array_element_type::float32:
+        case typed_array_values::float_value:
         {
             auto ta = typed_array_cast<const float>(typed_array);
             for (auto item : ta)
@@ -134,7 +134,7 @@ read_typed_array(jsoncons::span<uint8_t> typed_array, typed_array_element_type e
             }
             break;
         }
-        case typed_array_element_type::float64:
+        case typed_array_values::double_value:
         {
             auto ta = typed_array_cast<const double>(typed_array);
             for (auto item : ta)
@@ -424,7 +424,7 @@ struct decode_traits<T,
                 if (cursor.is_typed_array())
                 {
                     read_typed_array(cursor.typed_array(), cursor.element_type(), v);
-                    cursor.clear_typed_array();
+                    cursor.to_end_array();
                 }
                 else
                 {
@@ -493,7 +493,7 @@ struct decode_traits<T,
             if (cursor.is_typed_array())
             {
                 read_typed_array(cursor.typed_array(), cursor.element_type(), v);
-                cursor.clear_typed_array();
+                cursor.to_end_array();
             }
             else
             {

include/jsoncons/staj_cursor.hpp

@@ -310,17 +310,17 @@ class basic_staj_cursor
         return false;
     }
 
-    virtual typed_array_element_type element_type() const 
+    virtual typed_array_values element_type() const 
     {
-        return typed_array_element_type{};
+        return typed_array_values{};
     }
 
     virtual jsoncons::span<uint8_t> typed_array() 
     {
         return jsoncons::span<uint8_t>{};
     }
 
-    virtual void clear_typed_array() 
+    virtual void to_end_array() 
     {
     }
 };

include/jsoncons/typed_array.hpp

@@ -24,11 +24,19 @@
 
 namespace jsoncons {
 
-enum class typed_array_element_type
+enum class typed_array_values
 {
-    uint8=1,uint16,uint32,uint64,
-    int8,int16,int32,int64, 
-    half_float, float32, float64
+    uint8_value = 1,
+    uint16_value = 2,
+    uint32_value = 4,
+    uint64_value = 8,
+    int8_value = 16,
+    int16_value = 32,
+    int32_value = 64,
+    int64_value = 128, 
+    half_value = 256, 
+    float_value = 512, 
+    double_value = 1024
 };
 
 template <typename T>
@@ -154,6 +162,121 @@ jsoncons::span<const double> typed_array_cast<const double>(jsoncons::span<uint8
     return jsoncons::span<const double>{reinterpret_cast<const double*>(bytes.data()), bytes.size()/sizeof(double)};
 }
 
+class slice
+{
+    static constexpr size_t npos = size_t(-1);
+
+    size_t start_;
+    size_t stop_;
+    size_t step_;
+public:
+    constexpr explicit slice(size_t start = npos, size_t stop = npos, size_t step=1)
+        : start_(start), stop_(stop), step_(step)
+    {
+    }
+
+    slice(const slice& other) = default;
+    slice(slice&& other) = default;
+
+    slice& operator=(const slice& other) = default;
+    slice& operator=(slice&& other) = default;
+
+    size_t start(size_t origin) const
+    {
+        return start_ == npos ? origin : start_;
+    }
+
+    size_t stop(size_t origin, size_t n) const
+    {
+        return stop_ == npos ? (origin+n) : stop_;
+    }
+    size_t step() const
+    {
+        return step_;
+    }
+
+    size_t length(size_t origin, size_t n) const
+    {
+        size_t y = stop(origin, n);
+        size_t x = start(origin);
+
+        assert(y >= x);
+        size_t w = y - x;
+        return w/step_ + (w % step_ != 0);
+    }
+};
+
+#if 0
+struct row_major
+{
+    static void calculate_strides(jsoncons::span<const std::size_t> extents, 
+        std::vector<std::size_t>& strides, size_t& size)
+    {
+        size = 1;
+        const size_t num_extents = extents.size();
+        for (size_t i = 0; i < num_extents; ++i)
+        {
+            strides[num_extents-i-1] = size;
+            size *= extents[num_extents-i-1];
+        }
+    }
+/*
+    template <size_t N>
+    static void update_offsets(size_t rel, indices_t<N>& offsets)
+    {
+        offsets[N-1] += rel;
+    }
+*/
+    template <size_t N>
+    static std::vector<std::size_t> calculate_offsets(size_t rel,
+        jsoncons::span<const std::size_t> strides, 
+        jsoncons::span<const std::size_t> slices)
+    {
+        indices_t<N> offsets;
+        offsets[N-1] = rel + slices[N-1].start(Base::origin()) * strides[N-1];
+        for (size_t i = 0; i+1 < N; ++i)
+        {
+            offsets[i] = slices[i].start(Base::origin()) * strides[i]; 
+        }
+        return offsets;
+    }
+};
+
+struct column_major
+{
+    template <size_t N>
+    static void calculate_strides(const extents_t<N>& extents, indices_t<N>& strides, size_t& size)
+    {
+        size = 1;
+        for (size_t i = 0; i < N; ++i)
+        {
+            strides[i] = size;
+            size *= extents[i];
+        }
+    }
+/*
+    template <size_t N>
+    static void update_offsets(size_t rel, indices_t<N>& offsets)
+    {
+        offsets[0] += rel;
+    }
+*/
+    template <size_t N, typename Base>
+    static indices_t<N> calculate_offsets(size_t rel,
+        const indices_t<N>& strides, 
+        const std::array<slice,N>& slices)
+    {
+        indices_t<N> offsets;
+        offsets[0] = rel + Base::rebase_to_zero(slices[0].start(Base::origin())) * strides[0];
+        for (size_t i = 1; i < N; ++i)
+        {
+            offsets[i] = Base::rebase_to_zero(slices[i].start(Base::origin())) * strides[i]; 
+        }
+        return offsets;
+    }
+};
+#endif
+
 } // namespace jsoncons
 
 #endif // JSONCONS_TYPED_ARRAY_HPP

include/jsoncons_ext/cbor/cbor_cursor.hpp

@@ -168,7 +168,7 @@ class basic_cbor_cursor : public basic_staj_cursor<char>, private virtual ser_co
         return parser_.is_typed_array();
     }
 
-    typed_array_element_type element_type() const final
+    typed_array_values element_type() const final
     {
         return parser_.element_type();
     }
@@ -178,9 +178,9 @@ class basic_cbor_cursor : public basic_staj_cursor<char>, private virtual ser_co
         return parser_.typed_array();
     }
 
-    void clear_typed_array() final
+    void to_end_array() final
     {
-        parser_.clear_typed_array();
+        parser_.to_end_array();
     }
 
     const staj_event& current() const override