Modelli per la gestione dei set di proprietà modificabili in C ++

Bene, AFAIU vuoi un qualche tipo di riflessione, ma per mantenere il tipo statico di controllo i dati di riflessione devono essere disponibili per i metaprogrammi del modello. Ci sono (o almeno c'erano) diversi sforzi per implementare tale libreria: Riflessione Mirror C ++ utilità , librerie di boost per la programmazione riflessiva (sembrano obsolete). Dai un'occhiata a loro almeno come fonte di ispirazione. Dai anche un'occhiata a Boost.Fusion , è una libreria per lavorare con raccolte eterogenee di dati (tuple), che a loro volta possono rappresentare strutture.

La riflessione statica più semplice può essere ottenuta utilizzando un generatore di codice separato che produce un codice come:

struct Foo {
  int a;
  double b;
};

// Types to identify struct members
namespace name_tags { struct a; struct b; }

// Reflection metadata for struct Foo
template<>
struct DataMembers<Foo> {
  typedef boost::fusion::result_of::make_map<
    name_tags::a,
    name_tags::b,
    Member<Foo, int>,
    Member<Foo, double>
  >::type type;

  type value;
};

DataMembers<Foo>::type
DataMembers<Foo>::value = 
  boost::fusion::result_of::make_map<
    name_tags::a,
    name_tags::b>(Member<Foo, int>(&Foo::a, "a"), 
                  Member<Foo, double>(&Foo::b, "b"));

Dove il modello di classe Member è simile a:

template<typename S, typename M>
struct Member
{
  M S::* ptr;
  std::string name;

  Member(M S::* ptr, const std::string& name) : ptr(ptr), name(name) { }
};

Quindi puoi utilizzare Boost.Fusion per applicare un functor a tutti i membri della classe. Puoi utilizzare metafunzioni aggiuntive per contrassegnare alcuni membri, ad es. come proprietà da elaborare.

L'iterazione dei membri di Foo può essere eseguita come

boost::fusion::for_each(DataMembers<Foo>::value, ProcessMember());

struct ProcessMember
{
  void operator() (const boost::fusion::pair<name_tags::a, Member<Foo, int>>& mem) const
   {
     // ...
   }

  void operator() (const boost::fusion::pair<name_tags::b, Member<Foo, double>>& mem) const
   {
     // ...
   }

   // You can also provide a default case
   template<typename T>
   void operator() (const T&) const { }
};

I tipi di tag name_tags::a e name_tags::b vengono visualizzati nelle firme di operator() e consentono di fornire una funzione di elaborazione separata per ogni membro di Foo . Se aggiungi un membro a Foo e aggiorni i dati di riflessione (questo dovrebbe essere automatizzato) e dimentichi di aggiornare l'elaborazione, l'applicazione di tali funzioni non verrà compilata.

Un suggerimento è di rendere un PropValue un tipo base e BoolValue, IntValue, DoubleValue, ArrayValue, possono essere classi derivate. I numeri potrebbero essere raggruppati in NumberValue e ArrayValue potrebbe essere sottoclasse in VectorValue, DictionaryValue , ecc.

Ciò potrebbe aiutare a dividere i problemi di definizione dei tratti e di dove consentire conversioni di tipi.

Non vedo un'immagine completa di dove gestisci i tipi dinamici. Sembra che il consumatore sappia o si aspetti un bool nel tuo esempio. Quindi solo lo zucchero sintattico fa una conversione sovraccaricata piuttosto che chiamare qualcosa del tipo:

bool b_by_ref;
Error err  = Propset.GetBool("propname",&b_by_ref);

Se non conosci o non ti interessa ancora del tipo, passalo come PropValue * e lascia che le funzioni si preoccupino dei tipi internamente in quell'algoritmo.

void FooFunc (PropValue* p)
{
    DWORD id = p->GetTypeID();
    switch(id)
    {
        case INT_VALUE_TYPEID:   FooInt(p);
        case FLOAT_VALUE_TYPEID: FooFloat(p);
         .....
        default: Assert(0);
    }
 }

Devi avere un linguaggio dinamico reale, come Lua o Python, per gestire questo tipo di carico di lavoro.