236 lines
7.3 KiB
C++
236 lines
7.3 KiB
C++
/*
|
|
* Copyright 2015 Cloudius Systems
|
|
*/
|
|
|
|
/*
|
|
* This file is part of Scylla.
|
|
*
|
|
* Scylla is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Scylla 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 for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with Scylla. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef DB_SERIALIZER_HH_
|
|
#define DB_SERIALIZER_HH_
|
|
|
|
#include <experimental/optional>
|
|
|
|
#include "utils/data_input.hh"
|
|
#include "utils/data_output.hh"
|
|
#include "bytes_ostream.hh"
|
|
#include "bytes.hh"
|
|
#include "database_fwd.hh"
|
|
#include "db/commitlog/replay_position.hh"
|
|
|
|
namespace db {
|
|
/**
|
|
* Serialization objects for various types and using "internal" format. (Not CQL, origin whatnot).
|
|
* The design rationale is that a "serializer" can be instantiated for an object, and will contain
|
|
* the obj + size, and is usable as a functor.
|
|
*
|
|
* Serialization can also be done "explicitly" through the static method "write"
|
|
* (Not using "serialize", because writing "serializer<apa>::serialize" all the time is tiring and redundant)
|
|
* though care should be takes than data will fit of course.
|
|
*/
|
|
template<typename T>
|
|
class serializer {
|
|
public:
|
|
typedef T type;
|
|
typedef data_output output;
|
|
typedef data_input input;
|
|
typedef serializer<T> _MyType;
|
|
|
|
serializer(const type&);
|
|
|
|
// apply to memory, must be at least size() large.
|
|
const _MyType& operator()(output& out) const {
|
|
write(out, _item);
|
|
return *this;
|
|
}
|
|
|
|
static void write(output&, const type&);
|
|
static void read(type&, input&);
|
|
static type read(input&);
|
|
static void skip(input& in);
|
|
|
|
size_t size() const {
|
|
return _size;
|
|
}
|
|
|
|
void write(bytes_ostream& out) const {
|
|
auto buf = out.write_place_holder(_size);
|
|
data_output data_out((char*)buf, _size);
|
|
write(data_out, _item);
|
|
}
|
|
|
|
void write(data_output& out) const {
|
|
write(out, _item);
|
|
}
|
|
|
|
bytes to_bytes() const {
|
|
bytes b(bytes::initialized_later(), _size);
|
|
data_output out(b);
|
|
write(out);
|
|
return b;
|
|
}
|
|
|
|
static type from_bytes(bytes_view v) {
|
|
data_input in(v);
|
|
return read(in);
|
|
}
|
|
private:
|
|
const type& _item;
|
|
size_t _size;
|
|
};
|
|
|
|
template<typename T>
|
|
class serializer<std::experimental::optional<T>> {
|
|
public:
|
|
typedef std::experimental::optional<T> type;
|
|
typedef data_output output;
|
|
typedef data_input input;
|
|
typedef serializer<T> _MyType;
|
|
|
|
serializer(const type& t)
|
|
: _item(t)
|
|
, _size(output::serialized_size<bool>() + (t ? serializer<T>(*t).size() : 0))
|
|
{}
|
|
|
|
// apply to memory, must be at least size() large.
|
|
const _MyType& operator()(output& out) const {
|
|
write(out, _item);
|
|
return *this;
|
|
}
|
|
|
|
static void write(output& out, const type& v) {
|
|
bool en = v;
|
|
out.write<bool>(en);
|
|
if (en) {
|
|
serializer<T>::write(out, *v);
|
|
}
|
|
}
|
|
static void read(type& dst, input& in) {
|
|
auto en = in.read<bool>();
|
|
if (en) {
|
|
dst = serializer<T>::read(in);
|
|
} else {
|
|
dst = {};
|
|
}
|
|
}
|
|
static type read(input& in) {
|
|
type t;
|
|
read(t, in);
|
|
return t;
|
|
}
|
|
static void skip(input& in) {
|
|
auto en = in.read<bool>();
|
|
if (en) {
|
|
serializer<T>::skip(in);
|
|
}
|
|
}
|
|
|
|
size_t size() const {
|
|
return _size;
|
|
}
|
|
|
|
void write(bytes_ostream& out) const {
|
|
auto buf = out.write_place_holder(_size);
|
|
data_output data_out((char*)buf, _size);
|
|
write(data_out, _item);
|
|
}
|
|
|
|
void write(data_output& out) const {
|
|
write(out, _item);
|
|
}
|
|
|
|
bytes to_bytes() const {
|
|
bytes b(bytes::initialized_later(), _size);
|
|
data_output out(b);
|
|
write(out);
|
|
return b;
|
|
}
|
|
|
|
static type from_bytes(bytes_view v) {
|
|
data_input in(v);
|
|
return read(in);
|
|
}
|
|
private:
|
|
const std::experimental::optional<T> _item;
|
|
size_t _size;
|
|
};
|
|
|
|
|
|
template<> serializer<utils::UUID>::serializer(const utils::UUID &);
|
|
template<> void serializer<utils::UUID>::write(output&, const type&);
|
|
template<> void serializer<utils::UUID>::read(utils::UUID&, input&);
|
|
template<> void serializer<utils::UUID>::skip(input&);
|
|
template<> utils::UUID serializer<utils::UUID>::read(input&);
|
|
|
|
template<> serializer<bytes>::serializer(const bytes &);
|
|
template<> void serializer<bytes>::write(output&, const type&);
|
|
template<> void serializer<bytes>::read(bytes&, input&);
|
|
template<> void serializer<bytes>::skip(input&);
|
|
|
|
template<> serializer<bytes_view>::serializer(const bytes_view&);
|
|
template<> void serializer<bytes_view>::write(output&, const type&);
|
|
template<> void serializer<bytes_view>::read(bytes_view&, input&);
|
|
template<> bytes_view serializer<bytes_view>::read(input&);
|
|
|
|
template<> serializer<sstring>::serializer(const sstring&);
|
|
template<> void serializer<sstring>::write(output&, const type&);
|
|
template<> void serializer<sstring>::read(sstring&, input&);
|
|
template<> void serializer<sstring>::skip(input&);
|
|
|
|
template<> serializer<tombstone>::serializer(const tombstone &);
|
|
template<> void serializer<tombstone>::write(output&, const type&);
|
|
template<> void serializer<tombstone>::read(tombstone&, input&);
|
|
|
|
template<> serializer<atomic_cell_view>::serializer(const atomic_cell_view &);
|
|
template<> void serializer<atomic_cell_view>::write(output&, const type&);
|
|
template<> void serializer<atomic_cell_view>::read(atomic_cell_view&, input&);
|
|
template<> atomic_cell_view serializer<atomic_cell_view>::read(input&);
|
|
|
|
template<> serializer<collection_mutation_view>::serializer(const collection_mutation_view &);
|
|
template<> void serializer<collection_mutation_view>::write(output&, const type&);
|
|
template<> void serializer<collection_mutation_view>::read(collection_mutation_view&, input&);
|
|
|
|
template<> serializer<db::replay_position>::serializer(const db::replay_position&);
|
|
template<> void serializer<db::replay_position>::write(output&, const db::replay_position&);
|
|
template<> void serializer<db::replay_position>::read(db::replay_position&, input&);
|
|
|
|
template<typename T>
|
|
T serializer<T>::read(input& in) {
|
|
type t;
|
|
read(t, in);
|
|
return t;
|
|
}
|
|
|
|
extern template class serializer<tombstone>;
|
|
extern template class serializer<bytes>;
|
|
extern template class serializer<bytes_view>;
|
|
extern template class serializer<sstring>;
|
|
extern template class serializer<utils::UUID>;
|
|
extern template class serializer<db::replay_position>;
|
|
|
|
typedef serializer<tombstone> tombstone_serializer;
|
|
typedef serializer<bytes> bytes_serializer; // Compatible with bytes_view_serializer
|
|
typedef serializer<bytes_view> bytes_view_serializer; // Compatible with bytes_serializer
|
|
typedef serializer<sstring> sstring_serializer;
|
|
typedef serializer<atomic_cell_view> atomic_cell_view_serializer;
|
|
typedef serializer<collection_mutation_view> collection_mutation_view_serializer;
|
|
typedef serializer<utils::UUID> uuid_serializer;
|
|
typedef serializer<db::replay_position> replay_position_serializer;
|
|
|
|
}
|
|
|
|
#endif /* DB_SERIALIZER_HH_ */
|