python-cpp/src/executable/bytecode/serialization/serialize.hpp at 5a76241644612f45c1ee8f21c42857f447ac972a · gf712/python-cpp · GitHub

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
#pragma once

#include "runtime/PyTuple.hpp"
#include "utilities.hpp"

#include <cstdint>
#include <string>
#include <vector>

namespace py {

template<typename T> struct is_vector : std::false_type
{
	static constexpr bool value = false;
};

template<typename T> struct is_vector<std::vector<T>> : std::true_type
{
	using ElementType = T;
	static constexpr bool value = true;
};

template<typename T> inline constexpr bool is_vector_v = is_vector<T>::value;

template<typename T>
concept Vector = is_vector_v<T>;

enum class ValueType {
	INT64 = 0,
	F64 = 1,
	STRING = 2,
	BYTES = 3,
	ELLIPSIS = 4,
	NONE = 5,
	BOOL = 6,
	OBJECT = 7,
	TUPLE = 8,
};

template<typename T> inline void serialize(const T &value, std::vector<uint8_t> &result)
{
	auto *data = bit_cast<const uint8_t *>(&value);
	result.insert(result.end(), data, data + sizeof(T));
}

template<> inline void serialize<Value>(const Value &value, std::vector<uint8_t> &result);

template<> inline void serialize<bool>(const bool &value, std::vector<uint8_t> &result)
{
	result.push_back(value ? 1 : 0);
}

template<> inline void serialize<std::byte>(const std::byte &value, std::vector<uint8_t> &result)
{
	result.push_back(::bit_cast<uint8_t>(value));
}

template<>
inline void serialize<std::string>(const std::string &value, std::vector<uint8_t> &result)
{
	serialize(value.size(), result);
	for (const auto &el : value) { serialize(el, result); }
}

template<Vector VectorType>
inline void serialize(const VectorType &value, std::vector<uint8_t> &result)
{
	serialize(value.size(), result);
	for (const auto &el : value) { serialize(el, result); }
}

template<> inline void serialize<Tuple>(const Tuple &value, std::vector<uint8_t> &result)
{
	serialize(value.elements.size(), result);
	for (const auto &el : value.elements) { serialize(el, result); }
}

template<> inline void serialize<PyTuple *>(PyTuple *const &value, std::vector<uint8_t> &result)
{
	serialize(value->size(), result);
	for (const auto &el : value->elements()) { serialize(el, result); }
}

template<> inline void serialize<Value>(const Value &value, std::vector<uint8_t> &result)
{
	std::visit(
		overloaded{
			[&](const Number &val) {
				std::visit(overloaded{
							   [&](const BigIntType &v) {
								   ASSERT(v.fits_ulong_p());
								   const auto int_value = v.get_ui();
								   serialize(static_cast<uint8_t>(ValueType::INT64), result);
								   serialize(int_value, result);
							   },
							   [&](const double &v) {
								   serialize(static_cast<uint8_t>(ValueType::F64), result);
								   serialize(v, result);
							   },
						   },
					val.value);
			},
			[&](const String &val) {
				serialize(static_cast<uint8_t>(ValueType::STRING), result);
				serialize(val.s, result);
			},
			[&](const Bytes &bytes) {
				serialize(static_cast<uint8_t>(ValueType::BYTES), result);
				serialize(bytes.b, result);
			},
			[&](const Ellipsis &) { serialize(static_cast<uint8_t>(ValueType::ELLIPSIS), result); },
			[&](const NameConstant &val) {
				std::visit(overloaded{ [&](const bool &v) {
										  serialize(static_cast<uint8_t>(ValueType::BOOL), result);
										  serialize(v, result);
									  },
							   [&](const NoneType &) {
								   serialize(static_cast<uint8_t>(ValueType::NONE), result);
							   } },
					val.value);
			},
			[&](const Tuple &tuple) {
				serialize(static_cast<uint8_t>(ValueType::TUPLE), result);
				serialize(tuple, result);
			},
			[&](PyObject *const &) { TODO(); },
		},
		value);
}
}// namespace py