Copyright 2014 The Prometheus Authors Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

package model

import (
	
)
SeparatorByte is a byte that cannot occur in valid UTF-8 sequences and is used to separate label names, label values, and other strings from each other when calculating their combined hash value (aka signature aka fingerprint).
const SeparatorByte byte = 255
cache the signature of an empty label set.
	emptyLabelSignature = hashNew()
)
LabelsToSignature returns a quasi-unique signature (i.e., fingerprint) for a given label set. (Collisions are possible but unlikely if the number of label sets the function is applied to is small.)
func ( map[string]string) uint64 {
	if len() == 0 {
		return emptyLabelSignature
	}

	 := make([]string, 0, len())
	for  := range  {
		 = append(, )
	}
	sort.Strings()

	 := hashNew()
	for ,  := range  {
		 = hashAdd(, )
		 = hashAddByte(, SeparatorByte)
		 = hashAdd(, [])
		 = hashAddByte(, SeparatorByte)
	}
	return 
}
labelSetToFingerprint works exactly as LabelsToSignature but takes a LabelSet as parameter (rather than a label map) and returns a Fingerprint.
func ( LabelSet) Fingerprint {
	if len() == 0 {
		return Fingerprint(emptyLabelSignature)
	}

	 := make(LabelNames, 0, len())
	for  := range  {
		 = append(, )
	}
	sort.Sort()

	 := hashNew()
	for ,  := range  {
		 = hashAdd(, string())
		 = hashAddByte(, SeparatorByte)
		 = hashAdd(, string([]))
		 = hashAddByte(, SeparatorByte)
	}
	return Fingerprint()
}
labelSetToFastFingerprint works similar to labelSetToFingerprint but uses a faster and less allocation-heavy hash function, which is more susceptible to create hash collisions. Therefore, collision detection should be applied.
func ( LabelSet) Fingerprint {
	if len() == 0 {
		return Fingerprint(emptyLabelSignature)
	}

	var  uint64
	for ,  := range  {
		 := hashNew()
		 = hashAdd(, string())
		 = hashAddByte(, SeparatorByte)
		 = hashAdd(, string())
		 ^= 
	}
	return Fingerprint()
}
SignatureForLabels works like LabelsToSignature but takes a Metric as parameter (rather than a label map) and only includes the labels with the specified LabelNames into the signature calculation. The labels passed in will be sorted by this function.
func ( Metric,  ...LabelName) uint64 {
	if len() == 0 {
		return emptyLabelSignature
	}

	sort.Sort(LabelNames())

	 := hashNew()
	for ,  := range  {
		 = hashAdd(, string())
		 = hashAddByte(, SeparatorByte)
		 = hashAdd(, string([]))
		 = hashAddByte(, SeparatorByte)
	}
	return 
}
SignatureWithoutLabels works like LabelsToSignature but takes a Metric as parameter (rather than a label map) and excludes the labels with any of the specified LabelNames from the signature calculation.
func ( Metric,  map[LabelName]struct{}) uint64 {
	if len() == 0 {
		return emptyLabelSignature
	}

	 := make(LabelNames, 0, len())
	for  := range  {
		if ,  := []; ! {
			 = append(, )
		}
	}
	if len() == 0 {
		return emptyLabelSignature
	}
	sort.Sort()

	 := hashNew()
	for ,  := range  {
		 = hashAdd(, string())
		 = hashAddByte(, SeparatorByte)
		 = hashAdd(, string([]))
		 = hashAddByte(, SeparatorByte)
	}
	return