Copia (meglio, clonazione) generalizzata di documenti

[theguru]

Mi piacerebbe avere una funzione che restituisca una copia perfetta di una istanza di documento, indipendente dalla classe del documento stesso.
Eventualmente al netto delle proprietà loaded, errori, warning, un po' come fa copy_from().

Per fare ciò:
- la funzione duplicate() è inutilizzabile, perché scombina totalmente PK, FK e flag. Mai usata in vita mia.

- la funzione copy_from() andrebbe bene, se non fosse per il fatto che io devo avere già dichiarato l'istanza del documento su cui eseguire la clonazione, in modo che la struttura delle proprietà corrisponda.

- perfetto, quindi devo creare tale istanza, ma non conoscendone a priori la classe, ho come unica strada "estrarre" il DNA dal documento sorgente ed utilizzarlo per creare il documento destinazione, corretto?

- il problema è che, estraendo il DNA con get_dna(), e creando poi il documento target con get_from_dna(), il framework prevede SEMPRE di caricare il documento dal database, eventualmente dalla cache: ma perchè?? io ho già un istanza caricata in memoria, voglio semplicemente averne una vergine su cui duplicare quella, perché questo metodo mi costringe a caricare qualcosa? (scartato)

- a questo punto posso prendere il nome della classe del documento originale con instanza.typeName(), passare alla funzione get_from_dna() SOLO il nome della classe, ed ecco finalmente creata la mia istanza vergine del documento, sulla quale posso finalmente usare il metodo copy_from().

-In effetti funziona... ma solo se questa procedura è definita nello stesso componente dove è dichiarata anche la classe, altrimenti la funzione get_from_dna() non trova il nome della classe nel suo scope e restituisce null....

- Quindi devo replicare questa funzione in ogni componente del mio progetto, e chiamare quella.
E finalmente porto a casa il risultato... ma non vi sembra un po' troppo astruso per una esigenza tutto sommato semplice e basilare come quella di duplicare un documento già in memoria?
Oppure sono io che non riesco a trovare un metodo più immediato? mi perdo l'uovo di colombo?
Non poteva essere una buona idea inserire un parametro "clone" nella funzione duplicate, che impedisse di modificare FK e PK e flag?

[RB_82]

Seguo interessato perché anche io ho sempre usato il copyFrom su istanze conosciute, ma potrebbe capitare...

[lucabaldini]

- la funzione duplicate() è inutilizzabile, perché scombina totalmente PK, FK e flag. Mai usata in vita mia.

La funzione duplicate serve per creare un nuovo documento copiandone le proprietà così come indicato nella doc: nuovo documento, con una propria PK, con proprie FK collegate e con flag cambiati (inserted a true, per esempio, dato che quel documento è nuovo).

Riguardo la funzione GetFromDNA, come scritto nella doc:

Tramite la funzione statica GetFromDNA è possibile creare e caricare da database istanze di documenti in maniera generalizzata, senza conoscere il tipo e le proprietà identificative.

Quindi carica da database.... a meno che non sia stata specificata la chiave, come scritto

Se la stringa passata come parametro DNA contiene solo il nome della classe, allora verrà creato il documento ma non verrà caricato dal database.

Non puoi tenere conto dei componenti nella stringa passata alla GetFromDNA? Nelle note è scritto come è composto il DNA di classi di componente...

[theguru]

Eccomi.
grazie della risposta.
avevo ben studiato le note, in effetti.
Mi è venuto ora in mente che forse potrei pulire la stringa che arriva da get_dna() della sua chiave primaria, passarla a get_from_dna() e vedere se in questo modo riesco ad ottenere una istanza pulita anche fuori dal componente dove è stata definita la classe di riferimento.

..però:
allargando un po' lo zoom su questa situazione, quello che vorrei dire è questo:
- ogni volta che uso la reflection o cerco di creare delle funzioni generalizzate, ottenere un "clone" di una determinata istanza spesso diventa una necessità fondamentale.
- avere queste procedure/funzioni in un componente base, che non è quello dove le classi son definite, è altrettanto importante
- avere una versione semplificata di duplicate(), che cloni il doc senza modificare chiavi e flag, fatta e compilata in C in modo da avere buone performance (immagina quando devo duplicare un intera collection), sarebbe grasso che cola :)

Mi chiedevo se non fosse possibile avere qualcosa del genere.

NB: per curiosità (tua o di chi abbia le stese esigenze), il risultato in un modo o nell'altro lo porto a casa, per adesso il paradigma è questo:
- nella classe base è presente un array di obj, che conterrà un istanza campione di tutte le classi del progetto
- è presente anche un IMDB che fa da indice, associando il nome della classe alla posizione nell'array
- ogni componente del'app, nell'afterload, inietta una istanza delle proprie classi nell'array e nella imdb
- a questo punto, ogni volta che ho bisogno di un nuovo doc "vergine", nel componente base, vado a prendere l'oggetto nell'array, lo "casto" ad id_document, e lo clono con get_from_dna(doc.get_dna())
- ovviamante ho automatizzato tutto con vari metodi, che per esempio mi tornano anche un document structure generalizzato, etc.

ma la sensazione di sbattermi tanto per un esigenza tutto sommato basica resta.
pensateci su :)

[d.termini]

Praticamente ti sei fatto un class factory...

[theguru]

Diciamo.
Comunque ormai uso il sistema in diversi contesti, quindi rimarebbe in piedi anche se dovesse comparire una magica funzione "clone()"

[lucabaldini]

Beh, non è una cattiva idea... e un metodo Clone della libreria IDDocument potrebba anche starci... direi che varrebbe la pena di proporre il miglioramento... così che possa essere votato anche da altri e io possa capire quanto può essere utile.

Al momento io, dovessi fare quella funzione, leggerei il DNA del documento da clonare, pulirei il DNA lasciando solo il nome della classe, e creerei una nuova copia del documento a partire dal DNA pulito. Poi farei una funzione ricorsiva di copia delle proprietà.

Ma l'idea di aggiungere un metodo Clone (che fa quel che ho appena descritto) non è malvagia... ci può stare...

[theguru]

Più che altro mi verrebbe da pensare che avendo già la funzione duplicate(), chiaramente più sofisticata, potresti ottenere il clone() "spegnendo" le funzioni di rimappatura delle chiavi.
A intuito, eh.. :)

[lucabaldini]

Beh, quello dipende da me... preferisco fare una nuova funzione per non cambiare il comportamento della duplicate. Poi, se internamente riesco a riutilizzare un po' di codice (magari con qualche parametro opzionale che da fuori non si vede), perché no...
Però penso sia utile avere una nuova funzione Clone completamente staccata dall'altra che crea un duplicato identico del documento... comprese collection e proprietà correlate.

[smuser]

-In effetti funziona... ma solo se questa procedura è definita nello stesso componente dove è dichiarata anche la classe, altrimenti la funzione get_from_dna() non trova il nome della classe nel suo scope e restituisce null....

Per risolvere il problema descritto in questo post http://forum.progamma.com/viewtopic.php?f=5&t=87089 ho trovato una soluzione che provo a descrivere.

Scenario:
- applicazione A che dipende da C1 e C2 (C1 e C2 non si conoscono)
Problema:
- C1 non vede C2 e A
- C2 non vede C1 e A

Possibilità:
A vede C1 e C2

Tradotto: se fai IDDocument.getFromDna
- da una classe di C1 per classi di C2 o A torna null
- da una classe di C2 per classi di C1 o A torna null
- da una classe di A per classi di C1 o C2 torna il DNA della classe

Soluzione:
- creo un componente base B0
- in B0 creo una classe (con class factory attivo) che chiamo DocumentLoader e che definisce il metodo seguente:

Code: Select all

// ********************************************************************************************************************************
// Given a document name find its DNA. It must be copied in the application document loader which extends this.
// IMPORTANT: Don't call "base" implementation because the component cannot load documents declared outside of the component itself
// ********************************************************************************************************************************
public string DocumentLoader.FindDNA(string docName)
{
   IDDocument doc = IDDocument.getFromDNA(docName, ...)
   return doc.getDNA()
}


- in B0 creo una variabile globale di tipo DocumentLoader che chiamo DocLoader

- A, C1 e C2 dipendono da B0

- in A creo una classe AppDocumentLoader che estende DocumentLoader e copio (ripeto copio) l'implementazione del metodo di base così com'è
- nell'initialiaze di A inizializzo DocLoader come segue:

Code: Select all

DocumentLoader.setClassName(AppDocumentLoader.className())
DocumentLoader docloader = new()
B0.DocLoader = docloader


Chiamando il metodo DocLoader.FindDNA da C1 o da C2 vedi tutto quello che vede A.

La funzione tra l'altro torna un DNA pulito (senza PK) e può essere usato per creare istanze del documento associato senza passare dal database o dalla cache.

Se hai documenti generici per trovare il nome da passare al metodo puoi fare così:

Code: Select all

IDDocumentStructure docstr = doc.getStructure()
DocLoader.FindDNA(docstr.tag)