takers.go

package postcard

import (
	"encoding/binary"
	"errors"
	"io"
	"math"
)

// https://github.com/jamesmunns/postcard/blob/main/source/postcard-core/src/de.rs

func pop(r io.Reader) (byte, error) {
	buf := []byte{0}
	_, err := r.Read(buf)
	return buf[0], err
}

func takeBool(r io.Reader) (bool, error) {
	b, err := pop(r)
	if err != nil {
		return false, err
	}
	switch b {
	case 0:
		return false, nil
	case 1:
		return true, nil
	default:
		return false, errors.New("invalid bool value")
	}
}

func takeU8(r io.Reader) (uint8, error) {
	return pop(r)
}

type unsigned interface {
	uint16 | uint32 | uint64 | uintptr
}

func takeU16(r io.Reader) (uint16, error) {
	return takeUN[uint16](r, 2)
}

func takeU32(r io.Reader) (uint32, error) {
	return takeUN[uint32](r, 4)
}

func takeU64(r io.Reader) (uint64, error) {
	return takeUN[uint64](r, 8)
}

func takeUN[U unsigned](r io.Reader, sizeOf uint8) (U, error) {
	var out U
	for i := range varintMax(sizeOf) {
		val, err := pop(r)
		if err != nil {
			return 0, err
		}
		carry := U(val & 0x7F)
		out |= carry << (7 * i)

		if (val & 0x80) == 0 {
			if i == varintMax(sizeOf)-1 && val > maxOfLastByte(sizeOf) {
				break
			} else {
				return out, nil
			}
		}
	}
	return 0, errors.New("invalid unisgned int")
}

func takeI8(r io.Reader) (int8, error) {
	b, err := pop(r)
	return int8(b), err
}

func takeI16(r io.Reader) (int16, error) {
	u, err := takeU16(r)
	if err != nil {
		return 0, err
	}
	i := dezigzag[uint16, int16](u)
	return i, nil
}

func takeI32(r io.Reader) (int32, error) {
	u, err := takeU32(r)
	if err != nil {
		return 0, err
	}
	i := dezigzag[uint32, int32](u)
	return i, nil
}

func takeI64(r io.Reader) (int64, error) {
	u, err := takeU64(r)
	if err != nil {
		return 0, err
	}
	i := dezigzag[uint64, int64](u)
	return i, nil
}

func takeF32(r io.Reader) (float32, error) {
	buf := make([]byte, 4)
	_, err := io.ReadFull(r, buf)
	if err != nil {
		return 0, err
	}
	u := binary.LittleEndian.Uint32(buf)
	return math.Float32frombits(u), nil
}

func takeF64(r io.Reader) (float64, error) {
	buf := make([]byte, 8)
	_, err := io.ReadFull(r, buf)
	if err != nil {
		return 0, err
	}
	u := binary.LittleEndian.Uint64(buf)
	return math.Float64frombits(u), nil
}

func takeBytes(r io.Reader) ([]byte, error) {
	n, err := takeU64(r)
	if err != nil {
		return nil, err
	}
	buf := make([]byte, n)
	_, err = io.ReadFull(r, buf)
	if err != nil {
		return nil, err
	}
	return buf, nil
}

func takeStr(r io.Reader) (string, error) {
	raw, err := takeBytes(r)
	if err != nil {
		return "", err
	}
	return string(raw), nil
}

func takeChar(r io.Reader) (rune, error) {
	raw, err := takeU32(r)
	if err != nil {
		return 0, err
	}
	return rune(raw), nil
}

func takeSeq[E any](r io.Reader, t taker[E]) ([]E, error) {
	n, err := takeU64(r)
	if err != nil {
		return nil, err
	}
	items := make([]E, n)
	for i := range n {
		v, err := t(r)
		if err != nil {
			return nil, err
		}
		items[i] = v
	}
	return items, nil
}

type signed interface {
	int16 | int32 | int64 | int
}

func dezigzag[U unsigned, I signed](n U) I {
	return I(n>>1) ^ (-I(n & 0b1))
}