mmapbinfuse-write.go

package mmapbinfuse

import (
	"bufio"
	"bytes"
	"fmt"
	"os"

	eb "encoding/binary"

	"github.com/kelindar/binary"
)

var MagicNumber = []byte("BinaryFuse_v1")

func Write[T Unsigned](keys []uint64, dst string) error {
	dstFile, err := os.Create(dst)
	if err != nil {
		return fmt.Errorf("failed to create file: %w", err)
	}
	defer dstFile.Close()

	filter, err := NewBinaryFuse[T](keys)
	if err != nil {
		return fmt.Errorf("failed to create filter: %w", err)
	}
	err = marshalBinaryFuse(filter, dstFile)
	if err != nil {
		return fmt.Errorf("failed to marshal filter: %w", err)
	}
	return nil
}

func marshalBinaryFuse[T Unsigned](filter *BinaryFuse[T], dst *os.File) error {
	header, err := marshalFilterHead(filter)
	if err != nil {
		return fmt.Errorf("failed to marshal filter head: %w", err)
	}

	wBuffer := bufio.NewWriter(dst)

	_, err = wBuffer.Write(header)
	if err != nil {
		return fmt.Errorf("failed to write filter head: %w", err)
	}

	for _, fp := range filter.Fingerprints {
		err = eb.Write(wBuffer, eb.LittleEndian, fp)
		if err != nil {
			return fmt.Errorf("failed to write fingerprint: %w", err)
		}
	}
	wBuffer.Flush()
	return nil
}

func marshalFilterHead[T Unsigned](filter *BinaryFuse[T]) ([]byte, error) {
	buf := new(bytes.Buffer)
	encoder := binary.NewEncoder(buf)
	encoder.Write(MagicNumber)
	encoder.WriteUint64(filter.Seed)
	encoder.WriteUint32(filter.SegmentLength)
	encoder.WriteUint32(filter.SegmentLengthMask)
	encoder.WriteUint32(filter.SegmentCount)
	encoder.WriteUint32(filter.SegmentCountLength)
	encoder.WriteUint64(uint64(len(filter.Fingerprints)))

	typeOfT := uint8(0)
	switch any(*new(T)).(type) {
	case uint8:
		typeOfT = TypeOfTUint8
	case uint16:
		typeOfT = TypeOfTUint16
	case uint32:
		typeOfT = TypeOfTUint32
	default:
		return nil, fmt.Errorf("unsupported type: %T", any(*new(T)))
	}
	encoder.Write([]byte{typeOfT})
	return buf.Bytes(), nil
}

const (
	TypeOfTUint8  = 1
	TypeOfTUint16 = 2
	TypeOfTUint32 = 4
)

func typeNumberToString(t uint8) string {
	switch t {
	case TypeOfTUint8:
		return "uint8"
	case TypeOfTUint16:
		return "uint16"
	case TypeOfTUint32:
		return "uint32"
	default:
		return "unknown"
	}
}