wp
This commit is contained in:
@@ -1,11 +1,9 @@
|
||||
package chunkenc
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"log"
|
||||
|
||||
bin "gordenko.dev/dima/bin/little"
|
||||
"gordenko.dev/dima/pretty"
|
||||
"gordenko.dev/dima/qb"
|
||||
)
|
||||
|
||||
@@ -19,48 +17,63 @@ Timestamps читаються звичайними методами Get*, а п
|
||||
|
||||
*/
|
||||
|
||||
type ReverseTimeDeltaCompressor struct {
|
||||
buf []byte
|
||||
pos int
|
||||
lastUnixtime uint32
|
||||
lastDelta uint32
|
||||
lastDeltaSize int
|
||||
h byte
|
||||
state *TimeDeltaBound
|
||||
const (
|
||||
hSize = 1
|
||||
|
||||
// append scripts
|
||||
addUnixtime = 0
|
||||
incrementRun = 1
|
||||
incrementLiteral = 2
|
||||
endSeries = 3
|
||||
startRun = 5
|
||||
add1stDelta = 6
|
||||
)
|
||||
|
||||
type TimeDeltaCompressor struct {
|
||||
buf []byte
|
||||
// останній записаний байт, якщо рахувати справа наліво
|
||||
pos int
|
||||
lastUnixtime uint32
|
||||
lastDelta uint32
|
||||
h byte
|
||||
state *TimeDeltaCapturedState
|
||||
}
|
||||
|
||||
func NewReverseTimeDeltaCompressor(buf []byte, size int) *ReverseTimeDeltaCompressor {
|
||||
s := &ReverseTimeDeltaCompressor{
|
||||
// Кодує значення справа наліво футнкціями TailPut*. Читає значення зліва направо функціями Get*
|
||||
func NewTimeDeltaCompressor(buf []byte, size int) *TimeDeltaCompressor {
|
||||
s := &TimeDeltaCompressor{
|
||||
buf: buf,
|
||||
pos: size, // перший вільний байт
|
||||
pos: len(buf) - size,
|
||||
}
|
||||
if size > 0 {
|
||||
var err error
|
||||
s.lastUnixtime, err = bin.GetUint32(s.buf[s.pos:])
|
||||
if err != nil {
|
||||
log.Fatalf("bug: get last unixtime: %s", err)
|
||||
}
|
||||
s.pos += 4
|
||||
if s.pos < len(buf) {
|
||||
s.h = s.buf[s.pos]
|
||||
s.pos++
|
||||
u64, n, err := bin.GetVarUint64(s.buf[s.pos:])
|
||||
if err != nil {
|
||||
log.Fatalf("bug: get last delta: %s", err)
|
||||
}
|
||||
s.lastDelta = uint32(u64)
|
||||
s.pos += n
|
||||
}
|
||||
}
|
||||
// if size > 0 {
|
||||
// u64, n, err := bin.ReverseGetVarUint64(s.buf[:s.pos-1])
|
||||
// if err != nil {
|
||||
// log.Fatalf("bug: get last unixtime: %s", err)
|
||||
// }
|
||||
// s.lastUnixtime = uint32(u64)
|
||||
// s.pos -= n
|
||||
// if s.pos > 0 {
|
||||
// s.h = s.buf[s.pos-1]
|
||||
// u64, s.lastDeltaSize, err = bin.ReverseGetVarUint64(s.buf[:s.pos-2])
|
||||
// if err != nil {
|
||||
// log.Fatalf("bug: get last delta: %s", err)
|
||||
// }
|
||||
// s.lastDelta = uint32(u64)
|
||||
// }
|
||||
// }
|
||||
return s
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaCompressor) Size() int {
|
||||
return s.pos
|
||||
func (s *TimeDeltaCompressor) Size() int {
|
||||
return len(s.buf) - s.pos
|
||||
}
|
||||
|
||||
const hSize = 1
|
||||
|
||||
// retrun
|
||||
func (s *ReverseTimeDeltaCompressor) CalcRequiredSpace(unixtime uint32) (code int, size int) {
|
||||
func (s *TimeDeltaCompressor) CalcRequiredSpace(unixtime uint32) (code int, size int) {
|
||||
//fmt.Println(unixtime)
|
||||
size = 4 // last unixtime
|
||||
if s.lastUnixtime > 0 {
|
||||
delta := unixtime - s.lastUnixtime
|
||||
if s.lastDelta > 0 {
|
||||
@@ -68,81 +81,286 @@ func (s *ReverseTimeDeltaCompressor) CalcRequiredSpace(unixtime uint32) (code in
|
||||
if s.h < 128 {
|
||||
// run
|
||||
if delta == s.lastDelta && s.h < 127 {
|
||||
code = incementRun
|
||||
code = incrementRun
|
||||
size += hSize
|
||||
} else {
|
||||
code = endOfSeries
|
||||
code = endSeries
|
||||
size += bin.CountVarUint64(uint64(s.lastDelta)) + // previous delta
|
||||
hSize + // h - end of run
|
||||
bin.CountVarUint64(uint64(delta)) + // new literal
|
||||
hSize // new h
|
||||
}
|
||||
} else {
|
||||
// literal
|
||||
if delta != s.lastDelta {
|
||||
if s.h < 255 {
|
||||
code = incementLiteral
|
||||
code = incrementLiteral
|
||||
size += bin.CountVarUint64(uint64(s.lastDelta)) + // previous delta
|
||||
bin.CountVarUint64(uint64(delta)) + // new delta
|
||||
hSize
|
||||
} else {
|
||||
code = endOfSeries
|
||||
code = endSeries
|
||||
size += bin.CountVarUint64(uint64(s.lastDelta)) + // previous delta
|
||||
hSize + // h - end of literal
|
||||
bin.CountVarUint64(uint64(delta)) + // new literal
|
||||
hSize // new h
|
||||
}
|
||||
} else {
|
||||
code = startRun
|
||||
if s.h > 128 {
|
||||
size += hSize // h - end of literal
|
||||
}
|
||||
size += bin.CountVarUint64(uint64(delta)) + // new delta
|
||||
hSize // new h
|
||||
}
|
||||
}
|
||||
} else {
|
||||
code = add1stDelta
|
||||
size += bin.CountVarUint64(uint64(delta)) + // new literal
|
||||
hSize // new h
|
||||
}
|
||||
} else {
|
||||
code = addUnixtime
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
func (s *TimeDeltaCompressor) Append(code int, unixtime uint32) {
|
||||
delta := unixtime - s.lastUnixtime
|
||||
switch code {
|
||||
case incrementRun:
|
||||
s.h++
|
||||
case incrementLiteral:
|
||||
// write previous delta and increment counter
|
||||
n, _ := bin.TailPutVarUint64(s.buf[:s.pos], uint64(s.lastDelta))
|
||||
s.pos -= n
|
||||
s.lastDelta = delta
|
||||
s.h++
|
||||
case endSeries:
|
||||
n, _ := bin.TailPutVarUint64(s.buf[:s.pos], uint64(s.lastDelta))
|
||||
s.pos -= n
|
||||
// write h - end of run
|
||||
s.pos--
|
||||
s.buf[s.pos] = s.h
|
||||
// start new literal (length=1)
|
||||
s.lastDelta = delta
|
||||
s.h = 128
|
||||
case startRun:
|
||||
if s.h > 128 {
|
||||
// write h - end of literal (because length > 1)
|
||||
s.h--
|
||||
s.pos--
|
||||
s.buf[s.pos] = s.h
|
||||
}
|
||||
// start new run (length=2)
|
||||
s.h = 0
|
||||
case add1stDelta:
|
||||
// start new literal (length=1)
|
||||
s.lastDelta = delta
|
||||
s.h = 128
|
||||
}
|
||||
// 1st value
|
||||
s.lastUnixtime = unixtime
|
||||
}
|
||||
|
||||
func (s *TimeDeltaCompressor) DeleteLast() {
|
||||
|
||||
}
|
||||
|
||||
func (s *TimeDeltaCompressor) Sync() {
|
||||
//n, _ := bin.ReversePutVarUint64(s.buf[s.pos:], uint64(s.lastUnixtime))
|
||||
//s.pos += n
|
||||
}
|
||||
|
||||
// FIX - check methods
|
||||
|
||||
type TimeDeltaCapturedState struct {
|
||||
H byte
|
||||
LastUnixtime uint32
|
||||
LastDelta uint32
|
||||
Buf []byte
|
||||
}
|
||||
|
||||
// delta h
|
||||
func (s *TimeDeltaCompressor) CaptureState() {
|
||||
if s.state != nil {
|
||||
qb.Abort(qb.RepeatableLock, nil)
|
||||
}
|
||||
// позиція посувається вліво, отже може перескочити на попередній chunk
|
||||
s.state = &TimeDeltaCapturedState{
|
||||
H: s.h,
|
||||
LastUnixtime: s.lastUnixtime,
|
||||
LastDelta: s.lastDelta,
|
||||
Buf: s.buf[s.pos:],
|
||||
}
|
||||
}
|
||||
|
||||
// fix - повернути в Pool буфери
|
||||
func (s *TimeDeltaCompressor) ForgetCapturedState() {
|
||||
s.state = nil
|
||||
}
|
||||
|
||||
// fix
|
||||
func (s *TimeDeltaCompressor) Offset() int {
|
||||
// if s.state != nil {
|
||||
// return s.state.Pos
|
||||
// }
|
||||
return 0
|
||||
}
|
||||
|
||||
// Snapshot - для створення снапшота.
|
||||
// return tail, head
|
||||
func (s *TimeDeltaCompressor) Snapshot() (tail []byte, head []byte) {
|
||||
if s.state == nil {
|
||||
tail = s.encodeTail(s.lastUnixtime, s.lastDelta, s.h)
|
||||
head = s.buf[s.pos:]
|
||||
} else {
|
||||
size = 4
|
||||
tail = s.encodeTail(s.state.LastUnixtime, s.state.LastDelta, s.state.H)
|
||||
head = s.state.Buf
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
const (
|
||||
addUnixtime = 0
|
||||
incementRun = 1
|
||||
incementLiteral = 2
|
||||
endOfSeries = 3
|
||||
startRun = 4
|
||||
add1stDelta = 5
|
||||
)
|
||||
func (s *TimeDeltaCompressor) encodeTail(lastUnixtime, lastDelta uint32, h byte) []byte {
|
||||
tail := make([]byte, 9)
|
||||
bin.PutUint32(tail, lastUnixtime)
|
||||
n, _ := bin.PutVarUint64(tail[4:], uint64(lastDelta))
|
||||
tail[n+4] = h
|
||||
return tail[:n+5]
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaCompressor) Append(code int, unixtime uint32) {
|
||||
delta := unixtime - s.lastUnixtime
|
||||
switch code {
|
||||
case incementRun:
|
||||
s.h++
|
||||
case incementLiteral:
|
||||
// // white s.lastDelta
|
||||
//s.lastDelta = delta
|
||||
s.h++
|
||||
case endOfSeries:
|
||||
// write h - end of series
|
||||
s.lastDelta = delta
|
||||
s.h = 128 // new literal (length=1)
|
||||
case startRun:
|
||||
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
|
||||
|
||||
case add1stDelta:
|
||||
s.lastDelta = delta
|
||||
func (s *TimeDeltaCompressor) CreateDecompressor() qb.TimestampDecompressor {
|
||||
if s.state == nil {
|
||||
return NewTimeDeltaDecompressor(s.buf[s.pos:])
|
||||
}
|
||||
// 1st value
|
||||
s.lastUnixtime = unixtime
|
||||
return NewTimeDeltaDecompressorFromCapturedState(*s.state)
|
||||
}
|
||||
|
||||
func (s *TimeDeltaCompressor) Renew() {
|
||||
// УВАГА!
|
||||
// state не чіпаємо
|
||||
s.buf = make([]byte, minBufferSize)
|
||||
s.pos = len(s.buf)
|
||||
s.lastUnixtime = 0
|
||||
s.lastDelta = 0
|
||||
s.h = 0
|
||||
}
|
||||
|
||||
func (s *TimeDeltaCompressor) Chunks() []byte {
|
||||
return s.buf
|
||||
}
|
||||
|
||||
// DECOMPRESSOR
|
||||
|
||||
type TimeDeltaDecompressor struct {
|
||||
buf []byte
|
||||
pos int
|
||||
lastDelta uint32
|
||||
lastUnixtime uint32
|
||||
isRun bool
|
||||
pending int
|
||||
done bool
|
||||
}
|
||||
|
||||
func NewTimeDeltaDecompressor(buf []byte) *TimeDeltaDecompressor {
|
||||
s := &TimeDeltaDecompressor{
|
||||
buf: buf,
|
||||
}
|
||||
if s.pos < len(s.buf) {
|
||||
var err error
|
||||
s.lastUnixtime, err = bin.GetUint32(s.buf)
|
||||
if err != nil {
|
||||
log.Fatalf("bug: get last unixtime: %s", err)
|
||||
}
|
||||
s.pos += 4
|
||||
//fmt.Println("restored last unixtime", s.lastUnixtime)
|
||||
} else {
|
||||
s.done = true
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
func NewTimeDeltaDecompressorFromCapturedState(state TimeDeltaCapturedState) *TimeDeltaDecompressor {
|
||||
s := &TimeDeltaDecompressor{
|
||||
buf: state.Buf,
|
||||
lastUnixtime: state.LastUnixtime,
|
||||
}
|
||||
if state.LastDelta > 0 {
|
||||
s.lastDelta = state.LastDelta
|
||||
s.decodeHeaderByte(state.H)
|
||||
}
|
||||
//fmt.Println("-------------------")
|
||||
//fmt.Printf("restore from bound: isRun=%t, pending=%d, lastUnix=%d, lastDelta=%d\n",
|
||||
//s.isRun, s.pending, s.lastUnixtime, s.lastDelta)
|
||||
//fmt.Printf("buf: %d\n", s.buf)
|
||||
return s
|
||||
}
|
||||
|
||||
func (s *TimeDeltaDecompressor) NextValue() (value uint32, done bool) {
|
||||
//fmt.Printf("NextValue(): pos: %d, isRegular: %t, pending: %d\n", s.pos, s.isRegular, s.pending)
|
||||
if s.done {
|
||||
return 0, true
|
||||
}
|
||||
// повертаю значення, що було прочитано в методі RestoreFromBound/RestoreFromEnd
|
||||
value = s.lastUnixtime
|
||||
if s.lastDelta > 0 {
|
||||
s.lastUnixtime -= s.lastDelta
|
||||
s.pending--
|
||||
//fmt.Printf("lastUnix: %d, s.pending: %d\n", s.lastUnixtime, s.pending)
|
||||
if s.pending > 0 {
|
||||
// якщо в серії залишаються елементи
|
||||
if !s.isRun {
|
||||
s.readDelta()
|
||||
}
|
||||
} else if s.pos < len(s.buf) {
|
||||
// в серії більше немає елементів, отже перевіряє чи є ще дані в буфері.
|
||||
// дані є - читаю заголовок наступної серії
|
||||
s.readHeader()
|
||||
s.readDelta()
|
||||
} else {
|
||||
//s.done = true
|
||||
s.lastDelta = 0
|
||||
}
|
||||
} else {
|
||||
// був закодований лише last unixtime
|
||||
s.done = true
|
||||
}
|
||||
return value, false
|
||||
}
|
||||
|
||||
func (s *TimeDeltaDecompressor) readHeader() {
|
||||
h := s.buf[s.pos]
|
||||
s.pos++
|
||||
s.decodeHeaderByte(h)
|
||||
// fmt.Println()
|
||||
// fmt.Println("read from pos:", s.pos)
|
||||
// fmt.Println("h:", h)
|
||||
// fmt.Println("isRun:", s.isRun)
|
||||
// fmt.Println("pending:", s.pending)
|
||||
// fmt.Println()
|
||||
}
|
||||
|
||||
func (s *TimeDeltaDecompressor) decodeHeaderByte(h byte) {
|
||||
s.isRun = h < 128
|
||||
if s.isRun {
|
||||
s.pending = int(h) + 2
|
||||
} else {
|
||||
s.pending = int(h&127) + 1
|
||||
}
|
||||
}
|
||||
|
||||
func (s *TimeDeltaDecompressor) readDelta() {
|
||||
u64, n, err := bin.GetVarUint64(s.buf[s.pos:])
|
||||
if err != nil {
|
||||
log.Fatalln(err)
|
||||
}
|
||||
// fmt.Println()
|
||||
// fmt.Println("read from pos:", s.pos)
|
||||
// fmt.Println("read delta:", u64)
|
||||
// fmt.Println("read delta n:", n)
|
||||
// fmt.Println()
|
||||
s.pos += n
|
||||
s.lastDelta = uint32(u64)
|
||||
}
|
||||
|
||||
// func (s *ReverseTimeDeltaCompressor) Append(unixtime uint32) {
|
||||
@@ -188,274 +406,3 @@ func (s *ReverseTimeDeltaCompressor) Append(code int, unixtime uint32) {
|
||||
// // 1st value
|
||||
// s.lastUnixtime = unixtime
|
||||
// }
|
||||
|
||||
// func (s *ReverseTimeDeltaCompressor) convertLastFromLiteralToRun() {
|
||||
// // Зменшую кількість елементів в literal блоці
|
||||
// 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) convertLiteralToRun() {
|
||||
// // Знімаю flagLiteral, а лічильник 0 дорівнює 2 елементам в серії.
|
||||
// s.h = 0
|
||||
// s.buf[s.pos-1] = s.h
|
||||
// }
|
||||
|
||||
// func (s *ReverseTimeDeltaCompressor) appendDeltaToLiteral(delta uint32) {
|
||||
// s.h++ // збільшую к-сть дельт
|
||||
// s.lastDelta = delta
|
||||
// s.pos--
|
||||
// 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) {
|
||||
// //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) Sync() {
|
||||
n, _ := bin.ReversePutVarUint64(s.buf[s.pos:], uint64(s.lastUnixtime))
|
||||
s.pos += n
|
||||
}
|
||||
|
||||
// FIX - check methods
|
||||
|
||||
type TimeDeltaBound struct {
|
||||
Pos int
|
||||
H byte
|
||||
LastUnixtime uint32
|
||||
LastDelta uint32
|
||||
Chunks []byte
|
||||
}
|
||||
|
||||
// delta h
|
||||
// func (s *ReverseTimeDeltaCompressor) GetState() TimeDeltaBound { // fix replace by Lock
|
||||
// bound := TimeDeltaBound{
|
||||
// LastUnixtime: s.lastUnixtime,
|
||||
// }
|
||||
// if s.pos > 0 {
|
||||
// bound.Pos = s.pos - 1 - s.lastDeltaSize
|
||||
// bound.H = s.h
|
||||
// bound.LastDelta = s.lastDelta
|
||||
// }
|
||||
// return bound
|
||||
// }
|
||||
|
||||
// delta h
|
||||
func (s *ReverseTimeDeltaCompressor) Lock() {
|
||||
if s.state != nil {
|
||||
qb.Abort(qb.RepeatableLock, nil)
|
||||
}
|
||||
// позиція посувається вліво, отже може перескочити на попередній chunk
|
||||
pos := s.pos - 1 - s.lastDeltaSize
|
||||
s.state = &TimeDeltaBound{
|
||||
Pos: pos,
|
||||
H: s.h,
|
||||
LastUnixtime: s.lastUnixtime, // fix
|
||||
LastDelta: s.lastDelta,
|
||||
Chunks: s.buf[:s.pos], // fix check pos?
|
||||
}
|
||||
}
|
||||
|
||||
// fix - повернути в Pool буфери
|
||||
func (s *ReverseTimeDeltaCompressor) Unlock() {
|
||||
s.state = nil
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaCompressor) Offset() int {
|
||||
if s.state != nil {
|
||||
return s.state.Pos
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
// fix -
|
||||
func (s *ReverseTimeDeltaCompressor) Snapshot() ([]byte, int) {
|
||||
// if s.state == nil {
|
||||
// return s.buf, s.Size()
|
||||
// }
|
||||
// // ВАЖЛИВО!
|
||||
// // Треба відтворити стан останнього чанка
|
||||
// var (
|
||||
// pos = s.state.Pos
|
||||
// chunk = make([]byte, conbuf.ChunkSize)
|
||||
// lastChunkIdx = len(s.state.Chunks) - 1
|
||||
// qtyToCopy = pos % conbuf.ChunkSize
|
||||
// )
|
||||
// copy(chunk, s.state.Chunks[lastChunkIdx][:qtyToCopy])
|
||||
// chunks := append(s.state.Chunks[:lastChunkIdx], chunk)
|
||||
|
||||
// buf := conbuf.New(chunks)
|
||||
// pos += buf.ReversePutVarUint64(pos, uint64(s.state.LastDelta))
|
||||
// buf.SetByte(pos, s.state.H)
|
||||
// pos++
|
||||
// return chunks, pos
|
||||
return nil, 0
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaCompressor) CreateDecompressor() qb.TimestampDecompressor {
|
||||
if s.state == nil {
|
||||
d := NewReverseTimeDeltaDecompressor(s.buf, s.Size())
|
||||
d.RestoreFromEnd()
|
||||
return d
|
||||
}
|
||||
d := NewReverseTimeDeltaDecompressor(s.buf, s.Size())
|
||||
d.RestoreFromBound(*s.state)
|
||||
return d
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaCompressor) Renew() {
|
||||
// УВАГА!
|
||||
// state не чіпаємо
|
||||
s.buf = make([]byte, minBufferSize)
|
||||
s.pos = 0
|
||||
//
|
||||
//s.baseValue = 0
|
||||
s.lastDelta = 0
|
||||
s.lastDeltaSize = 0
|
||||
s.h = 0
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaCompressor) Chunks() []byte {
|
||||
return s.buf
|
||||
}
|
||||
|
||||
// DECOMPRESSOR
|
||||
|
||||
type ReverseTimeDeltaDecompressor struct {
|
||||
buf []byte
|
||||
pos int
|
||||
lastDelta uint32
|
||||
lastUnixtime uint32
|
||||
isRegular bool
|
||||
isRun bool
|
||||
pending int
|
||||
done bool
|
||||
}
|
||||
|
||||
func NewReverseTimeDeltaDecompressor(buf []byte, size int) *ReverseTimeDeltaDecompressor {
|
||||
return &ReverseTimeDeltaDecompressor{
|
||||
buf: buf,
|
||||
pos: size,
|
||||
}
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaDecompressor) RestoreFromEnd() {
|
||||
fmt.Println("RestoreFromEnd", s.pos)
|
||||
if s.pos > 0 {
|
||||
s.pos-- // перший байт даних
|
||||
u64, n, err := bin.ReverseGetVarUint64(s.buf[:s.pos])
|
||||
if err != nil {
|
||||
log.Fatalf("bug: get last unixtime: %s", err)
|
||||
}
|
||||
s.lastUnixtime = uint32(u64)
|
||||
s.pos -= n
|
||||
fmt.Println("restored", s.lastUnixtime, s.pos)
|
||||
if s.pos > 0 {
|
||||
s.readHeader()
|
||||
s.readDelta()
|
||||
}
|
||||
} else {
|
||||
s.done = true
|
||||
}
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaDecompressor) RestoreFromBound(bound TimeDeltaBound) {
|
||||
pretty.Println(bound)
|
||||
s.lastUnixtime = bound.LastUnixtime
|
||||
if bound.LastDelta > 0 {
|
||||
s.pos = bound.Pos - 1
|
||||
s.lastDelta = bound.LastDelta
|
||||
s.decodeHeaderByte(bound.H)
|
||||
} else {
|
||||
s.pos = -1
|
||||
}
|
||||
fmt.Printf("restore from bound: pos=%d, isRun=%t, pending=%d\n", s.pos, s.isRun, s.pending)
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaDecompressor) NextValue() (value uint32, done bool) {
|
||||
//fmt.Printf("NextValue(): pos: %d, isRegular: %t, pending: %d\n", s.pos, s.isRegular, s.pending)
|
||||
if s.done {
|
||||
return 0, true
|
||||
}
|
||||
// повертаю значення, що було прочитано в методі RestoreFromBound/RestoreFromEnd
|
||||
value = s.lastUnixtime
|
||||
if s.isRegular {
|
||||
s.pending--
|
||||
if s.pending > 0 {
|
||||
// якщо в серії залишаються елементи
|
||||
if !s.isRun {
|
||||
s.readDelta()
|
||||
}
|
||||
s.lastUnixtime -= s.lastDelta
|
||||
} else if s.pos > 0 {
|
||||
// в серії більше немає елементів, отже перевіряє чи є ще дані в буфері.
|
||||
// дані є - читаю заголовок наступної серії
|
||||
s.readHeader()
|
||||
s.readDelta()
|
||||
s.lastUnixtime -= s.lastDelta
|
||||
} else {
|
||||
s.done = true
|
||||
}
|
||||
} else {
|
||||
if s.lastDelta > 0 {
|
||||
s.isRegular = true
|
||||
s.lastUnixtime -= s.lastDelta
|
||||
} else {
|
||||
// був закодований лише last unixtime
|
||||
s.done = true
|
||||
}
|
||||
}
|
||||
return value, false
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaDecompressor) readHeader() {
|
||||
h := s.buf[s.pos]
|
||||
s.pos--
|
||||
s.decodeHeaderByte(h)
|
||||
// fmt.Println("h:", h)
|
||||
// fmt.Println("isRun:", s.isRun)
|
||||
// fmt.Println("pending:", s.pending)
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaDecompressor) decodeHeaderByte(h byte) {
|
||||
s.isRun = h < 128
|
||||
if s.isRun {
|
||||
s.pending = int(h&127) + 2
|
||||
} else {
|
||||
s.pending = int(h&127) + 1
|
||||
}
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaDecompressor) readDelta() {
|
||||
u64, n, err := bin.ReverseGetVarUint64(s.buf[:s.pos])
|
||||
if err != nil {
|
||||
log.Fatalln(err)
|
||||
}
|
||||
// fmt.Println()
|
||||
// fmt.Println("read from pos:", s.pos)
|
||||
// fmt.Println("read delta:", u64)
|
||||
// fmt.Println("read delta n:", n)
|
||||
// fmt.Println()
|
||||
s.pos -= n
|
||||
s.lastDelta = uint32(u64)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user