Flyweights con Boost e origini dati esterne

Question

Forse c'è un modo semplice per aggirare ciò che non vedo, quindi spero che qualcuno me lo possa spiegare.

Diciamo che ho una classe:

class A { 
public: 
    const double parameter; 
    const std::string name; 
    const std:: string fileName; 

    A(const double parameter, const std::string name, const std::string fileName) : 
     parameter(parameter), name(name), fileName(fileName) {}; 
}; 

e il generatore per la classe è:

class AReader { 
public: 
    ifstream dataFile; 
    AReader(const std::string filename); 
    A* readObject(const std::string objectName); 
}; 

Vorrei utilizzare boost::flyweight per gestire questi A oggetti perché ci saranno potenzialmente milioni di riferimenti a loro e in realtà contengono molti dati. Saranno sottoposti a hash su name e fileName insieme.

Cosa devo fare per funzionare? Ho bisogno dello boost::flyweight per chiamare AReader.readObject e dell'hash/memorizzare la classe A risultante.

Il AReader deve diventare una fabbrica completa e utilizzato come fabbrica personalizzata? Oppure è possibile utilizzare la fabbrica predefinita nel peso piuma e in qualche modo utilizzare AReader per generare le istanze A (anziché implementare l'intero modello di archiviazione richiesto dalla fabbrica), magari trasformando un'istanza AReader in qualcosa nel peso piuma? Oppure è possibile ottenere variabili pubbliche const (ad esempio una volta impostate, non cambiano) da un'origine dati esterna senza ricorrere a una seconda classe?

Modifica

Sono aperto anche ad altri suggerimenti che non utilizzano Boost. Posso certamente scrivere la mia implementazione di un peso mosca, o qualsiasi altro modello se uno è più adatto. Ma se posso usare qualcosa che esiste già, sarebbe meglio. Qualunque cosa minimizzi la quantità di codice che devo scrivere perché, come sempre, le scadenze sono brevi.

Answer 1

Non ho usato Boost :: flyweight ma dall'aspetto di esso per lo meno la chiave deve essere Assignable (oltre ad essere EqualityComparable e Hashable). Con i tuoi membri const digiti chiaramente nonAssignable. Dal suo aspetto, non è necessario renderlo Assignable se si dispone di un estrattore di chiavi . Usando un estrattore di chiavi solo la chiave deve essere Assignable.

Answer 2

Il metodo di base per utilizzare il flyweight nel caso è per readObject per restituire un peso mosca. Internamente, readObject crea un oggetto nuovo di zecca, e quando si crea l'oggetto del peso mosca corrispondente, controlla quindi se l'oggetto si trova già nel negozio di pesi mosca. In tal caso, rilascia il nuovo oggetto e restituisce un peso mosca che fa riferimento all'oggetto nel negozio. In caso contrario, aggiunge il nuovo oggetto al suo pool.

Ora, questo dovrebbe essere banale da implementare, ma a seconda del caso d'uso potrebbe essere inefficiente. Per prestazioni migliori, è possibile utilizzare la funzionalità key_value, che consente di fare riferimento agli oggetti tramite la chiave e di crearli solo se non sono già presenti nello store.

Answer 3

Sebbene il peso di un peso pari a key_value corrisponda al conto, sembra che ci sia un piccolo inconveniente. Dovresti essere in grado di costruire un peso proprio key_value utilizzando un solo parametro del tipo di chiave (key_value flyweights).Quindi, per farlo funzionare con la chiave che desideri (nomefile + nome) dovresti comprimere quei 2 campi in uno (tuple? Neanche sicuro che funzionerebbe.)

Supponendo che sei interessato a ottenere il la maggior parte con la minima quantità di lavoro, perché non solo Flyweight le stringhe della classe come dimostrato in Flyweight Basics?

Ciò significa A oggetti non vengono hash nel modo desiderato, ma le stringhe sono facilmente flyweighted, e questi sembrano essere i campi di memoria problematico. (a meno che non si tratti di una semplificazione eccessiva)