-
Notifications
You must be signed in to change notification settings - Fork 2
/
heap_pointreader.go
79 lines (63 loc) · 1.62 KB
/
heap_pointreader.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
package bkd
import (
"encoding/binary"
)
var _ PointReader = &HeapPointReader{}
// HeapPointReader Utility class to read buffered points from in-heap arrays.
// lucene.internal
type HeapPointReader struct {
curRead int
block []byte
config *Config
end int
pointValue *HeapPointValue
}
func NewHeapPointReader(config *Config, block []byte, start, end int) *HeapPointReader {
reader := &HeapPointReader{
curRead: start - 1,
block: block,
config: config,
end: end,
}
if len(block) > 0 {
reader.pointValue = NewHeapPointValue(config, block)
}
return reader
}
func (h *HeapPointReader) Close() error {
return nil
}
func (h *HeapPointReader) Next() (bool, error) {
h.curRead++
return h.curRead < h.end, nil
}
func (h *HeapPointReader) PointValue() PointValue {
h.pointValue.SetOffset(h.curRead * h.config.BytesPerDoc())
return h.pointValue
}
var _ PointValue = &HeapPointValue{}
// HeapPointValue Reusable implementation for a point value on-heap
type HeapPointValue struct {
config *Config
bytes []byte
offset int
}
func NewHeapPointValue(config *Config, value []byte) *HeapPointValue {
return &HeapPointValue{
config: config,
bytes: value,
}
}
func (h *HeapPointValue) SetOffset(offset int) {
h.offset = offset
}
func (h *HeapPointValue) PackedValue() []byte {
return h.bytes[h.offset : h.offset+h.config.PackedBytesLength()]
}
func (h *HeapPointValue) DocID() int {
bs := h.bytes[h.offset+h.config.PackedBytesLength():]
return int(binary.BigEndian.Uint32(bs))
}
func (h *HeapPointValue) PackedValueDocIDBytes() []byte {
return h.bytes[h.offset : h.offset+h.config.BytesPerDoc()]
}