mirrors/gotosocial
1
0
Fork 0
mirror of https://github.com/superseriousbusiness/gotosocial.git synced 2025-11-04 06:52:26 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

[chore] bump dependencies (#4406)

Browse source 
- codeberg.org/gruf/go-ffmpreg: v0.6.9 -> v0.6.10
- github.com/ncruces/go-sqlite3: v0.27.1 -> v0.28.0
- github.com/stretchr/testify: v1.10.0 -> v1.11.1
- github.com/tdewolff/minify/v2 v2.23.11 -> v2.24.2
- go.opentelemetry.io/otel{,/*}: v1.37.0 -> v1.38.0
- go.opentelemetry.io/contrib/*: v0.62.0 -> v0.63.0

Reviewed-on: https://codeberg.org/superseriousbusiness/gotosocial/pulls/4406
Co-authored-by: kim <grufwub@gmail.com>
Co-committed-by: kim <grufwub@gmail.com>
This commit is contained in:
kim 2025-09-04 15:29:27 +02:00 • committed by kim
commit 78defcd916
274 changed files with 9213 additions and 2368 deletions
Download patch file Download diff file Expand all files Collapse all files

603
vendor/github.com/tdewolff/parse/v2/binary.go generated vendored
View file

@ -5,360 +5,15 @@ import (
"errors"
"fmt"
"io"
"math"
"os"
)
const PageSize = 4096
// BinaryReader is a binary big endian file format reader.
type BinaryReader struct {
Endianness binary.ByteOrder
buf []byte
pos uint32
eof bool
}
// NewBinaryReader returns a big endian binary file format reader.
func NewBinaryReader(buf []byte) *BinaryReader {
if math.MaxUint32 < uint(len(buf)) {
return &BinaryReader{binary.BigEndian, nil, 0, true}
}
return &BinaryReader{binary.BigEndian, buf, 0, false}
}
// NewBinaryReaderLE returns a little endian binary file format reader.
func NewBinaryReaderLE(buf []byte) *BinaryReader {
r := NewBinaryReader(buf)
r.Endianness = binary.LittleEndian
return r
}
// Seek set the reader position in the buffer.
func (r *BinaryReader) Seek(pos uint32) error {
if uint32(len(r.buf)) < pos {
r.eof = true
return io.EOF
}
r.pos = pos
r.eof = false
return nil
}
// Pos returns the reader's position.
func (r *BinaryReader) Pos() uint32 {
return r.pos
}
// Len returns the remaining length of the buffer.
func (r *BinaryReader) Len() uint32 {
return uint32(len(r.buf)) - r.pos
}
// SetLen sets the remaining length of the underlying buffer.
func (r *BinaryReader) SetLen(n uint32) {
r.buf = r.buf[: r.pos+n : r.pos+n]
}
// EOF returns true if we reached the end-of-file.
func (r *BinaryReader) EOF() bool {
return r.eof
}
// Read complies with io.Reader.
func (r *BinaryReader) Read(b []byte) (int, error) {
n := copy(b, r.buf[r.pos:])
r.pos += uint32(n)
if r.pos == uint32(len(r.buf)) {
r.eof = true
return n, io.EOF
}
return n, nil
}
// ReadBytes reads n bytes.
func (r *BinaryReader) ReadBytes(n uint32) []byte {
if r.eof || uint32(len(r.buf))-r.pos < n {
r.eof = true
return nil
}
buf := r.buf[r.pos : r.pos+n : r.pos+n]
r.pos += n
return buf
}
// ReadString reads a string of length n.
func (r *BinaryReader) ReadString(n uint32) string {
return string(r.ReadBytes(n))
}
// ReadByte reads a single byte.
func (r *BinaryReader) ReadByte() byte {
b := r.ReadBytes(1)
if b == nil {
return 0
}
return b[0]
}
// ReadUint8 reads a uint8.
func (r *BinaryReader) ReadUint8() uint8 {
return r.ReadByte()
}
// ReadUint16 reads a uint16.
func (r *BinaryReader) ReadUint16() uint16 {
b := r.ReadBytes(2)
if b == nil {
return 0
}
return r.Endianness.Uint16(b)
}
// ReadUint24 reads a uint24 into a uint32.
func (r *BinaryReader) ReadUint24() uint32 {
b := r.ReadBytes(3)
if b == nil {
return 0
} else if r.Endianness == binary.LittleEndian {
return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16
} else {
return uint32(b[2]) | uint32(b[1])<<8 | uint32(b[0])<<16
}
}
// ReadUint32 reads a uint32.
func (r *BinaryReader) ReadUint32() uint32 {
b := r.ReadBytes(4)
if b == nil {
return 0
}
return r.Endianness.Uint32(b)
}
// ReadUint64 reads a uint64.
func (r *BinaryReader) ReadUint64() uint64 {
b := r.ReadBytes(8)
if b == nil {
return 0
}
return r.Endianness.Uint64(b)
}
// ReadInt8 reads an int8.
func (r *BinaryReader) ReadInt8() int8 {
return int8(r.ReadByte())
}
// ReadInt16 reads an int16.
func (r *BinaryReader) ReadInt16() int16 {
return int16(r.ReadUint16())
}
// ReadInt24 reads a int24 into an int32.
func (r *BinaryReader) ReadInt24() int32 {
return int32(r.ReadUint24())
}
// ReadInt32 reads an int32.
func (r *BinaryReader) ReadInt32() int32 {
return int32(r.ReadUint32())
}
// ReadInt64 reads an int64.
func (r *BinaryReader) ReadInt64() int64 {
return int64(r.ReadUint64())
}
type BinaryFileReader struct {
f *os.File
size uint64
offset uint64
Endianness binary.ByteOrder
buf []byte
pos int
}
func NewBinaryFileReader(f *os.File, chunk int) (*BinaryFileReader, error) {
var buf []byte
var size uint64
if chunk == 0 {
var err error
if buf, err = io.ReadAll(f); err != nil {
return nil, err
}
} else {
buf = make([]byte, 0, chunk)
}
if info, err := f.Stat(); err != nil {
return nil, err
} else {
size = uint64(info.Size())
}
return &BinaryFileReader{
f: f,
size: size,
Endianness: binary.BigEndian,
buf: buf,
}, nil
}
func (r *BinaryFileReader) buffer(pos, length uint64) error {
if pos < r.offset || r.offset+uint64(len(r.buf)) < pos+length {
if math.MaxInt64 < pos {
return fmt.Errorf("seek position too large")
} else if _, err := r.f.Seek(int64(pos), 0); err != nil {
return err
} else if n, err := r.f.Read(r.buf[:cap(r.buf)]); err != nil {
return err
} else {
r.offset = pos
r.buf = r.buf[:n]
r.pos = 0
}
}
return nil
}
// Seek set the reader position in the buffer.
func (r *BinaryFileReader) Seek(pos uint64) error {
if r.size <= pos {
return io.EOF
} else if err := r.buffer(pos, 0); err != nil {
return err
}
r.pos = int(pos - r.offset)
return nil
}
// Pos returns the reader's position.
func (r *BinaryFileReader) Pos() uint64 {
return r.offset + uint64(r.pos)
}
// Len returns the remaining length of the buffer.
func (r *BinaryFileReader) Len() uint64 {
return r.size - r.Pos()
}
// Offset returns the offset of the buffer.
func (r *BinaryFileReader) Offset() uint64 {
return r.offset
}
// BufferLen returns the length of the buffer.
func (r *BinaryFileReader) BufferLen() int {
return len(r.buf)
}
// Read complies with io.Reader.
func (r *BinaryFileReader) Read(b []byte) (int, error) {
if len(b) <= cap(r.buf) {
if err := r.buffer(r.offset+uint64(r.pos), uint64(len(b))); err != nil {
return 0, err
}
n := copy(b, r.buf[r.pos:])
r.pos += n
return n, nil
}
// read directly from file
if _, err := r.f.Seek(int64(r.offset)+int64(r.pos), 0); err != nil {
return 0, err
}
n, err := r.f.Read(b)
r.offset += uint64(r.pos + n)
r.pos = 0
r.buf = r.buf[:0]
return n, err
}
// ReadBytes reads n bytes.
func (r *BinaryFileReader) ReadBytes(n int) []byte {
if n < len(r.buf)-r.pos {
b := r.buf[r.pos : r.pos+n]
r.pos += n
return b
}
b := make([]byte, n)
if _, err := r.Read(b); err != nil {
return nil
}
return b
}
// ReadString reads a string of length n.
func (r *BinaryFileReader) ReadString(n int) string {
return string(r.ReadBytes(n))
}
// ReadByte reads a single byte.
func (r *BinaryFileReader) ReadByte() byte {
b := r.ReadBytes(1)
if b == nil {
return 0
}
return b[0]
}
// ReadUint8 reads a uint8.
func (r *BinaryFileReader) ReadUint8() uint8 {
return r.ReadByte()
}
// ReadUint16 reads a uint16.
func (r *BinaryFileReader) ReadUint16() uint16 {
b := r.ReadBytes(2)
if b == nil {
return 0
}
return r.Endianness.Uint16(b)
}
// ReadUint32 reads a uint32.
func (r *BinaryFileReader) ReadUint32() uint32 {
b := r.ReadBytes(4)
if b == nil {
return 0
}
return r.Endianness.Uint32(b)
}
// ReadUint64 reads a uint64.
func (r *BinaryFileReader) ReadUint64() uint64 {
b := r.ReadBytes(8)
if b == nil {
return 0
}
return r.Endianness.Uint64(b)
}
// ReadInt8 reads a int8.
func (r *BinaryFileReader) ReadInt8() int8 {
return int8(r.ReadByte())
}
// ReadInt16 reads a int16.
func (r *BinaryFileReader) ReadInt16() int16 {
return int16(r.ReadUint16())
}
// ReadInt32 reads a int32.
func (r *BinaryFileReader) ReadInt32() int32 {
return int32(r.ReadUint32())
}
// ReadInt64 reads a int64.
func (r *BinaryFileReader) ReadInt64() int64 {
return int64(r.ReadUint64())
}
type IBinaryReader interface {
Bytes([]byte, int64, int64) ([]byte, error)
Len() int64
Close() error
Len() int
Bytes(int, int64) ([]byte, error)
}
type binaryReaderFile struct {
@ -385,20 +40,21 @@ func (r *binaryReaderFile) Close() error {
}
// Len returns the length of the underlying memory-mapped file.
func (r *binaryReaderFile) Len() int {
return int(r.size)
func (r *binaryReaderFile) Len() int64 {
return r.size
}
func (r *binaryReaderFile) Bytes(n int, off int64) ([]byte, error) {
func (r *binaryReaderFile) Bytes(b []byte, n, off int64) ([]byte, error) {
if _, err := r.f.Seek(off, 0); err != nil {
return nil, err
} else if b == nil {
b = make([]byte, n)
}
b := make([]byte, n)
m, err := r.f.Read(b)
if err != nil {
return nil, err
} else if m != n {
} else if int64(m) != n {
return nil, errors.New("file: could not read all bytes")
}
return b, nil
@ -418,20 +74,26 @@ func (r *binaryReaderBytes) Close() error {
}
// Len returns the length of the underlying memory-mapped file.
func (r *binaryReaderBytes) Len() int {
return len(r.data)
func (r *binaryReaderBytes) Len() int64 {
return int64(len(r.data))
}
func (r *binaryReaderBytes) Bytes(n int, off int64) ([]byte, error) {
if off < 0 || int64(len(r.data)) < off {
return nil, fmt.Errorf("bytes: invalid offset %d", off)
func (r *binaryReaderBytes) Bytes(b []byte, n, off int64) ([]byte, error) {
if off < 0 || n < 0 || int64(len(r.data)) < off || int64(len(r.data))-off < n {
return nil, fmt.Errorf("bytes: invalid range %d--%d", off, off+n)
}
return r.data[off : off+int64(n) : off+int64(n)], nil
data := r.data[off : off+n : off+n]
if b == nil {
return data, nil
}
copy(b, data)
return b, nil
}
type binaryReaderReader struct {
r io.Reader
n int64
size int64
readerAt bool
seeker bool
}
@ -451,31 +113,33 @@ func (r *binaryReaderReader) Close() error {
}
// Len returns the length of the underlying memory-mapped file.
func (r *binaryReaderReader) Len() int {
return int(r.n)
func (r *binaryReaderReader) Len() int64 {
return r.size
}
func (r *binaryReaderReader) Bytes(n int, off int64) ([]byte, error) {
func (r *binaryReaderReader) Bytes(b []byte, n, off int64) ([]byte, error) {
if b == nil {
b = make([]byte, n)
}
// seeker seems faster than readerAt by 10%
if r.seeker {
if _, err := r.r.(io.Seeker).Seek(off, 0); err != nil {
return nil, err
}
b := make([]byte, n)
m, err := r.r.Read(b)
if err != nil {
return nil, err
} else if m != n {
} else if int64(m) != n {
return nil, errors.New("file: could not read all bytes")
}
return b, nil
} else if r.readerAt {
b := make([]byte, n)
m, err := r.r.(io.ReaderAt).ReadAt(b, off)
if err != nil {
return nil, err
} else if m != n {
} else if int64(m) != n {
return nil, errors.New("file: could not read all bytes")
}
return b, nil
@ -483,22 +147,22 @@ func (r *binaryReaderReader) Bytes(n int, off int64) ([]byte, error) {
return nil, errors.New("io.Seeker and io.ReaderAt not implemented")
}
type BinaryReader2 struct {
type BinaryReader struct {
f IBinaryReader
pos int64
err error
Endian binary.ByteOrder
ByteOrder binary.ByteOrder
}
func NewBinaryReader2(f IBinaryReader) *BinaryReader2 {
return &BinaryReader2{
f: f,
Endian: binary.BigEndian,
func NewBinaryReader(f IBinaryReader) *BinaryReader {
return &BinaryReader{
f: f,
ByteOrder: binary.BigEndian,
}
}
func NewBinaryReader2Reader(r io.Reader, n int64) (*BinaryReader2, error) {
func NewBinaryReaderReader(r io.Reader, n int64) (*BinaryReader, error) {
_, isReaderAt := r.(io.ReaderAt)
_, isSeeker := r.(io.Seeker)
@ -512,27 +176,44 @@ func NewBinaryReader2Reader(r io.Reader, n int64) (*BinaryReader2, error) {
}
f = newBinaryReaderBytes(b)
}
return NewBinaryReader2(f), nil
return NewBinaryReader(f), nil
}
func NewBinaryReader2Bytes(data []byte) *BinaryReader2 {
func NewBinaryReaderBytes(data []byte) *BinaryReader {
f := newBinaryReaderBytes(data)
return NewBinaryReader2(f)
return NewBinaryReader(f)
}
func NewBinaryReader2File(filename string) (*BinaryReader2, error) {
func NewBinaryReaderFile(filename string) (*BinaryReader, error) {
f, err := newBinaryReaderFile(filename)
if err != nil {
return nil, err
}
return NewBinaryReader2(f), nil
return NewBinaryReader(f), nil
}
func (r *BinaryReader2) Err() error {
func (r *BinaryReader) IBinaryReader() IBinaryReader {
return r.f
}
func (r *BinaryReader) Clone() *BinaryReader {
f := r.f
if cloner, ok := f.(interface{ Clone() IBinaryReader }); ok {
f = cloner.Clone()
}
return &BinaryReader{
f: f,
pos: r.pos,
err: r.err,
ByteOrder: r.ByteOrder,
}
}
func (r *BinaryReader) Err() error {
return r.err
}
func (r *BinaryReader2) Close() error {
func (r *BinaryReader) Close() error {
if err := r.f.Close(); err != nil {
return err
}
@ -540,68 +221,90 @@ func (r *BinaryReader2) Close() error {
}
// InPageCache returns true if the range is already in the page cache (for mmap).
func (r *BinaryReader2) InPageCache(start, end int64) bool {
index := int64(r.Pos()) / PageSize
func (r *BinaryReader) InPageCache(start, end int64) bool {
index := r.Pos() / PageSize
return start/PageSize == index && end/PageSize == index
}
// Free frees all previously read bytes, you cannot seek from before this position (for reader).
func (r *BinaryReader2) Free() {
}
// Pos returns the reader's position.
func (r *BinaryReader2) Pos() int64 {
func (r *BinaryReader) Pos() int64 {
return r.pos
}
// Len returns the remaining length of the buffer.
func (r *BinaryReader2) Len() int {
return int(int64(r.f.Len()) - int64(r.pos))
func (r *BinaryReader) Len() int64 {
return r.f.Len() - r.pos
}
func (r *BinaryReader2) Seek(pos int64) {
r.pos = pos
// Seek complies with io.Seeker.
func (r *BinaryReader) Seek(off int64, whence int) (int64, error) {
if whence == 0 {
if off < 0 || r.f.Len() < off {
return 0, fmt.Errorf("invalid offset")
}
r.pos = off
} else if whence == 1 {
if r.pos+off < 0 || r.f.Len() < r.pos+off {
return 0, fmt.Errorf("invalid offset")
}
r.pos += off
} else if whence == 2 {
if off < -r.f.Len() || 0 < off {
return 0, fmt.Errorf("invalid offset")
}
r.pos = r.f.Len() - off
} else {
return 0, fmt.Errorf("invalid whence")
}
return r.pos, nil
}
// Read complies with io.Reader.
func (r *BinaryReader2) Read(b []byte) (int, error) {
data, err := r.f.Bytes(len(b), r.pos)
func (r *BinaryReader) Read(b []byte) (int, error) {
data, err := r.f.Bytes(b, int64(len(b)), r.pos)
if err != nil && err != io.EOF {
return 0, err
}
n := copy(b, data)
r.pos += int64(len(b))
return n, err
r.pos += int64(len(data))
return len(data), err
}
// ReadAt complies with io.ReaderAt.
func (r *BinaryReader2) ReadAt(b []byte, off int64) (int, error) {
data, err := r.f.Bytes(len(b), off)
func (r *BinaryReader) ReadAt(b []byte, off int64) (int, error) {
data, err := r.f.Bytes(b, int64(len(b)), off)
if err != nil && err != io.EOF {
return 0, err
}
n := copy(b, data)
return n, err
return len(data), err
}
// ReadBytes reads n bytes.
func (r *BinaryReader2) ReadBytes(n int) []byte {
data, err := r.f.Bytes(n, r.pos)
func (r *BinaryReader) ReadBytes(n int64) []byte {
data, err := r.f.Bytes(nil, n, r.pos)
if err != nil {
r.err = err
return nil
}
r.pos += int64(n)
r.pos += n
return data
}
// ReadString reads a string of length n.
func (r *BinaryReader2) ReadString(n int) string {
func (r *BinaryReader) ReadString(n int64) string {
return string(r.ReadBytes(n))
}
// ReadByte reads a single byte.
func (r *BinaryReader2) ReadByte() byte {
func (r *BinaryReader) ReadByte() (byte, error) {
data := r.ReadBytes(1)
if data == nil {
return 0, r.err
}
return data[0], nil
}
// ReadUint8 reads a uint8.
func (r *BinaryReader) ReadUint8() uint8 {
data := r.ReadBytes(1)
if data == nil {
return 0
@ -609,81 +312,93 @@ func (r *BinaryReader2) ReadByte() byte {
return data[0]
}
// ReadUint8 reads a uint8.
func (r *BinaryReader2) ReadUint8() uint8 {
return r.ReadByte()
}
// ReadUint16 reads a uint16.
func (r *BinaryReader2) ReadUint16() uint16 {
func (r *BinaryReader) ReadUint16() uint16 {
data := r.ReadBytes(2)
if data == nil {
return 0
} else if r.Endian == binary.LittleEndian {
} else if r.ByteOrder == binary.LittleEndian {
return uint16(data[1])<<8 | uint16(data[0])
}
return uint16(data[0])<<8 | uint16(data[1])
}
// ReadUint24 reads a uint24 into a uint32.
func (r *BinaryReader) ReadUint24() uint32 {
b := r.ReadBytes(3)
if b == nil {
return 0
} else if r.ByteOrder == binary.LittleEndian {
return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16
} else {
return uint32(b[2]) | uint32(b[1])<<8 | uint32(b[0])<<16
}
}
// ReadUint32 reads a uint32.
func (r *BinaryReader2) ReadUint32() uint32 {
func (r *BinaryReader) ReadUint32() uint32 {
data := r.ReadBytes(4)
if data == nil {
return 0
} else if r.Endian == binary.LittleEndian {
} else if r.ByteOrder == binary.LittleEndian {
return uint32(data[3])<<24 | uint32(data[2])<<16 | uint32(data[1])<<8 | uint32(data[0])
}
return uint32(data[0])<<24 | uint32(data[1])<<16 | uint32(data[2])<<8 | uint32(data[3])
}
// ReadUint64 reads a uint64.
func (r *BinaryReader2) ReadUint64() uint64 {
func (r *BinaryReader) ReadUint64() uint64 {
data := r.ReadBytes(8)
if data == nil {
return 0
} else if r.Endian == binary.LittleEndian {
} else if r.ByteOrder == binary.LittleEndian {
return uint64(data[7])<<56 | uint64(data[6])<<48 | uint64(data[5])<<40 | uint64(data[4])<<32 | uint64(data[3])<<24 | uint64(data[2])<<16 | uint64(data[1])<<8 | uint64(data[0])
}
return uint64(data[0])<<56 | uint64(data[1])<<48 | uint64(data[2])<<40 | uint64(data[3])<<32 | uint64(data[4])<<24 | uint64(data[5])<<16 | uint64(data[6])<<8 | uint64(data[7])
}
// ReadInt8 reads a int8.
func (r *BinaryReader2) ReadInt8() int8 {
return int8(r.ReadByte())
func (r *BinaryReader) ReadInt8() int8 {
return int8(r.ReadUint8())
}
// ReadInt16 reads a int16.
func (r *BinaryReader2) ReadInt16() int16 {
func (r *BinaryReader) ReadInt16() int16 {
return int16(r.ReadUint16())
}
// ReadInt24 reads a int24 into an int32.
func (r *BinaryReader) ReadInt24() int32 {
return int32(r.ReadUint24())
}
// ReadInt32 reads a int32.
func (r *BinaryReader2) ReadInt32() int32 {
func (r *BinaryReader) ReadInt32() int32 {
return int32(r.ReadUint32())
}
// ReadInt64 reads a int64.
func (r *BinaryReader2) ReadInt64() int64 {
func (r *BinaryReader) ReadInt64() int64 {
return int64(r.ReadUint64())
}
// BinaryWriter is a big endian binary file format writer.
type BinaryWriter struct {
buf []byte
Endian binary.ByteOrder
buf []byte
ByteOrder binary.AppendByteOrder
}
// NewBinaryWriter returns a big endian binary file format writer.
func NewBinaryWriter(buf []byte) *BinaryWriter {
return &BinaryWriter{
buf: buf,
Endian: binary.BigEndian,
buf: buf,
ByteOrder: binary.BigEndian,
}
}
// Len returns the buffer's length in bytes.
func (w *BinaryWriter) Len() uint32 {
return uint32(len(w.buf))
func (w *BinaryWriter) Len() int64 {
return int64(len(w.buf))
}
// Bytes returns the buffer's bytes.
@ -719,23 +434,26 @@ func (w *BinaryWriter) WriteUint8(v uint8) {
// WriteUint16 writes the given uint16 to the buffer.
func (w *BinaryWriter) WriteUint16(v uint16) {
pos := len(w.buf)
w.buf = append(w.buf, make([]byte, 2)...)
w.Endian.PutUint16(w.buf[pos:], v)
w.buf = w.ByteOrder.AppendUint16(w.buf, v)
}
// WriteUint24 writes the given uint32 as a uint24 to the buffer.
func (w *BinaryWriter) WriteUint24(v uint32) {
if w.ByteOrder == binary.LittleEndian {
w.buf = append(w.buf, byte(v), byte(v>>8), byte(v>>16))
} else {
w.buf = append(w.buf, byte(v>>16), byte(v>>8), byte(v))
}
}
// WriteUint32 writes the given uint32 to the buffer.
func (w *BinaryWriter) WriteUint32(v uint32) {
pos := len(w.buf)
w.buf = append(w.buf, make([]byte, 4)...)
w.Endian.PutUint32(w.buf[pos:], v)
w.buf = w.ByteOrder.AppendUint32(w.buf, v)
}
// WriteUint64 writes the given uint64 to the buffer.
func (w *BinaryWriter) WriteUint64(v uint64) {
pos := len(w.buf)
w.buf = append(w.buf, make([]byte, 8)...)
w.Endian.PutUint64(w.buf[pos:], v)
w.buf = w.ByteOrder.AppendUint64(w.buf, v)
}
// WriteInt8 writes the given int8 to the buffer.
@ -748,6 +466,11 @@ func (w *BinaryWriter) WriteInt16(v int16) {
w.WriteUint16(uint16(v))
}
// WriteInt24 writes the given int32 as an in24 to the buffer.
func (w *BinaryWriter) WriteInt24(v int32) {
w.WriteUint24(uint32(v))
}
// WriteInt32 writes the given int32 to the buffer.
func (w *BinaryWriter) WriteInt32(v int32) {
w.WriteUint32(uint32(v))
@ -794,7 +517,7 @@ func (r *BitmapReader) Read() bool {
// BitmapWriter is a binary bitmap writer.
type BitmapWriter struct {
buf []byte
pos uint32
pos uint64
}
// NewBitmapWriter returns a binary bitmap writer.
@ -803,8 +526,8 @@ func NewBitmapWriter(buf []byte) *BitmapWriter {
}
// Len returns the buffer's length in bytes.
func (w *BitmapWriter) Len() uint32 {
return uint32(len(w.buf))
func (w *BitmapWriter) Len() int64 {
return int64(len(w.buf))
}
// Bytes returns the buffer's bytes.
@ -814,7 +537,7 @@ func (w *BitmapWriter) Bytes() []byte {
// Write writes the next bit.
func (w *BitmapWriter) Write(bit bool) {
if uint32(len(w.buf)) <= (w.pos+1)/8 {
if uint64(len(w.buf)) <= (w.pos+1)/8 {
w.buf = append(w.buf, 0)
}
if bit {