mmap.go

package mmapbinfuse

import (
	"fmt"
	"os"
	"reflect"
	"unsafe"

	"github.com/edsrzf/mmap-go"
)

func init() {
	// panic on big endian systems
	if !isLittleEndian() {
		panic("big endian systems are not supported")
	}
}

func isLittleEndian() bool {
	var i int32 = 0x1
	bs := (*[4]byte)(unsafe.Pointer(&i))
	return bs[0] == 0x1
}

// GenericMMap encapsulates an  MMap and provides generic access to its data.
type GenericMMap[T Unsigned] struct {
	data  mmap.MMap
	slice []T
}

func NewGenericMMapWithOffset[T Unsigned](filePath string, offset int64) (*GenericMMap[T], error) {
	data, err := OpenWithOffset(filePath, offset)
	if err != nil {
		return nil, fmt.Errorf("failed to open mmap file: %w", err)
	}

	// Create a slice header and adjust for the size of T.
	header := reflect.SliceHeader{
		Data: uintptr(unsafe.Pointer(&data[0])),
		Len:  len(data) / int(reflect.TypeOf(*new(T)).Size()),
		Cap:  len(data) / int(reflect.TypeOf(*new(T)).Size()),
	}

	return &GenericMMap[T]{
		data:  data,
		slice: *(*[]T)(unsafe.Pointer(&header)),
	}, nil
}

func (g *GenericMMap[T]) Close() error {
	if g.data == nil {
		return nil
	}
	return g.data.Unmap()
}

func (g *GenericMMap[T]) Get(index uint32) T {
	return g.slice[index]
}

func (g *GenericMMap[T]) Slice() []T {
	return g.slice
}

func OpenWithOffset(filename string, offset int64) (mmap.MMap, error) {
	f, err := os.Open(filename)
	if err != nil {
		return nil, fmt.Errorf("failed to open file: %w", err)
	}
	defer f.Close()
	fi, err := f.Stat()
	if err != nil {
		return nil, fmt.Errorf("failed to stat file: %w", err)
	}
	mm, err := mmap.MapRegion(f, int(fi.Size()), mmap.RDONLY, 0, 0)
	if err != nil {
		return nil, fmt.Errorf("failed to mmap file: %w", err)
	}
	return mm[offset:], nil
}