-
-
Notifications
You must be signed in to change notification settings - Fork 0
/
encode.go
188 lines (154 loc) · 4.59 KB
/
encode.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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
// Copyright (c) 2023, Roel Schut. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package rawconv
import (
"reflect"
"strconv"
"strings"
"github.com/go-pogo/errors"
)
const ErrMarshalNested errors.Msg = "cannot marshal nested array/slice/map"
// Marshal formats the value pointed to by v to a raw string Value.
// If v is not a supported type an UnsupportedTypeError is returned.
// By default, the following types are supported:
// - encoding.TextMarshaler
// - string
// - bool
// - int, int8, int16, int32, int64
// - uint, uint8, uint16, uint32, uint64
// - float32, float64
// - complex64, complex128
// - array, slice
// - map
// - time.Duration
// - url.URL
//
// Use RegisterMarshalFunc to add additional (custom) types.
func Marshal(v any) (Value, error) {
return marshaler.Marshal(reflect.ValueOf(v))
}
type MarshalFunc func(v any) (string, error)
// GetMarshalFunc returns the globally registered MarshalFunc for reflect.Type
// typ or nil if there is none registered with RegisterMarshalFunc.
func GetMarshalFunc(typ reflect.Type) MarshalFunc { return marshaler.Func(typ) }
// marshaler is the global Marshaler.
var marshaler Marshaler
// Marshaler is a type which can marshal any reflect.Value to its raw string
// representation as long as it's registered with Register. It wil always
// fallback to the global Marshaler when a type is not registered.
type Marshaler struct {
Options
register register[MarshalFunc]
}
// Register the MarshalFunc for typ but only for this Marshaler.
func (m *Marshaler) Register(typ reflect.Type, fn MarshalFunc) *Marshaler {
m.register.add(typ, fn)
return m
}
// Func returns the (globally) registered MarshalFunc for reflect.Type typ or
// nil if there is none registered with Register or RegisterMarshalFunc.
func (m *Marshaler) Func(typ reflect.Type) MarshalFunc {
if m.register.initialized() {
if fn := m.register.find(typ); fn != nil {
return fn
}
}
// fallback to global marshaler
return marshaler.register.find(typ)
}
// Marshal returns the string representation of the value.
// If the underlying reflect.Value is nil, it returns an empty string.
func (m *Marshaler) Marshal(val reflect.Value) (Value, error) {
str, err := m.marshal(val, false)
return Value(str), err
}
func (m *Marshaler) marshal(val reflect.Value, nested bool) (string, error) {
if fn := m.Func(val.Type()); fn != nil {
return fn.exec(val)
}
ot := val.Type()
for val.Kind() == reflect.Ptr {
if val.IsNil() {
return "", nil
}
val = val.Elem()
}
switch val.Kind() {
case reflect.String:
return val.String(), nil
case reflect.Bool:
return strconv.FormatBool(val.Bool()), nil
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return strconv.FormatInt(val.Int(), 10), nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return strconv.FormatUint(val.Uint(), 10), nil
case reflect.Float32, reflect.Float64:
return strconv.FormatFloat(val.Float(), 'g', -1, 64), nil
case reflect.Complex64, reflect.Complex128:
return strconv.FormatComplex(val.Complex(), 'g', -1, 128), nil
case reflect.Array, reflect.Slice:
if nested {
return "", errors.New(ErrMarshalNested)
}
sep := m.itemSeparator()
var buf strings.Builder
for i := 0; i < val.Len(); i++ {
v, err := m.marshal(val.Index(i), true)
if err != nil {
return "", err
}
if i > 0 {
buf.WriteString(sep)
}
buf.WriteString(v)
}
return buf.String(), nil
case reflect.Map:
if nested {
return "", errors.New(ErrMarshalNested)
}
sep1 := m.keyValueSeparator()
sep2 := m.itemSeparator()
var buf strings.Builder
var firstDone bool
for iter := val.MapRange(); iter.Next(); {
v, err := m.marshal(iter.Value(), true)
if err != nil {
return "", err
}
k, err := m.marshal(iter.Key(), true)
if err != nil {
return "", err
}
if firstDone {
buf.WriteString(sep2)
}
buf.WriteString(k)
buf.WriteString(sep1)
buf.WriteString(v)
firstDone = true
}
return buf.String(), nil
default:
return "", errors.WithStack(&UnsupportedTypeError{Type: ot})
}
}
// Exec executes the MarshalFunc for the given reflect.Value.
func (fn MarshalFunc) Exec(val reflect.Value) (Value, error) {
str, err := fn.exec(val)
return Value(str), err
}
func (fn MarshalFunc) exec(val reflect.Value) (string, error) {
for val.Kind() == reflect.Ptr {
if val.IsNil() {
return "", nil
}
val = val.Elem()
}
str, err := fn(val.Interface())
if err != nil {
return str, errors.WithStack(err)
}
return str, nil
}