You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1200 lines
24 KiB
Go
1200 lines
24 KiB
Go
package stdlib
|
|
|
|
import (
|
|
"time"
|
|
|
|
"github.com/d5/tengo/v2"
|
|
)
|
|
|
|
var timesModule = map[string]tengo.Object{
|
|
"format_ansic": &tengo.String{Value: time.ANSIC},
|
|
"format_unix_date": &tengo.String{Value: time.UnixDate},
|
|
"format_ruby_date": &tengo.String{Value: time.RubyDate},
|
|
"format_rfc822": &tengo.String{Value: time.RFC822},
|
|
"format_rfc822z": &tengo.String{Value: time.RFC822Z},
|
|
"format_rfc850": &tengo.String{Value: time.RFC850},
|
|
"format_rfc1123": &tengo.String{Value: time.RFC1123},
|
|
"format_rfc1123z": &tengo.String{Value: time.RFC1123Z},
|
|
"format_rfc3339": &tengo.String{Value: time.RFC3339},
|
|
"format_rfc3339_nano": &tengo.String{Value: time.RFC3339Nano},
|
|
"format_kitchen": &tengo.String{Value: time.Kitchen},
|
|
"format_stamp": &tengo.String{Value: time.Stamp},
|
|
"format_stamp_milli": &tengo.String{Value: time.StampMilli},
|
|
"format_stamp_micro": &tengo.String{Value: time.StampMicro},
|
|
"format_stamp_nano": &tengo.String{Value: time.StampNano},
|
|
"nanosecond": &tengo.Int{Value: int64(time.Nanosecond)},
|
|
"microsecond": &tengo.Int{Value: int64(time.Microsecond)},
|
|
"millisecond": &tengo.Int{Value: int64(time.Millisecond)},
|
|
"second": &tengo.Int{Value: int64(time.Second)},
|
|
"minute": &tengo.Int{Value: int64(time.Minute)},
|
|
"hour": &tengo.Int{Value: int64(time.Hour)},
|
|
"january": &tengo.Int{Value: int64(time.January)},
|
|
"february": &tengo.Int{Value: int64(time.February)},
|
|
"march": &tengo.Int{Value: int64(time.March)},
|
|
"april": &tengo.Int{Value: int64(time.April)},
|
|
"may": &tengo.Int{Value: int64(time.May)},
|
|
"june": &tengo.Int{Value: int64(time.June)},
|
|
"july": &tengo.Int{Value: int64(time.July)},
|
|
"august": &tengo.Int{Value: int64(time.August)},
|
|
"september": &tengo.Int{Value: int64(time.September)},
|
|
"october": &tengo.Int{Value: int64(time.October)},
|
|
"november": &tengo.Int{Value: int64(time.November)},
|
|
"december": &tengo.Int{Value: int64(time.December)},
|
|
"sleep": &tengo.UserFunction{
|
|
Name: "sleep",
|
|
Value: timesSleep,
|
|
}, // sleep(int)
|
|
"parse_duration": &tengo.UserFunction{
|
|
Name: "parse_duration",
|
|
Value: timesParseDuration,
|
|
}, // parse_duration(str) => int
|
|
"since": &tengo.UserFunction{
|
|
Name: "since",
|
|
Value: timesSince,
|
|
}, // since(time) => int
|
|
"until": &tengo.UserFunction{
|
|
Name: "until",
|
|
Value: timesUntil,
|
|
}, // until(time) => int
|
|
"duration_hours": &tengo.UserFunction{
|
|
Name: "duration_hours",
|
|
Value: timesDurationHours,
|
|
}, // duration_hours(int) => float
|
|
"duration_minutes": &tengo.UserFunction{
|
|
Name: "duration_minutes",
|
|
Value: timesDurationMinutes,
|
|
}, // duration_minutes(int) => float
|
|
"duration_nanoseconds": &tengo.UserFunction{
|
|
Name: "duration_nanoseconds",
|
|
Value: timesDurationNanoseconds,
|
|
}, // duration_nanoseconds(int) => int
|
|
"duration_seconds": &tengo.UserFunction{
|
|
Name: "duration_seconds",
|
|
Value: timesDurationSeconds,
|
|
}, // duration_seconds(int) => float
|
|
"duration_string": &tengo.UserFunction{
|
|
Name: "duration_string",
|
|
Value: timesDurationString,
|
|
}, // duration_string(int) => string
|
|
"month_string": &tengo.UserFunction{
|
|
Name: "month_string",
|
|
Value: timesMonthString,
|
|
}, // month_string(int) => string
|
|
"date": &tengo.UserFunction{
|
|
Name: "date",
|
|
Value: timesDate,
|
|
}, // date(year, month, day, hour, min, sec, nsec) => time
|
|
"now": &tengo.UserFunction{
|
|
Name: "now",
|
|
Value: timesNow,
|
|
}, // now() => time
|
|
"parse": &tengo.UserFunction{
|
|
Name: "parse",
|
|
Value: timesParse,
|
|
}, // parse(format, str) => time
|
|
"unix": &tengo.UserFunction{
|
|
Name: "unix",
|
|
Value: timesUnix,
|
|
}, // unix(sec, nsec) => time
|
|
"add": &tengo.UserFunction{
|
|
Name: "add",
|
|
Value: timesAdd,
|
|
}, // add(time, int) => time
|
|
"add_date": &tengo.UserFunction{
|
|
Name: "add_date",
|
|
Value: timesAddDate,
|
|
}, // add_date(time, years, months, days) => time
|
|
"sub": &tengo.UserFunction{
|
|
Name: "sub",
|
|
Value: timesSub,
|
|
}, // sub(t time, u time) => int
|
|
"after": &tengo.UserFunction{
|
|
Name: "after",
|
|
Value: timesAfter,
|
|
}, // after(t time, u time) => bool
|
|
"before": &tengo.UserFunction{
|
|
Name: "before",
|
|
Value: timesBefore,
|
|
}, // before(t time, u time) => bool
|
|
"time_year": &tengo.UserFunction{
|
|
Name: "time_year",
|
|
Value: timesTimeYear,
|
|
}, // time_year(time) => int
|
|
"time_month": &tengo.UserFunction{
|
|
Name: "time_month",
|
|
Value: timesTimeMonth,
|
|
}, // time_month(time) => int
|
|
"time_day": &tengo.UserFunction{
|
|
Name: "time_day",
|
|
Value: timesTimeDay,
|
|
}, // time_day(time) => int
|
|
"time_weekday": &tengo.UserFunction{
|
|
Name: "time_weekday",
|
|
Value: timesTimeWeekday,
|
|
}, // time_weekday(time) => int
|
|
"time_hour": &tengo.UserFunction{
|
|
Name: "time_hour",
|
|
Value: timesTimeHour,
|
|
}, // time_hour(time) => int
|
|
"time_minute": &tengo.UserFunction{
|
|
Name: "time_minute",
|
|
Value: timesTimeMinute,
|
|
}, // time_minute(time) => int
|
|
"time_second": &tengo.UserFunction{
|
|
Name: "time_second",
|
|
Value: timesTimeSecond,
|
|
}, // time_second(time) => int
|
|
"time_nanosecond": &tengo.UserFunction{
|
|
Name: "time_nanosecond",
|
|
Value: timesTimeNanosecond,
|
|
}, // time_nanosecond(time) => int
|
|
"time_unix": &tengo.UserFunction{
|
|
Name: "time_unix",
|
|
Value: timesTimeUnix,
|
|
}, // time_unix(time) => int
|
|
"time_unix_nano": &tengo.UserFunction{
|
|
Name: "time_unix_nano",
|
|
Value: timesTimeUnixNano,
|
|
}, // time_unix_nano(time) => int
|
|
"time_format": &tengo.UserFunction{
|
|
Name: "time_format",
|
|
Value: timesTimeFormat,
|
|
}, // time_format(time, format) => string
|
|
"time_location": &tengo.UserFunction{
|
|
Name: "time_location",
|
|
Value: timesTimeLocation,
|
|
}, // time_location(time) => string
|
|
"time_string": &tengo.UserFunction{
|
|
Name: "time_string",
|
|
Value: timesTimeString,
|
|
}, // time_string(time) => string
|
|
"is_zero": &tengo.UserFunction{
|
|
Name: "is_zero",
|
|
Value: timesIsZero,
|
|
}, // is_zero(time) => bool
|
|
"to_local": &tengo.UserFunction{
|
|
Name: "to_local",
|
|
Value: timesToLocal,
|
|
}, // to_local(time) => time
|
|
"to_utc": &tengo.UserFunction{
|
|
Name: "to_utc",
|
|
Value: timesToUTC,
|
|
}, // to_utc(time) => time
|
|
"in_location": &tengo.UserFunction{
|
|
Name: "in_location",
|
|
Value: timesInLocation,
|
|
}, // in_location(time, location) => time
|
|
}
|
|
|
|
func timesSleep(args ...tengo.Object) (ret tengo.Object, err error) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
i1, ok := tengo.ToInt64(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "int(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
time.Sleep(time.Duration(i1))
|
|
ret = tengo.UndefinedValue
|
|
|
|
return
|
|
}
|
|
|
|
func timesParseDuration(args ...tengo.Object) (
|
|
ret tengo.Object,
|
|
err error,
|
|
) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
s1, ok := tengo.ToString(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "string(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
dur, err := time.ParseDuration(s1)
|
|
if err != nil {
|
|
ret = wrapError(err)
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Int{Value: int64(dur)}
|
|
|
|
return
|
|
}
|
|
|
|
func timesSince(args ...tengo.Object) (
|
|
ret tengo.Object,
|
|
err error,
|
|
) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Int{Value: int64(time.Since(t1))}
|
|
|
|
return
|
|
}
|
|
|
|
func timesUntil(args ...tengo.Object) (
|
|
ret tengo.Object,
|
|
err error,
|
|
) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Int{Value: int64(time.Until(t1))}
|
|
|
|
return
|
|
}
|
|
|
|
func timesDurationHours(args ...tengo.Object) (
|
|
ret tengo.Object,
|
|
err error,
|
|
) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
i1, ok := tengo.ToInt64(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "int(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Float{Value: time.Duration(i1).Hours()}
|
|
|
|
return
|
|
}
|
|
|
|
func timesDurationMinutes(args ...tengo.Object) (
|
|
ret tengo.Object,
|
|
err error,
|
|
) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
i1, ok := tengo.ToInt64(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "int(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Float{Value: time.Duration(i1).Minutes()}
|
|
|
|
return
|
|
}
|
|
|
|
func timesDurationNanoseconds(args ...tengo.Object) (
|
|
ret tengo.Object,
|
|
err error,
|
|
) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
i1, ok := tengo.ToInt64(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "int(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Int{Value: time.Duration(i1).Nanoseconds()}
|
|
|
|
return
|
|
}
|
|
|
|
func timesDurationSeconds(args ...tengo.Object) (
|
|
ret tengo.Object,
|
|
err error,
|
|
) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
i1, ok := tengo.ToInt64(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "int(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Float{Value: time.Duration(i1).Seconds()}
|
|
|
|
return
|
|
}
|
|
|
|
func timesDurationString(args ...tengo.Object) (
|
|
ret tengo.Object,
|
|
err error,
|
|
) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
i1, ok := tengo.ToInt64(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "int(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.String{Value: time.Duration(i1).String()}
|
|
|
|
return
|
|
}
|
|
|
|
func timesMonthString(args ...tengo.Object) (
|
|
ret tengo.Object,
|
|
err error,
|
|
) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
i1, ok := tengo.ToInt64(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "int(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.String{Value: time.Month(i1).String()}
|
|
|
|
return
|
|
}
|
|
|
|
func timesDate(args ...tengo.Object) (
|
|
ret tengo.Object,
|
|
err error,
|
|
) {
|
|
if len(args) < 7 || len(args) > 8 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
i1, ok := tengo.ToInt(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "int(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
i2, ok := tengo.ToInt(args[1])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "second",
|
|
Expected: "int(compatible)",
|
|
Found: args[1].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
i3, ok := tengo.ToInt(args[2])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "third",
|
|
Expected: "int(compatible)",
|
|
Found: args[2].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
i4, ok := tengo.ToInt(args[3])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "fourth",
|
|
Expected: "int(compatible)",
|
|
Found: args[3].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
i5, ok := tengo.ToInt(args[4])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "fifth",
|
|
Expected: "int(compatible)",
|
|
Found: args[4].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
i6, ok := tengo.ToInt(args[5])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "sixth",
|
|
Expected: "int(compatible)",
|
|
Found: args[5].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
i7, ok := tengo.ToInt(args[6])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "seventh",
|
|
Expected: "int(compatible)",
|
|
Found: args[6].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
var loc *time.Location
|
|
if len(args) == 8 {
|
|
i8, ok := tengo.ToString(args[7])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "eighth",
|
|
Expected: "string(compatible)",
|
|
Found: args[7].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
loc, err = time.LoadLocation(i8)
|
|
if err != nil {
|
|
ret = wrapError(err)
|
|
return
|
|
}
|
|
} else {
|
|
loc = time.Now().Location()
|
|
}
|
|
|
|
ret = &tengo.Time{
|
|
Value: time.Date(i1,
|
|
time.Month(i2), i3, i4, i5, i6, i7, loc),
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func timesNow(args ...tengo.Object) (ret tengo.Object, err error) {
|
|
if len(args) != 0 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Time{Value: time.Now()}
|
|
|
|
return
|
|
}
|
|
|
|
func timesParse(args ...tengo.Object) (ret tengo.Object, err error) {
|
|
if len(args) != 2 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
s1, ok := tengo.ToString(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "string(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
s2, ok := tengo.ToString(args[1])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "second",
|
|
Expected: "string(compatible)",
|
|
Found: args[1].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
parsed, err := time.Parse(s1, s2)
|
|
if err != nil {
|
|
ret = wrapError(err)
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Time{Value: parsed}
|
|
|
|
return
|
|
}
|
|
|
|
func timesUnix(args ...tengo.Object) (ret tengo.Object, err error) {
|
|
if len(args) != 2 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
i1, ok := tengo.ToInt64(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "int(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
i2, ok := tengo.ToInt64(args[1])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "second",
|
|
Expected: "int(compatible)",
|
|
Found: args[1].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Time{Value: time.Unix(i1, i2)}
|
|
|
|
return
|
|
}
|
|
|
|
func timesAdd(args ...tengo.Object) (ret tengo.Object, err error) {
|
|
if len(args) != 2 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
i2, ok := tengo.ToInt64(args[1])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "second",
|
|
Expected: "int(compatible)",
|
|
Found: args[1].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Time{Value: t1.Add(time.Duration(i2))}
|
|
|
|
return
|
|
}
|
|
|
|
func timesSub(args ...tengo.Object) (ret tengo.Object, err error) {
|
|
if len(args) != 2 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
t2, ok := tengo.ToTime(args[1])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "second",
|
|
Expected: "time(compatible)",
|
|
Found: args[1].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Int{Value: int64(t1.Sub(t2))}
|
|
|
|
return
|
|
}
|
|
|
|
func timesAddDate(args ...tengo.Object) (ret tengo.Object, err error) {
|
|
if len(args) != 4 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
i2, ok := tengo.ToInt(args[1])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "second",
|
|
Expected: "int(compatible)",
|
|
Found: args[1].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
i3, ok := tengo.ToInt(args[2])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "third",
|
|
Expected: "int(compatible)",
|
|
Found: args[2].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
i4, ok := tengo.ToInt(args[3])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "fourth",
|
|
Expected: "int(compatible)",
|
|
Found: args[3].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Time{Value: t1.AddDate(i2, i3, i4)}
|
|
|
|
return
|
|
}
|
|
|
|
func timesAfter(args ...tengo.Object) (ret tengo.Object, err error) {
|
|
if len(args) != 2 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
t2, ok := tengo.ToTime(args[1])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "second",
|
|
Expected: "time(compatible)",
|
|
Found: args[1].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
if t1.After(t2) {
|
|
ret = tengo.TrueValue
|
|
} else {
|
|
ret = tengo.FalseValue
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func timesBefore(args ...tengo.Object) (ret tengo.Object, err error) {
|
|
if len(args) != 2 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
t2, ok := tengo.ToTime(args[1])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "second",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
if t1.Before(t2) {
|
|
ret = tengo.TrueValue
|
|
} else {
|
|
ret = tengo.FalseValue
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func timesTimeYear(args ...tengo.Object) (ret tengo.Object, err error) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Int{Value: int64(t1.Year())}
|
|
|
|
return
|
|
}
|
|
|
|
func timesTimeMonth(args ...tengo.Object) (ret tengo.Object, err error) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Int{Value: int64(t1.Month())}
|
|
|
|
return
|
|
}
|
|
|
|
func timesTimeDay(args ...tengo.Object) (ret tengo.Object, err error) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Int{Value: int64(t1.Day())}
|
|
|
|
return
|
|
}
|
|
|
|
func timesTimeWeekday(args ...tengo.Object) (ret tengo.Object, err error) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Int{Value: int64(t1.Weekday())}
|
|
|
|
return
|
|
}
|
|
|
|
func timesTimeHour(args ...tengo.Object) (ret tengo.Object, err error) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Int{Value: int64(t1.Hour())}
|
|
|
|
return
|
|
}
|
|
|
|
func timesTimeMinute(args ...tengo.Object) (ret tengo.Object, err error) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Int{Value: int64(t1.Minute())}
|
|
|
|
return
|
|
}
|
|
|
|
func timesTimeSecond(args ...tengo.Object) (ret tengo.Object, err error) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Int{Value: int64(t1.Second())}
|
|
|
|
return
|
|
}
|
|
|
|
func timesTimeNanosecond(args ...tengo.Object) (
|
|
ret tengo.Object,
|
|
err error,
|
|
) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Int{Value: int64(t1.Nanosecond())}
|
|
|
|
return
|
|
}
|
|
|
|
func timesTimeUnix(args ...tengo.Object) (ret tengo.Object, err error) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Int{Value: t1.Unix()}
|
|
|
|
return
|
|
}
|
|
|
|
func timesTimeUnixNano(args ...tengo.Object) (
|
|
ret tengo.Object,
|
|
err error,
|
|
) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Int{Value: t1.UnixNano()}
|
|
|
|
return
|
|
}
|
|
|
|
func timesTimeFormat(args ...tengo.Object) (ret tengo.Object, err error) {
|
|
if len(args) != 2 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
s2, ok := tengo.ToString(args[1])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "second",
|
|
Expected: "string(compatible)",
|
|
Found: args[1].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
s := t1.Format(s2)
|
|
if len(s) > tengo.MaxStringLen {
|
|
|
|
return nil, tengo.ErrStringLimit
|
|
}
|
|
|
|
ret = &tengo.String{Value: s}
|
|
|
|
return
|
|
}
|
|
|
|
func timesIsZero(args ...tengo.Object) (ret tengo.Object, err error) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
if t1.IsZero() {
|
|
ret = tengo.TrueValue
|
|
} else {
|
|
ret = tengo.FalseValue
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func timesToLocal(args ...tengo.Object) (ret tengo.Object, err error) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Time{Value: t1.Local()}
|
|
|
|
return
|
|
}
|
|
|
|
func timesToUTC(args ...tengo.Object) (ret tengo.Object, err error) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Time{Value: t1.UTC()}
|
|
|
|
return
|
|
}
|
|
|
|
func timesTimeLocation(args ...tengo.Object) (
|
|
ret tengo.Object,
|
|
err error,
|
|
) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.String{Value: t1.Location().String()}
|
|
|
|
return
|
|
}
|
|
|
|
func timesInLocation(args ...tengo.Object) (
|
|
ret tengo.Object,
|
|
err error,
|
|
) {
|
|
if len(args) != 2 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
s2, ok := tengo.ToString(args[1])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "second",
|
|
Expected: "string(compatible)",
|
|
Found: args[1].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
location, err := time.LoadLocation(s2)
|
|
if err != nil {
|
|
ret = wrapError(err)
|
|
return
|
|
}
|
|
|
|
ret = &tengo.Time{Value: t1.In(location)}
|
|
|
|
return
|
|
}
|
|
|
|
func timesTimeString(args ...tengo.Object) (ret tengo.Object, err error) {
|
|
if len(args) != 1 {
|
|
err = tengo.ErrWrongNumArguments
|
|
return
|
|
}
|
|
|
|
t1, ok := tengo.ToTime(args[0])
|
|
if !ok {
|
|
err = tengo.ErrInvalidArgumentType{
|
|
Name: "first",
|
|
Expected: "time(compatible)",
|
|
Found: args[0].TypeName(),
|
|
}
|
|
return
|
|
}
|
|
|
|
ret = &tengo.String{Value: t1.String()}
|
|
|
|
return
|
|
}
|