Renames

erigon-lib/recsplit/eliasfano32/rebased_elias_fano.go

@@ -32,9 +32,9 @@ func (ref *RebasedEliasFano) Count() uint64 {
 	return ref.ef.Count()
 }
 
-func (ref *RebasedEliasFano) Reset(baseNum uint64, data []byte) {
+func (ref *RebasedEliasFano) Reset(baseNum uint64, raw []byte) {
 	ref.baseNum = baseNum
-	ref.ef.Reset(data)
+	ref.ef.Reset(raw)
 }
 
 func (ref *RebasedEliasFano) Search(v uint64) (uint64, bool) {

erigon-lib/recsplit/multiencseq/sequence_reader.go

@@ -25,9 +25,9 @@ type SequenceReader struct {
 	sseq       simpleseq.SimpleSequence
 }
 
-func ReadMultiEncSeq(baseNum uint64, b []byte) *SequenceReader {
+func ReadMultiEncSeq(baseNum uint64, raw []byte) *SequenceReader {
 	var s SequenceReader
-	s.Reset(baseNum, b)
+	s.Reset(baseNum, raw)
 	return &s
 }
 
@@ -98,25 +98,25 @@ func (s *SequenceReader) Count() uint64 {
 	panic("unknown encoding")
 }
 
-func (s *SequenceReader) Reset(baseNum uint64, data []byte) {
+func (s *SequenceReader) Reset(baseNum uint64, raw []byte) {
 	// plain elias fano (legacy)
-	if data[0]&0b10000000 == 0 {
+	if raw[0]&0b10000000 == 0 {
 		s.currentEnc = PlainEliasFano
-		s.ref.Reset(0, data)
+		s.ref.Reset(0, raw)
 		return
 	}
 
 	// rebased elias fano
-	if data[0] == 0x90 {
+	if raw[0] == 0x90 {
 		s.currentEnc = RebasedEliasFano
-		s.ref.Reset(baseNum, data[1:])
+		s.ref.Reset(baseNum, raw[1:])
 		return
 	}
 
 	// simple encoding
-	if data[0]&0b11110000 == 0b10000000 {
+	if raw[0]&0b11110000 == 0b10000000 {
 		s.currentEnc = SimpleEncoding
-		s.sseq.Reset(baseNum, data[1:])
+		s.sseq.Reset(baseNum, raw[1:])
 		return
 	}
 

erigon-lib/recsplit/simpleseq/simple_sequence.go

@@ -14,29 +14,31 @@ import (
 // as uint64, while the deltas are uint32, reinforcing the assumption that this implementation
 // is optimized for short sequences of close values.
 type SimpleSequence struct {
-	baseNum   uint64
-	rawDeltas []byte
-	pos       int
+	baseNum uint64
+	raw     []byte
+	pos     int
 }
 
 func NewSimpleSequence(baseNum uint64, count uint64) *SimpleSequence {
 	return &SimpleSequence{
-		baseNum:   baseNum,
-		rawDeltas: make([]byte, count*4),
-		pos:       0,
+		baseNum: baseNum,
+		raw:     make([]byte, count*4),
+		pos:     0,
 	}
 }
 
-func ReadSimpleSequence(baseNum uint64, rawDeltas []byte) *SimpleSequence {
-	return &SimpleSequence{
-		baseNum:   baseNum,
-		rawDeltas: rawDeltas,
-		pos:       len(rawDeltas) / 4,
-	}
+// Construct a SimpleSequence from a serialized representation.
+//
+// Returned object can be reused by calling Reset() on it.
+func ReadSimpleSequence(baseNum uint64, raw []byte) *SimpleSequence {
+	seq := SimpleSequence{}
+	seq.Reset(baseNum, raw)
+	return &seq
 }
 
 func (s *SimpleSequence) Get(i uint64) uint64 {
-	delta := binary.BigEndian.Uint32(s.rawDeltas[i*4 : (i+1)*4])
+	idx := i * 4
+	delta := binary.BigEndian.Uint32(s.raw[idx : idx+4])
 	return s.baseNum + uint64(delta)
 }
 
@@ -49,22 +51,22 @@ func (s *SimpleSequence) Max() uint64 {
 }
 
 func (s *SimpleSequence) Count() uint64 {
-	return uint64(len(s.rawDeltas) / 4)
+	return uint64(len(s.raw) / 4)
 }
 
 func (s *SimpleSequence) AddOffset(offset uint64) {
-	binary.BigEndian.PutUint32(s.rawDeltas[s.pos*4:(s.pos+1)*4], uint32(offset-s.baseNum))
+	binary.BigEndian.PutUint32(s.raw[s.pos*4:(s.pos+1)*4], uint32(offset-s.baseNum))
 	s.pos++
 }
 
-func (s *SimpleSequence) Reset(baseNum uint64, rawDeltas []byte) {
+func (s *SimpleSequence) Reset(baseNum uint64, raw []byte) {
 	s.baseNum = baseNum
-	s.rawDeltas = rawDeltas
-	s.pos = len(rawDeltas) / 4
+	s.raw = raw
+	s.pos = len(raw) / 4
 }
 
 func (s *SimpleSequence) AppendBytes(buf []byte) []byte {
-	return append(buf, s.rawDeltas...)
+	return append(buf, s.raw...)
 }
 
 func (s *SimpleSequence) search(v uint64) (int, bool) {