...
▽

Package dohash

import "gitlab.eif.urjc.es/paurea/dohash"
Overview
Index
Examples

Overview ▾

Package to make a hash.Hash64 interface able to hash any value. For comparable types use ReHash and for non comparable types, use ReSubHash, which will be able to hash the comparable subset. All of the types calculate the hash in a non-portable way, that is, the hash obtained may be different on different architectures/systems (this is useful, for example, to write datatypes, like a hash table). It is written to be fast but in clean portable, non-fragile go. An slighly faster version hardwired to hash/maphash is also included. An example of client of this package to implement a cuckoo hash table can be found in cuckoo.

▾ Example

Code:

type inner = struct {
    p string
    o byte
}
type outer = struct {
    i  int
    s  string
    in inner
}
s := [2]outer{{2, "bla", inner{"oooo", 'c'}}, {2, "bla", inner{"oooo", 'c'}}}

var mh maphash.Hash
dh := dohash.NewReHash[[2]outer](&mh)

fmt.Printf("%x", dh.SumObj64(s))
dh.Reset()

type Hasher64

Hashes any comparable type. 

type Hasher64[K comparable] interface {
    SumObj64(key K) (s uint64)
}

type MapHash

Wrapper for hash/maphash.Hash capable of hashing values of type K. 

type MapHash[K comparable] struct {
    maphash.Hash
    // contains filtered or unexported fields
}

▾ Example

Code:

type inner = struct {
    p string
    o byte
}
type outer = struct {
    i  int
    s  string
    in inner
}
s := [2]outer{{2, "bla", inner{"oooo", 'c'}}, {2, "bla", inner{"oooo", 'c'}}}

hm := dohash.NewMapHashFromExample(s)

fmt.Printf("%x", hm.SumObj64(s))
hm.Reset()

func NewMapHash 

func NewMapHash[K comparable]() (hm *MapHash[K])

Create a MapHash capable of hashing values of type K.

func NewMapHashFromExample 

func NewMapHashFromExample[K comparable](val K) (hm *MapHash[K])

Create a MapHash from an example value capable of hashing values of the same type K. The value will only have its type inspected.

func (*MapHash[K]) SumObj64 

func (hm *MapHash[K]) SumObj64(key K) (s uint64)

SumObj64 hashes the key and returns the current 64-bit value, which depends on hm's seed and the sequence of bytes added to h since the last call to Hash.Reset or Hash.SetSeed.

type ReHash

Wraps a hash.Hash64 adding the information needed to be able to provide generic methods which hash any object of type K which has to be comparable. 

type ReHash[K comparable] struct {
    hash.Hash64
    // contains filtered or unexported fields
}

func NewReHash 

func NewReHash[K comparable](h hash.Hash64) (rh *ReHash[K])

Create a ReHash capable of hashing values of type K.

func NewReHashFromExample 

func NewReHashFromExample[K comparable](h hash.Hash64, val K) (rh *ReHash[K])

Create a ReHash from an example value capable of hashing values of the same type K. The value will only have its type inspected.

func (*ReHash[K]) SumObj64 

func (rh *ReHash[K]) SumObj64(key K) (s uint64)

SumObj64 hashes the key and returns the current 64-bit value, and updates its state. The semantics are similar to that of the underlying hash when hash/Sum64 is called.

type ReSubHash

Wraps a hash.Hash64 adding the information needed to be able to provide generic methods which hash any object of type K ignoring the parts which are not comparable 

type ReSubHash[K any] struct {
    hash.Hash64
    // contains filtered or unexported fields
}

func NewSubHash 

func NewSubHash[K any](h hash.Hash64) (rh *ReSubHash[K])

Create a ReHash capable of hashing values of type K. The non-comparable fields (even in the subfields of the fields) will be ignored.

func NewSubHashFromExample 

func NewSubHashFromExample[K any](h hash.Hash64, val K) (rh *ReSubHash[K])

Create a ReSubHash from an example value capable of hashing values of the same type K. The non-comparable fields (even in the subfields of the fields) will be ignored. The value will only have its type inspected.

func (*ReSubHash[K]) SumSubObj64 

func (rh *ReSubHash[K]) SumSubObj64(key K) (s uint64)

Calculate the hash of any type K. See hash.go for details on how this works. The only difference is that this method will ignore any non-comparable fields.

type SubHasher64

Hashes the comparable subset of any type. The non-comparable fields will be ignored, in the fields of the type and in the fields of the fields recursively. 

type SubHasher64[K any] interface {
    SumSubObj64(key K) (s uint64)
}