diff options
author | Claudius 'keldu' Holeksa <mail@keldu.de> | 2024-09-07 19:25:12 +0200 |
---|---|---|
committer | Claudius 'keldu' Holeksa <mail@keldu.de> | 2024-09-07 19:25:12 +0200 |
commit | 4a4bfa2ccf179e15a5b8e98f398c16f693ddd3e5 (patch) | |
tree | 274ab587c4de1ca2b254feed8dd721792fbc7885 | |
parent | 02e0554147004c6498d00cc88a1fa43e38e4ba3d (diff) |
Fixing raw data encoding. Prep for C layer
-rw-r--r-- | modules/codec/c++/data_raw.hpp | 190 | ||||
-rw-r--r-- | modules/codec/c++/schema_meta.hpp | 6 | ||||
-rw-r--r-- | modules/codec/tests/data_raw.cpp | 26 |
3 files changed, 191 insertions, 31 deletions
diff --git a/modules/codec/c++/data_raw.hpp b/modules/codec/c++/data_raw.hpp index 88a0ee2..37e56d9 100644 --- a/modules/codec/c++/data_raw.hpp +++ b/modules/codec/c++/data_raw.hpp @@ -123,6 +123,77 @@ public: } }; +template<typename T, uint64_t N> +class data<schema::Ref<schema::Primitive<T,N>>, encode::NativeRaw> { +public: + using ReferencedSchema = schema::Primitive<T,N>; + using Schema = schema::Ref<ReferencedSchema>; + using MetaSchema = typename meta_schema<Schema>::MetaSchema; +private: + ref<typename native_data_type<ReferencedSchema>::type > value_; +public: + data(ref<typename native_data_type<ReferencedSchema >::type > value__): + value_{value__} + {} + + SAW_DEFAULT_COPY(data); + SAW_FORBID_MOVE(data); + + void set(typename native_data_type<ReferencedSchema>::type val){ + value_() = val; + } + + typename native_data_type<ReferencedSchema>::type get() const { + return value_(); + } + + data<ReferencedSchema, encode::NativeRaw> operator*(const data<Schema, encode::NativeRaw>& rhs)const{ + return {get() * rhs.get()}; + } + + data<ReferencedSchema, encode::NativeRaw> operator/(const data<Schema, encode::NativeRaw>& rhs)const{ + return {get() / rhs.get()}; + } + + data<ReferencedSchema, encode::NativeRaw> operator+(const data<Schema, encode::NativeRaw>& rhs)const{ + return {get() + rhs.get()}; + } + + data<Schema, encode::NativeRaw>& operator+=(const data<Schema, encode::NativeRaw>& rhs)const{ + value_ += rhs.get(); + return *this; + } + + data<Schema, encode::NativeRaw>& operator-=(const data<Schema, encode::NativeRaw>& rhs)const{ + value_ -= rhs.get(); + return *this; + } + + data<ReferencedSchema, encode::NativeRaw> operator-(const data<Schema, encode::NativeRaw>& rhs)const{ + return {get() - rhs.get()}; + } + + template<typename Enc> + bool operator==(const data<Schema, Enc>& rhs)const{ + return get() == rhs.get(); + } + + template<typename Enc> + bool operator==(const data<ReferencedSchema, Enc>& rhs)const{ + return get() == rhs.get(); + } + + template<typename Enc> + bool operator<(const data<Schema, Enc>& rhs) const { + return get() < rhs.get(); + } + + template<typename Enc> + bool operator<(const data<ReferencedSchema, Enc>& rhs) const { + return get() < rhs.get(); + } +}; + /** * Mixed precision class for native formats */ @@ -223,7 +294,7 @@ private: template<uint64_t i = 0u> struct init_helper { - static void apply(std::tuple<data<T,encode::NativeRaw,storage::Default>...>& val, data<Schema, encode::NativeRaw>&& init){ + static void apply(std::tuple<data<T,encode::NativeRaw>...>& val, data<Schema, encode::NativeRaw>&& init){ auto& val_i = val.template get<i>(); auto& init_i = init.template get<i>(); @@ -294,7 +365,7 @@ private: template<uint64_t i = 0u> struct init_helper { - static void apply(std::tuple<data<T,encode::NativeRaw,storage::Default>...>& val, data<MetaSchema, encode::NativeRaw>&& init){ + static void apply(std::tuple<data<T,encode::NativeRaw>...>& val, data<MetaSchema, encode::NativeRaw>&& init){ auto& val_i = val.template get<i>(); auto& init_i = init.template get<i>(); @@ -337,20 +408,10 @@ class data<schema::Array<T,Dim>, encode::NativeRaw> { using Schema = schema::Array<T,Dim>; using MetaSchema = typename meta_schema<Schema>::MetaSchema; - using DataType = std::conditional< - is_primitive<typename T>::value, - typename native_data_type<typename T::StorageSchema>::type - >; private: // data<schema::FixedArray<schema::UInt64, Dim>> dims_; std::array<uint64_t, Dim> dims_; - std::vector< - std::conditional< - is_primitive<Schema>::value, - typename native_data_type<T>::type, - data<T, encode::NativeRaw> - > - > value_; + std::vector<typename raw_native_array_type_helper<T>::Type> value_; uint64_t get_full_size() const { uint64_t s = 1; @@ -425,30 +486,32 @@ class data<schema::Array<T,Dim>, encode::NativeRaw> { static_assert(sizeof...(Dims)==Dim, "Argument size must be equal to the Dimension"); } - data<T, encode::NativeRaw>& at(const std::array<uint64_t, Dim>& ind){ - return value_.at(this->get_flat_index(ind)); + data<schema::Ref<T>, encode::NativeRaw> at(const std::array<uint64_t, Dim>& ind){ + return {value_.at(this->get_flat_index(ind))}; } - const data<T, encode::NativeRaw>& at(const std::array<uint64_t, Dim>& ind) const { - return value_.at(this->get_flat_index(ind)); + const data<schema::Ref<T>, encode::NativeRaw> at(const std::array<uint64_t, Dim>& ind) const { + return {value_.at(this->get_flat_index(ind))}; } template<std::integral... Dims> - data<T, encode::NativeRaw>& at(Dims... i){ - return value_.at(this->get_flat_index(std::array<uint64_t, Dim>{static_cast<uint64_t>(i)...})); + data<schema::Ref<T>, encode::NativeRaw> at(Dims... i){ + return {value_.at(this->get_flat_index(std::array<uint64_t, Dim>{static_cast<uint64_t>(i)...}))}; } template<std::integral... Dims> - const data<T, encode::NativeRaw>& at(Dims... i) const { - return value_.at(this->get_flat_index(std::array<uint64_t, Dim>{static_cast<uint64_t>(i)...})); + const data<schema::Ref<T>, encode::NativeRaw> at(Dims... i) const { + return {value_.at(this->get_flat_index(std::array<uint64_t, Dim>{static_cast<uint64_t>(i)...}))}; } - data<T,encode::NativeRaw>& at(const data<schema::FixedArray<schema::UInt64,Dim>>& i){ - return value_.at(this->get_flat_index(i)); + template<typename Encoding> + data<schema::Ref<T>,encode::NativeRaw> at(const data<schema::FixedArray<schema::UInt64,Dim>, Encoding>& i){ + return {value_.at(this->get_flat_index(i))}; } - const data<T,encode::NativeRaw>& at(const data<schema::FixedArray<schema::UInt64,Dim>>& i)const{ - return value_.at(this->get_flat_index(i)); + template<typename Encoding> + const data<schema::Ref<T>,encode::NativeRaw> at(const data<schema::FixedArray<schema::UInt64,Dim>, Encoding>& i)const{ + return {value_.at(this->get_flat_index(i))}; } std::size_t get_dim_size(uint64_t i) const { @@ -457,18 +520,13 @@ class data<schema::Array<T,Dim>, encode::NativeRaw> { size_t size() const { return value_.size();} - data<schema::FixedArray<schema::UInt64, Dim>> get_dims() const { + data<schema::FixedArray<schema::UInt64, Dim>, encode::NativeRaw> get_dims() const { return {dims_}; } private: template<typename U> uint64_t get_flat_index(const U& i) const { - static_assert( - std::is_same_v<U,data<schema::FixedArray<schema::UInt64,Dim>>> or - std::is_same_v<U,std::array<uint64_t,Dim>>, - "Unsupported type" - ); assert(value_.size() == get_full_size()); uint64_t s = 0; @@ -494,5 +552,75 @@ private: } }; +template<typename T, uint64_t... D> +class data<schema::FixedArray<T,D...>, encode::NativeRaw> { +public: + using Schema = schema::FixedArray<T,D...>; + using MetaSchema = typename meta_schema<Schema>::MetaSchema; +private: + //using inner_type = std::array<data<T, encode::Native>, multiply_helper<Dims...>::value>; + //std::unique_ptr<inner_type> value_; + using ArrayT = std::array<typename raw_native_array_type_helper<T>::Type, ct_multiply<uint64_t, D...>::value>; + ArrayT value_; + +public: + data() = default; + data(data<MetaSchema, encode::NativeRaw>){} + data(const std::array<data<T, encode::NativeRaw>, ct_multiply<uint64_t,D...>::value>& value__): + value_{value__} + {} + + data<schema::Ref<T>, encode::NativeRaw> at(const std::array<uint64_t, sizeof...(D)>& ind){ + return {value_.at(this->get_flat_index(ind))}; + } + + const data<schema::Ref<T>, encode::Native> at(const std::array<uint64_t, sizeof...(D)>& ind) const { + return {value_.at(this->get_flat_index(ind))}; + } + + template<std::integral... Dims> + data<schema::Ref<T>, encode::Native> at(Dims... i) { + return {value_.at(this->get_flat_index({i...}))}; + } + + template<std::integral... Dims> + const data<schema::Ref<T>, encode::Native> at(Dims... i) const { + return {value_.at(this->get_flat_index({i...}))}; + } + + data<schema::Ref<T>, encode::Native> at(const data<schema::FixedArray<schema::UInt64, sizeof...(D)>, encode::NativeRaw>& i){ + return {value_.at(this->get_flat_index(i))}; + } + + const data<schema::Ref<T>, encode::Native> at(const data<schema::FixedArray<schema::UInt64, sizeof...(D)>, encode::NativeRaw>& i)const{ + return {value_.at(this->get_flat_index(i))}; + } + + template<uint64_t i> + uint64_t get_dim_size() const { + return parameter_pack_value<i, uint64_t, D...>::value; + } + + data<schema::FixedArray<schema::UInt64, sizeof...(D)>, encode::NativeRaw> get_dims() const { + return {std::array<uint64_t, sizeof...(D)>{D...}}; + } +private: + uint64_t get_flat_index(const std::array<uint64_t, sizeof...(D)>& i) const { + uint64_t s = 0; + + uint64_t stride = 1; + + constexpr static std::array<uint64_t, sizeof...(D)> dims_{D...}; + + for(uint64_t iter = 0; iter < sizeof...(D); ++iter){ + assert(i.at(iter) < dims_.at(iter)); + s += i.at(iter) * stride; + stride *= dims_.at(iter); + } + + return s; + } +}; + } diff --git a/modules/codec/c++/schema_meta.hpp b/modules/codec/c++/schema_meta.hpp index 9b111e3..80b6686 100644 --- a/modules/codec/c++/schema_meta.hpp +++ b/modules/codec/c++/schema_meta.hpp @@ -33,6 +33,12 @@ struct meta_schema<schema::MixedPrecision<schema::Primitive<TA,NA>, schema::Prim using MetaSchema = schema::Void; }; +template<typename T> +struct meta_schema<schema::Ref<T>> { + using MetaSchema = schema::Void; + using Schema = schema::Ref<T>; +}; + template<typename Key, typename Value> struct meta_schema<schema::Map<Key,Value>> { using MetaSchema = schema::Void; diff --git a/modules/codec/tests/data_raw.cpp b/modules/codec/tests/data_raw.cpp index 99d55a8..11e2c5e 100644 --- a/modules/codec/tests/data_raw.cpp +++ b/modules/codec/tests/data_raw.cpp @@ -4,7 +4,33 @@ namespace { namespace sch { using namespace saw::schema; + +using Int32Array = Array< + Int32 +>; } +SAW_TEST("Data NativeRaw/Array of Primitives"){ + using namespace saw; + + data<sch::Int32Array,encode::NativeRaw> prim{4u}; + prim.at(1u).set(0); + + auto a = prim.at(1u); + + a.set(5); + + auto b = prim.at(1u); + // Check if it's a reference being manipulated + SAW_EXPECT(a.get() == 5, "'a' has unexpected value."); + SAW_EXPECT(b.get() == 5, "'b' has unexpected value."); + + auto c = prim.at(1u); + c.set(10); + + SAW_EXPECT(a.get() == 10, "'a' has unexpected value."); + SAW_EXPECT(b.get() == 10, "'b' has unexpected value."); + SAW_EXPECT(c.get() == 10, "'c' has unexpected value."); +} } |