Packed Encoding Rules

Principe utilisé par Up ! Abstract Syntax Notation One

Contraintes générant une optimisation

En Basic Encoding Rules (BER), le triplet (Préambule, Taille, Valeur) est irréductible. En Packed Encoding Rules (PER), chaque composante peut être optionnelle, étant donné que de part la contrainte le type, la taille ou la valeur peut être déduit.

BIT STRING

• Taille.
  Par exemple : MaValeur BIT STRING (SIZE(1..256)) ::= '01'B.
• Valeur seule.
  Par exemple : MaValeur BIT STRING ('01'H) ::= '01'B.

IA5String

• Alphabet.
  Par exemple : MaValeur IA5String (FROM(A"..Z")) ::= COUCOU".
• Inclusion.
  Par exemple :
  MonType1 ::= IA5String (A"|B"|C"|D"|E")
MonType2 ::= IA5String (B"|C")
MaValeur ::= MonType2(MonType1)
• Taille.
  Par exemple : MaValeur IA5String (SIZE(1..256)) ::= coucou".

Ces optimisations s'appliquent aux types BMPString, IA5String, ISO646String, NumericString, PrintableString, UniversalString et VisibleString.

Ces optimisations ne s'appliquent pas aux types GeneralizedTime, ObjectDescriptor ou UTCTime.

CHARACTER STRING

• Restriction de la sémantique.
  Par l'usage de WITH COMPONENTS.

EMBEDDED-PDV

• Restriction de la sémantique.
  Par l'usage de WITH COMPONENTS.

INTEGER

• Inclusion.
  Par exemple :
  MonType1 ::= INTEGER (1|2|3|4|5)
MonType2 ::= INTEGER (2|3)
MaValeur ::= MonType2(MonType1)
• Intervalle.
  Par exemple : MaValeur INTEGER (1..10) ::= 2.
• Valeur seule.
  Par exemple : MaValeur INTEGER (1) ::= 1.

OCTET STRING

• Taille.
  Par exemple : MaValeur OCTET STRING (SIZE(1..256)) ::= '01'H.

SEQUENCE OF

• Taille.
  Par exemple : MaValeur SEQUENCE OF IA5String (SIZE(1..256)) ::= {coucou"}.

SET OF

• Taille.
  Par exemple : MaValeur SET OF IA5String (SIZE(1..256)) ::= {coucou"}.

Combinaison de contraintes

Par exemple :

• BIT STRING
  Par exemple : MaValeur BIT STRING (SIZE(1..256)|('01'H|'02'H|'01'H)) ::= '01'H.
• IA5String
  Par exemple : MaValeur IA5String (SIZE(1..256)|FROM(A"..Z")) ::= COUCOU".
• INTEGER
  Par exemple : MaValeur INTEGER (1..10)(2..20) ::= 2.
• OCTET STRING
  Par exemple : MaValeur OCTET STRING (SIZE(1..256)|('01'H|'02'H|'01'H)) ::= '01'H.
• SEQUENCE OF
  Par exemple : MaValeur SEQUENCE OF IA5String (SIZE(1..256)|FROM(A"..Z")) ::= {COUCOU"}.
• SET OF
  Par exemple : MaValeur SET OF IA5String (SIZE(1..256)|FROM(A"..Z")) ::= {COUCOU"}.

L'encodeur et le décodeur Packed Encoding Rules (PER) doivent donc calculer l'intervalle au plus juste en taille et en valeur des types de données et combiner ces intervalles en fonction des opérateurs utilisés dans les contraintes complexes.

Extension

De ce fait, toutes les contraintes visibles extensibles et non étendues sont donc aussi optimisables. Par exemple :

• BIT STRING
  Par exemple : MaValeur BIT STRING ('01'H|'02'H|'01'H, ...) ::= '01'H.
• IA5String
  Par exemple : MaValeur IA5String (A"|B"|C"|D"|E", ...) ::= A".
• INTEGER
  Par exemple : MaValeur INTEGER (1..10, ...) ::= 2.
• OCTET STRING
  Par exemple : MaValeur OCTET STRING ('01'H|'02'H|'01'H, ...) ::= '01'H.
• SEQUENCE OF
  Par exemple : MaValeur SEQUENCE OF IA5String (A"|B"|C"|D"|E", ...) ::= {A"} .
• SET OF
  Par exemple : MaValeur SET OF IA5String (A"|B"|C"|D"|E", ...) ::= {A"}.

Algorithme d'encodage générique à tous les types

Encodage d'une valeur entière

• Composant Taille du triplet (Préambule, Taille, Valeur).
  A la différence du standard Basic Encoding Rules (BER), l'unité de la taille est :

  Type de données.	Unité de compte.
  BIT STRING	Bit.
  OCTET STRING	Octet.
  Chaîne de caractères	1,2 ou 4 octets selon la page de codes.
  SEQUENCE OF	Nombre d'objets.
  SET OF	Nombre d'objets.
  Autres	Octet.

• Composant Valeur du triplet (Préambule, Taille, Valeur) pour le type INTEGER dans un intervalle.

Il y a trois cas de figure pour l'intervalle de valeurs :

• [BorneMin, BorneMax].
• [BorneMin, +Infini].
• [-Infini, BorneMax].
• [-Infini, +Infini].

Par lisibilité de ce document, l'encodage de la valeur entière correspond à la fonction :
/*******************************************************************/
Fonction EncoderEntierPer(E : Entier) Retourner Nul Ou Caractere
/* Objet : Encode le nombre entier positif ou nul E sous forme d'une chaîne de bits. */
/*******************************************************************/
...
Fin Fonction


Valeur appartenant à [BorneMin, BorneMax]

Voici le codage d'une telle valeur :

• Si Borne==1, aucun codage.
• Si Borne>=2 Et Borne<=255 alors la valeur translatée est écrite sur le nombre de bits minimal nécessaire sans coder la taille et sans alignement sur un octet.
  Par exemple MaValeur INTEGER(1..10)=3 nécessite 4 bits et se code 0011.
• Si Borne==256 alors la valeur translatée est écrite sur un octet sans coder la taille et avec alignement sur un octet.
  Par exemple 256 se code 0xFF.
• Si Borne>=257 Et Borne<=65536 alors la valeur translatée est écrite sur deux octets sans coder la taille et avec alignement sur un octet.
  Par exemple 259 se code 0x01 0x03.
• Si Borne>=65537 alors :
  • Pour une valeur correspondant à une taille.
    La fonction suivante est appelée pour la valeur translatée :
    /*******************************************************************/
    Fonction EncoderEntierAutreQueTaillePer(E : Entier) Retourner Nul Ou Caractere
    /* Objet : Encode le nombre entier positif ou nul E sous forme d'une chaîne de bits. */
    /*******************************************************************/
    Variable
    Resultat : Nul Ou Caractere; E1 : Entier;
    E2 : Entier;
    
    
    Debut
    Resultat=";
    E1=E/16384;
    E2=E%16384;
    TantQue E1>0 Faire
    Selon E1 Faire
    Cas Pour 1 Faire
    Resultat+=11000001"; E1-=4;
    Fin Cas
    
    Cas Pour 2 Faire
    Resultat+=11000010"; E1-=4;
    Fin Cas
    
    Cas Pour 3 Faire
    Resultat+=11000011"; E1-=4;
    Fin Cas
    
    Default
    Resultat+=11000100"; E1-=4;
    Fin Default
    
    Fin Selon
    Fin TantQue
    Si E2<=127 Alors
    Resultat+=0"+Binaire(E2,6);
    Sinon
    Resultat+=10"+Binaire(E2,14);
    Retourner Resultat;
    Fin Fonction
    Par exemple 98311=(4+2)*65536+7 se code 1100 0100 1100 0010 0 000111.
  • Pour une valeur autre qu'une taille.
    La valeur translatée est écrite sur un nombre variable octets en encodant la taille et avec alignement sur un octet. Par exemple 65540 se code 0x03 0x01 0x00 0x04.

Valeur appartenant à [BorneMin, +Infini]

La valeur translatée est écrite sur un nombre variable octets en encodant la taille et avec alignement sur un octet. Par exemple 65540 se code 0x03 0x01 0x00 0x04.

Valeur appartenant à [-Infini, BorneMax]

• BorneMax est négatif ou nul.
  Alors l'encodage est celui de -Valeur dans l'intervalle [-BorneMax, +Infini].
• BorneMax est positif.
  Alors l'encodage est celui Valeur dans l'intervalle [-Infini, +Infini].

Valeur appartenant à [-Infini, +Infini]

Encodage d'un index entier

• Index d'un énuméré étendu.
• Taille d'un codage bitmap d'une séquence ou d'un ensemble.
• Numéro du choix sélectionné.

Voici le codage d'un tel index :

• Si Index>=0 Et Index<=63, la valeur translatée est codée sur sept bits 0xx xxxx sans alignement sur un octet.
  Par exemple 10 se code 000 1010.
• Si Index>=64, la valeur translatée est codée sur un nombre variable de bits avec le préfixe d'un bit1 sans alignement sur un octet.
  Par exemple 65540 se code 1 0x03 0x01 0x00 0x04.

Algorithmes d'encodage spécifiques à chaque type

BIT STRING

• S'il existe une contrainte visible de PER extensible, alors :
  • Si la valeur n'est pas étendue, i.e. elle est issue de la version 1, alors le préambule a pour valeur 0.
  • Si la valeur est étendue, i.e. elle est issue d'une version supérieure à 1, alors le préambule a pour valeur 1.
• S'il n'existe pas une contrainte visible de PER extensible, alors il n'y a pas de préambule.

S'il existe une contrainte sur la taille visible de PER alors :

• Le préambule a pour valeur 0.
• Si la taille est unique, alors :
  Soit Taille la taille du binaire en nombre de bits.
  • Si Taille<16 alors la valeur est écrite sans coder la taille et sans alignement sur un octet.
    Par exemple MaValeur BIT STRING(3)='111'B se code 0111.
  • Si Taille>17 Et Taille<65536 alors la valeur est écrite sans coder la taille et avec alignement sur un octet.
    Par exemple MaValeur BIT STRING(17)='1 1111 0101 0101 1111'B se code 0 1111 1010 1010 1111 1.
  • Si Taille>65537 alors appel de EncoderEntierAutreQueTaillePer(Taille); puis écriture des octets et avec alignement sur un octet.
    Par exemple MaValeur BIT STRING(65543)='0101 0101 0101 ... 0101 0101'B se code 0 1100 0100 0 000111 0101 ... 0101'.
• Si la taille n'est pas unique, alors EncoderEntierPer(Taille); puis écriture des octets et avec alignement sur un octet.
  Par exemple MaValeur BIT STRING(1..10)='11'B se code 0 0010 11.

• Le préambule a pour valeur 1.
• La taille est écrite sur un nombre variable octets en encodant la taille et avec alignement sur un octet.
  
• La valeur est ensuite écrite.
  Par exemple MaValeur BIT STRING='111'B se code 1 0x01 0x03 111.

BOOLEAN

• TRUE.
  Il est encodé sur un bit 1.
• FALSE.
  Il est encodé sur un bit 0.

Chaînes de caractères

La taille de la chaîne de caractères est encodée de la manière suivante :

• S'il existe une contrainte sur la taille visible de PER extensible, alors :
  • Si la valeur n'est pas étendue, i.e. elle est issue de la version 1, alors le préambule a pour valeur 0.
  • Si la valeur est étendue, i.e. elle est issue d'une version supérieure à 1, alors le préambule a pour valeur 1.
• S'il n'existe pas de contrainte sur la taille visible de PER extensible, alors il n'y a pas de préambule.

• Si la taille est unique et inférieure ou égale à 65536, alors la taille n'est pas écrite.
• Si la taille n'est pas unique ou supérieure ou égale à 65537, alors appel de EncoderEntierAutreQueTaillePer(Taille);.

L'alphabet de la chaîne de caractères est encodée de la manière suivante :

• S'il existe une contrainte sur l'alphabet visible de PER non trivial, alors :
  • A chaque caractère possible est associé un index commençant à 0 pour le premier et s'incrémentant.
  • Le nombre minimal de bits nécessaires au codage de tous les index est retenu.
  • Pour chaque caractère, appel de EncoderEntierPer(Index(Valeur));.
• S'il n'existe pas de contrainte sur l'alphabet visible de PER non trivial, alors les octets sont écrits directement dans l'ordre poids fort puis poids faible.

Par exemple :

• MonType ::= IA5String(SIZE(3)^FROM(ABCD")) nécessite 2 bits.
  
  • MaValeur MonType ::= AAC" se code 00 00 10.
  • MaValeur MonType ::= DBB" se code 10 01 01.
• MonType ::= IA5String(SIZE(1..10)^FROM(ABCD")) nécessite 2 bits.
  
  • MaValeur MonType ::= AAC" se code 0011 00 00 10.
  • MaValeur MonType ::= DBBA" se code 0100 10 01 01 00.
• MonType ::= IA5String(SIZE(1..10, ...)^FROM(ABCD")) nécessite 2 bits.
  
  • MaValeur MonType ::= AAC" se code 0 0011 00 00 10.
  • MaValeur MonType ::= DBBA" se code 0 0100 10 01 01 00.
• MaValeur IA5String(SIZE(3)) ::= ABC" se code 0x41 0x42 0x43.
• MaValeur IA5String(SIZE(1..10)) ::= ABC" se code 0011 0x41 0x42 0x43.
• MaValeur IA5String(SIZE(1..10, ...)) ::= ABC" se code 0 0011 0x41 0x42 0x43.
• MonType ::= IA5String(FROM(ABCD")) nécessite 2 bits.
  
  • MaValeur MonType ::= AAC" se code 0 000011 00 00 10.
  • MaValeur MonType ::= DBBAAC" se code 0 000110 10 01 01 00 00 10.
• MaValeur IA5String ::= ABC" se code 0 000011 0x41 0x42 0x43.

CHOIX

• Si le type est extensible alors :
  • Si la valeur n'est pas étendue, i.e. elle est issue de la version 1, alors le préambule a pour valeur 0.
  • Si la valeur est étendue, i.e. elle est issue d'une version supérieure à 1, alors le préambule a pour valeur 1.
• Si le type n'est pas extensible alors il n'y a pas de préambule.

Si le choix comporte plusieurs alternatives :

• Si la valeur ne fait pas partie d'une extension, alors :
  • Les éléments du choix non étendus sont ordonnés par ordre canonique :
    • Par niveau UNIVERSAL, APPLICATION, contextuel puis PRIVATE.
    • Par numéro d'étiquette.
    Pour les éléments de type CHOIX, le type du premier choix est retenu pour le tri.
  • Un index est associé à chaque élément trié en commençant à 0.
  • Appel de EncoderEntierPer(Index(Choix));.
    
• Si la valeur ne fait pas partie d'une extension, alors les éléments du choix étendus sont ordonnés par ordre canonique.
  • Les éléments du choix étendu sont ordonnés par ordre canonique :
    • Par niveau UNIVERSAL, APPLICATION, contextuel puis PRIVATE.
    • Par numéro d'étiquette.
    Pour les élements de type CHOIX, le type du premier choix est retenu pour le tri.
  • Un index est associé à chaque élément trié en commençant à 0.
  • Appel de EncoderEntierPer(Index(Choix));.
    

La valeur du choix est ensuite encodée.

Par exemple :

• MaValeur CHOICE{A BOOLEAN, B INTEGER, C IA5String} := C :ABC" se code 0 000011 0 000011 0x41 0x42 0x43.
• MaValeur CHOICE{A BOOLEAN, B INTEGER, C IA5String, ...} := C :ABC" se code 0 0 000011 0 000011 0x41 0x42 0x43.
• MaValeur CHOICE{A BOOLEAN, ..., B INTEGER, C IA5String} := C :ABC" se code 1 0 000010 0 000011 0x41 0x42 0x43.

EMBEDDED-PDV

ENUMERATED

• Si le type ne comprend pas une contrainte extensible visible de PER, alors :
  • Il n'y a pas de préambule.
  • Les valeurs énumérées sont classées par ordre de valeurs croissantes.
  • A chaque valeur énumérée est associé un index commençant à 0 pour la première et s'incrémentant.
  • Le nombre minimal de bits nécessaires au codage de tous les index est retenu.
  • Appel de EncoderEntierPer(Index(Valeur));.
    Par exemple MaValeur ENUMERATED {rouge(20), vert(10), bleu(30)} nécessite 2 bits.
    
    • rouge se code 01.
    • vert se code 00.
    • bleu se code 10.
• Si le type comprend une contrainte extensible visible de PER, alors :
  • Si la valeur n'est pas étendue, i.e. elle est issue de la version 1, alors :
  • Le préambule a pour valeur 0.
  • Le principe d'encodage par index est utilisé.
    Par exemple MaValeur ENUMERATED {rouge(20), vert(10), bleu(30), ...}=rouge se code 0 01.
    
• Si la valeur est étendue, i.e. elle est issue d'une version supérieure à 1, alors :
  • Le préambule a pour valeur 1.
  • Appel de EncoderEntierAutreQueTaillePer(Valeur);.
    Par exemple MaValeur ENUMERATED {rouge(20), vert(10), bleu(30), ..., noir(40)}=noir se code 1 0 000100.
    

EXTERNAL

• En octets pour l'option single-ASN1-type octet-aligned.
• En bits pour l'option arbitrary.

La valeur externe est encodée de la manière suivante :

• Appel de EncoderEntierPer(Taille);.
• Encodage de la valeur comme en Basic Encoding Rules (BER).

INTEGER

• Si le type comprend une contrainte extensible visible de PER, alors :
  • Si la valeur n'est pas étendue, i.e. elle est issue de la version 1, alors :
    • Le préambule a pour valeur 0.
    • Appel de EncoderEntierPer(Valeur);.
      Par exemple MaValeur INTEGER(1..10, ...)=3 nécessite 4 bits et se code 0 0011.
  • Si la valeur est étendue, i.e. elle est issue d'une version supérieure à 1, alors :
    • Le préambule a pour valeur 1.
    • Appel de EncoderEntierBer(Valeur);.
      Par exemple MaValeur INTEGER(1..10, ...)=12 se code 1 0x01 0x0C.
• Si le type ne comprend pas une contrainte extensible visible de PER, alors :
  • Il n'y a pas de préambule.
  • Appel de EncoderEntierPer(Valeur);.
    Par exemple MaValeur INTEGER(1..10)=3 nécessite 4 bits et se code 0011.

NULL

OBJECT IDENTIFIER

OCTET STRING

• S'il existe une contrainte visible de PER extensible, alors :
  • Si la valeur n'est pas étendue, i.e. elle est issue de la version 1, alors le préambule a pour valeur 0.
  • Si la valeur est étendue, i.e. elle est issue d'une version supérieure à 1, alors le préambule a pour valeur 1.
• S'il n'existe pas une contrainte visible de PER extensible, alors il n'y a pas de préambule.

S'il existe une contrainte visible de PER qui impose une taille, alors :

• Si la taille est unique, alors :
  Soit Taille la taille du binaire en nombre d'octets.
  • Si Taille<16 alors la valeur est écrite sans coder la taille.
    Par exemple MaValeur OCTET STRING(3)='123456'H se code 0x12 0x34 0x56.
  • Si Taille>17 Et Taille<65536 alors la valeur est écrite sans coder la taille.
    Par exemple MaValeur OCTET STRING(17)='0123456789ABCDEF0'H se code 0x01 0x23 0x45 0x67 0x89 0xAB 0xCD 0xEF 0x0.
  • Si Taille>65537 alors appel de EncoderEntierAutreQueTaillePer(Taille); puis écriture des octets.
    Par exemple MaValeur OCTET STRING(65540)='AB AB ... AB AB'H se code 1100 0100 0 00100 0xAB ... 0xAB.
• Si la taille n'est pas unique, alors EncoderEntierPer(Taille); puis écriture des octets et avec alignement sur un octet.
  Par exemple MaValeur OCTET STRING(1..10)='AB'B se code 0001 0xAB.

Les valeurs des types BMPString, GeneralString, GraphicString, IA5String, ISO646String, NumericString, PrintableString, TeletexString, UniversalString, UTF8String, VideotextString et VisibleString

Pour valeurs types GeneralizedTime et UTCTime, l'encodage Basic Encoding Rules (BER) est utilisé.

REAL

RELATIVE-OID

SEQUENCE

• S'il existe une extension alors :
  • Si la valeur n'est pas étendue, i.e. elle est issue de la version 1, alors le préambule a pour valeur 0.
  • Si la valeur est étendue, i.e. elle est issue d'une version supérieure à 1, alors le préambule a pour valeur 1.
• S'il n'existe pas d'extension alors il n'y a pas de préambule.

• Si la séquence comporte NbProprietes propriétés marquées DEFAULT ou OPTIONAL, alors :
  • Appel de EncoderEntierAutreQueTaillePer(NbValeurs);.
  • Pour chaque propriété marquée :
    • Si elle est présente, le préambule a pour valeur 1.
      Pour une propriété marquée DEFAULT, cela est uniquement possible pour les types construits i.e. choix, ensemble, liste ou séquence.
    • Si elle est absente, le préambule a pour valeur 0.
• Si la séquence ne comporte par de propriété marquée DEFAULT ou OPTIONAL, alors il n'y a pas de préambule.

Les propriétés de la séquence sont ensuite codées par ordre de déclaration.

Si la séquence est extensible :

• Soit NbVersions le nombre de versions possible.
• Appel de EncoderEntierAutreQueTaillePer(NbVersions-1);.
• Pour chaque version :
  • Si l'extension correspondant est présente, le préambule a pour valeur 1.
    Cela est uniquement possible pour les types construits i.e. choix, ensemble, liste ou séquence.
  • Si l'extension correspondant absente, le préambule a pour valeur 0.
• Pour chaque version, les propriétés de l'extension correspondant sont codées par ordre de déclaration.
  Si une extension regroupe plusieurs propriétés du fait de la syntaxe [[ ... ]], celles-ci sont encodées comme une pseudo-séquence.

Par exemple :

• MaValeur SEQUENCE{A BOOLEAN, B INTEGER, C IA5String} := {A TRUE, B 10, C ABC"} se code 1 0x01 0x0A 0 000011 0x41 0x42 0x43.
• MaValeur SEQUENCE{A BOOLEAN, B INTEGER, C IA5String, ...} := {A TRUE, B 10, C ABC"} se code 0 1 0x01 0x0A 0 000011 0x41 0x42 0x43.
• MaValeur SEQUENCE{A BOOLEAN, B INTEGER DEFAUT 20, C IA5String OPTIONAL} := {A TRUE, B 10, C ABC"} se code 0 000010 1 1 1 0x01 0x0A 0 000011 0x41 0x42 0x43.
• MaValeur SEQUENCE{A BOOLEAN, B INTEGER DEFAUT 20, C IA5String OPTIONAL} := {A TRUE, C ABC"} se code 0 000010 0 1 1 000011 0x41 0x42 0x43.
• MaValeur SEQUENCE{A BOOLEAN, ..., B INTEGER DEFAUT 20, C IA5String OPTIONAL} := {A TRUE, B 10, C ABC"} se code 1 1 0 000010 1 1 0 000001 1 0x01 0x0A 0 000001 1 0 000011 0x41 0x42 0x43.
• MaValeur SEQUENCE{A BOOLEAN, ..., [[B INTEGER DEFAUT 20, C IA5String OPTIONAL]]} := {A TRUE, B 10, C ABC"} se code 1 1 0 000001 1 000010 1 1 0x01 0x0A 0 000011 0x41 0x42 0x43.

SEQUENCE OF

• Si le type comprend une contrainte de taille extensible visible de PER, alors :
  • Si la valeur n'est pas étendue, i.e. elle est issue de la version 1, alors le préambule a pour valeur 0.
  • Si la valeur est étendue, i.e. elle est issue d'une version supérieure à 1, alors le préambule a pour valeur 1.
• S'il n'existe pas d'extension alors il n'y a pas de préambule.

Soit Taille la taille de la liste.

• Si la taille de la liste est unique, elle n'est pas écrite.
• Si la taille de la liste n'est pas unique, appel de EncoderEntierPer(Taille);

Les propriétés de la liste sont ensuite codées par ordre de déclaration.

Par exemple :

• MaValeur SEQUENCE(3) OF BOOLEAN := {TRUE, TRUE, FALSE} se code 1 1 0.
• MaValeur SEQUENCE(1..3) OF BOOLEAN := {TRUE, FALSE} se code 10 1 0.
• MaValeur SEQUENCE OF BOOLEAN := {TRUE, TRUE, FALSE} se code 0 000011 1 1 0.
• MaValeur SEQUENCE(3, ...) OF BOOLEAN := {TRUE, TRUE, FALSE} se code 0 1 1 0.
• MaValeur SEQUENCE(1..3, ...) OF BOOLEAN := {TRUE, FALSE} se code 0 10 1 0.
• MaValeur SEQUENCE(1..3, ...) OF BOOLEAN := {TRUE, FALSE, TRUE, FALSE} se code 1 0 000100 1 0 1 0.

SET

• Les éléments de l'ensemble sont ordonnés comme suit :
  • Par ordre canonique pour les éléments ne provenant pas d'une extension.
    • Par niveau UNIVERSAL, APPLICATION, contextuel puis PRIVATE.
    • Par numéro d'étiquette.
    Pour les élements de type CHOIX, le type du premier choix est retenu pour le tri.
  • Puis par ordre alphabétique pour les éléments provenant d'une extension.
• Le résultat du tri est encodé comme une séquence.

Par exemple MaValeur SET{A BOOLEAN, B INTEGER, C IA5String} := {A TRUE, B 10, C ABC"} se code 1 0x01 0x0A 0 000011 0x41 0x42 0x43.

SET OF

Variantes du standard Packed Encoding Rules

• BASIC-PER versus CANONICAL-PER.
  Les algorithmes précédents sont rendus canoniques par application des restrictions suivantes :
  • Les chaînes de caractères UTF8 utilisent l'encodage Distinguished Encoding Rules (DER) et non encodage Basic Encoding Rules (BER).
    En pratique, comptage en octets et non en caractères et découpage en paquet de 1000.
  • Les valeurs de types GeneralizedTime et UTCTime utilisent l'encodage encodage Distinguished Encoding Rules (DER) et non encodage Basic Encoding Rules (BER).
    En pratique, comptage en octets et non en caractères et découpage en paquet de 1000.
  • Les caractères IA5SString ne sont pas encodés sur un octet mais sur sept bits.
    Du fait de la contrainte alphabétique (FROM(0..0x7F)).
  • Les propriétés utilisant leur valeur par défaut ne sont jamais encodées.
  • Les éléments d'une liste non ordonnée - SET OF - sont classés avec le tri canonique avant d'être encodés.

  Le mode canonique a la particularité de ne permettre qu'un seul choix d'encodage pour chaque typologie de valeurs.

• ALIGNED-PER versus UNALIGNED-PER.
  Les algorithmes précédents utilisent un alignement sur un octet. La plupart de ceux-ci peuvent être supprimés, ce qui minimise la taille du flux binaire :
  • Les valeurs entières sont toujours encodées sans taille.
  • Les valeurs entières ne sont jamais alignées sur un octet.