mirror of
https://github.com/go-gitea/gitea.git
synced 2024-08-25 21:44:20 -04:00
* denisenkom/go-mssqldb untagged -> v0.9.0 * github.com/editorconfig/editorconfig-core-go v2.3.7 -> v2.3.8 * github.com/go-testfixtures/testfixtures v3.4.0 -> v3.4.1 * github.com/mholt/archiver v3.3.2 -> v3.5.0 * github.com/olivere/elastic v7.0.20 -> v7.0.21 * github.com/urfave/cli v1.22.4 -> v1.22.5 * github.com/xanzy/go-gitlab v0.38.1 -> v0.39.0 * github.com/yuin/goldmark-meta untagged -> v1.0.0 * github.com/ethantkoenig/rupture 0a76f03a811a -> c3b3b810dc77 * github.com/jaytaylor/html2text 8fb95d837f7d -> 3577fbdbcff7 * github.com/kballard/go-shellquote cd60e84ee657 -> 95032a82bc51 * github.com/msteinert/pam 02ccfbfaf0cc -> 913b8f8cdf8b * github.com/unknwon/paginater 7748a72e0141 -> 042474bd0eae * CI.restart() Co-authored-by: techknowlogick <techknowlogick@gitea.io>
134 lines
2.9 KiB
Go
Vendored
134 lines
2.9 KiB
Go
Vendored
// +build !amd64,!386,!arm,!arm64,!ppc64le,!mipsle,!mips64le,!mips64p32le,!wasm appengine
|
|
|
|
package roaring
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"errors"
|
|
"io"
|
|
)
|
|
|
|
func (b *arrayContainer) writeTo(stream io.Writer) (int, error) {
|
|
buf := make([]byte, 2*len(b.content))
|
|
for i, v := range b.content {
|
|
base := i * 2
|
|
buf[base] = byte(v)
|
|
buf[base+1] = byte(v >> 8)
|
|
}
|
|
return stream.Write(buf)
|
|
}
|
|
|
|
func (b *arrayContainer) readFrom(stream io.Reader) (int, error) {
|
|
err := binary.Read(stream, binary.LittleEndian, b.content)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return 2 * len(b.content), nil
|
|
}
|
|
|
|
func (b *bitmapContainer) writeTo(stream io.Writer) (int, error) {
|
|
if b.cardinality <= arrayDefaultMaxSize {
|
|
return 0, errors.New("refusing to write bitmap container with cardinality of array container")
|
|
}
|
|
|
|
// Write set
|
|
buf := make([]byte, 8*len(b.bitmap))
|
|
for i, v := range b.bitmap {
|
|
base := i * 8
|
|
buf[base] = byte(v)
|
|
buf[base+1] = byte(v >> 8)
|
|
buf[base+2] = byte(v >> 16)
|
|
buf[base+3] = byte(v >> 24)
|
|
buf[base+4] = byte(v >> 32)
|
|
buf[base+5] = byte(v >> 40)
|
|
buf[base+6] = byte(v >> 48)
|
|
buf[base+7] = byte(v >> 56)
|
|
}
|
|
return stream.Write(buf)
|
|
}
|
|
|
|
func (b *bitmapContainer) readFrom(stream io.Reader) (int, error) {
|
|
err := binary.Read(stream, binary.LittleEndian, b.bitmap)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
b.computeCardinality()
|
|
return 8 * len(b.bitmap), nil
|
|
}
|
|
|
|
func (bc *bitmapContainer) asLittleEndianByteSlice() []byte {
|
|
by := make([]byte, len(bc.bitmap)*8)
|
|
for i := range bc.bitmap {
|
|
binary.LittleEndian.PutUint64(by[i*8:], bc.bitmap[i])
|
|
}
|
|
return by
|
|
}
|
|
|
|
func uint64SliceAsByteSlice(slice []uint64) []byte {
|
|
by := make([]byte, len(slice)*8)
|
|
|
|
for i, v := range slice {
|
|
binary.LittleEndian.PutUint64(by[i*8:], v)
|
|
}
|
|
|
|
return by
|
|
}
|
|
|
|
func uint16SliceAsByteSlice(slice []uint16) []byte {
|
|
by := make([]byte, len(slice)*2)
|
|
|
|
for i, v := range slice {
|
|
binary.LittleEndian.PutUint16(by[i*2:], v)
|
|
}
|
|
|
|
return by
|
|
}
|
|
|
|
func byteSliceAsUint16Slice(slice []byte) []uint16 {
|
|
if len(slice)%2 != 0 {
|
|
panic("Slice size should be divisible by 2")
|
|
}
|
|
|
|
b := make([]uint16, len(slice)/2)
|
|
|
|
for i := range b {
|
|
b[i] = binary.LittleEndian.Uint16(slice[2*i:])
|
|
}
|
|
|
|
return b
|
|
}
|
|
|
|
func byteSliceAsUint64Slice(slice []byte) []uint64 {
|
|
if len(slice)%8 != 0 {
|
|
panic("Slice size should be divisible by 8")
|
|
}
|
|
|
|
b := make([]uint64, len(slice)/8)
|
|
|
|
for i := range b {
|
|
b[i] = binary.LittleEndian.Uint64(slice[8*i:])
|
|
}
|
|
|
|
return b
|
|
}
|
|
|
|
// Converts a byte slice to a interval16 slice.
|
|
// The function assumes that the slice byte buffer is run container data
|
|
// encoded according to Roaring Format Spec
|
|
func byteSliceAsInterval16Slice(byteSlice []byte) []interval16 {
|
|
if len(byteSlice)%4 != 0 {
|
|
panic("Slice size should be divisible by 4")
|
|
}
|
|
|
|
intervalSlice := make([]interval16, len(byteSlice)/4)
|
|
|
|
for i := range intervalSlice {
|
|
intervalSlice[i] = interval16{
|
|
start: binary.LittleEndian.Uint16(byteSlice[i*4:]),
|
|
length: binary.LittleEndian.Uint16(byteSlice[i*4+2:]),
|
|
}
|
|
}
|
|
|
|
return intervalSlice
|
|
}
|