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
|
#pragma once
#include <forstio/core/error.h>
#include <forstio/codec/data.h>
#include <forstio/codec/stream_value.h>
namespace saw {
namespace encode {
struct Minecraft {};
struct VarIntTransport {};
}
template<typename T>
class data<T, encode::Minecraft> {
private:
ring_buffer buffer_;
public:
data() = default;
data(std::size_t size):
buffer_{size}
{}
buffer& get_buffer(){
return buffer_;
}
};
namespace mc {
namespace impl {
union minecraft_signed_four_conversion {
int32_t s;
uint32_t u;
};
union minecraft_signed_eight_conversion {
int64_t s;
uint64_t u;
};
template<typename Schema, typename FromEnc>
class minecraft_encode {
static_assert(always_false<Schema, FromEnc>, "This schema type is not being handled by the Minecraft encoding.");
};
template<typename FromEnc>
class minecraft_encode<schema::VarInt, FromEnc>{
static error_or<void> encode(const data<schema::VarInt, FromEnc>& from, buffer& to){
uint8_t encode_index = 0;
minecraft_signed_four_conversion value;
value.s = from.get();
/**
* VarInt max length is 5 bytes
*/
std::array<uint8_t, 5> encode_data;
do {
uint8_t step = static_cast<uint8_t>(value.u & 0x7F);
value.u = value.u >> 7;
if(value.u != 0){
step |= 0x80;
}
encode_data[encode_index] = step;
++encode_index;
}while(value.u != 0);
auto err = buffer.push(encode_data[0], encode_index);
if (!err.template is_type<err::no_error>()) {
return err;
}
return no_error();
}
};
template<typename Schema, typename FromEnc>
class minecraft_decode {
static_assert(always_false<Schema, FromEnc>, "This schema type is not being handled by the Minecraft encoding.");
};
template<typename FromEnc>
class minecraft_decode<schema::VarInt, FromEnc>{
static error_or<void> decode(buffer& from, data<schema::VarInt, FromEnc>& to){
uint8_t num_reads = 0;
minecraft_signed_four_conversion value;
value.u = 0;
uint8_t read{};
do {
auto err = from.pop(read);
if( !err.template is_type<err::no_error>() ){
return err;
}
value.u |= ((read & 0x7F) << (7*num_reads));
++num_reads;
if(num_reads > 5){
return make_error<err::>();
}
} while( (read & 0x80) != 0);
to.set(value.s);
return no_error();
}
};
}
}
namespace mc {
}
}
|
