func NewKllItemsSketchFromSlice[C comparable]()

in kll/items_sketch.go [109:188]
75 lines of code
12 McCabe index (conditional complexity)

func NewKllItemsSketchFromSlice[C comparable](sl []byte, compareFn common.CompareFn[C], serde common.ItemSketchSerde[C]) (*ItemsSketch[C], error) {
	if serde == nil {
		return nil, fmt.Errorf("no SerDe provided")
	}

	if compareFn == nil {
		return nil, fmt.Errorf("no compare function provided")
	}

	memVal, err := newItemsSketchMemoryValidate(sl, serde)
	if err != nil {
		return nil, err
	}

	var (
		k                 = memVal.k
		m                 = memVal.m
		levelsArr         = memVal.levelsArr
		n                 = memVal.n
		minK              = memVal.minK
		isLevelZeroSorted = memVal.level0SortedFlag
		minItem           *C
		maxItem           *C
		items             = make([]C, levelsArr[memVal.numLevels])
	)

	switch memVal.sketchStructure {
	case _COMPACT_EMPTY:
		minItem = nil
		maxItem = nil
		items = make([]C, k)
	case _COMPACT_SINGLE:
		offset := _N_LONG_ADR
		deserItems, err := serde.DeserializeManyFromSlice(sl, offset, 1)
		if err != nil {
			return nil, err
		}
		minItem = &deserItems[0]
		maxItem = &deserItems[0]
		items = make([]C, k)
		items[k-1] = deserItems[0]
	case _COMPACT_FULL:
		offset := int(_DATA_START_ADR + memVal.numLevels*4)
		deserMinItems, err := serde.DeserializeManyFromSlice(sl, offset, 1)
		minItem = &deserMinItems[0]
		if err != nil {
			return nil, err
		}
		offset += serde.SizeOf(*minItem)
		deserMaxItems, err := serde.DeserializeManyFromSlice(sl, offset, 1)
		maxItem = &deserMaxItems[0]
		if err != nil {
			return nil, err
		}
		offset += serde.SizeOf(*maxItem)
		numRetained := levelsArr[memVal.numLevels] - levelsArr[0]
		deseRetItems, err := serde.DeserializeManyFromSlice(sl, offset, int(numRetained))
		if err != nil {
			return nil, err
		}
		for i := uint32(0); i < numRetained; i++ {
			items[i+levelsArr[0]] = deseRetItems[i]
		}
	}

	return &ItemsSketch[C]{
		k:                 k,
		m:                 m,
		minK:              minK,
		numLevels:         memVal.numLevels,
		isLevelZeroSorted: isLevelZeroSorted,
		n:                 n,
		levels:            levelsArr,
		items:             items,
		minItem:           minItem,
		maxItem:           maxItem,
		serde:             serde,
		compareFn:         compareFn,
	}, nil
}