dichiarazione di interi

[citino@tin.it]

Ciao a tutti,
Sto cercando di integrare un framework di persistenza dati scritto da un'azienda delle mie parti con un progetto GWT. Il framework di per sé è scritto bene ma in certe parti si presenta in maniera oscura. Ad esempio è in grado di restituire al lato client utte le informazioni che servono per costruire dinamicamente una tabella, un form di ricerca a partire dal particolare oggetto con cui si vuole interagire.
Però la possibilità per un determinato campo di ricerca di un form di essere o meno listable, mandatory, visible etc, anziché essere espressa con un boolean è espressa nel seguente modo

public static final int MANDATORY = 0x01;
public static final int LISTABLE = 0x02;
public static final int ONLY_INSERT = 0x04;
public static final int EDIT = 0x08;
public static final int VISIBLE = 0x10;
public static final int STORICO = 0x20;
public static final int IS_DEFAULT = 0x40;
public static final int MULTIVALUE = 0x80;
public static final int IDX_INDEXED = 0x100;
public static final int IDX_TOKENIZED = 0x200;
public static final int IDX_STORE = 0x400;
public static final int IDX_IS_STOP_WORD = 0x800;
public static final int OPTIONAL_FIELD = 0x1000;
public static final int USER_FLAG1 = 0x2000;
public static final int USER_FLAG2 = 0x4000;
public static final int KEY_FIELD = 0xf0000000; //ca

purtroppo non riesco a capire questo dichiarazione di intero cosa significhi.

Grazie a tutti,
Alessandro

[Ed_Bunker]

Non sono una sorta di macro definite in ottale ?

P.S.: serviranno mica per andare ad indirizzare la mem ?!?

[LeleFT]

Significa che c'è un intero (che non è costruito a caso, se osservi i valori espressi in esadecimale) che viene utilizzato come una mappa di bit.

Sommando i vari interi si ottiene un intero che rappresenta tutte le opzioni che sono state attivate.

Facciamo un esempio semplice, con un intero su 8 bit (invece di un intero su 32 bit come Java):

int lettura = 0x01;     binario: 00000001
int scrittura = 0x02;   binario: 00000010
int esecuzione = 0x04;  binario: 00000100
...

Se voglio assegnare sia l'opzione di lettura che quella di esecuzione andrò a valorizzare un campo in questo modo:

in campo = lettura + esecuzione;

Il campo assumerà il valore 5, che in binario si traduce: 00000101

Come puoi vedere, sono accesi il bit 0 ed il bit 2. Da qualche parte si effettuerà un controllo:

if ((campo & lettura) > 0) {
   // proprietà di lettura attivata
}
if ((campo & scrittura) > 0) {
   // proprietà di scrittura attivata
}
if ((campo & esecuzione) > 0) {
   // proprietà di esecuzione attivata
}

Il giochino si fa con la mappa di bit, quindi utilizzando le operazioni bit a bit per verificare se il singolo bit è attivo o meno.


Ciao.

[citino@tin.it]

Grazie mille, mi sembra di aver capito grosso modo. Ancora due domande se possibile:
1) non è meglio una serie di campi booleani?
2) perché la serie è così costruita:
0x01
0x02
0x04
0x08
0x10
0x20
0x40
0x80
0x100
0x200
0x400
0x800
0x1000
0x2000
0x4000
...

non mi sembrano potenze di 2... quale è la logica che ci sta dietro?

grazie

[citino@tin.it]

Altra domanda, perdonami mi è scappata prima:

int competenze = lettura + scrittura equivale a int competenze = lettura | scrittura?

perché nel framework il default dei valori dell'attributo è indicato così.

Ciao Grazie

[andbin]

Originariamente inviato da citino@tin.it
1) non è meglio una serie di campi booleani?

No ... non ti è chiaro. Quelle che hai postato sono delle costanti che definiscono dei bit-field, in questo caso field di 1 bit ognuno. Queste costanti possono essere messe in OR (ed è in genere l'obiettivo finale, cioè poter specificare più "flag" messi insieme), ad esempio:

int val = EDIT | VISIBLE;

2) perché la serie è così costruita:
0x01
0x02
0x04
0x08

non mi sembrano potenze di 2... quale è la logica che ci sta dietro?

Ogni costante ha 1 solo bit a 1. 0x01 ha bit 0 alto, 0x02 ha il bit 1 alto, 0x04 ha il bit 2 alto ecc...

Nota il corrispondente binario a destra:

0x01      0......000001
0x02      0......000010
0x04      0......000100
0x08      0......001000
...

Originariamente inviato da citino@tin.it
int competenze = lettura + scrittura equivale a int competenze = lettura | scrittura?

Se non ci sono bit a 1 nella stessa posizione per entrambi, sì, sono la stessa cosa.