Method WriteSequenceChainedSignature

compressor/encode.go:808–850

(signature []byte)

}

func (buf *Buffer) WriteSequenceChainedSignature(signature []byte) (EncodeType, error) {
	// First we need to count how many chained signatures are there
	// for this we read the first 3 bytes of each, as they contain the size
	var pointer uint
	var parts [][]byte

	for pointer < uint(len(signature)) {
		length := uint(signature[pointer])<<16 | uint(signature[pointer+1])<<8 | uint(signature[pointer+2])
		pointer += 3

		npointer := pointer + length
		parts = append(parts, signature[pointer:npointer])
		pointer = npointer
	}

	// We have two instructions for this, one for 8 bits and one for 16 bits
	// depending on the number of parts
	totalParts := uint(len(parts))
	if totalParts > 255 {
		buf.commitUint(FLAG_SEQUENCE_READ_CHAINED_L)
		buf.commitByte(byte(totalParts >> 8))
		buf.commitByte(byte(totalParts))
	} else {
		buf.commitUint(FLAG_SEQUENCE_READ_CHAINED_S)
		buf.commitByte(byte(totalParts))
	}

	buf.end([]byte{}, Stateless)

	// Now we need to encode every nested part, one for each signature part
	encodeType := Stateless

	for _, part := range parts {
		t, err := buf.WriteSequenceSignature(part, false)
		if err != nil {
			return Stateless, err
		}

		encodeType = maxPriority(encodeType, t)
	}

	return encodeType, nil
}

// Encode N bytes, as optimized as possible
func (buf *Buffer) WriteBytesOptimized(bytes []byte, saveWord bool) (EncodeType, error) {