From 1d578450dc82843bd4b24f3a6aad2c1a82bbda5e Mon Sep 17 00:00:00 2001
From: Claudius 'keldu' Holeksa <mail@keldu.de>
Date: Tue, 17 Sep 2024 11:21:05 +0200
Subject: Managed to get hip to compile

---
 modules/codec/c++/data_raw.hpp | 114 ++++++++++++++++++++---------------------
 1 file changed, 56 insertions(+), 58 deletions(-)

(limited to 'modules/codec/c++/data_raw.hpp')

diff --git a/modules/codec/c++/data_raw.hpp b/modules/codec/c++/data_raw.hpp
index db57af3..2da49b4 100644
--- a/modules/codec/c++/data_raw.hpp
+++ b/modules/codec/c++/data_raw.hpp
@@ -62,54 +62,54 @@ public:
 private:
 	typename native_data_type<Schema>::type value_;
 public:
-	data():value_{}{}
-	data(data<MetaSchema, encode::NativeRaw>):value_{}{}
+	constexpr data():value_{}{}
+	constexpr data(data<MetaSchema, encode::NativeRaw>):value_{}{}
 
 	SAW_DEFAULT_COPY(data);
 	SAW_DEFAULT_MOVE(data);
 
-	data(typename native_data_type<Schema>::type value__):
+	constexpr data(typename native_data_type<Schema>::type value__):
 		value_{std::move(value__)}{}
 
-	void set(typename native_data_type<Schema>::type val){
+	constexpr void set(typename native_data_type<Schema>::type val){
 		value_ = val;
 	}
 
-	typename native_data_type<Schema>::type get() const {return value_;}
+	constexpr typename native_data_type<Schema>::type get() const {return value_;}
 
-	data<Schema, encode::NativeRaw> operator*(const data<Schema, encode::NativeRaw>& rhs)const{
+	constexpr data<Schema, 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{
+	constexpr data<Schema, 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{
+	constexpr data<Schema, 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{
+	constexpr 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{
+	constexpr 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{
+	constexpr data<Schema, 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{
+	constexpr bool operator==(const data<Schema, Enc>& rhs)const{
 		return get() == rhs.get();
 	}
 
 	template<typename Enc>
-	bool operator<(const data<Schema, Enc>& rhs) const {
+	constexpr bool operator<(const data<Schema, Enc>& rhs) const {
 		return get() < rhs.get();
 	}
 
@@ -117,7 +117,7 @@ public:
 	 * Casts 
 	 */
 	template<typename Target>
-	data<Target, encode::NativeRaw> cast_to() const {
+	constexpr data<Target, encode::NativeRaw> cast_to() const {
 		auto raw_to = static_cast<typename saw::native_data_type<Target>::type>(value_);
 		return {raw_to};
 	}
@@ -132,64 +132,64 @@ public:
 private:
 	ref<typename native_data_type<ReferencedSchema>::type > value_;
 public:
-	data(ref<typename native_data_type<ReferencedSchema >::type > value__):
+	constexpr 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){
+	constexpr void set(typename native_data_type<ReferencedSchema>::type val){
 		value_() = val;
 	}
 
-	typename native_data_type<ReferencedSchema>::type get() const {
+	constexpr typename native_data_type<ReferencedSchema>::type get() const {
 		return value_();
 	}
 	
-	data<ReferencedSchema, encode::NativeRaw> operator*(const data<Schema, encode::NativeRaw>& rhs)const{
+	constexpr 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{
+	constexpr 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{
+	constexpr 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{
+	constexpr 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{
+	constexpr 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{
+	constexpr 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{
+	constexpr bool operator==(const data<Schema, Enc>& rhs)const{
 		return get() == rhs.get();
 	}
 	
 	template<typename Enc>
-	bool operator==(const data<ReferencedSchema, Enc>& rhs)const{
+	constexpr bool operator==(const data<ReferencedSchema, Enc>& rhs)const{
 		return get() == rhs.get();
 	}
 
 	template<typename Enc>
-	bool operator<(const data<Schema, Enc>& rhs) const {
+	constexpr bool operator<(const data<Schema, Enc>& rhs) const {
 		return get() < rhs.get();
 	}
 	
 	template<typename Enc>
-	bool operator<(const data<ReferencedSchema, Enc>& rhs) const {
+	constexpr bool operator<(const data<ReferencedSchema, Enc>& rhs) const {
 		return get() < rhs.get();
 	}
 };
@@ -210,70 +210,70 @@ public:
 
 	data(typename saw::native_data_type<typename Schema::InterfaceSchema>::type val__):value_{static_cast<typename saw::native_data_type<typename Schema::StorageSchema>::type>(val__)}{}
 
-	typename saw::native_data_type<typename Schema::InterfaceSchema>::type get() const {
+	constexpr typename saw::native_data_type<typename Schema::InterfaceSchema>::type get() const {
 		return value_.template cast_to<typename Schema::InterfaceSchema>().get();
 	}
 
-	data(const saw::data<typename Schema::InterfaceSchema, encode::NativeRaw>& val){
+	constexpr data(const saw::data<typename Schema::InterfaceSchema, encode::NativeRaw>& val){
 		value_ = val.template cast_to<typename Schema::StorageSchema>();
 	}
 	
-	void set(typename saw::native_data_type<typename Schema::InterfaceSchema>::type val){
+	constexpr void set(typename saw::native_data_type<typename Schema::InterfaceSchema>::type val){
 		value_.set(static_cast<typename Schema::StorageSchema>(val));
 	}
 	
-	data<Schema, encode::NativeRaw> operator*(const data<Schema, encode::NativeRaw>& rhs) const {
+	constexpr data<Schema, encode::NativeRaw> operator*(const data<Schema, encode::NativeRaw>& rhs) const {
 		using CalcType = typename native_data_type<typename Schema::InterfaceSchema>::type;
 		CalcType left = static_cast<CalcType>(value_.get());
 		CalcType right = static_cast<CalcType>(rhs.get());
 		return {left * right};
 	}
 	
-	data<typename Schema::InterfaceSchema, encode::NativeRaw> operator*(const data<typename Schema::InterfaceSchema, encode::NativeRaw>& rhs) const {
+	constexpr data<typename Schema::InterfaceSchema, encode::NativeRaw> operator*(const data<typename Schema::InterfaceSchema, encode::NativeRaw>& rhs) const {
 		using CalcType = typename native_data_type<typename Schema::InterfaceSchema>::type;
 		CalcType left = static_cast<CalcType>(value_.get());
 		CalcType right = rhs.get();
 		return {left * right};
 	}
 	
-	data<typename Schema::InterfaceSchema, encode::NativeRaw> operator/(const data<Schema, encode::NativeRaw>& rhs)const{
+	constexpr data<typename Schema::InterfaceSchema, encode::NativeRaw> operator/(const data<Schema, encode::NativeRaw>& rhs)const{
 		using CalcType = typename native_data_type<typename Schema::InterfaceSchema>::type;
 		CalcType left = static_cast<CalcType>(value_.get());
 		CalcType right = static_cast<CalcType>(rhs.get());
 		return {left / right};
 	}
 	
-	data<typename Schema::InterfaceSchema, encode::NativeRaw> operator+(const data<Schema, encode::NativeRaw>& rhs)const{
+	constexpr data<typename Schema::InterfaceSchema, encode::NativeRaw> operator+(const data<Schema, encode::NativeRaw>& rhs)const{
 		using CalcType = typename native_data_type<typename Schema::InterfaceSchema>::type;
 		CalcType left = static_cast<CalcType>(value_.get());
 		CalcType right = static_cast<CalcType>(rhs.get());
 		return {left + right};
 	}
 	
-	data<Schema, encode::NativeRaw>& operator+=(const data<Schema, encode::NativeRaw>& rhs)const{
+	constexpr data<Schema, encode::NativeRaw>& operator+=(const data<Schema, encode::NativeRaw>& rhs)const{
 		*this = *this + rhs.get();
 		return *this;
 	}
 
-	data<typename Schema::InterfaceSchema, encode::NativeRaw> operator-(const data<Schema, encode::NativeRaw>& rhs)const{
+	constexpr data<typename Schema::InterfaceSchema, encode::NativeRaw> operator-(const data<Schema, encode::NativeRaw>& rhs)const{
 		using CalcType = typename native_data_type<typename Schema::InterfaceSchema>::type;
 		CalcType left = static_cast<CalcType>(value_.get());
 		CalcType right = static_cast<CalcType>(rhs.get());
 		return {left - right};
 	}
 	
-	data<Schema, encode::NativeRaw>& operator-=(const data<Schema, encode::NativeRaw>& rhs) const {
+	constexpr data<Schema, encode::NativeRaw>& operator-=(const data<Schema, encode::NativeRaw>& rhs) const {
 		*this = *this - rhs.get();
 		return *this;
 	}
 
 	template<typename Enc>
-	bool operator==(const data<Schema, Enc>& rhs)const{
+	constexpr bool operator==(const data<Schema, Enc>& rhs)const{
 		return get() == rhs.get();
 	}
 
 	template<typename Enc>
-	bool operator<(const data<Schema, Enc>& rhs) const {
+	constexpr bool operator<(const data<Schema, Enc>& rhs) const {
 		return get() < rhs.get();
 	}
 };
@@ -415,14 +415,14 @@ class data<schema::Array<T,Dim>, encode::NativeRaw> {
 		typename raw_native_array_type_helper<T>::Type* value_;
 		uint64_t value_size_;
 
-		uint64_t get_full_size() const {
+		constexpr uint64_t get_full_size() const {
 			uint64_t s = 1;
 
 			for(uint64_t iter = 0; iter < Dim; ++iter){
-				assert(dims_.at(iter) > 0);
-				s *= dims_.at(iter);
+				s *= dims_[iter];
 			}
 
+
 			return s;
 		}
 	public:
@@ -438,7 +438,7 @@ class data<schema::Array<T,Dim>, encode::NativeRaw> {
 		/**
 		 * Purely internal function for working C interfacing
 		 */
-		typename raw_native_array_type_helper<T>::Type* get_raw_data() {
+		constexpr typename raw_native_array_type_helper<T>::Type* get_raw_data() {
 			if(value_size_ == 0u){
 				return nullptr;
 			}
@@ -477,54 +477,53 @@ class data<schema::Array<T,Dim>, encode::NativeRaw> {
 		}
 
 		template<std::integral... Dims>
-		data(Dims... size_):
+		constexpr data(Dims... size_):
 			data{{static_cast<uint64_t>(size_)...}}
 		{
 			static_assert(sizeof...(Dims)==Dim, "Argument size must be equal to the Dimension");
 		}
 
-		data<schema::Ref<T>, encode::NativeRaw> at(const std::array<uint64_t, Dim>& ind){
+		constexpr data<schema::Ref<T>, encode::NativeRaw> at(const std::array<uint64_t, Dim>& ind){
 			return {value_[this->get_flat_index(ind)]};
 		}
 		
-		const data<schema::Ref<T>, encode::NativeRaw> at(const std::array<uint64_t, Dim>& ind) const {
+		constexpr const data<schema::Ref<T>, encode::NativeRaw> at(const std::array<uint64_t, Dim>& ind) const {
 			return {value_[this->get_flat_index(ind)]};
 		}
 
 		template<std::integral... Dims>
-		data<schema::Ref<T>, encode::NativeRaw> at(Dims... i){
+		constexpr data<schema::Ref<T>, encode::NativeRaw> at(Dims... i){
 			return {value_[this->get_flat_index(std::array<uint64_t, Dim>{static_cast<uint64_t>(i)...})]};
 		}
 		
 		template<std::integral... Dims>
-		const data<schema::Ref<T>, encode::NativeRaw> at(Dims... i) const {
+		constexpr const data<schema::Ref<T>, encode::NativeRaw> at(Dims... i) const {
 			return {value_[this->get_flat_index(std::array<uint64_t, Dim>{static_cast<uint64_t>(i)...})]};
 		}
 
 		template<typename Encoding>
-		data<schema::Ref<T>,encode::NativeRaw> at(const data<schema::FixedArray<schema::UInt64,Dim>, Encoding>& i){
+		constexpr data<schema::Ref<T>,encode::NativeRaw> at(const data<schema::FixedArray<schema::UInt64,Dim>, Encoding>& i){
 			return {value_[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{
+		constexpr const data<schema::Ref<T>,encode::NativeRaw> at(const data<schema::FixedArray<schema::UInt64,Dim>, Encoding>& i)const{
 			return {value_[this->get_flat_index(i)]};
 		}
 		
-		std::size_t get_dim_size(uint64_t i) const {
+		constexpr std::size_t get_dim_size(uint64_t i) const {
 			return dims_.at(i);
 		}
 
-		uint64_t size() const { return value_size_;}
+		constexpr uint64_t size() const { return value_size_;}
 
-		data<schema::FixedArray<schema::UInt64, Dim>, encode::NativeRaw> get_dims() const {
+		constexpr 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 {
-			assert(value_size_ == get_full_size());
+		constexpr uint64_t get_flat_index(const U& i) const {
 			uint64_t s = 0;
 
 			uint64_t stride = 1;
@@ -539,10 +538,9 @@ private:
 					}else{
 						static_assert(always_false<V>, "Cases exhausted");
 					}
-				}(i.at(iter));
-				assert(ind < dims_.at(iter));
+				}(i[iter]);
 				s += ind * stride;
-				stride *= dims_.at(iter);
+				stride *= dims_[iter];
 			}
 
 			return s;
-- 
cgit v1.2.3