', 'comma-separated list of benchmark names', (value) => {
18 | return value.split(',')
19 | })
20 |
21 | prog.version('0.2.0')
22 | prog.parse(process.argv)
23 |
24 | // createChart creates and exports a Google Bar Chart
25 | // as a PNG image, using the decamelized form of name
26 | // with '-' as separator. The parameter data must be a
27 | // two-dimensional array where each row represents a
28 | // bar in the chart.
29 | function createBarChart (dom, name, data, opts) {
30 | var head = dom.window.document.getElementsByTagName('head')[0]
31 | var func = head.insertBefore
32 |
33 | // Prevent call to Google Font API.
34 | head.insertBefore = function (el, ref) {
35 | if (el.href && el.href.indexOf('//fonts.googleapis.com/css?family=Input') > -1) {
36 | return
37 | }
38 | func.call(head, el, ref)
39 | }
40 | // Add an event listener to draw the chart once
41 | // the DOM is fully loaded.
42 | dom.window.addEventListener('DOMContentLoaded', function () {
43 | const g = dom.window.google
44 |
45 | // Load the Google Visualization
46 | // API and the corechart package.
47 | g.charts.load('45.2', {
48 | packages: ['corechart', 'bar']
49 | })
50 | g.charts.setOnLoadCallback(function () {
51 | drawBarChart(dom, name, data, opts)
52 | })
53 | })
54 | }
55 |
56 | // exportChartAsSVG exports the SVG of the chart to
57 | // the current working directory. The file name is a
58 | // decamelized version of name using the hyphen char
59 | // as separator, in lowercase.
60 | function exportChartAsSVG (e, name) {
61 | var filename = util.format('%s.svg',
62 | path.join(prog.directory, deca(name, '-'))
63 | )
64 | var svgEl = e.getElementsByTagName('svg')[0]
65 | var svg = htmlToElement(svgEl.outerHTML)
66 |
67 | svg.setAttribute('xmlns', 'http://www.w3.org/2000/svg')
68 | svg.setAttribute('version', '1.1')
69 |
70 | const result = optimize(svg.outerHTML, {
71 | plugins: [{
72 | name: "sortAttrs"
73 | }, {
74 | name: "removeAttrs",
75 | params: {
76 | attrs: "(clip-path|aria-label|overflow)"
77 | }
78 | }],
79 | multipass: true
80 | })
81 | try {
82 | return fs.writeFileSync(filename, result.data)
83 | } catch (err) {
84 | console.error('cannot write svg chart %s: %s', filename, err)
85 | }
86 | }
87 |
88 | function htmlToElement (html) {
89 | const d = (new JSDOM('...')).window.document
90 | var t = d.createElement('template')
91 | t.innerHTML = html.trim()
92 | return t.content.firstChild
93 | }
94 |
95 | function drawBarChart (dom, name, data, opts) {
96 | const g = dom.window.google
97 | const d = dom.window.document
98 |
99 | // Convert the data 2D-array to a DataTable,
100 | // and sort it in alphabetical order using
101 | // the content of the first column which
102 | // contains the names of the benchmark runs.
103 | var dt = new g.visualization.arrayToDataTable(data)
104 | dt.sort([{
105 | column: 0
106 | }])
107 | var e = d.getElementById('chart')
108 | var c = new g.visualization.ColumnChart(e)
109 |
110 | // Setup a callback that exports the chart as
111 | // a PNG image when it has finished drawing.
112 | g.visualization.events.addListener(c, 'ready', function () {
113 | exportChartAsSVG(e, name)
114 | })
115 | c.draw(dt, opts)
116 | }
117 |
118 | // Load and parse the JSON-formatted benchmark
119 | // statistics from the input file.
120 | var file = fs.readFileSync(prog.input)
121 | var data = JSON.parse(file)
122 |
123 | // Iterate over all benchmarks and create the
124 | // chart only if it was requested through the
125 | // command-line parameters.
126 | Object.keys(data).forEach(function (key) {
127 | if (!prog.names.includes(key)) {
128 | return
129 | }
130 | const pageFile = path.join(__dirname, 'jsdom.html')
131 |
132 | JSDOM.fromFile(pageFile, {
133 | resources: 'usable',
134 | runScripts: 'dangerously',
135 | pretendToBeVisual: true
136 | }).then(dom => {
137 | createBarChart(dom, key, data[key], {
138 | width: 700,
139 | height: 400,
140 | chartArea: {
141 | left: 100,
142 | top: 50,
143 | width: '70%',
144 | height: '75%'
145 | },
146 | vAxis: {
147 | format: '',
148 | gridlines: {
149 | count: 5
150 | },
151 | minorGridlines: {
152 | count: 2
153 | }
154 | },
155 | hAxis: {
156 | textStyle: {
157 | bold: true,
158 | fontName: 'Input'
159 | }
160 | }
161 | })
162 | })
163 | })
164 |
--------------------------------------------------------------------------------
/types.go:
--------------------------------------------------------------------------------
1 | package jettison
2 |
3 | import (
4 | "encoding"
5 | "encoding/json"
6 | "reflect"
7 | "sync"
8 | "time"
9 | "unsafe"
10 | )
11 |
12 | var (
13 | timeTimeType = reflect.TypeOf(time.Time{})
14 | timeDurationType = reflect.TypeOf(time.Duration(0))
15 | syncMapType = reflect.TypeOf((*sync.Map)(nil)).Elem()
16 | jsonNumberType = reflect.TypeOf(json.Number(""))
17 | jsonRawMessageType = reflect.TypeOf(json.RawMessage(nil))
18 | jsonMarshalerType = reflect.TypeOf((*json.Marshaler)(nil)).Elem()
19 | textMarshalerType = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
20 | appendMarshalerType = reflect.TypeOf((*AppendMarshaler)(nil)).Elem()
21 | appendMarshalerCtxType = reflect.TypeOf((*AppendMarshalerCtx)(nil)).Elem()
22 | )
23 |
24 | var emptyFnCache sync.Map // map[reflect.Type]emptyFunc
25 |
26 | // emptyFunc is a function that returns whether a
27 | // value pointed by an unsafe.Pointer represents the
28 | // zero value of its type.
29 | type emptyFunc func(unsafe.Pointer) bool
30 |
31 | // marshalerEncodeFunc is a function that appends
32 | // the result of a marshaler method call to dst.
33 | type marshalerEncodeFunc func(interface{}, []byte, encOpts, reflect.Type) ([]byte, error)
34 |
35 | func isBasicType(t reflect.Type) bool {
36 | return isBoolean(t) || isString(t) || isFloatingPoint(t) || isInteger(t)
37 | }
38 |
39 | func isBoolean(t reflect.Type) bool { return t.Kind() == reflect.Bool }
40 | func isString(t reflect.Type) bool { return t.Kind() == reflect.String }
41 |
42 | func isFloatingPoint(t reflect.Type) bool {
43 | kind := t.Kind()
44 | if kind == reflect.Float32 || kind == reflect.Float64 {
45 | return true
46 | }
47 | return false
48 | }
49 |
50 | func isInteger(t reflect.Type) bool {
51 | switch t.Kind() {
52 | case reflect.Int,
53 | reflect.Int8,
54 | reflect.Int16,
55 | reflect.Int32,
56 | reflect.Int64,
57 | reflect.Uint,
58 | reflect.Uint8,
59 | reflect.Uint16,
60 | reflect.Uint32,
61 | reflect.Uint64,
62 | reflect.Uintptr:
63 | return true
64 | default:
65 | return false
66 | }
67 | }
68 |
69 | func isInlined(t reflect.Type) bool {
70 | switch t.Kind() {
71 | case reflect.Ptr, reflect.Map:
72 | return true
73 | case reflect.Struct:
74 | return t.NumField() == 1 && isInlined(t.Field(0).Type)
75 | default:
76 | return false
77 | }
78 | }
79 |
80 | func isNilable(t reflect.Type) bool {
81 | switch t.Kind() {
82 | case reflect.Ptr, reflect.Interface, reflect.Slice, reflect.Map:
83 | return true
84 | }
85 | return false
86 | }
87 |
88 | // cachedEmptyFuncOf is similar to emptyFuncOf, but
89 | // returns a cached function, to avoid duplicates.
90 | func cachedEmptyFuncOf(t reflect.Type) emptyFunc {
91 | if fn, ok := emptyFnCache.Load(t); ok {
92 | return fn.(emptyFunc)
93 | }
94 | fn, _ := emptyFnCache.LoadOrStore(t, emptyFuncOf(t))
95 | return fn.(emptyFunc)
96 | }
97 |
98 | // emptyFuncOf returns a function that can be used to
99 | // determine if a value pointed by an unsafe,Pointer
100 | // represents the zero-value of type t.
101 | func emptyFuncOf(t reflect.Type) emptyFunc {
102 | switch t.Kind() {
103 | case reflect.Bool:
104 | return func(p unsafe.Pointer) bool {
105 | return !*(*bool)(p)
106 | }
107 | case reflect.String:
108 | return func(p unsafe.Pointer) bool {
109 | return (*stringHeader)(p).Len == 0
110 | }
111 | case reflect.Int:
112 | return func(p unsafe.Pointer) bool {
113 | return *(*int)(p) == 0
114 | }
115 | case reflect.Int8:
116 | return func(p unsafe.Pointer) bool {
117 | return *(*int8)(p) == 0
118 | }
119 | case reflect.Int16:
120 | return func(p unsafe.Pointer) bool {
121 | return *(*int16)(p) == 0
122 | }
123 | case reflect.Int32:
124 | return func(p unsafe.Pointer) bool {
125 | return *(*int32)(p) == 0
126 | }
127 | case reflect.Int64:
128 | return func(p unsafe.Pointer) bool {
129 | return *(*int64)(p) == 0
130 | }
131 | case reflect.Uint:
132 | return func(p unsafe.Pointer) bool {
133 | return *(*uint)(p) == 0
134 | }
135 | case reflect.Uint8:
136 | return func(p unsafe.Pointer) bool {
137 | return *(*uint8)(p) == 0
138 | }
139 | case reflect.Uint16:
140 | return func(p unsafe.Pointer) bool {
141 | return *(*uint16)(p) == 0
142 | }
143 | case reflect.Uint32:
144 | return func(p unsafe.Pointer) bool {
145 | return *(*uint32)(p) == 0
146 | }
147 | case reflect.Uint64:
148 | return func(p unsafe.Pointer) bool {
149 | return *(*uint64)(p) == 0
150 | }
151 | case reflect.Uintptr:
152 | return func(p unsafe.Pointer) bool {
153 | return *(*uintptr)(p) == 0
154 | }
155 | case reflect.Float32:
156 | return func(p unsafe.Pointer) bool {
157 | return *(*float32)(p) == 0
158 | }
159 | case reflect.Float64:
160 | return func(p unsafe.Pointer) bool {
161 | return *(*float64)(p) == 0
162 | }
163 | case reflect.Map:
164 | return func(p unsafe.Pointer) bool {
165 | return maplen(*(*unsafe.Pointer)(p)) == 0
166 | }
167 | case reflect.Ptr:
168 | return func(p unsafe.Pointer) bool {
169 | return *(*unsafe.Pointer)(p) == nil
170 | }
171 | case reflect.Interface:
172 | return func(p unsafe.Pointer) bool {
173 | return *(*unsafe.Pointer)(p) == nil
174 | }
175 | case reflect.Slice:
176 | return func(p unsafe.Pointer) bool {
177 | return (*sliceHeader)(p).Len == 0
178 | }
179 | case reflect.Array:
180 | if t.Len() == 0 {
181 | return func(unsafe.Pointer) bool { return true }
182 | }
183 | }
184 | return func(unsafe.Pointer) bool { return false }
185 | }
186 |
--------------------------------------------------------------------------------
/json.go:
--------------------------------------------------------------------------------
1 | package jettison
2 |
3 | import (
4 | "context"
5 | "fmt"
6 | "reflect"
7 | "runtime"
8 | )
9 |
10 | // AppendMarshaler is a variant of the json.Marshaler
11 | // interface, implemented by types that can append a
12 | // valid and compact JSON representation of themselves
13 | // to a buffer. If a type implements both interfaces,
14 | // this one will be used in priority by the package.
15 | type AppendMarshaler interface {
16 | AppendJSON([]byte) ([]byte, error)
17 | }
18 |
19 | // AppendMarshalerCtx is similar to AppendMarshaler,
20 | // but the method implemented also takes a context.
21 | // The use case for this interface is to dynamically
22 | // control the marshaling of the type implementing it
23 | // through the values encapsulated by the context,
24 | // that may be provided at runtime using WithContext.
25 | type AppendMarshalerCtx interface {
26 | AppendJSONContext(context.Context, []byte) ([]byte, error)
27 | }
28 |
29 | const (
30 | marshalerJSON = "MarshalJSON"
31 | marshalerText = "MarshalText"
32 | marshalerAppendJSONCtx = "AppendJSONContext"
33 | marshalerAppendJSON = "AppendJSON"
34 | )
35 |
36 | // MarshalerError represents an error from calling
37 | // the methods MarshalJSON or MarshalText.
38 | type MarshalerError struct {
39 | Type reflect.Type
40 | Err error
41 | funcName string
42 | }
43 |
44 | // Error implements the builtin error interface.
45 | func (e *MarshalerError) Error() string {
46 | return fmt.Sprintf("json: error calling %s for type %s: %s",
47 | e.funcName, e.Type, e.Err.Error())
48 | }
49 |
50 | // Unwrap returns the error wrapped by e.
51 | // This doesn't implement a public interface, but
52 | // allow to use the errors.Unwrap function released
53 | // in Go1.13 with a MarshalerError.
54 | func (e *MarshalerError) Unwrap() error {
55 | return e.Err
56 | }
57 |
58 | // UnsupportedTypeError is the error returned
59 | // by Marshal when attempting to encode an
60 | // unsupported value type.
61 | type UnsupportedTypeError struct {
62 | Type reflect.Type
63 | }
64 |
65 | // Error implements the bultin error interface.
66 | func (e *UnsupportedTypeError) Error() string {
67 | return fmt.Sprintf("json: unsupported type: %s", e.Type)
68 | }
69 |
70 | // UnsupportedValueError is the error returned
71 | // by Marshal when attempting to encode an
72 | // unsupported value.
73 | type UnsupportedValueError struct {
74 | Value reflect.Value
75 | Str string
76 | }
77 |
78 | // Error implements the builtin error interface.
79 | func (e *UnsupportedValueError) Error() string {
80 | return fmt.Sprintf("json: unsupported value: %s", e.Str)
81 | }
82 |
83 | // A SyntaxError is a description of a JSON syntax error.
84 | // Unlike its equivalent in the encoding/json package, the
85 | // Error method implemented does not return a meaningful
86 | // message, and the Offset field is always zero.
87 | // It is present merely for consistency.
88 | type SyntaxError struct {
89 | msg string
90 | Offset int64
91 | }
92 |
93 | // Error implements the builtin error interface.
94 | func (e *SyntaxError) Error() string { return e.msg }
95 |
96 | // InvalidOptionError is the error returned by
97 | // MarshalOpts when one of the given options is
98 | // invalid.
99 | type InvalidOptionError struct {
100 | Err error
101 | }
102 |
103 | // Error implements the builtin error interface.
104 | func (e *InvalidOptionError) Error() string {
105 | return fmt.Sprintf("json: invalid option: %s", e.Err.Error())
106 | }
107 |
108 | // Marshal returns the JSON encoding of v.
109 | // The full documentation can be found at
110 | // https://golang.org/pkg/encoding/json/#Marshal.
111 | func Marshal(v interface{}) ([]byte, error) {
112 | if v == nil {
113 | return []byte("null"), nil
114 | }
115 | return marshalJSON(v, defaultEncOpts())
116 | }
117 |
118 | // Append is similar to Marshal but appends the JSON
119 | // representation of v to dst instead of returning a
120 | // new allocated slice.
121 | func Append(dst []byte, v interface{}) ([]byte, error) {
122 | if v == nil {
123 | return append(dst, "null"...), nil
124 | }
125 | return appendJSON(dst, v, defaultEncOpts())
126 | }
127 |
128 | // MarshalOpts is similar to Marshal, but also accepts
129 | // a list of options to configure the encoding behavior.
130 | func MarshalOpts(v interface{}, opts ...Option) ([]byte, error) {
131 | if v == nil {
132 | return []byte("null"), nil
133 | }
134 | eo := defaultEncOpts()
135 |
136 | if len(opts) != 0 {
137 | (&eo).apply(opts...)
138 | if err := eo.validate(); err != nil {
139 | return nil, &InvalidOptionError{err}
140 | }
141 | }
142 | return marshalJSON(v, eo)
143 | }
144 |
145 | // AppendOpts is similar to Append, but also accepts
146 | // a list of options to configure the encoding behavior.
147 | func AppendOpts(dst []byte, v interface{}, opts ...Option) ([]byte, error) {
148 | if v == nil {
149 | return append(dst, "null"...), nil
150 | }
151 | eo := defaultEncOpts()
152 |
153 | if len(opts) != 0 {
154 | (&eo).apply(opts...)
155 | if err := eo.validate(); err != nil {
156 | return nil, &InvalidOptionError{err}
157 | }
158 | }
159 | return appendJSON(dst, v, eo)
160 | }
161 |
162 | func marshalJSON(v interface{}, opts encOpts) ([]byte, error) {
163 | ins := cachedInstr(reflect.TypeOf(v))
164 | buf := cachedBuffer()
165 |
166 | var err error
167 | buf.B, err = ins(unpackEface(v).word, buf.B, opts)
168 |
169 | // Ensure that v is reachable until
170 | // the instruction has returned.
171 | runtime.KeepAlive(v)
172 |
173 | var b []byte
174 | if err == nil {
175 | // Make a copy of the buffer's content
176 | // before its returned to the pool.
177 | b = make([]byte, len(buf.B))
178 | copy(b, buf.B)
179 | }
180 | bufferPool.Put(buf)
181 |
182 | return b, err
183 | }
184 |
185 | func appendJSON(dst []byte, v interface{}, opts encOpts) ([]byte, error) {
186 | ins := cachedInstr(reflect.TypeOf(v))
187 | var err error
188 | dst, err = ins(unpackEface(v).word, dst, opts)
189 | runtime.KeepAlive(v)
190 |
191 | return dst, err
192 | }
193 |
--------------------------------------------------------------------------------
/time.go:
--------------------------------------------------------------------------------
1 | package jettison
2 |
3 | import "time"
4 |
5 | const epoch = 62135683200 // 1970-01-01T00:00:00
6 |
7 | // DurationFmt represents the format used
8 | // to encode a time.Duration value.
9 | type DurationFmt int
10 |
11 | // DurationFmt constants.
12 | const (
13 | DurationString DurationFmt = iota
14 | DurationMinutes
15 | DurationSeconds
16 | DurationMilliseconds
17 | DurationMicroseconds
18 | DurationNanoseconds // default
19 | )
20 |
21 | // String implements the fmt.Stringer
22 | // interface for DurationFmt.
23 | func (f DurationFmt) String() string {
24 | if !f.valid() {
25 | return "unknown"
26 | }
27 | return durationFmtStr[f]
28 | }
29 |
30 | func (f DurationFmt) valid() bool {
31 | return f >= DurationString && f <= DurationNanoseconds
32 | }
33 |
34 | var (
35 | zeroDuration = []byte("0s")
36 | durationFmtStr = []string{"str", "min", "s", "ms", "μs", "nanosecond"}
37 | dayOffset = [13]uint16{0, 306, 337, 0, 31, 61, 92, 122, 153, 184, 214, 245, 275}
38 | )
39 |
40 | // appendDuration appends the textual representation
41 | // of d to the tail of dst and returns the extended buffer.
42 | // Adapted from https://golang.org/src/time/time.go.
43 | func appendDuration(dst []byte, d time.Duration) []byte {
44 | var buf [32]byte
45 |
46 | l := len(buf)
47 | u := uint64(d)
48 | n := d < 0
49 | if n {
50 | u = -u
51 | }
52 | if u < uint64(time.Second) {
53 | // Special case: if duration is smaller than
54 | // a second, use smaller units, like 1.2ms
55 | var prec int
56 | l--
57 | buf[l] = 's'
58 | l--
59 | switch {
60 | case u == 0:
61 | return append(dst, zeroDuration...)
62 | case u < uint64(time.Microsecond):
63 | prec = 0
64 | buf[l] = 'n'
65 | case u < uint64(time.Millisecond):
66 | prec = 3
67 | // U+00B5 'µ' micro sign is 0xC2 0xB5.
68 | // Need room for two bytes.
69 | l--
70 | copy(buf[l:], "µ")
71 | default: // Format as milliseconds.
72 | prec = 6
73 | buf[l] = 'm'
74 | }
75 | l, u = fmtFrac(buf[:l], u, prec)
76 | l = fmtInt(buf[:l], u)
77 | } else {
78 | l--
79 | buf[l] = 's'
80 |
81 | l, u = fmtFrac(buf[:l], u, 9)
82 |
83 | // Format as seconds.
84 | l = fmtInt(buf[:l], u%60)
85 | u /= 60
86 |
87 | // Format as minutes.
88 | if u > 0 {
89 | l--
90 | buf[l] = 'm'
91 | l = fmtInt(buf[:l], u%60)
92 | u /= 60
93 |
94 | // Format as hours. Stop there, because
95 | // days can be different lengths.
96 | if u > 0 {
97 | l--
98 | buf[l] = 'h'
99 | l = fmtInt(buf[:l], u)
100 | }
101 | }
102 | }
103 | if n {
104 | l--
105 | buf[l] = '-'
106 | }
107 | return append(dst, buf[l:]...)
108 | }
109 |
110 | // fmtInt formats v into the tail of buf.
111 | // It returns the index where the output begins.
112 | // Taken from https://golang.org/src/time/time.go.
113 | func fmtInt(buf []byte, v uint64) int {
114 | w := len(buf)
115 | if v == 0 {
116 | w--
117 | buf[w] = '0'
118 | } else {
119 | for v > 0 {
120 | w--
121 | buf[w] = byte(v%10) + '0'
122 | v /= 10
123 | }
124 | }
125 | return w
126 | }
127 |
128 | // fmtFrac formats the fraction of v/10**prec (e.g., ".12345")
129 | // into the tail of buf, omitting trailing zeros. It omits the
130 | // decimal point too when the fraction is 0. It returns the
131 | // index where the output bytes begin and the value v/10**prec.
132 | // Taken from https://golang.org/src/time/time.go.
133 | func fmtFrac(buf []byte, v uint64, prec int) (nw int, nv uint64) {
134 | // Omit trailing zeros up to and including decimal point.
135 | w := len(buf)
136 | print := false
137 | for i := 0; i < prec; i++ {
138 | digit := v % 10
139 | print = print || digit != 0
140 | if print {
141 | w--
142 | buf[w] = byte(digit) + '0'
143 | }
144 | v /= 10
145 | }
146 | if print {
147 | w--
148 | buf[w] = '.'
149 | }
150 | return w, v
151 | }
152 |
153 | func rdnToYmd(rdn uint32) (uint16, uint16, uint16) {
154 | // Rata Die algorithm by Peter Baum.
155 | var (
156 | Z = rdn + 306
157 | H = 100*Z - 25
158 | A = H / 3652425
159 | B = A - (A >> 2)
160 | y = (100*B + H) / 36525
161 | d = B + Z - (1461 * y >> 2)
162 | m = (535*d + 48950) >> 14
163 | )
164 | if m > 12 {
165 | y++
166 | m -= 12
167 | }
168 | return uint16(y), uint16(m), uint16(d) - dayOffset[m]
169 | }
170 |
171 | // appendRFC3339Time appends the RFC3339 textual representation
172 | // of t to the tail of dst and returns the extended buffer.
173 | // Adapted from https://github.com/chansen/c-timestamp.
174 | func appendRFC3339Time(t time.Time, dst []byte, nano bool) []byte {
175 | var buf [37]byte
176 |
177 | // Base layout chars with opening quote.
178 | buf[0], buf[5], buf[8], buf[11], buf[14], buf[17] = '"', '-', '-', 'T', ':', ':'
179 |
180 | // Year.
181 | _, offset := t.Zone()
182 | sec := t.Unix() + int64(offset) + epoch
183 | y, m, d := rdnToYmd(uint32(sec / 86400))
184 | for i := 4; i >= 1; i-- {
185 | buf[i] = byte(y%10) + '0'
186 | y /= 10
187 | }
188 | buf[7], m = byte(m%10)+'0', m/10 // month
189 | buf[6] = byte(m%10) + '0'
190 |
191 | buf[10], d = byte(d%10)+'0', d/10 // day
192 | buf[9] = byte(d%10) + '0'
193 |
194 | // Hours/minutes/seconds.
195 | s := sec % 86400
196 | buf[19], s = byte(s%10)+'0', s/10
197 | buf[18], s = byte(s%06)+'0', s/6
198 | buf[16], s = byte(s%10)+'0', s/10
199 | buf[15], s = byte(s%06)+'0', s/6
200 | buf[13], s = byte(s%10)+'0', s/10
201 | buf[12], _ = byte(s%10)+'0', 0
202 |
203 | n := 20
204 |
205 | // Fractional second precision.
206 | nsec := t.Nanosecond()
207 | if nano && nsec != 0 {
208 | buf[n] = '.'
209 | u := nsec
210 | for i := 9; i >= 1; i-- {
211 | buf[n+i] = byte(u%10) + '0'
212 | u /= 10
213 | }
214 | // Remove trailing zeros.
215 | var rpad int
216 | for i := 9; i >= 1; i-- {
217 | if buf[n+i] == '0' {
218 | rpad++
219 | } else {
220 | break
221 | }
222 | }
223 | n += 10 - rpad
224 | }
225 | // Zone.
226 | if offset == 0 {
227 | buf[n] = 'Z'
228 | n++
229 | } else {
230 | var z int
231 | zone := offset / 60 // convert to minutes
232 | if zone < 0 {
233 | buf[n] = '-'
234 | z = -zone
235 | } else {
236 | buf[n] = '+'
237 | z = zone
238 | }
239 | buf[n+3] = ':'
240 | buf[n+5], z = byte(z%10)+'0', z/10
241 | buf[n+4], z = byte(z%06)+'0', z/6
242 | buf[n+2], z = byte(z%10)+'0', z/10
243 | buf[n+1], _ = byte(z%10)+'0', 0
244 | n += 6
245 | }
246 | // Finally, add the closing quote.
247 | // It's position depends on the presence
248 | // of the fractional seconds and/or the
249 | // timezone offset.
250 | buf[n] = '"'
251 |
252 | return append(dst, buf[:n+1]...)
253 | }
254 |
--------------------------------------------------------------------------------
/bench_test.go:
--------------------------------------------------------------------------------
1 | package jettison
2 |
3 | import (
4 | "bytes"
5 | "compress/gzip"
6 | "context"
7 | "encoding/json"
8 | "io/ioutil"
9 | "os"
10 | "strconv"
11 | "sync"
12 | "testing"
13 | "time"
14 |
15 | jsoniter "github.com/json-iterator/go"
16 | segmentj "github.com/segmentio/encoding/json"
17 | )
18 |
19 | var jsoniterCfg = jsoniter.ConfigCompatibleWithStandardLibrary
20 |
21 | type marshalFunc func(interface{}) ([]byte, error)
22 |
23 | type codeResponse struct {
24 | Tree *codeNode `json:"tree"`
25 | Username string `json:"username"`
26 | }
27 |
28 | type codeNode struct {
29 | Name string `json:"name"`
30 | Kids []*codeNode `json:"kids"`
31 | CLWeight float64 `json:"cl_weight"`
32 | Touches int `json:"touches"`
33 | MinT int64 `json:"min_t"`
34 | MaxT int64 `json:"max_t"`
35 | MeanT int64 `json:"mean_t"`
36 | }
37 |
38 | type simplePayload struct {
39 | St int `json:"st"`
40 | Sid int `json:"sid"`
41 | Tt string `json:"tt"`
42 | Gr int `json:"gr"`
43 | UUID string `json:"uuid"`
44 | IP string `json:"ip"`
45 | Ua string `json:"ua"`
46 | Tz int `json:"tz"`
47 | V bool `json:"v"`
48 | }
49 |
50 | func BenchmarkSimple(b *testing.B) {
51 | sp := &simplePayload{
52 | St: 1,
53 | Sid: 2,
54 | Tt: "TestString",
55 | Gr: 4,
56 | UUID: "8f9a65eb-4807-4d57-b6e0-bda5d62f1429",
57 | IP: "127.0.0.1",
58 | Ua: "Mozilla",
59 | Tz: 8,
60 | V: true,
61 | }
62 | benchMarshal(b, sp)
63 | }
64 |
65 | func BenchmarkComplex(b *testing.B) {
66 | benchMarshal(b, xx)
67 | }
68 |
69 | func BenchmarkCodeMarshal(b *testing.B) {
70 | // Taken from the encoding/json package.
71 | x := codeInit(b)
72 | benchMarshal(b, x)
73 | }
74 |
75 | func BenchmarkMap(b *testing.B) {
76 | m := map[string]int{
77 | "Cassianus": 1,
78 | "Ludovicus": 42,
79 | "Flavius": 8990,
80 | "Baldwin": 345,
81 | "Agapios": -43,
82 | "Liberia": 0,
83 | }
84 | benchMarshal(b, m)
85 | benchMarshalOpts(b, "jettison-nosort", m, UnsortedMap())
86 | }
87 |
88 | func BenchmarkSyncMap(b *testing.B) {
89 | if testing.Short() {
90 | b.SkipNow()
91 | }
92 | var sm sync.Map
93 |
94 | sm.Store("a", "foobar")
95 | sm.Store("b", 42)
96 | sm.Store("c", false)
97 | sm.Store("d", float64(3.14159))
98 |
99 | benchMarshalOpts(b, "sorted", m)
100 | benchMarshalOpts(b, "unsorted", m, UnsortedMap())
101 | }
102 |
103 | func BenchmarkDuration(b *testing.B) {
104 | if testing.Short() {
105 | b.SkipNow()
106 | }
107 | d := 1337 * time.Second
108 | benchMarshal(b, d)
109 | }
110 |
111 | func BenchmarkDurationFormat(b *testing.B) {
112 | if testing.Short() {
113 | b.SkipNow()
114 | }
115 | d := 32*time.Hour + 56*time.Minute + 25*time.Second
116 | for _, f := range []DurationFmt{
117 | DurationString,
118 | DurationMinutes,
119 | DurationSeconds,
120 | DurationMicroseconds,
121 | DurationMilliseconds,
122 | DurationNanoseconds,
123 | } {
124 | benchMarshalOpts(b, f.String(), d, DurationFormat(f))
125 | }
126 | }
127 |
128 | func BenchmarkTime(b *testing.B) {
129 | if testing.Short() {
130 | b.SkipNow()
131 | }
132 | t := time.Now()
133 | benchMarshal(b, t)
134 | }
135 |
136 | func BenchmarkStringEscaping(b *testing.B) {
137 | if testing.Short() {
138 | b.SkipNow()
139 | }
140 | s := "<ŁØŘ€M ƗƤŞỮM ĐØŁØŘ ŞƗŦ ΔM€Ŧ>"
141 |
142 | benchMarshalOpts(b, "Full", s)
143 | benchMarshalOpts(b, "NoUTF8Coercion", s, NoUTF8Coercion())
144 | benchMarshalOpts(b, "NoHTMLEscaping", s, NoHTMLEscaping())
145 | benchMarshalOpts(b, "NoUTF8Coercion/NoHTMLEscaping", s, NoUTF8Coercion(), NoHTMLEscaping())
146 | benchMarshalOpts(b, "NoStringEscaping", s, NoStringEscaping())
147 | }
148 |
149 | type (
150 | jsonbm struct{}
151 | textbm struct{}
152 | jetibm struct{}
153 | jetictxbm struct{}
154 | )
155 |
156 | var (
157 | loreumipsum = "Lorem ipsum dolor sit amet"
158 | loreumipsumQ = strconv.Quote(loreumipsum)
159 | )
160 |
161 | func (jsonbm) MarshalJSON() ([]byte, error) { return []byte(loreumipsumQ), nil }
162 | func (textbm) MarshalText() ([]byte, error) { return []byte(loreumipsum), nil }
163 | func (jetibm) AppendJSON(dst []byte) ([]byte, error) { return append(dst, loreumipsum...), nil }
164 |
165 | func (jetictxbm) AppendJSONContext(_ context.Context, dst []byte) ([]byte, error) {
166 | return append(dst, loreumipsum...), nil
167 | }
168 |
169 | func BenchmarkMarshaler(b *testing.B) {
170 | if testing.Short() {
171 | b.SkipNow()
172 | }
173 | for _, bb := range []struct {
174 | name string
175 | impl interface{}
176 | opts []Option
177 | }{
178 | {"json", jsonbm{}, nil},
179 | {"text", textbm{}, nil},
180 | {"append", jetibm{}, nil},
181 | {"appendctx", jetictxbm{}, []Option{WithContext(context.Background())}},
182 | } {
183 | benchMarshalOpts(b, bb.name, bb.impl, bb.opts...)
184 | }
185 | }
186 |
187 | func codeInit(b *testing.B) *codeResponse {
188 | f, err := os.Open("testdata/code.json.gz")
189 | if err != nil {
190 | b.Fatal(err)
191 | }
192 | defer f.Close()
193 | gz, err := gzip.NewReader(f)
194 | if err != nil {
195 | b.Fatal(err)
196 | }
197 | data, err := ioutil.ReadAll(gz)
198 | if err != nil {
199 | b.Fatal(err)
200 | }
201 | codeJSON := data
202 |
203 | var resp codeResponse
204 | if err := json.Unmarshal(codeJSON, &resp); err != nil {
205 | b.Fatalf("unmarshal code.json: %s", err)
206 | }
207 | if data, err = Marshal(&resp); err != nil {
208 | b.Fatalf("marshal code.json: %s", err)
209 | }
210 | if !bytes.Equal(data, codeJSON) {
211 | b.Logf("different lengths: %d - %d", len(data), len(codeJSON))
212 |
213 | for i := 0; i < len(data) && i < len(codeJSON); i++ {
214 | if data[i] != codeJSON[i] {
215 | b.Logf("re-marshal: changed at byte %d", i)
216 | b.Logf("old: %s", string(codeJSON[i-10:i+10]))
217 | b.Logf("new: %s", string(data[i-10:i+10]))
218 | break
219 | }
220 | }
221 | b.Fatal("re-marshal code.json: different result")
222 | }
223 | return &resp
224 | }
225 |
226 | func benchMarshalOpts(b *testing.B, name string, x interface{}, opts ...Option) {
227 | b.Run(name, func(b *testing.B) {
228 | b.ReportAllocs()
229 | for i := 0; i < b.N; i++ {
230 | bts, err := MarshalOpts(x, opts...)
231 | if err != nil {
232 | b.Fatal(err)
233 | }
234 | b.SetBytes(int64(len(bts)))
235 | }
236 | })
237 | }
238 |
239 | func benchMarshal(b *testing.B, x interface{}) {
240 | for _, bb := range []struct {
241 | name string
242 | fn marshalFunc
243 | }{
244 | {"standard", json.Marshal},
245 | {"jsoniter", jsoniterCfg.Marshal},
246 | {"segmentj", segmentj.Marshal},
247 | {"jettison", Marshal},
248 | } {
249 | bb := bb
250 | b.Run(bb.name, func(b *testing.B) {
251 | b.ReportAllocs()
252 | for i := 0; i < b.N; i++ {
253 | bts, err := bb.fn(x)
254 | if err != nil {
255 | b.Error(err)
256 | }
257 | b.SetBytes(int64(len(bts)))
258 | }
259 | })
260 | }
261 | }
262 |
--------------------------------------------------------------------------------
/options.go:
--------------------------------------------------------------------------------
1 | package jettison
2 |
3 | import (
4 | "context"
5 | "fmt"
6 | "time"
7 | )
8 |
9 | // defaultTimeLayout is the default layout used
10 | // to format time.Time values. This is compliant
11 | // with the ECMA specification and the JavaScript
12 | // Date's toJSON method implementation.
13 | const defaultTimeLayout = time.RFC3339Nano
14 |
15 | // defaultDurationFmt is the default format used
16 | // to encode time.Duration values.
17 | const defaultDurationFmt = DurationNanoseconds
18 |
19 | // An Option overrides the default encoding
20 | // behavior of the MarshalOpts function.
21 | type Option func(*encOpts)
22 |
23 | type bitmask uint64
24 |
25 | func (b *bitmask) set(f bitmask) { *b |= f }
26 | func (b bitmask) has(f bitmask) bool { return b&f != 0 }
27 |
28 | const (
29 | unixTime bitmask = 1 << iota
30 | unsortedMap
31 | rawByteSlice
32 | byteArrayAsString
33 | nilMapEmpty
34 | nilSliceEmpty
35 | noStringEscaping
36 | noHTMLEscaping
37 | noUTF8Coercion
38 | noCompact
39 | noNumberValidation
40 | )
41 |
42 | type encOpts struct {
43 | ctx context.Context
44 | timeLayout string
45 | durationFmt DurationFmt
46 | flags bitmask
47 | allowList stringSet
48 | denyList stringSet
49 | }
50 |
51 | func defaultEncOpts() encOpts {
52 | return encOpts{
53 | ctx: context.TODO(),
54 | timeLayout: defaultTimeLayout,
55 | durationFmt: defaultDurationFmt,
56 | }
57 | }
58 |
59 | func (eo *encOpts) apply(opts ...Option) {
60 | for _, opt := range opts {
61 | if opt != nil {
62 | opt(eo)
63 | }
64 | }
65 | }
66 |
67 | func (eo encOpts) validate() error {
68 | switch {
69 | case eo.ctx == nil:
70 | return fmt.Errorf("nil context")
71 | case eo.timeLayout == "":
72 | return fmt.Errorf("empty time layout")
73 | case !eo.durationFmt.valid():
74 | return fmt.Errorf("unknown duration format")
75 | default:
76 | return nil
77 | }
78 | }
79 |
80 | // isDeniedField returns whether a struct field
81 | // identified by its name must be skipped during
82 | // the encoding of a struct.
83 | func (eo encOpts) isDeniedField(name string) bool {
84 | // The deny-list has precedence and must
85 | // be checked first if it has entries.
86 | if eo.denyList != nil {
87 | if _, ok := eo.denyList[name]; ok {
88 | return true
89 | }
90 | }
91 | if eo.allowList != nil {
92 | if _, ok := eo.allowList[name]; !ok {
93 | return true
94 | }
95 | }
96 | return false
97 | }
98 |
99 | type stringSet map[string]struct{}
100 |
101 | func fieldListToSet(list []string) stringSet {
102 | m := make(stringSet)
103 | for _, f := range list {
104 | m[f] = struct{}{}
105 | }
106 | return m
107 | }
108 |
109 | // UnixTime configures an encoder to encode
110 | // time.Time values as Unix timestamps. This
111 | // option, when used, has precedence over any
112 | // time layout confiured.
113 | func UnixTime() Option {
114 | return func(o *encOpts) { o.flags.set(unixTime) }
115 | }
116 |
117 | // UnsortedMap configures an encoder to skip
118 | // the sort of map keys.
119 | func UnsortedMap() Option {
120 | return func(o *encOpts) { o.flags.set(unsortedMap) }
121 | }
122 |
123 | // RawByteSlice configures an encoder to
124 | // encode byte slices as raw JSON strings,
125 | // rather than bas64-encoded strings.
126 | func RawByteSlice() Option {
127 | return func(o *encOpts) { o.flags.set(rawByteSlice) }
128 | }
129 |
130 | // ByteArrayAsString configures an encoder
131 | // to encode byte arrays as raw JSON strings.
132 | func ByteArrayAsString() Option {
133 | return func(o *encOpts) { o.flags.set(byteArrayAsString) }
134 | }
135 |
136 | // NilMapEmpty configures an encoder to
137 | // encode nil Go maps as empty JSON objects,
138 | // rather than null.
139 | func NilMapEmpty() Option {
140 | return func(o *encOpts) { o.flags.set(nilMapEmpty) }
141 | }
142 |
143 | // NilSliceEmpty configures an encoder to
144 | // encode nil Go slices as empty JSON arrays,
145 | // rather than null.
146 | func NilSliceEmpty() Option {
147 | return func(o *encOpts) { o.flags.set(nilSliceEmpty) }
148 | }
149 |
150 | // NoStringEscaping configures an encoder to
151 | // disable string escaping.
152 | func NoStringEscaping() Option {
153 | return func(o *encOpts) { o.flags.set(noStringEscaping) }
154 | }
155 |
156 | // NoHTMLEscaping configures an encoder to
157 | // disable the escaping of problematic HTML
158 | // characters in JSON strings.
159 | func NoHTMLEscaping() Option {
160 | return func(o *encOpts) { o.flags.set(noHTMLEscaping) }
161 | }
162 |
163 | // NoUTF8Coercion configures an encoder to
164 | // disable UTF8 coercion that replace invalid
165 | // bytes with the Unicode replacement rune.
166 | func NoUTF8Coercion() Option {
167 | return func(o *encOpts) { o.flags.set(noUTF8Coercion) }
168 | }
169 |
170 | // NoNumberValidation configures an encoder to
171 | // disable the validation of json.Number values.
172 | func NoNumberValidation() Option {
173 | return func(o *encOpts) { o.flags.set(noNumberValidation) }
174 | }
175 |
176 | // NoCompact configures an encoder to disable
177 | // the compaction of the JSON output produced
178 | // by a call to MarshalJSON, or the content of
179 | // a json.RawMessage.
180 | // see https://golang.org/pkg/encoding/json/#Compact
181 | func NoCompact() Option {
182 | return func(o *encOpts) { o.flags.set(noCompact) }
183 | }
184 |
185 | // TimeLayout sets the time layout used to encode
186 | // time.Time values. The layout must be compatible
187 | // with the Golang time package specification.
188 | func TimeLayout(layout string) Option {
189 | return func(o *encOpts) {
190 | o.timeLayout = layout
191 | }
192 | }
193 |
194 | // DurationFormat sets the format used to encode
195 | // time.Duration values.
196 | func DurationFormat(format DurationFmt) Option {
197 | return func(o *encOpts) {
198 | o.durationFmt = format
199 | }
200 | }
201 |
202 | // WithContext sets the context to use during
203 | // encoding. The context will be passed in to
204 | // the AppendJSONContext method of types that
205 | // implement the AppendMarshalerCtx interface.
206 | func WithContext(ctx context.Context) Option {
207 | return func(o *encOpts) {
208 | o.ctx = ctx
209 | }
210 | }
211 |
212 | // AllowList sets the list of fields which are to be
213 | // considered when encoding a struct.
214 | // The fields are identified by the name that is
215 | // used in the final JSON payload.
216 | // See DenyFields documentation for more information
217 | // regarding joint use with this option.
218 | func AllowList(fields []string) Option {
219 | m := fieldListToSet(fields)
220 | return func(o *encOpts) {
221 | o.allowList = m
222 | }
223 | }
224 |
225 | // DenyList is similar to AllowList, but conversely
226 | // sets the list of fields to omit during encoding.
227 | // When used in conjunction with AllowList, denied
228 | // fields have precedence over the allowed fields.
229 | func DenyList(fields []string) Option {
230 | m := fieldListToSet(fields)
231 | return func(o *encOpts) {
232 | o.denyList = m
233 | }
234 | }
235 |
--------------------------------------------------------------------------------
/struct.go:
--------------------------------------------------------------------------------
1 | package jettison
2 |
3 | import (
4 | "bytes"
5 | "encoding/json"
6 | "reflect"
7 | "sort"
8 | "strings"
9 | "sync"
10 | "unicode"
11 | )
12 |
13 | const validChars = "!#$%&()*+-./:<=>?@[]^_{|}~ "
14 |
15 | var fieldsCache sync.Map // map[reflect.Type][]field
16 |
17 | type seq struct {
18 | offset uintptr
19 | indir bool
20 | }
21 |
22 | type field struct {
23 | typ reflect.Type
24 | name string
25 | keyNonEsc []byte
26 | keyEscHTML []byte
27 | index []int
28 | tag bool
29 | quoted bool
30 | omitEmpty bool
31 | omitNil bool
32 | omitNullMarshaler bool
33 | instr instruction
34 | empty emptyFunc
35 |
36 | // embedSeq represents the sequence of offsets
37 | // and indirections to follow to reach the field
38 | // through one or more anonymous fields.
39 | embedSeq []seq
40 | }
41 |
42 | type typeCount map[reflect.Type]int
43 |
44 | // byIndex sorts a list of fields by index sequence.
45 | type byIndex []field
46 |
47 | func (x byIndex) Len() int { return len(x) }
48 | func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
49 |
50 | func (x byIndex) Less(i, j int) bool {
51 | for k, xik := range x[i].index {
52 | if k >= len(x[j].index) {
53 | return false
54 | }
55 | if xik != x[j].index[k] {
56 | return xik < x[j].index[k]
57 | }
58 | }
59 | return len(x[i].index) < len(x[j].index)
60 | }
61 |
62 | // cachedFields is similar to structFields, but uses a
63 | // cache to avoid repeated work.
64 | func cachedFields(t reflect.Type) []field {
65 | if f, ok := fieldsCache.Load(t); ok {
66 | return f.([]field)
67 | }
68 | f, _ := fieldsCache.LoadOrStore(t, structFields(t))
69 | return f.([]field)
70 | }
71 |
72 | // structFields returns a list of fields that should be
73 | // encoded for the given struct type. The algorithm is
74 | // breadth-first search over the set of structs to include,
75 | // the top one and then any reachable anonymous structs.
76 | func structFields(t reflect.Type) []field {
77 | var (
78 | flds []field
79 | ccnt typeCount
80 | curr = []field{}
81 | next = []field{{typ: t}}
82 | ncnt = make(typeCount)
83 | seen = make(map[reflect.Type]bool)
84 | )
85 | for len(next) > 0 {
86 | curr, next = next, curr[:0]
87 | ccnt, ncnt = ncnt, make(map[reflect.Type]int)
88 |
89 | for _, f := range curr {
90 | if seen[f.typ] {
91 | continue
92 | }
93 | seen[f.typ] = true
94 | // Scan the type for fields to encode.
95 | flds, next = scanFields(f, flds, next, ccnt, ncnt)
96 | }
97 | }
98 | sortFields(flds)
99 |
100 | flds = filterByVisibility(flds)
101 |
102 | // Sort fields by their index sequence.
103 | sort.Sort(byIndex(flds))
104 |
105 | return flds
106 | }
107 |
108 | // sortFields sorts the fields by name, breaking ties
109 | // with depth, then whether the field name come from
110 | // the JSON tag, and finally with the index sequence.
111 | func sortFields(fields []field) {
112 | sort.Slice(fields, func(i int, j int) bool {
113 | x := fields
114 |
115 | if x[i].name != x[j].name {
116 | return x[i].name < x[j].name
117 | }
118 | if len(x[i].index) != len(x[j].index) {
119 | return len(x[i].index) < len(x[j].index)
120 | }
121 | if x[i].tag != x[j].tag {
122 | return x[i].tag
123 | }
124 | return byIndex(x).Less(i, j)
125 | })
126 | }
127 |
128 | // shouldEncodeField returns whether a struct
129 | // field should be encoded.
130 | func shouldEncodeField(sf reflect.StructField) bool {
131 | isUnexported := sf.PkgPath != ""
132 | if sf.Anonymous {
133 | t := sf.Type
134 | if t.Kind() == reflect.Ptr {
135 | t = t.Elem()
136 | }
137 | // Ignore embedded fields of unexported non-struct
138 | // types, but in the contrary, don't ignore embedded
139 | // fields of unexported struct types since they may
140 | // have exported fields.
141 | if isUnexported && t.Kind() != reflect.Struct {
142 | return false
143 | }
144 | } else if isUnexported {
145 | // Ignore unexported non-embedded fields.
146 | return false
147 | }
148 | return true
149 | }
150 |
151 | // isValidFieldName returns whether s is a valid
152 | // name and can be used as a JSON key to encode
153 | // a struct field.
154 | func isValidFieldName(s string) bool {
155 | if len(s) == 0 {
156 | return false
157 | }
158 | for _, c := range s {
159 | switch {
160 | case strings.ContainsRune(validChars, c):
161 | // Backslash and quote chars are reserved, but
162 | // otherwise any punctuation chars are allowed
163 | // in a tag name.
164 | case !unicode.IsLetter(c) && !unicode.IsDigit(c):
165 | return false
166 | }
167 | }
168 | return true
169 | }
170 |
171 | // filterByVisibility deletes all fields that are hidden
172 | // by the Go rules for embedded fields, except that fields
173 | // with JSON tags are promoted. The fields are sorted in
174 | // primary order of name, secondary order of field index
175 | // length.
176 | func filterByVisibility(fields []field) []field {
177 | ret := fields[:0]
178 |
179 | for adv, i := 0, 0; i < len(fields); i += adv {
180 | // One iteration per name.
181 | // Find the sequence of fields with the name
182 | // of this first field.
183 | fi := fields[i]
184 | for adv = 1; i+adv < len(fields); adv++ {
185 | fj := fields[i+adv]
186 | if fj.name != fi.name {
187 | break
188 | }
189 | }
190 | if adv == 1 {
191 | // Only one field with this name.
192 | ret = append(ret, fi)
193 | continue
194 | }
195 | // More than one field with the same name are
196 | // present, delete hidden fields by choosing
197 | // the dominant field that survives.
198 | if dominant, ok := dominantField(fields[i : i+adv]); ok {
199 | ret = append(ret, dominant)
200 | }
201 | }
202 | return ret
203 | }
204 |
205 | func typeByIndex(t reflect.Type, index []int) reflect.Type {
206 | for _, i := range index {
207 | if t.Kind() == reflect.Ptr {
208 | t = t.Elem()
209 | }
210 | t = t.Field(i).Type
211 | }
212 | return t
213 | }
214 |
215 | // dominantField looks through the fields, all of which
216 | // are known to have the same name, to find the single
217 | // field that dominates the others using Go's embedding
218 | // rules, modified by the presence of JSON tags. If there
219 | // are multiple top-level fields, it returns false. This
220 | // condition is an error in Go, and all fields are skipped.
221 | func dominantField(fields []field) (field, bool) {
222 | if len(fields) > 1 &&
223 | len(fields[0].index) == len(fields[1].index) &&
224 | fields[0].tag == fields[1].tag {
225 | return field{}, false
226 | }
227 | return fields[0], true
228 | }
229 |
230 | func scanFields(f field, fields, next []field, cnt, ncnt typeCount) ([]field, []field) {
231 | var escBuf bytes.Buffer
232 |
233 | for i := 0; i < f.typ.NumField(); i++ {
234 | sf := f.typ.Field(i)
235 |
236 | if !shouldEncodeField(sf) {
237 | continue
238 | }
239 | tag := sf.Tag.Get("json")
240 | if tag == "-" {
241 | continue
242 | }
243 | // Parse name and options from the content
244 | // of the JSON tag.
245 | name, opts := parseTag(tag)
246 | if !isValidFieldName(name) {
247 | name = ""
248 | }
249 | index := make([]int, len(f.index)+1)
250 | copy(index, f.index)
251 | index[len(f.index)] = i
252 |
253 | typ := sf.Type
254 | isPtr := typ.Kind() == reflect.Ptr
255 | if typ.Name() == "" && isPtr {
256 | typ = typ.Elem()
257 | }
258 | // If the field is a named embedded struct or a
259 | // simple field, record it and its index sequence.
260 | if name != "" || !sf.Anonymous || typ.Kind() != reflect.Struct {
261 | tagged := name != ""
262 | // If a name is not present in the tag,
263 | // use the struct field's name instead.
264 | if name == "" {
265 | name = sf.Name
266 | }
267 | // Build HTML escaped field key.
268 | escBuf.Reset()
269 | _, _ = escBuf.WriteString(`"`)
270 | json.HTMLEscape(&escBuf, []byte(name))
271 | _, _ = escBuf.WriteString(`":`)
272 |
273 | nf := field{
274 | typ: typ,
275 | name: name,
276 | tag: tagged,
277 | index: index,
278 | omitEmpty: opts.Contains("omitempty"),
279 | omitNil: opts.Contains("omitnil"),
280 | quoted: opts.Contains("string") && isBasicType(typ),
281 | keyNonEsc: []byte(`"` + name + `":`),
282 | keyEscHTML: append([]byte(nil), escBuf.Bytes()...), // copy
283 | embedSeq: append(f.embedSeq[:0:0], f.embedSeq...), // clone
284 | }
285 | // Add final offset to sequences.
286 | nf.embedSeq = append(nf.embedSeq, seq{sf.Offset, false})
287 | fields = append(fields, nf)
288 |
289 | if cnt[f.typ] > 1 {
290 | // If there were multiple instances, add a
291 | // second, so that the annihilation code will
292 | // see a duplicate. It only cares about the
293 | // distinction between 1 or 2, so don't bother
294 | // generating any more copies.
295 | fields = append(fields, fields[len(fields)-1])
296 | }
297 | continue
298 | }
299 | // Record unnamed embedded struct
300 | // to be scanned in the next round.
301 | ncnt[typ]++
302 | if ncnt[typ] == 1 {
303 | next = append(next, field{
304 | typ: typ,
305 | name: typ.Name(),
306 | index: index,
307 | embedSeq: append(f.embedSeq, seq{sf.Offset, isPtr}),
308 | })
309 | }
310 | }
311 | return fields, next
312 | }
313 |
--------------------------------------------------------------------------------
/example_test.go:
--------------------------------------------------------------------------------
1 | package jettison_test
2 |
3 | import (
4 | "context"
5 | "encoding/json"
6 | "fmt"
7 | "log"
8 | "os"
9 | "strconv"
10 | "time"
11 |
12 | "github.com/wI2L/jettison"
13 | )
14 |
15 | func ExampleMarshal() {
16 | type X struct {
17 | A string `json:"a"`
18 | B int64 `json:"b"`
19 | C []string `json:"colors"`
20 | }
21 | x := X{
22 | A: "Loreum",
23 | B: -42,
24 | C: []string{"blue", "white", "red"},
25 | }
26 | b, err := jettison.Marshal(x)
27 | if err != nil {
28 | log.Fatal(err)
29 | }
30 | os.Stdout.Write(b)
31 | // Output:
32 | // {"a":"Loreum","b":-42,"colors":["blue","white","red"]}
33 | }
34 |
35 | func ExampleAppend() {
36 | type X struct {
37 | A bool `json:"a"`
38 | B uint32 `json:"b"`
39 | C map[string]string `json:"users"`
40 | }
41 | x := X{
42 | A: true,
43 | B: 42,
44 | C: map[string]string{
45 | "bob": "admin",
46 | "jerry": "user",
47 | },
48 | }
49 | buf, err := jettison.Append([]byte(nil), x)
50 | if err != nil {
51 | log.Fatal(err)
52 | }
53 | os.Stdout.Write(buf)
54 | // Output:
55 | // {"a":true,"b":42,"users":{"bob":"admin","jerry":"user"}}
56 | }
57 |
58 | func ExampleAppendOpts() {
59 | for _, v := range []interface{}{
60 | nil, 2 * time.Second,
61 | } {
62 | buf, err := jettison.AppendOpts([]byte(nil), v,
63 | jettison.DurationFormat(jettison.DurationString),
64 | )
65 | if err != nil {
66 | log.Fatal(err)
67 | }
68 | fmt.Printf("%s\n", string(buf))
69 | }
70 | // Output:
71 | // null
72 | // "2s"
73 | }
74 |
75 | type Animal int
76 |
77 | const (
78 | Unknown Animal = iota
79 | Gopher
80 | Zebra
81 | )
82 |
83 | // AppendJSON implements the jettison.AppendMarshaler interface.
84 | func (a Animal) AppendJSON(dst []byte) ([]byte, error) {
85 | var s string
86 | switch a {
87 | default:
88 | s = "unknown"
89 | case Gopher:
90 | s = "gopher"
91 | case Zebra:
92 | s = "zebra"
93 | }
94 | dst = append(dst, strconv.Quote(s)...)
95 | return dst, nil
96 | }
97 |
98 | func Example_customMarshaler() {
99 | zoo := []Animal{
100 | Unknown,
101 | Zebra,
102 | Gopher,
103 | }
104 | b, err := jettison.Marshal(zoo)
105 | if err != nil {
106 | log.Fatal(err)
107 | }
108 | os.Stdout.Write(b)
109 | // Output:
110 | // ["unknown","zebra","gopher"]
111 | }
112 |
113 | func ExampleRawByteSlice() {
114 | bs := []byte("Loreum Ipsum")
115 |
116 | for _, opt := range []jettison.Option{
117 | nil, jettison.RawByteSlice(),
118 | } {
119 | b, err := jettison.MarshalOpts(bs, opt)
120 | if err != nil {
121 | log.Fatal(err)
122 | }
123 | fmt.Printf("%s\n", string(b))
124 | }
125 | // Output:
126 | // "TG9yZXVtIElwc3Vt"
127 | // "Loreum Ipsum"
128 | }
129 |
130 | func ExampleByteArrayAsString() {
131 | b1 := [6]byte{'L', 'o', 'r', 'e', 'u', 'm'}
132 | b2 := [6]*byte{&b1[0], &b1[1], &b1[2], &b1[3], &b1[4], &b1[5]}
133 |
134 | for _, opt := range []jettison.Option{
135 | nil, jettison.ByteArrayAsString(),
136 | } {
137 | for _, v := range []interface{}{b1, b2} {
138 | b, err := jettison.MarshalOpts(v, opt)
139 | if err != nil {
140 | log.Fatal(err)
141 | }
142 | fmt.Printf("%s\n", string(b))
143 | }
144 | }
145 | // Output:
146 | // [76,111,114,101,117,109]
147 | // [76,111,114,101,117,109]
148 | // "Loreum"
149 | // [76,111,114,101,117,109]
150 | }
151 |
152 | func ExampleNilMapEmpty() {
153 | type X struct {
154 | M1 map[string]int
155 | M2 map[int]string
156 | }
157 | x := X{
158 | M1: map[string]int{},
159 | M2: nil,
160 | }
161 | for _, opt := range []jettison.Option{
162 | nil, jettison.NilMapEmpty(),
163 | } {
164 | b, err := jettison.MarshalOpts(x, opt)
165 | if err != nil {
166 | log.Fatal(err)
167 | }
168 | fmt.Printf("%s\n", string(b))
169 | }
170 | // Output:
171 | // {"M1":{},"M2":null}
172 | // {"M1":{},"M2":{}}
173 | }
174 |
175 | func ExampleNilSliceEmpty() {
176 | type X struct {
177 | S1 []int
178 | S2 []string
179 | }
180 | x := X{
181 | S1: []int{},
182 | S2: nil,
183 | }
184 | for _, opt := range []jettison.Option{
185 | nil, jettison.NilSliceEmpty(),
186 | } {
187 | b, err := jettison.MarshalOpts(x, opt)
188 | if err != nil {
189 | log.Fatal(err)
190 | }
191 | fmt.Printf("%s\n", string(b))
192 | }
193 | // Output:
194 | // {"S1":[],"S2":null}
195 | // {"S1":[],"S2":[]}
196 | }
197 |
198 | func ExampleUnixTime() {
199 | t := time.Date(2024, time.December, 24, 12, 24, 42, 0, time.UTC)
200 |
201 | b, err := jettison.MarshalOpts(t, jettison.UnixTime())
202 | if err != nil {
203 | log.Fatal(err)
204 | }
205 | os.Stdout.Write(b)
206 | // Output:
207 | // 1735043082
208 | }
209 |
210 | func ExampleTimeLayout() {
211 | t := time.Date(2042, time.July, 25, 16, 42, 24, 67850, time.UTC)
212 |
213 | locs := []*time.Location{
214 | time.UTC, time.FixedZone("WTF", 666), time.FixedZone("LOL", -4242),
215 | }
216 | for _, layout := range []string{
217 | time.RFC3339,
218 | time.RFC822,
219 | time.RFC1123Z,
220 | time.RFC3339Nano, // default
221 | } {
222 | for _, loc := range locs {
223 | b, err := jettison.MarshalOpts(t.In(loc), jettison.TimeLayout(layout))
224 | if err != nil {
225 | log.Fatal(err)
226 | }
227 | fmt.Printf("%s\n", string(b))
228 | }
229 | }
230 | // Output:
231 | // "2042-07-25T16:42:24Z"
232 | // "2042-07-25T16:53:30+00:11"
233 | // "2042-07-25T15:31:42-01:10"
234 | // "25 Jul 42 16:42 UTC"
235 | // "25 Jul 42 16:53 WTF"
236 | // "25 Jul 42 15:31 LOL"
237 | // "Fri, 25 Jul 2042 16:42:24 +0000"
238 | // "Fri, 25 Jul 2042 16:53:30 +0011"
239 | // "Fri, 25 Jul 2042 15:31:42 -0110"
240 | // "2042-07-25T16:42:24.00006785Z"
241 | // "2042-07-25T16:53:30.00006785+00:11"
242 | // "2042-07-25T15:31:42.00006785-01:10"
243 | }
244 |
245 | func ExampleDurationFormat() {
246 | d := 1*time.Hour + 3*time.Minute + 2*time.Second + 66*time.Millisecond
247 |
248 | for _, format := range []jettison.DurationFmt{
249 | jettison.DurationString,
250 | jettison.DurationMinutes,
251 | jettison.DurationSeconds,
252 | jettison.DurationMilliseconds,
253 | jettison.DurationMicroseconds,
254 | jettison.DurationNanoseconds,
255 | } {
256 | b, err := jettison.MarshalOpts(d, jettison.DurationFormat(format))
257 | if err != nil {
258 | log.Fatal(err)
259 | }
260 | fmt.Printf("%s\n", string(b))
261 | }
262 | // Output:
263 | // "1h3m2.066s"
264 | // 63.03443333333333
265 | // 3782.066
266 | // 3782066
267 | // 3782066000
268 | // 3782066000000
269 | }
270 |
271 | func ExampleUnsortedMap() {
272 | m := map[int]string{
273 | 3: "three",
274 | 1: "one",
275 | 2: "two",
276 | }
277 | b, err := jettison.MarshalOpts(m, jettison.UnsortedMap())
278 | if err != nil {
279 | log.Fatal(err)
280 | }
281 | var sorted map[int]string
282 | if err := json.Unmarshal(b, &sorted); err != nil {
283 | log.Fatal(err)
284 | }
285 | b, err = jettison.Marshal(sorted)
286 | if err != nil {
287 | log.Fatal(err)
288 | }
289 | os.Stdout.Write(b)
290 | // Output:
291 | // {"1":"one","2":"two","3":"three"}
292 | }
293 |
294 | func ExampleNoCompact() {
295 | rm := json.RawMessage(`{ "a":"b" }`)
296 | for _, opt := range []jettison.Option{
297 | nil, jettison.NoCompact(),
298 | } {
299 | b, err := jettison.MarshalOpts(rm, opt)
300 | if err != nil {
301 | log.Fatal(err)
302 | }
303 | fmt.Printf("%s\n", string(b))
304 | }
305 | // Output:
306 | // {"a":"b"}
307 | // { "a":"b" }
308 | }
309 |
310 | func ExampleAllowList() {
311 | type Z struct {
312 | Omega int `json:"ω"`
313 | }
314 | type Y struct {
315 | Pi string `json:"π"`
316 | }
317 | type X struct {
318 | Z Z `json:"Z"`
319 | Alpha string `json:"α"`
320 | Beta string `json:"β"`
321 | Gamma string
322 | Y
323 | }
324 | x := X{
325 | Z: Z{Omega: 42},
326 | Alpha: "1",
327 | Beta: "2",
328 | Gamma: "3",
329 | Y: Y{Pi: "4"},
330 | }
331 | for _, opt := range []jettison.Option{
332 | nil, jettison.AllowList([]string{"Z", "β", "Gamma", "π"}),
333 | } {
334 | b, err := jettison.MarshalOpts(x, opt)
335 | if err != nil {
336 | log.Fatal(err)
337 | }
338 | fmt.Printf("%s\n", string(b))
339 | }
340 | // Output:
341 | // {"Z":{"ω":42},"α":"1","β":"2","Gamma":"3","π":"4"}
342 | // {"Z":{},"β":"2","Gamma":"3","π":"4"}
343 | }
344 |
345 | func ExampleDenyList() {
346 | type X struct {
347 | A int `json:"aaAh"`
348 | B bool `json:"buzz"`
349 | C string
350 | D uint
351 | }
352 | x := X{
353 | A: -42,
354 | B: true,
355 | C: "Loreum",
356 | D: 42,
357 | }
358 | for _, opt := range []jettison.Option{
359 | nil, jettison.DenyList([]string{"buzz", "D"}),
360 | } {
361 | b, err := jettison.MarshalOpts(x, opt)
362 | if err != nil {
363 | log.Fatal(err)
364 | }
365 | fmt.Printf("%s\n", string(b))
366 | }
367 | // Output:
368 | // {"aaAh":-42,"buzz":true,"C":"Loreum","D":42}
369 | // {"aaAh":-42,"C":"Loreum"}
370 | }
371 |
372 | type (
373 | secret string
374 | ctxKey string
375 | )
376 |
377 | const obfuscateKey = ctxKey("_obfuscate_")
378 |
379 | // AppendJSONContext implements the jettison.AppendMarshalerCtx interface.
380 | func (s secret) AppendJSONContext(ctx context.Context, dst []byte) ([]byte, error) {
381 | out := string(s)
382 | if v := ctx.Value(obfuscateKey); v != nil {
383 | if hide, ok := v.(bool); ok && hide {
384 | out = "**__SECRET__**"
385 | }
386 | }
387 | dst = append(dst, strconv.Quote(out)...)
388 | return dst, nil
389 | }
390 |
391 | func ExampleWithContext() {
392 | sec := secret("v3ryS3nSitiv3P4ssWord")
393 |
394 | b, err := jettison.Marshal(sec)
395 | if err != nil {
396 | log.Fatal(err)
397 | }
398 | fmt.Printf("%s\n", string(b))
399 |
400 | ctx := context.WithValue(context.Background(),
401 | obfuscateKey, true,
402 | )
403 | b, err = jettison.MarshalOpts(sec, jettison.WithContext(ctx))
404 | if err != nil {
405 | log.Fatal(err)
406 | }
407 | fmt.Printf("%s\n", string(b))
408 | // Output:
409 | // "v3ryS3nSitiv3P4ssWord"
410 | // "**__SECRET__**"
411 | }
412 |
--------------------------------------------------------------------------------
/instruction.go:
--------------------------------------------------------------------------------
1 | package jettison
2 |
3 | import (
4 | "fmt"
5 | "reflect"
6 | "sync"
7 | "sync/atomic"
8 | "unsafe"
9 | )
10 |
11 | var (
12 | instrCachePtr unsafe.Pointer // *instrCache
13 | structInstrCache sync.Map // map[string]instruction
14 | )
15 |
16 | // An instruction appends the JSON representation
17 | // of a value pointed by the unsafe.Pointer p to
18 | // dst and returns the extended buffer.
19 | type instruction func(unsafe.Pointer, []byte, encOpts) ([]byte, error)
20 |
21 | // instrCache is an eventually consistent cache that
22 | // maps Go type definitions to dynamically generated
23 | // instructions. The key is unsafe.Pointer instead of
24 | // reflect.Type to improve lookup performance.
25 | type instrCache map[unsafe.Pointer]instruction
26 |
27 | func typeID(t reflect.Type) unsafe.Pointer {
28 | return unpackEface(t).word
29 | }
30 |
31 | // cachedInstr returns an instruction to encode the
32 | // given type from a cache, or create one on the fly.
33 | func cachedInstr(t reflect.Type) instruction {
34 | id := typeID(t)
35 |
36 | if instr, ok := loadInstr(id); ok {
37 | return instr
38 | }
39 | canAddr := t.Kind() == reflect.Ptr
40 |
41 | // canAddr indicates if the input value is addressable.
42 | // At this point, we only need to know if the value is
43 | // a pointer, the others instructions will handle that
44 | // themselves for their type, or pass-by the value.
45 | instr := newInstruction(t, canAddr, false)
46 | if isInlined(t) {
47 | instr = wrapInlineInstr(instr)
48 | }
49 | storeInstr(id, instr, loadCache())
50 |
51 | return instr
52 | }
53 |
54 | func loadCache() instrCache {
55 | p := atomic.LoadPointer(&instrCachePtr)
56 | return *(*instrCache)(unsafe.Pointer(&p))
57 | }
58 |
59 | func loadInstr(id unsafe.Pointer) (instruction, bool) {
60 | cache := loadCache()
61 | instr, ok := cache[id]
62 | return instr, ok
63 | }
64 |
65 | func storeInstr(key unsafe.Pointer, instr instruction, cache instrCache) {
66 | newCache := make(instrCache, len(cache)+1)
67 |
68 | // Clone the current cache and add the
69 | // new instruction.
70 | for k, v := range cache {
71 | newCache[k] = v
72 | }
73 | newCache[key] = instr
74 |
75 | atomic.StorePointer(
76 | &instrCachePtr,
77 | *(*unsafe.Pointer)(unsafe.Pointer(&newCache)),
78 | )
79 | }
80 |
81 | // newInstruction returns an instruction to encode t.
82 | // canAddr and quoted respectively indicates if the
83 | // value to encode is addressable and must be enclosed
84 | // with double-quote character in the output.
85 | func newInstruction(t reflect.Type, canAddr, quoted bool) instruction {
86 | // Go types must be checked first, because a Duration
87 | // is an int64, json.Number is a string, and both would
88 | // be interpreted as a basic type. Also, the time.Time
89 | // type implements the TextMarshaler interface, but we
90 | // want to use a special instruction instead.
91 | if ins := newGoTypeInstr(t); ins != nil {
92 | return ins
93 | }
94 | if ins := newMarshalerTypeInstr(t, canAddr); ins != nil {
95 | return ins
96 | }
97 | if ins := newBasicTypeInstr(t, quoted); ins != nil {
98 | return ins
99 | }
100 | switch t.Kind() {
101 | case reflect.Interface:
102 | return encodeInterface
103 | case reflect.Struct:
104 | return newStructInstr(t, canAddr)
105 | case reflect.Map:
106 | return newMapInstr(t)
107 | case reflect.Slice:
108 | return newSliceInstr(t)
109 | case reflect.Array:
110 | return newArrayInstr(t, canAddr)
111 | case reflect.Ptr:
112 | return newPtrInstr(t, quoted)
113 | }
114 | return newUnsupportedTypeInstr(t)
115 | }
116 |
117 | func newGoTypeInstr(t reflect.Type) instruction {
118 | switch t {
119 | case syncMapType:
120 | return encodeSyncMap
121 | case timeTimeType:
122 | return encodeTime
123 | case timeDurationType:
124 | return encodeDuration
125 | case jsonNumberType:
126 | return encodeNumber
127 | case jsonRawMessageType:
128 | return encodeRawMessage
129 | default:
130 | return nil
131 | }
132 | }
133 |
134 | // newMarshalerTypeInstr returns an instruction to handle
135 | // a type that implement one of the Marshaler, MarshalerCtx,
136 | // json.Marshal, encoding.TextMarshaler interfaces.
137 | func newMarshalerTypeInstr(t reflect.Type, canAddr bool) instruction {
138 | isPtr := t.Kind() == reflect.Ptr
139 | ptrTo := reflect.PtrTo(t)
140 |
141 | switch {
142 | case t.Implements(appendMarshalerCtxType):
143 | return newAppendMarshalerCtxInstr(t, false)
144 | case !isPtr && canAddr && ptrTo.Implements(appendMarshalerCtxType):
145 | return newAppendMarshalerCtxInstr(t, true)
146 | case t.Implements(appendMarshalerType):
147 | return newAppendMarshalerInstr(t, false)
148 | case !isPtr && canAddr && ptrTo.Implements(appendMarshalerType):
149 | return newAppendMarshalerInstr(t, true)
150 | case t.Implements(jsonMarshalerType):
151 | return newJSONMarshalerInstr(t, false)
152 | case !isPtr && canAddr && ptrTo.Implements(jsonMarshalerType):
153 | return newJSONMarshalerInstr(t, true)
154 | case t.Implements(textMarshalerType):
155 | return newTextMarshalerInstr(t, false)
156 | case !isPtr && canAddr && ptrTo.Implements(textMarshalerType):
157 | return newTextMarshalerInstr(t, true)
158 | default:
159 | return nil
160 | }
161 | }
162 |
163 | func newBasicTypeInstr(t reflect.Type, quoted bool) instruction {
164 | var ins instruction
165 |
166 | switch t.Kind() {
167 | case reflect.Bool:
168 | ins = encodeBool
169 | case reflect.String:
170 | return newStringInstr(quoted)
171 | case reflect.Int:
172 | ins = encodeInt
173 | case reflect.Int8:
174 | ins = encodeInt8
175 | case reflect.Int16:
176 | ins = encodeInt16
177 | case reflect.Int32:
178 | ins = encodeInt32
179 | case reflect.Int64:
180 | ins = encodeInt64
181 | case reflect.Uint:
182 | ins = encodeUint
183 | case reflect.Uint8:
184 | ins = encodeUint8
185 | case reflect.Uint16:
186 | ins = encodeUint16
187 | case reflect.Uint32:
188 | ins = encodeUint32
189 | case reflect.Uint64:
190 | ins = encodeUint64
191 | case reflect.Uintptr:
192 | ins = encodeUintptr
193 | case reflect.Float32:
194 | ins = encodeFloat32
195 | case reflect.Float64:
196 | ins = encodeFloat64
197 | default:
198 | return nil
199 | }
200 | if quoted {
201 | return wrapQuotedInstr(ins)
202 | }
203 | return ins
204 | }
205 |
206 | func newStringInstr(quoted bool) instruction {
207 | if quoted {
208 | return encodeQuotedString
209 | }
210 | return encodeString
211 | }
212 |
213 | func newUnsupportedTypeInstr(t reflect.Type) instruction {
214 | return func(p unsafe.Pointer, dst []byte, opts encOpts) ([]byte, error) {
215 | return dst, &UnsupportedTypeError{t}
216 | }
217 | }
218 |
219 | func newPtrInstr(t reflect.Type, quoted bool) instruction {
220 | e := t.Elem()
221 | i := newInstruction(e, true, quoted)
222 | return func(p unsafe.Pointer, dst []byte, opts encOpts) ([]byte, error) {
223 | return encodePointer(p, dst, opts, i)
224 | }
225 | }
226 |
227 | func newAppendMarshalerCtxInstr(t reflect.Type, hasPtr bool) instruction {
228 | return func(p unsafe.Pointer, dst []byte, opts encOpts) ([]byte, error) {
229 | return encodeMarshaler(p, dst, opts, t, hasPtr, encodeAppendMarshalerCtx)
230 | }
231 | }
232 |
233 | func newAppendMarshalerInstr(t reflect.Type, hasPtr bool) instruction {
234 | return func(p unsafe.Pointer, dst []byte, opts encOpts) ([]byte, error) {
235 | return encodeMarshaler(p, dst, opts, t, hasPtr, encodeAppendMarshaler)
236 | }
237 | }
238 |
239 | func newJSONMarshalerInstr(t reflect.Type, hasPtr bool) instruction {
240 | return func(p unsafe.Pointer, dst []byte, opts encOpts) ([]byte, error) {
241 | return encodeMarshaler(p, dst, opts, t, hasPtr, encodeJSONMarshaler)
242 | }
243 | }
244 |
245 | func newTextMarshalerInstr(t reflect.Type, hasPtr bool) instruction {
246 | return func(p unsafe.Pointer, dst []byte, opts encOpts) ([]byte, error) {
247 | return encodeMarshaler(p, dst, opts, t, hasPtr, encodeTextMarshaler)
248 | }
249 | }
250 |
251 | func newStructInstr(t reflect.Type, canAddr bool) instruction {
252 | id := fmt.Sprintf("%p-%t", typeID(t), canAddr)
253 |
254 | if instr, ok := structInstrCache.Load(id); ok {
255 | return instr.(instruction)
256 | }
257 | // To deal with recursive types, populate the
258 | // instructions cache with an indirect func
259 | // before we build it. This type waits on the
260 | // real instruction (ins) to be ready and then
261 | // calls it. This indirect function is only
262 | // used for recursive types.
263 | var (
264 | wg sync.WaitGroup
265 | ins instruction
266 | )
267 | wg.Add(1)
268 | i, loaded := structInstrCache.LoadOrStore(id,
269 | instruction(func(p unsafe.Pointer, dst []byte, opts encOpts) ([]byte, error) {
270 | wg.Wait() // few ns/op overhead
271 | return ins(p, dst, opts)
272 | }),
273 | )
274 | if loaded {
275 | return i.(instruction)
276 | }
277 | // Generate the real instruction and replace
278 | // the indirect func with it.
279 | ins = newStructFieldsInstr(t, canAddr)
280 | wg.Done()
281 | structInstrCache.Store(id, ins)
282 |
283 | return ins
284 | }
285 |
286 | func newStructFieldsInstr(t reflect.Type, canAddr bool) instruction {
287 | if t.NumField() == 0 {
288 | // Fast path for empty struct.
289 | return func(_ unsafe.Pointer, dst []byte, opts encOpts) ([]byte, error) {
290 | return append(dst, "{}"...), nil
291 | }
292 | }
293 | var (
294 | flds = cachedFields(t)
295 | dupl = append(flds[:0:0], flds...) // clone
296 | )
297 | for i := range dupl {
298 | f := &dupl[i]
299 | ftyp := typeByIndex(t, f.index)
300 | etyp := ftyp
301 |
302 | if etyp.Kind() == reflect.Ptr {
303 | etyp = etyp.Elem()
304 | }
305 | if f.omitNil && (ftyp.Implements(jsonMarshalerType) || reflect.PtrTo(ftyp).Implements(jsonMarshalerType)) {
306 | f.omitNullMarshaler = true
307 | }
308 | if !isNilable(ftyp) {
309 | // Disable the omitnil option, to
310 | // eliminate a check at runtime.
311 | f.omitNil = false
312 | }
313 | // Generate instruction and empty func of the field.
314 | // Only strings, floats, integers, and booleans
315 | // types can be quoted.
316 | f.instr = newInstruction(ftyp, canAddr, f.quoted && isBasicType(etyp))
317 | if f.omitEmpty {
318 | f.empty = cachedEmptyFuncOf(ftyp)
319 | }
320 | }
321 | return func(p unsafe.Pointer, dst []byte, opts encOpts) ([]byte, error) {
322 | return encodeStruct(p, dst, opts, dupl)
323 | }
324 | }
325 |
326 | func newArrayInstr(t reflect.Type, canAddr bool) instruction {
327 | var (
328 | etyp = t.Elem()
329 | size = etyp.Size()
330 | isba = false
331 | )
332 | // Array elements are addressable if the
333 | // array itself is addressable.
334 | ins := newInstruction(etyp, canAddr, false)
335 |
336 | // Byte arrays does not encode as a string
337 | // by default, this behavior is defined by
338 | // the encoder's options during marshaling.
339 | if etyp.Kind() == reflect.Uint8 {
340 | pe := reflect.PtrTo(etyp)
341 | if !pe.Implements(jsonMarshalerType) && !pe.Implements(textMarshalerType) {
342 | isba = true
343 | }
344 | }
345 | return func(p unsafe.Pointer, dst []byte, opts encOpts) ([]byte, error) {
346 | return encodeArray(p, dst, opts, ins, size, t.Len(), isba)
347 | }
348 | }
349 |
350 | func newSliceInstr(t reflect.Type) instruction {
351 | etyp := t.Elem()
352 |
353 | if etyp.Kind() == reflect.Uint8 {
354 | pe := reflect.PtrTo(etyp)
355 | if !pe.Implements(jsonMarshalerType) && !pe.Implements(textMarshalerType) {
356 | return encodeByteSlice
357 | }
358 | }
359 | // Slice elements are always addressable.
360 | // see https://golang.org/pkg/reflect/#Value.CanAddr
361 | // for reference.
362 | var (
363 | ins = newInstruction(etyp, true, false)
364 | size = etyp.Size()
365 | )
366 | return func(p unsafe.Pointer, dst []byte, opts encOpts) ([]byte, error) {
367 | return encodeSlice(p, dst, opts, ins, size)
368 | }
369 | }
370 |
371 | func newMapInstr(t reflect.Type) instruction {
372 | var (
373 | ki instruction
374 | vi instruction
375 | )
376 | kt := t.Key()
377 | et := t.Elem()
378 |
379 | if !isString(kt) && !isInteger(kt) && !kt.Implements(textMarshalerType) {
380 | return newUnsupportedTypeInstr(t)
381 | }
382 | // The standard library has a strict precedence order
383 | // for map key types, defined by the documentation of
384 | // the json.Marshal function. That's why we bypass the
385 | // newTypeInstr function if key type is string.
386 | if isString(kt) {
387 | ki = encodeString
388 | } else {
389 | ki = newInstruction(kt, false, false)
390 | }
391 | // Wrap the key instruction for types that
392 | // do not encode with quotes by default.
393 | if !isString(kt) && !kt.Implements(textMarshalerType) {
394 | ki = wrapQuotedInstr(ki)
395 | }
396 | // See issue golang.org/issue/33675 for reference.
397 | if kt.Implements(textMarshalerType) && kt.Kind() == reflect.Ptr {
398 | ki = wrapTextMarshalerNilCheck(ki)
399 | }
400 | vi = newInstruction(et, false, false)
401 |
402 | return func(p unsafe.Pointer, dst []byte, opts encOpts) ([]byte, error) {
403 | return encodeMap(p, dst, opts, t, ki, vi)
404 | }
405 | }
406 |
407 | func wrapInlineInstr(ins instruction) instruction {
408 | return func(p unsafe.Pointer, dst []byte, opts encOpts) ([]byte, error) {
409 | return ins(noescape(unsafe.Pointer(&p)), dst, opts)
410 | }
411 | }
412 |
413 | func wrapQuotedInstr(ins instruction) instruction {
414 | return func(p unsafe.Pointer, dst []byte, opts encOpts) ([]byte, error) {
415 | dst = append(dst, '"')
416 | var err error
417 | dst, err = ins(p, dst, opts)
418 | if err == nil {
419 | dst = append(dst, '"')
420 | }
421 | return dst, err
422 | }
423 | }
424 |
425 | func wrapTextMarshalerNilCheck(ins instruction) instruction {
426 | return func(p unsafe.Pointer, dst []byte, opts encOpts) ([]byte, error) {
427 | if *(*unsafe.Pointer)(p) == nil {
428 | return append(dst, `""`...), nil
429 | }
430 | return ins(p, dst, opts)
431 | }
432 | }
433 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | Jettison
2 | 
Jettison is a fast and flexible JSON encoder for the Go programming language, inspired by bet365/jingo, with a richer features set, aiming at 100% compatibility with the standard library.
3 |
4 | 
5 | 
6 | 
7 | 
8 | 
9 | 
10 | 
11 | 
12 |
13 |
14 |
15 | ---
16 |
17 | ## Installation
18 |
19 | Jettison uses [Go modules](https://github.com/golang/go/wiki/Modules). Releases are tagged according to the _SemVer_ format, prefixed with a `v`, starting from *0.2.0*. You can get the latest release using the following command.
20 |
21 | ```console
22 | $ go get github.com/wI2L/jettison@latest
23 | ```
24 |
25 | :warning: From version `v0.7.4`, the package requires [Go 1.17+](https://golang.org/doc/install) to build, due to the usage of the [new build constraints](https://go.googlesource.com/proposal/+/master/design/draft-gobuild.md).
26 |
27 | ## Key features
28 |
29 | - Fast, see [benchmarks](#benchmarks)
30 | - No dynamic memory allocations in hot paths
31 | - Behavior identical to the standard library by default
32 | - No code generation required
33 | - Clear and concise API
34 | - Configurable with opt-in functional options
35 | - Native support for many standard library types, see [improvements](#improvements)
36 | - Custom `AppendMarshaler` interface to avoid allocations
37 | - Extensive testsuite that compares its output against `encoding/json`
38 |
39 | ## Overview
40 |
41 | The goal of Jettision is to take up the idea introduced by the **bet365/jingo** package and build a fully-featured JSON encoder around it, that comply with the behavior of the [encoding/json](https://golang.org/pkg/encoding/json/) package. Unlike the latter, Jettison does not use reflection during marshaling, but only once to create the instruction set for a given type ahead of time. The drawback to this approach requires to instantiate an instruction-set once for each type that needs to be marshaled, but that is overcomed with a package cache.
42 |
43 | The package aims to have a behavior similar to that of the standard library for all types encoding and struct tags, meaning that the documentation of the `json.Marshal` [function](https://golang.org/pkg/encoding/json/#Marshal) is applicable for Jettison, with a few exceptions described in this [section](#differences-with-encodingjson). As such, most of the tests compare their output against it to guarantee that.
44 |
45 | ### Implementation details
46 |
47 | The main concept of Jettison consists of using pre-build instructions-set to reduce the cost of using the `reflect` package at runtime. When marshaling a value, a set of _instructions_ is recursively generated for its type, which defines how to iteratively encode it. An _instruction_ is a function or a closure, that have all the information required to read the data from memory using _unsafe_ operations (pointer type conversion, arithmetic...) during the instruction set execution.
48 |
49 | ### Differences with `encoding/json`
50 |
51 | All notable differences with the standard library behavior are listed below. Please note that these might evolve with future versions of the package.
52 |
53 | #### Improvements
54 |
55 | - The `time.Time` and `time.Duration` types are handled natively. For time values, the encoder doesn't invoke `MarshalJSON` or `MarshalText`, but use the `time.AppendFormat` [function](https://golang.org/pkg/time/#Time.AppendFormat) instead, and write the result to the stream. Similarly, for durations, it isn't necessary to implements the `json.Marshaler` or `encoding.TextMarshaler` interfaces on a custom wrapper type, the encoder uses the result of one of the methods `Minutes`, `Seconds`, `Nanoseconds` or `String`, based on the duration [format](https://godoc.org/github.com/wI2L/jettison#DurationFmt) configured.
56 |
57 | - The `sync.Map` type is handled natively. The marshaling behavior is similar to the one of a standard Go `map`. The option `UnsortedMap` can also be used in cunjunction with this type to disable the default keys sort.
58 |
59 | - The `omitnil` field tag's option can be used to specify that a field with a nil pointer should be omitted from the encoding. This option has precedence over the `omitempty` option. Note that struct fields that implement the `json.Marshaler` interface will be omitted too, if they return the literal JSON `null` value.
60 |
61 | #### Bugs
62 |
63 | ##### Go1.13 and backward
64 |
65 | - Nil map keys values implementing the `encoding.TextMarshaler` interface are encoded as empty strings, while the `encoding/json` package currently panic because of that. See this [issue](https://github.com/golang/go/issues/33675) for more details.[1]
66 |
67 | - Nil struct fields implementing the `encoding.TextMarshaler` interface are encoded as `null`, while the `encoding/json` package currently panic because of that. See this [issue](https://github.com/golang/go/issues/34235) for more details.[1]
68 |
69 | 1: The issues mentioned above have had their associated CL merged, and was released with Go 1.14.
70 |
71 | ## Usage
72 |
73 | ### Basic
74 |
75 | As stated above, the library behave similarly to the `encoding/json` package. You can simply replace the `json.Marshal` function with `jettison.Marshal`, and expect the same output with better performances.
76 |
77 | ```go
78 | type X struct {
79 | A string `json:"a"`
80 | B int64 `json:"b"`
81 | }
82 | b, err := jettison.Marshal(X{
83 | A: "Loreum",
84 | B: 42,
85 | })
86 | if err != nil {
87 | log.Fatal(err)
88 | }
89 | os.Stdout.Write(b)
90 | ```
91 | ###### Result
92 | ```json
93 | {"a":"Loreum","b":42}
94 | ```
95 |
96 | ### Advanced
97 |
98 | If more control over the encoding behavior is required, use the `MarshalOpts` function instead. The second parameter is variadic and accept a list of functional opt-in [options](https://godoc.org/github.com/wI2L/jettison#Option) described below:
99 |
100 | | name | description |
101 | |:------------------------:| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
102 | | **`TimeLayout`** | Defines the layout used to encode `time.Time` values. The layout must be compatible with the [AppendFormat](https://golang.org/pkg/time/#Time.AppendFormat) method. |
103 | | **`DurationFormat`** | Defines the format used to encode `time.Duration` values. See the documentation of the `DurationFmt` type for the complete list of formats available. |
104 | | **`UnixTime`** | Encode `time.Time` values as JSON numbers representing Unix timestamps, the number of seconds elapsed since *January 1, 1970 UTC*. This option has precedence over `TimeLayout`. |
105 | | **`UnsortedMap`** | Disables map keys sort. |
106 | | **`ByteArrayAsString`** | Encodes byte arrays as JSON strings rather than JSON arrays. The output is subject to the same escaping rules used for JSON strings, unless the option `NoStringEscaping` is used. |
107 | | **`RawByteSlice`** | Disables the *base64* default encoding used for byte slices. |
108 | | **`NilMapEmpty`** | Encodes nil Go maps as empty JSON objects rather than `null`. |
109 | | **`NilSliceEmpty`** | Encodes nil Go slices as empty JSON arrays rather than `null`. |
110 | | **`NoStringEscaping`** | Disables string escaping. `NoHTMLEscaping` and `NoUTF8Coercion` are ignored when this option is used. |
111 | | **`NoHTMLEscaping`** | Disables the escaping of special HTML characters such as `&`, `<` and `>` in JSON strings. This is similar to `json.Encoder.SetEscapeHTML(false)`. |
112 | | **`NoUTF8Coercion`** | Disables the replacement of invalid bytes with the Unicode replacement rune in JSON strings. |
113 | | **`AllowList`** | Sets a whitelist that represents which fields are to be encoded when marshaling a Go struct. |
114 | | **`DenyList`** | Sets a blacklist that represents which fields are ignored during the marshaling of a Go struct. |
115 | | **`NoCompact`** | Disables the compaction of JSON output produced by `MarshalJSON` method, and `json.RawMessage` values. |
116 | | **`NoNumberValidation`** | Disables the validation of `json.Number` values. |
117 | | **`WithContext`** | Sets the `context.Context` to be passed to invocations of `AppendJSONContext` methods. |
118 |
119 | Take a look at the [examples](example_test.go) to see these options in action.
120 |
121 | ## Benchmarks
122 |
123 | If you'd like to run the benchmarks yourself, use the following command.
124 |
125 | ```shell
126 | go get github.com/cespare/prettybench
127 | go test -bench=. | prettybench
128 | ```
129 |
130 | ### Results `-short`
131 |
132 | These benchmarks were run 10x (statistics computed with [benchstat](https://godoc.org/golang.org/x/perf/cmd/benchstat)) on a MacBook Pro 15", with the following specs:
133 | ```
134 | OS: macOS Catalina (10.15.7)
135 | CPU: 2.6 GHz Intel Core i7
136 | Mem: 16GB
137 | Go: go version go1.17 darwin/amd64
138 | Tag: v0.7.2
139 | ```
140 |
141 | Stats
142 | name time/op
143 | Simple/standard-8 573ns ± 1%
144 | Simple/jsoniter-8 547ns ± 0%
145 | Simple/segmentj-8 262ns ± 1%
146 | Simple/jettison-8 408ns ± 1%
147 | Complex/standard-8 11.7µs ± 0%
148 | Complex/jsoniter-8 11.6µs ± 1%
149 | Complex/segmentj-8 7.96µs ± 0%
150 | Complex/jettison-8 5.90µs ± 1%
151 | CodeMarshal/standard-8 6.71ms ± 0%
152 | CodeMarshal/jsoniter-8 6.35ms ± 1%
153 | CodeMarshal/segmentj-8 4.38ms ± 1%
154 | CodeMarshal/jettison-8 5.56ms ± 1%
155 | Map/standard-8 1.83µs ± 1%
156 | Map/jsoniter-8 1.65µs ± 0%
157 | Map/segmentj-8 1.61µs ± 0%
158 | Map/jettison-8 772ns ± 1%
159 | Map/jettison-nosort-8 507ns ± 1%
160 |
161 | name speed
162 | Simple/standard-8 236MB/s ± 1%
163 | Simple/jsoniter-8 247MB/s ± 0%
164 | Simple/segmentj-8 516MB/s ± 1%
165 | Simple/jettison-8 331MB/s ± 1%
166 | Complex/standard-8 72.9MB/s ± 0%
167 | Complex/jsoniter-8 70.6MB/s ± 0%
168 | Complex/segmentj-8 108MB/s ± 0%
169 | Complex/jettison-8 144MB/s ± 1%
170 | CodeMarshal/standard-8 289MB/s ± 0%
171 | CodeMarshal/jsoniter-8 306MB/s ± 1%
172 | CodeMarshal/segmentj-8 443MB/s ± 1%
173 | CodeMarshal/jettison-8 349MB/s ± 1%
174 | Map/standard-8 46.6MB/s ± 1%
175 | Map/jsoniter-8 51.5MB/s ± 0%
176 | Map/segmentj-8 52.8MB/s ± 0%
177 | Map/jettison-8 110MB/s ± 1%
178 | Map/jettison-nosort-8 168MB/s ± 1%
179 |
180 | name alloc/op
181 | Simple/standard-8 144B ± 0%
182 | Simple/jsoniter-8 152B ± 0%
183 | Simple/segmentj-8 144B ± 0%
184 | Simple/jettison-8 144B ± 0%
185 | Complex/standard-8 4.05kB ± 0%
186 | Complex/jsoniter-8 3.95kB ± 0%
187 | Complex/segmentj-8 2.56kB ± 0%
188 | Complex/jettison-8 935B ± 0%
189 | CodeMarshal/standard-8 1.97MB ± 0%
190 | CodeMarshal/jsoniter-8 2.00MB ± 0%
191 | CodeMarshal/segmentj-8 1.98MB ± 2%
192 | CodeMarshal/jettison-8 1.98MB ± 2%
193 | Map/standard-8 888B ± 0%
194 | Map/jsoniter-8 884B ± 0%
195 | Map/segmentj-8 576B ± 0%
196 | Map/jettison-8 96.0B ± 0%
197 | Map/jettison-nosort-8 160B ± 0%
198 |
199 | name allocs/op
200 | Simple/standard-8 1.00 ± 0%
201 | Simple/jsoniter-8 2.00 ± 0%
202 | Simple/segmentj-8 1.00 ± 0%
203 | Simple/jettison-8 1.00 ± 0%
204 | Complex/standard-8 79.0 ± 0%
205 | Complex/jsoniter-8 71.0 ± 0%
206 | Complex/segmentj-8 52.0 ± 0%
207 | Complex/jettison-8 8.00 ± 0%
208 | CodeMarshal/standard-8 1.00 ± 0%
209 | CodeMarshal/jsoniter-8 2.00 ± 0%
210 | CodeMarshal/segmentj-8 1.00 ± 0%
211 | CodeMarshal/jettison-8 1.00 ± 0%
212 | Map/standard-8 19.0 ± 0%
213 | Map/jsoniter-8 14.0 ± 0%
214 | Map/segmentj-8 18.0 ± 0%
215 | Map/jettison-8 1.00 ± 0%
216 | Map/jettison-nosort-8 2.00 ± 0%
217 |