code review 4035044: Update to current version of Go library.

libgo/go/expvar/expvar.go

 // Copyright 2009 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.
 
 // The expvar package provides a standardized interface to public variables,
 // such as operation counters in servers. It exposes these variables via
 // HTTP at /debug/vars in JSON format.
 //
 // Operations to set or modify these public variables are atomic.
 //
@@ skipping 20 matching lines @@
         "runtime"
         "strconv"
         "sync"
 )
 
 // Var is an abstract type for all exported variables.
 type Var interface {
         String() string
 }
 
-// Int is a 64-bit integer variable, and satisfies the Var interface.
+// Int is a 64-bit integer variable that satisfies the Var interface.
 type Int struct {
         i  int64
         mu sync.Mutex
 }
 
 func (v *Int) String() string { return strconv.Itoa64(v.i) }
 
 func (v *Int) Add(delta int64) {
         v.mu.Lock()
         defer v.mu.Unlock()
         v.i += delta
 }
 
 func (v *Int) Set(value int64) {
         v.mu.Lock()
         defer v.mu.Unlock()
         v.i = value
 }
 
-// Map is a string-to-Var map variable, and satisfies the Var interface.
+// Float is a 64-bit float variable that satisfies the Var interface.
+type Float struct {
+        f  float64
+        mu sync.Mutex
+}
+
+func (v *Float) String() string { return strconv.Ftoa64(v.f, 'g', -1) }
+
+// Add adds delta to v.
+func (v *Float) Add(delta float64) {
+        v.mu.Lock()
+        defer v.mu.Unlock()
+        v.f += delta
+}
+
+// Set sets v to value.
+func (v *Float) Set(value float64) {
+        v.mu.Lock()
+        defer v.mu.Unlock()
+        v.f = value
+}
+
+// Map is a string-to-Var map variable that satisfies the Var interface.
 type Map struct {
         m  map[string]Var
         mu sync.Mutex
 }
 
 // KeyValue represents a single entry in a Map.
 type KeyValue struct {
         Key   string
         Value Var
 }
@@ skipping 40 matching lines @@
                 av = new(Int)
                 v.m[key] = av
         }
 
         // Add to Int; ignore otherwise.
         if iv, ok := av.(*Int); ok {
                 iv.Add(delta)
         }
 }
 
+// AddFloat adds delta to the *Float value stored under the given map key.
+func (v *Map) AddFloat(key string, delta float64) {
+        v.mu.Lock()
+        defer v.mu.Unlock()
+        av, ok := v.m[key]
+        if !ok {
+                av = new(Float)
+                v.m[key] = av
+        }
+
+        // Add to Float; ignore otherwise.
+        if iv, ok := av.(*Float); ok {
+                iv.Add(delta)
+        }
+}
+
 // TODO(rsc): Make sure map access in separate thread is safe.
 func (v *Map) iterate(c chan<- KeyValue) {
         for k, v := range v.m {
                 c <- KeyValue{k, v}
         }
         close(c)
 }
 
 func (v *Map) Iter() <-chan KeyValue {
         c := make(chan KeyValue)
         go v.iterate(c)
         return c
 }
 
 // String is a string variable, and satisfies the Var interface.
 type String struct {
         s string
 }
 
 func (v *String) String() string { return strconv.Quote(v.s) }
 
 func (v *String) Set(value string) { v.s = value }
 
 // IntFunc wraps a func() int64 to create a value that satisfies the Var interface.
 // The function will be called each time the Var is evaluated.
 type IntFunc func() int64
 
 func (v IntFunc) String() string { return strconv.Itoa64(v()) }
 
+// FloatFunc wraps a func() float64 to create a value that satisfies the Var interface.
+// The function will be called each time the Var is evaluated.
+type FloatFunc func() float64
+
+func (v FloatFunc) String() string { return strconv.Ftoa64(v(), 'g', -1) }
+
 // StringFunc wraps a func() string to create value that satisfies the Var interface.
 // The function will be called each time the Var is evaluated.
 type StringFunc func() string
 
-func (f StringFunc) String() string { return f() }
+func (f StringFunc) String() string { return strconv.Quote(f()) }
 
 
 // All published variables.
 var vars map[string]Var = make(map[string]Var)
 var mutex sync.Mutex
 
 // Publish declares an named exported variable. This should be called from a
 // package's init function when it creates its Vars. If the name is already
 // registered then this will log.Panic.
 func Publish(name string, v Var) {
@@ skipping 19 matching lines @@
 }
 
 // Convenience functions for creating new exported variables.
 
 func NewInt(name string) *Int {
         v := new(Int)
         Publish(name, v)
         return v
 }
 
+func NewFloat(name string) *Float {
+        v := new(Float)
+        Publish(name, v)
+        return v
+}
+
 func NewMap(name string) *Map {
         v := new(Map).Init()
         Publish(name, v)
         return v
 }
 
 func NewString(name string) *String {
         v := new(String)
         Publish(name, v)
         return v
@@ skipping 35 matching lines @@
 func cmdline() string {
         b, _ := json.Marshal(os.Args)
         return string(b)
 }
 
 func init() {
         http.Handle("/debug/vars", http.HandlerFunc(expvarHandler))
         Publish("cmdline", StringFunc(cmdline))
         Publish("memstats", StringFunc(memstats))
 }