come scrivere un sacco di piccoli unioni da C a Java

Question

Riscrivo il codice C in Java. Il nucleo del codice C originale è un wrapper HW. In C stavamo usando un sacco di unioni per ogni HW registrarsi ad esempio:

typedef union RegIntStatus 
{ 
    u8 reg; 
    struct 
    { 
     u8 bit0_abc:1; 
     u8 bit1_cde:1; 
     u8 bit2_xyz:1; 
     u8 bit3_7_rsvd:5; 
    } bits; 
} regABC; 

allora l'abbiamo utilizzato come

regABC r; 
r.reg=0 
r.bits.bit0_abc=1; 
call(r.reg) 

immaginare v'è abbondanza di questi registri. Diciamo 40. Come implementarlo in java non avendo 40 file di classe? Stavo pensando di creare una classe come

univerasl_reg<T> { // where T will be some "enum" 
    public byte b; 
    public byte set(T bit_mask,bool val) { 
    // here is compile error it does not know variable bit_mask.v 
    if(val) {b |= bit_mask.v}  
    else b &= bit_mask.v^0xFF; 
    } 
} 

quindi un file può contenere più enumerazioni come:

public static enum RegTst{ 
     b1_abc(0x01), 
     b2_xyz(0x02), 
     b3_klm(0x04); 
     public byte v; 
     RegTst(int val){ 
      v = (byte)val; 
     } 
    } 

quindi vorrei utilizzarlo come:

univerasl_reg<RegTst> rt1; 
rt1.set(RegTst.b2_xyz,1) 
call(rt1.b) 

Ma non funziona perché sembra che non possa usare enum variable .v in univerasl_reg. Produce "Java canot trovare simbolo v". Sai perché? Sai come codice registri in modo da avere
- preferibilmente un file
- controllo di tipo tra i diversi registri (ad esempio

new univerasl_reg<RegTst>.set(RegTst_OTHER.b2_xyz,1)

deve portare ad errori come io non sto usando RegTst ma RegTst_OTHER)
- e mnemonico per bit (ad esempio RegTst.b1_abc)

Answer 1

Java I generici sono una caratteristica del solo sistema di tipo statico. Quando si accetta qualsiasi T per il parametro type, il sistema di tipo statico non ha basi per concludere che questo tipo abbia una variabile di istanza v. La tua scelta di enigmi complica ulteriormente le cose perché le enumerazioni non possono avere una superclasse arbitraria.

vorrei suggerire quanto segue:

1. contare su polimorfismo e nascondere v dietro un metodo;
2. dichiarare un'interfaccia con questo metodo;
3. fare in modo che tutte le enumerazioni implementino l'interfaccia;
4. utilizzare l'interfaccia come limite superiore su T.

in codice:

public interface Mask { 
    byte v(); 
} 

public class UniversalReg<T extends Mask> { 
    public byte b; 
    public byte set(T mask, boolean val) { 
    if (val) b |= mask.v(); 
    else b &= ~mask.v(); 
    } 
} 

public enum RegTst implements Mask { 
    b1_abc(0x01), 
    b2_xyz(0x02), 
    b3_klm(0x04); 

    private final byte v; 
    private RegTst(int val) { 
     v = (byte)val; 
    } 

    @Override public byte v() { return v; } 
}