// ZeroValue works like types.Type.SafeZeroValue, but unlike the types.Type
// version, this method can also return zero values for types in this
// package.
func ZeroValue(t types.Type) (interface{}, error) {
if t == types.Dist {
return (*Distribution)(nil), nil
} else {
return t.SafeZeroValue()
}
}
func valueToTextString(
value reflect.Value,
t types.Type,
u units.Unit,
isValueAPointer bool) string {
switch {
case t == types.Bool:
if value.Bool() {
return "true"
}
return "false"
case t.IsInt() && !isValueAPointer:
return strconv.FormatInt(value.Int(), 10)
case t.IsUint() && !isValueAPointer:
return strconv.FormatUint(value.Uint(), 10)
case t == types.Float32 && !isValueAPointer:
return strconv.FormatFloat(value.Float(), 'f', -1, 32)
case t == types.Float64 && !isValueAPointer:
return strconv.FormatFloat(value.Float(), 'f', -1, 64)
case t == types.String && !isValueAPointer:
return "\"" + value.String() + "\""
case t == types.GoTime:
return timeToDuration(
valueToTime(
value, isValueAPointer)).StringUsingUnits(u)
case t == types.GoDuration && !isValueAPointer:
return duration.New(
valueToGoDuration(value)).StringUsingUnits(u)
default:
panic(panicIncompatibleTypes)
}
}
// Register returns the correct MetricInfo instance from the pool for
// passed in metric and type. Register will always return a non nil value.
func (m *metricInfoStoreType) Register(
metric *metrics.Value, kind, subType types.Type) (
result *MetricInfo) {
if kind == types.Unknown {
panic("Got Unknown type")
}
if kind.UsesSubType() && subType == types.Unknown {
panic("Got unknown sub-type when it is required")
}
var ranges *Ranges
var isNotCumulative bool
if kind == types.Dist {
// TODO: Maybe later this shouldn't be tricorder specific,
// but for now tricorder is the only thing we know that
// has distributions.
distribution := metric.Value.(*messages.Distribution)
isNotCumulative = distribution.IsNotCumulative
upperLimitSlice := distExtractUpperLimits(distribution)
ranges = m.rangesCache.Get(metric.Path, upperLimitSlice)
}
infoStruct := MetricInfo{
path: metric.Path,
description: metric.Description,
unit: metric.Unit,
kind: kind,
subType: subType,
ranges: ranges,
isNotCumulative: isNotCumulative,
groupId: metric.GroupId}
result, alreadyExists := m.ByInfo[infoStruct]
if alreadyExists {
return
}
result = &infoStruct
m.ByInfo[infoStruct] = result
m.ByName[infoStruct.path] = append(m.ByName[infoStruct.path], result)
return
}
func valueToHtmlString(
value reflect.Value,
t types.Type,
u units.Unit,
isValueAPointer bool) string {
switch {
case t.IsInt() && !isValueAPointer:
switch u {
case units.Byte:
return iCompactForm(
value.Int(), 1024, byteSuffixes)
case units.BytePerSecond:
return iCompactForm(
value.Int(), 1024, bytePerSecondSuffixes)
default:
return iCompactForm(
value.Int(), 1000, suffixes)
}
case t.IsUint() && !isValueAPointer:
switch u {
case units.Byte:
return uCompactForm(
value.Uint(), 1024, byteSuffixes)
case units.BytePerSecond:
return uCompactForm(
value.Uint(), 1024, bytePerSecondSuffixes)
default:
return uCompactForm(
value.Uint(), 1000, suffixes)
}
case t == types.GoDuration && !isValueAPointer:
d := duration.New(valueToGoDuration(value))
if d.IsNegative() {
return valueToTextString(
value, t, u, isValueAPointer)
}
return d.PrettyFormat()
case t == types.GoTime:
t := valueToTime(value, isValueAPointer).UTC()
return t.Format("2006-01-02T15:04:05.999999999Z")
default:
return valueToTextString(value, t, u, isValueAPointer)
}
}
