J'aimerais faire l'équivalent de ce qu'on peut faire avec des unions en c++ mais en java
Cependant mon java est visiblement plus que rouillé et je ne trouve pas la meilleur façon de faire un équivalent en java de ce genre de chose :
typedef struct {
union {
struct {
int16_t x;
int16_t y;
};
int16_t coordonnees[2];
uint8_t bytes[4];
};
} Point;
Grâce à l'union si je fais
Point monPoint = { 0,0};
je peux aussi faire des truc du genre
monPoint.x = 1; // change le 0 en 1
monPoint.coordonnees[0] = 2; // change le monPoint.x =1 en 2 ...
Exemple de ma classe équivalent en java
class Point {
public short x; // 2 octets
public short y; // 2 octets
public Point(int x, int y) {
this.x = (short)x;
this.y = (short)y;
}
}
J'aimerais trouver le moyen de la modifier ajouter des "vues" en "bytes" et "coordonnées " pour pouvoir faire des truc du genre :
Point monPoint = new Point(0,0); monPoint.coords[0]=1; // change monPoint.x de 0 à 1 équivaut à monPoint.x =1 et on peut aussi lire monPoint.bytes[0] = 0 et monPoint.bytes[1] = 1 ...
le but étant de pouvoir indépendamment remplir et lire aussi bien en bytes en coordonnées ou bien en x et en y ...
L'idéal étant de pouvoir directement me reposer sur la structure mémoire comme je le fais avec les union en C de manière à ne pas avoir à utiliser des méthodes spécifique à chaque fois et ou à dédoubler les variables ...
Bref quelqu'un aurait il quelque chose de plus élégant à proposer que ça :
class Point {
public short x;
public short y;
public short [] coords = new short[2];
public byte [] bytes = new byte[4];
public Point(int x, int y) {
updateFromXY( x, y);
}
public Point(byte xl, byte xh, byte yl, byte yh) {
this.updateFromBytes(xl, xh, yl, yh);
}
public void coords(int n, int val) {
this.coords[n]=(short)val;
updateFromXY(this.coords[0] , this.coords[1]);
}
public void x(int val) {
this.x=(short)val;
updateFromXY(this.x , this.y);
}
public void y(int val) {
this.y=(short)val;
updateFromXY(this.x , this.y);
}
public void bytes(int n, int val) {
this.bytes[n]=(byte)val;
updateFromBytes(this.bytes[0], this.bytes[1], this.bytes[2], this.bytes[3]);
}
private void updateFromXY(int x, int y) {
this.x = (short)x;
this.y = (short)y;
this.coords[0] = this.x;
this.coords[1] = this.y;
this.bytes[0] = (byte)(x & 255);
this.bytes[1] = (byte)(x >> 8);
this.bytes[2] = (byte)(y & 255);
this.bytes[3] = (byte)(y >> 8);
}
private void updateFromBytes(byte xl, byte xh, byte yl, byte yh) {
this.bytes[0] = xl;
this.bytes[1] = xh;
this.bytes[2] = yl;
this.bytes[3] = yh;
int x = xh << 8 + xl;
int y = yh << 8 + yl;
this.x = (short)x;
this.y = (short)y;
this.coords[0] = this.x;
this.coords[1] = this.y;
}
}
car dans l'exemple ci dessus, je "triple l'usage mémoire" et pour " écrire les valeurs je dois passer par des méthodes qui mettent à jour les autres variables ...
à l'usage ça me donne un truc du genre :
Point monPoint = new Point(0,0); monPoint.coords(0,1); // Met la coordonnées 0 = x à 1 /* monPoint.coords[0] ( pour lire la valeur de x la coordonnée 0 qui vaut 1 ... ) monPoint.byte[1] ( pour lire l'octet de poids faible de x et qui vaut 1 , */ monPoint.x(2); // Met x à 2
Grosso modo avec cette solution bien que je ne trouve pas ça super élégante, mon cahier des charges est bien respecté en terme d'usage... Mais je me demande quand même si il y a pas moyen de faire " plus élégants sans la redondance mémoire " et l'usage de code "d'update " , "plus automatique " ... et donc aussi plus " rapide à exécuter "...
En javascrypt pour faire ce genre de chose j'ai utilisé des arrayBuffer ...
class Point {
constructor(x,y) {
this.arrayBuffer = new ArrayBuffer(4);
this.x = new Int16Array(this.arrayBuffer, 0, 1);
this.y = new Int16Array(this.arrayBuffer, 1, 1);
this.coords = new Int16Array(this.arrayBuffer, 0, 2);
this.bytes = new Uint8Array(this.arrayBuffer);
this.coords[0]=x; // équivaut à faire this.x[0] = x;
this.coords[1]=y; // et this.y[0] = y;
}
}
à l'écriture de la classe c'est "un petit peu lourd " car on utilise des tableaux même quand on a un seul élément et donc à chaque fois il faut spécifier le [0] dans ce cas notamment avec .x[0] et .y[0] ... mais mis à part ce point de détails, les performances et les fonctionnalités sont bien là, sans redondance mémoire, ni fonction d'update ... Y a t il un équivalent des arrayBuffer et de leur " vue typé" en java ?
...
