Package hashstructure

func Hash ¶

func Hash(v interface{}, opts *HashOptions) (uint64, error)

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. The same *HashOptions value cannot be used concurrently. None of the values within a *HashOptions struct are safe to read/write while hashing is being done.

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" or "-" - 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.

* "string" - The field will be hashed as a string, only works when the
             field implements fmt.Stringer

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 := Hash(v, nil)
if err != nil {
    panic(err)
}

fmt.Printf("%d", hash)

6691276962590150517

type ErrNotStringer ¶

ErrNotStringer is returned when there's an error with hash:"string"

type ErrNotStringer struct {
    Field string
}

func (*ErrNotStringer) Error ¶

func (ens *ErrNotStringer) Error() string

Error implements error for ErrNotStringer

type HashOptions ¶

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

    // ZeroNil is flag determining if nil pointer should be treated equal
    // to a zero value of pointed type. By default this is false.
    ZeroNil bool
}

type Includable ¶

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)
}

type IncludableMap ¶

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)
}