C++ 使用 boost fusion adapt_struct 迭代到嵌套结构域
两个stackoverflow 答案 建议使用 fusion adapt_struct 迭代结构字段的方法.这种方法看起来不错.但是，如何迭代到一个本身就是结构体的字段?
Two stackoverflow answers suggest the approach using fusion adapt_struct to iterate over struct fields. The approach looks nice. However, how do you iterate into a field which itself is a struct?
按照前面的答案，我想出了下面的代码.问题在于代码无法编译的#if 0"子句.作为替代解决方案，我创建了decode()"函数来获取指向目标参数的空指针.这有效，但在编译时丢失了类型信息.有更好的解决方案吗?
Following the previous answers, I come up with the code below. The problem is at the "#if 0" clause the code does not compile. As an alternative solution I created "decode()" function to take a void pointer to the target argument. That works, but loses the type information at compile time. Is there a better solution?
struct Foo_s { int i; };
BOOST_FUSION_ADAPT_STRUCT( Foo_s, (int, i) )
struct Bar_s { int v; Foo_s w; };
BOOST_FUSION_ADAPT_STRUCT( Bar_s, (int, v) (Foo_s, w) )
struct AppendToTextBox {
template <typename T> void operator()(T& t) const {
int status = 0;
const char *realname = abi::__cxa_demangle(typeid(t).name(), 0, 0, &status);
printf(" typename: %s value: %s realname: %s
", typeid(t).name(),
boost::lexical_cast<std::string>(t).c_str(), realname);
std::string rn(realname);
if ( rn.rfind("_s") == rn.size()-2 ) {
#if 0 /* this can not compile */
for_each(t, AppendToTextBox());
#else
decode(&t, rn);
#endif
}
}
};
void decode(void *f, std::string & intype ) {
if ( intype.find("Foo_s") == 0 )
for_each( *(Foo_s *)f, AppendToTextBox());
};
int main(int argc, char *argv[]) {
Bar_s f = { 2, { 3 } };
for_each(f, AppendToTextBox());
return 0;
}
我在 wikipedia 上看到，而不是传递您可以使用的类型字符串intype"typeid 和 dynamic_cast.但这只会是一个很小的改进.我正在寻找一种对 C++ 或 boost 语言设计更内在的解决方案.
I have seen on wikipedia instead of passing a type string "intype" you can use typeid and dynamic_cast. But that will only be a minor improvement. I'm looking for a solution that is more intrinsic to C++ or boost language design.
推荐答案
我做了 您可以在我的博客网站上看到的您想要的示例.在这种情况下，它是一个使用嵌套结构的 JSON 序列化程序.自从我在 Boost.Serialization 库中看到它以来，它使用了更多 Boost"解决方案.(另见下文和在 Coliru 上直播.)
I made an example of what you want that you can see at my blog site. In this is case it's a JSON serializer that works with nested structs. It uses a 'more Boost' solution since I saw it in the Boost.Serialization library. (See also below and live on Coliru.)
该解决方案使用结构的 Fusion Sequence 适配和一个遍历对象成员(递归)的元函数 - 使用 Boost.TypeTraits 和特定类型的不同特征.
The solution uses Fusion Sequence adaptation of structs and a metafunction that walks object members (recursively) - using Boost.TypeTraits and different traits for specific types.
你可以看到一个更复杂的googlecode corbasim 项目网站上的相同解决方案示例，用于创建运行时自反 API.
You can see a more complex example of the same solution at the site for googlecode corbasim project for creating an run-time reflexive API.
看到它在 Coliru 上直播
See it Live on Coliru
#ifndef JSON_SERIALIZER_HPP
#define JSON_SERIALIZER_HPP
#include <boost/type_traits.hpp> // is_array, is_class, remove_bounds
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/next_prior.hpp>
#include <boost/fusion/mpl.hpp>
#include <boost/fusion/adapted.hpp> // BOOST_FUSION_ADAPT_STRUCT
// boost::fusion::result_of::value_at
#include <boost/fusion/sequence/intrinsic/value_at.hpp>
#include <boost/fusion/include/value_at.hpp>
// boost::fusion::result_of::size
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/include/size.hpp>
// boost::fusion::at
#include <boost/fusion/sequence/intrinsic/at.hpp>
#include <boost/fusion/include/at.hpp>
namespace json
{
// Forward
template < typename T >
struct serializer;
namespace detail
{
namespace iterator
{
template < typename S, typename N >
struct Comma
{
template < typename Ostream >
static inline void comma(Ostream& os)
{
os << ", ";
}
};
template < typename S >
struct Comma< S, typename boost::mpl::prior< typename boost::fusion::result_of::size< S >::type >::type >
{
template < typename Ostream >
static inline void comma(Ostream& os)
{
}
};
// Iteracion sobre una estructura
template < typename S, typename N >
struct StructImpl
{
// Tipo del campo actual
typedef typename boost::fusion::result_of::value_at< S, N >::type current_t;
typedef typename boost::mpl::next< N >::type next_t;
typedef boost::fusion::extension::struct_member_name< S, N::value > name_t;
template < typename Ostream >
static inline void serialize(Ostream& os, const S& s)
{
os << """ << name_t::call() << "": ";
::json::serializer< current_t >::serialize(os, boost::fusion::at< N >(s));
// Insert comma or not
Comma< S, N >::comma(os);
StructImpl< S, next_t >::serialize(os, s);
}
};
// Fin de la iteracion sobre estructuras.
template < typename S >
struct StructImpl< S, typename boost::fusion::result_of::size< S >::type >
{
template < typename Ostream >
static inline void serialize(Ostream& os, const S& s)
{
// Nada que hacer
}
};
// Iterador sobre una estructura. Template fachada.
template < typename S >
struct Struct : StructImpl< S, boost::mpl::int_< 0 > > {};
} // iterator
template < typename T >
struct array_serializer
{
typedef array_serializer< T > type;
typedef typename boost::remove_bounds< T >::type slice_t;
static const size_t size = sizeof(T) / sizeof(slice_t);
template < typename Ostream >
static inline void serialize(Ostream& os, const T& t)
{
os << "[";
for(size_t idx=0; idx<size; idx++)
{
::json::serializer< slice_t >::serialize(os, t[idx]);
if (idx != size-1)
os << ", ";
}
os << "]";
}
};
template < typename T >
struct struct_serializer
{
typedef struct_serializer< T > type;
template < typename Ostream >
static inline void serialize(Ostream& os, const T& t)
{
os << "{";
iterator::Struct< T >::serialize(os, t);
os << "}";
}
};
template < typename T >
struct arithmetic_serializer
{
typedef arithmetic_serializer< T > type;
template < typename Ostream >
static inline void serialize(Ostream& os, const T& t)
{
os << t;
}
};
template < typename T >
struct calculate_serializer
{
typedef
typename boost::mpl::eval_if< boost::is_array< T >,
boost::mpl::identity< array_serializer < T > >,
//else
typename boost::mpl::eval_if< boost::is_class< T >,
boost::mpl::identity< struct_serializer < T > >,
//else
boost::mpl::identity< arithmetic_serializer < T > >
>
>::type type;
};
} // detail
template < typename T >
struct serializer : public detail::calculate_serializer < T >::type
{
};
} // json
#endif // JSON_SERIALIZER_HPP
//#include "json.hpp"
#include <iostream>
struct my_other_struct
{
int my_other_integer;
};
struct my_struct
{
int my_integer;
typedef int my_array_t[2];
my_array_t my_array;
typedef my_other_struct my_other_structs_t[3];
my_other_structs_t my_other_structs;
};
BOOST_FUSION_ADAPT_STRUCT(my_struct, (int, my_integer) (my_struct::my_array_t, my_array) (my_struct::my_other_structs_t, my_other_structs))
BOOST_FUSION_ADAPT_STRUCT(my_other_struct, (int, my_other_integer))
int main(int argc, char *argv[])
{
my_struct s1 = my_struct { 1, { 42, -42 }, { { 11 }, { 22 }, { 33 } } };
json::serializer< my_struct >::serialize(std::cout, s1);
std::cout << std::endl;
}
相关文章