Cluster di istanze di classe nel grafico di riferimento agli oggetti per la serializzazione di più voci

La mia domanda è sul modo migliore per raggruppare un grafico di istanze di classe intorno a oggetti specificatamente contrassegnati (gli oggetti sono i nodi del grafico ei riferimenti tra loro sono i bordi diretti del grafico). Per spiegare meglio la mia domanda, lascia che ti spieghi la mia motivazione:

Attualmente utilizzo un sistema moderatamente complesso per serializzare i dati utilizzati nei miei progetti:

• gli oggetti "contrassegnati" hanno attributi specifici che memorizzano una "voce salvata": il percorso di un file associato sul disco (ma potrebbe essere fatto per qualsiasi tipo di memoria che fornisce l'interfaccia adatta)
• Questi oggetti possono quindi essere serializzati automaticamente (es: obj.save() )
• La serializzazione di un oggetto contrassegnato 'a' contiene implicitamente tutti gli oggetti 'b' per cui 'a' ha un riferimento a, direttamente s.t: a.b = b o indirettamente s.t .: a.c.b = b per qualche oggetto 'c'

In pratica definiscono specifiche voci di memoria per oggetti specifici. Ho quindi oggetti di tipo "contenitore" che:

1. può essere serializzato in modo simile (infatti sono o possono essere "contrassegnati")
2. non serializzano nelle loro voci di archiviazione gli oggetti "contrassegnati" (con riferimento diretto): se a e a.b sono entrambi marcati, a.save() chiama b.save() e memorizza a.b = storage_entry(b)

Quindi, se serializzo 'a' , serializzerà automaticamente tutti gli oggetti che possono essere raggiunti da 'a' attraverso il grafico di riferimento dell'oggetto, possibilmente in voci multiple. Questo è quello che voglio e di solito fornisce le funzionalità di cui ho bisogno. Tuttavia, ci sono alcune limitazioni strutturali a questo approccio:

1. il salvataggio a più voci può funzionare solo tramite connessioni dirette in oggetti "contenitore" e
2. ci sono situazioni con comportamento indefinito come se due oggetti "marcati" 'a' e 'b' abbiano entrambi un riferimento a un oggetto non marcato 'c' . In questo caso il mio sistema memorizza 'c' in 'a' e 'b' facendo una copia implicita che non solo raddoppia la dimensione della memoria, ma cambia anche il grafico di riferimento dell'oggetto dopo il nuovo caricamento.

Sto pensando di generalizzare il processo. A parte le domande pratiche sull'implementazione (sto codificando in python e uso Pickle per serializzare i miei oggetti), c'è una domanda generale sul modo di allegare (cluster) gli oggetti non marcati a quelli contrassegnati.

Quindi, le mie domande sono:

• Quali sono i problemi importanti che dovrebbero essere considerati? Fondamentalmente, perché non utilizzare solo un algoritmo di analisi dei grafi con il comportamento "annetti all'ultimo nodo contrassegnato".
• C'è qualche lavoro su questo problema, pratico o teorico, di cui dovrei essere a conoscenza?

Esempio di un semplice oggetto grafico da serializzare:

I cerchi sono oggetti e riferimenti alle frecce. I cerchi arancioni sono oggetti contrassegnati.

Durante la serializzazione di A , l'oggetto B in E deve essere serializzato ma non gli oggetti blu perché non sono raggiungibili da A . Ora, B è serializzato nella sua stessa voce (cioè il file) e la domanda è come scegliere dove serializzare oggetti C in E , in A o B in entrata?

Alcuni pensano in questo esempio:

• l'oggetto C è raggiungibile solo da A , quindi è necessario collegarlo ad esso
• per raggiungere E , è necessario passare da B , quindi E deve essere associato a B
• che dire di D ? Perché dopo la serializzazione se B è caricato (e non A ), anche D deve essere caricato ma non A . Pertanto D deve essere serializzato in B entry.

Nota: Ho aggiunto il tag database perché penso che la risposta potrebbe provenire da quei campi, anche se la domanda non è vera.