cmd/bpa-operator/vendor/github.com/prometheus/common/model/fingerprinting.go

   1 // Copyright 2013 The Prometheus Authors
   2 // Licensed under the Apache License, Version 2.0 (the "License");
   3 // you may not use this file except in compliance with the License.
   4 // You may obtain a copy of the License at
   5 //
   6 // http://www.apache.org/licenses/LICENSE-2.0
   7 //
   8 // Unless required by applicable law or agreed to in writing, software
   9 // distributed under the License is distributed on an "AS IS" BASIS,
  10 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  11 // See the License for the specific language governing permissions and
  12 // limitations under the License.
  13
  14 package model
  15
  16 import (
  17         "fmt"
  18         "strconv"
  19 )
  20
  21 // Fingerprint provides a hash-capable representation of a Metric.
  22 // For our purposes, FNV-1A 64-bit is used.
  23 type Fingerprint uint64
  24
  25 // FingerprintFromString transforms a string representation into a Fingerprint.
  26 func FingerprintFromString(s string) (Fingerprint, error) {
  27         num, err := strconv.ParseUint(s, 16, 64)
  28         return Fingerprint(num), err
  29 }
  30
  31 // ParseFingerprint parses the input string into a fingerprint.
  32 func ParseFingerprint(s string) (Fingerprint, error) {
  33         num, err := strconv.ParseUint(s, 16, 64)
  34         if err != nil {
  35                 return 0, err
  36         }
  37         return Fingerprint(num), nil
  38 }
  39
  40 func (f Fingerprint) String() string {
  41         return fmt.Sprintf("%016x", uint64(f))
  42 }
  43
  44 // Fingerprints represents a collection of Fingerprint subject to a given
  45 // natural sorting scheme. It implements sort.Interface.
  46 type Fingerprints []Fingerprint
  47
  48 // Len implements sort.Interface.
  49 func (f Fingerprints) Len() int {
  50         return len(f)
  51 }
  52
  53 // Less implements sort.Interface.
  54 func (f Fingerprints) Less(i, j int) bool {
  55         return f[i] < f[j]
  56 }
  57
  58 // Swap implements sort.Interface.
  59 func (f Fingerprints) Swap(i, j int) {
  60         f[i], f[j] = f[j], f[i]
  61 }
  62
  63 // FingerprintSet is a set of Fingerprints.
  64 type FingerprintSet map[Fingerprint]struct{}
  65
  66 // Equal returns true if both sets contain the same elements (and not more).
  67 func (s FingerprintSet) Equal(o FingerprintSet) bool {
  68         if len(s) != len(o) {
  69                 return false
  70         }
  71
  72         for k := range s {
  73                 if _, ok := o[k]; !ok {
  74                         return false
  75                 }
  76         }
  77
  78         return true
  79 }
  80
  81 // Intersection returns the elements contained in both sets.
  82 func (s FingerprintSet) Intersection(o FingerprintSet) FingerprintSet {
  83         myLength, otherLength := len(s), len(o)
  84         if myLength == 0 || otherLength == 0 {
  85                 return FingerprintSet{}
  86         }
  87
  88         subSet := s
  89         superSet := o
  90
  91         if otherLength < myLength {
  92                 subSet = o
  93                 superSet = s
  94         }
  95
  96         out := FingerprintSet{}
  97
  98         for k := range subSet {
  99                 if _, ok := superSet[k]; ok {
 100                         out[k] = struct{}{}
 101                 }
 102         }
 103
 104         return out
 105 }