init commit

vendor/github.com/twinj/uuid/format.go

@@ -0,0 +1,161 @@
+package uuid
+
+import (
+	"strings"
+)
+
+// Format represents different styles a UUID can be printed in constants
+// represent a pattern used by the package with which to print a UUID.
+type Format string
+
+// The following are the default Formats supplied by the uuid package.
+const (
+	FormatHex        Format = "%x%x%x%x%x"
+	FormatHexCurly   Format = "{%x%x%x%x%x}"
+	FormatHexBracket Format = "(%x%x%x%x%x)"
+
+	// FormatCanonical is the default format.
+	FormatCanonical Format = "%x-%x-%x-%x-%x"
+
+	FormatCanonicalCurly   Format = "{%x-%x-%x-%x-%x}"
+	FormatCanonicalBracket Format = "(%x-%x-%x-%x-%x)"
+	FormatUrn              Format = "urn:uuid:" + FormatCanonical
+)
+
+var (
+	printFormat = FormatCanonical
+	defaultFormats map[Format]bool = make(map[Format]bool)
+)
+
+func init() {
+	defaultFormats[FormatHex] = true
+	defaultFormats[FormatHexCurly] = true
+	defaultFormats[FormatHexBracket] = true
+	defaultFormats[FormatCanonical] = true
+	defaultFormats[FormatCanonicalCurly] = true
+	defaultFormats[FormatCanonicalBracket] = true
+	defaultFormats[FormatUrn] = true
+}
+
+// SwitchFormat switches the default printing format for ALL UUIDs.
+//
+// The default is canonical uuid.Format.FormatCanonical which has been
+// optimised for use with this package. It is twice as fast compared to other
+// formats. However, non package formats are still very quick.
+//
+// A valid format will have 5 groups of [%x|%X] or follow the pattern,
+// *%[xX]*%[xX]*%[xX]*%[xX]*%[xX]*. If the supplied format does not meet this
+// standard the function will panic. Note any extra uses of [%] outside of the
+// [%x|%X] will also cause a panic.
+// Constant uuid.Formats have been provided for most likely formats.
+func SwitchFormat(form Format) {
+	checkFormat(form)
+	printFormat = form
+}
+
+// SwitchFormatToUpper is a convenience function to set the uuid.Format to uppercase
+// versions.
+func SwitchFormatToUpper(form Format) {
+	SwitchFormat(Format(strings.ToUpper(string(form))))
+}
+
+// Formatter will return a string representation of the given UUID.
+//
+// Use this for one time formatting when setting the Format using
+// uuid.SwitchFormat would be overkill.
+//
+// A valid format will have 5 groups of [%x|%X] or follow the pattern,
+// *%[xX]*%[xX]*%[xX]*%[xX]*%[xX]*. If the supplied format does not meet this
+// standard the function will panic. Note any extra uses of [%] outside of the
+// [%x|%X] will also cause a panic.
+func Formatter(id Implementation, form Format) string {
+	checkFormat(form)
+	return formatUuid(id.Bytes(), form)
+}
+
+func checkFormat(form Format) {
+	if defaultFormats[form] {
+		return
+	}
+	s := strings.ToLower(string(form))
+	if strings.Count(s, "%x") != 5 {
+		panic("uuid: invalid format")
+	}
+	s = strings.Replace(s, "%x", "", -1)
+	if strings.Count(s, "%") > 0 {
+		panic("uuid: invalid format")
+	}
+}
+
+const (
+	hexTable      = "0123456789abcdef"
+	hexUpperTable = "0123456789ABCDEF"
+
+	canonicalLength      = length*2 + 4
+	formatArgCount       = 10
+	uuidStringBufferSize = length*2 - formatArgCount
+)
+
+var groups = [...]int{4, 2, 2, 2, 6}
+
+func formatUuid(src []byte, form Format) string {
+	if form == FormatCanonical {
+		return string(formatCanonical(src))
+	}
+	return string(format(src, string(form)))
+}
+
+func format(src []byte, form string) []byte {
+	end := len(form)
+	buf := make([]byte, end+uuidStringBufferSize)
+
+	var s, ls, b, e, p int
+	var u bool
+	for _, v := range groups {
+		ls = s
+		for ; s < end && form[s] != '%'; s++ {
+		}
+		copy(buf[p:], form[ls:s])
+		p += s - ls
+		s++
+		u = form[s] == 'X'
+		s++
+		e = b + v
+		for i, t := range src[b:e] {
+			j := p + i + i
+			table := hexTable
+			if u {
+				table = hexUpperTable
+			}
+			buf[j] = table[t>>4]
+			buf[j+1] = table[t&0x0f]
+		}
+		b = e
+		p += v + v
+	}
+	ls = s
+	for ; s < end && form[s] != '%'; s++ {
+	}
+	copy(buf[p:], form[ls:s])
+	return buf
+}
+
+func formatCanonical(src []byte) []byte {
+	buf := make([]byte, canonicalLength)
+	var b, p, e int
+	for h, v := range groups {
+		e = b + v
+		for i, t := range src[b:e] {
+			j := p + i + i
+			buf[j] = hexTable[t>>4]
+			buf[j+1] = hexTable[t&0x0f]
+		}
+		b = e
+		p += v + v
+		if h < 4 {
+			buf[p] = '-'
+			p += 1
+		}
+	}
+	return buf
+}