summaryrefslogtreecommitdiff
path: root/modules/codec/c++
diff options
context:
space:
mode:
Diffstat (limited to 'modules/codec/c++')
-rw-r--r--modules/codec/c++/base64.hpp2
-rw-r--r--modules/codec/c++/data.hpp123
-rw-r--r--modules/codec/c++/data_raw.hpp34
-rw-r--r--modules/codec/c++/id_map.hpp8
-rw-r--r--modules/codec/c++/interface.hpp57
5 files changed, 110 insertions, 114 deletions
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)...};
}
};
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-09-17 17:59:49 +0000