chrono

package
v0.6.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 14, 2024 License: MIT Imports: 11 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	Nanosecond  = time.Nanosecond
	Microsecond = time.Microsecond
	Millisecond = time.Millisecond
	Second      = time.Second
	Minute      = time.Minute
	Hour        = time.Hour
	Day         = Hour * 24
	Week        = Day * 7
)
View Source 
const (
	DefaultSchedulerTick      = time.Millisecond * 10
	DefaultSchedulerWheelSize = 10
)
View Source 
const (
	SchedulerForever   = -1 //  无限循环
	SchedulerOnce      = 1  // 一次
	SchedulerInstantly = 0  // 立刻
)
View Source 
const (
	BuiltInSchedulerWheelSize = 50
)

Variables

This section is empty.

Functions

func CeilDeltaDays 

func CeilDeltaDays(t1, t2 time.Time) int

CeilDeltaDays 计算两个时间之间的天数差异，并向上取整

func CeilDeltaHours 

func CeilDeltaHours(t1, t2 time.Time) int

CeilDeltaHours 计算两个时间之间的小时数差异，并向上取整

func CeilDeltaMinutes 

func CeilDeltaMinutes(t1, t2 time.Time) int

CeilDeltaMinutes 计算两个时间之间的分钟数差异，并向上取整

func Delta 

func Delta(t1, t2 time.Time) time.Duration

Delta 获取两个时间之间的时间差

func ExponentialBackoff added in v0.6.0 

func ExponentialBackoff(count, maxRetries int, baseDelay, maxDelay time.Duration, multiplier, randomization float64) time.Duration

ExponentialBackoff 退避指数函数用于计算下一次重试将在多长时间后发生，当返回 -1 时表示不再重试

  • count：当前重试次数
  • maxRetries：最大重试次数，当为负数时表示无限重试
  • baseDelay：基础延迟
  • maxDelay：最大延迟
  • multiplier：延迟时间的乘数，通常为 2
  • randomization：延迟时间的随机化因子，通常为 0.5

func FloorDeltaDays 

func FloorDeltaDays(t1, t2 time.Time) int

FloorDeltaDays 计算两个时间之间的天数差异，并向下取整

func FloorDeltaHours 

func FloorDeltaHours(t1, t2 time.Time) int

FloorDeltaHours 计算两个时间之间的小时数差异，并向下取整

func FloorDeltaMinutes 

func FloorDeltaMinutes(t1, t2 time.Time) int

FloorDeltaMinutes 计算两个时间之间的分钟数差异，并向下取整

func GetEndOfDay 

func GetEndOfDay(t time.Time) time.Time

GetEndOfDay 获取指定时间的当天最后一刻，即 23:59:59

func GetEndOfWeek 

func GetEndOfWeek(t time.Time, weekday time.Weekday) time.Time

GetEndOfWeek 获取指定时间所在周的特定周的最后时刻，即 23:59:59

func GetMonthDays 

func GetMonthDays(t time.Time) int

GetMonthDays 获取指定时间所在月的天数

func GetNextMoment 

func GetNextMoment(now time.Time, hour, min, sec int) time.Time

GetNextMoment 获取下一个指定时刻发生的时间。

func GetRelativeEndOfDay 

func GetRelativeEndOfDay(t time.Time, offsetDays int) time.Time

GetRelativeEndOfDay 获取相对于指定时间减去或加上指定天数后的当天结束时间

  • offsetDays: 要偏移的天数，负数表示过去的某一天，正数表示未来的某一天

func GetRelativeEndOfWeek 

func GetRelativeEndOfWeek(now time.Time, week time.Weekday, offsetWeeks int) time.Time

GetRelativeEndOfWeek 获取相对于当前时间的本周结束时间，以指定的星期作为一周的开始，并根据需要进行周数的偏移

  • 该函数详细解释参考 GetRelativeEndOfWeek 函数，其中不同的是，该函数返回的是这一天最后一刻的时间，即 23:59:59

func GetRelativeStartOfDay 

func GetRelativeStartOfDay(t time.Time, offsetDays int) time.Time

GetRelativeStartOfDay 获取相对于指定时间减去或加上指定天数后的当天开始时间

  • offsetDays: 要偏移的天数，负数表示过去的某一天，正数表示未来的某一天

func GetRelativeStartOfWeek 

func GetRelativeStartOfWeek(now time.Time, week time.Weekday, offsetWeeks int) time.Time

GetRelativeStartOfWeek 获取相对于当前时间的本周开始时间，以指定的星期作为一周的开始，并根据需要进行周数的偏移

  • now：当前时间
  • week：以哪一天作为一周的开始
  • offsetWeeks：要偏移的周数，正数表示向未来偏移，负数表示向过去偏移

该函数返回以指定星期作为一周的开始时间，然后根据偏移量进行周数偏移，得到相对于当前时间的周的开始时间

假设 week 为 time.Saturday 且 offsetWeeks 为 -1，则表示获取上周六的开始时间，一下情况中第一个时间为 now，第二个时间为函数返回值

  • 2024-03-01 00:00:00 --相对时间-> 2024-02-24 00:00:00 --偏移时间--> 2024-02-17 00:00:00
  • 2024-03-02 00:00:00 --相对时间-> 2024-02-24 00:00:00 --偏移时间--> 2024-02-17 00:00:00
  • 2024-03-03 00:00:00 --相对时间-> 2024-03-02 00:00:00 --偏移时间--> 2024-02-24 00:00:00

func GetRelativeTimeOfWeek 

func GetRelativeTimeOfWeek(now time.Time, week time.Weekday, offsetWeeks int) time.Time

GetRelativeTimeOfWeek 获取相对于当前时间的本周指定星期的指定时刻，以指定的星期作为一周的开始，并根据需要进行周数的偏移

  • 该函数详细解释参考 GetRelativeStartOfWeek 函数，其中不同的是，该函数返回的是这一天对应 now 的时间

func GetStartOfDay 

func GetStartOfDay(t time.Time) time.Time

GetStartOfDay 获取指定时间的当天第一刻，即 00:00:00

func GetStartOfWeek 

func GetStartOfWeek(t time.Time, weekday time.Weekday) time.Time

GetStartOfWeek 获取指定时间所在周的特定周的开始时刻，即 00:00:00

func IsMomentFuture 

func IsMomentFuture(now time.Time, hour, min, sec int) bool

IsMomentFuture 检查指定时刻是否在未来

func IsMomentPassed 

func IsMomentPassed(now time.Time, hour, min, sec int) bool

IsMomentPassed 检查指定时刻是否已经过去

func IsSameDay 

func IsSameDay(t1, t2 time.Time) bool

IsSameDay 检查两个时间是否在同一天

func IsSameHour 

func IsSameHour(t1, t2 time.Time) bool

IsSameHour 检查两个时间是否在同一小时

func IsSameMinute 

func IsSameMinute(t1, t2 time.Time) bool

IsSameMinute 检查两个时间是否在同一分钟

func IsSameMonth 

func IsSameMonth(t1, t2 time.Time) bool

IsSameMonth 检查两个时间是否在同一月

func IsSameSecond 

func IsSameSecond(t1, t2 time.Time) bool

IsSameSecond 检查两个时间是否在同一秒

func IsSameWeek 

func IsSameWeek(t1, t2 time.Time) bool

IsSameWeek 检查两个时间是否在同一周

func IsSameYear 

func IsSameYear(t1, t2 time.Time) bool

IsSameYear 检查两个时间是否在同一年

func IsZero 

func IsZero(t time.Time) bool

IsZero 检查一个时间是否为零值

func Max 

func Max(t1, t2 time.Time) time.Time

Max 获取两个时间中的最大值

func Min 

func Min(t1, t2 time.Time) time.Time

Min 获取两个时间中的最小值

func Now 

func Now() time.Time

Now 调用内置时间调节器 BuiltInAdjuster 的 Adjuster.Now 函数

func RegisterAfterTask 

func RegisterAfterTask(name string, after time.Duration, function interface{}, args ...interface{})

RegisterAfterTask 调用内置时间调度器 BuiltInScheduler 的 Scheduler.RegisterAfterTask 函数

func RegisterCronTask 

func RegisterCronTask(name, expression string, function interface{}, args ...interface{}) error

RegisterCronTask 调用内置时间调度器 BuiltInScheduler 的 Scheduler.RegisterCronTask 函数

func RegisterDayMomentTask 

func RegisterDayMomentTask(name string, lastExecuted time.Time, offset time.Duration, hour, min, sec int, function interface{}, args ...interface{})

RegisterDayMomentTask 调用内置时间调度器 BuiltInScheduler 的 Scheduler.RegisterDayMomentTask 函数

func RegisterImmediateCronTask 

func RegisterImmediateCronTask(name, expression string, function interface{}, args ...interface{}) error

RegisterImmediateCronTask 调用内置时间调度器 BuiltInScheduler 的 Scheduler.RegisterImmediateCronTask 函数

func RegisterRepeatedTask 

func RegisterRepeatedTask(name string, after, interval time.Duration, times int, function interface{}, args ...interface{})

RegisterRepeatedTask 调用内置时间调度器 BuiltInScheduler 的 Scheduler.RegisterRepeatedTask 函数

func RoundDeltaDays 

func RoundDeltaDays(t1, t2 time.Time) int

RoundDeltaDays 计算两个时间之间的天数差异，并四舍五入

func RoundDeltaHours 

func RoundDeltaHours(t1, t2 time.Time) int

RoundDeltaHours 计算两个时间之间的小时数差异，并四舍五入

func RoundDeltaMinutes 

func RoundDeltaMinutes(t1, t2 time.Time) int

RoundDeltaMinutes 计算两个时间之间的分钟数差异，并四舍五入

func Since 

func Since(t time.Time) time.Duration

Since 调用内置时间调节器 BuiltInAdjuster 的 Adjuster.Since 函数

func SmallerFirst 

func SmallerFirst(t1, t2 time.Time) (time.Time, time.Time)

SmallerFirst 将两个时间按照从小到大的顺序排列

func SmallerLast 

func SmallerLast(t1, t2 time.Time) (time.Time, time.Time)

SmallerLast 将两个时间按照从大到小的顺序排列

func StandardExponentialBackoff added in v0.6.0 

func StandardExponentialBackoff(count, maxRetries int, baseDelay, maxDelay time.Duration) time.Duration

StandardExponentialBackoff 退避指数函数用于计算下一次重试将在多长时间后发生，当返回 -1 时表示不再重试

  • count：当前重试次数
  • maxRetries：最大重试次数，当为负数时表示无限重试

该函数将以 2 为基数，0.5 为随机化因子进行计算

func ToDuration 

func ToDuration[V constraints.Number](v V, unit ...time.Duration) time.Duration

ToDuration 将一个数值转换为 time.Duration 类型，当 unit 为空时，默认为纳秒单位

func ToDurationDay 

func ToDurationDay[V constraints.Number](v V) time.Duration

ToDurationDay 将一个数值转换为天的 time.Duration 类型

func ToDurationHour 

func ToDurationHour[V constraints.Number](v V) time.Duration

ToDurationHour 将一个数值转换为小时的 time.Duration 类型

func ToDurationMinute 

func ToDurationMinute[V constraints.Number](v V) time.Duration

ToDurationMinute 将一个数值转换为分钟的 time.Duration 类型

func ToDurationSecond 

func ToDurationSecond[V constraints.Number](v V) time.Duration

ToDurationSecond 将一个数值转换为秒的 time.Duration 类型

func ToDurationWeek 

func ToDurationWeek[V constraints.Number](v V) time.Duration

ToDurationWeek 将一个数值转换为周的 time.Duration 类型

func UnregisterTask 

func UnregisterTask(name string)

UnregisterTask 调用内置时间调度器 BuiltInScheduler 的 Scheduler.UnregisterTask 函数

func Zero 

func Zero() time.Time

Zero 获取一个零值的时间

Types

type Adjuster 

type Adjuster struct {
	// contains filtered or unexported fields
}

Adjuster 时间调节器是一个用于获取偏移时间的工具

func BuiltInAdjuster 

func BuiltInAdjuster() *Adjuster

BuiltInAdjuster 获取内置的由 NewAdjuster(0) 函数创建的时间调节器

func NewAdjuster 

func NewAdjuster(adjust time.Duration) *Adjuster

NewAdjuster 创建一个时间调节器

func (*Adjuster) AddAdjust 

func (a *Adjuster) AddAdjust(adjust time.Duration)

AddAdjust 增加偏移调整的时间量

func (*Adjuster) Adjust 

func (a *Adjuster) Adjust() time.Duration

Adjust 获取偏移调整的时间量

func (*Adjuster) Now 

func (a *Adjuster) Now() time.Time

Now 获取经过偏移调整的当前时间

func (*Adjuster) SetAdjust 

func (a *Adjuster) SetAdjust(adjust time.Duration)

SetAdjust 设置偏移调整的时间量

func (*Adjuster) Since 

func (a *Adjuster) Since(t time.Time) time.Duration

Since 获取经过偏移调整的时间间隔

type Period 

type Period [2]time.Time

Period 表示一个时间段

func NewPeriod 

func NewPeriod(start, end time.Time) Period

NewPeriod 创建一个时间段

  • 如果 start 比 end 晚，则会自动交换两个时间

func NewPeriodWindow 

func NewPeriodWindow(t time.Time, size time.Duration) Period

NewPeriodWindow 创建一个特定长度的时间窗口

func NewPeriodWindowWeek 

func NewPeriodWindowWeek(t time.Time) Period

NewPeriodWindowWeek 创建一周长度的时间窗口，从周一零点开始至周日 23:59:59 结束

func NewPeriodWithDay 

func NewPeriodWithDay(t time.Time, day int) Period

NewPeriodWithDay 创建一个时间段，从 t 开始，持续 day 天

func NewPeriodWithDayZero 

func NewPeriodWithDayZero(t time.Time, day int) Period

NewPeriodWithDayZero 创建一个时间段，从 t 开始，持续到 day 天后的 0 点

func NewPeriodWithHour 

func NewPeriodWithHour(t time.Time, hour int) Period

NewPeriodWithHour 创建一个时间段，从 t 开始，持续 hour 小时

func NewPeriodWithMicrosecond 

func NewPeriodWithMicrosecond(t time.Time, microsecond int) Period

NewPeriodWithMicrosecond 创建一个时间段，从 t 开始，持续 microsecond 微秒

func NewPeriodWithMillisecond 

func NewPeriodWithMillisecond(t time.Time, millisecond int) Period

NewPeriodWithMillisecond 创建一个时间段，从 t 开始，持续 millisecond 毫秒

func NewPeriodWithMinute 

func NewPeriodWithMinute(t time.Time, minute int) Period

NewPeriodWithMinute 创建一个时间段，从 t 开始，持续 minute 分钟

func NewPeriodWithNanosecond 

func NewPeriodWithNanosecond(t time.Time, nanosecond int) Period

NewPeriodWithNanosecond 创建一个时间段，从 t 开始，持续 nanosecond 纳秒

func NewPeriodWithSecond 

func NewPeriodWithSecond(t time.Time, second int) Period

NewPeriodWithSecond 创建一个时间段，从 t 开始，持续 second 秒

func NewPeriodWithTimeArray 

func NewPeriodWithTimeArray(times [2]time.Time) Period

NewPeriodWithTimeArray 创建一个时间段

func (Period) Days 

func (p Period) Days() int

Days 返回时间段的持续天数

func (Period) Duration 

func (p Period) Duration() time.Duration

Duration 返回时间段的持续时间

func (Period) End 

func (p Period) End() time.Time

End 返回时间段的结束时间

func (Period) Hours 

func (p Period) Hours() int

Hours 返回时间段的持续小时数

func (Period) IsAfter 

func (p Period) IsAfter(t time.Time) bool

IsAfter 判断时间段是否在指定时间之后

func (Period) IsBefore 

func (p Period) IsBefore(t time.Time) bool

IsBefore 判断时间段是否在指定时间之前

func (Period) IsBetween 

func (p Period) IsBetween(t time.Time) bool

IsBetween 判断指定时间是否在时间段之间

func (Period) IsBetweenOrEqual 

func (p Period) IsBetweenOrEqual(t time.Time) bool

IsBetweenOrEqual 判断指定时间是否在时间段之间或者等于时间段的开始或结束时间

func (Period) IsBetweenOrEqualPeriod 

func (p Period) IsBetweenOrEqualPeriod(t Period) bool

IsBetweenOrEqualPeriod 判断指定时间是否在时间段之间或者等于时间段的开始或结束时间

func (Period) IsInvalid 

func (p Period) IsInvalid() bool

IsInvalid 判断时间段是否无效

func (Period) IsOngoing 

func (p Period) IsOngoing(t time.Time) bool

IsOngoing 判断指定时间是否正在进行时

  • 如果时间段的开始时间在指定时间之前或者等于指定时间，且时间段的结束时间在指定时间之后，则返回 true

func (Period) IsOverlap 

func (p Period) IsOverlap(t Period) bool

IsOverlap 判断时间段是否与指定时间段重叠

func (Period) IsZero 

func (p Period) IsZero() bool

IsZero 判断时间段是否为零值

func (Period) Microseconds 

func (p Period) Microseconds() int

Microseconds 返回时间段的持续微秒数

func (Period) Milliseconds 

func (p Period) Milliseconds() int

Milliseconds 返回时间段的持续毫秒数

func (Period) Minutes 

func (p Period) Minutes() int

Minutes 返回时间段的持续分钟数

func (Period) Nanoseconds 

func (p Period) Nanoseconds() int

Nanoseconds 返回时间段的持续纳秒数

func (Period) Seconds 

func (p Period) Seconds() int

Seconds 返回时间段的持续秒数

func (Period) Start 

func (p Period) Start() time.Time

Start 返回时间段的开始时间

type Scheduler 

type Scheduler struct {
	// contains filtered or unexported fields
}

Scheduler 并发安全的时间调度器

func BuiltInScheduler 

func BuiltInScheduler() *Scheduler

BuiltInScheduler 获取内置的由 NewScheduler(DefaultSchedulerTick, BuiltInSchedulerWheelSize) 创建的时间调度器

func NewDefaultScheduler 

func NewDefaultScheduler() *Scheduler

NewDefaultScheduler 创建一个默认的时间调度器

  • tick: DefaultSchedulerTick
  • wheelSize: DefaultSchedulerWheelSize

func NewScheduler 

func NewScheduler(tick time.Duration, wheelSize int64) *Scheduler

NewScheduler 创建一个并发安全的时间调度器

  • tick: 时间轮的刻度间隔。
  • wheelSize: 时间轮的大小。

func (*Scheduler) Clear added in v0.6.0 

func (s *Scheduler) Clear()

Clear 清空所有任务但不关闭时间调度器

func (*Scheduler) Close added in v0.6.0 

func (s *Scheduler) Close()

Close 关闭时间调度器并停止所有任务，此后不再可用

func (*Scheduler) GetRegisteredTasks 

func (s *Scheduler) GetRegisteredTasks() []string

GetRegisteredTasks 获取所有未执行完成的任务名称

func (*Scheduler) RegisterAfterTask 

func (s *Scheduler) RegisterAfterTask(name string, after time.Duration, function any, args ...any)

RegisterAfterTask 注册一个在特定时间后执行一次的任务

func (*Scheduler) RegisterCronTask 

func (s *Scheduler) RegisterCronTask(name, expression string, function any, args ...any) error

RegisterCronTask 通过 cron 表达式注册一个任务。

  • 当 cron 表达式错误时，将会返回错误信息

func (*Scheduler) RegisterDayMomentTask 

func (s *Scheduler) RegisterDayMomentTask(name string, lastExecuted time.Time, offset time.Duration, hour, min, sec int, function any, args ...any)

RegisterDayMomentTask 注册一个在每天特定时刻执行的任务

  • 其中 lastExecuted 为上次执行时间，adjust 为时间偏移量，hour、min、sec 为时、分、秒
  • 当上次执行时间被错过时，将会立即执行一次

func (*Scheduler) RegisterImmediateCronTask 

func (s *Scheduler) RegisterImmediateCronTask(name, expression string, function any, args ...any) error

RegisterImmediateCronTask 与 RegisterCronE 相同，但是会立即执行一次

func (*Scheduler) RegisterRepeatedTask 

func (s *Scheduler) RegisterRepeatedTask(name string, after, interval time.Duration, times int, function any, args ...any)

RegisterRepeatedTask 注册一个在特定时间后反复执行的任务

func (*Scheduler) SetExecutor 

func (s *Scheduler) SetExecutor(executor SchedulerExecutor)

SetExecutor 设置任务执行器

func (*Scheduler) UnregisterTask 

func (s *Scheduler) UnregisterTask(name string)

UnregisterTask 取消特定任务的执行计划的注册

  • 如果任务不存在，则不执行任何操作

type SchedulerExecutor added in v0.6.0 

type SchedulerExecutor func(name string, caller func(), separate func())

type StateLine 

type StateLine[State comparable] struct {
	// contains filtered or unexported fields
}

StateLine 表示一个状态时间线，它记录了一系列时间点及其对应的状态和触发器。 在时间线中，每个时间点都与一个状态和一组触发器相关联，可以通过时间点查找状态，并触发与之相关联的触发器。

func NewStateLine 

func NewStateLine[State comparable](zero State) *StateLine[State]

NewStateLine 创建一个从左向右由早到晚的状态时间线

func (*StateLine[State]) AddState 

func (s *StateLine[State]) AddState(state State, t time.Time, onTrigger ...func()) *StateLine[State]

AddState 添加一个状态到时间线中，状态不能与任一时间点重合，否则将被忽略

  • onTrigger: 该状态绑定的触发器，该触发器不会被主动执行，需要主动获取触发器执行

func (*StateLine[State]) AddTriggerToState 

func (s *StateLine[State]) AddTriggerToState(state State, onTrigger ...func()) *StateLine[State]

AddTriggerToState 给指定状态添加触发器

func (*StateLine[State]) Check 

func (s *StateLine[State]) Check(missingAllowed bool, states ...State) bool

Check 根据状态顺序检查时间线是否合法

  • missingAllowed: 是否允许状态缺失，如果为 true，则状态可以不连续，如果为 false，则状态必须连续

状态不连续表示时间线中存在状态缺失，例如：

  • 状态为 [1, 2, 3, 4, 5] 的时间线，如果 missingAllowed 为 true，则状态为 [1, 3, 5] 也是合法的
  • 状态为 [1, 2, 3, 4, 5] 的时间线，如果 missingAllowed 为 false，则状态为 [1, 3, 5] 是不合法的

func (*StateLine[State]) GetIndexByState 

func (s *StateLine[State]) GetIndexByState(state State) int

GetIndexByState 获取指定状态的索引

func (*StateLine[State]) GetLastState 

func (s *StateLine[State]) GetLastState() State

GetLastState 获取最后一个状态

func (*StateLine[State]) GetMissingStates 

func (s *StateLine[State]) GetMissingStates(states ...State) []State

GetMissingStates 获取缺失的状态

func (*StateLine[State]) GetNextStateTimeByIndex 

func (s *StateLine[State]) GetNextStateTimeByIndex(index int) time.Time

GetNextStateTimeByIndex 获取指定索引的下一个时间点

func (*StateLine[State]) GetNextTimeByState 

func (s *StateLine[State]) GetNextTimeByState(state State) time.Time

GetNextTimeByState 获取指定状态的下一个时间点

func (*StateLine[State]) GetPrevStateTimeByIndex 

func (s *StateLine[State]) GetPrevStateTimeByIndex(index int) time.Time

GetPrevStateTimeByIndex 获取指定索引的上一个时间点

func (*StateLine[State]) GetPrevTimeByState 

func (s *StateLine[State]) GetPrevTimeByState(state State) time.Time

GetPrevTimeByState 获取指定状态的上一个时间点

func (*StateLine[State]) GetStateByIndex 

func (s *StateLine[State]) GetStateByIndex(index int) State

GetStateByIndex 获取指定索引的状态

func (*StateLine[State]) GetStateByTime 

func (s *StateLine[State]) GetStateByTime(t time.Time) State

GetStateByTime 获取指定时间点的状态

func (*StateLine[State]) GetStateCount 

func (s *StateLine[State]) GetStateCount() int

GetStateCount 获取状态数量

func (*StateLine[State]) GetStateIndexByTime 

func (s *StateLine[State]) GetStateIndexByTime(t time.Time) int

GetStateIndexByTime 获取指定时间点的索引

func (*StateLine[State]) GetTimeByIndex 

func (s *StateLine[State]) GetTimeByIndex(index int) time.Time

GetTimeByIndex 获取指定索引的时间点

func (*StateLine[State]) GetTimeByState 

func (s *StateLine[State]) GetTimeByState(state State) time.Time

GetTimeByState 获取指定状态的时间点

func (*StateLine[State]) GetTriggerByIndex 

func (s *StateLine[State]) GetTriggerByIndex(index int) []func()

GetTriggerByIndex 获取指定索引的触发器

func (*StateLine[State]) GetTriggerByState 

func (s *StateLine[State]) GetTriggerByState(state State) []func()

GetTriggerByState 获取指定状态的触发器

func (*StateLine[State]) GetTriggerByTime 

func (s *StateLine[State]) GetTriggerByTime(t time.Time) []func()

GetTriggerByTime 获取指定时间点的触发器

func (*StateLine[State]) HasState 

func (s *StateLine[State]) HasState(state State) bool

HasState 检查时间线中是否包含指定状态

func (*StateLine[State]) Iterate 

func (s *StateLine[State]) Iterate(handler func(index int, state State, t time.Time) bool)

Iterate 按照时间顺序遍历时间线

func (*StateLine[State]) IterateReverse 

func (s *StateLine[State]) IterateReverse(handler func(index int, state State, t time.Time) bool)

IterateReverse 按照时间逆序遍历时间线

func (*StateLine[State]) Move 

func (s *StateLine[State]) Move(d time.Duration) *StateLine[State]

Move 时间线整体移动

func (*StateLine[State]) String 

func (s *StateLine[State]) String() string

String 获取时间线的字符串表示

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.