Source File
sort.go
Belonging Package
golang.org/x/exp/collection/internal/fmtsort
// Copyright 2018 The Go Authors. All rights reserved.// Use of this source code is governed by a BSD-style// license that can be found in the LICENSE file.// Copied from the go repo at 1a1b710b4c.// Package fmtsort provides a general stable ordering mechanism// for maps, on behalf of the fmt and text/template packages.// It is not guaranteed to be efficient and works only for types// that are valid map keys.package fmtsortimport ()// Note: Throughout this package we avoid calling reflect.Value.Interface as// it is not always legal to do so and it's easier to avoid the issue than to face it.// SortedMap is a slice of KeyValue pairs that simplifies sorting// and iterating over map entries.//// Each KeyValue pair contains a map key and its corresponding value.type SortedMap []KeyValue// KeyValue holds a single key and value pair found in a map.type KeyValue struct {Key, Value reflect.Value}// Sort accepts a map and returns a SortedMap that has the same keys and// values but in a stable sorted order according to the keys, modulo issues// raised by unorderable key values such as NaNs.//// The ordering rules are more general than with Go's < operator://// - when applicable, nil compares low// - ints, floats, and strings order by <// - NaN compares less than non-NaN floats// - bool compares false before true// - complex compares real, then imag// - pointers compare by machine address// - channel values compare by machine address// - structs compare each field in turn// - arrays compare each element in turn.// Otherwise identical arrays compare by length.// - interface values compare first by reflect.Type describing the concrete type// and then by concrete value as described in the previous rules.func ( reflect.Value) SortedMap {if .Type().Kind() != reflect.Map {return nil}// Note: this code is arranged to not panic even in the presence// of a concurrent map update. The runtime is responsible for// yelling loudly if that happens. See issue 33275.:= .Len():= make(SortedMap, 0, ):= .MapRange()for .Next() {= append(, KeyValue{.Key(), .Value()})}slices.SortStableFunc(, func(, KeyValue) int {return Compare(.Key, .Key)})return}// Compare compares two values of the same type. It returns -1, 0, 1// according to whether a > b (1), a == b (0), or a < b (-1).// If the types differ, it returns -1.// See the comment on Sort for the comparison rules.func (, reflect.Value) int {, := .Type(), .Type()if != {return -1 // No good answer possible, but don't return 0: they're not equal.}switch .Kind() {case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:return cmp.Compare(.Int(), .Int())case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:return cmp.Compare(.Uint(), .Uint())case reflect.String:return cmp.Compare(.String(), .String())case reflect.Float32, reflect.Float64:return cmp.Compare(.Float(), .Float())case reflect.Complex64, reflect.Complex128:, := .Complex(), .Complex()if := cmp.Compare(real(), real()); != 0 {return}return cmp.Compare(imag(), imag())case reflect.Bool:, := .Bool(), .Bool()switch {case == :return 0case :return 1default:return -1}case reflect.Pointer, reflect.UnsafePointer:return cmp.Compare(.Pointer(), .Pointer())case reflect.Chan:if , := nilCompare(, ); {return}return cmp.Compare(.Pointer(), .Pointer())case reflect.Struct:for := 0; < .NumField(); ++ {if := (.Field(), .Field()); != 0 {return}}return 0case reflect.Array:for := 0; < .Len(); ++ {if := (.Index(), .Index()); != 0 {return}}return 0case reflect.Interface:if , := nilCompare(, ); {return}:= (reflect.ValueOf(.Elem().Type()), reflect.ValueOf(.Elem().Type()))if != 0 {return}return (.Elem(), .Elem())default:// Certain types cannot appear as keys (maps, funcs, slices), but be explicit.panic("bad type in compare: " + .String())}}// nilCompare checks whether either value is nil. If not, the boolean is false.// If either value is nil, the boolean is true and the integer is the comparison// value. The comparison is defined to be 0 if both are nil, otherwise the one// nil value compares low. Both arguments must represent a chan, func,// interface, map, pointer, or slice.func (, reflect.Value) (int, bool) {if .IsNil() {if .IsNil() {return 0, true}return -1, true}if .IsNil() {return 1, true}return 0, false}
The pages are generated with Golds v0.8.7. (GOOS=linux GOARCH=amd64)