KeyNotFound is the constant returned by memo table functions when a key isn't found in the table
const KeyNotFound = -1
func Hash(b []byte, alg uint64) uint64
for smaller amounts of bytes this is faster than even calling into xxh3 to do the Hash, so we specialize in order to get the benefits of that performance.
type BinaryBuilderIFace interface {
Reserve(int)
ReserveData(int)
Retain()
Resize(int)
ResizeData(int)
Release()
DataLen() int
Value(int) []byte
Len() int
AppendNull()
AppendString(string)
Append([]byte)
}
BinaryMemoTable is our hashtable for binary data using the BinaryBuilder to construct the actual data in an easy to pass around way with minimal copies while using a hash table to keep track of the indexes into the dictionary that is created as we go.
type BinaryMemoTable struct {
// contains filtered or unexported fields
}
func NewBinaryMemoTable(initial, valuesize int, bldr BinaryBuilderIFace) *BinaryMemoTable
NewBinaryMemoTable returns a hash table for Binary data, the passed in allocator will be utilized for the BinaryBuilder, if nil then memory.DefaultAllocator will be used. initial and valuesize can be used to pre-allocate the table to reduce allocations. With initial being the initial number of entries to allocate for and valuesize being the starting amount of space allocated for writing the actual binary data.
func (b *BinaryMemoTable) CopyFixedWidthValues(start, width int, out []byte)
CopyFixedWidthValues exists to cope with the fact that the table doesn't keep track of the fixed width when inserting the null value the databuffer holds a zero length byte slice for the null value (if found)
func (b *BinaryMemoTable) CopyLargeOffsets(out []int64)
CopyLargeOffsets copies the list of offsets into the passed in slice, the offsets being the start and end values of the underlying allocated bytes in the builder for the individual values of the table. out should be at least sized to Size()+1
func (b *BinaryMemoTable) CopyLargeOffsetsSubset(start int, out []int64)
CopyLargeOffsetsSubset is like CopyOffsets but instead of copying all of the offsets, it gets a subset of the offsets in the table starting at the index provided by "start".
func (b *BinaryMemoTable) CopyOffsets(out []int32)
CopyOffsets copies the list of offsets into the passed in slice, the offsets being the start and end values of the underlying allocated bytes in the builder for the individual values of the table. out should be at least sized to Size()+1
func (b *BinaryMemoTable) CopyOffsetsSubset(start int, out []int32)
CopyOffsetsSubset is like CopyOffsets but instead of copying all of the offsets, it gets a subset of the offsets in the table starting at the index provided by "start".
func (b *BinaryMemoTable) CopyValues(out interface{})
CopyValues copies the raw binary data bytes out, out should be a []byte with at least ValuesSize bytes allocated to copy into.
func (b *BinaryMemoTable) CopyValuesSubset(start int, out interface{})
CopyValuesSubset copies the raw binary data bytes out starting with the value at the index start, out should be a []byte with at least ValuesSize bytes allocated
func (b *BinaryMemoTable) Get(val interface{}) (int, bool)
Get returns the index of the specified value in the table or KeyNotFound, and a boolean indicating whether it was found in the table.
func (s *BinaryMemoTable) GetNull() (int, bool)
GetNull returns the index of a null that has been inserted into the table or KeyNotFound. The bool returned will be true if there was a null inserted into the table, and false otherwise.
func (b *BinaryMemoTable) GetOrInsert(val interface{}) (idx int, found bool, err error)
GetOrInsert returns the index of the given value in the table, if not found it is inserted into the table. The return value 'found' indicates whether the value was found in the table (true) or inserted (false) along with any possible error.
func (b *BinaryMemoTable) GetOrInsertBytes(val []byte) (idx int, found bool, err error)
GetOrInsertBytes returns the index of the given value in the table, if not found it is inserted into the table. The return value 'found' indicates whether the value was found in the table (true) or inserted (false) along with any possible error.
func (b *BinaryMemoTable) GetOrInsertNull() (idx int, found bool)
GetOrInsertNull retrieves the index of a null in the table or inserts null into the table, returning the index and a boolean indicating if it was found in the table (true) or was inserted (false).
func (b *BinaryMemoTable) Release()
Release is used to tell the underlying builder that it can release the memory allocated when the reference count reaches 0, this is safe to be called from multiple goroutines simultaneously
func (s *BinaryMemoTable) Reset()
Reset dumps all of the data in the table allowing it to be reutilized.
func (b *BinaryMemoTable) Retain()
Retain increases the ref count, it is safe to call it from multiple goroutines simultaneously.
func (s *BinaryMemoTable) Size() int
Size returns the current size of the memo table including the null value if one has been inserted.
func (BinaryMemoTable) TypeTraits() TypeTraits
func (b *BinaryMemoTable) Value(i int) []byte
func (b *BinaryMemoTable) ValuesSize() int
ValuesSize returns the current total size of all the raw bytes that have been inserted into the memotable so far.
func (b *BinaryMemoTable) VisitValues(start int, visitFn func([]byte))
VisitValues exists to run the visitFn on each value currently in the hash table.
func (b *BinaryMemoTable) WriteOut(out []byte)
func (b *BinaryMemoTable) WriteOutSubset(start int, out []byte)
type ByteSlice interface {
Bytes() []byte
}
Float32HashTable is a hashtable specifically for float32 that is utilized with the MemoTable to generalize interactions for easier implementation of dictionaries without losing performance.
type Float32HashTable struct {
// contains filtered or unexported fields
}
func NewFloat32HashTable(cap uint64) *Float32HashTable
NewFloat32HashTable returns a new hash table for float32 values initialized with the passed in capacity or 32 whichever is larger.
func (h *Float32HashTable) CopyValues(out []float32)
CopyValues is used for copying the values out of the hash table into the passed in slice, in the order that they were first inserted
func (h *Float32HashTable) CopyValuesSubset(start int, out []float32)
CopyValuesSubset copies a subset of the values in the hashtable out, starting with the value at start, in the order that they were inserted.
func (h *Float32HashTable) Insert(e *entryFloat32, v uint64, val float32, memoIdx int32) error
Insert updates the given entry with the provided hash value, payload value and memo index. The entry pointer must have been retrieved via lookup in order to actually insert properly.
func (h *Float32HashTable) Lookup(v uint64, cmp func(float32) bool) (*entryFloat32, bool)
Lookup retrieves the entry for a given hash value assuming it's payload value returns true when passed to the cmp func. Returns a pointer to the entry for the given hash value, and a boolean as to whether it was found. It is not safe to use the pointer if the bool is false.
func (h *Float32HashTable) Reset(cap uint64)
Reset drops all of the values in this hash table and re-initializes it with the specified initial capacity as if by calling New, but without having to reallocate the object.
func (h *Float32HashTable) VisitEntries(visit func(*entryFloat32))
VisitEntries will call the passed in function on each *valid* entry in the hash table, a valid entry being one which has had a value inserted into it.
func (h *Float32HashTable) WriteOut(out []byte)
func (h *Float32HashTable) WriteOutSubset(start int, out []byte)
Float32MemoTable is a wrapper over the appropriate hashtable to provide an interface conforming to the MemoTable interface defined in the encoding package for general interactions regarding dictionaries.
type Float32MemoTable struct {
// contains filtered or unexported fields
}
func NewFloat32MemoTable(num int64) *Float32MemoTable
NewFloat32MemoTable returns a new memotable with num entries pre-allocated to reduce further allocations when inserting.
func (s *Float32MemoTable) CopyValues(out interface{})
CopyValues will copy the values from the memo table out into the passed in slice which must be of the appropriate type.
func (s *Float32MemoTable) CopyValuesSubset(start int, out interface{})
CopyValuesSubset is like CopyValues but only copies a subset of values starting at the provided start index
func (s *Float32MemoTable) Get(val interface{}) (int, bool)
Get returns the index of the requested value in the hash table or KeyNotFound along with a boolean indicating if it was found or not.
func (s *Float32MemoTable) GetNull() (int, bool)
GetNull returns the index of an inserted null or KeyNotFound along with a bool that will be true if found and false if not.
func (s *Float32MemoTable) GetOrInsert(val interface{}) (idx int, found bool, err error)
GetOrInsert will return the index of the specified value in the table, or insert the value into the table and return the new index. found indicates whether or not it already existed in the table (true) or was inserted by this call (false).
func (s *Float32MemoTable) GetOrInsertBytes(val []byte) (idx int, found bool, err error)
GetOrInsertBytes is unimplemented
func (s *Float32MemoTable) GetOrInsertNull() (idx int, found bool)
GetOrInsertNull will return the index of the null entry or insert a null entry if one currently doesn't exist. The found value will be true if there was already a null in the table, and false if it inserted one.
func (s *Float32MemoTable) Reset()
Reset allows this table to be re-used by dumping all the data currently in the table.
func (s *Float32MemoTable) Size() int
Size returns the current number of inserted elements into the table including if a null has been inserted.
func (Float32MemoTable) TypeTraits() TypeTraits
func (s *Float32MemoTable) WriteOut(out []byte)
func (s *Float32MemoTable) WriteOutLE(out []byte)
func (s *Float32MemoTable) WriteOutSubset(start int, out []byte)
func (s *Float32MemoTable) WriteOutSubsetLE(start int, out []byte)
Float64HashTable is a hashtable specifically for float64 that is utilized with the MemoTable to generalize interactions for easier implementation of dictionaries without losing performance.
type Float64HashTable struct {
// contains filtered or unexported fields
}
func NewFloat64HashTable(cap uint64) *Float64HashTable
NewFloat64HashTable returns a new hash table for float64 values initialized with the passed in capacity or 32 whichever is larger.
func (h *Float64HashTable) CopyValues(out []float64)
CopyValues is used for copying the values out of the hash table into the passed in slice, in the order that they were first inserted
func (h *Float64HashTable) CopyValuesSubset(start int, out []float64)
CopyValuesSubset copies a subset of the values in the hashtable out, starting with the value at start, in the order that they were inserted.
func (h *Float64HashTable) Insert(e *entryFloat64, v uint64, val float64, memoIdx int32) error
Insert updates the given entry with the provided hash value, payload value and memo index. The entry pointer must have been retrieved via lookup in order to actually insert properly.
func (h *Float64HashTable) Lookup(v uint64, cmp func(float64) bool) (*entryFloat64, bool)
Lookup retrieves the entry for a given hash value assuming it's payload value returns true when passed to the cmp func. Returns a pointer to the entry for the given hash value, and a boolean as to whether it was found. It is not safe to use the pointer if the bool is false.
func (h *Float64HashTable) Reset(cap uint64)
Reset drops all of the values in this hash table and re-initializes it with the specified initial capacity as if by calling New, but without having to reallocate the object.
func (h *Float64HashTable) VisitEntries(visit func(*entryFloat64))
VisitEntries will call the passed in function on each *valid* entry in the hash table, a valid entry being one which has had a value inserted into it.
func (h *Float64HashTable) WriteOut(out []byte)
func (h *Float64HashTable) WriteOutSubset(start int, out []byte)
Float64MemoTable is a wrapper over the appropriate hashtable to provide an interface conforming to the MemoTable interface defined in the encoding package for general interactions regarding dictionaries.
type Float64MemoTable struct {
// contains filtered or unexported fields
}
func NewFloat64MemoTable(num int64) *Float64MemoTable
NewFloat64MemoTable returns a new memotable with num entries pre-allocated to reduce further allocations when inserting.
func (s *Float64MemoTable) CopyValues(out interface{})
CopyValues will copy the values from the memo table out into the passed in slice which must be of the appropriate type.
func (s *Float64MemoTable) CopyValuesSubset(start int, out interface{})
CopyValuesSubset is like CopyValues but only copies a subset of values starting at the provided start index
func (s *Float64MemoTable) Get(val interface{}) (int, bool)
Get returns the index of the requested value in the hash table or KeyNotFound along with a boolean indicating if it was found or not.
func (s *Float64MemoTable) GetNull() (int, bool)
GetNull returns the index of an inserted null or KeyNotFound along with a bool that will be true if found and false if not.
func (s *Float64MemoTable) GetOrInsert(val interface{}) (idx int, found bool, err error)
GetOrInsert will return the index of the specified value in the table, or insert the value into the table and return the new index. found indicates whether or not it already existed in the table (true) or was inserted by this call (false).
func (s *Float64MemoTable) GetOrInsertBytes(val []byte) (idx int, found bool, err error)
GetOrInsertBytes is unimplemented
func (s *Float64MemoTable) GetOrInsertNull() (idx int, found bool)
GetOrInsertNull will return the index of the null entry or insert a null entry if one currently doesn't exist. The found value will be true if there was already a null in the table, and false if it inserted one.
func (s *Float64MemoTable) Reset()
Reset allows this table to be re-used by dumping all the data currently in the table.
func (s *Float64MemoTable) Size() int
Size returns the current number of inserted elements into the table including if a null has been inserted.
func (Float64MemoTable) TypeTraits() TypeTraits
func (s *Float64MemoTable) WriteOut(out []byte)
func (s *Float64MemoTable) WriteOutLE(out []byte)
func (s *Float64MemoTable) WriteOutSubset(start int, out []byte)
func (s *Float64MemoTable) WriteOutSubsetLE(start int, out []byte)
Int16HashTable is a hashtable specifically for int16 that is utilized with the MemoTable to generalize interactions for easier implementation of dictionaries without losing performance.
type Int16HashTable struct {
// contains filtered or unexported fields
}
func NewInt16HashTable(cap uint64) *Int16HashTable
NewInt16HashTable returns a new hash table for int16 values initialized with the passed in capacity or 32 whichever is larger.
func (h *Int16HashTable) CopyValues(out []int16)
CopyValues is used for copying the values out of the hash table into the passed in slice, in the order that they were first inserted
func (h *Int16HashTable) CopyValuesSubset(start int, out []int16)
CopyValuesSubset copies a subset of the values in the hashtable out, starting with the value at start, in the order that they were inserted.
func (h *Int16HashTable) Insert(e *entryInt16, v uint64, val int16, memoIdx int32) error
Insert updates the given entry with the provided hash value, payload value and memo index. The entry pointer must have been retrieved via lookup in order to actually insert properly.
func (h *Int16HashTable) Lookup(v uint64, cmp func(int16) bool) (*entryInt16, bool)
Lookup retrieves the entry for a given hash value assuming it's payload value returns true when passed to the cmp func. Returns a pointer to the entry for the given hash value, and a boolean as to whether it was found. It is not safe to use the pointer if the bool is false.
func (h *Int16HashTable) Reset(cap uint64)
Reset drops all of the values in this hash table and re-initializes it with the specified initial capacity as if by calling New, but without having to reallocate the object.
func (h *Int16HashTable) VisitEntries(visit func(*entryInt16))
VisitEntries will call the passed in function on each *valid* entry in the hash table, a valid entry being one which has had a value inserted into it.
func (h *Int16HashTable) WriteOut(out []byte)
func (h *Int16HashTable) WriteOutSubset(start int, out []byte)
Int16MemoTable is a wrapper over the appropriate hashtable to provide an interface conforming to the MemoTable interface defined in the encoding package for general interactions regarding dictionaries.
type Int16MemoTable struct {
// contains filtered or unexported fields
}
func NewInt16MemoTable(num int64) *Int16MemoTable
NewInt16MemoTable returns a new memotable with num entries pre-allocated to reduce further allocations when inserting.
func (s *Int16MemoTable) CopyValues(out interface{})
CopyValues will copy the values from the memo table out into the passed in slice which must be of the appropriate type.
func (s *Int16MemoTable) CopyValuesSubset(start int, out interface{})
CopyValuesSubset is like CopyValues but only copies a subset of values starting at the provided start index
func (s *Int16MemoTable) Get(val interface{}) (int, bool)
Get returns the index of the requested value in the hash table or KeyNotFound along with a boolean indicating if it was found or not.
func (s *Int16MemoTable) GetNull() (int, bool)
GetNull returns the index of an inserted null or KeyNotFound along with a bool that will be true if found and false if not.
func (s *Int16MemoTable) GetOrInsert(val interface{}) (idx int, found bool, err error)
GetOrInsert will return the index of the specified value in the table, or insert the value into the table and return the new index. found indicates whether or not it already existed in the table (true) or was inserted by this call (false).
func (s *Int16MemoTable) GetOrInsertBytes(val []byte) (idx int, found bool, err error)
GetOrInsertBytes is unimplemented
func (s *Int16MemoTable) GetOrInsertNull() (idx int, found bool)
GetOrInsertNull will return the index of the null entry or insert a null entry if one currently doesn't exist. The found value will be true if there was already a null in the table, and false if it inserted one.
func (s *Int16MemoTable) Reset()
Reset allows this table to be re-used by dumping all the data currently in the table.
func (s *Int16MemoTable) Size() int
Size returns the current number of inserted elements into the table including if a null has been inserted.
func (Int16MemoTable) TypeTraits() TypeTraits
func (s *Int16MemoTable) WriteOut(out []byte)
func (s *Int16MemoTable) WriteOutLE(out []byte)
func (s *Int16MemoTable) WriteOutSubset(start int, out []byte)
func (s *Int16MemoTable) WriteOutSubsetLE(start int, out []byte)
Int32HashTable is a hashtable specifically for int32 that is utilized with the MemoTable to generalize interactions for easier implementation of dictionaries without losing performance.
type Int32HashTable struct {
// contains filtered or unexported fields
}
func NewInt32HashTable(cap uint64) *Int32HashTable
NewInt32HashTable returns a new hash table for int32 values initialized with the passed in capacity or 32 whichever is larger.
func (h *Int32HashTable) CopyValues(out []int32)
CopyValues is used for copying the values out of the hash table into the passed in slice, in the order that they were first inserted
func (h *Int32HashTable) CopyValuesSubset(start int, out []int32)
CopyValuesSubset copies a subset of the values in the hashtable out, starting with the value at start, in the order that they were inserted.
func (h *Int32HashTable) Insert(e *entryInt32, v uint64, val int32, memoIdx int32) error
Insert updates the given entry with the provided hash value, payload value and memo index. The entry pointer must have been retrieved via lookup in order to actually insert properly.
func (h *Int32HashTable) Lookup(v uint64, cmp func(int32) bool) (*entryInt32, bool)
Lookup retrieves the entry for a given hash value assuming it's payload value returns true when passed to the cmp func. Returns a pointer to the entry for the given hash value, and a boolean as to whether it was found. It is not safe to use the pointer if the bool is false.
func (h *Int32HashTable) Reset(cap uint64)
Reset drops all of the values in this hash table and re-initializes it with the specified initial capacity as if by calling New, but without having to reallocate the object.
func (h *Int32HashTable) VisitEntries(visit func(*entryInt32))
VisitEntries will call the passed in function on each *valid* entry in the hash table, a valid entry being one which has had a value inserted into it.
func (h *Int32HashTable) WriteOut(out []byte)
func (h *Int32HashTable) WriteOutSubset(start int, out []byte)
Int32MemoTable is a wrapper over the appropriate hashtable to provide an interface conforming to the MemoTable interface defined in the encoding package for general interactions regarding dictionaries.
type Int32MemoTable struct {
// contains filtered or unexported fields
}
func NewInt32MemoTable(num int64) *Int32MemoTable
NewInt32MemoTable returns a new memotable with num entries pre-allocated to reduce further allocations when inserting.
func (s *Int32MemoTable) CopyValues(out interface{})
CopyValues will copy the values from the memo table out into the passed in slice which must be of the appropriate type.
func (s *Int32MemoTable) CopyValuesSubset(start int, out interface{})
CopyValuesSubset is like CopyValues but only copies a subset of values starting at the provided start index
func (s *Int32MemoTable) Get(val interface{}) (int, bool)
Get returns the index of the requested value in the hash table or KeyNotFound along with a boolean indicating if it was found or not.
func (s *Int32MemoTable) GetNull() (int, bool)
GetNull returns the index of an inserted null or KeyNotFound along with a bool that will be true if found and false if not.
func (s *Int32MemoTable) GetOrInsert(val interface{}) (idx int, found bool, err error)
GetOrInsert will return the index of the specified value in the table, or insert the value into the table and return the new index. found indicates whether or not it already existed in the table (true) or was inserted by this call (false).
func (s *Int32MemoTable) GetOrInsertBytes(val []byte) (idx int, found bool, err error)
GetOrInsertBytes is unimplemented
func (s *Int32MemoTable) GetOrInsertNull() (idx int, found bool)
GetOrInsertNull will return the index of the null entry or insert a null entry if one currently doesn't exist. The found value will be true if there was already a null in the table, and false if it inserted one.
func (s *Int32MemoTable) Reset()
Reset allows this table to be re-used by dumping all the data currently in the table.
func (s *Int32MemoTable) Size() int
Size returns the current number of inserted elements into the table including if a null has been inserted.
func (Int32MemoTable) TypeTraits() TypeTraits
func (s *Int32MemoTable) WriteOut(out []byte)
func (s *Int32MemoTable) WriteOutLE(out []byte)
func (s *Int32MemoTable) WriteOutSubset(start int, out []byte)
func (s *Int32MemoTable) WriteOutSubsetLE(start int, out []byte)
Int64HashTable is a hashtable specifically for int64 that is utilized with the MemoTable to generalize interactions for easier implementation of dictionaries without losing performance.
type Int64HashTable struct {
// contains filtered or unexported fields
}
func NewInt64HashTable(cap uint64) *Int64HashTable
NewInt64HashTable returns a new hash table for int64 values initialized with the passed in capacity or 32 whichever is larger.
func (h *Int64HashTable) CopyValues(out []int64)
CopyValues is used for copying the values out of the hash table into the passed in slice, in the order that they were first inserted
func (h *Int64HashTable) CopyValuesSubset(start int, out []int64)
CopyValuesSubset copies a subset of the values in the hashtable out, starting with the value at start, in the order that they were inserted.
func (h *Int64HashTable) Insert(e *entryInt64, v uint64, val int64, memoIdx int32) error
Insert updates the given entry with the provided hash value, payload value and memo index. The entry pointer must have been retrieved via lookup in order to actually insert properly.
func (h *Int64HashTable) Lookup(v uint64, cmp func(int64) bool) (*entryInt64, bool)
Lookup retrieves the entry for a given hash value assuming it's payload value returns true when passed to the cmp func. Returns a pointer to the entry for the given hash value, and a boolean as to whether it was found. It is not safe to use the pointer if the bool is false.
func (h *Int64HashTable) Reset(cap uint64)
Reset drops all of the values in this hash table and re-initializes it with the specified initial capacity as if by calling New, but without having to reallocate the object.
func (h *Int64HashTable) VisitEntries(visit func(*entryInt64))
VisitEntries will call the passed in function on each *valid* entry in the hash table, a valid entry being one which has had a value inserted into it.
func (h *Int64HashTable) WriteOut(out []byte)
func (h *Int64HashTable) WriteOutSubset(start int, out []byte)
Int64MemoTable is a wrapper over the appropriate hashtable to provide an interface conforming to the MemoTable interface defined in the encoding package for general interactions regarding dictionaries.
type Int64MemoTable struct {
// contains filtered or unexported fields
}
func NewInt64MemoTable(num int64) *Int64MemoTable
NewInt64MemoTable returns a new memotable with num entries pre-allocated to reduce further allocations when inserting.
func (s *Int64MemoTable) CopyValues(out interface{})
CopyValues will copy the values from the memo table out into the passed in slice which must be of the appropriate type.
func (s *Int64MemoTable) CopyValuesSubset(start int, out interface{})
CopyValuesSubset is like CopyValues but only copies a subset of values starting at the provided start index
func (s *Int64MemoTable) Get(val interface{}) (int, bool)
Get returns the index of the requested value in the hash table or KeyNotFound along with a boolean indicating if it was found or not.
func (s *Int64MemoTable) GetNull() (int, bool)
GetNull returns the index of an inserted null or KeyNotFound along with a bool that will be true if found and false if not.
func (s *Int64MemoTable) GetOrInsert(val interface{}) (idx int, found bool, err error)
GetOrInsert will return the index of the specified value in the table, or insert the value into the table and return the new index. found indicates whether or not it already existed in the table (true) or was inserted by this call (false).
func (s *Int64MemoTable) GetOrInsertBytes(val []byte) (idx int, found bool, err error)
GetOrInsertBytes is unimplemented
func (s *Int64MemoTable) GetOrInsertNull() (idx int, found bool)
GetOrInsertNull will return the index of the null entry or insert a null entry if one currently doesn't exist. The found value will be true if there was already a null in the table, and false if it inserted one.
func (s *Int64MemoTable) Reset()
Reset allows this table to be re-used by dumping all the data currently in the table.
func (s *Int64MemoTable) Size() int
Size returns the current number of inserted elements into the table including if a null has been inserted.
func (Int64MemoTable) TypeTraits() TypeTraits
func (s *Int64MemoTable) WriteOut(out []byte)
func (s *Int64MemoTable) WriteOutLE(out []byte)
func (s *Int64MemoTable) WriteOutSubset(start int, out []byte)
func (s *Int64MemoTable) WriteOutSubsetLE(start int, out []byte)
Int8HashTable is a hashtable specifically for int8 that is utilized with the MemoTable to generalize interactions for easier implementation of dictionaries without losing performance.
type Int8HashTable struct {
// contains filtered or unexported fields
}
func NewInt8HashTable(cap uint64) *Int8HashTable
NewInt8HashTable returns a new hash table for int8 values initialized with the passed in capacity or 32 whichever is larger.
func (h *Int8HashTable) CopyValues(out []int8)
CopyValues is used for copying the values out of the hash table into the passed in slice, in the order that they were first inserted
func (h *Int8HashTable) CopyValuesSubset(start int, out []int8)
CopyValuesSubset copies a subset of the values in the hashtable out, starting with the value at start, in the order that they were inserted.
func (h *Int8HashTable) Insert(e *entryInt8, v uint64, val int8, memoIdx int32) error
Insert updates the given entry with the provided hash value, payload value and memo index. The entry pointer must have been retrieved via lookup in order to actually insert properly.
func (h *Int8HashTable) Lookup(v uint64, cmp func(int8) bool) (*entryInt8, bool)
Lookup retrieves the entry for a given hash value assuming it's payload value returns true when passed to the cmp func. Returns a pointer to the entry for the given hash value, and a boolean as to whether it was found. It is not safe to use the pointer if the bool is false.
func (h *Int8HashTable) Reset(cap uint64)
Reset drops all of the values in this hash table and re-initializes it with the specified initial capacity as if by calling New, but without having to reallocate the object.
func (h *Int8HashTable) VisitEntries(visit func(*entryInt8))
VisitEntries will call the passed in function on each *valid* entry in the hash table, a valid entry being one which has had a value inserted into it.
func (h *Int8HashTable) WriteOut(out []byte)
func (h *Int8HashTable) WriteOutSubset(start int, out []byte)
Int8MemoTable is a wrapper over the appropriate hashtable to provide an interface conforming to the MemoTable interface defined in the encoding package for general interactions regarding dictionaries.
type Int8MemoTable struct {
// contains filtered or unexported fields
}
func NewInt8MemoTable(num int64) *Int8MemoTable
NewInt8MemoTable returns a new memotable with num entries pre-allocated to reduce further allocations when inserting.
func (s *Int8MemoTable) CopyValues(out interface{})
CopyValues will copy the values from the memo table out into the passed in slice which must be of the appropriate type.
func (s *Int8MemoTable) CopyValuesSubset(start int, out interface{})
CopyValuesSubset is like CopyValues but only copies a subset of values starting at the provided start index
func (s *Int8MemoTable) Get(val interface{}) (int, bool)
Get returns the index of the requested value in the hash table or KeyNotFound along with a boolean indicating if it was found or not.
func (s *Int8MemoTable) GetNull() (int, bool)
GetNull returns the index of an inserted null or KeyNotFound along with a bool that will be true if found and false if not.
func (s *Int8MemoTable) GetOrInsert(val interface{}) (idx int, found bool, err error)
GetOrInsert will return the index of the specified value in the table, or insert the value into the table and return the new index. found indicates whether or not it already existed in the table (true) or was inserted by this call (false).
func (s *Int8MemoTable) GetOrInsertBytes(val []byte) (idx int, found bool, err error)
GetOrInsertBytes is unimplemented
func (s *Int8MemoTable) GetOrInsertNull() (idx int, found bool)
GetOrInsertNull will return the index of the null entry or insert a null entry if one currently doesn't exist. The found value will be true if there was already a null in the table, and false if it inserted one.
func (s *Int8MemoTable) Reset()
Reset allows this table to be re-used by dumping all the data currently in the table.
func (s *Int8MemoTable) Size() int
Size returns the current number of inserted elements into the table including if a null has been inserted.
func (Int8MemoTable) TypeTraits() TypeTraits
func (s *Int8MemoTable) WriteOut(out []byte)
func (s *Int8MemoTable) WriteOutLE(out []byte)
func (s *Int8MemoTable) WriteOutSubset(start int, out []byte)
func (s *Int8MemoTable) WriteOutSubsetLE(start int, out []byte)
MemoTable interface for hash tables and dictionary encoding.
Values will remember the order they are inserted to generate a valid dictionary.
type MemoTable interface {
TypeTraits() TypeTraits
// Reset drops everything in the table allowing it to be reused
Reset()
// Size returns the current number of unique values stored in
// the table, including whether or not a null value has been
// inserted via GetOrInsertNull.
Size() int
// GetOrInsert returns the index of the table the specified value is,
// and a boolean indicating whether or not the value was found in
// the table (if false, the value was inserted). An error is returned
// if val is not the appropriate type for the table.
GetOrInsert(val interface{}) (idx int, existed bool, err error)
// GetOrInsertBytes returns the index of the table the specified value is,
// and a boolean indicating whether or not the value was found in
// the table (if false, the value was inserted). An error is returned
// if val is not the appropriate type for the table. This function is intended to be used by
// the BinaryMemoTable to prevent unnecessary allocations of the data when converting from a []byte to interface{}.
GetOrInsertBytes(val []byte) (idx int, existed bool, err error)
// GetOrInsertNull returns the index of the null value in the table,
// inserting one if it hasn't already been inserted. It returns a boolean
// indicating if the null value already existed or not in the table.
GetOrInsertNull() (idx int, existed bool)
// GetNull returns the index of the null value in the table, but does not
// insert one if it doesn't already exist. Will return -1 if it doesn't exist
// indicated by a false value for the boolean.
GetNull() (idx int, exists bool)
// WriteOut copies the unique values of the memotable out to the byte slice
// provided. Must have allocated enough bytes for all the values.
WriteOut(out []byte)
// WriteOutSubset is like WriteOut, but only writes a subset of values
// starting with the index offset.
WriteOutSubset(offset int, out []byte)
}
type NumericMemoTable interface {
MemoTable
WriteOutLE(out []byte)
WriteOutSubsetLE(offset int, out []byte)
}
type TypeTraits interface {
BytesRequired(n int) int
}
Uint16HashTable is a hashtable specifically for uint16 that is utilized with the MemoTable to generalize interactions for easier implementation of dictionaries without losing performance.
type Uint16HashTable struct {
// contains filtered or unexported fields
}
func NewUint16HashTable(cap uint64) *Uint16HashTable
NewUint16HashTable returns a new hash table for uint16 values initialized with the passed in capacity or 32 whichever is larger.
func (h *Uint16HashTable) CopyValues(out []uint16)
CopyValues is used for copying the values out of the hash table into the passed in slice, in the order that they were first inserted
func (h *Uint16HashTable) CopyValuesSubset(start int, out []uint16)
CopyValuesSubset copies a subset of the values in the hashtable out, starting with the value at start, in the order that they were inserted.
func (h *Uint16HashTable) Insert(e *entryUint16, v uint64, val uint16, memoIdx int32) error
Insert updates the given entry with the provided hash value, payload value and memo index. The entry pointer must have been retrieved via lookup in order to actually insert properly.
func (h *Uint16HashTable) Lookup(v uint64, cmp func(uint16) bool) (*entryUint16, bool)
Lookup retrieves the entry for a given hash value assuming it's payload value returns true when passed to the cmp func. Returns a pointer to the entry for the given hash value, and a boolean as to whether it was found. It is not safe to use the pointer if the bool is false.
func (h *Uint16HashTable) Reset(cap uint64)
Reset drops all of the values in this hash table and re-initializes it with the specified initial capacity as if by calling New, but without having to reallocate the object.
func (h *Uint16HashTable) VisitEntries(visit func(*entryUint16))
VisitEntries will call the passed in function on each *valid* entry in the hash table, a valid entry being one which has had a value inserted into it.
func (h *Uint16HashTable) WriteOut(out []byte)
func (h *Uint16HashTable) WriteOutSubset(start int, out []byte)
Uint16MemoTable is a wrapper over the appropriate hashtable to provide an interface conforming to the MemoTable interface defined in the encoding package for general interactions regarding dictionaries.
type Uint16MemoTable struct {
// contains filtered or unexported fields
}
func NewUint16MemoTable(num int64) *Uint16MemoTable
NewUint16MemoTable returns a new memotable with num entries pre-allocated to reduce further allocations when inserting.
func (s *Uint16MemoTable) CopyValues(out interface{})
CopyValues will copy the values from the memo table out into the passed in slice which must be of the appropriate type.
func (s *Uint16MemoTable) CopyValuesSubset(start int, out interface{})
CopyValuesSubset is like CopyValues but only copies a subset of values starting at the provided start index
func (s *Uint16MemoTable) Get(val interface{}) (int, bool)
Get returns the index of the requested value in the hash table or KeyNotFound along with a boolean indicating if it was found or not.
func (s *Uint16MemoTable) GetNull() (int, bool)
GetNull returns the index of an inserted null or KeyNotFound along with a bool that will be true if found and false if not.
func (s *Uint16MemoTable) GetOrInsert(val interface{}) (idx int, found bool, err error)
GetOrInsert will return the index of the specified value in the table, or insert the value into the table and return the new index. found indicates whether or not it already existed in the table (true) or was inserted by this call (false).
func (s *Uint16MemoTable) GetOrInsertBytes(val []byte) (idx int, found bool, err error)
GetOrInsertBytes is unimplemented
func (s *Uint16MemoTable) GetOrInsertNull() (idx int, found bool)
GetOrInsertNull will return the index of the null entry or insert a null entry if one currently doesn't exist. The found value will be true if there was already a null in the table, and false if it inserted one.
func (s *Uint16MemoTable) Reset()
Reset allows this table to be re-used by dumping all the data currently in the table.
func (s *Uint16MemoTable) Size() int
Size returns the current number of inserted elements into the table including if a null has been inserted.
func (Uint16MemoTable) TypeTraits() TypeTraits
func (s *Uint16MemoTable) WriteOut(out []byte)
func (s *Uint16MemoTable) WriteOutLE(out []byte)
func (s *Uint16MemoTable) WriteOutSubset(start int, out []byte)
func (s *Uint16MemoTable) WriteOutSubsetLE(start int, out []byte)
Uint32HashTable is a hashtable specifically for uint32 that is utilized with the MemoTable to generalize interactions for easier implementation of dictionaries without losing performance.
type Uint32HashTable struct {
// contains filtered or unexported fields
}
func NewUint32HashTable(cap uint64) *Uint32HashTable
NewUint32HashTable returns a new hash table for uint32 values initialized with the passed in capacity or 32 whichever is larger.
func (h *Uint32HashTable) CopyValues(out []uint32)
CopyValues is used for copying the values out of the hash table into the passed in slice, in the order that they were first inserted
func (h *Uint32HashTable) CopyValuesSubset(start int, out []uint32)
CopyValuesSubset copies a subset of the values in the hashtable out, starting with the value at start, in the order that they were inserted.
func (h *Uint32HashTable) Insert(e *entryUint32, v uint64, val uint32, memoIdx int32) error
Insert updates the given entry with the provided hash value, payload value and memo index. The entry pointer must have been retrieved via lookup in order to actually insert properly.
func (h *Uint32HashTable) Lookup(v uint64, cmp func(uint32) bool) (*entryUint32, bool)
Lookup retrieves the entry for a given hash value assuming it's payload value returns true when passed to the cmp func. Returns a pointer to the entry for the given hash value, and a boolean as to whether it was found. It is not safe to use the pointer if the bool is false.
func (h *Uint32HashTable) Reset(cap uint64)
Reset drops all of the values in this hash table and re-initializes it with the specified initial capacity as if by calling New, but without having to reallocate the object.
func (h *Uint32HashTable) VisitEntries(visit func(*entryUint32))
VisitEntries will call the passed in function on each *valid* entry in the hash table, a valid entry being one which has had a value inserted into it.
func (h *Uint32HashTable) WriteOut(out []byte)
func (h *Uint32HashTable) WriteOutSubset(start int, out []byte)
Uint32MemoTable is a wrapper over the appropriate hashtable to provide an interface conforming to the MemoTable interface defined in the encoding package for general interactions regarding dictionaries.
type Uint32MemoTable struct {
// contains filtered or unexported fields
}
func NewUint32MemoTable(num int64) *Uint32MemoTable
NewUint32MemoTable returns a new memotable with num entries pre-allocated to reduce further allocations when inserting.
func (s *Uint32MemoTable) CopyValues(out interface{})
CopyValues will copy the values from the memo table out into the passed in slice which must be of the appropriate type.
func (s *Uint32MemoTable) CopyValuesSubset(start int, out interface{})
CopyValuesSubset is like CopyValues but only copies a subset of values starting at the provided start index
func (s *Uint32MemoTable) Get(val interface{}) (int, bool)
Get returns the index of the requested value in the hash table or KeyNotFound along with a boolean indicating if it was found or not.
func (s *Uint32MemoTable) GetNull() (int, bool)
GetNull returns the index of an inserted null or KeyNotFound along with a bool that will be true if found and false if not.
func (s *Uint32MemoTable) GetOrInsert(val interface{}) (idx int, found bool, err error)
GetOrInsert will return the index of the specified value in the table, or insert the value into the table and return the new index. found indicates whether or not it already existed in the table (true) or was inserted by this call (false).
func (s *Uint32MemoTable) GetOrInsertBytes(val []byte) (idx int, found bool, err error)
GetOrInsertBytes is unimplemented
func (s *Uint32MemoTable) GetOrInsertNull() (idx int, found bool)
GetOrInsertNull will return the index of the null entry or insert a null entry if one currently doesn't exist. The found value will be true if there was already a null in the table, and false if it inserted one.
func (s *Uint32MemoTable) Reset()
Reset allows this table to be re-used by dumping all the data currently in the table.
func (s *Uint32MemoTable) Size() int
Size returns the current number of inserted elements into the table including if a null has been inserted.
func (Uint32MemoTable) TypeTraits() TypeTraits
func (s *Uint32MemoTable) WriteOut(out []byte)
func (s *Uint32MemoTable) WriteOutLE(out []byte)
func (s *Uint32MemoTable) WriteOutSubset(start int, out []byte)
func (s *Uint32MemoTable) WriteOutSubsetLE(start int, out []byte)
Uint64HashTable is a hashtable specifically for uint64 that is utilized with the MemoTable to generalize interactions for easier implementation of dictionaries without losing performance.
type Uint64HashTable struct {
// contains filtered or unexported fields
}
func NewUint64HashTable(cap uint64) *Uint64HashTable
NewUint64HashTable returns a new hash table for uint64 values initialized with the passed in capacity or 32 whichever is larger.
func (h *Uint64HashTable) CopyValues(out []uint64)
CopyValues is used for copying the values out of the hash table into the passed in slice, in the order that they were first inserted
func (h *Uint64HashTable) CopyValuesSubset(start int, out []uint64)
CopyValuesSubset copies a subset of the values in the hashtable out, starting with the value at start, in the order that they were inserted.
func (h *Uint64HashTable) Insert(e *entryUint64, v uint64, val uint64, memoIdx int32) error
Insert updates the given entry with the provided hash value, payload value and memo index. The entry pointer must have been retrieved via lookup in order to actually insert properly.
func (h *Uint64HashTable) Lookup(v uint64, cmp func(uint64) bool) (*entryUint64, bool)
Lookup retrieves the entry for a given hash value assuming it's payload value returns true when passed to the cmp func. Returns a pointer to the entry for the given hash value, and a boolean as to whether it was found. It is not safe to use the pointer if the bool is false.
func (h *Uint64HashTable) Reset(cap uint64)
Reset drops all of the values in this hash table and re-initializes it with the specified initial capacity as if by calling New, but without having to reallocate the object.
func (h *Uint64HashTable) VisitEntries(visit func(*entryUint64))
VisitEntries will call the passed in function on each *valid* entry in the hash table, a valid entry being one which has had a value inserted into it.
func (h *Uint64HashTable) WriteOut(out []byte)
func (h *Uint64HashTable) WriteOutSubset(start int, out []byte)
Uint64MemoTable is a wrapper over the appropriate hashtable to provide an interface conforming to the MemoTable interface defined in the encoding package for general interactions regarding dictionaries.
type Uint64MemoTable struct {
// contains filtered or unexported fields
}
func NewUint64MemoTable(num int64) *Uint64MemoTable
NewUint64MemoTable returns a new memotable with num entries pre-allocated to reduce further allocations when inserting.
func (s *Uint64MemoTable) CopyValues(out interface{})
CopyValues will copy the values from the memo table out into the passed in slice which must be of the appropriate type.
func (s *Uint64MemoTable) CopyValuesSubset(start int, out interface{})
CopyValuesSubset is like CopyValues but only copies a subset of values starting at the provided start index
func (s *Uint64MemoTable) Get(val interface{}) (int, bool)
Get returns the index of the requested value in the hash table or KeyNotFound along with a boolean indicating if it was found or not.
func (s *Uint64MemoTable) GetNull() (int, bool)
GetNull returns the index of an inserted null or KeyNotFound along with a bool that will be true if found and false if not.
func (s *Uint64MemoTable) GetOrInsert(val interface{}) (idx int, found bool, err error)
GetOrInsert will return the index of the specified value in the table, or insert the value into the table and return the new index. found indicates whether or not it already existed in the table (true) or was inserted by this call (false).
func (s *Uint64MemoTable) GetOrInsertBytes(val []byte) (idx int, found bool, err error)
GetOrInsertBytes is unimplemented
func (s *Uint64MemoTable) GetOrInsertNull() (idx int, found bool)
GetOrInsertNull will return the index of the null entry or insert a null entry if one currently doesn't exist. The found value will be true if there was already a null in the table, and false if it inserted one.
func (s *Uint64MemoTable) Reset()
Reset allows this table to be re-used by dumping all the data currently in the table.
func (s *Uint64MemoTable) Size() int
Size returns the current number of inserted elements into the table including if a null has been inserted.
func (Uint64MemoTable) TypeTraits() TypeTraits
func (s *Uint64MemoTable) WriteOut(out []byte)
func (s *Uint64MemoTable) WriteOutLE(out []byte)
func (s *Uint64MemoTable) WriteOutSubset(start int, out []byte)
func (s *Uint64MemoTable) WriteOutSubsetLE(start int, out []byte)
Uint8HashTable is a hashtable specifically for uint8 that is utilized with the MemoTable to generalize interactions for easier implementation of dictionaries without losing performance.
type Uint8HashTable struct {
// contains filtered or unexported fields
}
func NewUint8HashTable(cap uint64) *Uint8HashTable
NewUint8HashTable returns a new hash table for uint8 values initialized with the passed in capacity or 32 whichever is larger.
func (h *Uint8HashTable) CopyValues(out []uint8)
CopyValues is used for copying the values out of the hash table into the passed in slice, in the order that they were first inserted
func (h *Uint8HashTable) CopyValuesSubset(start int, out []uint8)
CopyValuesSubset copies a subset of the values in the hashtable out, starting with the value at start, in the order that they were inserted.
func (h *Uint8HashTable) Insert(e *entryUint8, v uint64, val uint8, memoIdx int32) error
Insert updates the given entry with the provided hash value, payload value and memo index. The entry pointer must have been retrieved via lookup in order to actually insert properly.
func (h *Uint8HashTable) Lookup(v uint64, cmp func(uint8) bool) (*entryUint8, bool)
Lookup retrieves the entry for a given hash value assuming it's payload value returns true when passed to the cmp func. Returns a pointer to the entry for the given hash value, and a boolean as to whether it was found. It is not safe to use the pointer if the bool is false.
func (h *Uint8HashTable) Reset(cap uint64)
Reset drops all of the values in this hash table and re-initializes it with the specified initial capacity as if by calling New, but without having to reallocate the object.
func (h *Uint8HashTable) VisitEntries(visit func(*entryUint8))
VisitEntries will call the passed in function on each *valid* entry in the hash table, a valid entry being one which has had a value inserted into it.
func (h *Uint8HashTable) WriteOut(out []byte)
func (h *Uint8HashTable) WriteOutSubset(start int, out []byte)
Uint8MemoTable is a wrapper over the appropriate hashtable to provide an interface conforming to the MemoTable interface defined in the encoding package for general interactions regarding dictionaries.
type Uint8MemoTable struct {
// contains filtered or unexported fields
}
func NewUint8MemoTable(num int64) *Uint8MemoTable
NewUint8MemoTable returns a new memotable with num entries pre-allocated to reduce further allocations when inserting.
func (s *Uint8MemoTable) CopyValues(out interface{})
CopyValues will copy the values from the memo table out into the passed in slice which must be of the appropriate type.
func (s *Uint8MemoTable) CopyValuesSubset(start int, out interface{})
CopyValuesSubset is like CopyValues but only copies a subset of values starting at the provided start index
func (s *Uint8MemoTable) Get(val interface{}) (int, bool)
Get returns the index of the requested value in the hash table or KeyNotFound along with a boolean indicating if it was found or not.
func (s *Uint8MemoTable) GetNull() (int, bool)
GetNull returns the index of an inserted null or KeyNotFound along with a bool that will be true if found and false if not.
func (s *Uint8MemoTable) GetOrInsert(val interface{}) (idx int, found bool, err error)
GetOrInsert will return the index of the specified value in the table, or insert the value into the table and return the new index. found indicates whether or not it already existed in the table (true) or was inserted by this call (false).
func (s *Uint8MemoTable) GetOrInsertBytes(val []byte) (idx int, found bool, err error)
GetOrInsertBytes is unimplemented
func (s *Uint8MemoTable) GetOrInsertNull() (idx int, found bool)
GetOrInsertNull will return the index of the null entry or insert a null entry if one currently doesn't exist. The found value will be true if there was already a null in the table, and false if it inserted one.
func (s *Uint8MemoTable) Reset()
Reset allows this table to be re-used by dumping all the data currently in the table.
func (s *Uint8MemoTable) Size() int
Size returns the current number of inserted elements into the table including if a null has been inserted.
func (Uint8MemoTable) TypeTraits() TypeTraits
func (s *Uint8MemoTable) WriteOut(out []byte)
func (s *Uint8MemoTable) WriteOutLE(out []byte)
func (s *Uint8MemoTable) WriteOutSubset(start int, out []byte)
func (s *Uint8MemoTable) WriteOutSubsetLE(start int, out []byte)