Annexe C. Exemple d'Algorithme d'Encodage en Un Seul Passage

Pseudocode pour l'encodage en un seul passage, excluant la gestion des doublons, le mode non bloquant, le contrôle de flux du flux d'encodeur disponible et le suivi des références.

Fonctions Auxiliaires

# Encoder un entier en utilisant le préfixe et la longueur spécifiés
encodeInteger(buffer, prefix, value, prefixLength)

# Encoder une instruction d'insertion de table dynamique avec un index de nom statique ou dynamique optionnel (mais pas les deux)
encodeInsert(buffer, staticNameIndex, dynamicNameIndex, fieldLine)

# Encoder une référence d'index statique
encodeStaticIndexReference(buffer, staticIndex)

# Encoder une référence d'index dynamique relative à Base
encodeDynamicIndexReference(buffer, dynamicIndex, base)

# Encoder un littéral avec un index de nom statique optionnel
encodeLiteral(buffer, staticNameIndex, fieldLine)

# Encoder un littéral avec un index de nom dynamique relatif à Base
encodeDynamicLiteral(buffer, dynamicNameIndex, base, fieldLine)

Algorithme d'Encodage

base = dynamicTable.getInsertCount()
requiredInsertCount = 0

for line in fieldLines:
    staticIndex = staticTable.findIndex(line)
    if staticIndex is not None:
        encodeStaticIndexReference(streamBuffer, staticIndex)
        continue

    dynamicIndex = dynamicTable.findIndex(line)
    if dynamicIndex is None:
        # Aucune entrée correspondante. Soit insérer+indexer, soit encoder un littéral
        staticNameIndex = staticTable.findName(line.name)
        if staticNameIndex is None:
            dynamicNameIndex = dynamicTable.findName(line.name)

        if shouldIndex(line) and dynamicTable.canIndex(line):
            encodeInsert(encoderBuffer, staticNameIndex,
                        dynamicNameIndex, line)
            dynamicIndex = dynamicTable.add(line)

    if dynamicIndex is None:
        # Impossible de l'indexer, utiliser un littéral
        if dynamicNameIndex is not None:
            # Encoder un littéral avec un nom dynamique, éventuellement au-dessus de Base
            encodeDynamicLiteral(streamBuffer, dynamicNameIndex,
                                base, line)
            requiredInsertCount = max(requiredInsertCount,
                                    dynamicNameIndex)
        else:
            # Encoder un littéral avec un nom statique ou un nom littéral
            encodeLiteral(streamBuffer, staticNameIndex, line)
    else:
        # Référence d'index dynamique
        assert(dynamicIndex is not None)
        requiredInsertCount = max(requiredInsertCount, dynamicIndex)
        # Encoder dynamicIndex, éventuellement au-dessus de Base
        encodeDynamicIndexReference(streamBuffer, dynamicIndex, base)

# Encoder le préfixe
if requiredInsertCount == 0:
    encodeInteger(prefixBuffer, 0x00, 0, 8)
    encodeInteger(prefixBuffer, 0x00, 0, 7)
else:
    wireRIC = (
        requiredInsertCount
        % (2 * getMaxEntries(maxTableCapacity))
    ) + 1
    encodeInteger(prefixBuffer, 0x00, wireRIC, 8)
    if base >= requiredInsertCount:
        encodeInteger(prefixBuffer, 0x00,
                    base - requiredInsertCount, 7)
    else:
        encodeInteger(prefixBuffer, 0x80,
                    requiredInsertCount - base - 1, 7)

return encoderBuffer, prefixBuffer + streamBuffer

Explication de l'Algorithme

Cet algorithme démontre la logique de base d'un encodeur en un seul passage :

1. Initialisation : Définir Base sur le nombre d'insertions actuel, initialiser requiredInsertCount à 0.

2. Itérer sur les Lignes de Champ : Pour chaque ligne de champ :

   • D'abord essayer de trouver une correspondance complète dans la table statique
   • Si non trouvé, rechercher dans la table dynamique
   • Si aucun des deux n'est trouvé, décider d'insérer une nouvelle entrée ou d'utiliser un littéral

3. Logique de Décision :

   • Correspondance Complète : Référence directe (statique ou dynamique)
   • Aucune Correspondance : Décider d'insérer dans la table dynamique en fonction de la politique
   • Correspondance de Nom Uniquement : Utiliser un littéral avec référence de nom

4. Encodage du Préfixe : Encoder le préfixe de section de champ en fonction des valeurs de requiredInsertCount et Base.

5. Sortie : Retourner le tampon de flux d'encodeur et la section de champ encodée (préfixe + représentations de lignes de champ).

Points Clés

• Traitement en Un Seul Passage : L'algorithme prend des décisions d'encodage et d'insertion lors de l'itération sur les lignes de champ
• Suivi de Base : Utilise le nombre d'insertions comme Base, permettant l'indexation Post-Base
• Stratégie Flexible : La fonction shouldIndex() encapsule la stratégie d'indexation, ajustable selon les besoins d'implémentation
• Comptage de Références : requiredInsertCount suit l'état maximal de la table dynamique requis

---