Appendice C. Esempio di Algoritmo di Codifica a Singolo Passaggio

Pseudocodice per la codifica a singolo passaggio, escludendo la gestione dei duplicati, la modalità non bloccante, il controllo del flusso del flusso dell'encoder disponibile e il tracciamento dei riferimenti.

Funzioni Ausiliarie

# Codifica un intero utilizzando il prefisso e la lunghezza specificati
encodeInteger(buffer, prefix, value, prefixLength)

# Codifica un'istruzione di inserimento nella tabella dinamica con indice di nome statico o dinamico opzionale (ma non entrambi)
encodeInsert(buffer, staticNameIndex, dynamicNameIndex, fieldLine)

# Codifica un riferimento all'indice statico
encodeStaticIndexReference(buffer, staticIndex)

# Codifica un riferimento all'indice dinamico relativo a Base
encodeDynamicIndexReference(buffer, dynamicIndex, base)

# Codifica un letterale con indice di nome statico opzionale
encodeLiteral(buffer, staticNameIndex, fieldLine)

# Codifica un letterale con indice di nome dinamico relativo a Base
encodeDynamicLiteral(buffer, dynamicNameIndex, base, fieldLine)

Algoritmo di Codifica

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:
        # Nessuna voce corrispondente. Inserire+indicizzare o codificare letterale
        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:
        # Impossibile indicizzarlo, utilizzare letterale
        if dynamicNameIndex is not None:
            # Codifica letterale con nome dinamico, possibilmente sopra Base
            encodeDynamicLiteral(streamBuffer, dynamicNameIndex,
                                base, line)
            requiredInsertCount = max(requiredInsertCount,
                                    dynamicNameIndex)
        else:
            # Codifica letterale con nome statico o nome letterale
            encodeLiteral(streamBuffer, staticNameIndex, line)
    else:
        # Riferimento all'indice dinamico
        assert(dynamicIndex is not None)
        requiredInsertCount = max(requiredInsertCount, dynamicIndex)
        # Codifica dynamicIndex, possibilmente sopra Base
        encodeDynamicIndexReference(streamBuffer, dynamicIndex, base)

# Codifica prefisso
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

Spiegazione dell'Algoritmo

Questo algoritmo dimostra la logica di base di un encoder a singolo passaggio:

1. Inizializzazione: Impostare Base sul conteggio di inserimento corrente, inizializzare requiredInsertCount a 0.

2. Iterare le Righe di Campo: Per ogni riga di campo:

   • Prima provare a trovare una corrispondenza completa nella tabella statica
   • Se non trovata, cercare nella tabella dinamica
   • Se nessuna delle due è trovata, decidere se inserire una nuova voce o utilizzare un letterale

3. Logica di Decisione:

   • Corrispondenza Completa: Riferimento diretto (statico o dinamico)
   • Nessuna Corrispondenza: Decidere se inserire nella tabella dinamica in base alla politica
   • Solo Corrispondenza Nome: Utilizzare letterale con riferimento al nome

4. Codifica del Prefisso: Codificare il prefisso della sezione di campo in base ai valori di requiredInsertCount e Base.

5. Output: Restituire il buffer del flusso dell'encoder e la sezione di campo codificata (prefisso + rappresentazioni di righe di campo).

Punti Chiave

• Elaborazione a Singolo Passaggio: L'algoritmo prende decisioni di codifica e inserimento durante l'iterazione attraverso le righe di campo
• Tracciamento di Base: Utilizza il conteggio di inserimento come Base, consentendo l'indicizzazione Post-Base
• Strategia Flessibile: La funzione shouldIndex() incapsula la strategia di indicizzazione, regolabile in base alle esigenze di implementazione
• Conteggio dei Riferimenti: requiredInsertCount tiene traccia dello stato massimo della tabella dinamica richiesto

---