Vendor mitchellh/hashstructure
This commit is contained in:
parent
bc6107508d
commit
3708522913
|
@ -599,6 +599,10 @@
|
||||||
"ImportPath": "github.com/mitchellh/go-linereader",
|
"ImportPath": "github.com/mitchellh/go-linereader",
|
||||||
"Rev": "07bab5fdd9580500aea6ada0e09df4aa28e68abd"
|
"Rev": "07bab5fdd9580500aea6ada0e09df4aa28e68abd"
|
||||||
},
|
},
|
||||||
|
{
|
||||||
|
"ImportPath": "github.com/mitchellh/hashstructure",
|
||||||
|
"Rev": "6b17d669fac5e2f71c16658d781ec3fdd3802b69"
|
||||||
|
},
|
||||||
{
|
{
|
||||||
"ImportPath": "github.com/mitchellh/mapstructure",
|
"ImportPath": "github.com/mitchellh/mapstructure",
|
||||||
"Rev": "281073eb9eb092240d33ef253c404f1cca550309"
|
"Rev": "281073eb9eb092240d33ef253c404f1cca550309"
|
||||||
|
|
|
@ -0,0 +1,21 @@
|
||||||
|
The MIT License (MIT)
|
||||||
|
|
||||||
|
Copyright (c) 2016 Mitchell Hashimoto
|
||||||
|
|
||||||
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||||
|
of this software and associated documentation files (the "Software"), to deal
|
||||||
|
in the Software without restriction, including without limitation the rights
|
||||||
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||||
|
copies of the Software, and to permit persons to whom the Software is
|
||||||
|
furnished to do so, subject to the following conditions:
|
||||||
|
|
||||||
|
The above copyright notice and this permission notice shall be included in
|
||||||
|
all copies or substantial portions of the Software.
|
||||||
|
|
||||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||||
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||||
|
THE SOFTWARE.
|
|
@ -0,0 +1,61 @@
|
||||||
|
# hashstructure
|
||||||
|
|
||||||
|
hashstructure is a Go library for creating a unique hash value
|
||||||
|
for arbitrary values in Go.
|
||||||
|
|
||||||
|
This can be used to key values in a hash (for use in a map, set, etc.)
|
||||||
|
that are complex. The most common use case is comparing two values without
|
||||||
|
sending data across the network, caching values locally (de-dup), and so on.
|
||||||
|
|
||||||
|
## Features
|
||||||
|
|
||||||
|
* Hash any arbitrary Go value, including complex types.
|
||||||
|
|
||||||
|
* Tag a struct field to ignore it and not affect the hash value.
|
||||||
|
|
||||||
|
* Tag a slice type struct field to treat it as a set where ordering
|
||||||
|
doesn't affect the hash code but the field itself is still taken into
|
||||||
|
account to create the hash value.
|
||||||
|
|
||||||
|
* Optionally specify a custom hash function to optimize for speed, collision
|
||||||
|
avoidance for your data set, etc.
|
||||||
|
|
||||||
|
## Installation
|
||||||
|
|
||||||
|
Standard `go get`:
|
||||||
|
|
||||||
|
```
|
||||||
|
$ go get github.com/mitchellh/hashstructure
|
||||||
|
```
|
||||||
|
|
||||||
|
## Usage & Example
|
||||||
|
|
||||||
|
For usage and examples see the [Godoc](http://godoc.org/github.com/mitchellh/hashstructure).
|
||||||
|
|
||||||
|
A quick code example is shown below:
|
||||||
|
|
||||||
|
|
||||||
|
type ComplexStruct struct {
|
||||||
|
Name string
|
||||||
|
Age uint
|
||||||
|
Metadata map[string]interface{}
|
||||||
|
}
|
||||||
|
|
||||||
|
v := ComplexStruct{
|
||||||
|
Name: "mitchellh",
|
||||||
|
Age: 64,
|
||||||
|
Metadata: map[string]interface{}{
|
||||||
|
"car": true,
|
||||||
|
"location": "California",
|
||||||
|
"siblings": []string{"Bob", "John"},
|
||||||
|
},
|
||||||
|
}
|
||||||
|
|
||||||
|
hash, err := hashstructure.Hash(v, nil)
|
||||||
|
if err != nil {
|
||||||
|
panic(err)
|
||||||
|
}
|
||||||
|
|
||||||
|
fmt.Printf("%d", hash)
|
||||||
|
// Output:
|
||||||
|
// 2307517237273902113
|
|
@ -0,0 +1,323 @@
|
||||||
|
package hashstructure
|
||||||
|
|
||||||
|
import (
|
||||||
|
"encoding/binary"
|
||||||
|
"fmt"
|
||||||
|
"hash"
|
||||||
|
"hash/fnv"
|
||||||
|
"reflect"
|
||||||
|
)
|
||||||
|
|
||||||
|
// HashOptions are options that are available for hashing.
|
||||||
|
type HashOptions struct {
|
||||||
|
// Hasher is the hash function to use. If this isn't set, it will
|
||||||
|
// default to FNV.
|
||||||
|
Hasher hash.Hash64
|
||||||
|
|
||||||
|
// TagName is the struct tag to look at when hashing the structure.
|
||||||
|
// By default this is "hash".
|
||||||
|
TagName string
|
||||||
|
}
|
||||||
|
|
||||||
|
// Hash returns the hash value of an arbitrary value.
|
||||||
|
//
|
||||||
|
// If opts is nil, then default options will be used. See HashOptions
|
||||||
|
// for the default values.
|
||||||
|
//
|
||||||
|
// Notes on the value:
|
||||||
|
//
|
||||||
|
// * Unexported fields on structs are ignored and do not affect the
|
||||||
|
// hash value.
|
||||||
|
//
|
||||||
|
// * Adding an exported field to a struct with the zero value will change
|
||||||
|
// the hash value.
|
||||||
|
//
|
||||||
|
// For structs, the hashing can be controlled using tags. For example:
|
||||||
|
//
|
||||||
|
// struct {
|
||||||
|
// Name string
|
||||||
|
// UUID string `hash:"ignore"`
|
||||||
|
// }
|
||||||
|
//
|
||||||
|
// The available tag values are:
|
||||||
|
//
|
||||||
|
// * "ignore" - The field will be ignored and not affect the hash code.
|
||||||
|
//
|
||||||
|
// * "set" - The field will be treated as a set, where ordering doesn't
|
||||||
|
// affect the hash code. This only works for slices.
|
||||||
|
//
|
||||||
|
func Hash(v interface{}, opts *HashOptions) (uint64, error) {
|
||||||
|
// Create default options
|
||||||
|
if opts == nil {
|
||||||
|
opts = &HashOptions{}
|
||||||
|
}
|
||||||
|
if opts.Hasher == nil {
|
||||||
|
opts.Hasher = fnv.New64()
|
||||||
|
}
|
||||||
|
if opts.TagName == "" {
|
||||||
|
opts.TagName = "hash"
|
||||||
|
}
|
||||||
|
|
||||||
|
// Reset the hash
|
||||||
|
opts.Hasher.Reset()
|
||||||
|
|
||||||
|
// Create our walker and walk the structure
|
||||||
|
w := &walker{
|
||||||
|
h: opts.Hasher,
|
||||||
|
tag: opts.TagName,
|
||||||
|
}
|
||||||
|
return w.visit(reflect.ValueOf(v), nil)
|
||||||
|
}
|
||||||
|
|
||||||
|
type walker struct {
|
||||||
|
h hash.Hash64
|
||||||
|
tag string
|
||||||
|
}
|
||||||
|
|
||||||
|
type visitOpts struct {
|
||||||
|
// Flags are a bitmask of flags to affect behavior of this visit
|
||||||
|
Flags visitFlag
|
||||||
|
|
||||||
|
// Information about the struct containing this field
|
||||||
|
Struct interface{}
|
||||||
|
StructField string
|
||||||
|
}
|
||||||
|
|
||||||
|
func (w *walker) visit(v reflect.Value, opts *visitOpts) (uint64, error) {
|
||||||
|
// Loop since these can be wrapped in multiple layers of pointers
|
||||||
|
// and interfaces.
|
||||||
|
for {
|
||||||
|
// If we have an interface, dereference it. We have to do this up
|
||||||
|
// here because it might be a nil in there and the check below must
|
||||||
|
// catch that.
|
||||||
|
if v.Kind() == reflect.Interface {
|
||||||
|
v = v.Elem()
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
if v.Kind() == reflect.Ptr {
|
||||||
|
v = reflect.Indirect(v)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
break
|
||||||
|
}
|
||||||
|
|
||||||
|
// If it is nil, treat it like a zero.
|
||||||
|
if !v.IsValid() {
|
||||||
|
var tmp int8
|
||||||
|
v = reflect.ValueOf(tmp)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Binary writing can use raw ints, we have to convert to
|
||||||
|
// a sized-int, we'll choose the largest...
|
||||||
|
switch v.Kind() {
|
||||||
|
case reflect.Int:
|
||||||
|
v = reflect.ValueOf(int64(v.Int()))
|
||||||
|
case reflect.Uint:
|
||||||
|
v = reflect.ValueOf(uint64(v.Uint()))
|
||||||
|
case reflect.Bool:
|
||||||
|
var tmp int8
|
||||||
|
if v.Bool() {
|
||||||
|
tmp = 1
|
||||||
|
}
|
||||||
|
v = reflect.ValueOf(tmp)
|
||||||
|
}
|
||||||
|
|
||||||
|
k := v.Kind()
|
||||||
|
|
||||||
|
// We can shortcut numeric values by directly binary writing them
|
||||||
|
if k >= reflect.Int && k <= reflect.Complex64 {
|
||||||
|
// A direct hash calculation
|
||||||
|
w.h.Reset()
|
||||||
|
err := binary.Write(w.h, binary.LittleEndian, v.Interface())
|
||||||
|
return w.h.Sum64(), err
|
||||||
|
}
|
||||||
|
|
||||||
|
switch k {
|
||||||
|
case reflect.Array:
|
||||||
|
var h uint64
|
||||||
|
l := v.Len()
|
||||||
|
for i := 0; i < l; i++ {
|
||||||
|
current, err := w.visit(v.Index(i), nil)
|
||||||
|
if err != nil {
|
||||||
|
return 0, err
|
||||||
|
}
|
||||||
|
|
||||||
|
h = hashUpdateOrdered(w.h, h, current)
|
||||||
|
}
|
||||||
|
|
||||||
|
return h, nil
|
||||||
|
|
||||||
|
case reflect.Map:
|
||||||
|
var includeMap IncludableMap
|
||||||
|
if opts != nil && opts.Struct != nil {
|
||||||
|
if v, ok := opts.Struct.(IncludableMap); ok {
|
||||||
|
includeMap = v
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Build the hash for the map. We do this by XOR-ing all the key
|
||||||
|
// and value hashes. This makes it deterministic despite ordering.
|
||||||
|
var h uint64
|
||||||
|
for _, k := range v.MapKeys() {
|
||||||
|
v := v.MapIndex(k)
|
||||||
|
if includeMap != nil {
|
||||||
|
incl, err := includeMap.HashIncludeMap(
|
||||||
|
opts.StructField, k.Interface(), v.Interface())
|
||||||
|
if err != nil {
|
||||||
|
return 0, err
|
||||||
|
}
|
||||||
|
if !incl {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
kh, err := w.visit(k, nil)
|
||||||
|
if err != nil {
|
||||||
|
return 0, err
|
||||||
|
}
|
||||||
|
vh, err := w.visit(v, nil)
|
||||||
|
if err != nil {
|
||||||
|
return 0, err
|
||||||
|
}
|
||||||
|
|
||||||
|
fieldHash := hashUpdateOrdered(w.h, kh, vh)
|
||||||
|
h = hashUpdateUnordered(h, fieldHash)
|
||||||
|
}
|
||||||
|
|
||||||
|
return h, nil
|
||||||
|
|
||||||
|
case reflect.Struct:
|
||||||
|
var include Includable
|
||||||
|
parent := v.Interface()
|
||||||
|
if impl, ok := parent.(Includable); ok {
|
||||||
|
include = impl
|
||||||
|
}
|
||||||
|
|
||||||
|
t := v.Type()
|
||||||
|
h, err := w.visit(reflect.ValueOf(t.Name()), nil)
|
||||||
|
if err != nil {
|
||||||
|
return 0, err
|
||||||
|
}
|
||||||
|
|
||||||
|
l := v.NumField()
|
||||||
|
for i := 0; i < l; i++ {
|
||||||
|
if v := v.Field(i); v.CanSet() || t.Field(i).Name != "_" {
|
||||||
|
var f visitFlag
|
||||||
|
fieldType := t.Field(i)
|
||||||
|
if fieldType.PkgPath != "" {
|
||||||
|
// Unexported
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
tag := fieldType.Tag.Get(w.tag)
|
||||||
|
if tag == "ignore" {
|
||||||
|
// Ignore this field
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
// Check if we implement includable and check it
|
||||||
|
if include != nil {
|
||||||
|
incl, err := include.HashInclude(fieldType.Name, v)
|
||||||
|
if err != nil {
|
||||||
|
return 0, err
|
||||||
|
}
|
||||||
|
if !incl {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
switch tag {
|
||||||
|
case "set":
|
||||||
|
f |= visitFlagSet
|
||||||
|
}
|
||||||
|
|
||||||
|
kh, err := w.visit(reflect.ValueOf(fieldType.Name), nil)
|
||||||
|
if err != nil {
|
||||||
|
return 0, err
|
||||||
|
}
|
||||||
|
|
||||||
|
vh, err := w.visit(v, &visitOpts{
|
||||||
|
Flags: f,
|
||||||
|
Struct: parent,
|
||||||
|
StructField: fieldType.Name,
|
||||||
|
})
|
||||||
|
if err != nil {
|
||||||
|
return 0, err
|
||||||
|
}
|
||||||
|
|
||||||
|
fieldHash := hashUpdateOrdered(w.h, kh, vh)
|
||||||
|
h = hashUpdateUnordered(h, fieldHash)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return h, nil
|
||||||
|
|
||||||
|
case reflect.Slice:
|
||||||
|
// We have two behaviors here. If it isn't a set, then we just
|
||||||
|
// visit all the elements. If it is a set, then we do a deterministic
|
||||||
|
// hash code.
|
||||||
|
var h uint64
|
||||||
|
var set bool
|
||||||
|
if opts != nil {
|
||||||
|
set = (opts.Flags & visitFlagSet) != 0
|
||||||
|
}
|
||||||
|
l := v.Len()
|
||||||
|
for i := 0; i < l; i++ {
|
||||||
|
current, err := w.visit(v.Index(i), nil)
|
||||||
|
if err != nil {
|
||||||
|
return 0, err
|
||||||
|
}
|
||||||
|
|
||||||
|
if set {
|
||||||
|
h = hashUpdateUnordered(h, current)
|
||||||
|
} else {
|
||||||
|
h = hashUpdateOrdered(w.h, h, current)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return h, nil
|
||||||
|
|
||||||
|
case reflect.String:
|
||||||
|
// Directly hash
|
||||||
|
w.h.Reset()
|
||||||
|
_, err := w.h.Write([]byte(v.String()))
|
||||||
|
return w.h.Sum64(), err
|
||||||
|
|
||||||
|
default:
|
||||||
|
return 0, fmt.Errorf("unknown kind to hash: %s", k)
|
||||||
|
}
|
||||||
|
|
||||||
|
return 0, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func hashUpdateOrdered(h hash.Hash64, a, b uint64) uint64 {
|
||||||
|
// For ordered updates, use a real hash function
|
||||||
|
h.Reset()
|
||||||
|
|
||||||
|
// We just panic if the binary writes fail because we are writing
|
||||||
|
// an int64 which should never be fail-able.
|
||||||
|
e1 := binary.Write(h, binary.LittleEndian, a)
|
||||||
|
e2 := binary.Write(h, binary.LittleEndian, b)
|
||||||
|
if e1 != nil {
|
||||||
|
panic(e1)
|
||||||
|
}
|
||||||
|
if e2 != nil {
|
||||||
|
panic(e2)
|
||||||
|
}
|
||||||
|
|
||||||
|
return h.Sum64()
|
||||||
|
}
|
||||||
|
|
||||||
|
func hashUpdateUnordered(a, b uint64) uint64 {
|
||||||
|
return a ^ b
|
||||||
|
}
|
||||||
|
|
||||||
|
// visitFlag is used as a bitmask for affecting visit behavior
|
||||||
|
type visitFlag uint
|
||||||
|
|
||||||
|
const (
|
||||||
|
visitFlagInvalid visitFlag = iota
|
||||||
|
visitFlagSet = iota << 1
|
||||||
|
)
|
|
@ -0,0 +1,15 @@
|
||||||
|
package hashstructure
|
||||||
|
|
||||||
|
// Includable is an interface that can optionally be implemented by
|
||||||
|
// a struct. It will be called for each field in the struct to check whether
|
||||||
|
// it should be included in the hash.
|
||||||
|
type Includable interface {
|
||||||
|
HashInclude(field string, v interface{}) (bool, error)
|
||||||
|
}
|
||||||
|
|
||||||
|
// IncludableMap is an interface that can optionally be implemented by
|
||||||
|
// a struct. It will be called when a map-type field is found to ask the
|
||||||
|
// struct if the map item should be included in the hash.
|
||||||
|
type IncludableMap interface {
|
||||||
|
HashIncludeMap(field string, k, v interface{}) (bool, error)
|
||||||
|
}
|
Loading…
Reference in New Issue