如何减少当前序列化所需的样板文件
How to reduce boilerplate currently necessary for serialization
我们的软件正在抽象出硬件，我们有 类 表示该硬件的状态，并且有大量数据成员用于该外部硬件的所有属性。我们需要定期更新有关该状态的其他组件，为此我们通过 MQTT 和其他消息传递协议发送 protobuf 编码的消息。有不同的消息描述硬件的不同方面，因此我们需要发送那些 类 的数据的不同视图。这是一个草图：
struct some_data {
Foo foo;
Bar bar;
Baz baz;
Fbr fbr;
// ...
};
假设我们需要发送一封包含 foo 和 bar 的消息，以及一封包含 bar 和 baz 的消息。我们目前的做法是大量样板文件：
struct foobar {
Foo foo;
Bar bar;
foobar(const Foo& foo, const Bar& bar) : foo(foo), bar(bar) {}
bool operator==(const foobar& rhs) const {return foo == rhs.foo && bar == rhs.bar;}
bool operator!=(const foobar& rhs) const {return !operator==(*this,rhs);}
};
struct barbaz {
Bar bar;
Baz baz;
foobar(const Bar& bar, const Baz& baz) : bar(bar), baz(baz) {}
bool operator==(const barbaz& rhs) const {return bar == rhs.bar && baz == rhs.baz;}
bool operator!=(const barbaz& rhs) const {return !operator==(*this,rhs);}
};
template<> struct serialization_traits<foobar> {
static SerializedFooBar encode(const foobar& fb) {
SerializedFooBar sfb;
sfb.set_foo(fb.foo);
sfb.set_bar(fb.bar);
return sfb;
}
};
template<> struct serialization_traits<barbaz> {
static SerializedBarBaz encode(const barbaz& bb) {
SerializedBarBaz sbb;
sfb.set_bar(bb.bar);
sfb.set_baz(bb.baz);
return sbb;
}
};
然后可以发送：
void send(const some_data& data) {
send_msg( serialization_traits<foobar>::encode(foobar(data.foo, data.bar)) );
send_msg( serialization_traits<barbaz>::encode(barbaz(data.foo, data.bar)) );
}
考虑到要发送的数据集通常比两个项目大得多，我们也需要解码该数据，并且我们有大量这些消息，因此涉及的样板文件比本文中的要多得多这个草图。所以我一直在寻找一种方法来减少这种情况。这是第一个想法：
typedef std::tuple< Foo /* 0 foo */
, Bar /* 1 bar */
> foobar;
typedef std::tuple< Bar /* 0 bar */
, Baz /* 1 baz */
> barbaz;
// yay, we get comparison for free!
template<>
struct serialization_traits<foobar> {
static SerializedFooBar encode(const foobar& fb) {
SerializedFooBar sfb;
sfb.set_foo(std::get<0>(fb));
sfb.set_bar(std::get<1>(fb));
return sfb;
}
};
template<>
struct serialization_traits<barbaz> {
static SerializedBarBaz encode(const barbaz& bb) {
SerializedBarBaz sbb;
sfb.set_bar(std::get<0>(bb));
sfb.set_baz(std::get<1>(bb));
return sbb;
}
};
void send(const some_data& data) {
send_msg( serialization_traits<foobar>::encode(std::tie(data.foo, data.bar)) );
send_msg( serialization_traits<barbaz>::encode(std::tie(data.bar, data.baz)) );
}
我得到了这个工作，它大大减少了样板文件。 （不是在这个小例子中，但如果你想象有十几个数据点被编码和解码，大量重复的数据成员列表消失会产生很大的不同）。但是，这有两个缺点：
这依赖于 Foo、Bar 和 Baz 是不同的类型。如果它们都是int，我们需要在元组中添加一个虚拟标签类型。
这是可以做到的，但它确实使整个想法的吸引力大打折扣。
旧代码中的变量名在新代码中变成了注释和数字。这非常糟糕，并且考虑到编码和解码中很可能存在混淆两个成员的错误，它不能在简单的单元测试中被捕获，但需要通过其他技术创建的测试组件（所以集成测试）来捕获此类错误。
我不知道如何解决这个问题。
有没有人知道如何为我们减少样板文件？
注：
- 目前，我们还停留在 C++03 上。是的，你没有看错。对我们来说，它是
std::tr1::tuple。没有拉姆达。也没有auto。
- 我们有大量使用这些序列化特征的代码。我们不能抛开整个计划，做一些完全不同的事情。我正在寻找一种解决方案来简化适合现有框架的未来代码。任何需要我们重写整个东西的想法很可能会被驳回。
在我看来，最好的 all-around 解决方案是使用脚本语言的外部 C++ 代码生成器。它具有以下优点：
灵活性：它允许您随时更改生成的代码。这对几个 sub-reasons:
来说非常好
- 随时修复所有受支持的旧版本中的错误。
- 如果您将来迁移到 C++11 或更高版本，请使用新的 C++ 功能。
- 为不同的语言生成代码。这非常非常有用（特别是如果您的组织很大 and/or 您有很多用户）。例如，您可以输出一个小型脚本库（例如 Python 模块），它可以用作与硬件交互的 CLI 工具。根据我的经验，硬件工程师非常喜欢它。
- 生成 GUI 代码（或 GUI 描述，例如 XML/JSON；甚至是 Web 界面）——对使用最终硬件和测试人员的人很有用。
- 生成其他类型的数据。例如，图表、统计数据等。甚至是 protobuf 描述本身。
维护：会比C++更容易维护。即使它是用不同的语言编写的，学习该语言通常比让新的 C++ 开发人员深入研究 C++ 模板元编程（特别是在 C++03 中）更容易。
性能：它可以很容易地减少C++端的编译时间（因为你可以输出非常简单的C++——甚至是纯C）。当然，生成器可能会抵消这个优势。在您的情况下，这可能不适用，因为看起来您无法更改客户端代码。
我已经在几次 projects/systems 中使用了这种方法，结果非常好。特别是使用硬件的不同替代方案（C++ lib、Python lib、CLI、GUI...）可以 非常 赞赏.
旁注：如果生成的一部分需要解析 已经存在的 C++ 代码（例如 headers 具有要序列化的数据类型，就像在 OP 的情况下 Serialized 类型);那么一个非常好的解决方案是使用 LLVM/clang's tooling 来做到这一点。
在我从事的一个特定项目中，我们必须自动序列化数十种 C++ 类型（用户随时可能更改这些类型）。我们设法通过使用 clang Python 绑定自动生成代码并将其集成到构建过程中。虽然 Python 绑定没有公开所有 AST 细节（至少在当时是这样），但它们足以为我们所有的类型（包括模板化 类、容器等）生成所需的序列化代码.).
您想要的是类元组但不是真正的元组。假设所有 tuple_like classes 实现 tie() 基本上只是绑定他们的成员，这是我的假设代码：
template<typename T> struct tuple_like {
bool operator==(const T& rhs) const {
return this->tie() == rhs.tie();
}
bool operator!=(const T& rhs) const {
return !operator==(*this,rhs);
}
};
template<typename T, typename Serialised> struct serialised_tuple_like : tuple_like<T> {
};
template<typename T, typename Serialised>
struct serialization_traits<serialised_tuple_like<T, Serialised>> {
static Serialised encode(const T& bb) {
Serialised s;
s.tie() = bb.tie();
return s;
}
};
只要双方实现适当的tie()，就可以了。如果源或目标 class 不直接在您的控制中，建议定义一个继承的 class 来实现 tie() 并使用它。要合并多个 classes，请定义一个根据其成员实现 tie() 的助手 class。
如果您的样板文件真的只是一堆带有普通比较运算符的普通旧数据结构，您可能可以使用一些宏。
#define POD2(NAME, T0, N0, T1, N1) \
struct NAME { \
T0 N0; \
T1 N1; \
NAME(const T0& N0, const T1& N1) \
: N0(N0), N1(N1) {} \
bool operator==(const NAME& rhs) const { return N0 == rhs.N0 && N1 == rhs.N1; }
\
bool operator!=(const NAME& rhs) const { return !operator==(rhs); } \
};
用法如下：
POD2(BarBaz, Bar, bar, Baz, baz)
template <>
struct serialization_traits<BarBaz> {
static SerializedBarBaz encode(const BarBaz& bb) {
SerializedBarBaz sbb;
sbb.set_bar(bb.bar);
sbb.set_baz(bb.baz);
return sbb;
}
};
您将需要 N 个宏，其中 N 是您拥有的参数计数的排列数，但这将是一次性的前期成本。
或者，您可以像您建议的那样利用元组为您完成大量繁重的工作。在这里，我创建了一个 "NamedTuple" 模板来命名元组的 getter。
#define NAMED_TUPLE2_T(N0, N1) NamedTuple##N0##N1
#define NAMED_TUPLE2(N0, N1) \
template <typename T0, typename T1> \
struct NAMED_TUPLE2_T(N0, N1) { \
typedef std::tuple<T0, T1> TupleType; \
const typename std::tuple_element<0, TupleType>::type& N0() const { return std::get<0>(tuple_); } \
const typename std::tuple_element<1, TupleType>::type& N1() const { return std::get<1>(tuple_); } \
NAMED_TUPLE2_T(N0, N1)(const std::tuple<T0, T1>& tuple) : tuple_(tuple) {} \
bool operator==(const NAMED_TUPLE2_T(N0, N1)& rhs) const { return tuple_ == rhs.tuple_; } \
bool operator!=(const NAMED_TUPLE2_T(N0, N1)& rhs) const { return !operator==(rhs); } \
private: \
TupleType tuple_; \
}; \
typedef NAMED_TUPLE2_T(N0, N1)
用法：
NAMED_TUPLE2(foo, bar)<int, int> FooBar;
template <>
struct serialization_traits<FooBar> {
static SerializedFooBar encode(const FooBar& fb) {
SerializedFooBar sfb;
sfb.set_foo(fb.foo());
sfb.set_bar(fb.bar());
return sfb;
}
};
我将以您提出的解决方案为基础，但改用 boost::fusion::tuples（假设允许）。假设您的数据类型是
struct Foo{};
struct Bar{};
struct Baz{};
struct Fbr{};
你的数据是
struct some_data {
Foo foo;
Bar bar;
Baz baz;
Fbr fbr;
};
从评论中，我了解到您无法控制 SerialisedXYZ classes，但它们确实有特定的界面。我会假设这样的事情已经足够接近了（？）：
struct SerializedFooBar {
void set_foo(const Foo&){
std::cout << "set_foo in SerializedFooBar" << std::endl;
}
void set_bar(const Bar&){
std::cout << "set_bar in SerializedFooBar" << std::endl;
}
};
// another protobuf-generated class
struct SerializedBarBaz {
void set_bar(const Bar&){
std::cout << "set_bar in SerializedBarBaz" << std::endl;
}
void set_baz(const Baz&){
std::cout << "set_baz in SerializedBarBaz" << std::endl;
}
};
我们现在可以减少样板文件并将其限制为每个数据类型排列一个 typedef 和 SerializedXYZ class 的每个 set_XXX 成员一个简单的重载，如下所示：
typedef boost::fusion::tuple<Foo, Bar> foobar;
typedef boost::fusion::tuple<Bar, Baz> barbaz;
//...
template <class S>
void serialized_set(S& s, const Foo& v) {
s.set_foo(v);
}
template <class S>
void serialized_set(S& s, const Bar& v) {
s.set_bar(v);
}
template <class S>
void serialized_set(S& s, const Baz& v) {
s.set_baz(v);
}
template <class S, class V>
void serialized_set(S& s, const Fbr& v) {
s.set_fbr(v);
}
//...
现在的好处是您不再需要专门化您的 serialization_traits。下面使用 boost::fusion::fold 函数，我认为它可以在您的项目中使用：
template <class SerializedX>
class serialization_traits {
struct set_functor {
template <class V>
SerializedX& operator()(SerializedX& s, const V& v) const {
serialized_set(s, v);
return s;
}
};
public:
template <class Tuple>
static SerializedX encode(const Tuple& t) {
SerializedX s;
boost::fusion::fold(t, s, set_functor());
return s;
}
};
这里有一些它是如何工作的例子。请注意，如果有人试图绑定 some_data 中不符合 SerializedXYZ 接口的数据成员，编译器将通知您：
void send_msg(const SerializedFooBar&){
std::cout << "Sent SerializedFooBar" << std::endl;
}
void send_msg(const SerializedBarBaz&){
std::cout << "Sent SerializedBarBaz" << std::endl;
}
void send(const some_data& data) {
send_msg( serialization_traits<SerializedFooBar>::encode(boost::fusion::tie(data.foo, data.bar)) );
send_msg( serialization_traits<SerializedBarBaz>::encode(boost::fusion::tie(data.bar, data.baz)) );
// send_msg( serialization_traits<SerializedFooBar>::encode(boost::fusion::tie(data.foo, data.baz)) ); // compiler error; SerializedFooBar has no set_baz member
}
int main() {
some_data my_data;
send(my_data);
}
代码here
编辑：
不幸的是，这个解决方案没有解决 OP 的问题 #1。为了解决这个问题，我们可以定义一系列标签，一个用于您的每个数据成员，并遵循类似的方法。以下是标签以及修改后的 serialized_set 函数：
struct foo_tag{};
struct bar1_tag{};
struct bar2_tag{};
struct baz_tag{};
struct fbr_tag{};
template <class S>
void serialized_set(S& s, const some_data& data, foo_tag) {
s.set_foo(data.foo);
}
template <class S>
void serialized_set(S& s, const some_data& data, bar1_tag) {
s.set_bar1(data.bar1);
}
template <class S>
void serialized_set(S& s, const some_data& data, bar2_tag) {
s.set_bar2(data.bar2);
}
template <class S>
void serialized_set(S& s, const some_data& data, baz_tag) {
s.set_baz(data.baz);
}
template <class S>
void serialized_set(S& s, const some_data& data, fbr_tag) {
s.set_fbr(data.fbr);
}
样板再次限制为每个数据成员一个 serialized_set 并且线性缩放，类似于我之前的回答。这是修改后的 serialization_traits:
// the serialization_traits doesn't need specialization anymore :)
template <class SerializedX>
class serialization_traits {
class set_functor {
const some_data& m_data;
public:
typedef SerializedX& result_type;
set_functor(const some_data& data)
: m_data(data){}
template <class Tag>
SerializedX& operator()(SerializedX& s, Tag tag) const {
serialized_set(s, m_data, tag);
return s;
}
};
public:
template <class Tuple>
static SerializedX encode(const some_data& data, const Tuple& t) {
SerializedX s;
boost::fusion::fold(t, s, set_functor(data));
return s;
}
};
这是它的工作原理：
void send(const some_data& data) {
send_msg( serialization_traits<SerializedFooBar>::encode(data,
boost::fusion::make_tuple(foo_tag(), bar1_tag())));
send_msg( serialization_traits<SerializedBarBaz>::encode(data,
boost::fusion::make_tuple(baz_tag(), bar1_tag(), bar2_tag())));
}
更新代码 here
您是否考虑过稍微不同的方法？与其使用单独的 FooBar 和 BarBaz 表示，不如考虑使用类似于
的 FooBarBaz
message FooBarBaz {
optional Foo foo = 1;
optional Bar bar = 2;
optional Baz baz = 3;
}
然后在您的应用程序代码中，您可以像这样利用它：
FooBarBaz foo;
foo.set_foo(...);
FooBarBaz bar;
bar.set_bar(...);
FooBarBaz baz;
baz.set_baz(...);
FooBarBaz foobar = foo;
foobar.MergeFrom(bar);
FooBarBaz barbaz = bar;
barbaz.MergeFrom(baz);
或者，您可以利用 protobuf 编码并序列化消息。 （protobuf 本身实际上并没有序列化，您可以通过调用其中一种 ToString 方法来获得它）。
// assume string_foo is the actual serialized foo from above, likewise string_bar
string serialized_foobar = string_foo + string_bar;
string serialized_barbaz = string_bar + string_baz;
FooBarBaz barbaz;
barbaz.ParseFromString(serialized_barbaz);
这确实假设您可以将大部分 api 从显式字段集转移到带有可选字段的公共消息，以仅发送您需要的内容。您可能希望包装系统的边缘以断言特定进程所需的字段在尝试使用它之前已设置，但这可能会导致其他地方的样板文件更少。如果您正在通过一个实际上并不关心其中内容的系统，字符串连接技巧也可以派上用场。
我们的软件正在抽象出硬件，我们有 类 表示该硬件的状态，并且有大量数据成员用于该外部硬件的所有属性。我们需要定期更新有关该状态的其他组件，为此我们通过 MQTT 和其他消息传递协议发送 protobuf 编码的消息。有不同的消息描述硬件的不同方面，因此我们需要发送那些 类 的数据的不同视图。这是一个草图：
struct some_data {
Foo foo;
Bar bar;
Baz baz;
Fbr fbr;
// ...
};
假设我们需要发送一封包含 foo 和 bar 的消息，以及一封包含 bar 和 baz 的消息。我们目前的做法是大量样板文件：
struct foobar {
Foo foo;
Bar bar;
foobar(const Foo& foo, const Bar& bar) : foo(foo), bar(bar) {}
bool operator==(const foobar& rhs) const {return foo == rhs.foo && bar == rhs.bar;}
bool operator!=(const foobar& rhs) const {return !operator==(*this,rhs);}
};
struct barbaz {
Bar bar;
Baz baz;
foobar(const Bar& bar, const Baz& baz) : bar(bar), baz(baz) {}
bool operator==(const barbaz& rhs) const {return bar == rhs.bar && baz == rhs.baz;}
bool operator!=(const barbaz& rhs) const {return !operator==(*this,rhs);}
};
template<> struct serialization_traits<foobar> {
static SerializedFooBar encode(const foobar& fb) {
SerializedFooBar sfb;
sfb.set_foo(fb.foo);
sfb.set_bar(fb.bar);
return sfb;
}
};
template<> struct serialization_traits<barbaz> {
static SerializedBarBaz encode(const barbaz& bb) {
SerializedBarBaz sbb;
sfb.set_bar(bb.bar);
sfb.set_baz(bb.baz);
return sbb;
}
};
然后可以发送：
void send(const some_data& data) {
send_msg( serialization_traits<foobar>::encode(foobar(data.foo, data.bar)) );
send_msg( serialization_traits<barbaz>::encode(barbaz(data.foo, data.bar)) );
}
考虑到要发送的数据集通常比两个项目大得多，我们也需要解码该数据，并且我们有大量这些消息，因此涉及的样板文件比本文中的要多得多这个草图。所以我一直在寻找一种方法来减少这种情况。这是第一个想法：
typedef std::tuple< Foo /* 0 foo */
, Bar /* 1 bar */
> foobar;
typedef std::tuple< Bar /* 0 bar */
, Baz /* 1 baz */
> barbaz;
// yay, we get comparison for free!
template<>
struct serialization_traits<foobar> {
static SerializedFooBar encode(const foobar& fb) {
SerializedFooBar sfb;
sfb.set_foo(std::get<0>(fb));
sfb.set_bar(std::get<1>(fb));
return sfb;
}
};
template<>
struct serialization_traits<barbaz> {
static SerializedBarBaz encode(const barbaz& bb) {
SerializedBarBaz sbb;
sfb.set_bar(std::get<0>(bb));
sfb.set_baz(std::get<1>(bb));
return sbb;
}
};
void send(const some_data& data) {
send_msg( serialization_traits<foobar>::encode(std::tie(data.foo, data.bar)) );
send_msg( serialization_traits<barbaz>::encode(std::tie(data.bar, data.baz)) );
}
我得到了这个工作，它大大减少了样板文件。 （不是在这个小例子中，但如果你想象有十几个数据点被编码和解码，大量重复的数据成员列表消失会产生很大的不同）。但是，这有两个缺点：
这依赖于
Foo、Bar和Baz是不同的类型。如果它们都是int，我们需要在元组中添加一个虚拟标签类型。这是可以做到的，但它确实使整个想法的吸引力大打折扣。
旧代码中的变量名在新代码中变成了注释和数字。这非常糟糕，并且考虑到编码和解码中很可能存在混淆两个成员的错误，它不能在简单的单元测试中被捕获，但需要通过其他技术创建的测试组件（所以集成测试）来捕获此类错误。
我不知道如何解决这个问题。
有没有人知道如何为我们减少样板文件？
注：
- 目前，我们还停留在 C++03 上。是的，你没有看错。对我们来说，它是
std::tr1::tuple。没有拉姆达。也没有auto。 - 我们有大量使用这些序列化特征的代码。我们不能抛开整个计划，做一些完全不同的事情。我正在寻找一种解决方案来简化适合现有框架的未来代码。任何需要我们重写整个东西的想法很可能会被驳回。
在我看来，最好的 all-around 解决方案是使用脚本语言的外部 C++ 代码生成器。它具有以下优点：
灵活性：它允许您随时更改生成的代码。这对几个 sub-reasons:
来说非常好- 随时修复所有受支持的旧版本中的错误。
- 如果您将来迁移到 C++11 或更高版本，请使用新的 C++ 功能。
- 为不同的语言生成代码。这非常非常有用（特别是如果您的组织很大 and/or 您有很多用户）。例如，您可以输出一个小型脚本库（例如 Python 模块），它可以用作与硬件交互的 CLI 工具。根据我的经验，硬件工程师非常喜欢它。
- 生成 GUI 代码（或 GUI 描述，例如 XML/JSON；甚至是 Web 界面）——对使用最终硬件和测试人员的人很有用。
- 生成其他类型的数据。例如，图表、统计数据等。甚至是 protobuf 描述本身。
维护：会比C++更容易维护。即使它是用不同的语言编写的，学习该语言通常比让新的 C++ 开发人员深入研究 C++ 模板元编程（特别是在 C++03 中）更容易。
性能：它可以很容易地减少C++端的编译时间（因为你可以输出非常简单的C++——甚至是纯C）。当然，生成器可能会抵消这个优势。在您的情况下，这可能不适用，因为看起来您无法更改客户端代码。
我已经在几次 projects/systems 中使用了这种方法，结果非常好。特别是使用硬件的不同替代方案（C++ lib、Python lib、CLI、GUI...）可以 非常 赞赏.
旁注：如果生成的一部分需要解析 已经存在的 C++ 代码（例如 headers 具有要序列化的数据类型，就像在 OP 的情况下 Serialized 类型);那么一个非常好的解决方案是使用 LLVM/clang's tooling 来做到这一点。
在我从事的一个特定项目中，我们必须自动序列化数十种 C++ 类型（用户随时可能更改这些类型）。我们设法通过使用 clang Python 绑定自动生成代码并将其集成到构建过程中。虽然 Python 绑定没有公开所有 AST 细节（至少在当时是这样），但它们足以为我们所有的类型（包括模板化 类、容器等）生成所需的序列化代码.).
您想要的是类元组但不是真正的元组。假设所有 tuple_like classes 实现 tie() 基本上只是绑定他们的成员，这是我的假设代码：
template<typename T> struct tuple_like {
bool operator==(const T& rhs) const {
return this->tie() == rhs.tie();
}
bool operator!=(const T& rhs) const {
return !operator==(*this,rhs);
}
};
template<typename T, typename Serialised> struct serialised_tuple_like : tuple_like<T> {
};
template<typename T, typename Serialised>
struct serialization_traits<serialised_tuple_like<T, Serialised>> {
static Serialised encode(const T& bb) {
Serialised s;
s.tie() = bb.tie();
return s;
}
};
只要双方实现适当的tie()，就可以了。如果源或目标 class 不直接在您的控制中，建议定义一个继承的 class 来实现 tie() 并使用它。要合并多个 classes，请定义一个根据其成员实现 tie() 的助手 class。
如果您的样板文件真的只是一堆带有普通比较运算符的普通旧数据结构，您可能可以使用一些宏。
#define POD2(NAME, T0, N0, T1, N1) \
struct NAME { \
T0 N0; \
T1 N1; \
NAME(const T0& N0, const T1& N1) \
: N0(N0), N1(N1) {} \
bool operator==(const NAME& rhs) const { return N0 == rhs.N0 && N1 == rhs.N1; }
\
bool operator!=(const NAME& rhs) const { return !operator==(rhs); } \
};
用法如下：
POD2(BarBaz, Bar, bar, Baz, baz)
template <>
struct serialization_traits<BarBaz> {
static SerializedBarBaz encode(const BarBaz& bb) {
SerializedBarBaz sbb;
sbb.set_bar(bb.bar);
sbb.set_baz(bb.baz);
return sbb;
}
};
您将需要 N 个宏，其中 N 是您拥有的参数计数的排列数，但这将是一次性的前期成本。
或者，您可以像您建议的那样利用元组为您完成大量繁重的工作。在这里，我创建了一个 "NamedTuple" 模板来命名元组的 getter。
#define NAMED_TUPLE2_T(N0, N1) NamedTuple##N0##N1
#define NAMED_TUPLE2(N0, N1) \
template <typename T0, typename T1> \
struct NAMED_TUPLE2_T(N0, N1) { \
typedef std::tuple<T0, T1> TupleType; \
const typename std::tuple_element<0, TupleType>::type& N0() const { return std::get<0>(tuple_); } \
const typename std::tuple_element<1, TupleType>::type& N1() const { return std::get<1>(tuple_); } \
NAMED_TUPLE2_T(N0, N1)(const std::tuple<T0, T1>& tuple) : tuple_(tuple) {} \
bool operator==(const NAMED_TUPLE2_T(N0, N1)& rhs) const { return tuple_ == rhs.tuple_; } \
bool operator!=(const NAMED_TUPLE2_T(N0, N1)& rhs) const { return !operator==(rhs); } \
private: \
TupleType tuple_; \
}; \
typedef NAMED_TUPLE2_T(N0, N1)
用法：
NAMED_TUPLE2(foo, bar)<int, int> FooBar;
template <>
struct serialization_traits<FooBar> {
static SerializedFooBar encode(const FooBar& fb) {
SerializedFooBar sfb;
sfb.set_foo(fb.foo());
sfb.set_bar(fb.bar());
return sfb;
}
};
我将以您提出的解决方案为基础，但改用 boost::fusion::tuples（假设允许）。假设您的数据类型是
struct Foo{};
struct Bar{};
struct Baz{};
struct Fbr{};
你的数据是
struct some_data {
Foo foo;
Bar bar;
Baz baz;
Fbr fbr;
};
从评论中，我了解到您无法控制 SerialisedXYZ classes，但它们确实有特定的界面。我会假设这样的事情已经足够接近了（？）：
struct SerializedFooBar {
void set_foo(const Foo&){
std::cout << "set_foo in SerializedFooBar" << std::endl;
}
void set_bar(const Bar&){
std::cout << "set_bar in SerializedFooBar" << std::endl;
}
};
// another protobuf-generated class
struct SerializedBarBaz {
void set_bar(const Bar&){
std::cout << "set_bar in SerializedBarBaz" << std::endl;
}
void set_baz(const Baz&){
std::cout << "set_baz in SerializedBarBaz" << std::endl;
}
};
我们现在可以减少样板文件并将其限制为每个数据类型排列一个 typedef 和 SerializedXYZ class 的每个 set_XXX 成员一个简单的重载，如下所示：
typedef boost::fusion::tuple<Foo, Bar> foobar;
typedef boost::fusion::tuple<Bar, Baz> barbaz;
//...
template <class S>
void serialized_set(S& s, const Foo& v) {
s.set_foo(v);
}
template <class S>
void serialized_set(S& s, const Bar& v) {
s.set_bar(v);
}
template <class S>
void serialized_set(S& s, const Baz& v) {
s.set_baz(v);
}
template <class S, class V>
void serialized_set(S& s, const Fbr& v) {
s.set_fbr(v);
}
//...
现在的好处是您不再需要专门化您的 serialization_traits。下面使用 boost::fusion::fold 函数，我认为它可以在您的项目中使用：
template <class SerializedX>
class serialization_traits {
struct set_functor {
template <class V>
SerializedX& operator()(SerializedX& s, const V& v) const {
serialized_set(s, v);
return s;
}
};
public:
template <class Tuple>
static SerializedX encode(const Tuple& t) {
SerializedX s;
boost::fusion::fold(t, s, set_functor());
return s;
}
};
这里有一些它是如何工作的例子。请注意，如果有人试图绑定 some_data 中不符合 SerializedXYZ 接口的数据成员，编译器将通知您：
void send_msg(const SerializedFooBar&){
std::cout << "Sent SerializedFooBar" << std::endl;
}
void send_msg(const SerializedBarBaz&){
std::cout << "Sent SerializedBarBaz" << std::endl;
}
void send(const some_data& data) {
send_msg( serialization_traits<SerializedFooBar>::encode(boost::fusion::tie(data.foo, data.bar)) );
send_msg( serialization_traits<SerializedBarBaz>::encode(boost::fusion::tie(data.bar, data.baz)) );
// send_msg( serialization_traits<SerializedFooBar>::encode(boost::fusion::tie(data.foo, data.baz)) ); // compiler error; SerializedFooBar has no set_baz member
}
int main() {
some_data my_data;
send(my_data);
}
代码here
编辑：
不幸的是，这个解决方案没有解决 OP 的问题 #1。为了解决这个问题，我们可以定义一系列标签，一个用于您的每个数据成员，并遵循类似的方法。以下是标签以及修改后的 serialized_set 函数：
struct foo_tag{};
struct bar1_tag{};
struct bar2_tag{};
struct baz_tag{};
struct fbr_tag{};
template <class S>
void serialized_set(S& s, const some_data& data, foo_tag) {
s.set_foo(data.foo);
}
template <class S>
void serialized_set(S& s, const some_data& data, bar1_tag) {
s.set_bar1(data.bar1);
}
template <class S>
void serialized_set(S& s, const some_data& data, bar2_tag) {
s.set_bar2(data.bar2);
}
template <class S>
void serialized_set(S& s, const some_data& data, baz_tag) {
s.set_baz(data.baz);
}
template <class S>
void serialized_set(S& s, const some_data& data, fbr_tag) {
s.set_fbr(data.fbr);
}
样板再次限制为每个数据成员一个 serialized_set 并且线性缩放，类似于我之前的回答。这是修改后的 serialization_traits:
// the serialization_traits doesn't need specialization anymore :)
template <class SerializedX>
class serialization_traits {
class set_functor {
const some_data& m_data;
public:
typedef SerializedX& result_type;
set_functor(const some_data& data)
: m_data(data){}
template <class Tag>
SerializedX& operator()(SerializedX& s, Tag tag) const {
serialized_set(s, m_data, tag);
return s;
}
};
public:
template <class Tuple>
static SerializedX encode(const some_data& data, const Tuple& t) {
SerializedX s;
boost::fusion::fold(t, s, set_functor(data));
return s;
}
};
这是它的工作原理：
void send(const some_data& data) {
send_msg( serialization_traits<SerializedFooBar>::encode(data,
boost::fusion::make_tuple(foo_tag(), bar1_tag())));
send_msg( serialization_traits<SerializedBarBaz>::encode(data,
boost::fusion::make_tuple(baz_tag(), bar1_tag(), bar2_tag())));
}
更新代码 here
您是否考虑过稍微不同的方法？与其使用单独的 FooBar 和 BarBaz 表示，不如考虑使用类似于
的 FooBarBazmessage FooBarBaz {
optional Foo foo = 1;
optional Bar bar = 2;
optional Baz baz = 3;
}
然后在您的应用程序代码中，您可以像这样利用它：
FooBarBaz foo;
foo.set_foo(...);
FooBarBaz bar;
bar.set_bar(...);
FooBarBaz baz;
baz.set_baz(...);
FooBarBaz foobar = foo;
foobar.MergeFrom(bar);
FooBarBaz barbaz = bar;
barbaz.MergeFrom(baz);
或者，您可以利用 protobuf 编码并序列化消息。 （protobuf 本身实际上并没有序列化，您可以通过调用其中一种 ToString 方法来获得它）。
// assume string_foo is the actual serialized foo from above, likewise string_bar
string serialized_foobar = string_foo + string_bar;
string serialized_barbaz = string_bar + string_baz;
FooBarBaz barbaz;
barbaz.ParseFromString(serialized_barbaz);
这确实假设您可以将大部分 api 从显式字段集转移到带有可选字段的公共消息，以仅发送您需要的内容。您可能希望包装系统的边缘以断言特定进程所需的字段在尝试使用它之前已设置，但这可能会导致其他地方的样板文件更少。如果您正在通过一个实际上并不关心其中内容的系统，字符串连接技巧也可以派上用场。