1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
#pragma once
#include <forstio/common.h>
#include <forstio/string_literal.h>
namespace saw {
namespace schema {
// NOLINTBEGIN
template <typename T, string_literal Literal> struct Member {};
template <typename... T> struct Struct {
static_assert(
always_false<T...>,
"This schema template doesn't support this type of template argument");
};
template <typename... V, string_literal... K>
struct Struct<Member<V, K>...> {};
template <typename... T> struct Union {
static_assert(
always_false<T...>,
"This schema template doesn't support this type of template argument");
};
template <typename... V, string_literal... K>
struct Union<Member<V, K>...> {};
template <typename T, size_t Dim = 1> struct Array {};
template<typename T, size_t... S> struct FixedArray {};
template <typename... T> struct Tuple {};
/**
* This acts as a separator of different encodings being mashed together
* For example we can transport any base64 encodings in JSON
*
* using WrappedExample = schema::Tuple<
* schema::Wrapper<schema::String, encode::Base64>
* >;
*
* data<WrappedExample, encode::Json> ex_data;
*/
template <typename T, typename Enc>
class Wrapper {};
struct String {};
struct SignedInteger {};
struct UnsignedInteger {};
struct FloatingPoint {};
template <class T, size_t N> struct Primitive {
static_assert(((std::is_same_v<T, SignedInteger> ||
std::is_same_v<T, UnsignedInteger>)&&(N == 1 || N == 2 ||
N == 4 || N == 8)) ||
(std::is_same_v<T, FloatingPoint> && (N == 4 || N == 8)),
"Primitive Type is not supported");
};
using Int8 = Primitive<SignedInteger, 1>;
using Int16 = Primitive<SignedInteger, 2>;
using Int32 = Primitive<SignedInteger, 4>;
using Int64 = Primitive<SignedInteger, 8>;
using UInt8 = Primitive<UnsignedInteger, 1>;
using UInt16 = Primitive<UnsignedInteger, 2>;
using UInt32 = Primitive<UnsignedInteger, 4>;
using UInt64 = Primitive<UnsignedInteger, 8>;
using Float32 = Primitive<FloatingPoint, 4>;
using Float64 = Primitive<FloatingPoint, 8>;
/**
* Classes allowing to distinguish Ints from VarInts
*/
template<typename T, std::size_t MaxLen>
struct VariableLengthPrimitive {};
using VarInt = VariableLengthPrimitive<SignedInteger, 5>;
using VarLong = VariableLengthPrimitive<SignedInteger, 10>;
/**
* Classes enabling Rpc calls
*/
template <class Request, class Response>
struct Function {};
template <class... T> struct Interface {
static_assert(
always_false<T...>,
"This schema template doesn't support this type of template argument");
};
template <class... Requests, class... Responses, string_literal... Names>
struct Interface<Member<Function<Requests, Responses>,Names>...> {};
// NOLINTEND
} // namespace schema
template <class T> struct is_struct {
constexpr static bool value = false;
};
template <class... V, string_literal... K> struct is_struct<schema::Struct<schema::Member<V,K>...>> {
constexpr static bool value = true;
};
template <class T> struct is_string {
constexpr static bool value = false;
};
template <> struct is_string<schema::String> {
constexpr static bool value = true;
};
template <class T> struct is_tuple {
constexpr static bool value = false;
};
template <class... T> struct is_tuple<schema::Tuple<T...>> {
constexpr static bool value = true;
};
template <class T> struct is_array {
constexpr static bool value = false;
};
template <class T, size_t Dim> struct is_array<schema::Array<T,Dim>> {
constexpr static bool value = true;
};
template <class T> struct is_primitive {
constexpr static bool value = false;
};
template <typename T, size_t N> struct is_primitive<schema::Primitive<T,N>> {
constexpr static bool value = true;
};
} // namespace saw
|
