Realm C++ SDK Versão C++ v2.2.0

tipos.hpp

1
2//
3// Autores 2022 Realm Inc.
4//
5// Licenciado sob a Licença Apache, Versão 2.0 (a "Licença");
6// você não pode usar este arquivo, exceto em conformidade com a Licença.
7// Você pode obter uma cópia da Licença em
8//
9// http://www.apache.org/license/LICENSE-2.0
10//
11// A menos que exigido pela lei aplicável ou acordado por escrito, o software
12// distribuído sob a Licença é distribuído "Como está",
13// sem garantias ou condições de qualquer tipo, Express ou implícitas.
14// Consulte a Licença para obter as permissões específicas de domínio do idioma e
15// limitações da Licença.
16//
18
19#ifndef CPPREALM_TYPES_HPP
20#define CPPREALM_TYpes_HPP
21
22#include <array>
23#include <optional>
24#include <set>
25#include <stdexcept>
26
27#include <cprealm/internal/bridge/realm.hpp>
28#include <cpprealm/internal/bridge/schema.hpp>
29#include <cpprealm/internal/type_info.hpp>
30
31namespace Realm {
32
33 const size_t not_in_collection = -1;
34
35 estrutura, estrutura uuid {
36 explícito uuid(const std::string &);
37 uuid(const std::array<uint8_t, 16>&);
38 uuid() = default;
39 [[nodiscard]] std::string to_string() const;
40 [[nodiscard]] std::string to_base64() const;
41 [[nodiscard]] std::array<uint8_t, 16> to_bytes() const;
42 uuid(const internal::bridge::uuid &);
43 internal::bridge::uuid m_uuid;
44 amigo estrutura, estrutura internal::bridge::uuid;
45 modelo <typename mapped_type>
46 amigo estrutura, estrutura box_base;
47 };
48
49 in-line operador de bool ==(const uuid& lhs, const uuid& rhs) { return lhs.m_uuid == rhs.m_uuid; }
50 in-line operador de bool !=(const uuid& lhs, const uuid& rhs) { return lhs.m_uuid != rhs.m_uuid; }
51 in-line operador de bool >(const uuid& lhs, const uuid& rhs) { return lhs.m_uuid > rhs.m_uuid; }
52 in-line operador de bool >=(const uuid& lhs, const uuid& rhs) { return lhs.m_uuid >= rhs.m_uuid; }
53 in-line operador de bool <(const uuid& lhs, const uuid& rhs) { return lhs.m_uuid < rhs.m_uuid; }
54 in-line operador de bool <=(const uuid& lhs, const uuid& rhs) { return lhs.m_uuid <= rhs.m_uuid; }
55
56 estrutura, estrutura object_id {
57 explícito object_id(const std::string &);
58 object_id() = padrão;
59 [[nodiscard] estática object_id gerar();
60 [[nodiscard]] std::string to_string() const;
61 object_id(const internal::bridge::object_id &);
62 internal::bridge::object_id m_object_id;
63 amigo estrutura, estrutura internal::bridge::object_id;
64 modelo <typename mapped_type>
65 amigo estrutura, estrutura box_base;
66 };
67
68 in-line operador de bool ==(const object_id& lhs, const object_id& rhs) { return lhs.m_object_id == rhs.m_object_id; }
69 in-line operador de bool !=(const object_id& lhs, const object_id& rhs) { return lhs.m_object_id != rhs.m_object_id; }
70 in-line operador de bool <(const object_id& lhs, const object_id& rhs) { return lhs.m_object_id < rhs.m_object_id; }
71 in-line operador de bool >(const object_id& lhs, const object_id& rhs) { return lhs.m_object_id > rhs.m_object_id; }
72 in-line operador de bool <=(const object_id& lhs, const object_id& rhs) { return lhs.m_object_id <= rhs.m_object_id; }
73 in-line operador bool >=(const object_id& lhs, const object_id& rhs) { return lhs.m_object_id >= rhs.m_object_id; }
74
75 estrutura, estrutura decimal128 {
76 explícito decimal128(const std::string &);
77 decimal128(const double &);
78 decimal128() = padrão;
79 [[nodiscard]] std::string to_string() const;
80 [[nodiscard]] bool is_NaN() const;
81 decimal128(const internal::bridge::decimal128 &);
82 internal::bridge::decimal128 m_decimal;
83 amigo estrutura, estrutura internal::bridge::decimal128;
84 modelo <typename mapped_type>
85 amigo estrutura, estrutura box_base;
86
87 operador decimal128 -( decimal const 128& o);
88 operador decimal128 +( decimal const 128& o);
89 operador decimal128 *( decimal const 128& o);
90 operador decimal128 /( decimal const 128& o);
91
92 decimal128& operador-=(const decimal128& o);
93 decimal128& operador+=(const decimal128& o);
94 decimal128& operador*=(const decimal128& o);
95 decimal128& operador/=( decimal const 128& o);
96 };
97
98 in-line operador bool >( decimal const 128& lhs, decimal const 128& rhs) { return lhs.m_decimal > rhs.m_decimal; }
99 in-line operador bool >=( decimal const 128& lhs, decimal const 128& rhs) { return lhs.m_decimal >= rhs.m_decimal; }
100 in-line operador bool <( decimal const 128& lhs, decimal const 128& rhs) { return lhs.m_decimal < rhs.m_decimal; }
101 in-line operador bool <=(const decimal128& lhs, const decimal128& rhs) { return lhs.m_decimal <= rhs.m_decimal; }
102 in-line bool operator ==(const decimal128& lhs, const decimal128& rhs) { return lhs.m_decimal == rhs.m_decimal; }
103 in-line operador de bool !=(const decimal128& lhs, const decimal128& rhs) { return lhs.m_decimal != rhs.m_decimal; }
104}
105
106namespace Realm {
107
108 estático inline int64_t serialize(int64_t v, const std::optional<internal::bridge::realm>& = std::nullopt) {
109 return v;
110 }
111 estático inline int64_t deserialize(int64_t v) {
112 return v;
113 }
114
115 estático inline std:: Realm<int64> serialize(const std::optional64 <internal::bridge::realm>{
116 return v;
117 }
118 estático inline std::opcional <int64_t> deserialize(const std::opcional<int64_t>& v) {
119 return v;
120 }
121
122 estático in-line double serialização (const double& v, const std::opcional<internal::bridge::realm>& = std::nullopt) {
123 return v;
124 }
125 estático in-line desserialização double (const double& v) {
126 return v;
127 }
128
129 estático inline std::optional<double> serialize(const std::optional<double>& v, const std::optional<internal::bridge::realm>& = std::nullopt) {
130 return v;
131 }
132 estático inline std::opcional<double> deserialize(const std::opcional<double>& v) {
133 return v;
134 }
135
136 estático in-line bool serialize(bool v, const std::opcional<internal::bridge::realm>& = std::nulopt) {
137 return v;
138 }
139 estático in-line bool desserialize(bool v) {
140 return v;
141 }
142
143 estático inline std::opcional<bool> serialize(std::opcional<bool> v, const std::opcional<internal::bridge::realm>& = std::nullopt) {
144 return v;
145 }
146 estático inline std::opcional<bool> deserialize(std::opcional<bool> v) {
147 return v;
148 }
149
150 modelo<typename T>
151 estático in-line typename std::enable_if_t<std::is_enum_v<T>, int64_t> serialize(const T& v, const std::optional<internal::bridge::realm>& = std::nullopt) {
152 Método estático_cast <int64_t>(v);
153 }
154 template<typename T, std::enable_if_t<std::is_enum_v<T>>>
155 estático inline T desserialize(int64_t v) {
156 Método estático_cast<T>(v);
157 }
158
159 modelo<typename T>
160 estático inline std::enable_if_t<std::is_enum_v<typename T::value_type>, std::optional<int64_t>> serialize(const T& v, const std::optional<internal::bridge::realm>& = std::nullopt) {
161 se (v) {
162 Método estático_cast <int64_t>(*v);
163 } mais {
164 return std::nullopt;
165 }
166 }
167 modelo<typename T, std::enable_if_t<std::is_enum_v<typename T::value_type>>>
168 estático inline std::opcional <int64_t> deserialize(std::opcional <int64_t> v) {
169 se (v) {
170 Método estático_cast<T>(*v);
171 } mais {
172 return std::nullopt;
173 }
174 }
175
176 estático inline std::string serialize(const std::string& v, const std::optional<internal::bridge::realm>& = std::nullopt) {
177 return v;
178 }
179 estático inline std::string deserialize(const std::string& v) {
180 return v;
181 }
182
183 estático inline std::optional<std::string> serialize(const std::optional<std::string>& v, const std::optional<internal::bridge::realm>& = std::nullopt) {
184 return v;
185 }
186 estático inline std::opcional<std::string> deserialize(const std::opcional<std::string>& v) {
187 return v;
188 }
189
190 estático inline internal::bridge::uuid serialize(const uuid& v, const std::optional<internal::bridge::realm>& = std::nullopt) {
191 return v;
192 }
193 estático inline uuid deserialize(const internal::bridge::uuid& v) {
194 retornar v.operator :: Realm::uuid();
195 }
196
197 estático inline std::optional<internal::bridge::uuid> serialize(const std::opcional<uuid>& v, const std::opcional<internal::bridge::realm>& = std::nullopt) {
198 return v;
199 }
200 estático inline std::opcional<uuid> deserialize(const std::opcional<internal::bridge::uuid>& v) {
201 se (v) {
202 return v->operator ::Realm::uuid();
203 } mais {
204 return std::nullopt;
205 }
206 }
207
208 estático inline internal::bridge::binary serialize(const std::vector<uint8_t>& v, const std::optional<internal::bridge::realm>& = std::nullopt) {
209 return v;
210 }
211 estático inline std::vector<uint8_t> deserialize(const internal::bridge::binary& v) {
212 return v.operator std::vector<uint8_t>();
213 }
214
215 estático inline std::optional<internal::bridge::binary> serialize(const std::opcional<std::vector<uint8_t>>& v, const std::opcional<internal::bridge::realm>& = std::nullopt) {
216 return v;
217 }
218 estático inline std::optional <std::vector <uint8_t>> deserialize(const std::optional<internal::bridge::binary>& v) {
219 se (v) {
220 return v->operator std::vector<uint8_t>();
221 } mais {
222 return std::nullopt;
223 }
224 }
225
226 estático inline internal::bridge::timestamp serialize(const std::chrono::time_point<std::chrono::system_clock>& v, const std::optional<internal::bridge::realm>& = std::nullopt ) {
227 return v;
228 }
229 estático inline std::chrono::time_point<std::chrono::system_clock> deserialize(const internal::bridge::timestamp& v) {
230 return v.operator<std::chrono::system_clock> std::chrono::time_point();
231 }
232
233 estático inline std::optional<internal::bridge::timestamp> serialize(const std::optional<std::chrono::time_point<std::chrono::system_clock>>& v, const std::optional<internal::bridge::realm>& = std::nullopt) {
234 return v;
235 }
236 estático inline std::opcional <std::chrono::time_point<std::chrono::system_clock>> deserialize(const std::opcional<internal::bridge::timestamp>& v) {
237 se (v) {
238 retornar v->operator std::chrono::time_point<std::chrono::system_clock>();
239 } mais {
240 return std::nullopt;
241 }
242 }
243
244 estático inline internal::bridge::object_id serialize(const Realm::object_id& v, const std::optional<internal::bridge::realm>& = std::nullopt) {
245 return v;
246 }
247 estático in-line realm::object_id deserialize(const internal::bridge::object_id& v) {
248 return v.operator :: Realm::object_id();
249 }
250
251 estático inline std::opcional<internal::bridge::object_id> serialize(const <realm::object_id>std::opcional"Realm::object_id>& v, const <internal::bridge::realm>std::opcional & = std::nullopt ) {
252 return v;
253 }
254 estático inline std::optional<realm::object_id> deserialize(const std::optional<internal::bridge::object_id>& v) {
255 se (v) {
256 return v->operator ::realm::object_id();
257 } mais {
258 return std::nullopt;
259 }
260 }
261
262 estático inline internal::bridge::decimal128 serialize(const realm::decimal128& v, const std::optional<internal::bridge::realm>& = std::nullopt) {
263 return v;
264 }
265 estático in-line realm::decimal128 deserialize(const internal::bridge::decimal128& v) {
266 return v.operator ::realm::decimal128();
267 }
268
269 estático inline std::opcional <interno::ponte::decimal128> serialize(const std::opcional < Realm::decimal128>& v, const std::opcional<internal::bridge::realm>& = std::nullopt) {
270 return v;
271 }
272 estático inline std::opcional < Realm::decimal128> deserialize(const std::opcional <internal::bridge::decimal128>& v) {
273 se (v) {
274 retornar v->operador :: Realm::decimal128();
275 } mais {
276 return std::nullopt;
277 }
278 }
279
280 modelo <typename T>
281 estático in-line typename std::enable_if_t<internal::type_info::MixedPersistableConcept<T>::value, internal::bridge::mixed> serialize(const T& v, const std::optional<internal::bridge::realm>& = std::nullopt) {
282 return std::visit([&](auto&& arg) {
283 usando StoredType = std::decay_t<decltype(arg)>;
284 usando M = typename internal::type_info::type_info<StoredType>::internal_type;
285 return internal::bridge::mixed(M(arg));
286 }, v);
287 }
288
289 modelo <typename T>
290 estático in-line typename std::enable_if_t<!internal::type_info::MixedPersistableConcept<T>::value, T>
291 deserialize(const internal::bridge::mixed& value) {
292 se constexpr (internal::type_info::is_optional<T>::value) {
293 return std::nullopt;
294 } else if constexpr (std::is_same_v<T, int64_t>) {
295 valor de retorno.operator int64_t();
296 } mais se constexpr (std::is_same_v<T, bool>) {
297 valor de retorno.operador bool();
298 } else if constexpr (std::is_same_v<T, std::string>) {
299 Método estático_cast <std::string>(valor);
300 } else if constexpr (std::is_same_v<T, std::vector<uint8_t>>) {
301 Método estático_cast<std::vector<uint8_t>>(estático_cast<interno::bridge::binário>(valor));
302 } else if constexpr (std::is_same_v<T, std::chrono::time_point<std::chrono::system_clock>>) {
303 Método estático_cast<interno::bridge::timestamp>(valor);
304 } mais se constexpr (std::disjunction_v<std::is_same<T, double>, std::is_same<T, float>>) {
305 Método estático_cast <double>(valor);
306 } else if constexpr (std::is_same_v<T, realm::uuid>) {
307 valor de retorno.operator internal::bridge::uuid().operator :: Realm::uuid();
308 } else if constexpr (std::is_same_v<T, realm::object_id>) {
309 valor de retorno.operator internal::bridge::object_id().operator :: Realm::object_id();
310 } mais se constexpr (std::is_same_v<T, realm::decimal128>) {
311 valor de retorno.operator internal::bridge::decimal128() .operator :: Realm::decimal128();
312 } else if constexpr (std::is_enum_v<T>) {
313 Método estático_cast<T>(valor.operador int64_t());
314 } mais {
315 abort();
316 }
317 }
318
319 modelo <typename T>
320 estático in-line typename std::enable_if_t<internal::type_info::MixedPersistableConcept<T>::value, T>
321 deserialize(const internal::bridge::mixed& value) {
322 if (value.is_null()) {
323 return std::monostate();
324 }
325
326 switch (value.type()) {
327 caso interno::bridge::data_type::Int:
328 valor de retorno.operator int64_t();
329 caso internal::bridge::data_type::Bool:
330 valor de retorno.operador bool();
331 caso interno::bridge::data_type::String:
332 Método estático_cast <std::string>(valor);
333 caso interno::bridge::data_type::Binary:
334 Método estático_cast<std::vector<uint8_t>>(estático_cast<interno::bridge::binário>(valor));
335 caso interno::bridge::data_type::Timestamp:
336 Método estático_cast<interno::bridge::timestamp>(valor);
337 caso interno::bridge::data_type::Float:
338 caso interno::bridge::data_type::Double:
339 Método estático_cast <double>(valor);
340 caso interno::bridge::data_type::UUID:
341 valor de retorno.operator internal::bridge::uuid().operator :: Realm::uuid();
342 caso interno::bridge::data_type::ObjectId:
343 valor de retorno.operator internal::bridge::object_id().operator :: Realm::object_id();
344 caso internal::bridge::data_type::Decimal:
345 valor de retorno.operator internal::bridge::decimal128().operator :: Realm::decimal128();
346 caso interno::bridge::data_type::TypedLink:
347 lance std::runtime_error("Objetos armazenados em propriedades mistas devem ser acessados via `get_object_value()'");
348 Padrão:
349 lance std::runtime_error("Tipo de dados desconhecido ao desserializar propriedade mista.");
350 }
351 }
352
353} // namespace realm
354
355
356#endif//CPPrealm_TYpes_HPP
Realm::box_base
Definição: managed_Dictionary.hpp:31
realm::decimal128
Definição: tipos.hpp:75
realm::internal::bridge::decimal128
Definição: decimal128.hpp:30
Realm::internal::bridge::objeto
Definição: object_id.hpp:31
Realm::internal::bridge::uuid
Definição: uuid.hpp:32
Objeto de Realm
Definição: tipos.hpp:56
Realm::uuid
Definição: tipos.hpp:35
Generated by doxygen 1.9.4