Lecteurs/écrivains et persistance découplée des classes dérivées

Question

Je suis en train de refactoriser un tas de vieux codes. Mon objectif principal est de découpler le comportement de la base de données. L'implémentation actuelle accède directement à la base de données, ce qui rend difficile le test et la mise en œuvre de couches de cache, etc ... Jusqu'à présent, j'utilise une combinaison d'inversion de dépendance et de lecteurs/graveurs avec beaucoup de succès. atteint certains de nos types les plus complexes.

J'ai une classe d'utilisateur de base abstraite qui encapsule des informations communes à tous nos types d'utilisateurs. Hériter de la classe de base est un certain nombre de spécialisations du type d'utilisateur de base, dont chacune encapsule des informations spécifiques à ce type.

Si j'ai un pointeur ou une référence à la classe de base et que j'ai besoin de maintenir cet utilisateur dans la base de données, comment savoir quel script utiliser? Si je devais utiliser l'écrivain pour la classe de base, les informations spécifiques aux classes dérivées seraient perdues. Mettre une méthode abstraite getUserType() sur la classe de base qui doit ensuite être implémentée par chaque dérivée semble être un peu un hack. Cela pourrait être un cas de double expédition, mais les détails de mise en œuvre sont un peu flou pour moi.

class User 
{ 
public: 
    std::string 
    name() const 
    { 
     return m_name; 
    } 

    void 
    name(const std::string& name) 
    { 
     m_name = name; 
    } 

private: 
    std::string m_name; 
} 

class EmailUser : User 
{ 
public: 
    std::list<std::string> 
    emails() const 
    { 
     return m_emails; 
    } 

    void 
    emails(const std::string<std::string>& emails) 
    { 
     m_emails = emails; 
    } 

private: 
    std::set<std::string> m_emails; 
} 

class UserWriter 
{ 
public: 
    virtual void 
    write(User& user) = 0; 
} 

class DBUserWriter : UserWriter 
{ 
public: 
    void 
    write(User& user) 
    { 
     SQLExecute("SOME SQL UPDATE STMT %s", user.name()); 
    } 
} 

class DBEmailUserWriter : UserWriter 
{ 
public: 
    void 
    write(User& user) 
    { 
     m_baseUserWriter.write(user); 
     SQLExecute("SOME SQL UPDATE STMT %s", user.email.front()); 
    } 
private: 
    DBUserWriter m_baseUserWriter; 
} 

Answer 1

Voici un échantillon en utilisant la double mise en œuvre d'expédition spécifié dans la page wikipedia:

#include <iostream> 
using namespace std; 

class Writer; 

class User 
{ 
public: 
    std::string name() const { return m_name; } 
    void name(const std::string& name) { m_name = name; } 
    virtual void accept(Writer & writer) const; 

private: 
    std::string m_name; 
}; 

class EmailUser : public User 
{ 
public: 
    std::string email() const { return m_email; } 
    void email(const std::string& email) { m_email = email; } 
    virtual void accept(Writer & writer) const; 

private: 
    std::string m_email; 
}; 

class Writer 
{ 
public: 
    void process(const User& user) { user.accept(*this); } 
    virtual void write(const User& user) { cout << user.name() << endl; } 
    virtual void write(const EmailUser& user) { cout << user.email() << endl; } 
}; 

class SubWriter : public Writer 
{ 
public: 
    void process(const User& user) { user.accept(*this); } 
    void write(const User& user) { cout << "[" << user.name() << endl; } 
    void write(const EmailUser& user) { cout << "[" << user.email() << endl; } 
}; 

void User::accept(Writer & writer) const { writer.write(*this); } 
void EmailUser::accept(Writer & writer) const { writer.write(*this); } 

int main() 
{ 
    User u; 
    EmailUser eu; 
    Writer w; 
    SubWriter s; 

    u.name("Hugo Peixoto"); 
    eu.email("hugo.peixoto@gmail.com"); 

    w.process(u); 
    w.process(eu); 

    s.process(u); 
    s.process(eu); 

    return 0; 
}