Discussion :

[cilies38]

Bonjour tout le monde,

Voici un code qui prend un nombre long et et le fragmente par couple de 7 bits
et place ces 7 bits dans des payloads avec le bit (continue) tout à gauche dans un octet qui commence par 1
sauf le dernier qui commence par 0. Mais je ne comprends pas bien le code.

• (max << 7) |0x7fL >> décale de 7 bits vers la gauche mais le reste ???
  
  >>> décale de x bits à droite en insérant des 0 à gauche
  mais je ne comprends pas bien ce que fait value >>> (i*7) ??
  
  (int)((temp | 0x80) & 0xff) je ne comprends pas non plus 0x80 et 0xff quel est l'effet ??...
  
  Pouvez vous m'aider à comprendre le code merci.
  

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
 static private final int SHORT_INTEGER_MAX = 127;
 
protected void appendUintvarInteger(long value, DataOutputStream f) {
        /*
         * To encode a large unsigned integer, split it into 7-bit fragments
         * and place them in the payloads of multiple octets. The most significant
         * bits are placed in the first octets with the least significant bits
         * ending up in the last octet. All octets MUST set the Continue bit to 1
         * except the last octet, which MUST set the Continue bit to 0.
         */
        int i;
        long max = SHORT_INTEGER_MAX;
        for (i = 0; i < 5; i++) {
            if (value < max) {
                break;
            }
            max = (max << 7) | 0x7fl;
        }
        while(i > 0) {
            long temp = value >>> (i * 7);
            temp = temp & 0x7f;
            append((int)((temp | 0x80) & 0xff), f);
            i--;
        }
        append((int)(value & 0x7f), f);
    }

[dinobogan]

mais je ne comprends pas bien ce que fait value >>> (i*7) ??

Il y aura un décalage d'un nombre multiple de 7 à chaque tour de boucle.
Si i=1, alors il y aura un décalage de 7 bits vers la droite.
Si i=2, alors il y aura un décalage de 14 bits vers la droite.
Si i=3, ...

(int)((temp | 0x80) & 0xff) je ne comprends pas non plus 0x80 et 0xff quel est l'effet ??...

Les parenthèses sont prioritaires. Donc :

1. temp | 0x80 : OU binaire. 0x80 vaut 80 en hexadécimal, donc 1000 0000 en binaire. Cela permet "d'allumer" le 8eme bit en partant de la droite (le moins significatif).
2. valeur & 0xff : ET binaire. 0xff vaut 1111 1111 en binaire. Tous les autres bits de "valeur" seront mis à zéro. Seul les 8 premiers bits (en partant de la droite, les moins significatifs) conserveront leur valeur.

[cilies38]

Ok et 0x7f permet de mettre 0 au premier bit en partant de la gauche du premier octet. Merci c'est déjà plus clair.