Initial Commit

Author: ZeroMemes

.gitignore

@@ -0,0 +1 @@
+.idea

README.md

@@ -0,0 +1,3 @@
+# bitbuf-go
+
+A direct port of [bitbuf](https://github.com/noocene/bitbuf) for Golang

bitbuf.go

@@ -0,0 +1,39 @@
+package bitbuf
+
+type Size uint
+
+type BitBuf interface {
+	Advance(bits Size) error
+	Read(dst []byte, bits Size) (Size, error)
+	ReadAll(dst []byte, bits Size) error
+	ReadAligned(dst []byte) Size
+	ReadAlignedAll(out []byte) error
+	ReadBool() (bool, error)
+	ReadByte() (byte, error)
+	Remaining() Size
+	Len() Size
+}
+
+type BitBufMut interface {
+	Advance(bits Size) error
+	Write(data []byte, bits Size) (Size, error)
+	WriteAll(data []byte, bits Size) error
+	WriteAligned(data []byte) Size
+	WriteAlignedAll(data []byte) error
+	WriteBool(data bool) error
+	WriteByte(data byte) error
+	Remaining() Size
+	Len() Size
+}
+
+type Drain interface {
+	IntoInner() []byte
+	DrainInto(buf BitBufMut) error
+	AsBuf() BitBuf
+}
+
+type Fill interface {
+	IntoInner() []byte
+	FillFrom(buf BitBuf) error
+	AsBuf() BitBuf
+}

drain.go

@@ -0,0 +1,67 @@
+package bitbuf
+
+func NewDrain(buf []byte) Drain {
+	return drain{&transportContainer{
+		buf:    buf,
+		length: 0,
+		capacity: func(data []byte) Size {
+			return Size(len(data)) * 8
+		},
+	}}
+}
+
+func NewCappedDrain(buf []byte, cap Size) Drain {
+	return drain{&transportContainer{
+		buf:    buf,
+		length: 0,
+		capacity: func(data []byte) Size {
+			return cap
+		},
+	}}
+}
+
+func (d drain) IntoInner() []byte {
+	return d.buf
+}
+
+func (d drain) DrainInto(to BitBufMut) error {
+	capacity := d.capacity(d.buf)
+	from := NewBitSlice(d.buf)
+	err := from.Advance(d.length)
+	if err != nil {
+		panic(err)
+	}
+
+	for true {
+		if d.length < capacity {
+			if to.Remaining() >= 8 && capacity-d.length >= 8 {
+				val, err := from.ReadByte()
+				if err != nil {
+					panic(err)
+				}
+				err = to.WriteByte(val)
+				if err != nil {
+					panic(err)
+				}
+				d.length += 8
+			} else {
+				val, err := from.ReadBool()
+				if err != nil {
+					panic(err)
+				}
+				err = to.WriteBool(val)
+				if err != nil {
+					return InsufficientError{}
+				}
+				d.length++
+			}
+		} else {
+			return nil
+		}
+	}
+	return nil
+}
+
+func (d drain) AsBuf() BitBuf {
+	return NewBitSlice(d.buf)
+}

errors.go

@@ -0,0 +1,13 @@
+package bitbuf
+
+type InsufficientError struct{}
+
+func (e InsufficientError) Error() string {
+	return "Insufficient"
+}
+
+type OverflowError struct{}
+
+func (e OverflowError) Error() string {
+	return "Overflow"
+}

fill.go

@@ -0,0 +1,67 @@
+package bitbuf
+
+func NewFill(buf []byte) Fill {
+	return fill{&transportContainer{
+		buf:    buf,
+		length: 0,
+		capacity: func(data []byte) Size {
+			return Size(len(data)) * 8
+		},
+	}}
+}
+
+func NewCappedFill(buf []byte, cap Size) Fill {
+	return fill{&transportContainer{
+		buf:    buf,
+		length: 0,
+		capacity: func(data []byte) Size {
+			return cap
+		},
+	}}
+}
+
+func (f fill) IntoInner() []byte {
+	return f.buf
+}
+
+func (f fill) FillFrom(from BitBuf) error {
+	capacity := f.capacity(f.buf)
+	to := NewBitSliceMut(f.buf)
+	err := to.Advance(f.length)
+	if err != nil {
+		panic(err)
+	}
+
+	for true {
+		if f.length < capacity {
+			if from.Remaining() >= 8 && capacity-f.length >= 8 {
+				val, err := from.ReadByte()
+				if err != nil {
+					panic(err)
+				}
+				err = to.WriteByte(val)
+				if err != nil {
+					panic(err)
+				}
+				f.length += 8
+			} else {
+				val, err := from.ReadBool()
+				if err != nil {
+					panic(err)
+				}
+				err = to.WriteBool(val)
+				if err != nil {
+					return InsufficientError{}
+				}
+				f.length++
+			}
+		} else {
+			return nil
+		}
+	}
+	return nil
+}
+
+func (f fill) AsBuf() BitBuf {
+	return NewBitSlice(f.buf)
+}

go.mod

@@ -0,0 +1,2 @@
+module github.com/cabaletta/bitbuf-go
+go 1.14

internal.go

@@ -0,0 +1,31 @@
+package bitbuf
+
+// hake
+
+type sliceContainer struct {
+	data   []byte
+	offset byte
+	length Size
+}
+
+type transportContainer struct {
+	buf      []byte
+	length   Size
+	capacity func([]byte) Size
+}
+
+type bitSlice struct {
+	*sliceContainer
+}
+
+type bitSliceMut struct {
+	*sliceContainer
+}
+
+type drain struct {
+	*transportContainer
+}
+
+type fill struct {
+	*transportContainer
+}