forked from TrueCloudLab/neoneo-go
a67728628e
* Created test_data folder with block json files for testing + create separate file for block base. * Fixed bug in WriteVarUint + Trim logic + unit tests * Refactored store and add more tests for it. * restore headerList from chain file * Fix tx decode bug + lots of housekeeping. * Implemented Node restore state from chain file. * Created standalone package for storage. Added couple more methods to Batch and Store interfaces. * Block persisting + tests * bumped version -> 0.31.0
73 lines
1.8 KiB
Go
73 lines
1.8 KiB
Go
package core
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"io"
|
|
|
|
"github.com/CityOfZion/neo-go/pkg/util"
|
|
)
|
|
|
|
// A HeaderHashList represents a list of header hashes.
|
|
// This datastructure in not routine safe and should be
|
|
// used under some kind of protection against race conditions.
|
|
type HeaderHashList struct {
|
|
hashes []util.Uint256
|
|
}
|
|
|
|
// NewHeaderHashListFromBytes return a new hash list from the given bytes.
|
|
func NewHeaderHashListFromBytes(b []byte) (*HeaderHashList, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
// NewHeaderHashList return a new pointer to a HeaderHashList.
|
|
func NewHeaderHashList(hashes ...util.Uint256) *HeaderHashList {
|
|
return &HeaderHashList{
|
|
hashes: hashes,
|
|
}
|
|
}
|
|
|
|
// Add appends the given hash to the list of hashes.
|
|
func (l *HeaderHashList) Add(h ...util.Uint256) {
|
|
l.hashes = append(l.hashes, h...)
|
|
}
|
|
|
|
// Len return the length of the underlying hashes slice.
|
|
func (l *HeaderHashList) Len() int {
|
|
return len(l.hashes)
|
|
}
|
|
|
|
// Get returns the hash by the given index.
|
|
func (l *HeaderHashList) Get(i int) util.Uint256 {
|
|
if l.Len() <= i {
|
|
return util.Uint256{}
|
|
}
|
|
return l.hashes[i]
|
|
}
|
|
|
|
// Last return the last hash in the HeaderHashList.
|
|
func (l *HeaderHashList) Last() util.Uint256 {
|
|
return l.hashes[l.Len()-1]
|
|
}
|
|
|
|
// Slice return a subslice of the underlying hashes.
|
|
// Subsliced from start to end.
|
|
// Example:
|
|
// headers := headerList.Slice(0, 2000)
|
|
func (l *HeaderHashList) Slice(start, end int) []util.Uint256 {
|
|
return l.hashes[start:end]
|
|
}
|
|
|
|
// WriteTo will write n underlying hashes to the given io.Writer
|
|
// starting from start.
|
|
func (l *HeaderHashList) Write(w io.Writer, start, n int) error {
|
|
if err := util.WriteVarUint(w, uint64(n)); err != nil {
|
|
return err
|
|
}
|
|
hashes := l.Slice(start, start+n)
|
|
for _, hash := range hashes {
|
|
if err := binary.Write(w, binary.LittleEndian, hash); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|