Newsgroup: it.comp.lang.delphi
Titolo: Salvare variabili di tipo set of... nel registro miglior metodo.

Allora devo salvare delle variabile di tipo set of tipo (spero si
capisca di cosa sto parlando)
per ora le salvo io a mano convertendole in booleani opzione1:=
soopzione1 in variabileset;
e cio inplica che se viene aggiunto in questo set una nuova variabile
devo aggiornare il codice.
Esiste un metodo migliore?
Ogni suggerimento e' ben accetto
Ciao
-- 
.     _  _______  ļ,ø*°`°*ø,ļ_ļ,ø*°`°*ø,ļ_ļ,ø*°`°*ø,ļ_ļ,ø*°`°*ø,ļ_
  /| // /__  __/  Kirys <Remove DELTHIS from the address to reply>
 / |/ \   / /     Kirys Tech 2000: 
http://www.kt2k.com
/__|\__\ /_/ 2000 ļ,ø*°`°*ø,ļ_ļ,ø*°`°*ø,ļ_ļ,ø*°`°*ø,ļ_ļ,ø*°`°*ø,ļ_

 devo aggiornare il codice.
E se invece di salvare valori booleani ti salvi l'intera variabile e poi la 
ricarichi esattamente pari pari?
Cioč una cosa del tipo:
Type TOrdinal = (obello, obrutto, ocattivo);
Type TOrdinalSet = set of TOrdinal;
Type POrdinalSet = ^TOrdinalSet;
Var Laforgia : TOrdinalSet; // ogni riferimento a fatti ecc. :PP
Var valore : Cardinal;
  Laforgia := [obrutto, ocattivo];
  valore := PCardinal(@Laforgia)^;
// e scrivi il valore nella configurazione... 
// viceversa quando devi caricarlo, lo carichi come Cardinal (dword)
// e lo typecasti nuovamente:
  Laforgia := POrdinalSet (@valore)^;
Spero di esserti stato utile, 
Ciao!
Davide DG.
-- 
All resistance is futile! Prepare to be disassembled !

Carino, io lo riscriverei cosi' ;)
type MyEnum = (oBello, oAffascinante, oIntelligente);
     MySet = set of MyEnum;
procedure TForm1.Button1Click(Sender: TObject);
var
  DavideDG: MySet;
  MyCardinal: Cardinal;
begin
  DavideDG := [oBello, oAffascinante];
  MyCardinal := Cardinal(Pointer(@DavideDG)^);
  ShowMessageFmt('%d', [MyCardinal]);
end;
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

ricarichi esattamente pari pari?
ma cosa accade se quando ho salvato avevo:
Type TOrdinal = (obello, obrutto, ocattivo);
Type TOrdinalSet = set of TOrdinal;
mentre quando carico ho
Type TOrdinal = (obello, obrutto, ocattivo,oaltro);
Type TOrdinalSet = set of TOrdinal;
oppure
Type TOrdinal = (obello, obrutto);
Type TOrdinalSet = set of TOrdinal;
??????


 Type TOrdinalSet = set of TOrdinal;
Puoi farlo, tenendo presente però che i due tipi sono 0-based a partire dal 
primo elemento, quindi non puoi definire TOrdinalSet_new come set di
TOrdinal_new = (ociao, obau, o1, o2, o4, o3, o12, o41)
Cioè l'ampliamento o la riduzione dei valori possibili è valida (e comoda) 
solamente se effetuata alla destra (al limite superiore).
Se hai salvato [obello, obrutto, ocattivo] e carichi in una variabile che 
possa contenere anche oaltro, questa variabile semplicemente non conterrà 
oaltro.
Per l'altro caso (la riduzione), pensa ad una situazione di questo tipo:
type TOrdinal_old = (o0__old, o1__old, o2__old, o3__old);
type TOrdinal_new = (o0, o1, o2);
type TOrdinalSet_new = Set Of TOrdinal_new;
type TOrdinalSet_old = Set Of TOrdinal_old;
var old : TOrdinalSet_old;
var new : TOrdinalSet_new;
old := [o0__old, o1__old, o2__old, o3__old];
// Ora, se vuoi passare a new i valori in comune con old, cioè:
{in pseudocodice} new := old; // quindi new = [o0, o1, o2]
puoi fare in 2 modi: uno "pulito" e uno "veloce"
Quello veloce è un semplice typecasting...:
  new := TOrdinalSet_new(old);
Ma se poi vai a vedere col debugger... ti dà un (out of bounds) sul valore di 
new .
Il metodo pulito è quello di tagliar fuori con un AND i valori non ammessi:
PCardinal(@new)^ := // una linea
 (2 shl cardinal(high(TOrdinal_new)) -1) AND PCardinal(@old)^;
Ok, spero di non averti fatto confusione!
Ciao!!


 Type TOrdinal = (obello, obrutto);
L'ampliamento del set di partenza non produce problemi,
a meno di non aggiungere a sinistra.
Nel caso che citi, obello vale 1, obrutto vale 2, 
ocattivo vale 4.  Quindi, un eventuale [obello, ocattivo]
corrisponderebbe a 5.  Ora, anche aggiungendo oaltro al
set di partenza (che assumerebbe, quindi, valore 8),
l'insieme [obello, ocattivo] non cambierebbe valore.
Viceversa, aggiungendo oaltro prima di obello, avresti
lo slittamento dei valori del set di partenza e quindi
[obello, ocattivo] varrebbe esattamente il doppio.
bello = 1, brutto = 2, cattivo = 4
[bello, cattivo] = 5
bello = 1, brutto = 2, cattivo = 4, altro = 8
[bello, cattivo] = 5
altro = 1, bello = 2, brutto = 4, cattivo = 8
[bello, cattivo] = 10
Il caso della riduzione e' sempre soggetto alla regola
che bisogna eliminare gli elementi alla destra, perche'
i vecchi conservino il valore corretto.
Se e' cosi', allora calcoli il valore relativo all'insieme
comprendente tutti gli elementi e lo metti a AND con il
valore che hai letto, in modo da "tagliare fuori", quegli
elementi non + presenti nel set di partenza.


Ok, spero di non averti fatto confusione!
siete stati entrabi chiarissimi.
E dovro comunque usare il metodo iniziale, questo per quanto sia +
compatto e veloce e' limitato dal fatto che le nuove opzioni deveno
stare a destra.
Ovviamente usero il metodo da voi descritto per progetti di cui io
gestisca tutto :D (o quantomeno il seT)
X me andrebbe benissimo ma aimeh quella parte del codice non e'
gestita direttamente da me e quindi non posso essere certo che tale
ordine venga mantenuto (anzi di recente i componenti sono stati
ordinati alfabeticamente figuratevi).
Vi rigrazio nuovamente entrambi.
Ciao


 E dovro comunque usare il metodo iniziale, 
E fai bene, a mio avviso.
