esperimenti con TNullable

[nomorelogic]

ciao a tutti

relativamente all'articolo sui TNullable sul blog https://blog.lazaruspascal.it/2021/12/27/tnullable/
sto facendo degli esperimenti

se qualcuno è interessato sto cercando di capire come determinare il tipo di specializzazione a partire da un puntatore non tipizzato
qualcosa di simile all'operatore is delle classi ma applicato agli advanced records
penso che l'unico modo sarà quello di accedere alle info RTTI ma spero in qualcosa di meglio

ho postato sul forum ufficiale
https://forum.lazarus.freepascal.org/index.php?topic=57814.msg430213#msg430213

[DragoRosso]

Perchè usi il new e il dispose ?

Non puoi semplicemente lasciare che il compilatore lavori per te usando il record (classe) e non il puntatore.

Se ti serve un puntatore lo referenzi con la variabile ....

In questo modo non ti serve ne costruirlo ne distruggerlo ...

Ciao

[nomorelogic]

Sto cercando di realizzare una specie di classe per gestire una "memory space".
In pratica ho una hash list dove vado a memorizzare specializzazioni di TNullable di stringhe, interi, double, ecc...
(Questo mi serve perché non so quali valori arriveranno ed in quale sequenza)

Poi arriva il momento della Dispose, in quel momento la Dispose ha bisogno del puntatore tipizzato.

Edit:
in fondo è come se in una hash list memorizzassi a caso interi, stringhe e double.
Qualcuno farebbe una hash per tipo, io ho bisogno di una unica hash.

[DragoRosso]

Quindi, in pratica, a differenza del codice che hai postato, tu userai la variabile nullint (e le altre tipizzate) per creare il contenitore, assegni il contenitore ad una lista e continui così.

Di fatto l'unica referenza di tutti i contenitori (TNullable) che avrai creato sarà nella lista, non contando nullint che verrà "sovrascritta" ogni volta.....

Hai due problemi di referenza, non solo quando fai la dispose ma anche quando estrai dalla lista l'oggetto devi conoscere la tipizzazione (TNullString, TNullInteger), se no come fai a sapere cosa ci hai messo dentro ?

Secondo me, potrebbe essere interessante inserire in TNullable (ovviamente riscrivendolo) una proprietà con la sua tipizzazione. In questo modo non usi le RTTI.

Non vedo altro modo per fare ciò che chiedi ...

Ciao.

[nomorelogic]

in effetti è così, quando estraggo il valore, so già di che tipo si tratta
è come quando hai un integer: sai che è un integer!

per questo avrò una proprietà per ogni tipo, ad esempio:

Codice: [Seleziona]

     property Integers[AName : String] : TMaizAssignable_Integer Read GetIntegers Write SetIntegers;
     property Strings[AName : String] : TMaizAssignable_String read GetStrings write SetStrings;

in questo modo posso cercare nella hash list (che è unica per tutti i tipi di valori) e poi assegnare il tipo giusto nel Getter

è una alternativa a creare un tipo record statico, ad esempio, per ogni tabella di un database
io ho diverse tabelle che superano i 100 campi...
avrei potuto generare i tipi record ma ho bisogno di adattarmi a qualunque tipo di tabella senza conoscerne la definizione
così perdo un po' in prestazioni (ma poco) ma ci guadagno in dinamismo


Edit:
TMaizAssignable è una mia versione di TNullable

[DragoRosso]

in effetti è così, quando estraggo il valore, so già di che tipo si tratta
è come quando hai un integer: sai che è un integer!

Bhè, si è no ..... quando tu scrivi:

Codice: [Seleziona]

WriteLn('one = ', PNullString(HashList.Find('one'))^.Value);

istruisci al compilatore a fare una cosa ben precisa ... deferenzi in maniera rigida una "risposta" il cui risultato non è noto al compilatore (il riferimento di "HashList.Find('one'))^.Value" non può esserti noto a priori in generale).

Lo sarebbe se tu avessi un qualcosa del tipo: "HashList.Find('one'))^.ValueString" o "HashList.Find('one'))^.ValueInteger" ad esempio.

Inoltre, per l'uso delle RTTI dovresti comunque implementare nel codice del TNullable un qualcosa.

In generale, vorrei ricordare che ereditarietà, interfacce e altro con i record non si possono usare.

Ciao

EDIT: giusto per essere più chiaro, il tuo chiamamolo cast PNullString(...) non è dinamico, ma statico. Il compilatore sia aspetta di trovare quella referenza. Quindi in generale và bene avere il gettere e il setter, ma non è sufficiente. Se devi leggere un tipo di valore generico, non puoi aspettarti un tipo di valore noto, a meno che non istruisci il "getter" a darti quel tipo preciso di valore (ad esempio come fanno gli HELPER .toString .toInteger .... etc) ....   

[nomorelogic]

istruisci al compilatore a fare una cosa ben precisa ...

infatti: so già che cosa mi torna indietro e va bene così


il codice sotto

Codice: [Seleziona]

var i: integer
begin
  i := 5;
  writeln('intero I =', i);
end;

voglio scriverlo così

Codice: [Seleziona]

var ms: TMemoryspace;
begin
  ms:=TMemoryspace.Create;
  ms.Integers['i'] := 5;
  writeln('intero I =',ms.Integers['i']);
  ms.Free;
end;

solo che in più ho gestiti anche i valori null

[DragoRosso]

Lol .... ma se sai cosa ti torna, allora sai anche come "distruggerlo" .....

 

[nomorelogic]

fai conto che devo memorizzare tutte le colonne di un record di una query: scorro la proprietà FieldDefs del ClientDataset

però da quello che mi rispondono sul forum ufficiale, dovrò farlo comunque di salvarmi il tipo...

[DragoRosso]

@nomorelogic,
ho visto la modifica che hai proposto nel codice presentato nel forum ufficiale.

E ho visto che hai usato FREEMEM su un "oggetto" creato con NEW.

Guarda che l'uso di FREEMEM al posto del DISPOSE su oggetti creati con NEW è assolutamente sconsigliata. E' storica questa cosa, e non penso sia mai stata sanata la differenza, differenza che non conosco nei dettagli (dai sorgenti non è così scontato riuscire a seguire tutti i rami).

E anche se le prove che fai magari ti riportano un esito positivo, non è assolutamente detto che ciò possa perdurare in tutte le condizioni.

Un'altra cosa che mi "prude" nell'uso dei puntatori così diretti, in particolare con record complessi, è il pericolo del "ref on copy" e del "dup on copy", ossia che a runtime generalmente si crea semplicemente un riferimento allo stesso puntatore quando si copia "qualcosa", ma può anche effettuarsi un duplicato dell'oggetto, con un puntatore, allocazioni ed altro diverse dall'originale nel caso si modifichi una delle copie. Ma questa è una mia paturnia.

Ciao

[nomorelogic]

Riguardo l'uso di FreeMem al posto di Dispose non l'ho proposto io. Lo ha proposto engkin ed io ho provato per vedere che succedeva  perché neanche io pensavo fosse possibile ed ho voluto vedere.
Però di basare il codice su questa forzatura non mi piace, infatti seguirò il consiglio di PascalDragon che è quello di memorizzare il tipo per poi fare una Rispose mirata.

Riguardo agli effetti collaterali nell'uso dei puntatori, spero di scrivere codice non buggato, del resto i puntatori esistono e in questo caso ho bisogno di velocità... 😊

[DragoRosso]

.....
Però di basare il codice su questa forzatura non mi piace, infatti seguirò il consiglio di PascalDragon che è quello di memorizzare il tipo per poi fare una Rispose mirata.
.....

....
Secondo me, potrebbe essere interessante inserire in TNullable (ovviamente riscrivendolo) una proprietà con la sua tipizzazione. In questo modo non usi le RTTI.
....

E certo che la "pesantezza delle affermazioni" di un membro INTERNAZIONALE si fà sentire ...... sigh

 

[DragoRosso]

Stò costruendo un TNullable che associa anche il NULL, consentendo l'assegnazione diretta nei due sensi ....

@nomorelogic, sò già che non ti piacerà .... ma consente l'assegnazione mantenendo comunque la logica di un NULLABLE.

Ciao

[nomorelogic]

.....
Però di basare il codice su questa forzatura non mi piace, infatti seguirò il consiglio di PascalDragon che è quello di memorizzare il tipo per poi fare una Rispose mirata.
.....

....
Secondo me, potrebbe essere interessante inserire in TNullable (ovviamente riscrivendolo) una proprietà con la sua tipizzazione. In questo modo non usi le RTTI.
....

E certo che la "pesantezza delle affermazioni" di un membro INTERNAZIONALE si fà sentire ...... sigh

 

giusto per fugare i dubbi... 
me ne sono accorto che era lo stesso consiglio ed infatti ho dato la stessa risposta (nel senso che per l'uso dei valori non ne avevo bisogno) con un bel copia/incolla/traduci da questo thread

onestamente pensavo che almeno con rtti si potesse fare qualcosa, anche se non sapevo ancora come; e lo avrei preferito
nel senso che memorizzare il tipo avrei voluto evitarlo per tenere il codice il più snello possibile

poi se uno come PascalDragon ti dice che sei in un vicolo cieco... tocca trovare una strada diversa
anche perchè, la FreeMem al posto della Dispose... la pensiamo allo stesso modo e non voglio farla (anche se devo ammettere che mi ha fatto venire un'idea, ma non è questo il momento)

[nomorelogic]

Stò costruendo un TNullable che associa anche il NULL, consentendo l'assegnazione diretta nei due sensi ....

@nomorelogic, sò già che non ti piacerà .... ma consente l'assegnazione mantenendo comunque la logica di un NULLABLE.

suppongo che abbia a che fare con i variant quindi

cmq, lo ammetto, sono curioso