Removing storage as a parameter

17 files changed, 196 insertions, 200 deletions

diff --git a/modules/codec-json/c++/json.tmpl.hpp b/modules/codec-json/c++/json.tmpl.hpp
index 8663d5a..bead73a 100644
--- a/modules/codec-json/c++/json.tmpl.hpp
+++ b/modules/codec-json/c++/json.tmpl.hpp
@@ -837,7 +837,7 @@ struct json_decode<schema::Array<T,D>, ToDecode> {
 	using Schema = schema::Array<T,D>;
 
 	template<size_t Level>
-	static error_or<void> decode_flat_level(buffer_view& buff, std::vector<data<T, encode::Native, storage::Default>>& to, std::array<std::size_t, D>& index, std::array<std::size_t, D>& dims, bool log_dim){
+	static error_or<void> decode_flat_level(buffer_view& buff, std::vector<data<T, encode::Native>>& to, std::array<std::size_t, D>& index, std::array<std::size_t, D>& dims, bool log_dim){
 		if constexpr (Level == D) {
 			json_helper::skip_whitespace(buff);
 
@@ -903,7 +903,7 @@ struct json_decode<schema::Array<T,D>, ToDecode> {
 	}
 
 	template<std::size_t Level>
-	static error_or<void> decode_unflat_level(std::vector<data<T,encode::Native, storage::Default>>& flat, data<schema::Array<T,D>, ToDecode>& to, std::array<std::size_t, D>& index, std::size_t& flat_index) {
+	static error_or<void> decode_unflat_level(std::vector<data<T,encode::Native>>& flat, data<schema::Array<T,D>, ToDecode>& to, std::array<std::size_t, D>& index, std::size_t& flat_index) {
 		if constexpr ( Level == D ){
 			auto& flat_data = flat.at(flat_index);
 			to.at(index) = std::move(flat_data);
@@ -925,7 +925,7 @@ struct json_decode<schema::Array<T,D>, ToDecode> {
 		std::array<std::size_t, D> index;
 		std::array<std::size_t, D> dims;
 		std::fill(dims.begin(), dims.end(), 0);
-		std::vector<data<T,encode::Native, storage::Default>> flat_array;
+		std::vector<data<T,encode::Native>> flat_array;
 		auto eov = decode_flat_level<0>(buff, flat_array, index, dims, true);
 		if(eov.is_error()){
 			return eov;
diff --git a/modules/codec-json/tests/codec-json.cpp b/modules/codec-json/tests/codec-json.cpp
index bc1540e..1d6c0f0 100644
--- a/modules/codec-json/tests/codec-json.cpp
+++ b/modules/codec-json/tests/codec-json.cpp
@@ -34,7 +34,7 @@ using TestStructArrayStruct = Struct<
 
 SAW_TEST("UInt8 write"){
 	using namespace saw;
-	data<schema::UInt8, encode::Native, storage::Default> native_int;
+	data<schema::UInt8, encode::Native> native_int;
 	data<schema::UInt8, encode::Json> json_int;
 
 	native_int.set(121);
@@ -54,7 +54,7 @@ SAW_TEST("UInt8 write"){
 
 SAW_TEST("UInt16 write"){
 	using namespace saw;
-	data<schema::UInt16, encode::Native, storage::Default> native_int;
+	data<schema::UInt16, encode::Native> native_int;
 	data<schema::UInt16, encode::Json> json_int;
 
 	native_int.set(24413);
@@ -74,7 +74,7 @@ SAW_TEST("UInt16 write"){
 
 SAW_TEST("UInt32 write"){
 	using namespace saw;
-	data<schema::UInt32, encode::Native, storage::Default> native_int;
+	data<schema::UInt32, encode::Native> native_int;
 	data<schema::UInt32, encode::Json> json_int;
 
 	native_int.set(44123);
@@ -94,7 +94,7 @@ SAW_TEST("UInt32 write"){
 
 SAW_TEST("UInt64 write"){
 	using namespace saw;
-	data<schema::UInt64, encode::Native, storage::Default> native_int;
+	data<schema::UInt64, encode::Native> native_int;
 	data<schema::UInt64, encode::Json> json_int;
 
 	native_int.set(243345543);
@@ -114,7 +114,7 @@ SAW_TEST("UInt64 write"){
 
 SAW_TEST("Int8 write"){
 	using namespace saw;
-	data<schema::Int8, encode::Native, storage::Default> native_int;
+	data<schema::Int8, encode::Native> native_int;
 	data<schema::Int8, encode::Json> json_int;
 
 	native_int.set(-121);
@@ -134,7 +134,7 @@ SAW_TEST("Int8 write"){
 
 SAW_TEST("Int16 write"){
 	using namespace saw;
-	data<schema::Int16, encode::Native, storage::Default> native_int;
+	data<schema::Int16, encode::Native> native_int;
 	data<schema::Int16, encode::Json> json_int;
 
 	native_int.set(-24413);
@@ -154,7 +154,7 @@ SAW_TEST("Int16 write"){
 
 SAW_TEST("Int32 write"){
 	using namespace saw;
-	data<schema::Int32, encode::Native, storage::Default> native_int;
+	data<schema::Int32, encode::Native> native_int;
 	data<schema::Int32, encode::Json> json_int;
 
 	native_int.set(44123);
@@ -174,7 +174,7 @@ SAW_TEST("Int32 write"){
 
 SAW_TEST("Int64 write"){
 	using namespace saw;
-	data<schema::Int64, encode::Native, storage::Default> native_int;
+	data<schema::Int64, encode::Native> native_int;
 	data<schema::Int64, encode::Json> json_int;
 
 	native_int.set(243345543);
@@ -194,7 +194,7 @@ SAW_TEST("Int64 write"){
 
 SAW_TEST("String write and read"){
 	using namespace saw;
-	data<schema::String, encode::Native, storage::Default> nat_str;
+	data<schema::String, encode::Native> nat_str;
 	data<schema::String, encode::Json> json_str;
 
 	nat_str.set("foo");
@@ -221,7 +221,7 @@ SAW_TEST("String write and read"){
 
 SAW_TEST("Tuple read and write"){
 	using namespace saw;
-	data<schema::TestTuple, encode::Native, storage::Default> native_tup;
+	data<schema::TestTuple, encode::Native> native_tup;
 	data<schema::TestTuple, encode::Json> json_tup;
 
 	auto& nat_zero = native_tup.template get<0>();
@@ -250,7 +250,7 @@ SAW_TEST("Tuple read and write"){
 
 SAW_TEST("Array write"){
 	using namespace saw;
-	data<schema::TestArray, encode::Native, storage::Default> native{3u};
+	data<schema::TestArray, encode::Native> native{3u};
 	data<schema::TestArray, encode::Json> json;
 
 	native.at(0).set("foo");
@@ -270,7 +270,7 @@ SAW_TEST("Array write"){
 
 SAW_TEST("Three Dim Array write and read"){
 	using namespace saw;
-	data<schema::TestMultiArray, encode::Native, storage::Default> native{2,1,2};
+	data<schema::TestMultiArray, encode::Native> native{2,1,2};
 	data<schema::TestMultiArray, encode::Json> json;
 
 	native.at(0,0,0).set("multi");
@@ -300,7 +300,7 @@ SAW_TEST("Three Dim Array write and read"){
 
 SAW_TEST("Struct read and write"){
 	using namespace saw;
-	data<schema::TestStruct, encode::Native, storage::Default> native;
+	data<schema::TestStruct, encode::Native> native;
 	data<schema::TestStruct, encode::Json> json;
 
 	native.get<"foo">().set(5);
@@ -325,7 +325,7 @@ SAW_TEST("Struct read and write"){
 
 SAW_TEST("Array Struct Empty read and write"){
 	using namespace saw;
-	data<schema::TestArrayStruct, encode::Native, storage::Default> native{0u};
+	data<schema::TestArrayStruct, encode::Native> native{0u};
 	data<schema::TestArrayStruct, encode::Json> json;
 
 	codec<schema::TestArrayStruct, encode::Json> json_codec;
@@ -345,7 +345,7 @@ SAW_TEST("Array Struct Empty read and write"){
 
 SAW_TEST("Array Struct read and write"){
 	using namespace saw;
-	data<schema::TestArrayStruct, encode::Native, storage::Default> native{4u};
+	data<schema::TestArrayStruct, encode::Native> native{4u};
 	data<schema::TestArrayStruct, encode::Json> json;
 
 	native.at(0).get<"foo">().set(5);
@@ -374,7 +374,7 @@ SAW_TEST("Array Struct read and write"){
 
 SAW_TEST("Struct Array Struct read and write"){
 	using namespace saw;
-	data<schema::TestStructArrayStruct, encode::Native, storage::Default> native;
+	data<schema::TestStructArrayStruct, encode::Native> native;
 	native.template get<"banana">() = {4u};
 	data<schema::TestStructArrayStruct, encode::Json> json;
 
@@ -404,7 +404,7 @@ SAW_TEST("Struct Array Struct read and write"){
 
 SAW_TEST("Int8 read"){
 	using namespace saw;
-	data<schema::Int8, encode::Native, storage::Default> native_int;
+	data<schema::Int8, encode::Native> native_int;
 	data<schema::Int8, encode::Json> json_int{"43"};
 
 	codec<schema::Int8, encode::Json> json_codec;
@@ -422,7 +422,7 @@ SAW_TEST("Int8 read"){
 
 SAW_TEST("Int64 read"){
 	using namespace saw;
-	data<schema::Int64, encode::Native, storage::Default> native_int;
+	data<schema::Int64, encode::Native> native_int;
 	data<schema::Int64, encode::Json> json_int{"-453"};
 
 	codec<schema::Int64, encode::Json> json_codec;
@@ -440,7 +440,7 @@ SAW_TEST("Int64 read"){
 
 SAW_TEST("Tuple Pretty Encode and Decode"){
 	using namespace saw;
-	data<schema::TestTuple, encode::Native, storage::Default> native_tup;
+	data<schema::TestTuple, encode::Native> native_tup;
 	data<schema::TestTuple, encode::Json> json_tup;
 
 	auto& nat_zero = native_tup.template get<0>();
diff --git a/modules/codec-netcdf/tests/codec-netcdf.cpp b/modules/codec-netcdf/tests/codec-netcdf.cpp
index a47294f..7e624df 100644
--- a/modules/codec-netcdf/tests/codec-netcdf.cpp
+++ b/modules/codec-netcdf/tests/codec-netcdf.cpp
@@ -46,7 +46,7 @@ std::array<uint8_t,156> tests_data_array_nc = {
 SAW_TEST("NetCDF Struct Primitive write"){
 	using namespace saw;
 
-	data<schema::TestStruct, encode::Native, storage::Default> native;
+	data<schema::TestStruct, encode::Native> native;
 
 	native.template get<"data">().set(5);
 	native.template get<"other">().set(32.0);
@@ -69,7 +69,7 @@ SAW_TEST("NetCDF Struct Primitive read"){
 		using namespace saw;
 		
 		data<schema::TestStruct, encode::Netcdf> netcdf{tests_data_primitive_nc};
-		data<schema::TestStruct, encode::Native, storage::Default> native;
+		data<schema::TestStruct, encode::Native> native;
 
 		codec<schema::TestStruct, encode::Netcdf> codec;
 
@@ -84,7 +84,7 @@ SAW_TEST("NetCDF Struct Array read"){
 		
 		data<schema::TestArrayStruct, encode::Netcdf> netcdf{tests_data_array_nc};
 
-		data<schema::TestArrayStruct, encode::Native, storage::Default> native;
+		data<schema::TestArrayStruct, encode::Native> native;
 
 		codec<schema::TestArrayStruct, encode::Netcdf> codec;
 
diff --git a/modules/codec/c++/base64.hpp b/modules/codec/c++/base64.hpp
index 0c264be..141a63d 100644
--- a/modules/codec/c++/base64.hpp
+++ b/modules/codec/c++/base64.hpp
@@ -6,7 +6,7 @@ struct Base64 {};
 }
 
 template<>
-class data<schema::String, encode::Base64, storage::Default> {
+class data<schema::String, encode::Base64> {
 public:
 	using Schema = schema::String;
 private:
diff --git a/modules/codec/c++/data.hpp b/modules/codec/c++/data.hpp
index 77edf8e..5d3e4ee 100644
--- a/modules/codec/c++/data.hpp
+++ b/modules/codec/c++/data.hpp
@@ -17,9 +17,6 @@
 #include "schema_meta.hpp"
 
 namespace saw {
-namespace storage {
-struct Default {};
-}
 
 namespace encode {
 struct Native {
@@ -85,7 +82,7 @@ struct native_data_type<schema::Primitive<schema::FloatingPoint, 8>> {
 	using type = double;
 };
 
-template<typename T, typename Encoding = encode::Native, typename Storage = storage::Default>
+template<typename T, typename Encoding = encode::Native>
 class data {
 private:
 	static_assert(always_false<T>, "Type not supported.");
@@ -121,8 +118,8 @@ public:
 	}
 };
 
-template<typename T, size_t N, typename Storage>
-class data<schema::Primitive<T,N>, encode::Native, Storage> {
+template<typename T, size_t N>
+class data<schema::Primitive<T,N>, encode::Native> {
 public:
 	using Schema = schema::Primitive<T,N>;
 	using MetaSchema = typename meta_schema<Schema>::MetaSchema;
@@ -144,29 +141,29 @@ public:
 
 	typename native_data_type<Schema>::type get() const {return value_;}
 
-	data<Schema, encode::Native, Storage> operator*(const data<Schema, encode::Native, Storage>& rhs)const{
+	data<Schema, encode::Native> operator*(const data<Schema, encode::Native>& rhs)const{
 		return {get() * rhs.get()};
 	}
 	
-	data<Schema, encode::Native, Storage> operator/(const data<Schema, encode::Native, Storage>& rhs)const{
+	data<Schema, encode::Native> operator/(const data<Schema, encode::Native>& rhs)const{
 		return {get() / rhs.get()};
 	}
 	
-	data<Schema, encode::Native, Storage> operator+(const data<Schema, encode::Native, Storage>& rhs)const{
+	data<Schema, encode::Native> operator+(const data<Schema, encode::Native>& rhs)const{
 		return {get() + rhs.get()};
 	}
 	
-	data<Schema, encode::Native, Storage>& operator+=(const data<Schema, encode::Native, Storage>& rhs)const{
+	data<Schema, encode::Native>& operator+=(const data<Schema, encode::Native>& rhs)const{
 		value_ += rhs.get();
 		return *this;
 	}
 	
-	data<Schema, encode::Native, Storage>& operator-=(const data<Schema, encode::Native, Storage>& rhs)const{
+	data<Schema, encode::Native>& operator-=(const data<Schema, encode::Native>& rhs)const{
 		value_ -= rhs.get();
 		return *this;
 	}
 
-	data<Schema, encode::Native, Storage> operator-(const data<Schema, encode::Native, Storage>& rhs)const{
+	data<Schema, encode::Native> operator-(const data<Schema, encode::Native>& rhs)const{
 		return {get() - rhs.get()};
 	}
 
@@ -184,7 +181,7 @@ public:
 	 * Casts 
 	 */
 	template<typename Target>
-	data<Target, encode::Native, Storage> cast_to() const {
+	data<Target, encode::Native> cast_to() const {
 		auto raw_to = static_cast<typename saw::native_data_type<Target>::type>(value_);
 		return {raw_to};
 	}
@@ -193,13 +190,13 @@ public:
 /**
  * Mixed precision class for native formats
  */
-template<typename TA, uint64_t NA, typename TB, uint64_t NB, typename Storage> 
-class data<schema::MixedPrecision<schema::Primitive<TA,NA>, schema::Primitive<TB,NB>>, encode::Native, Storage>{
+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>{
 public:
 	using Schema = schema::MixedPrecision<schema::Primitive<TA,NA>, schema::Primitive<TB,NB>>;
 	using MetaSchema = typename meta_schema<Schema>::MetaSchema;
 private:
-	data<typename Schema::StorageSchema, encode::Native, Storage> value_;
+	data<typename Schema::StorageSchema, encode::Native> value_;
 public:
 	data():value_{}{}
 	data(data<MetaSchema, encode::Native>):value_{}{}
@@ -210,7 +207,7 @@ public:
 		return value_.template cast_to<typename Schema::InterfaceSchema>().get();
 	}
 
-	data(const saw::data<typename Schema::InterfaceSchema, encode::Native, Storage>& val){
+	data(const saw::data<typename Schema::InterfaceSchema, encode::Native>& val){
 		value_ = val.template cast_to<typename Schema::StorageSchema>();
 	}
 	
@@ -218,65 +215,65 @@ public:
 		value_.set(static_cast<typename Schema::StorageSchema>(val));
 	}
 	
-	data<Schema, encode::Native, Storage> operator*(const data<Schema, encode::Native, Storage>& rhs) const {
+	data<Schema, encode::Native> operator*(const data<Schema, encode::Native>& 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::Native, Storage> operator*(const data<typename Schema::InterfaceSchema, encode::Native, Storage>& rhs) const {
+	data<typename Schema::InterfaceSchema, encode::Native> operator*(const data<typename Schema::InterfaceSchema, encode::Native>& 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::Native, Storage> operator/(const data<Schema, encode::Native, Storage>& rhs)const{
+	data<typename Schema::InterfaceSchema, encode::Native> operator/(const data<Schema, encode::Native>& 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::Native, Storage> operator+(const data<Schema, encode::Native, Storage>& rhs)const{
+	data<typename Schema::InterfaceSchema, encode::Native> operator+(const data<Schema, encode::Native>& 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::Native, Storage>& operator+=(const data<Schema, encode::Native, Storage>& rhs)const{
+	data<Schema, encode::Native>& operator+=(const data<Schema, encode::Native>& rhs)const{
 		*this = *this + rhs.get();
 		return *this;
 	}
 
-	data<typename Schema::InterfaceSchema, encode::Native, Storage> operator-(const data<Schema, encode::Native, Storage>& rhs)const{
+	data<typename Schema::InterfaceSchema, encode::Native> operator-(const data<Schema, encode::Native>& 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::Native, Storage>& operator-=(const data<Schema, encode::Native, Storage>& rhs) const {
+	data<Schema, encode::Native>& operator-=(const data<Schema, encode::Native>& rhs) const {
 		*this = *this - rhs.get();
 		return *this;
 	}
 
 	template<typename Enc>
-	bool operator==(const data<Schema, Enc, Storage>& rhs)const{
+	bool operator==(const data<Schema, Enc>& rhs)const{
 		return get() == rhs.get();
 	}
 
 	template<typename Enc>
-	bool operator<(const data<Schema, Enc, Storage>& rhs) const {
+	bool operator<(const data<Schema, Enc>& rhs) const {
 		return get() < rhs.get();
 	}
 };
 
 /* 
 template<typename T, typename N>
-class data<schema::Ref<schema::Primitive<T,N>>, encode::Native, storage::Default {
+class data<schema::Ref<schema::Primitive<T,N>>, encode::Native {
 public:
 	using Schema = schema::Ref<schema::Primitive<T,N>>;
 private:
@@ -299,16 +296,16 @@ 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> {
 public:
 	using Schema = schema::Union<schema::Member<T,literals>...>;
 	using MetaSchema = typename meta_schema<Schema>::MetaSchema;
 private:
-	std::variant<data<T,encode::Native, storage::Default>...> value_;
+	std::variant<data<T,encode::Native>...> value_;
 	
 	template<uint64_t i = 0u>
 	struct init_helper {
-		static void apply(std::variant<data<T,encode::Native,storage::Default>...>& val, data<MetaSchema, encode::Native>&& init){
+		static void apply(std::variant<data<T,encode::Native>...>& val, data<MetaSchema, encode::Native>&& init){
 			if( init.index() == i ){
 				auto& val_i = val.template init<i>();
 				val_i = {std::move(init.template get<i>())};
@@ -332,12 +329,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> 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>& init(){
 		value_.template emplace<parameter_key_pack_index<lit, literals...>::value>();
 		return get<lit>();
 	}
@@ -348,12 +345,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>& 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>& get() const{
 		return std::get<parameter_key_pack_index<lit, literals...>::value>(value_);
 	}
 };
@@ -362,7 +359,7 @@ 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> {
 public:
 	using Schema = schema::Struct<schema::Member<T,literals>...>;
 	using MetaSchema = typename meta_schema<Schema>::MetaSchema;
@@ -370,11 +367,11 @@ private:
 	/**
 	 * Tuple storing the member values.
 	 */
-	std::tuple<data<T,encode::Native, storage::Default>...> value_;
+	std::tuple<data<T,encode::Native>...> value_;
 	
 	template<uint64_t i = 0u>
 	struct init_helper {
-		static void apply(std::tuple<data<T,encode::Native,storage::Default>...>& val, data<Schema, encode::Native>&& init){
+		static void apply(std::tuple<data<T,encode::Native>...>& val, data<Schema, encode::Native>&& init){
 			auto& val_i = val.template get<i>();
 			auto& init_i = init.template get<i>();
 
@@ -409,7 +406,7 @@ public:
 				literal, literals...
 			>::value
 		, T...>::type
-	, encode::Native, storage::Default>& get(){
+	, encode::Native>& get(){
 		return std::get<parameter_key_pack_index<literal, literals...>::value>(value_);
 	}
 	
@@ -423,7 +420,7 @@ public:
 				literal, literals...
 			>::value
 		, T...>::type
-	, encode::Native, storage::Default>& get() const {
+	, encode::Native>& get() const {
 		return std::get<parameter_key_pack_index<literal, literals...>::value>(value_);
 	}
 
@@ -436,16 +433,16 @@ public:
 };
 
 template<typename... T>
-class data<schema::Tuple<T...>, encode::Native, storage::Default> {
+class data<schema::Tuple<T...>, encode::Native> {
 public:
 	using Schema = schema::Tuple<T...>;
 	using MetaSchema = typename meta_schema<Schema>::MetaSchema;
 private:
-	std::tuple<data<T,encode::Native, storage::Default>...> value_;
+	std::tuple<data<T,encode::Native>...> value_;
 
 	template<uint64_t i = 0u>
 	struct init_helper {
-		static void apply(std::tuple<data<T,encode::Native,storage::Default>...>& val, data<MetaSchema, encode::Native>&& init){
+		static void apply(std::tuple<data<T,encode::Native>...>& val, data<MetaSchema, encode::Native>&& init){
 			auto& val_i = val.template get<i>();
 			auto& init_i = init.template get<i>();
 
@@ -468,12 +465,12 @@ public:
 	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>& 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>& get() const{
 		return std::get<i>(value_);
 	}
 
@@ -524,14 +521,14 @@ 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> {
 	public:
 		using Schema = schema::Array<T,Dim>;
 		using MetaSchema = typename meta_schema<Schema>::MetaSchema;
 	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>> value_;
 
 		uint64_t get_full_size() const {
 			uint64_t s = 1;
@@ -570,7 +567,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> 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.
@@ -605,29 +602,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>& 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>& 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>& 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>& 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>& 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>& at(const data<schema::FixedArray<schema::UInt64,Dim>>& i)const{
 			return value_.at(this->get_flat_index(i));
 		}
 		
@@ -675,14 +672,14 @@ 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> {
 public:
 	using Schema = schema::FixedArray<T,D...>;
 	using MetaSchema = typename meta_schema<Schema>::MetaSchema;
 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>, 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>, ct_multiply<uint64_t, D...>::value>;
 	ArrayT value_;
 	
 public:
@@ -692,29 +689,29 @@ public:
 		value_{value__}
 	{}
 
-	data<T, encode::Native, storage::Default>& at(const std::array<uint64_t, sizeof...(D)>& ind){
+	data<T, encode::Native>& 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>& 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>& 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>& 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>& 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>& at(const data<schema::FixedArray<schema::UInt64, sizeof...(D)>>& i)const{
 		return value_.at(this->get_flat_index(i));
 	}
 
@@ -748,7 +745,7 @@ private:
  * Data type representing string.
  */
 template<>
-class data<schema::String, encode::Native, storage::Default> {
+class data<schema::String, encode::Native> {
 public:
 	using Schema = schema::String;
 	using MetaSchema = typename meta_schema<Schema>::MetaSchema;
diff --git a/modules/codec/c++/data_raw.hpp b/modules/codec/c++/data_raw.hpp
index 40751a3..de5e7f0 100644
--- a/modules/codec/c++/data_raw.hpp
+++ b/modules/codec/c++/data_raw.hpp
@@ -211,7 +211,7 @@ 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::NativeRaw, storage::Default> {
+class data<schema::Struct<schema::Member<T, literals>...>, encode::NativeRaw> {
 public:
 	using Schema = schema::Struct<schema::Member<T,literals>...>;
 	using MetaSchema = typename meta_schema<Schema>::MetaSchema;
@@ -219,7 +219,7 @@ private:
 	/**
 	 * Tuple storing the member values.
 	 */
-	std::tuple<data<T,encode::NativeRaw, storage::Default>...> value_;
+	std::tuple<data<T,encode::NativeRaw>...> value_;
 	
 	template<uint64_t i = 0u>
 	struct init_helper {
@@ -258,7 +258,7 @@ public:
 				literal, literals...
 			>::value
 		, T...>::type
-	, encode::NativeRaw, storage::Default>& get(){
+	, encode::NativeRaw>& get(){
 		return std::get<parameter_key_pack_index<literal, literals...>::value>(value_);
 	}
 	
@@ -272,7 +272,7 @@ public:
 				literal, literals...
 			>::value
 		, T...>::type
-	, encode::NativeRaw, storage::Default>& get() const {
+	, encode::NativeRaw>& get() const {
 		return std::get<parameter_key_pack_index<literal, literals...>::value>(value_);
 	}
 
@@ -285,12 +285,12 @@ public:
 };
 
 template<typename... T>
-class data<schema::Tuple<T...>, encode::NativeRaw, storage::Default> {
+class data<schema::Tuple<T...>, encode::NativeRaw> {
 public:
 	using Schema = schema::Tuple<T...>;
 	using MetaSchema = typename meta_schema<Schema>::MetaSchema;
 private:
-	std::tuple<data<T,encode::NativeRaw, storage::Default>...> value_;
+	std::tuple<data<T,encode::NativeRaw>...> value_;
 
 	template<uint64_t i = 0u>
 	struct init_helper {
@@ -317,12 +317,12 @@ public:
 	SAW_DEFAULT_MOVE(data);
 	
 	template<size_t i>
-	data<typename parameter_pack_type<i,T...>::type, encode::NativeRaw, storage::Default>& get(){
+	data<typename parameter_pack_type<i,T...>::type, encode::NativeRaw>& get(){
 		return std::get<i>(value_);
 	}
 	
 	template<size_t i>
-	const data<typename parameter_pack_type<i,T...>::type, encode::NativeRaw, storage::Default>& get() const{
+	const data<typename parameter_pack_type<i,T...>::type, encode::NativeRaw>& get() const{
 		return std::get<i>(value_);
 	}
 
@@ -332,7 +332,7 @@ public:
 };
 
 template<typename T, size_t Dim>
-class data<schema::Array<T,Dim>, encode::NativeRaw, storage::Default> {
+class data<schema::Array<T,Dim>, encode::NativeRaw> {
 	public:
 		using Schema = schema::Array<T,Dim>;
 		using MetaSchema = typename meta_schema<Schema>::MetaSchema;
@@ -348,7 +348,7 @@ class data<schema::Array<T,Dim>, encode::NativeRaw, storage::Default> {
 			std::conditional<
 				is_primitive<Schema>::value,
 				typename native_data_type<T>::type,
-				data<T, encode::NativeRaw, storage::Default>
+				data<T, encode::NativeRaw>
 			>
 		> value_;
 
@@ -390,7 +390,7 @@ class data<schema::Array<T,Dim>, encode::NativeRaw, storage::Default> {
 		}
 
 		template<size_t i = 0>
-		error_or<void> add(saw::data<T,encode::NativeRaw, storage::Default> data){
+		error_or<void> add(saw::data<T,encode::NativeRaw> 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.
@@ -425,29 +425,29 @@ class data<schema::Array<T,Dim>, encode::NativeRaw, storage::Default> {
 			static_assert(sizeof...(Dims)==Dim, "Argument size must be equal to the Dimension");
 		}
 
-		data<T, encode::NativeRaw, storage::Default>& at(const std::array<uint64_t, Dim>& ind){
+		data<T, encode::NativeRaw>& at(const std::array<uint64_t, Dim>& ind){
 			return value_.at(this->get_flat_index(ind));
 		}
 		
-		const data<T, encode::NativeRaw, storage::Default>& at(const std::array<uint64_t, Dim>& ind) const {
+		const data<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, storage::Default>& at(Dims... i){
+		data<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, storage::Default>& at(Dims... i) const {
+		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)...}));
 		}
 
-		data<T,encode::NativeRaw, storage::Default>& at(const data<schema::FixedArray<schema::UInt64,Dim>>& i){
+		data<T,encode::NativeRaw>& at(const data<schema::FixedArray<schema::UInt64,Dim>>& i){
 			return value_.at(this->get_flat_index(i));
 		}
 		
-		const data<T,encode::NativeRaw, storage::Default>& at(const data<schema::FixedArray<schema::UInt64,Dim>>& i)const{
+		const data<T,encode::NativeRaw>& at(const data<schema::FixedArray<schema::UInt64,Dim>>& i)const{
 			return value_.at(this->get_flat_index(i));
 		}
 		
diff --git a/modules/codec/c++/id_map.hpp b/modules/codec/c++/id_map.hpp
index 18a331f..56becf0 100644
--- a/modules/codec/c++/id_map.hpp
+++ b/modules/codec/c++/id_map.hpp
@@ -19,7 +19,7 @@ private:
 		/**
 		 * Container which stores the primary data
 		 */
-		std::vector<data<T,Encoding,Storage>> data_;
+		std::vector<data<T,Encoding>> data_;
 		/**
 		 * Container which tracks free'd/fragmented elements within the
 		 * main container
@@ -65,7 +65,7 @@ public:
 		 * Inserts an element into the container and returns either an id on success
 		 * or an error on failure.
 		 */
-		error_or<id<T>> insert(data<T,Encoding,Storage> val) noexcept {
+		error_or<id<T>> insert(data<T,Encoding> val) noexcept {
 				/// @todo Fix size_t and id base type
 				if(free_ids_.empty()){
 						try {
@@ -90,7 +90,7 @@ public:
 		/**
 		 * Insert as data with associated id. This can fail when it doesn't adhere to the standard approach.  
 		 */
-		error_or<void> insert_as(data<T,Encoding,Storage> val, id<T> id) noexcept {
+		error_or<void> insert_as(data<T,Encoding> val, id<T> id) noexcept {
 			if(free_ids_.empty()){
 				if( id.get_value() != data_.size() ){
 					return make_error<err::invalid_state>("Can't insert_as with provided ID. Doesn't match.");
@@ -178,7 +178,7 @@ public:
 		 * Returns an error on failure and returns
 		 * a value pointer on success.
 		 */
-		error_or<data<T,Encoding,Storage>*> find(const id<T>& val){
+		error_or<data<T,Encoding>*> find(const id<T>& val){
 			if(val.get_value() >= data_.size()){
 				return make_error<err::not_found>("ID is too large");
 			}
diff --git a/modules/codec/c++/interface.hpp b/modules/codec/c++/interface.hpp
index e1c9a12..f31b778 100644
--- a/modules/codec/c++/interface.hpp
+++ b/modules/codec/c++/interface.hpp
@@ -8,44 +8,44 @@
 #include "data.hpp"
 
 namespace saw {
-template<typename SchemaFunc, typename Encode, typename Storage, typename Context = void_t >
+template<typename SchemaFunc, typename Encode, typename Context = void_t >
 class function;
 
 namespace impl {
-template<typename DataSchema, typename Encode, typename Storage>
+template<typename DataSchema, typename Encode>
 struct FuncReturnTypeHelper {
-	using Type = data<DataSchema,Encode,Storage>;
+	using Type = data<DataSchema,Encode>;
 };
 
-template<typename Encode, typename Storage>
-struct FuncReturnTypeHelper<schema::Void, Encode, Storage> {
+template<typename Encode>
+struct FuncReturnTypeHelper<schema::Void, Encode> {
 	using Type = void;
 };
 
-template<typename Request, typename Response, typename Encode, typename Storage, typename Ctx>
+template<typename Request, typename Response, typename Encode, typename Ctx>
 struct FuncTypeHelper {
-	using Type = std::function<error_or<typename FuncReturnTypeHelper<Response,Encode,Storage>::Type>(data<Request, Encode, Storage>&, Ctx)>;
+	using Type = std::function<error_or<typename FuncReturnTypeHelper<Response,Encode>::Type>(data<Request, Encode>&, Ctx)>;
 };
 
-template<typename Request, typename Response, typename Encode, typename Storage>
-struct FuncTypeHelper<Request, Response, Encode, Storage, void_t> {
-	using Type = std::function<error_or<typename FuncReturnTypeHelper<Response, Encode, Storage>::Type>(data<Request, Encode, Storage>&)>;
+template<typename Request, typename Response, typename Encode>
+struct FuncTypeHelper<Request, Response, Encode, void_t> {
+	using Type = std::function<error_or<typename FuncReturnTypeHelper<Response, Encode>::Type>(data<Request, Encode>&)>;
 };
 
 }
 
-template<typename Request, typename Response, typename Encode, typename Storage, typename Context>
-class function<schema::Function<Request, Response>, Encode, Storage, Context> {
+template<typename Request, typename Response, typename Encode, typename Context>
+class function<schema::Function<Request, Response>, Encode, Context> {
 private:
-	typename impl::FuncTypeHelper<Request, Response, Encode, Storage, Context>::Type func_;
-	using ResponseDataType = typename impl::FuncReturnTypeHelper<Response, Encode, Storage>::Type;
+	typename impl::FuncTypeHelper<Request, Response, Encode, Context>::Type func_;
+	using ResponseDataType = typename impl::FuncReturnTypeHelper<Response, Encode>::Type;
 public:
 	template<typename Func>
 		function(Func func):
 				func_{std::move(func)}
 		{}
 
-		error_or<ResponseDataType> call(data<Request, Encode, Storage>& req, Context ctx = {}){
+		error_or<ResponseDataType> call(data<Request, Encode>& req, Context ctx = {}){
 			if constexpr (std::is_same_v<Context, void_t>){
 				(void) ctx;
 				return func_(req);
@@ -55,17 +55,17 @@ public:
 		}
 };
 
-template<typename T, typename Encode, typename Storage = storage::Default, typename Context = void_t >
+template<typename T, typename Encode, typename Context = void_t >
 class interface;
 
-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> {
+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> {
 public:
 	using Schema = schema::Interface<schema::Member<schema::Function<Requests, Responses>,Names>...>;
 private:
-		std::tuple<function<schema::Function<Requests, Responses>, Encode, Storage, Context>...> funcs_;
+		std::tuple<function<schema::Function<Requests, Responses>, Encode, Context>...> funcs_;
 public:
-		interface(function<schema::Function<Requests, Responses>, Encode, Storage, Context>... funcs):
+		interface(function<schema::Function<Requests, Responses>, Encode, Context>... funcs):
 				funcs_{std::move(funcs)...}
 		{}
 
@@ -88,7 +88,6 @@ public:
 						, Responses...>::type
 				>
 		,		Encode
-		,		Storage
 		,		Context
 		>& get(){
 				return std::get<parameter_key_pack_index<Lit, Names...>::value>(funcs_);
@@ -102,14 +101,14 @@ public:
 								Lit, Names...
 						>::value
 				, Responses...>::type
-		, Encode, Storage>::Type > call(
+		, Encode>::Type > call(
 						data<
 								typename parameter_pack_type<
 										parameter_key_pack_index<
 												Lit, Names...
 										>::value
 								, Requests...>::type
-						, Encode, Storage>& req,
+						, Encode>& req,
 						Context ctx = {}
 				){
 				if constexpr (std::is_same_v<Context, void_t>) {
@@ -121,19 +120,19 @@ public:
 		}
 };
 
-template<typename T, typename Encode, typename Storage = storage::Default, typename Context = void_t>
+template<typename T, typename Encode, typename Context = void_t>
 struct function_factory {
 		template<typename Func>
-		static function<T,Encode, Storage, Context> create(Func func){
-				return function<T,Encode, Storage, Context> {std::move(func)};
+		static function<T,Encode, Context> create(Func func){
+				return function<T,Encode, Context> {std::move(func)};
 		}
 };
 
-template<typename T, typename Encode, typename Storage = storage::Default, typename Context = void_t>
+template<typename T, typename Encode, typename Context = void_t>
 struct interface_factory {
 		template<typename... Func>
-		static interface<T,Encode,Storage,Context> create(Func... func){
-				return interface<T,Encode,Storage,Context>{std::move(func)...};
+		static interface<T,Encode,Context> create(Func... func){
+				return interface<T,Encode,Context>{std::move(func)...};
 		}
 };
 }
diff --git a/modules/codec/tests/codec.cpp b/modules/codec/tests/codec.cpp
index 1bec214..7ad1c89 100644
--- a/modules/codec/tests/codec.cpp
+++ b/modules/codec/tests/codec.cpp
@@ -54,7 +54,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> arr{500u};
 
 	int bar = 0;
 
@@ -73,7 +73,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> 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");
@@ -82,7 +82,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> arr{5u};
 
 	int bar = 0;
 
@@ -99,7 +99,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> arr{10,30u};
 
 	int expected_sum = (300 * 301) / 2;
 
@@ -123,7 +123,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> arr{10,10u,3};
 	int expected_sum = (300 * 301) / 2;
 
 	int bar = 0;
@@ -149,7 +149,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> native;
 	data<schema::UInt16, encode::KelSimple> simple;
 
 	codec<schema::UInt16, encode::KelSimple> codec;
@@ -172,7 +172,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> native;
 	data<schema::UInt32, encode::KelSimple> simple;
 
 	codec<schema::UInt32, encode::KelSimple> codec;
@@ -195,7 +195,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> native{2,3};
 	data<schema::TwoDimArray, encode::KelSimple> simple;
 
 	codec<schema::TwoDimArray, encode::KelSimple> codec;
@@ -228,7 +228,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> native;
 	data<schema::TestStruct,encode::KelSimple> simple;
 
 	auto& tda = native.template get<"two_dim_array">();
@@ -259,7 +259,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> native;
 
 	native.template init<"two">().set(50u);
 
@@ -272,10 +272,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> 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>{});
 	native.template get<"number">().set(410);
 	
 	codec<schema::TestUnion, encode::KelSimple> codec;
@@ -296,7 +296,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> native;
 	data<schema::TestTuple,encode::KelSimple> simple;
 
 	auto& tda = native.template get<0>();
@@ -327,7 +327,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> native;
 	data<schema::String,encode::KelSimple> simple;
 
 	std::string str = "FooBananaJoe";
@@ -352,14 +352,14 @@ SAW_TEST("Function basics"){
 	using namespace saw;
 
 	{
-			data<schema::TestInt32Pair, encode::Native, storage::Default> native;
+			data<schema::TestInt32Pair, encode::Native> 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>::create(
+				[](data<schema::TestInt32Pair, encode::Native> req){
+						data<schema::Int32, encode::Native> resp;
 
 						resp.set(req.get<0>().get() + req.get<1>().get());
 
@@ -378,26 +378,26 @@ SAW_TEST("Function basics"){
 SAW_TEST("Interface basics"){
 	using namespace saw;
 
-	data<schema::TestInt32Pair, encode::Native, storage::Default> native;
+	data<schema::TestInt32Pair, encode::Native> 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>& req){
+				data<schema::Int32, encode::Native> 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>& req){
+				data<schema::Int32, encode::Native> 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>& req){
+				data<schema::Int32, encode::Native> resp;
 
 				resp.set(req.get<0>().get() * req.get<1>().get());
 
@@ -409,10 +409,10 @@ SAW_TEST("Interface basics"){
 		return void_t{};
 	};
 
-	auto iface = interface_factory<schema::TestInterface, encode::Native, storage::Default>::create(std::move(func_add), std::move(func_sub), std::move(func_multiply), std::move(func_void));
+	auto iface = interface_factory<schema::TestInterface, encode::Native>::create(std::move(func_add), std::move(func_sub), std::move(func_multiply), std::move(func_void));
 
     {
-			data<schema::TestInt32Pair, encode::Native, storage::Default> native;
+			data<schema::TestInt32Pair, encode::Native> native;
 
 			native.get<0>().set(5);
 			native.get<1>().set(40);
@@ -423,7 +423,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> native;
 
 			native.get<0>().set(5);
 			native.get<1>().set(40);
@@ -434,7 +434,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> 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 638b864..ac394ce 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> native_data{n_size};
 	{
 		auto& row = native_data.at(0);
 		row.template get<"string">().set("foo");
diff --git a/modules/remote-sycl/c++/device.hpp b/modules/remote-sycl/c++/device.hpp
index 6d4dbbf..a050078 100644
--- a/modules/remote-sycl/c++/device.hpp
+++ b/modules/remote-sycl/c++/device.hpp
@@ -37,7 +37,7 @@ public:
 	template<typename Schema, typename Encoding>
 	error_or<data<Schema, Encoding>> copy_to_host(data<Schema, encode::Sycl<Encoding>>& dev_data){
 		/**
-		data<Schema,Encoding, Storage> host_data;
+		data<Schema,Encoding> host_data;
 		cmd_queue_.submit([&](cl::sycl::handler& h){
 			auto acc_buff = dev_data.template access<cl::sycl::access::mode::read>(h);
 			h.copy(acc_buff, &host_data);
diff --git a/modules/remote-sycl/c++/rpc.hpp b/modules/remote-sycl/c++/rpc.hpp
index da2eeaa..8cb4d8d 100644
--- a/modules/remote-sycl/c++/rpc.hpp
+++ b/modules/remote-sycl/c++/rpc.hpp
@@ -48,14 +48,14 @@ public:
 	/**
 	 * Wait for the data
 	 */
-	error_or<data<T,Encoding,Storage>> wait(){
+	error_or<data<T,Encoding>> wait(){
 		return make_error<err::not_implemented>();
 	}
 
 	/**
 	 * Request data asynchronously
 	 */
-	// conveyor<data<T,Encoding,Storage>> on_receive(); /// Stopped here
+	// conveyor<data<T,Encoding>> on_receive(); /// Stopped here
 };
 
 /**
@@ -151,7 +151,7 @@ public:
 		>
 	> call(const data_or_id<typename schema_member_type<Name, Iface>::type::RequestT, Encoding>& input){
 		auto next_free_id = srv_->template next_free_id<typename schema_member_type<Name, Iface>::type::ResponseT>();
-		return srv_->template call<Name, Storage>(input, next_free_id);
+		return srv_->template call<Name>(input, next_free_id);
 	}
 
 };
@@ -180,7 +180,7 @@ private:
 	/**
 	 * The interface including the relevant context class.
 	 */
-	interface<Iface, Encoding, storage::Default, InterfaceCtxT> cl_interface_;
+	interface<Iface, Encoding, InterfaceCtxT> cl_interface_;
 
 public:
 
@@ -205,7 +205,7 @@ public:
 
 	/**
 	template<typename IdT, typename Storage>
-	remote_data<IdT, Encoding, Storage, rmt::Sycl> request_data(id<IdT> dat_id){
+	remote_data<IdT, Encoding, rmt::Sycl> request_data(id<IdT> dat_id){
 		return {dat_id, std::get<id_map<IdT,Encoding,rmt::Sycl>>(storage_.maps), device_->get_handle()};
 	}
 	*/
diff --git a/modules/remote-sycl/c++/transfer.hpp b/modules/remote-sycl/c++/transfer.hpp
index e39165b..b6a21f0 100644
--- a/modules/remote-sycl/c++/transfer.hpp
+++ b/modules/remote-sycl/c++/transfer.hpp
@@ -131,7 +131,7 @@ public:
 	 * Requests data from the server
 	 */
 	template<typename Sch>
-	error_or<data<Sch, Encoding, storage::Default>> receive(id<Sch> store_id){
+	error_or<data<Sch, Encoding>> receive(id<Sch> store_id){
 		auto& vals = std::get<std::unordered_map<uint64_t, data<Sch,encode::Sycl<Encoding>>>>(values_);
 		auto find_res = vals.find(store_id.get_value());
 		if(find_res == vals.end()){
diff --git a/modules/remote-sycl/examples/sycl_basic.cpp b/modules/remote-sycl/examples/sycl_basic.cpp
index bc4d997..a4bc595 100644
--- a/modules/remote-sycl/examples/sycl_basic.cpp
+++ b/modules/remote-sycl/examples/sycl_basic.cpp
@@ -21,7 +21,7 @@ int main(){
 	auto device = remote_ctx.connect_device(*rmt_addr);
 
 	auto rpc_server = listen_basic_sycl(remote_ctx, device, *rmt_addr);
-	saw::rpc_client<schema::BasicInterface, saw::encode::Native, saw::storage::Default, saw::rmt::Sycl> client{rpc_server};
+	saw::rpc_client<schema::BasicInterface, saw::encode::Native, saw::rmt::Sycl> client{rpc_server};
 
 	saw::id<schema::Array<schema::UInt64>> id_zero{0u};
 	saw::data<schema::Array<schema::UInt64>, saw::encode::Native> ex_data{1u};
@@ -38,7 +38,7 @@ int main(){
 		id_zero = eov.get_value();
 	}
 	{
-		auto rmt_data = rpc_server.request_data<schema::Array<schema::UInt64>, saw::storage::Default>(id_zero);
+		auto rmt_data = rpc_server.request_data<schema::Array<schema::UInt64>>(id_zero);
 		auto eo_rd = rmt_data.wait();
 		if(eo_rd.is_error()){
 			auto& err = eo_rd.get_error();
@@ -64,7 +64,7 @@ int main(){
 		id_one = eov.get_value();
 	}
 	{
-		auto rmt_data = rpc_server.request_data<schema::Array<schema::UInt64>, saw::storage::Default>(id_one);
+		auto rmt_data = rpc_server.request_data<schema::Array<schema::UInt64>>(id_one);
 		auto eo_rd = rmt_data.wait();
 		if(eo_rd.is_error()){
 			auto& err = eo_rd.get_error();
diff --git a/modules/remote-thread/c++/remote.hpp b/modules/remote-thread/c++/remote.hpp
index 39c64a6..280101a 100644
--- a/modules/remote-thread/c++/remote.hpp
+++ b/modules/remote-thread/c++/remote.hpp
@@ -36,7 +36,7 @@ class thread_rpc_communication_handler final {
 private:
 	std::mutex mut_;
 
-	using FunctionT = std::function<error_or<void>(rpc_server<Iface, Encoding, Storage, rmt::Thread>&)>;
+	using FunctionT = std::function<error_or<void>(rpc_server<Iface, Encoding, rmt::Thread>&)>;
 	std::deque<FunctionT> dispatches_;
 
 	// TODO Need a send + receive + erase request queue
@@ -48,12 +48,12 @@ public:
 	error_or<void> call(id<Void> dat_id){
 		std::lock_guard lock{mut_};
 
-		dispatches_.emplace_back([dat_id](rpc_server<Iface, Encoding, Storage, rmt::Thread>& srv){
+		dispatches_.emplace_back([dat_id](rpc_server<Iface, Encoding, rmt::Thread>& srv){
 			srv.template call<Lit>(dat_id);
 		});
 	}
 
-	error_or<void> run_next_dispatch(rpc_server<Iface, Encoding, Storage, rmt::Thread>& srv){
+	error_or<void> run_next_dispatch(rpc_server<Iface, Encoding, rmt::Thread>& srv){
 		std::lock_guard lock{mut_};
 		if(dispatches_.empty()){
 			return make_error<err::recoverable>("Dispatch Queue is empty");
@@ -67,19 +67,19 @@ public:
 
 }
 
-template<Iface, Encoding, Storage>
-class rpc_server<Iface, Encoding, Storage, rmt::Thread> {
+template<Iface, Encoding>
+class rpc_server<Iface, Encoding, rmt::Thread> {
 private:
-	our<impl::thread_rpc_communication_handler<Iface, Encoding, Storage>> comms_;
+	our<impl::thread_rpc_communication_handler<Iface, Encoding>> comms_;
 public:	
 };
 
-template<Iface, Encoding, Storage>
-class rpc_client<Iface, Encoding, Storage, rmt::Thread> {
+template<Iface, Encoding>
+class rpc_client<Iface, Encoding, rmt::Thread> {
 private:
-	our<impl::thread_rpc_communication_handler<Iface, Encoding, Storage>> comms_;
+	our<impl::thread_rpc_communication_handler<Iface, Encoding>> comms_;
 public:
-	rpc_client(our<impl::thread_rpc_communication_handler<Iface, Encoding, Storage>> comms__):
+	rpc_client(our<impl::thread_rpc_communication_handler<Iface, Encoding>> comms__):
 		comms_{std::move(comms__)}
 	{}
 };
diff --git a/modules/remote/c++/transfer.hpp b/modules/remote/c++/transfer.hpp
index f68497b..5a2e2b2 100644
--- a/modules/remote/c++/transfer.hpp
+++ b/modules/remote/c++/transfer.hpp
@@ -32,14 +32,14 @@ template<typename Schema, typename Encoding, typename Remote>
 class data_client;
 
 namespace impl {
-template<typename Encoding, typename Storage, typename T>
+template<typename Encoding, typename T>
 struct data_server_redux {
 	using type = std::tuple<>;
 };
 
-template<typename Encoding, typename Storage, typename... Schema>
-struct data_server_redux<Encoding, Storage, tmpl_group<Schema...>> {
-	using type = std::tuple<std::unordered_map<uint64_t, data<Schema, Encoding, Storage>>...>;
+template<typename Encoding, typename... Schema>
+struct data_server_redux<Encoding, tmpl_group<Schema...>> {
+	using type = std::tuple<std::unordered_map<uint64_t, data<Schema, Encoding>>...>;
 };
 }
 }
diff --git a/modules/remote/c++/transfer_loopback.hpp b/modules/remote/c++/transfer_loopback.hpp
index 39ae402..bc23498 100644
--- a/modules/remote/c++/transfer_loopback.hpp
+++ b/modules/remote/c++/transfer_loopback.hpp
@@ -102,7 +102,7 @@ public:
 template<typename... Schema, typename Encoding>
 class data_server<tmpl_group<Schema...>, Encoding, rmt::Loopback> final : public i_data_server<rmt::Loopback> {
 private:
-	typename impl::data_server_redux<Encoding, storage::Default, typename tmpl_reduce<tmpl_group<Schema...>>::type>::type values_;
+	typename impl::data_server_redux<Encoding, typename tmpl_reduce<tmpl_group<Schema...>>::type>::type values_;
 
 	ptr<remote<rmt::Loopback>> remote_;
 	remote_address<rmt::Loopback> rmt_address_;
@@ -134,7 +134,7 @@ public:
 	 * Get data from client
 	 */
 	template<typename Sch>
-	error_or<void> send(const data<Sch, Encoding, storage::Default>& dat, id<Sch> store_id){
+	error_or<void> send(const data<Sch, Encoding>& dat, id<Sch> store_id){
 		auto& vals = std::get<std::unordered_map<uint64_t, data<Sch,Encoding>>>(values_);
 
 		try {
@@ -166,7 +166,7 @@ public:
 	}
 
 	template<typename Sch>
-	error_or<data<Sch, Encoding, storage::Default>> receive(id<Sch> store_id){
+	error_or<data<Sch, Encoding>> receive(id<Sch> store_id){
 		auto& vals = std::get<std::unordered_map<uint64_t, data<Sch,Encoding>>>(values_);
 
 		auto find_res = vals.find(store_id.get_value());
@@ -189,7 +189,7 @@ public:
 	}
 
 	template<typename Sch>
-	error_or<data<Sch, Encoding, storage::Default>*> find(id<Sch> store_id){
+	error_or<data<Sch, Encoding>*> find(id<Sch> store_id){
 		auto& vals = std::get<std::unordered_map<uint64_t, data<Sch,Encoding>>>(values_);
 		auto find_res = vals.find(store_id.get_value());
 		if(find_res == vals.end()){
@@ -245,7 +245,7 @@ public:
 	/**
 	 * Receive data
 	 */
-	conveyor<data<Schema, Encoding, storage::Default>> receive(id<Schema> dat_id){
+	conveyor<data<Schema, Encoding>> receive(id<Schema> dat_id){
 		auto eov = srv_().receive(dat_id);
 		if(eov.is_error()){
 			auto& err = eov.get_error();
@@ -310,7 +310,7 @@ public:
 	 * Send data to the remote.
 	 */
 	template<typename Sch>
-	error_or<id<Sch>> send(const data<Sch, Encoding, storage::Default>& dat){
+	error_or<id<Sch>> send(const data<Sch, Encoding>& dat){
 		id<Sch> dat_id{next_id_};
 		auto eov = srv_().send(dat, dat_id);
 		if(eov.is_error()){
@@ -341,7 +341,7 @@ public:
 	 * Receive data
 	 */
 	template<typename Sch>
-	conveyor<data<Sch, Encoding, storage::Default>> receive(id<Sch> dat_id){
+	conveyor<data<Sch, Encoding>> receive(id<Sch> dat_id){
 		auto eov = srv_().receive(dat_id);
 		if(eov.is_error()){
 			auto& err = eov.get_error();