From c5c66ba45dea9494d2416a57a087a88856c86d85 Mon Sep 17 00:00:00 2001 From: Faye Amacker <33205765+fxamacker@users.noreply.github.com> Date: Mon, 27 May 2024 20:08:55 -0500 Subject: [PATCH] Refactor to remove more magic numbers --- common.go | 20 +++++++++++++++----- decode.go | 48 +++++++++++++++++++++++++++++++++--------------- diagnose.go | 26 +++++++++++++++----------- 3 files changed, 63 insertions(+), 31 deletions(-) diff --git a/common.go b/common.go index f004a74b..4e11f0f5 100644 --- a/common.go +++ b/common.go @@ -47,11 +47,21 @@ func (t cborType) String() string { type additionalInformation uint8 const ( - maxAdditionalInformationWithoutArgument = 23 - additionalInformationWith1ByteArgument = 24 - additionalInformationWith2ByteArgument = 25 - additionalInformationWith4ByteArgument = 26 - additionalInformationWith8ByteArgument = 27 + maxAdditionalInformationWithoutArgument = 23 + additionalInformationWith1ByteArgument = 24 + additionalInformationWith2ByteArgument = 25 + additionalInformationWith4ByteArgument = 26 + additionalInformationWith8ByteArgument = 27 + + // additional information with major type 7 + additionalInformationAsFalse = 20 + additionalInformationAsTrue = 21 + additionalInformationAsNull = 22 + additionalInformationAsUndefined = 23 + additionalInformationAsFloat16 = 25 + additionalInformationAsFloat32 = 26 + additionalInformationAsFloat64 = 27 + additionalInformationAsIndefiniteLengthFlag = 31 ) diff --git a/decode.go b/decode.go index 1d92ddb5..ea943977 100644 --- a/decode.go +++ b/decode.go @@ -1444,15 +1444,18 @@ func (d *decoder) parseToValue(v reflect.Value, tInfo *typeInfo) error { //nolin case cborTypePrimitives: _, ai, val := d.getHead() switch ai { - case 25: + case additionalInformationAsFloat16: f := float64(float16.Frombits(uint16(val)).Float32()) return fillFloat(t, f, v) - case 26: + + case additionalInformationAsFloat32: f := float64(math.Float32frombits(uint32(val))) return fillFloat(t, f, v) - case 27: + + case additionalInformationAsFloat64: f := math.Float64frombits(val) return fillFloat(t, f, v) + default: // ai <= 24 if d.dm.simpleValues.rejected[SimpleValue(val)] { return &UnacceptableDataItemError{ @@ -1462,10 +1465,14 @@ func (d *decoder) parseToValue(v reflect.Value, tInfo *typeInfo) error { //nolin } switch ai { - case 20, 21: - return fillBool(t, ai == 21, v) - case 22, 23: + case additionalInformationAsFalse, + additionalInformationAsTrue: + return fillBool(t, ai == additionalInformationAsTrue, v) + + case additionalInformationAsNull, + additionalInformationAsUndefined: return fillNil(t, v) + default: return fillPositiveInt(t, val, v) } @@ -1664,12 +1671,15 @@ func (d *decoder) parseToTime() (time.Time, bool, error) { _, ai, val := d.getHead() var f float64 switch ai { - case 25: + case additionalInformationAsFloat16: f = float64(float16.Frombits(uint16(val)).Float32()) - case 26: + + case additionalInformationAsFloat32: f = float64(math.Float32frombits(uint32(val))) - case 27: + + case additionalInformationAsFloat64: f = math.Float64frombits(val) + default: return time.Time{}, false, &UnmarshalTypeError{CBORType: t.String(), GoType: typeTime.String()} } @@ -1931,6 +1941,7 @@ func (d *decoder) parse(skipSelfDescribedTag bool) (interface{}, error) { //noli return content, nil } return Tag{tagNum, content}, nil + case cborTypePrimitives: _, ai, val := d.getHead() if ai <= 24 && d.dm.simpleValues.rejected[SimpleValue(val)] { @@ -1943,20 +1954,27 @@ func (d *decoder) parse(skipSelfDescribedTag bool) (interface{}, error) { //noli return SimpleValue(val), nil } switch ai { - case 20, 21: - return (ai == 21), nil - case 22, 23: + case additionalInformationAsFalse, + additionalInformationAsTrue: + return (ai == additionalInformationAsTrue), nil + + case additionalInformationAsNull, + additionalInformationAsUndefined: return nil, nil - case 25: + + case additionalInformationAsFloat16: f := float64(float16.Frombits(uint16(val)).Float32()) return f, nil - case 26: + + case additionalInformationAsFloat32: f := float64(math.Float32frombits(uint32(val))) return f, nil - case 27: + + case additionalInformationAsFloat64: f := math.Float64frombits(val) return f, nil } + case cborTypeArray: return d.parseArray() case cborTypeMap: diff --git a/diagnose.go b/diagnose.go index 800f25c9..05850f1a 100644 --- a/diagnose.go +++ b/diagnose.go @@ -441,23 +441,25 @@ func (di *diagnose) item() error { //nolint:gocyclo case cborTypePrimitives: _, ai, val := di.d.getHead() switch ai { - case 20: + case additionalInformationAsFalse: di.w.WriteString("false") return nil - case 21: + case additionalInformationAsTrue: di.w.WriteString("true") return nil - case 22: + case additionalInformationAsNull: di.w.WriteString("null") return nil - case 23: + case additionalInformationAsUndefined: di.w.WriteString("undefined") return nil - case 25, 26, 27: + case additionalInformationAsFloat16, + additionalInformationAsFloat32, + additionalInformationAsFloat64: return di.encodeFloat(ai, val) default: @@ -628,7 +630,7 @@ func (di *diagnose) encodeTextString(val string, quote byte) error { func (di *diagnose) encodeFloat(ai byte, val uint64) error { f64 := float64(0) switch ai { - case 25: + case additionalInformationAsFloat16: f16 := float16.Frombits(uint16(val)) switch { case f16.IsNaN(): @@ -644,7 +646,7 @@ func (di *diagnose) encodeFloat(ai byte, val uint64) error { f64 = float64(f16.Float32()) } - case 26: + case additionalInformationAsFloat32: f32 := math.Float32frombits(uint32(val)) switch { case f32 != f32: @@ -660,7 +662,7 @@ func (di *diagnose) encodeFloat(ai byte, val uint64) error { f64 = float64(f32) } - case 27: + case additionalInformationAsFloat64: f64 = math.Float64frombits(val) switch { case f64 != f64: @@ -703,13 +705,15 @@ func (di *diagnose) encodeFloat(ai byte, val uint64) error { if di.dm.floatPrecisionIndicator { switch ai { - case 25: + case additionalInformationAsFloat16: di.w.WriteString("_1") return nil - case 26: + + case additionalInformationAsFloat32: di.w.WriteString("_2") return nil - case 27: + + case additionalInformationAsFloat64: di.w.WriteString("_3") return nil }