Deterministic sorting for all map key types.

render/render.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package render
 
 import (
         "bytes"
         "fmt"
         "reflect"
@@ skipping 312 matching lines @@
 
         default:
                 buf.WriteString(t.String())
         }
 
         if parens {
                 buf.WriteRune(')')
         }
 }
 
+type cmpFn func(a, b reflect.Value) int
+
 type sortableValueSlice struct {
-        kind     reflect.Kind
+        cmp      cmpFn
         elements []reflect.Value
 }
 
-func (s *sortableValueSlice) Len() int {
+func (s sortableValueSlice) Len() int {
         return len(s.elements)
 }
 
-func (s *sortableValueSlice) Less(i, j int) bool {
-        switch s.kind {
-        case reflect.String:
-                return s.elements[i].String() < s.elements[j].String()
-
-        case reflect.Int:
-                return s.elements[i].Int() < s.elements[j].Int()
-
-        default:
-                panic(fmt.Errorf("unsupported sort kind: %s", s.kind))
-        }
+func (s sortableValueSlice) Less(i, j int) bool {
+        return s.cmp(s.elements[i], s.elements[j]) < 0
 }
 
-func (s *sortableValueSlice) Swap(i, j int) {
+func (s sortableValueSlice) Swap(i, j int) {
         s.elements[i], s.elements[j] = s.elements[j], s.elements[i]
 }
 
+// cmpForType returns a cmpFn which sorts the data for some type t in the same
+// order that a go-native map key is compared for equality.
+func cmpForType(t reflect.Type) cmpFn {
+        switch t.Kind() {
+        case reflect.String:
+                return func(av, bv reflect.Value) int {
+                        a, b := av.String(), bv.String()
+                        if a < b {
+                                return -1
+                        } else if a > b {
+                                return 1
+                        }
+                        return 0
+                }
+
+        case reflect.Bool:
+                return func(av, bv reflect.Value) int {
+                        a, b := av.Bool(), bv.Bool()
+                        if !a && b {
+                                return -1
+                        } else if a && !b {
+                                return 1
+                        }
+                        return 0
+                }
+
+        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                return func(av, bv reflect.Value) int {
+                        a, b := av.Int(), bv.Int()
+                        if a < b {
+                                return -1
+                        } else if a > b {
+                                return 1
+                        }
+                        return 0
+                }
+
+        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32,
+                reflect.Uint64, reflect.Uintptr, reflect.UnsafePointer:
+                return func(av, bv reflect.Value) int {
+                        a, b := av.Uint(), bv.Uint()
+                        if a < b {
+                                return -1
+                        } else if a > b {
+                                return 1
+                        }
+                        return 0
+                }
+
+        case reflect.Float32, reflect.Float64:
+                return func(av, bv reflect.Value) int {
+                        a, b := av.Float(), bv.Float()
+                        if a < b {
+                                return -1
+                        } else if a > b {
+                                return 1
+                        }
+                        return 0
+                }
+
+        case reflect.Interface:
+                return func(av, bv reflect.Value) int {
+                        a, b := av.InterfaceData(), bv.InterfaceData()
+                        if a[0] < b[0] {
+                                return -1
+                        } else if a[0] > b[0] {
+                                return 1
+                        }
+                        if a[1] < b[1] {
+                                return -1
+                        } else if a[1] > b[1] {
+                                return 1
+                        }
+                        return 0
+                }
+
+        case reflect.Complex64, reflect.Complex128:
+                return func(av, bv reflect.Value) int {
+                        a, b := av.Complex(), bv.Complex()
+                        if real(a) < real(b) {
+                                return -1
+                        } else if real(a) > real(b) {
+                                return 1
+                        }
+                        if imag(a) < imag(b) {
+                                return -1
+                        } else if imag(a) > imag(b) {
+                                return 1
+                        }
+                        return 0
+                }
+
+        case reflect.Ptr, reflect.Chan:
+                return func(av, bv reflect.Value) int {
+                        a, b := av.Pointer(), bv.Pointer()
+                        if a < b {
+                                return -1
+                        } else if a > b {
+                                return 1
+                        }
+                        return 0
+                }
+
+        case reflect.Struct:
+                cmpLst := make([]cmpFn, t.NumField())
+                for i := range cmpLst {
+                        cmpLst[i] = cmpForType(t.Field(i).Type)
+                }
+                return func(a, b reflect.Value) int {
+                        for i, cmp := range cmpLst {
+                                if rslt := cmp(a.Field(i), b.Field(i)); rslt != 0 {
+                                        return rslt
+                                }
+                        }
+                        return 0
+                }
+        }
+
+        return nil
+}
+
 func tryAndSortMapKeys(mt reflect.Type, k []reflect.Value) {
-        // Try our stock sortable values.
-        switch mt.Key().Kind() {
-        case reflect.String, reflect.Int:
-                vs := &sortableValueSlice{
-                        kind:     mt.Key().Kind(),
-                        elements: k,
-                }
-                sort.Sort(vs)
+        if cmp := cmpForType(mt.Key()); cmp != nil {
+                sort.Sort(sortableValueSlice{cmp, k})
         }
 }