Humaner.Format(): change method to take a Humanable as argument

Add a new `FormatNumber()` method with the old behavior.

Remove `Human()` from the `Humanable` interface.

Author: mhagger

counts/human.go

@@ -2,14 +2,10 @@ package counts
 
 import (
 	"fmt"
-	"math"
 )
 
 // A quantity that can be made human-readable using Human().
 type Humanable interface {
-	// Return the value and units as separate strings.
-	Human(Humaner, string) (string, string)
-
 	// Return the value as a uint64, and a boolean telling whether it
 	// overflowed.
 	ToUint64() (uint64, bool)
@@ -50,10 +46,11 @@ var Binary = Humaner{
 	},
 }
 
-// Format values, aligned, in `len(unit) + 10` or fewer characters
-// (except for extremely large numbers).
-func (h *Humaner) Format(n uint64, unit string) (string, string) {
+// Format n, aligned, in `len(unit) + 10` or fewer characters (except
+// for extremely large numbers).
+func (h *Humaner) FormatNumber(n uint64, unit string) (string, string) {
 	prefix := h.prefixes[0]
+
 	wholePart := n
 	for _, p := range h.prefixes {
 		w := n / p.Multiplier
@@ -81,18 +78,13 @@ func (h *Humaner) Format(n uint64, unit string) (string, string) {
 	}
 }
 
-func (n Count32) Human(humaner Humaner, unit string) (string, string) {
-	if n == math.MaxUint32 {
+// Format values, aligned, in `len(unit) + 10` or fewer characters
+// (except for extremely large numbers).
+func (h *Humaner) Format(value Humanable, unit string) (string, string) {
+	n, overflow := value.ToUint64()
+	if overflow {
 		return "∞", unit
-	} else {
-		return humaner.Format(uint64(n), unit)
 	}
-}
 
-func (n Count64) Human(humaner Humaner, unit string) (string, string) {
-	if n == math.MaxUint64 {
-		return "∞", unit
-	} else {
-		return humaner.Format(uint64(n), unit)
-	}
+	return h.FormatNumber(n, unit)
 }

counts/human_test.go

@@ -52,18 +52,18 @@ func TestMetric(t *testing.T) {
 		{12345678900000000000, "12346", "Pcd"}, // Not ideal, but ok
 		{0xffffffffffffffff, "18447", "Pcd"},   // Not ideal, but ok
 	} {
-		number, unit := counts.Metric.Format(ht.n, "cd")
+		number, unit := counts.Metric.FormatNumber(ht.n, "cd")
 		assert.Equalf(ht.number, number, "Number for %d in metric", ht.n)
 		assert.Equalf(ht.unit, unit, "Unit for %d in metric", ht.n)
 		if ht.n < 0xffffffff {
 			c := counts.NewCount32(ht.n)
-			number, unit := c.Human(counts.Metric, "cd")
+			number, unit := counts.Metric.Format(c, "cd")
 			assert.Equalf(ht.number, number, "Number for Count32(%d) in metric", ht.n)
 			assert.Equalf(ht.unit, unit, "Unit for Count32(%d) in metric", ht.n)
 		}
 		if ht.n < 0xffffffffffffffff {
 			c := counts.NewCount64(ht.n)
-			number, unit := c.Human(counts.Metric, "cd")
+			number, unit := counts.Metric.Format(c, "cd")
 			assert.Equalf(ht.number, number, "Number for Count64(%d) in metric", ht.n)
 			assert.Equalf(ht.unit, unit, "Unit for Count64(%d) in metric", ht.n)
 		}
@@ -91,18 +91,18 @@ func TestBinary(t *testing.T) {
 		{1152921504606846976, "1024", "PiB"},
 		{0xffffffffffffffff, "16384", "PiB"},
 	} {
-		number, unit := counts.Binary.Format(ht.n, "B")
+		number, unit := counts.Binary.FormatNumber(ht.n, "B")
 		assert.Equalf(ht.number, number, "Number for %d in binary", ht.n)
 		assert.Equalf(ht.unit, unit, "Unit for %d in binary", ht.n)
 		if ht.n < 0xffffffff {
 			c := counts.NewCount32(ht.n)
-			number, unit := c.Human(counts.Binary, "B")
+			number, unit := counts.Binary.Format(c, "B")
 			assert.Equalf(ht.number, number, "Number for Count32(%d) in binary", ht.n)
 			assert.Equalf(ht.unit, unit, "Unit for Count32(%d) in binary", ht.n)
 		}
 		if ht.n < 0xffffffffffffffff {
 			c := counts.NewCount64(ht.n)
-			number, unit := c.Human(counts.Binary, "B")
+			number, unit := counts.Binary.Format(c, "B")
 			assert.Equalf(ht.number, number, "Number for Count64(%d) in binary", ht.n)
 			assert.Equalf(ht.unit, unit, "Unit for Count64(%d) in binary", ht.n)
 		}
@@ -113,7 +113,7 @@ func TestLimits32(t *testing.T) {
 	assert := assert.New(t)
 
 	c := counts.NewCount32(0xffffffff)
-	number, unit := c.Human(counts.Metric, "cd")
+	number, unit := counts.Metric.Format(c, "cd")
 	assert.Equalf("∞", number, "Number for Count32(0xffffffff) in metric")
 	assert.Equalf("cd", unit, "Unit for Count32(0xffffffff) in metric")
 }
@@ -122,7 +122,7 @@ func TestLimits64(t *testing.T) {
 	assert := assert.New(t)
 
 	c := counts.NewCount64(0xffffffffffffffff)
-	number, unit := c.Human(counts.Metric, "B")
+	number, unit := counts.Metric.Format(c, "B")
 	assert.Equalf("∞", number, "Number for Count64(0xffffffffffffffff) in metric")
 	assert.Equalf("B", unit, "Unit for Count64(0xffffffffffffffff) in metric")
 }

sizes/output.go

@@ -131,7 +131,7 @@ func (l *item) Emit(t *table) {
 	if !interesting {
 		return
 	}
-	valueString, unitString := l.value.Human(l.humaner, l.unit)
+	valueString, unitString := l.humaner.Format(l.value, l.unit)
 	t.formatRow(
 		l.name, t.footnotes.CreateCitation(l.Footnote(t.nameStyle)),
 		valueString, unitString,