timeutil

package

v1.0.0-beta.214 Latest Latest Go to latest Published: Jun 25, 2025 License: Apache-2.0 Imports: 6 Imported by: 0

Documentation ¶

Index ¶

Constants
func AsTimed[T any](fn func(T) time.Time) func(T) Timed[T]
func Compare(a, b time.Time) int
type ClosedPeriod
type OpenPeriod
type Period
type Recurrence
- func RecurrenceFromISODuration(p *isodate.Period, anchor time.Time) (Recurrence, error)
type RecurrenceInterval
type SimpleTimeline
- func NewSimpleTimeline(times []time.Time) SimpleTimeline
type Timed
type Timeline
- func NewTimeline[T any](times []Timed[T]) Timeline[T]

Constants ¶

const MAX_SAFE_ITERATIONS = 10000

Variables ¶

This section is empty.

Functions ¶

func AsTimed ¶

func AsTimed[T any](fn func(T) time.Time) func(T) Timed[T]

AsTimed returns a function that converts a value of type T to a Timed value.

func Compare ¶

func Compare(a, b time.Time) int

Types ¶

type ClosedPeriod ¶

type ClosedPeriod struct {
	From time.Time `json:"from"`
	To   time.Time `json:"to"`
}

func (ClosedPeriod) Contains ¶

func (p ClosedPeriod) Contains(t time.Time) bool

Inclusive at start, exclusive at end

func (ClosedPeriod) ContainsExclusive ¶

func (p ClosedPeriod) ContainsExclusive(t time.Time) bool

Exclusive at both start and end

func (ClosedPeriod) ContainsInclusive ¶

func (p ClosedPeriod) ContainsInclusive(t time.Time) bool

Inclusive at both start and end

func (ClosedPeriod) Duration ¶

func (p ClosedPeriod) Duration() time.Duration

func (ClosedPeriod) Intersection ¶

func (p ClosedPeriod) Intersection(other ClosedPeriod) *ClosedPeriod

func (ClosedPeriod) Open ¶

func (p ClosedPeriod) Open() OpenPeriod

func (ClosedPeriod) Overlaps ¶

func (p ClosedPeriod) Overlaps(other ClosedPeriod) bool

Returns true if the two periods overlap at any point Returns false if the periods are exactly sequential, e.g.: [1, 2] and [2, 3]

func (ClosedPeriod) OverlapsInclusive ¶

func (p ClosedPeriod) OverlapsInclusive(other ClosedPeriod) bool

Returns true if the two periods overlap at any point Returns true if the periods are exactly sequential, e.g.: [1, 2] and [2, 3]

type OpenPeriod ¶

type OpenPeriod struct {
	From *time.Time `json:"from,omitempty"`
	To   *time.Time `json:"to,omitempty"`
}

func (OpenPeriod) Closed ¶

func (p OpenPeriod) Closed() (ClosedPeriod, error)

func (OpenPeriod) Contains ¶

func (p OpenPeriod) Contains(t time.Time) bool

Inclusive at start, exclusive at end

func (OpenPeriod) ContainsExclusive ¶

func (p OpenPeriod) ContainsExclusive(t time.Time) bool

Exclusive at both start and end

func (OpenPeriod) ContainsInclusive ¶

func (p OpenPeriod) ContainsInclusive(t time.Time) bool

Inclusive at both start and end

func (OpenPeriod) Difference ¶

func (p OpenPeriod) Difference(other OpenPeriod) []OpenPeriod

Difference returns P - Other (times in P not in Other)

func (OpenPeriod) Equals ¶

func (p OpenPeriod) Equals(other OpenPeriod) bool

func (OpenPeriod) Intersection ¶

func (p OpenPeriod) Intersection(other OpenPeriod) *OpenPeriod

func (OpenPeriod) IsSupersetOf ¶

func (p OpenPeriod) IsSupersetOf(other OpenPeriod) bool

IsSupersetOf returns true if p contains other (both ends inclusive)

func (OpenPeriod) Union ¶

func (p OpenPeriod) Union(other OpenPeriod) OpenPeriod

type Period ¶

type Period interface {
	// Inclusive at both start and end
	ContainsInclusive(t time.Time) bool
	// Exclusive at both start and end
	ContainsExclusive(t time.Time) bool
	// Inclusive at start, exclusive at end
	Contains(t time.Time) bool
}

type Recurrence ¶

type Recurrence struct {
	Interval RecurrenceInterval `json:"period"`
	// Anchor can be an arbitrary anchor time for the recurrence.
	// It does not have to be the last or the next time.
	Anchor time.Time `json:"anchor"`
}

func RecurrenceFromISODuration ¶

func RecurrenceFromISODuration(p *isodate.Period, anchor time.Time) (Recurrence, error)

func (Recurrence) GetPeriodAt ¶

func (r Recurrence) GetPeriodAt(t time.Time) (ClosedPeriod, error)

Returns a period where p.Contains(t) is true

func (Recurrence) Next ¶

func (r Recurrence) Next(t time.Time) (time.Time, error)

func (Recurrence) NextAfter ¶

func (r Recurrence) NextAfter(t time.Time) (time.Time, error)

NextAfter returns the next time after t that the recurrence should occur. If at t the recurrence should occur, it will return t.

func (Recurrence) Prev ¶

func (r Recurrence) Prev(t time.Time) (time.Time, error)

func (Recurrence) PrevBefore ¶

func (r Recurrence) PrevBefore(t time.Time) (time.Time, error)

PrevBefore returns the previous time before t that the recurrence should occur.

func (Recurrence) Validate ¶

func (r Recurrence) Validate() error

type RecurrenceInterval ¶

type RecurrenceInterval struct {
	isodate.Period
}

var (
	RecurrencePeriodDaily RecurrenceInterval = RecurrenceInterval{isodate.NewPeriod(0, 0, 0, 1, 0, 0, 0)}
	RecurrencePeriodWeek  RecurrenceInterval = RecurrenceInterval{isodate.NewPeriod(0, 0, 1, 0, 0, 0, 0)}
	RecurrencePeriodMonth RecurrenceInterval = RecurrenceInterval{isodate.NewPeriod(0, 1, 0, 0, 0, 0, 0)}
	RecurrencePeriodYear  RecurrenceInterval = RecurrenceInterval{isodate.NewPeriod(1, 0, 0, 0, 0, 0, 0)}
)

type SimpleTimeline ¶

type SimpleTimeline = Timeline[time.Time]

func NewSimpleTimeline ¶

func NewSimpleTimeline(times []time.Time) SimpleTimeline

type Timed ¶

type Timed[T any] struct {
	// contains filtered or unexported fields
}

func (Timed[T]) Equal ¶

func (t Timed[T]) Equal(other Timed[T]) bool

func (Timed[T]) GetTime ¶

func (t Timed[T]) GetTime() time.Time

func (Timed[T]) GetValue ¶

func (t Timed[T]) GetValue() T

type Timeline ¶

type Timeline[T any] struct {
	// contains filtered or unexported fields
}

func NewTimeline ¶

func NewTimeline[T any](times []Timed[T]) Timeline[T]

func (Timeline[T]) After ¶

func (t Timeline[T]) After(at time.Time) Timeline[T]

func (Timeline[T]) Before ¶

func (t Timeline[T]) Before(at time.Time) Timeline[T]

func (Timeline[T]) GetAt ¶

func (t Timeline[T]) GetAt(idx int) Timed[T]

func (Timeline[T]) GetBoundingPeriod ¶

func (t Timeline[T]) GetBoundingPeriod() ClosedPeriod

func (Timeline[T]) GetClosedPeriods ¶

func (t Timeline[T]) GetClosedPeriods() []ClosedPeriod

GetClosedPeriods returns the closed periods between the times in the timeline.

func (Timeline[T]) GetOpenPeriods ¶

func (t Timeline[T]) GetOpenPeriods() []OpenPeriod

GetOpenPeriods returns the open periods between the times in the timeline. For non-empty timelines, the first and last periods will be open at the start and end of the timeline respectively while the rest will effectively be closed.

func (Timeline[T]) GetTimes ¶

func (t Timeline[T]) GetTimes() []time.Time

Source Files ¶

View all Source files

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL