Data mapping : from "any" class to a generic key value map (C++) - c++

Question

For logging purposes, I would like to adapt various classes (for this reason I'd like a generic approach) to a key value dictionary : this could be seen as "key value serialization".
Let's assume the keys are pre-defined and that, depending on the input class we do want to adapt, each value may correspond to a specific attribute.
Values can always be encapsulated into an std::string.
This would be my approach :
Create an adapter class which can be dumped into the database
#include <keys.h> // enum with possible keys, defining type Key_t
namespace generic
{
class Adapter
{
public:
Adapter();
virtual ~Adapter();
virtual void init() = 0;
private:
std::map<Key_t, std::string> _data;
}
}
For every possible client, specialize the adapter class in its namespace, supposing it is friend with any client's specific business object model (to access attributes easily), and that it receives the instances of such models via const references in its constructor
e.g.
#include <generic/Adapter.h>
#include <client1/bom1.h>
#include <client1/bom2.h>
...
#include <client1/bomN.h>
namespace client1
{
class Adapter : public generic::Adapter
{
public:
Adapter(const Bom1& bom1,
const Bom2& bom2,
const BomN& bomN)
: _bom1(bom1), _bom2(bom2), _bomN(bomN)
{}
void init()
{
// Explicit data mapping in here
_map[NAME] = _bom1._name;
_map[TITLE] = _bom2._title;
....
....
}
private:
Bom1 _bom1;
Bom2 _bom2;
BomN _bomN;
}
}
What do you think about this approach ?
Is there a more generic way of achieving this in c++ ?
What would have been your design ?
Thanks!
Update
When a new client is implemented the logging engine shouldn't change: that is why the adapting logic should be distributed on client side rather than being implemented in the core of the logging engine.
The logging engine would be updated only if new keys are required (this would probably imply a database structural change).

Answer 1

I would have stored serialized strings for both keys and values.
Here I'm using the ldbSerialize method which uses boost serialization by default and can be easily specialized without creating a new class. For every new type of the key one would simply add a new specalization:
template <> inline void ldbSerialize<Key32> (string& bytes, const Key32& key) {
bytes += key.whatever();
}