From fccca0b7530cb4dd80daa1302b0402260bbe8f1a Mon Sep 17 00:00:00 2001
From: Dima Gordenko <1.e4.kc6@gmail.com>
Date: Fri, 27 Dec 2024 08:15:07 +0200
Subject: [PATCH] added uint48

---
 bin.go | 98 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 98 insertions(+)

diff --git a/bin.go b/bin.go
index 4caab14..c8d471f 100644
--- a/bin.go
+++ b/bin.go
@@ -228,6 +228,26 @@ func GetUint32(arr []byte, byteOrder ByteOrder) (num uint32, err error) {
 	return
 }
 
+func GetUint48(arr []byte, byteOrder ByteOrder) (num uint64, err error) {
+	if len(arr) < 6 {
+		err = fmt.Errorf(wrongArraySize, len(arr))
+		return
+	}
+	switch byteOrder {
+	case LH:
+		num = uint64(arr[0]) | (uint64(arr[1]) << 8) |
+			(uint64(arr[2]) << 16) | (uint64(arr[3]) << 24) |
+			(uint64(arr[4]) << 32) | (uint64(arr[5]) << 40)
+	case HL:
+		num = uint64(arr[5]) | (uint64(arr[4]) << 8) |
+			(uint64(arr[3]) << 16) | (uint64(arr[2]) << 24) |
+			(uint64(arr[1]) << 32) | (uint64(arr[0]) << 40)
+	default:
+		err = fmt.Errorf(unknownByteOrder, byteOrder)
+	}
+	return
+}
+
 // GetUint64 - читает из массива arr 8 байт и декодирует их в uint64.
 func GetUint64(arr []byte, byteOrder ByteOrder) (num uint64, err error) {
 	if len(arr) < 8 {
@@ -384,6 +404,32 @@ func PutUint32(arr []byte, num uint32, byteOrder ByteOrder) (err error) {
 	return
 }
 
+func PutUint48(arr []byte, num uint64, byteOrder ByteOrder) (err error) {
+	if len(arr) < 6 {
+		err = fmt.Errorf(wrongArraySize, len(arr))
+		return
+	}
+	switch byteOrder {
+	case LH:
+		arr[0] = byte(num)
+		arr[1] = byte(num >> 8)
+		arr[2] = byte(num >> 16)
+		arr[3] = byte(num >> 24)
+		arr[4] = byte(num >> 32)
+		arr[5] = byte(num >> 40)
+	case HL:
+		arr[5] = byte(num)
+		arr[4] = byte(num >> 8)
+		arr[3] = byte(num >> 16)
+		arr[2] = byte(num >> 24)
+		arr[1] = byte(num >> 32)
+		arr[0] = byte(num >> 40)
+	default:
+		err = fmt.Errorf(unknownByteOrder, byteOrder)
+	}
+	return
+}
+
 // PutUint64 - записывает 8 байт в массив arr
 func PutUint64(arr []byte, num uint64, byteOrder ByteOrder) (err error) {
 	if len(arr) < 8 {
@@ -617,6 +663,33 @@ func WriteUint32(w io.Writer, num uint32, byteOrder ByteOrder) (err error) {
 	return
 }
 
+// WriteUint48 - записывает в Writer 6 байт
+func WriteUint48(w io.Writer, num uint64, byteOrder ByteOrder) (err error) {
+	switch byteOrder {
+	case LH:
+		_, err = w.Write([]byte{
+			byte(num),
+			byte(num >> 8),
+			byte(num >> 16),
+			byte(num >> 24),
+			byte(num >> 32),
+			byte(num >> 40),
+		})
+	case HL:
+		_, err = w.Write([]byte{
+			byte(num >> 40),
+			byte(num >> 32),
+			byte(num >> 24),
+			byte(num >> 16),
+			byte(num >> 8),
+			byte(num),
+		})
+	default:
+		err = fmt.Errorf(unknownByteOrder, byteOrder)
+	}
+	return
+}
+
 // WriteUint64 - записывает в Writer 8 байт
 func WriteUint64(w io.Writer, num uint64, byteOrder ByteOrder) (err error) {
 	switch byteOrder {
@@ -873,6 +946,31 @@ func ReadUint32(src io.ByteReader, byteOrder ByteOrder) (num uint32, err error)
 	return
 }
 
+// ReadUint48 - читает из ByteReader arr 6 байт и декодирует их в uint64.
+func ReadUint48(src io.ByteReader, byteOrder ByteOrder) (num uint64, err error) {
+	var (
+		b       byte
+		offsets []uint
+	)
+	switch byteOrder {
+	case LH:
+		offsets = offsets48LH
+	case HL:
+		offsets = offsets48HL
+	default:
+		err = fmt.Errorf(unknownByteOrder, byteOrder)
+		return
+	}
+	for _, off := range offsets {
+		b, err = src.ReadByte()
+		if err != nil {
+			return
+		}
+		num |= uint64(b) << off
+	}
+	return
+}
+
 // ReadUint64 - читает из ByteReader arr 8 байт и декодирует их в uint64.
 func ReadUint64(src io.ByteReader, byteOrder ByteOrder) (num uint64, err error) {
 	var (