podman

1
package spec
2

3
import (
4
	"bytes"
5
	"encoding/json"
6
	"reflect"
7
	"sort"
8
)
9

10
// OrderSchemaItem holds a named schema (e.g. from a property of an object)
11
type OrderSchemaItem struct {
12
	Name string
13
	Schema
14
}
15

16
// OrderSchemaItems is a sortable slice of named schemas.
17
// The ordering is defined by the x-order schema extension.
18
type OrderSchemaItems []OrderSchemaItem
19

20
// MarshalJSON produces a json object with keys defined by the name schemas
21
// of the OrderSchemaItems slice, keeping the original order of the slice.
22
func (items OrderSchemaItems) MarshalJSON() ([]byte, error) {
23
	buf := bytes.NewBuffer(nil)
24
	buf.WriteString("{")
25
	for i := range items {
26
		if i > 0 {
27
			buf.WriteString(",")
28
		}
29
		buf.WriteString("\"")
30
		buf.WriteString(items[i].Name)
31
		buf.WriteString("\":")
32
		bs, err := json.Marshal(&items[i].Schema)
33
		if err != nil {
34
			return nil, err
35
		}
36
		buf.Write(bs)
37
	}
38
	buf.WriteString("}")
39
	return buf.Bytes(), nil
40
}
41

42
func (items OrderSchemaItems) Len() int      { return len(items) }
43
func (items OrderSchemaItems) Swap(i, j int) { items[i], items[j] = items[j], items[i] }
44
func (items OrderSchemaItems) Less(i, j int) (ret bool) {
45
	ii, oki := items[i].Extensions.GetInt("x-order")
46
	ij, okj := items[j].Extensions.GetInt("x-order")
47
	if oki {
48
		if okj {
49
			defer func() {
50
				if err := recover(); err != nil {
51
					defer func() {
52
						if err = recover(); err != nil {
53
							ret = items[i].Name < items[j].Name
54
						}
55
					}()
56
					ret = reflect.ValueOf(ii).String() < reflect.ValueOf(ij).String()
57
				}
58
			}()
59
			return ii < ij
60
		}
61
		return true
62
	} else if okj {
63
		return false
64
	}
65
	return items[i].Name < items[j].Name
66
}
67

68
// SchemaProperties is a map representing the properties of a Schema object.
69
// It knows how to transform its keys into an ordered slice.
70
type SchemaProperties map[string]Schema
71

72
// ToOrderedSchemaItems transforms the map of properties into a sortable slice
73
func (properties SchemaProperties) ToOrderedSchemaItems() OrderSchemaItems {
74
	items := make(OrderSchemaItems, 0, len(properties))
75
	for k, v := range properties {
76
		items = append(items, OrderSchemaItem{
77
			Name:   k,
78
			Schema: v,
79
		})
80
	}
81
	sort.Sort(items)
82
	return items
83
}
84

85
// MarshalJSON produces properties as json, keeping their order.
86
func (properties SchemaProperties) MarshalJSON() ([]byte, error) {
87
	if properties == nil {
88
		return []byte("null"), nil
89
	}
90
	return json.Marshal(properties.ToOrderedSchemaItems())
91
}
92