wp
This commit is contained in:
@@ -144,7 +144,7 @@ func TestCumdeltaBound(t *testing.T) {
|
|||||||
c.Append(191)
|
c.Append(191)
|
||||||
|
|
||||||
fmt.Printf("pos: %d\n", c.pos)
|
fmt.Printf("pos: %d\n", c.pos)
|
||||||
fmt.Printf("%d\n", buf.Chunks()[0])
|
fmt.Printf("%d\n", c.Chunks())
|
||||||
//////////////////////////
|
//////////////////////////
|
||||||
|
|
||||||
c.Lock()
|
c.Lock()
|
||||||
@@ -155,7 +155,7 @@ func TestCumdeltaBound(t *testing.T) {
|
|||||||
c.Append(305)
|
c.Append(305)
|
||||||
|
|
||||||
fmt.Printf("pos: %d\n", c.pos)
|
fmt.Printf("pos: %d\n", c.pos)
|
||||||
fmt.Printf("%d\n", buf.Chunks()[0])
|
fmt.Printf("%d\n", c.Chunks())
|
||||||
|
|
||||||
d := NewReverseCumulativeDeltaDecompressor(buf, c.Size(), fracDigits)
|
d := NewReverseCumulativeDeltaDecompressor(buf, c.Size(), fracDigits)
|
||||||
d.RestoreFromEnd()
|
d.RestoreFromEnd()
|
||||||
@@ -205,7 +205,7 @@ func TestInsdeltaBound(t *testing.T) {
|
|||||||
c.Append(191)
|
c.Append(191)
|
||||||
|
|
||||||
fmt.Printf("pos: %d\n", c.pos)
|
fmt.Printf("pos: %d\n", c.pos)
|
||||||
fmt.Printf("%d\n", buf.Chunks()[0])
|
fmt.Printf("%d\n", c.Chunks())
|
||||||
//////////////////////////
|
//////////////////////////
|
||||||
|
|
||||||
//bound := c.GetState()
|
//bound := c.GetState()
|
||||||
@@ -216,7 +216,7 @@ func TestInsdeltaBound(t *testing.T) {
|
|||||||
c.Append(305)
|
c.Append(305)
|
||||||
|
|
||||||
fmt.Printf("pos: %d\n", c.pos)
|
fmt.Printf("pos: %d\n", c.pos)
|
||||||
fmt.Printf("%d\n", buf.Chunks()[0])
|
fmt.Printf("%d\n", c.Chunks())
|
||||||
|
|
||||||
d := NewReverseInstantDeltaDecompressor(buf, c.Size(), fracDigits)
|
d := NewReverseInstantDeltaDecompressor(buf, c.Size(), fracDigits)
|
||||||
d.RestoreFromEnd()
|
d.RestoreFromEnd()
|
||||||
@@ -265,7 +265,7 @@ func TestInsdeltaBound2(t *testing.T) {
|
|||||||
c.Append(130)
|
c.Append(130)
|
||||||
|
|
||||||
fmt.Printf("pos: %d\n", c.pos)
|
fmt.Printf("pos: %d\n", c.pos)
|
||||||
fmt.Printf("%d\n", buf.Chunks()[0])
|
fmt.Printf("%d\n", c.Chunks())
|
||||||
//////////////////////////
|
//////////////////////////
|
||||||
|
|
||||||
//bound := c.GetState()
|
//bound := c.GetState()
|
||||||
@@ -276,7 +276,7 @@ func TestInsdeltaBound2(t *testing.T) {
|
|||||||
c.Append(10)
|
c.Append(10)
|
||||||
|
|
||||||
fmt.Printf("pos: %d\n", c.pos)
|
fmt.Printf("pos: %d\n", c.pos)
|
||||||
fmt.Printf("%d\n", buf.Chunks()[0])
|
fmt.Printf("%d\n", c.Chunks())
|
||||||
|
|
||||||
d := NewReverseInstantDeltaDecompressor(buf, c.Size(), fracDigits)
|
d := NewReverseInstantDeltaDecompressor(buf, c.Size(), fracDigits)
|
||||||
d.RestoreFromEnd()
|
d.RestoreFromEnd()
|
||||||
|
|||||||
@@ -7,7 +7,6 @@ import (
|
|||||||
|
|
||||||
bin "gordenko.dev/dima/bin/little"
|
bin "gordenko.dev/dima/bin/little"
|
||||||
"gordenko.dev/dima/qb"
|
"gordenko.dev/dima/qb"
|
||||||
"gordenko.dev/dima/qb/conbuf"
|
|
||||||
)
|
)
|
||||||
|
|
||||||
// COMPRESSOR REVERSE
|
// COMPRESSOR REVERSE
|
||||||
@@ -209,25 +208,26 @@ func (s *ReverseCumulativeDeltaCompressor) Offset() int {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (s *ReverseCumulativeDeltaCompressor) Snapshot() ([]byte, int) {
|
func (s *ReverseCumulativeDeltaCompressor) Snapshot() ([]byte, int) {
|
||||||
if s.state == nil {
|
// if s.state == nil {
|
||||||
return s.buf, s.Size()
|
// return s.buf, s.Size()
|
||||||
}
|
// }
|
||||||
// ВАЖЛИВО!
|
// // ВАЖЛИВО!
|
||||||
// Треба відтворити стан останнього чанка
|
// // Треба відтворити стан останнього чанка
|
||||||
var (
|
// var (
|
||||||
pos = s.state.Pos
|
// pos = s.state.Pos
|
||||||
chunk = make([]byte, conbuf.ChunkSize)
|
// chunk = make([]byte, conbuf.ChunkSize)
|
||||||
lastChunkIdx = len(s.state.Chunks) - 1
|
// lastChunkIdx = len(s.state.Chunks) - 1
|
||||||
qtyToCopy = pos % conbuf.ChunkSize
|
// qtyToCopy = pos % conbuf.ChunkSize
|
||||||
)
|
// )
|
||||||
copy(chunk, s.state.Chunks[lastChunkIdx][:qtyToCopy])
|
// copy(chunk, s.state.Chunks[lastChunkIdx][:qtyToCopy])
|
||||||
chunks := append(s.state.Chunks[:lastChunkIdx], chunk)
|
// chunks := append(s.state.Chunks[:lastChunkIdx], chunk)
|
||||||
|
|
||||||
buf := conbuf.New(chunks)
|
// buf := conbuf.New(chunks)
|
||||||
pos += buf.ReversePutVarUint64(pos, s.state.LastDelta)
|
// pos += buf.ReversePutVarUint64(pos, s.state.LastDelta)
|
||||||
buf.SetByte(pos, s.state.H)
|
// buf.SetByte(pos, s.state.H)
|
||||||
pos++
|
// pos++
|
||||||
return chunks, pos
|
// return chunks, pos
|
||||||
|
return nil, 0
|
||||||
}
|
}
|
||||||
|
|
||||||
func (s *ReverseCumulativeDeltaCompressor) CreateDecompressor(fracDigits byte) qb.ValueDecompressor {
|
func (s *ReverseCumulativeDeltaCompressor) CreateDecompressor(fracDigits byte) qb.ValueDecompressor {
|
||||||
|
|||||||
@@ -7,7 +7,6 @@ import (
|
|||||||
|
|
||||||
"gordenko.dev/dima/qb"
|
"gordenko.dev/dima/qb"
|
||||||
"gordenko.dev/dima/qb/bin"
|
"gordenko.dev/dima/qb/bin"
|
||||||
"gordenko.dev/dima/qb/conbuf"
|
|
||||||
)
|
)
|
||||||
|
|
||||||
type ReverseInstantDeltaCompressor struct {
|
type ReverseInstantDeltaCompressor struct {
|
||||||
@@ -181,25 +180,26 @@ func (s *ReverseInstantDeltaCompressor) Offset() int {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (s *ReverseInstantDeltaCompressor) Snapshot() ([]byte, int) {
|
func (s *ReverseInstantDeltaCompressor) Snapshot() ([]byte, int) {
|
||||||
if s.state == nil {
|
// if s.state == nil {
|
||||||
return s.buf, s.Size()
|
// return s.buf, s.Size()
|
||||||
}
|
// }
|
||||||
// ВАЖЛИВО!
|
// // ВАЖЛИВО!
|
||||||
// Треба відтворити стан останнього чанка
|
// // Треба відтворити стан останнього чанка
|
||||||
var (
|
// var (
|
||||||
pos = s.state.Pos
|
// pos = s.state.Pos
|
||||||
chunk = make([]byte, conbuf.ChunkSize)
|
// chunk = make([]byte, conbuf.ChunkSize)
|
||||||
lastChunkIdx = len(s.state.Chunks) - 1
|
// lastChunkIdx = len(s.state.Chunks) - 1
|
||||||
qtyToCopy = pos % conbuf.ChunkSize
|
// qtyToCopy = pos % conbuf.ChunkSize
|
||||||
)
|
// )
|
||||||
copy(chunk, s.state.Chunks[lastChunkIdx][:qtyToCopy])
|
// copy(chunk, s.state.Chunks[lastChunkIdx][:qtyToCopy])
|
||||||
chunks := append(s.state.Chunks[:lastChunkIdx], chunk)
|
// chunks := append(s.state.Chunks[:lastChunkIdx], chunk)
|
||||||
|
|
||||||
buf := conbuf.New(chunks)
|
// buf := conbuf.New(chunks)
|
||||||
pos += buf.ReversePutVarInt64(pos, s.state.LastDelta)
|
// pos += buf.ReversePutVarInt64(pos, s.state.LastDelta)
|
||||||
buf.SetByte(pos, s.state.H)
|
// buf.SetByte(pos, s.state.H)
|
||||||
pos++
|
// pos++
|
||||||
return chunks, pos
|
// return chunks, pos
|
||||||
|
return nil, 0
|
||||||
}
|
}
|
||||||
|
|
||||||
func (s *ReverseInstantDeltaCompressor) CreateDecompressor(fracDigits byte) qb.ValueDecompressor {
|
func (s *ReverseInstantDeltaCompressor) CreateDecompressor(fracDigits byte) qb.ValueDecompressor {
|
||||||
|
|||||||
@@ -7,7 +7,6 @@ import (
|
|||||||
bin "gordenko.dev/dima/bin/little"
|
bin "gordenko.dev/dima/bin/little"
|
||||||
"gordenko.dev/dima/pretty"
|
"gordenko.dev/dima/pretty"
|
||||||
"gordenko.dev/dima/qb"
|
"gordenko.dev/dima/qb"
|
||||||
"gordenko.dev/dima/qb/conbuf"
|
|
||||||
)
|
)
|
||||||
|
|
||||||
/*
|
/*
|
||||||
@@ -35,22 +34,22 @@ func NewReverseTimeDeltaCompressor(buf []byte, size int) *ReverseTimeDeltaCompre
|
|||||||
buf: buf,
|
buf: buf,
|
||||||
pos: size, // перший вільний байт
|
pos: size, // перший вільний байт
|
||||||
}
|
}
|
||||||
if size > 0 {
|
// if size > 0 {
|
||||||
u64, n, err := bin.ReverseGetVarUint64(s.buf[:s.pos-1])
|
// u64, n, err := bin.ReverseGetVarUint64(s.buf[:s.pos-1])
|
||||||
if err != nil {
|
// if err != nil {
|
||||||
log.Fatalf("bug: get last unixtime: %s", err)
|
// log.Fatalf("bug: get last unixtime: %s", err)
|
||||||
}
|
// }
|
||||||
s.lastUnixtime = uint32(u64)
|
// s.lastUnixtime = uint32(u64)
|
||||||
s.pos -= n
|
// s.pos -= n
|
||||||
if s.pos > 0 {
|
// if s.pos > 0 {
|
||||||
s.h = s.buf[s.pos-1]
|
// s.h = s.buf[s.pos-1]
|
||||||
u64, s.lastDeltaSize, err = bin.ReverseGetVarUint64(s.buf[:s.pos-2])
|
// u64, s.lastDeltaSize, err = bin.ReverseGetVarUint64(s.buf[:s.pos-2])
|
||||||
if err != nil {
|
// if err != nil {
|
||||||
log.Fatalf("bug: get last delta: %s", err)
|
// log.Fatalf("bug: get last delta: %s", err)
|
||||||
}
|
// }
|
||||||
s.lastDelta = uint32(u64)
|
// s.lastDelta = uint32(u64)
|
||||||
}
|
// }
|
||||||
}
|
// }
|
||||||
return s
|
return s
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -58,99 +57,176 @@ func (s *ReverseTimeDeltaCompressor) Size() int {
|
|||||||
return s.pos
|
return s.pos
|
||||||
}
|
}
|
||||||
|
|
||||||
func (s *ReverseTimeDeltaCompressor) CalcRequiredSpace(value uint32) int {
|
const hSize = 1
|
||||||
return 0
|
|
||||||
|
// retrun
|
||||||
|
func (s *ReverseTimeDeltaCompressor) CalcRequiredSpace(unixtime uint32) (code int, size int) {
|
||||||
|
if s.lastUnixtime > 0 {
|
||||||
|
delta := unixtime - s.lastUnixtime
|
||||||
|
if s.lastDelta > 0 {
|
||||||
|
// 3rd value
|
||||||
|
if s.h < 128 {
|
||||||
|
// run
|
||||||
|
if delta == s.lastDelta && s.h < 127 {
|
||||||
|
code = incementRun
|
||||||
|
} else {
|
||||||
|
code = endOfSeries
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
// literal
|
||||||
|
if delta != s.lastDelta {
|
||||||
|
if s.h < 255 {
|
||||||
|
code = incementLiteral
|
||||||
|
} else {
|
||||||
|
code = endOfSeries
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
code = startRun
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
code = add1stDelta
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
code = addUnixtime
|
||||||
|
}
|
||||||
|
|
||||||
|
if code != addUnixtime {
|
||||||
|
size = hSize
|
||||||
|
if code != incementRun {
|
||||||
|
size += bin.CountVarUint64(uint64(unixtime))
|
||||||
|
if code == endOfSeries {
|
||||||
|
size += hSize
|
||||||
|
} else if code == startRun && s.h > 128 {
|
||||||
|
// need end of literal series
|
||||||
|
size += hSize
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
size = 4
|
||||||
|
}
|
||||||
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
func (s *ReverseTimeDeltaCompressor) Append(unixtime uint32) {
|
const (
|
||||||
if s.lastUnixtime > 0 {
|
addUnixtime = 0
|
||||||
// base value
|
incementRun = 1
|
||||||
//s.pos += s.buf.PutVarUint64(s.pos, uint64(value*s.coef))
|
incementLiteral = 2
|
||||||
//s.baseValue = value
|
endOfSeries = 3
|
||||||
//s.appendNewLiteral(0)
|
startRun = 4
|
||||||
|
add1stDelta = 5
|
||||||
|
)
|
||||||
|
|
||||||
//} else {
|
func (s *ReverseTimeDeltaCompressor) Append(code int, unixtime uint32) {
|
||||||
delta := unixtime - s.lastUnixtime
|
delta := unixtime - s.lastUnixtime
|
||||||
if delta == s.lastDelta {
|
switch code {
|
||||||
if s.h < 128 {
|
case incementRun:
|
||||||
// run блок - отже треба збільшити лічильник
|
|
||||||
if s.h < 127 {
|
|
||||||
// increase counter
|
|
||||||
s.h++
|
s.h++
|
||||||
s.buf[s.pos-1] = s.h
|
case incementLiteral:
|
||||||
} else {
|
// // white s.lastDelta
|
||||||
// не можу збільшити - буде переповнення. Додаю новий literal блок
|
//s.lastDelta = delta
|
||||||
// counter overflow
|
s.h++
|
||||||
s.appendNewLiteral(delta)
|
case endOfSeries:
|
||||||
}
|
// write h - end of series
|
||||||
} else {
|
s.lastDelta = delta
|
||||||
// literal блок.
|
s.h = 128 // new literal (length=1)
|
||||||
// Якщо в ньому лише одне значення - перетворюю його на run блок.
|
case startRun:
|
||||||
// Інакше забираю останнє значення із literal блока і додаю новий run блок.
|
if s.h > 128 { //
|
||||||
q := s.h & 127
|
// write h - end literal series if length > 1
|
||||||
if q == 0 { // 1 кодується як 0
|
|
||||||
s.convertLiteralToRun()
|
|
||||||
} else {
|
|
||||||
// забираю останнє значення із literal блоку щоб зробити run блок
|
|
||||||
s.convertLastFromLiteralToRun()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
if s.h < 127 { // fix 128?
|
|
||||||
// end of run
|
|
||||||
s.appendNewLiteral(delta)
|
|
||||||
} else {
|
|
||||||
if s.h < 255 {
|
|
||||||
// encode value from pos - 1, then append h byte
|
|
||||||
s.appendDeltaToLiteral(delta)
|
|
||||||
} else {
|
|
||||||
// overflowed - encode new
|
|
||||||
s.appendNewLiteral(delta)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
// last literal convert to run (length=2)
|
||||||
|
// write delta
|
||||||
|
s.h = 0 // run, length=2
|
||||||
|
|
||||||
|
case add1stDelta:
|
||||||
|
s.lastDelta = delta
|
||||||
}
|
}
|
||||||
|
// 1st value
|
||||||
s.lastUnixtime = unixtime
|
s.lastUnixtime = unixtime
|
||||||
}
|
}
|
||||||
|
|
||||||
func (s *ReverseTimeDeltaCompressor) convertLastFromLiteralToRun() {
|
// func (s *ReverseTimeDeltaCompressor) Append(unixtime uint32) {
|
||||||
// Зменшую кількість елементів в literal блоці
|
// if s.lastUnixtime > 0 {
|
||||||
s.h--
|
// delta := unixtime - s.lastUnixtime
|
||||||
s.pos -= 1 + s.lastDeltaSize
|
// if s.lastDelta > 0 {
|
||||||
s.buf[s.pos] = s.h // закриваю literal блок
|
// // 3rd value
|
||||||
s.pos++
|
// if s.h < 128 {
|
||||||
s.lastDeltaSize, _ = bin.ReversePutVarUint64(s.buf[s.pos:], uint64(s.lastDelta))
|
// // run
|
||||||
s.pos += s.lastDeltaSize
|
// if delta == s.lastDelta && s.h < 127 {
|
||||||
s.h = 0 // run блок, довжини 2
|
// s.h++
|
||||||
s.buf[s.pos] = s.h
|
// } else {
|
||||||
s.pos++
|
// //write h - end of run
|
||||||
}
|
// s.lastDelta = delta
|
||||||
|
// s.h = 128 // new literal (length=1)
|
||||||
|
// }
|
||||||
|
// } else {
|
||||||
|
// // literal
|
||||||
|
// if delta == s.lastDelta {
|
||||||
|
// if s.h > 128 { //
|
||||||
|
// // write h - end literal series if length > 1
|
||||||
|
// }
|
||||||
|
// // last literal convert to run (length=2)
|
||||||
|
// // write delta
|
||||||
|
// s.h = 0 // run, length=2
|
||||||
|
// } else {
|
||||||
|
// // white s.lastDelta
|
||||||
|
// if s.h < 255 {
|
||||||
|
// //s.lastDelta = delta
|
||||||
|
// s.h++
|
||||||
|
// } else {
|
||||||
|
// // write h - end of literal
|
||||||
|
// s.lastDelta = delta
|
||||||
|
// s.h = 128 // new literal (length=1)
|
||||||
|
// }
|
||||||
|
// }
|
||||||
|
// }
|
||||||
|
// } else {
|
||||||
|
// // 2nd value
|
||||||
|
// s.lastDelta = delta
|
||||||
|
// }
|
||||||
|
// }
|
||||||
|
// // 1st value
|
||||||
|
// s.lastUnixtime = unixtime
|
||||||
|
// }
|
||||||
|
|
||||||
func (s *ReverseTimeDeltaCompressor) convertLiteralToRun() {
|
// func (s *ReverseTimeDeltaCompressor) convertLastFromLiteralToRun() {
|
||||||
// Знімаю flagLiteral, а лічильник 0 дорівнює 2 елементам в серії.
|
// // Зменшую кількість елементів в literal блоці
|
||||||
s.h = 0
|
// s.h--
|
||||||
s.buf[s.pos-1] = s.h
|
// s.pos -= 1 + s.lastDeltaSize
|
||||||
}
|
// s.buf[s.pos] = s.h // закриваю literal блок
|
||||||
|
// s.pos++
|
||||||
|
// s.lastDeltaSize, _ = bin.ReversePutVarUint64(s.buf[s.pos:], uint64(s.lastDelta))
|
||||||
|
// s.pos += s.lastDeltaSize
|
||||||
|
// s.h = 0 // run блок, довжини 2
|
||||||
|
// s.buf[s.pos] = s.h
|
||||||
|
// s.pos++
|
||||||
|
// }
|
||||||
|
|
||||||
func (s *ReverseTimeDeltaCompressor) appendDeltaToLiteral(delta uint32) {
|
// func (s *ReverseTimeDeltaCompressor) convertLiteralToRun() {
|
||||||
s.h++ // збільшую к-сть дельт
|
// // Знімаю flagLiteral, а лічильник 0 дорівнює 2 елементам в серії.
|
||||||
s.lastDelta = delta
|
// s.h = 0
|
||||||
s.pos--
|
// s.buf[s.pos-1] = s.h
|
||||||
s.lastDeltaSize, _ = bin.ReversePutVarUint64(s.buf[s.pos:], uint64(delta))
|
// }
|
||||||
s.pos += s.lastDeltaSize
|
|
||||||
s.buf[s.pos] = s.h
|
|
||||||
s.pos++
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseTimeDeltaCompressor) appendNewLiteral(delta uint32) {
|
// func (s *ReverseTimeDeltaCompressor) appendDeltaToLiteral(delta uint32) {
|
||||||
//fmt.Println("appendNewLiteral", delta)
|
// s.h++ // збільшую к-сть дельт
|
||||||
s.h = flagLiteral
|
// s.lastDelta = delta
|
||||||
s.lastDelta = delta
|
// s.pos--
|
||||||
s.lastDeltaSize, _ = bin.ReversePutVarUint64(s.buf[s.pos:], uint64(delta))
|
// s.lastDeltaSize, _ = bin.ReversePutVarUint64(s.buf[s.pos:], uint64(delta))
|
||||||
s.pos += s.lastDeltaSize
|
// s.pos += s.lastDeltaSize
|
||||||
s.buf[s.pos] = flagLiteral // literal, length = 1
|
// s.buf[s.pos] = s.h
|
||||||
s.pos++
|
// s.pos++
|
||||||
}
|
// }
|
||||||
|
|
||||||
|
// func (s *ReverseTimeDeltaCompressor) appendNewLiteral(delta uint32) {
|
||||||
|
// //fmt.Println("appendNewLiteral", delta)
|
||||||
|
// s.h = flagLiteral
|
||||||
|
// s.lastDelta = delta
|
||||||
|
// s.lastDeltaSize, _ = bin.ReversePutVarUint64(s.buf[s.pos:], uint64(delta))
|
||||||
|
// s.pos += s.lastDeltaSize
|
||||||
|
// s.buf[s.pos] = flagLiteral // literal, length = 1
|
||||||
|
// s.pos++
|
||||||
|
// }
|
||||||
|
|
||||||
func (s *ReverseTimeDeltaCompressor) DeleteLast() {
|
func (s *ReverseTimeDeltaCompressor) DeleteLast() {
|
||||||
|
|
||||||
@@ -214,25 +290,26 @@ func (s *ReverseTimeDeltaCompressor) Offset() int {
|
|||||||
|
|
||||||
// fix -
|
// fix -
|
||||||
func (s *ReverseTimeDeltaCompressor) Snapshot() ([]byte, int) {
|
func (s *ReverseTimeDeltaCompressor) Snapshot() ([]byte, int) {
|
||||||
if s.state == nil {
|
// if s.state == nil {
|
||||||
return s.buf, s.Size()
|
// return s.buf, s.Size()
|
||||||
}
|
// }
|
||||||
// ВАЖЛИВО!
|
// // ВАЖЛИВО!
|
||||||
// Треба відтворити стан останнього чанка
|
// // Треба відтворити стан останнього чанка
|
||||||
var (
|
// var (
|
||||||
pos = s.state.Pos
|
// pos = s.state.Pos
|
||||||
chunk = make([]byte, conbuf.ChunkSize)
|
// chunk = make([]byte, conbuf.ChunkSize)
|
||||||
lastChunkIdx = len(s.state.Chunks) - 1
|
// lastChunkIdx = len(s.state.Chunks) - 1
|
||||||
qtyToCopy = pos % conbuf.ChunkSize
|
// qtyToCopy = pos % conbuf.ChunkSize
|
||||||
)
|
// )
|
||||||
copy(chunk, s.state.Chunks[lastChunkIdx][:qtyToCopy])
|
// copy(chunk, s.state.Chunks[lastChunkIdx][:qtyToCopy])
|
||||||
chunks := append(s.state.Chunks[:lastChunkIdx], chunk)
|
// chunks := append(s.state.Chunks[:lastChunkIdx], chunk)
|
||||||
|
|
||||||
buf := conbuf.New(chunks)
|
// buf := conbuf.New(chunks)
|
||||||
pos += buf.ReversePutVarUint64(pos, uint64(s.state.LastDelta))
|
// pos += buf.ReversePutVarUint64(pos, uint64(s.state.LastDelta))
|
||||||
buf.SetByte(pos, s.state.H)
|
// buf.SetByte(pos, s.state.H)
|
||||||
pos++
|
// pos++
|
||||||
return chunks, pos
|
// return chunks, pos
|
||||||
|
return nil, 0
|
||||||
}
|
}
|
||||||
|
|
||||||
func (s *ReverseTimeDeltaCompressor) CreateDecompressor() qb.TimestampDecompressor {
|
func (s *ReverseTimeDeltaCompressor) CreateDecompressor() qb.TimestampDecompressor {
|
||||||
|
|||||||
@@ -1,3 +0,0 @@
|
|||||||
package chunkenc2
|
|
||||||
|
|
||||||
const eps = 0.000001
|
|
||||||
@@ -1,330 +0,0 @@
|
|||||||
package chunkenc2
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"math"
|
|
||||||
|
|
||||||
"gordenko.dev/dima/qb/bin"
|
|
||||||
"gordenko.dev/dima/qb/conbuf"
|
|
||||||
)
|
|
||||||
|
|
||||||
// REVERSE
|
|
||||||
|
|
||||||
type ReverseCumulativeDeltaCompressor struct {
|
|
||||||
buf *conbuf.ContinuousBuffer
|
|
||||||
coef float64
|
|
||||||
pos int
|
|
||||||
firstValue float64
|
|
||||||
lastDelta uint64
|
|
||||||
length uint16
|
|
||||||
numIdx int
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewReverseCumulativeDeltaCompressor(buf *conbuf.ContinuousBuffer, size int, fracDigits byte) *ReverseCumulativeDeltaCompressor {
|
|
||||||
var coef float64 = 1
|
|
||||||
if fracDigits > 0 {
|
|
||||||
coef = math.Pow(10, float64(fracDigits))
|
|
||||||
}
|
|
||||||
s := &ReverseCumulativeDeltaCompressor{
|
|
||||||
buf: buf,
|
|
||||||
pos: size,
|
|
||||||
coef: coef,
|
|
||||||
}
|
|
||||||
if size > 0 {
|
|
||||||
s.restoreState()
|
|
||||||
}
|
|
||||||
return s
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseCumulativeDeltaCompressor) restoreState() {
|
|
||||||
u64, n, err := s.buf.GetVarUint64(0)
|
|
||||||
if err != nil {
|
|
||||||
panic(fmt.Sprintf("bug: get first value: %s", err))
|
|
||||||
}
|
|
||||||
s.firstValue = float64(u64) / s.coef
|
|
||||||
|
|
||||||
if s.pos > n {
|
|
||||||
pos := s.pos - 1
|
|
||||||
idxOf8 := uint(8 - s.buf.GetByte(pos))
|
|
||||||
pos--
|
|
||||||
s8 := s.buf.GetByte(pos)
|
|
||||||
pos--
|
|
||||||
|
|
||||||
var n int
|
|
||||||
s.lastDelta, n, err = s.buf.ReverseGetVarUint64(pos)
|
|
||||||
if err != nil {
|
|
||||||
panic(fmt.Sprintf("bug: get last delta: %s", err))
|
|
||||||
}
|
|
||||||
pos -= n
|
|
||||||
s.numIdx = pos + 1
|
|
||||||
|
|
||||||
var flag byte = 1 << idxOf8
|
|
||||||
if (s8 & flag) == flag {
|
|
||||||
s.length, _ = s.buf.DecodeRunLength(pos)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseCumulativeDeltaCompressor) Size() int {
|
|
||||||
return s.pos
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseCumulativeDeltaCompressor) CalcRequiredSpace(value float64) int {
|
|
||||||
if s.pos == 0 {
|
|
||||||
n := bin.CalcVarUint64Length(uint64(value * s.coef))
|
|
||||||
return n + 3
|
|
||||||
}
|
|
||||||
delta := uint64((value-s.firstValue)*s.coef + eps)
|
|
||||||
if delta == s.lastDelta {
|
|
||||||
if s.length == 0 {
|
|
||||||
return 1
|
|
||||||
} else {
|
|
||||||
newLength := s.length + 1
|
|
||||||
if newLength < 130 {
|
|
||||||
return 0
|
|
||||||
} else if newLength == 130 {
|
|
||||||
return 1
|
|
||||||
} else {
|
|
||||||
if newLength < 32769 {
|
|
||||||
return 0
|
|
||||||
} else {
|
|
||||||
n := bin.CalcVarUint64Length(delta)
|
|
||||||
n += 2
|
|
||||||
s8q := s.buf.GetByte(s.pos - 1)
|
|
||||||
if s8q == 8 {
|
|
||||||
n -= 1
|
|
||||||
} else {
|
|
||||||
n -= 2
|
|
||||||
}
|
|
||||||
return n
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
n := bin.CalcVarUint64Length(delta)
|
|
||||||
n += 2
|
|
||||||
s8q := s.buf.GetByte(s.pos - 1)
|
|
||||||
if s8q == 8 {
|
|
||||||
n -= 1
|
|
||||||
} else {
|
|
||||||
n -= 2
|
|
||||||
}
|
|
||||||
return n
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseCumulativeDeltaCompressor) Append(value float64) {
|
|
||||||
if s.pos == 0 {
|
|
||||||
n := s.buf.PutVarUint64(s.pos, uint64(value*s.coef))
|
|
||||||
s.pos += n
|
|
||||||
s.firstValue = value
|
|
||||||
s.encodeNewDelta(0, 0, 1)
|
|
||||||
} else {
|
|
||||||
delta := uint64((value-s.firstValue)*s.coef + eps)
|
|
||||||
if delta == s.lastDelta {
|
|
||||||
if s.length == 0 {
|
|
||||||
s.length = 2
|
|
||||||
s.shiftOnePosToRight()
|
|
||||||
s.buf.SetByte(s.numIdx-1, 0)
|
|
||||||
s8q := s.buf.GetByte(s.pos - 1)
|
|
||||||
s.buf.SetFlag(s.pos-2, 1<<(8-s8q))
|
|
||||||
} else {
|
|
||||||
s.length++
|
|
||||||
if s.length < 130 {
|
|
||||||
s.buf.SetByte(s.numIdx-1, byte(s.length-2))
|
|
||||||
} else if s.length == 130 {
|
|
||||||
s.shiftOnePosToRight()
|
|
||||||
s.encode2bLength()
|
|
||||||
} else {
|
|
||||||
if s.length < 32769 {
|
|
||||||
s.encode2bLength()
|
|
||||||
} else {
|
|
||||||
s.appendNewDelta(delta)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
s.appendNewDelta(delta)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseCumulativeDeltaCompressor) appendNewDelta(delta uint64) {
|
|
||||||
s.length = 0
|
|
||||||
|
|
||||||
s8 := s.buf.GetByte(s.pos - 2)
|
|
||||||
s8q := s.buf.GetByte(s.pos - 1)
|
|
||||||
|
|
||||||
if s8q == 8 {
|
|
||||||
s.pos -= 1
|
|
||||||
s8 = 0
|
|
||||||
s8q = 1
|
|
||||||
} else {
|
|
||||||
s.pos -= 2
|
|
||||||
s8q++
|
|
||||||
}
|
|
||||||
|
|
||||||
s.encodeNewDelta(delta, s8, s8q)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseCumulativeDeltaCompressor) encodeNewDelta(delta uint64, s8 byte, s8q byte) {
|
|
||||||
s.lastDelta = delta
|
|
||||||
s.numIdx = s.pos
|
|
||||||
n := s.buf.ReversePutVarUint64(s.pos, s.lastDelta)
|
|
||||||
s.pos += n
|
|
||||||
s.buf.SetByte(s.pos, s8)
|
|
||||||
s.pos++
|
|
||||||
s.buf.SetByte(s.pos, s8q)
|
|
||||||
s.pos++
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseCumulativeDeltaCompressor) shiftOnePosToRight() {
|
|
||||||
s.buf.ShiftOnePosToRight(s.numIdx, s.pos)
|
|
||||||
s.pos++
|
|
||||||
s.numIdx++
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseCumulativeDeltaCompressor) encode2bLength() {
|
|
||||||
num := s.length - 2
|
|
||||||
s.buf.SetByte(s.numIdx-1, byte(num&127)|128)
|
|
||||||
s.buf.SetByte(s.numIdx-2, byte(num>>7))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseCumulativeDeltaCompressor) DeleteLast() {
|
|
||||||
var (
|
|
||||||
s8q = s.buf.GetByte(s.pos - 1)
|
|
||||||
s8 = s.buf.GetByte(s.pos - 2)
|
|
||||||
flag byte = 1 << uint(8-s8q)
|
|
||||||
)
|
|
||||||
|
|
||||||
if s.length > 0 {
|
|
||||||
if s.length == 2 {
|
|
||||||
s.length = 0
|
|
||||||
s.buf.UnsetFlag(s.pos-2, flag)
|
|
||||||
s.buf.ShiftOnePosToLeft(s.numIdx, s.pos)
|
|
||||||
s.numIdx--
|
|
||||||
s.pos--
|
|
||||||
} else if s.length < 130 {
|
|
||||||
s.length--
|
|
||||||
s.buf.SetByte(s.numIdx-1, byte(s.length)-2)
|
|
||||||
} else if s.length == 130 {
|
|
||||||
s.length--
|
|
||||||
s.buf.ShiftOnePosToLeft(s.numIdx, s.pos)
|
|
||||||
s.numIdx--
|
|
||||||
s.pos--
|
|
||||||
s.buf.SetByte(s.numIdx-1, byte(s.length)-2)
|
|
||||||
} else {
|
|
||||||
s.length--
|
|
||||||
s.encode2bLength()
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
if s8q > 1 {
|
|
||||||
s8q--
|
|
||||||
flag = 1 << uint(8-s8q)
|
|
||||||
s.pos = s.numIdx + 2
|
|
||||||
s.buf.SetByte(s.pos-2, s8)
|
|
||||||
s.buf.SetByte(s.pos-1, s8q)
|
|
||||||
} else {
|
|
||||||
s.pos = s.numIdx + 1
|
|
||||||
s.buf.SetByte(s.pos-1, 8)
|
|
||||||
s8 = s.buf.GetByte(s.pos - 2)
|
|
||||||
flag = 1
|
|
||||||
}
|
|
||||||
var (
|
|
||||||
pos = s.pos - 3
|
|
||||||
n int
|
|
||||||
err error
|
|
||||||
)
|
|
||||||
s.lastDelta, n, err = s.buf.ReverseGetVarUint64(pos)
|
|
||||||
if err != nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
s.numIdx = pos - n
|
|
||||||
if (s8 & flag) == flag {
|
|
||||||
s.length, _ = s.buf.DecodeRunLength(s.numIdx - 1)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
type ReverseCumulativeDeltaDecompressor struct {
|
|
||||||
buf *conbuf.ContinuousBuffer
|
|
||||||
pos int
|
|
||||||
bound int
|
|
||||||
firstValue float64
|
|
||||||
lastValue float64
|
|
||||||
length uint16
|
|
||||||
coef float64
|
|
||||||
idxOf8 uint
|
|
||||||
s8 byte
|
|
||||||
step byte
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewReverseCumulativeDeltaDecompressor(buf *conbuf.ContinuousBuffer, size int, fracDigits byte) *ReverseCumulativeDeltaDecompressor {
|
|
||||||
var coef float64 = 1
|
|
||||||
if fracDigits > 0 {
|
|
||||||
coef = math.Pow(10, float64(fracDigits))
|
|
||||||
}
|
|
||||||
return &ReverseCumulativeDeltaDecompressor{
|
|
||||||
buf: buf,
|
|
||||||
coef: coef,
|
|
||||||
pos: size,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseCumulativeDeltaDecompressor) NextValue() (value float64, done bool) {
|
|
||||||
if s.step > 0 {
|
|
||||||
if s.length > 0 {
|
|
||||||
s.length--
|
|
||||||
return s.lastValue, false
|
|
||||||
}
|
|
||||||
if s.pos < s.bound {
|
|
||||||
return 0, true
|
|
||||||
}
|
|
||||||
if s.idxOf8 == 0 {
|
|
||||||
s.s8 = s.buf.GetByte(s.pos)
|
|
||||||
s.pos--
|
|
||||||
}
|
|
||||||
s.readVar()
|
|
||||||
if s.length > 0 {
|
|
||||||
s.length--
|
|
||||||
}
|
|
||||||
return s.lastValue, false
|
|
||||||
}
|
|
||||||
u64, n, err := s.buf.GetVarUint64(0)
|
|
||||||
if err != nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
s.firstValue = float64(u64) / s.coef
|
|
||||||
s.bound = n
|
|
||||||
s.pos--
|
|
||||||
s.idxOf8 = uint(8 - s.buf.GetByte(s.pos))
|
|
||||||
s.pos--
|
|
||||||
s.s8 = s.buf.GetByte(s.pos)
|
|
||||||
s.pos--
|
|
||||||
s.readVar()
|
|
||||||
if s.length > 0 {
|
|
||||||
s.length--
|
|
||||||
}
|
|
||||||
s.step = 1
|
|
||||||
return s.lastValue, false
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseCumulativeDeltaDecompressor) readVar() {
|
|
||||||
u64, n, err := s.buf.ReverseGetVarUint64(s.pos)
|
|
||||||
if err != nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
s.pos -= n
|
|
||||||
s.lastValue = s.firstValue + float64(u64)/s.coef
|
|
||||||
|
|
||||||
var flag byte = 1 << s.idxOf8
|
|
||||||
if (s.s8 & flag) == flag {
|
|
||||||
s.length, n = s.buf.DecodeRunLength(s.pos)
|
|
||||||
s.pos -= n
|
|
||||||
}
|
|
||||||
if s.idxOf8 == 7 {
|
|
||||||
s.idxOf8 = 0
|
|
||||||
} else {
|
|
||||||
s.idxOf8++
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,345 +0,0 @@
|
|||||||
package chunkenc2
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"math"
|
|
||||||
|
|
||||||
"gordenko.dev/dima/qb/bin"
|
|
||||||
"gordenko.dev/dima/qb/conbuf"
|
|
||||||
)
|
|
||||||
|
|
||||||
// REVERSE
|
|
||||||
|
|
||||||
type ReverseInstantDeltaCompressor struct {
|
|
||||||
buf *conbuf.ContinuousBuffer
|
|
||||||
coef float64
|
|
||||||
pos int
|
|
||||||
firstValue float64
|
|
||||||
lastDelta int64
|
|
||||||
length uint16
|
|
||||||
numIdx int
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewReverseInstantDeltaCompressor(buf *conbuf.ContinuousBuffer, size int, fracDigits byte) *ReverseInstantDeltaCompressor {
|
|
||||||
var coef float64 = 1
|
|
||||||
if fracDigits > 0 {
|
|
||||||
coef = math.Pow(10, float64(fracDigits))
|
|
||||||
}
|
|
||||||
s := &ReverseInstantDeltaCompressor{
|
|
||||||
buf: buf,
|
|
||||||
pos: size,
|
|
||||||
coef: coef,
|
|
||||||
}
|
|
||||||
if size > 0 {
|
|
||||||
s.restoreState()
|
|
||||||
}
|
|
||||||
return s
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseInstantDeltaCompressor) restoreState() {
|
|
||||||
i64, n, err := s.buf.GetVarInt64(0)
|
|
||||||
if err != nil {
|
|
||||||
panic(fmt.Sprintf("bug: get first value: %s", err))
|
|
||||||
}
|
|
||||||
s.firstValue = float64(i64) / s.coef
|
|
||||||
|
|
||||||
if s.pos > n {
|
|
||||||
pos := s.pos - 1
|
|
||||||
idxOf8 := uint(8 - s.buf.GetByte(pos))
|
|
||||||
pos--
|
|
||||||
s8 := s.buf.GetByte(pos)
|
|
||||||
pos--
|
|
||||||
|
|
||||||
var n int
|
|
||||||
s.lastDelta, n, err = s.buf.ReverseGetVarInt64(pos)
|
|
||||||
if err != nil {
|
|
||||||
panic(fmt.Sprintf("bug: get last delta: %s", err))
|
|
||||||
}
|
|
||||||
pos -= n
|
|
||||||
s.numIdx = pos + 1
|
|
||||||
var flag byte = 1 << idxOf8
|
|
||||||
if (s8 & flag) == flag {
|
|
||||||
s.length, _ = s.buf.DecodeRunLength(pos)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseInstantDeltaCompressor) Size() int {
|
|
||||||
return s.pos
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseInstantDeltaCompressor) CalcRequiredSpace(value float64) int {
|
|
||||||
if s.pos == 0 {
|
|
||||||
n := bin.CalcVarInt64Length(int64(value * s.coef))
|
|
||||||
return n + 3
|
|
||||||
}
|
|
||||||
|
|
||||||
tmp := (value - s.firstValue) * s.coef
|
|
||||||
if tmp > 0 {
|
|
||||||
tmp += eps
|
|
||||||
} else {
|
|
||||||
tmp -= eps
|
|
||||||
}
|
|
||||||
delta := int64(tmp)
|
|
||||||
|
|
||||||
if delta == s.lastDelta {
|
|
||||||
if s.length == 0 {
|
|
||||||
return 1
|
|
||||||
} else {
|
|
||||||
newLength := s.length + 1
|
|
||||||
if newLength < 130 {
|
|
||||||
return 0
|
|
||||||
} else if newLength == 130 {
|
|
||||||
return 1
|
|
||||||
} else {
|
|
||||||
if newLength < 32769 {
|
|
||||||
return 0
|
|
||||||
} else {
|
|
||||||
n := bin.CalcVarInt64Length(delta)
|
|
||||||
n += 2
|
|
||||||
s8q := s.buf.GetByte(s.pos - 1)
|
|
||||||
if s8q == 8 {
|
|
||||||
n -= 1
|
|
||||||
} else {
|
|
||||||
n -= 2
|
|
||||||
}
|
|
||||||
return n
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
n := bin.CalcVarInt64Length(delta)
|
|
||||||
n += 2
|
|
||||||
s8q := s.buf.GetByte(s.pos - 1)
|
|
||||||
if s8q == 8 {
|
|
||||||
n -= 1
|
|
||||||
} else {
|
|
||||||
n -= 2
|
|
||||||
}
|
|
||||||
return n
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// В начале буфера кодирую базовое значение.
|
|
||||||
func (s *ReverseInstantDeltaCompressor) Append(value float64) {
|
|
||||||
if s.pos == 0 {
|
|
||||||
n := s.buf.PutVarInt64(s.pos, int64(value*s.coef))
|
|
||||||
s.pos += n
|
|
||||||
s.firstValue = value
|
|
||||||
s.encodeNewDelta(0, 0, 1)
|
|
||||||
} else {
|
|
||||||
tmp := (value - s.firstValue) * s.coef
|
|
||||||
if tmp > 0 {
|
|
||||||
tmp += eps
|
|
||||||
} else {
|
|
||||||
tmp -= eps
|
|
||||||
}
|
|
||||||
delta := int64(tmp)
|
|
||||||
|
|
||||||
if delta == s.lastDelta {
|
|
||||||
if s.length == 0 {
|
|
||||||
s.length = 2
|
|
||||||
s.shiftOnePosToRight()
|
|
||||||
s.buf.SetByte(s.numIdx-1, 0)
|
|
||||||
s8q := s.buf.GetByte(s.pos - 1)
|
|
||||||
s.buf.SetFlag(s.pos-2, 1<<(8-s8q))
|
|
||||||
} else {
|
|
||||||
s.length++
|
|
||||||
if s.length < 130 {
|
|
||||||
s.buf.SetByte(s.numIdx-1, byte(s.length-2))
|
|
||||||
} else if s.length == 130 {
|
|
||||||
s.shiftOnePosToRight()
|
|
||||||
s.encode2bLength()
|
|
||||||
} else {
|
|
||||||
if s.length < 32769 {
|
|
||||||
s.encode2bLength()
|
|
||||||
} else {
|
|
||||||
s.appendNewDelta(delta)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
s.appendNewDelta(delta)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseInstantDeltaCompressor) appendNewDelta(delta int64) {
|
|
||||||
s.length = 0
|
|
||||||
|
|
||||||
s8 := s.buf.GetByte(s.pos - 2)
|
|
||||||
s8q := s.buf.GetByte(s.pos - 1)
|
|
||||||
|
|
||||||
if s8q == 8 {
|
|
||||||
s.pos -= 1
|
|
||||||
s8 = 0
|
|
||||||
s8q = 1
|
|
||||||
} else {
|
|
||||||
s.pos -= 2
|
|
||||||
s8q++
|
|
||||||
}
|
|
||||||
s.encodeNewDelta(delta, s8, s8q)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseInstantDeltaCompressor) encodeNewDelta(delta int64, s8 byte, s8q byte) {
|
|
||||||
s.lastDelta = delta
|
|
||||||
s.numIdx = s.pos
|
|
||||||
n := s.buf.ReversePutVarInt64(s.pos, s.lastDelta)
|
|
||||||
s.pos += n
|
|
||||||
s.buf.SetByte(s.pos, s8)
|
|
||||||
s.pos++
|
|
||||||
s.buf.SetByte(s.pos, s8q)
|
|
||||||
s.pos++
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseInstantDeltaCompressor) shiftOnePosToRight() {
|
|
||||||
s.buf.ShiftOnePosToRight(s.numIdx, s.pos)
|
|
||||||
s.pos++
|
|
||||||
s.numIdx++
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseInstantDeltaCompressor) encode2bLength() {
|
|
||||||
num := s.length - 2
|
|
||||||
s.buf.SetByte(s.numIdx-1, byte(num&127)|128)
|
|
||||||
s.buf.SetByte(s.numIdx-2, byte(num>>7))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseInstantDeltaCompressor) DeleteLast() {
|
|
||||||
var (
|
|
||||||
s8q = s.buf.GetByte(s.pos - 1)
|
|
||||||
s8 = s.buf.GetByte(s.pos - 2)
|
|
||||||
flag byte = 1 << uint(8-s8q)
|
|
||||||
)
|
|
||||||
|
|
||||||
if s.length > 0 {
|
|
||||||
if s.length == 2 {
|
|
||||||
s.length = 0
|
|
||||||
s.buf.UnsetFlag(s.pos-2, flag)
|
|
||||||
s.buf.ShiftOnePosToLeft(s.numIdx, s.pos)
|
|
||||||
s.numIdx--
|
|
||||||
s.pos--
|
|
||||||
} else if s.length < 130 {
|
|
||||||
s.length--
|
|
||||||
s.buf.SetByte(s.numIdx-1, byte(s.length)-2)
|
|
||||||
} else if s.length == 130 {
|
|
||||||
s.length--
|
|
||||||
s.buf.ShiftOnePosToLeft(s.numIdx, s.pos)
|
|
||||||
s.numIdx--
|
|
||||||
s.pos--
|
|
||||||
s.buf.SetByte(s.numIdx-1, byte(s.length)-2)
|
|
||||||
} else {
|
|
||||||
s.length--
|
|
||||||
s.encode2bLength()
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
if s8q > 1 {
|
|
||||||
s8q--
|
|
||||||
flag = 1 << uint(8-s8q)
|
|
||||||
s.pos = s.numIdx + 2
|
|
||||||
s.buf.SetByte(s.pos-2, s8)
|
|
||||||
s.buf.SetByte(s.pos-1, s8q)
|
|
||||||
} else {
|
|
||||||
s.pos = s.numIdx + 1
|
|
||||||
s.buf.SetByte(s.pos-1, 8)
|
|
||||||
s8 = s.buf.GetByte(s.pos - 2)
|
|
||||||
flag = 1
|
|
||||||
}
|
|
||||||
var (
|
|
||||||
pos = s.pos - 3
|
|
||||||
n int
|
|
||||||
err error
|
|
||||||
)
|
|
||||||
s.lastDelta, n, err = s.buf.ReverseGetVarInt64(pos)
|
|
||||||
if err != nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
s.numIdx = pos - n
|
|
||||||
if (s8 & flag) == flag {
|
|
||||||
s.length, _ = s.buf.DecodeRunLength(s.numIdx - 1)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
type ReverseInstantDeltaDecompressor struct {
|
|
||||||
step byte
|
|
||||||
buf *conbuf.ContinuousBuffer
|
|
||||||
pos int
|
|
||||||
bound int
|
|
||||||
firstValue float64
|
|
||||||
lastValue float64
|
|
||||||
length uint16
|
|
||||||
coef float64
|
|
||||||
idxOf8 uint
|
|
||||||
s8 byte
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewReverseInstantDeltaDecompressor(buf *conbuf.ContinuousBuffer, size int, fracDigits byte) *ReverseInstantDeltaDecompressor {
|
|
||||||
var coef float64 = 1
|
|
||||||
if fracDigits > 0 {
|
|
||||||
coef = math.Pow(10, float64(fracDigits))
|
|
||||||
}
|
|
||||||
return &ReverseInstantDeltaDecompressor{
|
|
||||||
buf: buf,
|
|
||||||
coef: coef,
|
|
||||||
pos: size,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseInstantDeltaDecompressor) NextValue() (value float64, done bool) {
|
|
||||||
if s.step > 0 {
|
|
||||||
if s.length > 0 {
|
|
||||||
s.length--
|
|
||||||
return s.lastValue, false
|
|
||||||
}
|
|
||||||
if s.pos < s.bound {
|
|
||||||
return 0, true
|
|
||||||
}
|
|
||||||
|
|
||||||
if s.idxOf8 == 0 {
|
|
||||||
s.s8 = s.buf.GetByte(s.pos)
|
|
||||||
s.pos--
|
|
||||||
}
|
|
||||||
s.readVar()
|
|
||||||
if s.length > 0 {
|
|
||||||
s.length--
|
|
||||||
}
|
|
||||||
return s.lastValue, false
|
|
||||||
}
|
|
||||||
i64, n, err := s.buf.GetVarInt64(0)
|
|
||||||
if err != nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
s.firstValue = float64(i64) / s.coef
|
|
||||||
s.bound = n
|
|
||||||
s.pos--
|
|
||||||
s.idxOf8 = uint(8 - s.buf.GetByte(s.pos))
|
|
||||||
s.pos--
|
|
||||||
s.s8 = s.buf.GetByte(s.pos)
|
|
||||||
s.pos--
|
|
||||||
s.readVar()
|
|
||||||
if s.length > 0 {
|
|
||||||
s.length--
|
|
||||||
}
|
|
||||||
s.step = 1
|
|
||||||
return s.lastValue, false
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseInstantDeltaDecompressor) readVar() {
|
|
||||||
i64, n, err := s.buf.ReverseGetVarInt64(s.pos)
|
|
||||||
if err != nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
s.pos -= n
|
|
||||||
s.lastValue = s.firstValue + float64(i64)/s.coef
|
|
||||||
|
|
||||||
var flag byte = 1 << s.idxOf8
|
|
||||||
if (s.s8 & flag) == flag {
|
|
||||||
s.length, n = s.buf.DecodeRunLength(s.pos)
|
|
||||||
s.pos -= n
|
|
||||||
}
|
|
||||||
if s.idxOf8 == 7 {
|
|
||||||
s.idxOf8 = 0
|
|
||||||
} else {
|
|
||||||
s.idxOf8++
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,374 +0,0 @@
|
|||||||
package chunkenc2
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
|
|
||||||
"gordenko.dev/dima/qb/bin"
|
|
||||||
"gordenko.dev/dima/qb/conbuf"
|
|
||||||
)
|
|
||||||
|
|
||||||
// REVERSE
|
|
||||||
|
|
||||||
const (
|
|
||||||
lastUnixtimeIdx = 0
|
|
||||||
baseDeltaIdx = 4
|
|
||||||
)
|
|
||||||
|
|
||||||
type ReverseTimeDeltaOfDeltaCompressor struct {
|
|
||||||
buf *conbuf.ContinuousBuffer
|
|
||||||
pos int
|
|
||||||
baseDelta uint32
|
|
||||||
lastUnixtime uint32
|
|
||||||
lastDeltaOfDelta int64
|
|
||||||
length uint16
|
|
||||||
numIdx int
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewReverseTimeDeltaOfDeltaCompressor(buf *conbuf.ContinuousBuffer, size int) *ReverseTimeDeltaOfDeltaCompressor {
|
|
||||||
s := &ReverseTimeDeltaOfDeltaCompressor{
|
|
||||||
buf: buf,
|
|
||||||
pos: size,
|
|
||||||
}
|
|
||||||
if size > 0 {
|
|
||||||
s.restoreState()
|
|
||||||
}
|
|
||||||
return s
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseTimeDeltaOfDeltaCompressor) restoreState() {
|
|
||||||
s.lastUnixtime = s.buf.GetUint32(lastUnixtimeIdx)
|
|
||||||
if s.pos > 4 {
|
|
||||||
u64, _, err := s.buf.GetVarUint64(baseDeltaIdx)
|
|
||||||
if err != nil {
|
|
||||||
panic(fmt.Sprintf("bug: get base delta: %s", err))
|
|
||||||
}
|
|
||||||
s.baseDelta = uint32(u64)
|
|
||||||
|
|
||||||
pos := s.pos - 1
|
|
||||||
idxOf8 := uint(8 - s.buf.GetByte(pos))
|
|
||||||
pos--
|
|
||||||
s8 := s.buf.GetByte(pos)
|
|
||||||
pos--
|
|
||||||
|
|
||||||
var n int
|
|
||||||
s.lastDeltaOfDelta, n, err = s.buf.ReverseGetVarInt64(pos)
|
|
||||||
if err != nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
pos -= n
|
|
||||||
s.numIdx = pos + 1
|
|
||||||
var flag byte = 1 << idxOf8
|
|
||||||
if (s8 & flag) == flag {
|
|
||||||
s.length, _ = s.buf.DecodeRunLength(pos)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseTimeDeltaOfDeltaCompressor) Size() int {
|
|
||||||
return s.pos
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseTimeDeltaOfDeltaCompressor) CalcRequiredSpace(unixtime uint32) int {
|
|
||||||
if s.pos == 0 {
|
|
||||||
return 4
|
|
||||||
}
|
|
||||||
|
|
||||||
if s.baseDelta == 0 {
|
|
||||||
baseDelta := unixtime - s.lastUnixtime
|
|
||||||
n := bin.CalcVarUint64Length(uint64(baseDelta))
|
|
||||||
return n + 3
|
|
||||||
}
|
|
||||||
|
|
||||||
deltaOfDelta := int64(unixtime-s.lastUnixtime) - int64(s.baseDelta)
|
|
||||||
if deltaOfDelta == s.lastDeltaOfDelta {
|
|
||||||
if s.length == 0 {
|
|
||||||
return 1
|
|
||||||
} else {
|
|
||||||
newLength := s.length + 1
|
|
||||||
if newLength < 130 {
|
|
||||||
return 0
|
|
||||||
} else if newLength == 130 {
|
|
||||||
return 1
|
|
||||||
} else {
|
|
||||||
if newLength < 32769 {
|
|
||||||
return 0
|
|
||||||
} else {
|
|
||||||
n := bin.CalcVarInt64Length(deltaOfDelta)
|
|
||||||
n += 2
|
|
||||||
s8q := s.buf.GetByte(s.pos - 1)
|
|
||||||
if s8q == 8 {
|
|
||||||
n -= 1
|
|
||||||
} else {
|
|
||||||
n -= 2
|
|
||||||
}
|
|
||||||
return n
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
n := bin.CalcVarInt64Length(deltaOfDelta)
|
|
||||||
n += 2
|
|
||||||
s8q := s.buf.GetByte(s.pos - 1)
|
|
||||||
if s8q == 8 {
|
|
||||||
n -= 1
|
|
||||||
} else {
|
|
||||||
n -= 2
|
|
||||||
}
|
|
||||||
return n
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseTimeDeltaOfDeltaCompressor) Append(unixtime uint32) {
|
|
||||||
if s.pos == 0 {
|
|
||||||
s.lastUnixtime = unixtime
|
|
||||||
s.buf.PutUint32(lastUnixtimeIdx, unixtime)
|
|
||||||
s.pos += 4
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
if s.baseDelta == 0 {
|
|
||||||
s.baseDelta = unixtime - s.lastUnixtime
|
|
||||||
s.lastDeltaOfDelta = 0
|
|
||||||
s.lastUnixtime = unixtime
|
|
||||||
s.buf.PutUint32(lastUnixtimeIdx, unixtime)
|
|
||||||
|
|
||||||
n := s.buf.PutVarUint64(s.pos, uint64(s.baseDelta))
|
|
||||||
s.pos += n
|
|
||||||
s.encodeNewDeltaOfDelta(0, 0, 1)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
deltaOfDelta := int64(unixtime-s.lastUnixtime) - int64(s.baseDelta)
|
|
||||||
s.lastUnixtime = unixtime
|
|
||||||
s.buf.PutUint32(lastUnixtimeIdx, unixtime)
|
|
||||||
|
|
||||||
if deltaOfDelta == s.lastDeltaOfDelta {
|
|
||||||
if s.length == 0 {
|
|
||||||
s.length = 2
|
|
||||||
s.shiftOnePosToRight()
|
|
||||||
s.buf.SetByte(s.numIdx-1, 0)
|
|
||||||
s8q := s.buf.GetByte(s.pos - 1)
|
|
||||||
s.buf.SetFlag(s.pos-2, 1<<(8-s8q))
|
|
||||||
} else {
|
|
||||||
s.length++
|
|
||||||
if s.length < 130 {
|
|
||||||
s.buf.SetByte(s.numIdx-1, byte(s.length-2))
|
|
||||||
} else if s.length == 130 {
|
|
||||||
s.shiftOnePosToRight()
|
|
||||||
s.encode2bLength()
|
|
||||||
} else {
|
|
||||||
if s.length < 32769 {
|
|
||||||
s.encode2bLength()
|
|
||||||
} else {
|
|
||||||
s.appendNewDeltaOfDelta(deltaOfDelta)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
s.appendNewDeltaOfDelta(deltaOfDelta)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseTimeDeltaOfDeltaCompressor) appendNewDeltaOfDelta(deltaOfDelta int64) {
|
|
||||||
s.length = 0
|
|
||||||
s8 := s.buf.GetByte(s.pos - 2)
|
|
||||||
s8q := s.buf.GetByte(s.pos - 1)
|
|
||||||
|
|
||||||
if s8q == 8 {
|
|
||||||
s.pos -= 1
|
|
||||||
s8 = 0
|
|
||||||
s8q = 1
|
|
||||||
} else {
|
|
||||||
s.pos -= 2
|
|
||||||
s8q++
|
|
||||||
}
|
|
||||||
|
|
||||||
s.encodeNewDeltaOfDelta(deltaOfDelta, s8, s8q)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseTimeDeltaOfDeltaCompressor) encodeNewDeltaOfDelta(deltaOfDelta int64, s8 byte, s8q byte) {
|
|
||||||
s.lastDeltaOfDelta = deltaOfDelta
|
|
||||||
s.numIdx = s.pos
|
|
||||||
n := s.buf.ReversePutVarInt64(s.pos, deltaOfDelta)
|
|
||||||
s.pos += n
|
|
||||||
s.buf.SetByte(s.pos, s8)
|
|
||||||
s.pos++
|
|
||||||
s.buf.SetByte(s.pos, s8q)
|
|
||||||
s.pos++
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseTimeDeltaOfDeltaCompressor) shiftOnePosToRight() {
|
|
||||||
s.buf.ShiftOnePosToRight(s.numIdx, s.pos)
|
|
||||||
s.pos++
|
|
||||||
s.numIdx++
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseTimeDeltaOfDeltaCompressor) encode2bLength() {
|
|
||||||
num := s.length - 2
|
|
||||||
s.buf.SetByte(s.numIdx-1, byte(num&127)|128)
|
|
||||||
s.buf.SetByte(s.numIdx-2, byte(num>>7))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseTimeDeltaOfDeltaCompressor) DeleteLast() {
|
|
||||||
var (
|
|
||||||
s8q = s.buf.GetByte(s.pos - 1)
|
|
||||||
s8 = s.buf.GetByte(s.pos - 2)
|
|
||||||
flag byte = 1 << uint(8-s8q)
|
|
||||||
)
|
|
||||||
|
|
||||||
if s.length > 0 {
|
|
||||||
if s.length == 2 {
|
|
||||||
s.length = 0
|
|
||||||
s.buf.UnsetFlag(s.pos-2, flag)
|
|
||||||
s.buf.ShiftOnePosToLeft(s.numIdx, s.pos)
|
|
||||||
s.numIdx--
|
|
||||||
s.pos--
|
|
||||||
} else if s.length < 130 {
|
|
||||||
s.length--
|
|
||||||
s.buf.SetByte(s.numIdx-1, byte(s.length)-2)
|
|
||||||
} else if s.length == 130 {
|
|
||||||
s.length--
|
|
||||||
s.buf.ShiftOnePosToLeft(s.numIdx, s.pos)
|
|
||||||
s.numIdx--
|
|
||||||
s.pos--
|
|
||||||
s.buf.SetByte(s.numIdx-1, byte(s.length)-2)
|
|
||||||
} else {
|
|
||||||
s.length--
|
|
||||||
s.encode2bLength()
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
if s8q > 1 {
|
|
||||||
s8q--
|
|
||||||
flag = 1 << uint(8-s8q)
|
|
||||||
s.pos = s.numIdx + 2
|
|
||||||
s.buf.SetByte(s.pos-2, s8)
|
|
||||||
s.buf.SetByte(s.pos-1, s8q)
|
|
||||||
} else {
|
|
||||||
s.pos = s.numIdx + 1
|
|
||||||
s.buf.SetByte(s.pos-1, 8)
|
|
||||||
s8 = s.buf.GetByte(s.pos - 2)
|
|
||||||
flag = 1
|
|
||||||
}
|
|
||||||
var (
|
|
||||||
pos = s.pos - 3
|
|
||||||
n int
|
|
||||||
err error
|
|
||||||
)
|
|
||||||
s.lastDeltaOfDelta, n, err = s.buf.ReverseGetVarInt64(pos)
|
|
||||||
if err != nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
s.numIdx = pos - n
|
|
||||||
if (s8 & flag) == flag {
|
|
||||||
s.length, _ = s.buf.DecodeRunLength(s.numIdx - 1)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
delta := int64(s.baseDelta) + s.lastDeltaOfDelta
|
|
||||||
s.lastUnixtime = uint32(int64(s.lastUnixtime) - delta)
|
|
||||||
s.buf.PutUint32(lastUnixtimeIdx, s.lastUnixtime)
|
|
||||||
}
|
|
||||||
|
|
||||||
type ReverseTimeDeltaOfDeltaDecompressor struct {
|
|
||||||
step byte
|
|
||||||
buf *conbuf.ContinuousBuffer
|
|
||||||
pos int
|
|
||||||
bound int
|
|
||||||
lastUnixtime uint32
|
|
||||||
baseDelta uint32
|
|
||||||
lastDeltaOfDelta int64
|
|
||||||
length uint16
|
|
||||||
idxOf8 uint
|
|
||||||
s8 byte
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewReverseTimeDeltaOfDeltaDecompressor(buf *conbuf.ContinuousBuffer, size int) *ReverseTimeDeltaOfDeltaDecompressor {
|
|
||||||
return &ReverseTimeDeltaOfDeltaDecompressor{
|
|
||||||
buf: buf,
|
|
||||||
pos: size,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseTimeDeltaOfDeltaDecompressor) NextValue() (value uint32, done bool) {
|
|
||||||
if s.step == 0 {
|
|
||||||
if s.pos == 0 {
|
|
||||||
return 0, true
|
|
||||||
}
|
|
||||||
s.lastUnixtime = s.buf.GetUint32(lastUnixtimeIdx)
|
|
||||||
s.step = 1
|
|
||||||
return s.lastUnixtime, false
|
|
||||||
}
|
|
||||||
|
|
||||||
if s.step == 1 {
|
|
||||||
if s.pos == baseDeltaIdx {
|
|
||||||
return 0, true
|
|
||||||
}
|
|
||||||
u64, n, err := s.buf.GetVarUint64(baseDeltaIdx)
|
|
||||||
if err != nil {
|
|
||||||
panic("EOF")
|
|
||||||
}
|
|
||||||
s.bound = baseDeltaIdx + n
|
|
||||||
s.baseDelta = uint32(u64)
|
|
||||||
|
|
||||||
s.pos--
|
|
||||||
s.idxOf8 = uint(8 - s.buf.GetByte(s.pos))
|
|
||||||
s.pos--
|
|
||||||
s.s8 = s.buf.GetByte(s.pos)
|
|
||||||
s.pos--
|
|
||||||
|
|
||||||
s.readVar()
|
|
||||||
if s.length > 0 {
|
|
||||||
s.length--
|
|
||||||
}
|
|
||||||
s.step = 2
|
|
||||||
return s.lastUnixtime, false
|
|
||||||
}
|
|
||||||
|
|
||||||
if s.length > 0 {
|
|
||||||
s.length--
|
|
||||||
delta := int64(s.baseDelta) + s.lastDeltaOfDelta
|
|
||||||
s.lastUnixtime = uint32(int64(s.lastUnixtime) - delta)
|
|
||||||
return s.lastUnixtime, false
|
|
||||||
}
|
|
||||||
|
|
||||||
if s.pos < s.bound {
|
|
||||||
return 0, true
|
|
||||||
}
|
|
||||||
|
|
||||||
if s.idxOf8 == 0 {
|
|
||||||
s.s8 = s.buf.GetByte(s.pos)
|
|
||||||
s.pos--
|
|
||||||
}
|
|
||||||
s.readVar()
|
|
||||||
if s.length > 0 {
|
|
||||||
s.length--
|
|
||||||
}
|
|
||||||
return s.lastUnixtime, false
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *ReverseTimeDeltaOfDeltaDecompressor) readVar() {
|
|
||||||
var (
|
|
||||||
n int
|
|
||||||
err error
|
|
||||||
)
|
|
||||||
|
|
||||||
s.lastDeltaOfDelta, n, err = s.buf.ReverseGetVarInt64(s.pos)
|
|
||||||
if err != nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
s.pos -= n
|
|
||||||
|
|
||||||
delta := int64(s.baseDelta) + s.lastDeltaOfDelta
|
|
||||||
s.lastUnixtime = uint32(int64(s.lastUnixtime) - delta)
|
|
||||||
|
|
||||||
var flag byte = 1 << s.idxOf8
|
|
||||||
if (s.s8 & flag) == flag {
|
|
||||||
s.length, n = s.buf.DecodeRunLength(s.pos)
|
|
||||||
s.pos -= n
|
|
||||||
}
|
|
||||||
if s.idxOf8 == 7 {
|
|
||||||
s.idxOf8 = 0
|
|
||||||
} else {
|
|
||||||
s.idxOf8++
|
|
||||||
}
|
|
||||||
}
|
|
||||||
2
go.sum
2
go.sum
@@ -18,8 +18,6 @@ gopkg.in/ini.v1 v1.67.1/go.mod h1:x/cyOwCgZqOkJoDIJ3c1KNHMo10+nLGAhh+kn3Zizss=
|
|||||||
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||||
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
|
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
|
||||||
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||||
gordenko.dev/dima/bin v0.0.0-20260528204801-12b890585248 h1:APYOkErjDz3hykfcddvmABsexoyKUgdRPU3XiM16F34=
|
|
||||||
gordenko.dev/dima/bin v0.0.0-20260528204801-12b890585248/go.mod h1:/I+9fvRUzXHgXSwGEwOK1mBBM4BJ3AtCmoCZ2upDiwk=
|
|
||||||
gordenko.dev/dima/bin v0.0.0-20260604235618-bff16d774d98 h1:pQzJ4wnSrFXn9Hu+v6KvWZ4GQVBmuTljJGZ20Pb+BJA=
|
gordenko.dev/dima/bin v0.0.0-20260604235618-bff16d774d98 h1:pQzJ4wnSrFXn9Hu+v6KvWZ4GQVBmuTljJGZ20Pb+BJA=
|
||||||
gordenko.dev/dima/bin v0.0.0-20260604235618-bff16d774d98/go.mod h1:/I+9fvRUzXHgXSwGEwOK1mBBM4BJ3AtCmoCZ2upDiwk=
|
gordenko.dev/dima/bin v0.0.0-20260604235618-bff16d774d98/go.mod h1:/I+9fvRUzXHgXSwGEwOK1mBBM4BJ3AtCmoCZ2upDiwk=
|
||||||
gordenko.dev/dima/pretty v0.0.0-20221225212746-0c27d8c0ac69 h1:nyJ3mzTQ46yUeMZCdLyYcs7B5JCS54c67v84miyhq2E=
|
gordenko.dev/dima/pretty v0.0.0-20221225212746-0c27d8c0ac69 h1:nyJ3mzTQ46yUeMZCdLyYcs7B5JCS54c67v84miyhq2E=
|
||||||
|
|||||||
Reference in New Issue
Block a user