-
Notifications
You must be signed in to change notification settings - Fork 91
/
float64.go
135 lines (105 loc) · 3.04 KB
/
float64.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
package types
import (
"context"
"fmt"
"math/big"
"github.com/hashicorp/terraform-plugin-framework/attr"
"github.com/hashicorp/terraform-plugin-framework/diag"
"github.com/hashicorp/terraform-plugin-go/tftypes"
)
func float64Validate(ctx context.Context, in tftypes.Value, path *tftypes.AttributePath) diag.Diagnostics {
var diags diag.Diagnostics
if !in.Type().Equal(tftypes.Number) {
diags.AddAttributeError(
path,
"Float64 Type Validation Error",
"An unexpected error was encountered trying to validate an attribute value. This is always an error in the provider. Please report the following to the provider developer:\n\n"+
fmt.Sprintf("Expected Number value, received %T with value: %v", in, in),
)
return diags
}
if !in.IsKnown() || in.IsNull() {
return diags
}
var value *big.Float
err := in.As(&value)
if err != nil {
diags.AddAttributeError(
path,
"Float64 Type Validation Error",
"An unexpected error was encountered trying to validate an attribute value. This is always an error in the provider. Please report the following to the provider developer:\n\n"+
fmt.Sprintf("Cannot convert value to big.Float: %s", err),
)
return diags
}
_, accuracy := value.Float64()
if accuracy != 0 {
diags.AddAttributeError(
path,
"Float64 Type Validation Error",
fmt.Sprintf("Value %s cannot be represented as a 64-bit floating point.", value),
)
return diags
}
return diags
}
func float64ValueFromTerraform(ctx context.Context, in tftypes.Value) (attr.Value, error) {
if !in.IsKnown() {
return Float64{Unknown: true}, nil
}
if in.IsNull() {
return Float64{Null: true}, nil
}
var bigF *big.Float
err := in.As(&bigF)
if err != nil {
return nil, err
}
f, accuracy := bigF.Float64()
if accuracy != 0 {
return nil, fmt.Errorf("Value %s cannot be represented as a 64-bit floating point.", bigF)
}
return Float64{Value: f}, nil
}
var _ attr.Value = Float64{}
// Float64 represents a 64-bit floating point value, exposed as an float64.
type Float64 struct {
// Unknown will be true if the value is not yet known.
Unknown bool
// Null will be true if the value was not set, or was explicitly set to
// null.
Null bool
// Value contains the set value, as long as Unknown and Null are both
// false.
Value float64
}
// Equal returns true if `other` is an Float64 and has the same value as `i`.
func (f Float64) Equal(other attr.Value) bool {
o, ok := other.(Float64)
if !ok {
return false
}
if f.Unknown != o.Unknown {
return false
}
if f.Null != o.Null {
return false
}
return f.Value == o.Value
}
// ToTerraformValue returns the data contained in the Float64 as a float64.
// If Unknown is true, it returns a tftypes.UnknownValue. If Null is true, it
// returns nil.
func (f Float64) ToTerraformValue(ctx context.Context) (interface{}, error) {
if f.Null {
return nil, nil
}
if f.Unknown {
return tftypes.UnknownValue, nil
}
return big.NewFloat(f.Value), nil
}
// Type returns a NumberType.
func (f Float64) Type(ctx context.Context) attr.Type {
return Float64Type
}