From e4e49a117702945066e3e279fa0f005200400cb7 Mon Sep 17 00:00:00 2001
From: "Claudius \"keldu\" Holeksa" <mail@keldu.de>
Date: Wed, 12 Jun 2024 15:04:42 +0200
Subject: Separated Encoding and Storage approaches

---
 modules/codec/c++/data.hpp      | 91 ++++++++++++++++++++---------------------
 modules/codec/c++/interface.hpp | 50 +++++++++++-----------
 modules/codec/tests/codec.cpp   | 58 +++++++++++++-------------
 modules/codec/tests/csv.cpp     |  2 +-
 4 files changed, 100 insertions(+), 101 deletions(-)

(limited to 'modules/codec')

diff --git a/modules/codec/c++/data.hpp b/modules/codec/c++/data.hpp
index 2a5f082..79f5264 100644
--- a/modules/codec/c++/data.hpp
+++ b/modules/codec/c++/data.hpp
@@ -20,10 +20,9 @@ struct Default {};
 }
 
 namespace encode {
-template<typename Storage = storage::Default>
 struct Native {};
 }
-template<typename Schema, typename Encode>
+template<typename Schema, typename Encode, typename Storage = storage::Default>
 class codec;
 /*
  * Helper for the basic message container, so the class doesn't have to be
@@ -81,14 +80,14 @@ struct native_data_type<schema::Primitive<schema::FloatingPoint, 8>> {
 	using type = double;
 };
 
-template<typename T, typename Encoding = encode::Native<storage::Default>>
+template<typename T, typename Encoding = encode::Native, typename Storage = storage::Default>
 class data {
 private:
 	static_assert(always_false<T>, "Type not supported");
 };
 
-template<typename T, size_t N, typename Platform>
-class data<schema::Primitive<T,N>, encode::Native<Platform>> {
+template<typename T, size_t N>
+class data<schema::Primitive<T,N>, encode::Native, storage::Default> {
 private:
 	typename native_data_type<schema::Primitive<T,N>>::type value_;
 public:
@@ -106,19 +105,19 @@ public:
 
 	typename native_data_type<schema::Primitive<T,N>>::type get() const {return value_;}
 
-	data<schema::Primitive<T,N>, encode::Native<Platform>> operator*(const data<schema::Primitive<T,N>, encode::Native<Platform>>& rhs)const{
+	data<schema::Primitive<T,N>, encode::Native, storage::Default> operator*(const data<schema::Primitive<T,N>, encode::Native, storage::Default>& rhs)const{
 		return {get() * rhs.get()};
 	}
 	
-	data<schema::Primitive<T,N>, encode::Native<Platform>> operator/(const data<schema::Primitive<T,N>, encode::Native<Platform>>& rhs)const{
+	data<schema::Primitive<T,N>, encode::Native, storage::Default> operator/(const data<schema::Primitive<T,N>, encode::Native, storage::Default>& rhs)const{
 		return {get() / rhs.get()};
 	}
 	
-	data<schema::Primitive<T,N>, encode::Native<Platform>> operator+(const data<schema::Primitive<T,N>, encode::Native<Platform>>& rhs)const{
+	data<schema::Primitive<T,N>, encode::Native, storage::Default> operator+(const data<schema::Primitive<T,N>, encode::Native, storage::Default>& rhs)const{
 		return {get() + rhs.get()};
 	}
 
-	data<schema::Primitive<T,N>, encode::Native<Platform>> operator-(const data<schema::Primitive<T,N>, encode::Native<Platform>>& rhs)const{
+	data<schema::Primitive<T,N>, encode::Native, storage::Default> operator-(const data<schema::Primitive<T,N>, encode::Native, storage::Default>& rhs)const{
 		return {get() - rhs.get()};
 	}
 
@@ -136,7 +135,7 @@ public:
 	 * Casts 
 	 */
 	template<typename Target>
-	data<Target, encode::Native<Platform>> cast_to(){
+	data<Target, encode::Native, storage::Default> cast_to(){
 		auto raw_to = static_cast<typename saw::native_data_type<Target>::type>(value_);
 		return {raw_to};
 	}
@@ -145,12 +144,12 @@ public:
 /**
  * Mixed precision class for native formats
  */
-template<typename TA, uint64_t NA, typename TB, uint64_t NB, typename Platform> 
-class data<schema::MixedPrecision<schema::Primitive<TA,NA>, schema::Primitive<TB,NB>>, encode::Native<Platform>>{
+template<typename TA, uint64_t NA, typename TB, uint64_t NB> 
+class data<schema::MixedPrecision<schema::Primitive<TA,NA>, schema::Primitive<TB,NB>>, encode::Native, storage::Default>{
 public:
 	using Schema = schema::MixedPrecision<schema::Primitive<TA,NA>, schema::Primitive<TB,NB>>;
 private:
-	data<typename Schema::StorageSchema, encode::Native<Platform>> value_;
+	data<typename Schema::StorageSchema, encode::Native, storage::Default> value_;
 public:
 	data():value_{}{}
 
@@ -169,9 +168,9 @@ public:
  * Union type for native data classes
  */
 template<typename... T, string_literal... literals>
-class data<schema::Union<schema::Member<T, literals>...>, encode::Native<storage::Default>> {
+class data<schema::Union<schema::Member<T, literals>...>, encode::Native, storage::Default> {
 private:
-	std::variant<data<T,encode::Native<storage::Default>>...> value_;
+	std::variant<data<T,encode::Native, storage::Default>...> value_;
 public:
 	data() = default;
 
@@ -179,12 +178,12 @@ public:
 	SAW_DEFAULT_MOVE(data);
 
 	template<string_literal lit>
-	void set(data<typename parameter_pack_type<parameter_key_pack_index<lit, literals...>::value, T...>::type, encode::Native<storage::Default>> val){
+	void set(data<typename parameter_pack_type<parameter_key_pack_index<lit, literals...>::value, T...>::type, encode::Native, storage::Default> val){
 		value_ = std::move(val);
 	}
 
 	template<string_literal lit>
-	data<typename parameter_pack_type<parameter_key_pack_index<lit, literals...>::value, T...>::type, encode::Native<storage::Default>>& init(){
+	data<typename parameter_pack_type<parameter_key_pack_index<lit, literals...>::value, T...>::type, encode::Native, storage::Default>& init(){
 		value_.template emplace<parameter_key_pack_index<lit, literals...>::value>();
 		return get<lit>();
 	}
@@ -195,12 +194,12 @@ public:
 	}
 
 	template<string_literal lit>
-	data<typename parameter_pack_type<parameter_key_pack_index<lit, literals...>::value, T...>::type, encode::Native<storage::Default>>& get(){
+	data<typename parameter_pack_type<parameter_key_pack_index<lit, literals...>::value, T...>::type, encode::Native, storage::Default>& get(){
 		return std::get<parameter_key_pack_index<lit, literals...>::value>(value_);
 	}
 	
 	template<string_literal lit>
-	const data<typename parameter_pack_type<parameter_key_pack_index<lit, literals...>::value, T...>::type, encode::Native<storage::Default>>& get() const{
+	const data<typename parameter_pack_type<parameter_key_pack_index<lit, literals...>::value, T...>::type, encode::Native, storage::Default>& get() const{
 		return std::get<parameter_key_pack_index<lit, literals...>::value>(value_);
 	}
 };
@@ -209,12 +208,12 @@ public:
  * Data class which represents a struct in the native format.
  */
 template<typename... T, string_literal... literals>
-class data<schema::Struct<schema::Member<T, literals>...>, encode::Native<storage::Default>> {
+class data<schema::Struct<schema::Member<T, literals>...>, encode::Native, storage::Default> {
 private:
 	/**
 	 * Tuple storing the member values.
 	 */
-	std::tuple<data<T,encode::Native<storage::Default>>...> value_;
+	std::tuple<data<T,encode::Native, storage::Default>...> value_;
 public:
 	/**
 	 * Default constructor.
@@ -233,7 +232,7 @@ public:
 				literal, literals...
 			>::value
 		, T...>::type
-	, encode::Native<storage::Default>>& get(){
+	, encode::Native, storage::Default>& get(){
 		return std::get<parameter_key_pack_index<literal, literals...>::value>(value_);
 	}
 	
@@ -247,7 +246,7 @@ public:
 				literal, literals...
 			>::value
 		, T...>::type
-	, encode::Native<storage::Default>>& get() const {
+	, encode::Native, storage::Default>& get() const {
 		return std::get<parameter_key_pack_index<literal, literals...>::value>(value_);
 	}
 
@@ -260,21 +259,21 @@ public:
 };
 
 template<typename... T>
-class data<schema::Tuple<T...>, encode::Native<storage::Default>> {
+class data<schema::Tuple<T...>, encode::Native, storage::Default> {
 private:
-	std::tuple<data<T,encode::Native<storage::Default>>...> value_;
+	std::tuple<data<T,encode::Native, storage::Default>...> value_;
 public:
 	data() = default;
 	SAW_DEFAULT_COPY(data);
 	SAW_DEFAULT_MOVE(data);
 	
 	template<size_t i>
-	data<typename parameter_pack_type<i,T...>::type, encode::Native<storage::Default>>& get(){
+	data<typename parameter_pack_type<i,T...>::type, encode::Native, storage::Default>& get(){
 		return std::get<i>(value_);
 	}
 	
 	template<size_t i>
-	const data<typename parameter_pack_type<i,T...>::type, encode::Native<storage::Default>>& get() const{
+	const data<typename parameter_pack_type<i,T...>::type, encode::Native, storage::Default>& get() const{
 		return std::get<i>(value_);
 	}
 
@@ -284,11 +283,11 @@ public:
 };
 
 template<typename T, size_t Dim>
-class data<schema::Array<T,Dim>, encode::Native<storage::Default>> {
+class data<schema::Array<T,Dim>, encode::Native, storage::Default> {
 	private:
 		// data<schema::FixedArray<schema::UInt64, Dim>> dims_;
 		std::array<uint64_t, Dim> dims_;
-		std::vector<data<T, encode::Native<storage::Default>>> value_;
+		std::vector<data<T, encode::Native, storage::Default>> value_;
 
 		uint64_t get_full_size() const {
 			uint64_t s = 1;
@@ -320,7 +319,7 @@ class data<schema::Array<T,Dim>, encode::Native<storage::Default>> {
 		}
 
 		template<size_t i = 0>
-		error_or<void> add(saw::data<T,encode::Native<storage::Default>> data){
+		error_or<void> add(saw::data<T,encode::Native, storage::Default> data){
 			/** @todo
 			 * Generally the last dimension can always accept a element so to say.
 			 * Changing the others would require moving data due to the stride changing.
@@ -355,29 +354,29 @@ class data<schema::Array<T,Dim>, encode::Native<storage::Default>> {
 			static_assert(sizeof...(Dims)==Dim, "Argument size must be equal to the Dimension");
 		}
 
-		data<T, encode::Native<storage::Default>>& at(const std::array<uint64_t, Dim>& ind){
+		data<T, encode::Native, storage::Default>& at(const std::array<uint64_t, Dim>& ind){
 			return value_.at(this->get_flat_index(ind));
 		}
 		
-		const data<T, encode::Native<storage::Default>>& at(const std::array<uint64_t, Dim>& ind) const {
+		const data<T, encode::Native, storage::Default>& at(const std::array<uint64_t, Dim>& ind) const {
 			return value_.at(this->get_flat_index(ind));
 		}
 
 		template<std::integral... Dims>
-		data<T, encode::Native<storage::Default>>& at(Dims... i){
+		data<T, encode::Native, storage::Default>& 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::Native<storage::Default>>& at(Dims... i) const {
+		const data<T, encode::Native, storage::Default>& at(Dims... i) const {
 			return value_.at(this->get_flat_index(std::array<uint64_t, Dim>{static_cast<uint64_t>(i)...}));
 		}
 
-		data<T,encode::Native<storage::Default>>& at(const data<schema::FixedArray<schema::UInt64,Dim>>& i){
+		data<T,encode::Native, storage::Default>& at(const data<schema::FixedArray<schema::UInt64,Dim>>& i){
 			return value_.at(this->get_flat_index(i));
 		}
 		
-		const data<T,encode::Native<storage::Default>>& at(const data<schema::FixedArray<schema::UInt64,Dim>>& i)const{
+		const data<T,encode::Native, storage::Default>& at(const data<schema::FixedArray<schema::UInt64,Dim>>& i)const{
 			return value_.at(this->get_flat_index(i));
 		}
 		
@@ -425,39 +424,39 @@ private:
 };
 
 template<typename T, uint64_t... D>
-class data<schema::FixedArray<T,D...>, encode::Native<storage::Default>> {
+class data<schema::FixedArray<T,D...>, encode::Native, storage::Default> {
 private:
-	//using inner_type = std::array<data<T, encode::Native<storage::Default>>, multiply_helper<Dims...>::value>;
+	//using inner_type = std::array<data<T, encode::Native, storage::Default>, multiply_helper<Dims...>::value>;
 	//std::unique_ptr<inner_type> value_;
-	using ArrayT = std::array<data<T, encode::Native<storage::Default>>, ct_multiply<uint64_t, D...>::value>;
+	using ArrayT = std::array<data<T, encode::Native, storage::Default>, ct_multiply<uint64_t, D...>::value>;
 	ArrayT value_;
 	
 public:
 	data() = default;
 
-	data<T, encode::Native<storage::Default>>& at(const std::array<uint64_t, sizeof...(D)>& ind){
+	data<T, encode::Native, storage::Default>& at(const std::array<uint64_t, sizeof...(D)>& ind){
 		return value_.at(this->get_flat_index(ind));
 	}
 		
-	const data<T, encode::Native<storage::Default>>& at(const std::array<uint64_t, sizeof...(D)>& ind) const {
+	const data<T, encode::Native, storage::Default>& at(const std::array<uint64_t, sizeof...(D)>& ind) const {
 		return value_.at(this->get_flat_index(ind));
 	}
 
 	template<std::integral... Dims>
-	data<T, encode::Native<storage::Default>>& at(Dims... i) {
+	data<T, encode::Native, storage::Default>& at(Dims... i) {
 		return value_.at(this->get_flat_index({i...}));
 	}
 
 	template<std::integral... Dims>
-	const data<T, encode::Native<storage::Default>>& at(Dims... i) const {
+	const data<T, encode::Native, storage::Default>& at(Dims... i) const {
 		return value_.at(this->get_flat_index({i...}));
 	}
 
-	data<T, encode::Native<storage::Default>>& at(const data<schema::FixedArray<schema::UInt64, sizeof...(D)>>& i){
+	data<T, encode::Native, storage::Default>& at(const data<schema::FixedArray<schema::UInt64, sizeof...(D)>>& i){
 		return value_.at(this->get_flat_index(i));
 	}
 	
-	const data<T, encode::Native<storage::Default>>& at(const data<schema::FixedArray<schema::UInt64, sizeof...(D)>>& i)const{
+	const data<T, encode::Native, storage::Default>& at(const data<schema::FixedArray<schema::UInt64, sizeof...(D)>>& i)const{
 		return value_.at(this->get_flat_index(i));
 	}
 
@@ -491,7 +490,7 @@ private:
  * Data type representing string.
  */
 template<>
-class data<schema::String, encode::Native<storage::Default>> {
+class data<schema::String, encode::Native, storage::Default> {
 private:
 	/**
 	 * The native way to represent strings.
diff --git a/modules/codec/c++/interface.hpp b/modules/codec/c++/interface.hpp
index 8c6808b..d55b415 100644
--- a/modules/codec/c++/interface.hpp
+++ b/modules/codec/c++/interface.hpp
@@ -8,32 +8,32 @@
 #include "data.hpp"
 
 namespace saw {
-template<typename SchemaFunc, typename Encode, typename Context = void_t >
+template<typename SchemaFunc, typename Encode, typename Storage, typename Context = void_t >
 class function;
 
 namespace impl {
-template<typename Request, typename Response, typename Encode, typename Ctx>
+template<typename Request, typename Response, typename Encode, typename Storage, typename Ctx>
 struct FuncTypeHelper {
-	using Type = std::function<data<Response, Encode>(data<Request, Encode>, Ctx)>;
+	using Type = std::function<data<Response, Encode, Storage>(data<Request, Encode, Storage>, Ctx)>;
 };
 
-template<typename Request, typename Response, typename Encode>
-struct FuncTypeHelper<Request, Response, Encode, void_t> {
-	using Type = std::function<data<Response, Encode>(data<Request, Encode>)>;
+template<typename Request, typename Response, typename Encode, typename Storage>
+struct FuncTypeHelper<Request, Response, Encode, Storage, void_t> {
+	using Type = std::function<data<Response, Encode, Storage>(data<Request, Encode, Storage>)>;
 };
 }
 
-template<typename Request, typename Response, typename Encode, typename Context>
-class function<schema::Function<Request, Response>, Encode, Context> {
+template<typename Request, typename Response, typename Encode, typename Storage, typename Context>
+class function<schema::Function<Request, Response>, Encode, Storage, Context> {
 private:
-	typename impl::FuncTypeHelper<Request, Response, Encode, Context>::Type func_;
+	typename impl::FuncTypeHelper<Request, Response, Encode, Storage, Context>::Type func_;
 public:
 	template<typename Func>
 		function(Func func):
 				func_{std::move(func)}
 		{}
 
-		error_or<data<Response, Encode>> call(data<Request, Encode> req, Context ctx = {}){
+		error_or<data<Response, Encode, Storage>> call(data<Request, Encode, Storage> req, Context ctx = {}){
 			if constexpr (std::is_same_v<Context, void_t>){
 				(void) ctx;
 				return func_(std::move(req));
@@ -43,17 +43,17 @@ public:
 		}
 };
 
-template<typename T, typename Encode, typename Context = void_t >
+template<typename T, typename Encode, typename Storage = storage::Default, typename Context = void_t >
 class interface;
 
-template<typename... Requests, typename... Responses, string_literal... Names, typename Encode, typename Context>
-class interface<schema::Interface<schema::Member<schema::Function<Requests, Responses>, Names>...>, Encode, Context> {
+template<typename... Requests, typename... Responses, string_literal... Names, typename Encode, typename Storage, typename Context>
+class interface<schema::Interface<schema::Member<schema::Function<Requests, Responses>, Names>...>, Encode, Storage, Context> {
 public:
 	using Schema = schema::Interface<schema::Member<schema::Function<Requests, Responses>,Names>...>;
 private:
-		std::tuple<function<schema::Function<Requests, Responses>, Encode, Context>...> funcs_;
+		std::tuple<function<schema::Function<Requests, Responses>, Encode, Storage, Context>...> funcs_;
 public:
-		interface(function<schema::Function<Requests, Responses>, Encode, Context>... funcs):
+		interface(function<schema::Function<Requests, Responses>, Encode, Storage, Context>... funcs):
 				funcs_{std::move(funcs)...}
 		{}
 
@@ -75,8 +75,8 @@ public:
 								>::value
 						, Responses...>::type
 				>
-		,
-				Encode
+		,		Encode
+		,		Storage
 		,		Context
 		>& get(){
 				return std::get<parameter_key_pack_index<Lit, Names...>::value>(funcs_);
@@ -90,14 +90,14 @@ public:
 								Lit, Names...
 						>::value
 				, Responses...>::type
-		, Encode>> call(
+		, Encode, Storage>> call(
 						data<
 								typename parameter_pack_type<
 										parameter_key_pack_index<
 												Lit, Names...
 										>::value
 								, Requests...>::type
-						, Encode> req,
+						, Encode, Storage> req,
 						Context ctx = {}
 				){
 				if constexpr (std::is_same_v<Context, void_t>) {
@@ -109,19 +109,19 @@ public:
 		}
 };
 
-template<typename T, typename Encode, typename Context = void_t>
+template<typename T, typename Encode, typename Storage = storage::Default, typename Context = void_t>
 struct function_factory {
 		template<typename Func>
-		static function<T,Encode, Context> create(Func func){
-				return function<T,Encode,Context> {std::move(func)};
+		static function<T,Encode, Storage, Context> create(Func func){
+				return function<T,Encode, Storage, Context> {std::move(func)};
 		}
 };
 
-template<typename T, typename Encode, typename Context = void_t>
+template<typename T, typename Encode, typename Storage = storage::Default, typename Context = void_t>
 struct interface_factory {
 		template<typename... Func>
-		static interface<T,Encode,Context> create(Func... func){
-				return interface<T,Encode,Context>{std::move(func)...};
+		static interface<T,Encode,Storage,Context> create(Func... func){
+				return interface<T,Encode,Storage,Context>{std::move(func)...};
 		}
 };
 }
diff --git a/modules/codec/tests/codec.cpp b/modules/codec/tests/codec.cpp
index e8a2fb3..10d9d0c 100644
--- a/modules/codec/tests/codec.cpp
+++ b/modules/codec/tests/codec.cpp
@@ -51,7 +51,7 @@ using TestInterface = Interface<
 SAW_TEST("One Dimensional Array") {
 	using namespace saw;
 
-	data<schema::OneDimArray, encode::Native<storage::Default>> arr{500u};
+	data<schema::OneDimArray, encode::Native, storage::Default> arr{500u};
 
 	int bar = 0;
 
@@ -70,7 +70,7 @@ SAW_TEST("One Dimensional Array") {
 SAW_TEST("One dim Array Default init"){
 	using namespace saw;
 
-	data<schema::OneDimArray, encode::Native<storage::Default>> arr;
+	data<schema::OneDimArray, encode::Native, storage::Default> arr;
 
 	SAW_EXPECT(arr.get_dim_size(0) == 0, "Dim should be size 0");
 	SAW_EXPECT(arr.size() == 0, "Total size should also be zero");
@@ -79,7 +79,7 @@ SAW_TEST("One dim Array Default init"){
 SAW_TEST("One dimensional Array Add"){
 	using namespace saw;
 
-	data<schema::OneDimArray, encode::Native<storage::Default>> arr{5u};
+	data<schema::OneDimArray, encode::Native, storage::Default> arr{5u};
 
 	int bar = 0;
 
@@ -96,7 +96,7 @@ SAW_TEST("One dimensional Array Add"){
 SAW_TEST("Two Dimensional Array") {
 	using namespace saw;
 
-	data<schema::TwoDimArray, encode::Native<storage::Default>> arr{10,30u};
+	data<schema::TwoDimArray, encode::Native, storage::Default> arr{10,30u};
 
 	int expected_sum = (300 * 301) / 2;
 
@@ -120,7 +120,7 @@ SAW_TEST("Two Dimensional Array") {
 SAW_TEST("Three Dimensional Array") {
 	using namespace saw;
 
-	data<schema::ThreeDimArray, encode::Native<storage::Default>> arr{10,10u,3};
+	data<schema::ThreeDimArray, encode::Native, storage::Default> arr{10,10u,3};
 	int expected_sum = (300 * 301) / 2;
 
 	int bar = 0;
@@ -146,7 +146,7 @@ SAW_TEST("Three Dimensional Array") {
 
 SAW_TEST("KelSimple UInt16 write"){
 	using namespace saw;
-	data<schema::UInt16, encode::Native<storage::Default>> native;
+	data<schema::UInt16, encode::Native, storage::Default> native;
 	data<schema::UInt16, encode::KelSimple> simple;
 
 	codec<schema::UInt16, encode::KelSimple> codec;
@@ -169,7 +169,7 @@ SAW_TEST("KelSimple UInt16 write"){
 
 SAW_TEST("KelSimple UInt32 write"){
 	using namespace saw;
-	data<schema::UInt32, encode::Native<storage::Default>> native;
+	data<schema::UInt32, encode::Native, storage::Default> native;
 	data<schema::UInt32, encode::KelSimple> simple;
 
 	codec<schema::UInt32, encode::KelSimple> codec;
@@ -192,7 +192,7 @@ SAW_TEST("KelSimple UInt32 write"){
 
 SAW_TEST("KelSimple Array write and read back"){
 	using namespace saw;
-	data<schema::TwoDimArray, encode::Native<storage::Default>> native{2,3};
+	data<schema::TwoDimArray, encode::Native, storage::Default> native{2,3};
 	data<schema::TwoDimArray, encode::KelSimple> simple;
 
 	codec<schema::TwoDimArray, encode::KelSimple> codec;
@@ -225,7 +225,7 @@ SAW_TEST("KelSimple Array write and read back"){
 SAW_TEST("KelSimple Struct write and read back"){
 	using namespace saw;
 
-	data<schema::TestStruct,encode::Native<storage::Default>> native;
+	data<schema::TestStruct,encode::Native, storage::Default> native;
 	data<schema::TestStruct,encode::KelSimple> simple;
 
 	auto& tda = native.template get<"two_dim_array">();
@@ -256,7 +256,7 @@ SAW_TEST("KelSimple Struct write and read back"){
 SAW_TEST("Native Union same type compilation"){
 	using namespace saw;
 
-	data<schema::TestSameTypeUnion, encode::Native<storage::Default>> native;
+	data<schema::TestSameTypeUnion, encode::Native, storage::Default> native;
 
 	native.template init<"two">().set(50u);
 
@@ -269,10 +269,10 @@ SAW_TEST("Native Union same type compilation"){
 SAW_TEST("KelSimple Union write and read back"){
 	using namespace saw;
 
-	data<schema::TestUnion,encode::Native<storage::Default>> native;
+	data<schema::TestUnion,encode::Native, storage::Default> native;
 	data<schema::TestUnion,encode::KelSimple> simple;
 
-	native.template set<"number">(data<schema::UInt64, encode::Native<storage::Default>>{});
+	native.template set<"number">(data<schema::UInt64, encode::Native, storage::Default>{});
 	native.template get<"number">().set(410);
 	
 	codec<schema::TestUnion, encode::KelSimple> codec;
@@ -293,7 +293,7 @@ SAW_TEST("KelSimple Union write and read back"){
 SAW_TEST("KelSimple Tuple write and read back"){
 	using namespace saw;
 
-	data<schema::TestTuple,encode::Native<storage::Default>> native;
+	data<schema::TestTuple,encode::Native, storage::Default> native;
 	data<schema::TestTuple,encode::KelSimple> simple;
 
 	auto& tda = native.template get<0>();
@@ -324,7 +324,7 @@ SAW_TEST("KelSimple Tuple write and read back"){
 SAW_TEST("KelSimple String write and read back"){
 	using namespace saw;
 
-	data<schema::String,encode::Native<storage::Default>> native;
+	data<schema::String,encode::Native, storage::Default> native;
 	data<schema::String,encode::KelSimple> simple;
 
 	std::string str = "FooBananaJoe";
@@ -349,14 +349,14 @@ SAW_TEST("Function basics"){
 	using namespace saw;
 
 	{
-			data<schema::TestInt32Pair, encode::Native<storage::Default>> native;
+			data<schema::TestInt32Pair, encode::Native, storage::Default> native;
 
 			native.get<0>().set(5);
 			native.get<1>().set(40);
 
-			auto func_add = function_factory<schema::TestCalcFunction, encode::Native<storage::Default>>::create(
-				[](data<schema::TestInt32Pair, encode::Native<storage::Default>> req){
-						data<schema::Int32, encode::Native<storage::Default>> resp;
+			auto func_add = function_factory<schema::TestCalcFunction, encode::Native, storage::Default>::create(
+				[](data<schema::TestInt32Pair, encode::Native, storage::Default> req){
+						data<schema::Int32, encode::Native, storage::Default> resp;
 
 						resp.set(req.get<0>().get() + req.get<1>().get());
 
@@ -375,36 +375,36 @@ SAW_TEST("Function basics"){
 SAW_TEST("Interface basics"){
 	using namespace saw;
 
-	data<schema::TestInt32Pair, encode::Native<storage::Default>> native;
+	data<schema::TestInt32Pair, encode::Native, storage::Default> native;
 
 	auto func_add = 
-		[](data<schema::TestInt32Pair, encode::Native<storage::Default>> req){
-				data<schema::Int32, encode::Native<storage::Default>> resp;
+		[](data<schema::TestInt32Pair, encode::Native, storage::Default> req){
+				data<schema::Int32, encode::Native, storage::Default> resp;
 
 				resp.set(req.get<0>().get() + req.get<1>().get());
 
 				return resp;
 		};
 	auto func_sub = 
-		[](data<schema::TestInt32Pair, encode::Native<storage::Default>> req){
-				data<schema::Int32, encode::Native<storage::Default>> resp;
+		[](data<schema::TestInt32Pair, encode::Native, storage::Default> req){
+				data<schema::Int32, encode::Native, storage::Default> resp;
 
 				resp.set(req.get<0>().get() - req.get<1>().get());
 
 				return resp;
 		};
-	auto func_multiply = [](data<schema::TestInt32Pair, encode::Native<storage::Default>> req){
-				data<schema::Int32, encode::Native<storage::Default>> resp;
+	auto func_multiply = [](data<schema::TestInt32Pair, encode::Native, storage::Default> req){
+				data<schema::Int32, encode::Native, storage::Default> resp;
 
 				resp.set(req.get<0>().get() * req.get<1>().get());
 
 				return resp;
 		};
 
-	auto iface = interface_factory<schema::TestInterface, encode::Native<storage::Default>>::create(std::move(func_add), std::move(func_sub), std::move(func_multiply));
+	auto iface = interface_factory<schema::TestInterface, encode::Native, storage::Default>::create(std::move(func_add), std::move(func_sub), std::move(func_multiply));
 
     {
-			data<schema::TestInt32Pair, encode::Native<storage::Default>> native;
+			data<schema::TestInt32Pair, encode::Native, storage::Default> native;
 
 			native.get<0>().set(5);
 			native.get<1>().set(40);
@@ -415,7 +415,7 @@ SAW_TEST("Interface basics"){
 			SAW_EXPECT(val.get() == 45, "Sum is incorrect");
 	}
     {
-			data<schema::TestInt32Pair, encode::Native<storage::Default>> native;
+			data<schema::TestInt32Pair, encode::Native, storage::Default> native;
 
 			native.get<0>().set(5);
 			native.get<1>().set(40);
@@ -426,7 +426,7 @@ SAW_TEST("Interface basics"){
 			SAW_EXPECT(val.get() == -35, "Sum is incorrect");
 	}
     {
-			data<schema::TestInt32Pair, encode::Native<storage::Default>> native;
+			data<schema::TestInt32Pair, encode::Native, storage::Default> native;
 
 			native.get<0>().set(5);
 			native.get<1>().set(40);
diff --git a/modules/codec/tests/csv.cpp b/modules/codec/tests/csv.cpp
index 04813c5..638b864 100644
--- a/modules/codec/tests/csv.cpp
+++ b/modules/codec/tests/csv.cpp
@@ -22,7 +22,7 @@ SAW_TEST("Codec Csv Encode Basic"){
 	using namespace saw;
 
 	size_t n_size = 3;
-	data <TestArray, encode::Native<storage::Default>> native_data{n_size};
+	data <TestArray, encode::Native, storage::Default> native_data{n_size};
 	{
 		auto& row = native_data.at(0);
 		row.template get<"string">().set("foo");
-- 
cgit v1.2.3