通过字段的键从任何结构或元组获取迭代器作为字符串

Question

Do you know a library in boost, poco, ... that has a function with a signature such as :

template <typename T> auto vectorize(const std::vector<std::string> & mask, T & t) -> T::iterator

which could be used like :

struct A {double x; double y; double z;};
auto a = A();
auto it = vectorize({"x","z"}, a);
//and here doing perturbations and increments on a; ideally it is for passing it to another function

I am redesigning existing code that does such a thing (with a method for serializing inside the struct) but I have to admit our version is quite messy :/

Do you have an idea of abstraction for that and working with tuples ? I am currently trying with an enum for mapping the field of the tuple.

I am pretty sure that someone wrote something intelligent for this kind of reflexive container iteration problem. (I have looked to boost::fusion but it doest filtering by types only or I missed a page)

Answer 1

C++ doesn't have any magic ways of doing this nicely like many of the VM languages.

Usually you'd use something like boost serialization . The goal being that you just write a simple mapping function, and the rest is just configuring policies.

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>

class gps_position
{
public:
    int degrees;
    int minutes;
    float seconds;
    gps_position(){};
    gps_position(int d, int m, float s) :
        degrees(d), minutes(m), seconds(s)
    {}
};

namespace boost {
namespace serialization {

template<class Archive>
void serialize(Archive & ar, gps_position & g, const unsigned int version)
{
    ar & g.degrees;
    ar & g.minutes;
    ar & g.seconds;
}

} // namespace serialization
} // namespace boost

Alternatively, you may be able to get some traction with something simple that assumes that you're always serializing doubles or write static visitors for std::tuple or boost::tuple if you're not using c++11.