2017-05-26 04:48:44 +08:00
|
|
|
/*
|
|
|
|
* serialize.h
|
|
|
|
*
|
|
|
|
* This source file is part of the FoundationDB open source project
|
|
|
|
*
|
|
|
|
* Copyright 2013-2018 Apple Inc. and the FoundationDB project authors
|
2018-02-22 02:25:11 +08:00
|
|
|
*
|
2017-05-26 04:48:44 +08:00
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
2018-02-22 02:25:11 +08:00
|
|
|
*
|
2017-05-26 04:48:44 +08:00
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
2018-02-22 02:25:11 +08:00
|
|
|
*
|
2017-05-26 04:48:44 +08:00
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef FLOW_SERIALIZE_H
|
|
|
|
#define FLOW_SERIALIZE_H
|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#include <stdint.h>
|
2019-02-21 07:37:13 +08:00
|
|
|
#include <array>
|
2017-05-26 04:48:44 +08:00
|
|
|
#include <set>
|
2019-06-19 05:49:04 +08:00
|
|
|
#include "flow/ProtocolVersion.h"
|
2018-10-20 01:30:13 +08:00
|
|
|
#include "flow/Error.h"
|
|
|
|
#include "flow/Arena.h"
|
2019-01-26 07:10:20 +08:00
|
|
|
#include "flow/FileIdentifier.h"
|
|
|
|
#include "flow/ObjectSerializer.h"
|
2017-05-26 04:48:44 +08:00
|
|
|
#include <algorithm>
|
|
|
|
|
2017-10-28 07:54:44 +08:00
|
|
|
// Though similar, is_binary_serializable cannot be replaced by std::is_pod, as doing so would prefer
|
|
|
|
// memcpy over a defined serialize() method on a POD struct. As not all of our structs are packed,
|
|
|
|
// this would both inflate message sizes by transmitting padding, and mean that we're transmitting
|
|
|
|
// undefined bytes over the wire.
|
|
|
|
// A more intelligent SFINAE that does "binarySerialize if POD and no serialize() is defined" could
|
|
|
|
// replace the usage of is_binary_serializable.
|
2017-05-26 04:48:44 +08:00
|
|
|
template <class T>
|
|
|
|
struct is_binary_serializable { enum { value = 0 }; };
|
|
|
|
|
|
|
|
#define BINARY_SERIALIZABLE( T ) template<> struct is_binary_serializable<T> { enum { value = 1 }; };
|
|
|
|
|
2017-08-04 07:16:36 +08:00
|
|
|
BINARY_SERIALIZABLE( int8_t );
|
2017-05-26 04:48:44 +08:00
|
|
|
BINARY_SERIALIZABLE( uint8_t );
|
|
|
|
BINARY_SERIALIZABLE( int16_t );
|
|
|
|
BINARY_SERIALIZABLE( uint16_t );
|
|
|
|
BINARY_SERIALIZABLE( int32_t );
|
|
|
|
BINARY_SERIALIZABLE( uint32_t );
|
|
|
|
BINARY_SERIALIZABLE( int64_t );
|
|
|
|
BINARY_SERIALIZABLE( uint64_t );
|
|
|
|
BINARY_SERIALIZABLE( bool );
|
|
|
|
BINARY_SERIALIZABLE( double );
|
2019-06-19 05:49:04 +08:00
|
|
|
BINARY_SERIALIZABLE( ProtocolVersion );
|
|
|
|
|
|
|
|
template<>
|
|
|
|
struct scalar_traits<ProtocolVersion> : std::true_type {
|
|
|
|
constexpr static size_t size = sizeof(uint64_t);
|
|
|
|
|
|
|
|
static void save(uint8_t* out, const ProtocolVersion& v) {
|
|
|
|
*reinterpret_cast<uint64_t*>(out) = v.versionWithFlags();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class Context>
|
|
|
|
static void load(const uint8_t* i, ProtocolVersion& out, Context& context) {
|
|
|
|
const uint64_t* in = reinterpret_cast<const uint64_t*>(i);
|
|
|
|
out = ProtocolVersion(*in);
|
|
|
|
}
|
|
|
|
};
|
2017-05-26 04:48:44 +08:00
|
|
|
|
|
|
|
template <class Archive, class Item>
|
|
|
|
inline typename Archive::WRITER& operator << (Archive& ar, const Item& item ) {
|
|
|
|
save(ar, const_cast<Item&>(item));
|
|
|
|
return ar;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class Archive, class Item>
|
|
|
|
inline typename Archive::READER& operator >> (Archive& ar, Item& item ) {
|
|
|
|
load(ar, item);
|
|
|
|
return ar;
|
|
|
|
}
|
|
|
|
|
2018-12-29 02:49:26 +08:00
|
|
|
template <class Archive, class Item, class... Items>
|
|
|
|
typename Archive::WRITER& serializer(Archive& ar, const Item& item, const Items&... items) {
|
2017-05-26 04:48:44 +08:00
|
|
|
save(ar, item);
|
2020-03-03 06:32:36 +08:00
|
|
|
if constexpr (sizeof...(Items) > 0) {
|
|
|
|
serializer(ar, items...);
|
|
|
|
}
|
2017-05-26 04:48:44 +08:00
|
|
|
return ar;
|
|
|
|
}
|
|
|
|
|
2018-12-29 02:49:26 +08:00
|
|
|
template <class Archive, class Item, class... Items>
|
|
|
|
typename Archive::READER& serializer(Archive& ar, Item& item, Items&... items) {
|
2017-05-26 04:48:44 +08:00
|
|
|
load(ar, item);
|
2020-03-03 06:32:36 +08:00
|
|
|
if constexpr (sizeof...(Items) > 0) {
|
|
|
|
serializer(ar, items...);
|
|
|
|
}
|
2017-05-26 04:48:44 +08:00
|
|
|
return ar;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class Archive, class T, class Enable = void>
|
|
|
|
class Serializer {
|
|
|
|
public:
|
|
|
|
static void serialize( Archive& ar, T& t ) {
|
|
|
|
t.serialize(ar);
|
2019-06-19 08:55:27 +08:00
|
|
|
ASSERT( ar.protocolVersion().isValid() );
|
2017-05-26 04:48:44 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class Ar, class T>
|
|
|
|
inline void save( Ar& ar, const T& value ) {
|
|
|
|
Serializer<Ar,T>::serialize(ar, const_cast<T&>(value));
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class Ar, class T>
|
|
|
|
inline void load( Ar& ar, T& value ) {
|
|
|
|
Serializer<Ar,T>::serialize(ar, value);
|
|
|
|
}
|
|
|
|
|
2019-01-26 07:10:20 +08:00
|
|
|
template <class CharT, class Traits, class Allocator>
|
|
|
|
struct FileIdentifierFor<std::basic_string<CharT, Traits, Allocator>> {
|
|
|
|
constexpr static FileIdentifier value = 15694229;
|
|
|
|
};
|
|
|
|
|
2017-05-26 04:48:44 +08:00
|
|
|
template <class Archive>
|
|
|
|
inline void load( Archive& ar, std::string& value ) {
|
|
|
|
int32_t length;
|
|
|
|
ar >> length;
|
|
|
|
value.resize(length);
|
|
|
|
ar.serializeBytes( &value[0], (int)value.length() );
|
2019-06-19 08:55:27 +08:00
|
|
|
ASSERT( ar.protocolVersion().isValid() );
|
2017-05-26 04:48:44 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class Archive>
|
|
|
|
inline void save( Archive& ar, const std::string& value ) {
|
|
|
|
ar << (int32_t)value.length();
|
|
|
|
ar.serializeBytes( (void*)&value[0], (int)value.length() );
|
2019-06-19 08:55:27 +08:00
|
|
|
ASSERT( ar.protocolVersion().isValid() );
|
2017-05-26 04:48:44 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class Archive, class T>
|
2017-10-28 07:54:44 +08:00
|
|
|
class Serializer< Archive, T, typename std::enable_if< is_binary_serializable<T>::value >::type> {
|
2017-05-26 04:48:44 +08:00
|
|
|
public:
|
|
|
|
static void serialize( Archive& ar, T& t ) {
|
|
|
|
ar.serializeBinaryItem(t);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2019-04-17 00:30:02 +08:00
|
|
|
template <class F, class S, bool = HasFileIdentifier<F>::value&& HasFileIdentifier<S>::value>
|
|
|
|
struct PairFileIdentifier;
|
|
|
|
|
|
|
|
template <class F, class S>
|
|
|
|
struct PairFileIdentifier<F, S, false> {};
|
|
|
|
|
2019-01-26 07:10:20 +08:00
|
|
|
template <class F, class S>
|
2019-04-17 00:30:02 +08:00
|
|
|
struct PairFileIdentifier<F, S, true> {
|
2019-01-26 07:10:20 +08:00
|
|
|
constexpr static FileIdentifier value = FileIdentifierFor<F>::value ^ FileIdentifierFor<S>::value;
|
|
|
|
};
|
|
|
|
|
2019-04-17 00:30:02 +08:00
|
|
|
template <class F, class S>
|
|
|
|
struct FileIdentifierFor<std::pair<F, S>> : PairFileIdentifier<F, S> {};
|
2019-01-26 07:10:20 +08:00
|
|
|
|
2017-05-26 04:48:44 +08:00
|
|
|
template <class Archive, class T1, class T2>
|
|
|
|
class Serializer< Archive, std::pair<T1,T2>, void > {
|
|
|
|
public:
|
|
|
|
static void serialize( Archive& ar, std::pair<T1, T2>& p ) {
|
2018-12-29 02:49:26 +08:00
|
|
|
serializer(ar, p.first, p.second);
|
2017-05-26 04:48:44 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2019-01-26 07:10:20 +08:00
|
|
|
template <class T, class Allocator>
|
2019-04-17 00:30:02 +08:00
|
|
|
struct FileIdentifierFor<std::vector<T, Allocator>> : ComposedIdentifierExternal<T, 0x10> {};
|
2019-01-26 07:10:20 +08:00
|
|
|
|
2017-05-26 04:48:44 +08:00
|
|
|
template <class Archive, class T>
|
|
|
|
inline void save( Archive& ar, const std::vector<T>& value ) {
|
|
|
|
ar << (int)value.size();
|
|
|
|
for(auto it = value.begin(); it != value.end(); ++it)
|
|
|
|
ar << *it;
|
2019-06-19 08:55:27 +08:00
|
|
|
ASSERT( ar.protocolVersion().isValid() );
|
2017-05-26 04:48:44 +08:00
|
|
|
}
|
|
|
|
template <class Archive, class T>
|
|
|
|
inline void load( Archive& ar, std::vector<T>& value ) {
|
|
|
|
int s;
|
|
|
|
ar >> s;
|
|
|
|
value.clear();
|
|
|
|
value.reserve(s);
|
|
|
|
for (int i = 0; i < s; i++) {
|
|
|
|
value.push_back(T());
|
|
|
|
ar >> value[i];
|
|
|
|
}
|
2019-06-19 08:55:27 +08:00
|
|
|
ASSERT( ar.protocolVersion().isValid() );
|
2017-05-26 04:48:44 +08:00
|
|
|
}
|
|
|
|
|
2019-02-21 07:37:13 +08:00
|
|
|
template <class Archive, class T, size_t N>
|
|
|
|
inline void save( Archive& ar, const std::array<T, N>& value ) {
|
|
|
|
for(int ii = 0; ii < N; ++ii)
|
|
|
|
ar << value[ii];
|
2019-06-19 08:55:27 +08:00
|
|
|
ASSERT( ar.protocolVersion().isValid() );
|
2019-02-21 07:37:13 +08:00
|
|
|
}
|
|
|
|
template <class Archive, class T, size_t N>
|
|
|
|
inline void load( Archive& ar, std::array<T, N>& value ) {
|
|
|
|
for (int ii = 0; ii < N; ii++) {
|
|
|
|
ar >> value[ii];
|
|
|
|
}
|
2019-06-19 08:55:27 +08:00
|
|
|
ASSERT( ar.protocolVersion().isValid() );
|
2019-02-21 07:37:13 +08:00
|
|
|
}
|
|
|
|
|
2017-05-26 04:48:44 +08:00
|
|
|
template <class Archive, class T>
|
|
|
|
inline void save( Archive& ar, const std::set<T>& value ) {
|
|
|
|
ar << (int)value.size();
|
|
|
|
for(auto it = value.begin(); it != value.end(); ++it)
|
|
|
|
ar << *it;
|
2019-06-19 08:55:27 +08:00
|
|
|
ASSERT( ar.protocolVersion().isValid() );
|
2017-05-26 04:48:44 +08:00
|
|
|
}
|
|
|
|
template <class Archive, class T>
|
|
|
|
inline void load( Archive& ar, std::set<T>& value ) {
|
|
|
|
int s;
|
|
|
|
ar >> s;
|
|
|
|
value.clear();
|
|
|
|
T currentValue;
|
|
|
|
for (int i = 0; i < s; i++) {
|
|
|
|
ar >> currentValue;
|
|
|
|
value.insert(currentValue);
|
|
|
|
}
|
2019-06-19 08:55:27 +08:00
|
|
|
ASSERT( ar.protocolVersion().isValid() );
|
2017-05-26 04:48:44 +08:00
|
|
|
}
|
|
|
|
|
2019-02-01 03:24:04 +08:00
|
|
|
template <class Archive, class K, class V>
|
|
|
|
inline void save( Archive& ar, const std::map<K, V>& value ) {
|
|
|
|
ar << (int)value.size();
|
|
|
|
for (const auto &it : value) {
|
|
|
|
ar << it.first << it.second;
|
|
|
|
}
|
2019-06-19 08:55:27 +08:00
|
|
|
ASSERT( ar.protocolVersion().isValid() );
|
2019-02-01 03:24:04 +08:00
|
|
|
}
|
|
|
|
template <class Archive, class K, class V>
|
|
|
|
inline void load( Archive& ar, std::map<K, V>& value ) {
|
|
|
|
int s;
|
|
|
|
ar >> s;
|
|
|
|
value.clear();
|
|
|
|
for (int i = 0; i < s; ++i) {
|
|
|
|
std::pair<K, V> p;
|
|
|
|
ar >> p.first >> p.second;
|
|
|
|
value.emplace(p);
|
|
|
|
}
|
2019-06-19 08:55:27 +08:00
|
|
|
ASSERT( ar.protocolVersion().isValid() );
|
2019-02-01 03:24:04 +08:00
|
|
|
}
|
|
|
|
|
2017-05-26 04:48:44 +08:00
|
|
|
#pragma intrinsic (memcpy)
|
|
|
|
|
|
|
|
#if VALGRIND
|
|
|
|
static bool valgrindCheck( const void* data, int bytes, const char* context ) {
|
|
|
|
auto first= VALGRIND_CHECK_MEM_IS_DEFINED( data, bytes );
|
|
|
|
if (first) {
|
|
|
|
int und=0;
|
|
|
|
for(int b=0; b<bytes; b++)
|
|
|
|
if (VALGRIND_CHECK_MEM_IS_DEFINED( (uint8_t*)data+b, 1 ))
|
|
|
|
und++;
|
|
|
|
TraceEvent(SevError, "UndefinedData").detail("In", context).detail("Size", bytes).detail("Undefined", und).detail("FirstAt", (int64_t)first-(int64_t)data);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline bool valgrindCheck( const void* data, int bytes, const char* context ) { return true; }
|
|
|
|
#endif
|
|
|
|
|
|
|
|
struct _IncludeVersion {
|
2019-06-19 05:49:04 +08:00
|
|
|
ProtocolVersion v;
|
|
|
|
explicit _IncludeVersion( ProtocolVersion defaultVersion ) : v(defaultVersion) {
|
|
|
|
ASSERT( defaultVersion.isValid() );
|
2017-05-26 04:48:44 +08:00
|
|
|
}
|
|
|
|
template <class Ar>
|
|
|
|
void write( Ar& ar ) {
|
|
|
|
ar.setProtocolVersion(v);
|
|
|
|
ar << v;
|
|
|
|
}
|
|
|
|
template <class Ar>
|
|
|
|
void read( Ar& ar ) {
|
|
|
|
ar >> v;
|
2019-06-19 05:49:04 +08:00
|
|
|
if (!v.isValid()) {
|
2017-05-26 04:48:44 +08:00
|
|
|
auto err = incompatible_protocol_version();
|
2020-02-22 11:09:16 +08:00
|
|
|
TraceEvent(SevWarnAlways, "InvalidSerializationVersion").error(err).detailf("Version", "%llx", v.versionWithFlags());
|
2017-05-26 04:48:44 +08:00
|
|
|
throw err;
|
|
|
|
}
|
|
|
|
if (v > currentProtocolVersion) {
|
|
|
|
// For now, no forward compatibility whatsoever is supported. In the future, this check may be weakened for
|
|
|
|
// particular data structures (e.g. to support mismatches between client and server versions when the client
|
|
|
|
// must deserialize zookeeper and database structures)
|
|
|
|
auto err = incompatible_protocol_version();
|
2019-06-21 00:29:01 +08:00
|
|
|
TraceEvent(SevError, "FutureProtocolVersion").error(err).detailf("Version", "%llx", v.versionWithFlags());
|
2017-05-26 04:48:44 +08:00
|
|
|
throw err;
|
|
|
|
}
|
|
|
|
ar.setProtocolVersion(v);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
struct _AssumeVersion {
|
2019-06-19 05:49:04 +08:00
|
|
|
ProtocolVersion v;
|
|
|
|
explicit _AssumeVersion( ProtocolVersion version );
|
2017-05-26 04:48:44 +08:00
|
|
|
template <class Ar> void write( Ar& ar ) { ar.setProtocolVersion(v); }
|
|
|
|
template <class Ar> void read( Ar& ar ) { ar.setProtocolVersion(v); }
|
|
|
|
};
|
|
|
|
struct _Unversioned {
|
2019-06-19 05:49:04 +08:00
|
|
|
template <class Ar> void write( Ar& ar ) {}
|
|
|
|
template <class Ar> void read( Ar& ar ) {}
|
2017-05-26 04:48:44 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
// These functions return valid options to the VersionOptions parameter of the constructor of each archive type
|
2019-06-19 05:49:04 +08:00
|
|
|
inline _IncludeVersion IncludeVersion( ProtocolVersion defaultVersion = currentProtocolVersion ) { return _IncludeVersion(defaultVersion); }
|
|
|
|
inline _AssumeVersion AssumeVersion( ProtocolVersion version ) { return _AssumeVersion(version); }
|
2017-05-26 04:48:44 +08:00
|
|
|
inline _Unversioned Unversioned() { return _Unversioned(); }
|
|
|
|
|
2019-03-30 04:21:15 +08:00
|
|
|
//static uint64_t size_limits[] = { 0ULL, 255ULL, 65535ULL, 16777215ULL, 4294967295ULL, 1099511627775ULL, 281474976710655ULL, 72057594037927935ULL, 18446744073709551615ULL };
|
2017-05-26 04:48:44 +08:00
|
|
|
|
|
|
|
class BinaryWriter : NonCopyable {
|
|
|
|
public:
|
|
|
|
static const int isDeserializing = 0;
|
2019-06-30 02:20:33 +08:00
|
|
|
static constexpr bool isSerializing = true;
|
2017-05-26 04:48:44 +08:00
|
|
|
typedef BinaryWriter WRITER;
|
|
|
|
|
|
|
|
void serializeBytes( StringRef bytes ) {
|
|
|
|
serializeBytes(bytes.begin(), bytes.size());
|
|
|
|
}
|
|
|
|
void serializeBytes(const void* data, int bytes) {
|
2019-12-04 05:09:29 +08:00
|
|
|
if (bytes > 0) {
|
|
|
|
valgrindCheck(data, bytes, "serializeBytes");
|
|
|
|
void* p = writeBytes(bytes);
|
|
|
|
memcpy(p, data, bytes);
|
|
|
|
}
|
2017-05-26 04:48:44 +08:00
|
|
|
}
|
|
|
|
template <class T>
|
|
|
|
void serializeBinaryItem( const T& t ) {
|
|
|
|
*(T*)writeBytes(sizeof(T)) = t;
|
|
|
|
}
|
|
|
|
void* getData() { return data; }
|
|
|
|
int getLength() { return size; }
|
2019-03-29 02:52:50 +08:00
|
|
|
Standalone<StringRef> toValue() { return Standalone<StringRef>( StringRef(data,size), arena ); }
|
2017-05-26 04:48:44 +08:00
|
|
|
template <class VersionOptions>
|
|
|
|
explicit BinaryWriter( VersionOptions vo ) : data(NULL), size(0), allocated(0) { vo.write(*this); }
|
2019-03-27 08:27:33 +08:00
|
|
|
BinaryWriter( BinaryWriter&& rhs ) : arena(std::move(rhs.arena)), data(rhs.data), size(rhs.size), allocated(rhs.allocated), m_protocolVersion(rhs.m_protocolVersion) {
|
2017-05-26 04:48:44 +08:00
|
|
|
rhs.size = 0;
|
|
|
|
rhs.allocated = 0;
|
|
|
|
rhs.data = 0;
|
|
|
|
}
|
|
|
|
void operator=( BinaryWriter&& r) {
|
2019-03-27 08:27:33 +08:00
|
|
|
arena = std::move(r.arena);
|
2017-05-26 04:48:44 +08:00
|
|
|
data = r.data;
|
|
|
|
size = r.size;
|
|
|
|
allocated = r.allocated;
|
|
|
|
m_protocolVersion = r.m_protocolVersion;
|
|
|
|
r.size = 0;
|
|
|
|
r.allocated = 0;
|
|
|
|
r.data = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class T, class VersionOptions>
|
|
|
|
static Standalone<StringRef> toValue( T const& t, VersionOptions vo ) {
|
|
|
|
BinaryWriter wr(vo);
|
|
|
|
wr << t;
|
2019-03-29 02:52:50 +08:00
|
|
|
return wr.toValue();
|
2017-05-26 04:48:44 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int bytesNeeded( uint64_t val ) {
|
|
|
|
int n;
|
|
|
|
for( n=1; n<8 && (val>>(n*8)); ++n );
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
void serializeAsTuple( StringRef str ) {
|
|
|
|
size_t last_pos = 0;
|
|
|
|
|
|
|
|
serializeBytes(LiteralStringRef("\x01"));
|
|
|
|
|
|
|
|
for (size_t pos = 0; pos < str.size(); ++pos) {
|
|
|
|
if (str[pos] == '\x00') {
|
|
|
|
serializeBytes(str.substr(last_pos,pos - last_pos));
|
|
|
|
serializeBytes(LiteralStringRef("\x00\xff"));
|
|
|
|
last_pos = pos + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
serializeBytes(str.substr(last_pos,str.size() - last_pos));
|
|
|
|
serializeBytes(LiteralStringRef("\x00"));
|
|
|
|
}
|
|
|
|
|
|
|
|
void serializeAsTuple( bool t ) {
|
|
|
|
if(!t) {
|
|
|
|
void* p = writeBytes(1);
|
|
|
|
((uint8_t*)p)[0] = (uint8_t)20;
|
|
|
|
} else {
|
|
|
|
void* p = writeBytes(2);
|
|
|
|
((uint8_t*)p)[0] = (uint8_t)21;
|
|
|
|
((uint8_t*)p)[1] = (uint8_t)1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void serializeAsTuple( uint64_t t ) {
|
|
|
|
if(t == 0) {
|
|
|
|
void* p = writeBytes(1);
|
|
|
|
((uint8_t*)p)[0] = (uint8_t)20;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//int n = ( std::lower_bound(size_limits, size_limits+9, t) - size_limits );
|
|
|
|
//ASSERT( n <= 8 );
|
|
|
|
int n = bytesNeeded(t);
|
|
|
|
void* p = writeBytes(n+1);
|
|
|
|
((uint8_t*)p)[0] = (uint8_t)(20+n);
|
|
|
|
uint64_t x = bigEndian64(t);
|
|
|
|
memcpy((uint8_t*)p+1, (uint8_t*)&x+(8-n), n);
|
|
|
|
}
|
|
|
|
|
|
|
|
void serializeAsTuple( int64_t t ) {
|
|
|
|
if(t == 0) {
|
|
|
|
void* p = writeBytes(1);
|
|
|
|
((uint8_t*)p)[0] = (uint8_t)20;
|
|
|
|
} else if(t > 0) {
|
|
|
|
//int n = ( std::lower_bound(size_limits, size_limits+9, t) - size_limits );
|
|
|
|
//ASSERT( n <= 9 );
|
|
|
|
int n = bytesNeeded(t);
|
|
|
|
|
|
|
|
void* p = writeBytes(n+1);
|
|
|
|
((uint8_t*)p)[0] = (uint8_t)(20+n);
|
|
|
|
uint64_t x = bigEndian64((uint64_t)t);
|
|
|
|
memcpy((uint8_t*)p+1, (uint8_t*)&x+(8-n), n);
|
|
|
|
} else {
|
|
|
|
//int n = ( std::lower_bound(size_limits, size_limits+9, -t) - size_limits );
|
|
|
|
//ASSERT( n <= 9 );
|
|
|
|
int n = bytesNeeded(-t);
|
|
|
|
|
|
|
|
void* p = writeBytes(n+1);
|
|
|
|
((uint8_t*)p)[0] = (uint8_t)(20-n);
|
|
|
|
uint64_t x = bigEndian64(t-1);
|
|
|
|
memcpy((uint8_t*)p+1, (uint8_t*)&x+(8-n), n);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-19 05:49:04 +08:00
|
|
|
ProtocolVersion protocolVersion() const { return m_protocolVersion; }
|
|
|
|
void setProtocolVersion(ProtocolVersion pv) { m_protocolVersion = pv; }
|
2017-05-26 04:48:44 +08:00
|
|
|
private:
|
2019-03-27 08:27:33 +08:00
|
|
|
Arena arena;
|
2017-05-26 04:48:44 +08:00
|
|
|
uint8_t* data;
|
|
|
|
int size, allocated;
|
2019-06-19 05:49:04 +08:00
|
|
|
ProtocolVersion m_protocolVersion;
|
2017-05-26 04:48:44 +08:00
|
|
|
|
|
|
|
void* writeBytes(int s) {
|
|
|
|
int p = size;
|
|
|
|
size += s;
|
|
|
|
if (size > allocated) {
|
2019-03-28 10:54:58 +08:00
|
|
|
if(size <= 512-sizeof(ArenaBlock)) {
|
|
|
|
allocated = 512-sizeof(ArenaBlock);
|
|
|
|
} else if(size <= 4096-sizeof(ArenaBlock)) {
|
|
|
|
allocated = 4096-sizeof(ArenaBlock);
|
2019-03-27 03:06:39 +08:00
|
|
|
} else {
|
2019-03-27 08:27:33 +08:00
|
|
|
allocated = std::max(allocated*2, size);
|
2019-03-27 03:06:39 +08:00
|
|
|
}
|
2019-03-27 08:27:33 +08:00
|
|
|
Arena newArena;
|
|
|
|
uint8_t* newData = new ( newArena ) uint8_t[ allocated ];
|
2019-12-04 05:09:29 +08:00
|
|
|
if (p > 0) {
|
|
|
|
memcpy(newData, data, p);
|
|
|
|
}
|
2019-03-27 08:27:33 +08:00
|
|
|
arena = newArena;
|
2017-05-26 04:48:44 +08:00
|
|
|
data = newData;
|
|
|
|
}
|
|
|
|
return data+p;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// A known-length memory segment and an unknown-length memory segment which can be written to as a whole.
|
|
|
|
struct SplitBuffer {
|
|
|
|
void write(const void* data, int length);
|
|
|
|
void write(const void* data, int length, int offset);
|
|
|
|
void writeAndShrink(const void* data, int length);
|
|
|
|
uint8_t *begin, *next;
|
|
|
|
int first_length;
|
|
|
|
};
|
|
|
|
|
|
|
|
// A writer that can serialize to a SplitBuffer
|
|
|
|
class OverWriter {
|
|
|
|
public:
|
|
|
|
typedef OverWriter WRITER;
|
|
|
|
|
|
|
|
template <class VersionOptions>
|
|
|
|
explicit OverWriter(SplitBuffer buf, VersionOptions vo) : buf(buf), len(std::numeric_limits<int>::max()) { vo.write(*this); }
|
|
|
|
|
|
|
|
template <class VersionOptions>
|
|
|
|
explicit OverWriter(void *ptr, int len, VersionOptions vo) : len(len) {
|
|
|
|
buf.begin = (uint8_t *)ptr;
|
|
|
|
buf.first_length = len;
|
|
|
|
vo.write(*this);
|
|
|
|
}
|
|
|
|
|
|
|
|
void serializeBytes( StringRef bytes ) {
|
|
|
|
serializeBytes(bytes.begin(), bytes.size());
|
|
|
|
}
|
|
|
|
void serializeBytes(const void* data, int bytes) {
|
|
|
|
valgrindCheck( data, bytes, "serializeBytes" );
|
|
|
|
writeBytes(data, bytes);
|
|
|
|
}
|
|
|
|
template <class T>
|
|
|
|
void serializeBinaryItem( const T& t ) {
|
|
|
|
writeBytes(&t, sizeof(T));
|
|
|
|
}
|
|
|
|
|
2019-06-19 05:49:04 +08:00
|
|
|
ProtocolVersion protocolVersion() const { return m_protocolVersion; }
|
|
|
|
void setProtocolVersion(ProtocolVersion pv) { m_protocolVersion = pv; }
|
2017-05-26 04:48:44 +08:00
|
|
|
|
|
|
|
private:
|
|
|
|
int len;
|
|
|
|
SplitBuffer buf;
|
2019-06-19 05:49:04 +08:00
|
|
|
ProtocolVersion m_protocolVersion;
|
2017-05-26 04:48:44 +08:00
|
|
|
|
|
|
|
void writeBytes(const void *data, int wlen) {
|
|
|
|
ASSERT(wlen <= len);
|
|
|
|
buf.writeAndShrink(data, wlen);
|
|
|
|
len -= wlen;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class ArenaReader {
|
|
|
|
public:
|
|
|
|
static const int isDeserializing = 1;
|
2019-06-30 02:20:33 +08:00
|
|
|
static constexpr bool isSerializing = false;
|
2017-05-26 04:48:44 +08:00
|
|
|
typedef ArenaReader READER;
|
|
|
|
|
|
|
|
const void* readBytes( int bytes ) {
|
|
|
|
const char* b = begin;
|
|
|
|
const char* e = b + bytes;
|
|
|
|
ASSERT( e <= end );
|
|
|
|
begin = e;
|
|
|
|
return b;
|
|
|
|
}
|
|
|
|
|
|
|
|
const void* peekBytes( int bytes ) {
|
|
|
|
ASSERT( begin + bytes <= end );
|
|
|
|
return begin;
|
|
|
|
}
|
|
|
|
|
|
|
|
void serializeBytes(void* data, int bytes) {
|
|
|
|
memcpy(data, readBytes(bytes), bytes);
|
|
|
|
}
|
|
|
|
|
|
|
|
const uint8_t* arenaRead( int bytes ) {
|
|
|
|
return (const uint8_t*)readBytes(bytes);
|
|
|
|
}
|
|
|
|
|
2019-01-26 07:10:20 +08:00
|
|
|
StringRef arenaReadAll() const {
|
|
|
|
return StringRef(reinterpret_cast<const uint8_t*>(begin), end - begin);
|
|
|
|
}
|
|
|
|
|
2017-05-26 04:48:44 +08:00
|
|
|
template <class T>
|
|
|
|
void serializeBinaryItem( T& t ) {
|
|
|
|
t = *(T*)readBytes(sizeof(T));
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class VersionOptions>
|
2018-03-17 02:40:21 +08:00
|
|
|
ArenaReader( Arena const& arena, const StringRef& input, VersionOptions vo ) : m_pool(arena), check(NULL) {
|
2017-05-26 04:48:44 +08:00
|
|
|
begin = (const char*)input.begin();
|
|
|
|
end = begin + input.size();
|
|
|
|
vo.read(*this);
|
|
|
|
}
|
|
|
|
|
|
|
|
Arena& arena() { return m_pool; }
|
|
|
|
|
2019-06-19 05:49:04 +08:00
|
|
|
ProtocolVersion protocolVersion() const { return m_protocolVersion; }
|
|
|
|
void setProtocolVersion(ProtocolVersion pv) { m_protocolVersion = pv; }
|
2017-05-26 04:48:44 +08:00
|
|
|
|
|
|
|
bool empty() const { return begin == end; }
|
|
|
|
|
2018-03-17 02:40:21 +08:00
|
|
|
void checkpoint() {
|
|
|
|
check = begin;
|
|
|
|
}
|
|
|
|
|
|
|
|
void rewind() {
|
|
|
|
ASSERT(check != NULL);
|
|
|
|
begin = check;
|
|
|
|
check = NULL;
|
|
|
|
}
|
|
|
|
|
2017-05-26 04:48:44 +08:00
|
|
|
private:
|
2018-03-17 02:40:21 +08:00
|
|
|
const char *begin, *end, *check;
|
2017-05-26 04:48:44 +08:00
|
|
|
Arena m_pool;
|
2019-06-19 05:49:04 +08:00
|
|
|
ProtocolVersion m_protocolVersion;
|
2017-05-26 04:48:44 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
class BinaryReader {
|
|
|
|
public:
|
|
|
|
static const int isDeserializing = 1;
|
2019-06-30 02:20:33 +08:00
|
|
|
static constexpr bool isSerializing = false;
|
2017-05-26 04:48:44 +08:00
|
|
|
typedef BinaryReader READER;
|
|
|
|
|
2019-04-11 08:41:02 +08:00
|
|
|
const void* readBytes( int bytes );
|
2017-05-26 04:48:44 +08:00
|
|
|
|
2019-02-08 09:02:36 +08:00
|
|
|
const void* peekBytes( int bytes ) {
|
|
|
|
ASSERT( begin + bytes <= end );
|
|
|
|
return begin;
|
|
|
|
}
|
|
|
|
|
2017-05-26 04:48:44 +08:00
|
|
|
void serializeBytes(void* data, int bytes) {
|
|
|
|
memcpy(data, readBytes(bytes), bytes);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class T>
|
|
|
|
void serializeBinaryItem( T& t ) {
|
|
|
|
t = *(T*)readBytes(sizeof(T));
|
|
|
|
}
|
|
|
|
|
|
|
|
const uint8_t* arenaRead( int bytes ) {
|
|
|
|
// Reads and returns the next bytes.
|
|
|
|
// The returned pointer has the lifetime of this.arena()
|
|
|
|
// Could be implemented zero-copy if [begin,end) was in this.arena() already; for now is a copy
|
|
|
|
if (!bytes) return NULL;
|
|
|
|
uint8_t* dat = new (arena()) uint8_t[ bytes ];
|
|
|
|
serializeBytes( dat, bytes );
|
|
|
|
return dat;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class VersionOptions>
|
|
|
|
BinaryReader( const void* data, int length, VersionOptions vo ) {
|
|
|
|
begin = (const char*)data;
|
|
|
|
end = begin + length;
|
2019-02-08 09:02:36 +08:00
|
|
|
check = nullptr;
|
2017-05-26 04:48:44 +08:00
|
|
|
vo.read(*this);
|
|
|
|
}
|
|
|
|
template <class VersionOptions>
|
|
|
|
BinaryReader( const StringRef& s, VersionOptions vo ) { begin = (const char*)s.begin(); end = begin + s.size(); vo.read(*this); }
|
|
|
|
template <class VersionOptions>
|
|
|
|
BinaryReader( const std::string& v, VersionOptions vo ) { begin = v.c_str(); end = begin + v.size(); vo.read(*this); }
|
|
|
|
|
|
|
|
Arena& arena() { return m_pool; }
|
|
|
|
|
|
|
|
template <class T, class VersionOptions>
|
|
|
|
static T fromStringRef( StringRef sr, VersionOptions vo ) {
|
|
|
|
T t;
|
|
|
|
BinaryReader r(sr, vo);
|
|
|
|
r >> t;
|
|
|
|
return t;
|
|
|
|
}
|
|
|
|
|
2019-06-19 05:49:04 +08:00
|
|
|
ProtocolVersion protocolVersion() const { return m_protocolVersion; }
|
|
|
|
void setProtocolVersion(ProtocolVersion pv) { m_protocolVersion = pv; }
|
2017-05-26 04:48:44 +08:00
|
|
|
|
|
|
|
void assertEnd() { ASSERT( begin == end ); }
|
|
|
|
|
|
|
|
bool empty() const { return begin == end; }
|
|
|
|
|
2019-02-08 09:02:36 +08:00
|
|
|
void checkpoint() {
|
|
|
|
check = begin;
|
|
|
|
}
|
|
|
|
|
|
|
|
void rewind() {
|
|
|
|
ASSERT(check != nullptr);
|
|
|
|
begin = check;
|
|
|
|
check = nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-05-26 04:48:44 +08:00
|
|
|
private:
|
2019-02-08 09:02:36 +08:00
|
|
|
const char *begin, *end, *check;
|
2017-05-26 04:48:44 +08:00
|
|
|
Arena m_pool;
|
2019-06-19 05:49:04 +08:00
|
|
|
ProtocolVersion m_protocolVersion;
|
2017-05-26 04:48:44 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
struct SendBuffer {
|
|
|
|
uint8_t const* data;
|
|
|
|
SendBuffer* next;
|
2019-07-02 00:57:50 +08:00
|
|
|
int bytes_written, bytes_sent;
|
2017-05-26 04:48:44 +08:00
|
|
|
};
|
|
|
|
|
2019-07-02 00:57:50 +08:00
|
|
|
struct PacketBuffer : SendBuffer {
|
|
|
|
private:
|
2017-05-26 04:48:44 +08:00
|
|
|
int reference_count;
|
2019-07-02 00:57:50 +08:00
|
|
|
uint32_t size_;
|
|
|
|
static constexpr size_t PACKET_BUFFER_OVERHEAD = 32;
|
2017-05-26 04:48:44 +08:00
|
|
|
|
2019-07-02 00:57:50 +08:00
|
|
|
public:
|
|
|
|
uint8_t* data() { return const_cast<uint8_t*>(static_cast<SendBuffer*>(this)->data); }
|
|
|
|
size_t size() { return size_; }
|
|
|
|
|
|
|
|
private:
|
|
|
|
explicit PacketBuffer(size_t size) : reference_count(1), size_(size) {
|
2017-05-26 04:48:44 +08:00
|
|
|
next = 0;
|
|
|
|
bytes_written = bytes_sent = 0;
|
2019-07-02 00:57:50 +08:00
|
|
|
((SendBuffer*)this)->data = reinterpret_cast<uint8_t*>(this + 1);
|
|
|
|
static_assert(sizeof(PacketBuffer) == PACKET_BUFFER_OVERHEAD);
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
static PacketBuffer* create(size_t size = 0) {
|
|
|
|
size = std::max(size, 4096 - PACKET_BUFFER_OVERHEAD);
|
|
|
|
if (size == 4096 - PACKET_BUFFER_OVERHEAD) {
|
|
|
|
return new (FastAllocator<4096>::allocate()) PacketBuffer{ size };
|
|
|
|
}
|
|
|
|
uint8_t* mem = new uint8_t[size + PACKET_BUFFER_OVERHEAD];
|
|
|
|
return new (mem) PacketBuffer{ size };
|
2017-05-26 04:48:44 +08:00
|
|
|
}
|
|
|
|
PacketBuffer* nextPacketBuffer() { return (PacketBuffer*)next; }
|
|
|
|
void addref() { ++reference_count; }
|
2019-07-02 00:57:50 +08:00
|
|
|
void delref() {
|
|
|
|
if (!--reference_count) {
|
|
|
|
if (size_ == 4096 - PACKET_BUFFER_OVERHEAD) {
|
|
|
|
FastAllocator<4096>::release(this);
|
|
|
|
} else {
|
|
|
|
delete[] this;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
int bytes_unwritten() const { return size_ - bytes_written; }
|
2017-05-26 04:48:44 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
struct PacketWriter {
|
|
|
|
static const int isDeserializing = 0;
|
2019-07-02 02:29:06 +08:00
|
|
|
static constexpr bool isSerializing = true;
|
2017-05-26 04:48:44 +08:00
|
|
|
typedef PacketWriter WRITER;
|
|
|
|
|
|
|
|
PacketBuffer* buffer;
|
|
|
|
struct ReliablePacket *reliable; // NULL if this is unreliable; otherwise the last entry in the ReliablePacket::cont chain
|
|
|
|
int length;
|
2019-06-19 05:49:04 +08:00
|
|
|
ProtocolVersion m_protocolVersion;
|
2017-05-26 04:48:44 +08:00
|
|
|
|
|
|
|
// reliable is NULL if this is an unreliable packet, or points to a ReliablePacket. PacketWriter is responsible
|
|
|
|
// for filling in reliable->buffer, ->cont, ->begin, and ->end, but not ->prev or ->next.
|
|
|
|
template <class VersionOptions>
|
|
|
|
PacketWriter(PacketBuffer* buf, ReliablePacket* reliable, VersionOptions vo) { init(buf, reliable); vo.read(*this); }
|
|
|
|
|
|
|
|
void serializeBytes(const void* data, int bytes) {
|
|
|
|
if (bytes <= buffer->bytes_unwritten()) {
|
2019-07-02 00:57:50 +08:00
|
|
|
memcpy(buffer->data() + buffer->bytes_written, data, bytes);
|
2017-05-26 04:48:44 +08:00
|
|
|
buffer->bytes_written += bytes;
|
|
|
|
} else {
|
|
|
|
serializeBytesAcrossBoundary(data, bytes);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void serializeBytesAcrossBoundary(const void* data, int bytes);
|
|
|
|
void writeAhead( int bytes, struct SplitBuffer* );
|
2019-07-02 09:14:32 +08:00
|
|
|
void nextBuffer(size_t size = 0 /* downstream it will default to at least 4k minus some padding */);
|
2017-05-26 04:48:44 +08:00
|
|
|
PacketBuffer* finish();
|
|
|
|
int size() { return length; }
|
|
|
|
|
|
|
|
void serializeBytes( StringRef bytes ) {
|
|
|
|
serializeBytes(bytes.begin(), bytes.size());
|
|
|
|
}
|
|
|
|
template <class T>
|
|
|
|
void serializeBinaryItem( const T& t ) {
|
|
|
|
if (sizeof(T) <= buffer->bytes_unwritten()) {
|
2019-07-02 00:57:50 +08:00
|
|
|
*(T*)(buffer->data() + buffer->bytes_written) = t;
|
2017-05-26 04:48:44 +08:00
|
|
|
buffer->bytes_written += sizeof(T);
|
|
|
|
} else {
|
|
|
|
serializeBytesAcrossBoundary(&t, sizeof(T));
|
|
|
|
}
|
|
|
|
}
|
2019-06-19 05:49:04 +08:00
|
|
|
ProtocolVersion protocolVersion() const { return m_protocolVersion; }
|
|
|
|
void setProtocolVersion(ProtocolVersion pv) { m_protocolVersion = pv; }
|
2019-07-02 09:14:32 +08:00
|
|
|
|
2017-05-26 04:48:44 +08:00
|
|
|
private:
|
2019-07-02 09:14:32 +08:00
|
|
|
uint8_t* writeBytes(size_t size) {
|
|
|
|
if (size > buffer->bytes_unwritten()) {
|
|
|
|
nextBuffer(size);
|
|
|
|
ASSERT(buffer->size() >= size);
|
|
|
|
}
|
|
|
|
uint8_t* result = buffer->data() + buffer->bytes_written;
|
|
|
|
buffer->bytes_written += size;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class, class>
|
|
|
|
friend class MakeSerializeSource;
|
|
|
|
|
2017-05-26 04:48:44 +08:00
|
|
|
void init( PacketBuffer* buf, ReliablePacket* reliable );
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ISerializeSource {
|
2020-02-13 02:41:52 +08:00
|
|
|
virtual void serializePacketWriter(PacketWriter&) const = 0;
|
2019-04-18 01:49:19 +08:00
|
|
|
virtual void serializeObjectWriter(ObjectWriter&) const = 0;
|
2017-05-26 04:48:44 +08:00
|
|
|
};
|
|
|
|
|
2019-01-29 11:38:13 +08:00
|
|
|
template <class T, class V>
|
2017-05-26 04:48:44 +08:00
|
|
|
struct MakeSerializeSource : ISerializeSource {
|
2019-01-29 11:38:13 +08:00
|
|
|
using value_type = V;
|
2020-02-13 02:41:52 +08:00
|
|
|
virtual void serializePacketWriter(PacketWriter& w) const {
|
|
|
|
ObjectWriter writer([&](size_t size) { return w.writeBytes(size); }, AssumeVersion(w.protocolVersion()));
|
|
|
|
writer.serialize(get()); // Writes directly into buffer supplied by |w|
|
2019-01-26 07:10:20 +08:00
|
|
|
}
|
2019-01-29 11:38:13 +08:00
|
|
|
virtual value_type const& get() const = 0;
|
2017-05-26 04:48:44 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
template <class T>
|
2019-01-29 11:38:13 +08:00
|
|
|
struct SerializeSource : MakeSerializeSource<SerializeSource<T>, T> {
|
|
|
|
using value_type = T;
|
2017-05-26 04:48:44 +08:00
|
|
|
T const& value;
|
|
|
|
SerializeSource(T const& value) : value(value) {}
|
2019-04-18 01:49:19 +08:00
|
|
|
virtual void serializeObjectWriter(ObjectWriter& w) const {
|
2019-01-31 05:53:23 +08:00
|
|
|
w.serialize(value);
|
|
|
|
}
|
2019-01-26 07:10:20 +08:00
|
|
|
virtual T const& get() const { return value; }
|
2017-05-26 04:48:44 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
#endif
|