100 lines
1.8 KiB
Go
100 lines
1.8 KiB
Go
// internal/adapter/buffer.go
|
|
package adapter
|
|
|
|
import (
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
type RingBuffer struct {
|
|
mu sync.RWMutex
|
|
data []byte
|
|
writePtr int
|
|
count int
|
|
|
|
lastWrite time.Time
|
|
}
|
|
|
|
func NewRingBuffer(size int) *RingBuffer {
|
|
return &RingBuffer{
|
|
data: make([]byte, size),
|
|
lastWrite: time.Now(),
|
|
}
|
|
}
|
|
|
|
func (rb *RingBuffer) Write(b byte) {
|
|
rb.mu.Lock()
|
|
defer rb.mu.Unlock()
|
|
|
|
rb.data[rb.writePtr] = b
|
|
rb.writePtr = (rb.writePtr + 1) % len(rb.data)
|
|
|
|
if rb.count < len(rb.data) {
|
|
rb.count++
|
|
}
|
|
|
|
rb.lastWrite = time.Now()
|
|
}
|
|
|
|
func (rb *RingBuffer) LastWriteTime() time.Time {
|
|
rb.mu.RLock()
|
|
defer rb.mu.RUnlock()
|
|
return rb.lastWrite
|
|
}
|
|
|
|
func (rb *RingBuffer) GetLatest() (byte, bool) {
|
|
rb.mu.RLock()
|
|
defer rb.mu.RUnlock()
|
|
|
|
if rb.count == 0 {
|
|
return 0, false
|
|
}
|
|
|
|
idx := rb.writePtr - 1
|
|
if idx < 0 {
|
|
idx += len(rb.data)
|
|
}
|
|
|
|
return rb.data[idx], true
|
|
}
|
|
|
|
func (rb *RingBuffer) GetLast(n int) []byte {
|
|
rb.mu.RLock()
|
|
defer rb.mu.RUnlock()
|
|
|
|
if n > rb.count {
|
|
n = rb.count
|
|
}
|
|
|
|
res := make([]byte, n)
|
|
|
|
start := rb.writePtr - n
|
|
if start < 0 {
|
|
start += len(rb.data)
|
|
copy(res, rb.data[start:])
|
|
copy(res[len(rb.data)-start:], rb.data[:rb.writePtr])
|
|
} else {
|
|
copy(res, rb.data[start:rb.writePtr])
|
|
}
|
|
|
|
return res
|
|
}
|
|
|
|
func (rb *RingBuffer) Stats() map[string]interface{} {
|
|
rb.mu.RLock()
|
|
defer rb.mu.RUnlock()
|
|
|
|
return map[string]interface{}{
|
|
"size": len(rb.data),
|
|
"filled": rb.count,
|
|
"last_write": rb.lastWrite,
|
|
}
|
|
}
|
|
|
|
func (rb *RingBuffer) IsAlive(timeout time.Duration) bool {
|
|
rb.mu.RLock()
|
|
defer rb.mu.RUnlock()
|
|
|
|
return time.Since(rb.lastWrite) < timeout
|
|
}
|