podman

1
// Copyright 2015 go-swagger maintainers
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//    http://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14

15
package strfmt
16

17
import (
18
	"database/sql/driver"
19
	"encoding/json"
20
	"errors"
21
	"fmt"
22
	"regexp"
23
	"strconv"
24
	"strings"
25
	"time"
26

27
	"go.mongodb.org/mongo-driver/bson"
28
)
29

30
func init() {
31
	d := Duration(0)
32
	// register this format in the default registry
33
	Default.Add("duration", &d, IsDuration)
34
}
35

36
var (
37
	timeUnits = [][]string{
38
		{"ns", "nano"},
39
		{"us", "µs", "micro"},
40
		{"ms", "milli"},
41
		{"s", "sec"},
42
		{"m", "min"},
43
		{"h", "hr", "hour"},
44
		{"d", "day"},
45
		{"w", "wk", "week"},
46
	}
47

48
	timeMultiplier = map[string]time.Duration{
49
		"ns": time.Nanosecond,
50
		"us": time.Microsecond,
51
		"ms": time.Millisecond,
52
		"s":  time.Second,
53
		"m":  time.Minute,
54
		"h":  time.Hour,
55
		"d":  24 * time.Hour,
56
		"w":  7 * 24 * time.Hour,
57
	}
58

59
	durationMatcher = regexp.MustCompile(`((\d+)\s*([A-Za-zµ]+))`)
60
)
61

62
// IsDuration returns true if the provided string is a valid duration
63
func IsDuration(str string) bool {
64
	_, err := ParseDuration(str)
65
	return err == nil
66
}
67

68
// Duration represents a duration
69
//
70
// Duration stores a period of time as a nanosecond count, with the largest
71
// repesentable duration being approximately 290 years.
72
//
73
// swagger:strfmt duration
74
type Duration time.Duration
75

76
// MarshalText turns this instance into text
77
func (d Duration) MarshalText() ([]byte, error) {
78
	return []byte(time.Duration(d).String()), nil
79
}
80

81
// UnmarshalText hydrates this instance from text
82
func (d *Duration) UnmarshalText(data []byte) error { // validation is performed later on
83
	dd, err := ParseDuration(string(data))
84
	if err != nil {
85
		return err
86
	}
87
	*d = Duration(dd)
88
	return nil
89
}
90

91
// ParseDuration parses a duration from a string, compatible with scala duration syntax
92
func ParseDuration(cand string) (time.Duration, error) {
93
	if dur, err := time.ParseDuration(cand); err == nil {
94
		return dur, nil
95
	}
96

97
	var dur time.Duration
98
	ok := false
99
	for _, match := range durationMatcher.FindAllStringSubmatch(cand, -1) {
100

101
		factor, err := strconv.Atoi(match[2]) // converts string to int
102
		if err != nil {
103
			return 0, err
104
		}
105
		unit := strings.ToLower(strings.TrimSpace(match[3]))
106

107
		for _, variants := range timeUnits {
108
			last := len(variants) - 1
109
			multiplier := timeMultiplier[variants[0]]
110

111
			for i, variant := range variants {
112
				if (last == i && strings.HasPrefix(unit, variant)) || strings.EqualFold(variant, unit) {
113
					ok = true
114
					dur += (time.Duration(factor) * multiplier)
115
				}
116
			}
117
		}
118
	}
119

120
	if ok {
121
		return dur, nil
122
	}
123
	return 0, fmt.Errorf("unable to parse %s as duration", cand)
124
}
125

126
// Scan reads a Duration value from database driver type.
127
func (d *Duration) Scan(raw interface{}) error {
128
	switch v := raw.(type) {
129
	// TODO: case []byte: // ?
130
	case int64:
131
		*d = Duration(v)
132
	case float64:
133
		*d = Duration(int64(v))
134
	case nil:
135
		*d = Duration(0)
136
	default:
137
		return fmt.Errorf("cannot sql.Scan() strfmt.Duration from: %#v", v)
138
	}
139

140
	return nil
141
}
142

143
// Value converts Duration to a primitive value ready to be written to a database.
144
func (d Duration) Value() (driver.Value, error) {
145
	return driver.Value(int64(d)), nil
146
}
147

148
// String converts this duration to a string
149
func (d Duration) String() string {
150
	return time.Duration(d).String()
151
}
152

153
// MarshalJSON returns the Duration as JSON
154
func (d Duration) MarshalJSON() ([]byte, error) {
155
	return json.Marshal(time.Duration(d).String())
156
}
157

158
// UnmarshalJSON sets the Duration from JSON
159
func (d *Duration) UnmarshalJSON(data []byte) error {
160
	if string(data) == jsonNull {
161
		return nil
162
	}
163

164
	var dstr string
165
	if err := json.Unmarshal(data, &dstr); err != nil {
166
		return err
167
	}
168
	tt, err := ParseDuration(dstr)
169
	if err != nil {
170
		return err
171
	}
172
	*d = Duration(tt)
173
	return nil
174
}
175

176
func (d Duration) MarshalBSON() ([]byte, error) {
177
	return bson.Marshal(bson.M{"data": d.String()})
178
}
179

180
func (d *Duration) UnmarshalBSON(data []byte) error {
181
	var m bson.M
182
	if err := bson.Unmarshal(data, &m); err != nil {
183
		return err
184
	}
185

186
	if data, ok := m["data"].(string); ok {
187
		rd, err := ParseDuration(data)
188
		if err != nil {
189
			return err
190
		}
191
		*d = Duration(rd)
192
		return nil
193
	}
194

195
	return errors.New("couldn't unmarshal bson bytes value as Date")
196
}
197

198
// DeepCopyInto copies the receiver and writes its value into out.
199
func (d *Duration) DeepCopyInto(out *Duration) {
200
	*out = *d
201
}
202

203
// DeepCopy copies the receiver into a new Duration.
204
func (d *Duration) DeepCopy() *Duration {
205
	if d == nil {
206
		return nil
207
	}
208
	out := new(Duration)
209
	d.DeepCopyInto(out)
210
	return out
211
}
212