4493d40a-92aa-4162-9dfc-bfc4ec0996e6
/
polardbxengine
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
polardbxengine/plugin/polarx_rpc/coders/encoders/encoding_primitives_base.h

390 lines
14 KiB
C++
Raw Blame History

/*
* Copyright (c) 2019, 2022, Oracle and/or its affiliates.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License, version 2.0,
* as published by the Free Software Foundation.
*
* This program is also distributed with certain software (including
* but not limited to OpenSSL) that is licensed under separate terms,
* as designated in a particular file or component or in included license
* documentation. The authors of MySQL hereby grant you an additional
* permission to link the program and your derivative works with the
* separately licensed software that they have included with MySQL.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License, version 2.0, for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#include <cassert>
#include <cstdint>
#include <google/protobuf/wire_format_lite.h>
namespace protocol {
namespace primitives {
namespace base {
template <uint64_t length, uint64_t value> struct Varint_length_value {
static void encode(uint8_t *&) {
static_assert(0 == length, "Length must be grater then zero.");
static_assert(length,
"You have specified unsupported version of length, currently "
"supported 1-10.");
}
};
template <uint64_t value> struct Varint_length_value<1, value> {
static void encode(uint8_t *&out) { // NOLINT
*(out++) = static_cast<uint8_t>(value & 0x7F);
}
};
template <uint64_t value> struct Varint_length_value<2, value> {
static void encode(uint8_t *&out) { // NOLINT
*(out++) = static_cast<uint8_t>((value & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>((value >> 7) & 0x7F);
}
};
template <uint64_t value> struct Varint_length_value<3, value> {
static void encode(uint8_t *&out) { // NOLINT
*(out++) = static_cast<uint8_t>((value & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 7) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>((value >> 14) & 0x7F);
}
};
template <uint64_t value> struct Varint_length_value<4, value> {
static void encode(uint8_t *&out) { // NOLINT
*(out++) = static_cast<uint8_t>((value & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 7) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 14) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>((value >> 21) & 0x7F);
}
};
template <uint64_t value> struct Varint_length_value<5, value> {
static void encode(uint8_t *&out) { // NOLINT
*(out++) = static_cast<uint8_t>((value & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 7) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 14) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 21) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>((value >> 28) & 0x7F);
}
};
template <uint64_t value> struct Varint_length_value<6, value> {
static void encode(uint8_t *&out) { // NOLINT
*(out++) = static_cast<uint8_t>((value & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 7) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 14) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 21) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 28) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>((value >> 35) & 0x7F);
}
};
template <uint64_t value> struct Varint_length_value<7, value> {
static void encode(uint8_t *&out) { // NOLINT
*(out++) = static_cast<uint8_t>((value & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 7) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 14) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 21) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 28) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 35) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>((value >> 42) & 0x7F);
}
};
template <uint64_t value> struct Varint_length_value<8, value> {
static void encode(uint8_t *&out) { // NOLINT
*(out++) = static_cast<uint8_t>((value & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 7) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 14) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 21) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 28) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 35) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 42) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>((value >> 49) & 0x7F);
}
};
template <uint64_t value> struct Varint_length_value<9, value> {
static void encode(uint8_t *&out) { // NOLINT
*(out++) = static_cast<uint8_t>((value & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 7) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 14) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 21) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 28) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 35) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 42) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 49) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>((value >> 56) & 0x7F);
}
};
template <uint64_t value> struct Varint_length_value<10, value> {
static void encode(uint8_t *&out) { // NOLINT
*(out++) = static_cast<uint8_t>((value & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 7) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 14) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 21) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 28) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 35) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 42) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 49) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>(((value >> 56) & 0x7F) | 0x80);
*(out++) = static_cast<uint8_t>((value >> 63) & 0x7F);
}
};
template <uint64_t length> struct Varint_length {
static void encode(uint8_t *&, const uint64_t) {
static_assert(0 == length, "Length must be grater then zero.");
static_assert(length,
"You have specified unsupported version of length, currently "
"supported 1-10.");
}
};
template <> struct Varint_length<1> {
static void encode(uint8_t *&out, const uint64_t value) { // NOLINT
*(out++) = static_cast<uint8_t>(value & 0x7F);
}
};
template <> struct Varint_length<2> {
static void encode(uint8_t *&out, const uint64_t value) { // NOLINT
*(out++) = static_cast<uint8_t>(value & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 7) & 0x7F);
}
};
template <> struct Varint_length<3> {
static void encode(uint8_t *&out, const uint64_t value) { // NOLINT
*(out++) = static_cast<uint8_t>(value & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 7) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 14) & 0x7F);
}
};
template <> struct Varint_length<4> {
static void encode(uint8_t *&out, const uint64_t value) { // NOLINT
*(out++) = static_cast<uint8_t>(value & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 7) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 14) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 21) & 0x7F);
}
};
template <> struct Varint_length<5> {
static void encode(uint8_t *&out, const uint64_t value) { // NOLINT
*(out++) = static_cast<uint8_t>(value & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 7) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 14) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 21) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 28) & 0x7F);
}
};
template <> struct Varint_length<6> {
static void encode(uint8_t *&out, const uint64_t value) { // NOLINT
*(out++) = static_cast<uint8_t>(value & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 7) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 14) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 21) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 28) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 35) & 0x7F);
}
};
template <> struct Varint_length<7> {
static void encode(uint8_t *&out, const uint64_t value) { // NOLINT
*(out++) = static_cast<uint8_t>(value & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 7) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 14) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 21) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 28) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 35) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 42) & 0x7F);
}
};
template <> struct Varint_length<8> {
static void encode(uint8_t *&out, const uint64_t value) { // NOLINT
*(out++) = static_cast<uint8_t>(value & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 7) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 14) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 21) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 28) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 35) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 42) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 49) & 0x7F);
}
};
template <> struct Varint_length<9> {
static void encode(uint8_t *&out, const uint64_t value) { // NOLINT
*(out++) = static_cast<uint8_t>(value & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 7) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 14) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 21) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 28) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 35) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 42) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 49) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 56) & 0x7F);
}
};
template <> struct Varint_length<10> {
static void encode(uint8_t *&out, const uint64_t value) { // NOLINT
*(out++) = static_cast<uint8_t>(value & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 7) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 14) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 21) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 28) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 35) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 42) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 49) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 56) & 0x7F) | 0x80;
*(out++) = static_cast<uint8_t>((value >> 63) & 0x7F);
}
};
struct Varint {
template <typename Value_type>
static void encode(uint8_t *&out, Value_type value) { // NOLINT
while (value > 0x7F) {
*(out++) = static_cast<uint8_t>(value & 0x7F) | 0x80;
value >>= 7;
}
*(out++) = static_cast<uint8_t>(value & 0x7F);
}
};
struct Fixint {};
template <uint32_t length> struct Fixint_length {};
template <> struct Fixint_length<1> {
template <uint8_t value> static void encode(uint8_t *&out) { // NOLINT
*(out++) = value;
}
static void encode_value(uint8_t *&out, const uint8_t value) { // NOLINT
*(out++) = value;
}
};
template <> struct Fixint_length<4> {
template <uint32_t value> static void encode(uint8_t *&out) { // NOLINT
#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
*reinterpret_cast<uint32_t *>(out) = __builtin_bswap32(value);
out += 4;
#else
*reinterpret_cast<uint32_t *>(out) = value;
out += 4;
#endif
}
static void encode_value(uint8_t *&out, const uint32_t value) { // NOLINT
#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
*reinterpret_cast<uint32_t *>(out) = __builtin_bswap32(value);
out += 4;
#else
*reinterpret_cast<uint32_t *>(out) = value;
out += 4;
#endif
}
};
template <> struct Fixint_length<8> {
template <uint64_t value> static void encode(uint8_t *&out) { // NOLINT
#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
*reinterpret_cast<uint64_t *>(out) = __builtin_bswap64(value);
out += 8;
#else
*reinterpret_cast<uint64_t *>(out) = value;
out += 8;
#endif
}
static void encode_value(uint8_t *&out, const uint64_t value) { // NOLINT
#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
*reinterpret_cast<uint64_t *>(out) = __builtin_bswap64(value);
out += 8;
#else
*reinterpret_cast<uint64_t *>(out) = value;
out += 8;
#endif
}
};
class Helper {
public:
using WireType = google::protobuf::internal::WireFormatLite::WireType;
static constexpr uint32_t encode_field_tag(const uint32_t field_no,
const WireType wt) {
return static_cast<uint32_t>(
field_no << ::google::protobuf::internal::WireFormatLite::kTagTypeBits |
wt);
}
static constexpr uint64_t encode_zigzag(const int64_t value) {
return static_cast<uint64_t>(value >> 63) ^
(static_cast<uint64_t>(value) << 1);
}
static constexpr uint32_t encode_zigzag(const int32_t value) {
return (value >> 31) ^ (value << 1);
}
constexpr static int get_varint_length(const uint64_t value, uint64_t shift,
uint8_t level) {
return (value < shift) ? level
: get_varint_length(value, shift << 7, level + 1);
}
static int get_varint_length(const uint64_t value) {
if (value < 0x0000000000000080)
return 1;
if (value < 0x0000000000004000)
return 2;
if (value < 0x0000000000200000)
return 3;
if (value < 0x0000000010000000)
return 4;
if (value < 0x0000000800000000)
return 5;
if (value < 0x0000040000000000)
return 6;
if (value < 0x0002000000000000)
return 7;
if (value < 0x0100000000000000)
return 8;
if (value < 0x8000000000000000)
return 9;
return 10;
}
};
} // namespace base
} // namespace primitives
} // namespace protocol
Reference in New Issue View Git Blame Copy Permalink