package clock

Import Path
	go.pact.im/x/clock (on go.dev)

Dependency Relation
	imports 2 packages, and imported by 5 packages

Involved Source Files

	   #d clock.go
		Package clock defines basic interfaces to a clock. A clock can be provided by
		the host operating system but also by other packages.

		A clock provides a capability to schedule an arbitrary event to run after at
		least the given duration. On expiry, the event calls a function in its own
		goroutine with the current time argument. All other functions are implemented
		in terms of scheduled events or using an optimized Scheduler implementations.

		A time.Now function signature should be accepted instead of Clock instance
		if a limited capability is required that allows getting the current time but
		not scheduling new events. It is possible to implement Schedule, Timer and
		Ticker in terms of each other interchangeably and hence there is no option to
		limit the scope for these operations.

	      now.go
	      runtime.go
	      ticker.go
	      timer.go
Package-Level Type Names (total 13, in which 8 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Clock (struct)
		A Clock provides a functionality for measuring and displaying time.

		Fields (only one, which is exported)
			Scheduler Scheduler
		Methods (total 5, in which 4 are exported)
			(*Clock) Now() time.Time
				Now returns the current local time.

				Unless the underlying Scheduler implements Timer, Now calls Timer with zero
				duration and uses C on the returned timer to wait for the current time.

			(*Clock) Schedule(d time.Duration, f func(now time.Time)) Event
				Schedule implements the Scheduler interface. It uses the clock provided by
				the host operating system if c is nil or the underlying Scheduler is not set.

			(*Clock) Ticker(d time.Duration) Ticker
				Ticker returns a new Ticker containing a channel that will send the current
				time on the channel after each tick. The period of the ticks is specified by
				the duration argument. The ticker will adjust the time interval or drop ticks
				to make up for slow receivers. The duration d must be greater than zero; if
				not, Ticker will panic. Stop the ticker to release associated resources.

				Unless the underlying Scheduler implements TickerScheduler, Ticker calls
				Timer and resets the returned timer on each tick.

			(*Clock) Timer(d time.Duration) Timer
				Timer creates a new Timer that will send the current time on its channel
				after at least duration d.

				Unless the underlying Scheduler implements TimerScheduler, Timer calls
				Schedule and sends the current time on the channel when the Event expires.

			/* one unexported ... *//* one unexported: */
			(*Clock) sched() Scheduler
				sched returns the Scheduler implementation for this clock.

		Implements (at least 4, all are exported)
			*Clock : NowScheduler
			*Clock : Scheduler
			*Clock : TickerScheduler
			*Clock : TimerScheduler
		As Outputs Of (at least 2, both are exported)
			func NewClock(s Scheduler) *Clock
			func System() *Clock
		As Inputs Of (at least 6, in which 5 are exported)
			func go.pact.im/x/clock/observeclock.NewClock(c *Clock) *observeclock.Clock
			func go.pact.im/x/flaky.(*DebounceExecutor).WithClock(c *Clock) *flaky.DebounceExecutor
			func go.pact.im/x/flaky.(*RetryExecutor).WithClock(c *Clock) *flaky.RetryExecutor
			func go.pact.im/x/flaky.(*ScheduleExecutor).WithClock(c *Clock) *flaky.ScheduleExecutor
			func go.pact.im/x/flaky.(*WatchdogExecutor).WithClock(c *Clock) *flaky.WatchdogExecutor
			/* at least one unexported ... *//* at least one unexported: */
			func newEventTicker(c *Clock, d time.Duration) *eventTicker
		As Types Of (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			  var systemClock

	 type Event (interface)
		The Event type represents a single event. When the Event expires, the
		function is called in its own goroutine.

		Methods (total 2, both are exported)
			( Event) Reset(d time.Duration) bool
				Reset changes the timer to expire after duration d. It returns true
				if the timer had been active, false if the timer had expired or been
				stopped.

				It either reschedules when f will run, in which case Reset returns
				true, or schedules f to run again, in which case it returns false.

				Note that Reset does not guarantee that the subsequent goroutine
				running the function does not run concurrently with the prior one.

			( Event) Stop() bool
				Stop prevents the Event from firing. It returns true if the call
				stops the timer, false if the timer has been stopped or already
				expired and the function has been started in its own goroutine.

				Stop does not wait for function to complete before returning.

		Implemented By (at least 2, in which 1 are exported)
			*time.Timer
			/* at least one unexported ... *//* at least one unexported: */
			*go.pact.im/x/clock/fakeclock.event
		As Outputs Of (at least 9, all are exported)
			func (*Clock).Schedule(d time.Duration, f func(now time.Time)) Event
			func NowScheduler.Schedule(d time.Duration, f func(now time.Time)) Event
			func Scheduler.Schedule(d time.Duration, f func(now time.Time)) Event
			func TickerScheduler.Schedule(d time.Duration, f func(now time.Time)) Event
			func TimerScheduler.Schedule(d time.Duration, f func(now time.Time)) Event
			func go.pact.im/x/clock/fakeclock.(*Clock).Schedule(d time.Duration, f func(now time.Time)) Event
			func go.pact.im/x/clock/mockclock.Clock.Schedule(d time.Duration, f func(now time.Time)) Event
			func go.pact.im/x/clock/mockclock.(*MockClock).Schedule(d time.Duration, f func(time.Time)) Event
			func go.pact.im/x/clock/observeclock.(*Clock).Schedule(d time.Duration, f func(time.Time)) Event

	 type NowScheduler (interface)
		NowScheduler is the interface implemented by a clock that provides an
		optimized implementation of Now.

		Methods (total 2, both are exported)
			( NowScheduler) Now() time.Time
				Now returns the current local time.

			( NowScheduler) Schedule(d time.Duration, f func(now time.Time)) Event
				Schedule schedules an event that calls f in its own goroutine when
				the given duration elapses. It returns an Event that can be canceled
				using the Stop method.

		Implemented By (at least 6, in which 5 are exported)
			*Clock
			*go.pact.im/x/clock/fakeclock.Clock
			 go.pact.im/x/clock/mockclock.Clock (interface)
			*go.pact.im/x/clock/mockclock.MockClock
			*go.pact.im/x/clock/observeclock.Clock
			/* at least one unexported ... *//* at least one unexported: */
			*runtimeClock
		Implements (at least one exported)
			 NowScheduler : Scheduler

	 type Scheduler (interface)
		A Scheduler allows scheduling events to run after duration elapses.

		The Scheduler interface is the minimum implementation required of the clock.
		A clock may implement additional interfaces, such as TimerScheduler, to provide
		additional or optimized functionality.

		It is a low-level interface provided by clock implementations. Users should
		accept Clock instance instead of Scheduler.

		Methods (only one, which is exported)
			( Scheduler) Schedule(d time.Duration, f func(now time.Time)) Event
				Schedule schedules an event that calls f in its own goroutine when
				the given duration elapses. It returns an Event that can be canceled
				using the Stop method.

		Implemented By (at least 9, in which 8 are exported)
			*Clock
			 NowScheduler (interface)
			 TickerScheduler (interface)
			 TimerScheduler (interface)
			*go.pact.im/x/clock/fakeclock.Clock
			 go.pact.im/x/clock/mockclock.Clock (interface)
			*go.pact.im/x/clock/mockclock.MockClock
			*go.pact.im/x/clock/observeclock.Clock
			/* at least one unexported ... *//* at least one unexported: */
			*runtimeClock
		As Outputs Of (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func newRuntimeClock() Scheduler
			func (*Clock).sched() Scheduler
		As Inputs Of (at least 2, both are exported)
			func NewClock(s Scheduler) *Clock
			func go.pact.im/x/clock/observeclock.New(s Scheduler) *observeclock.Clock

	 type Ticker (interface)
		A Ticker holds a channel that delivers “ticks” of a clock at intervals.

		Methods (total 3, all are exported)
			( Ticker) C() <-chan time.Time
				C returns the channel on which the ticks are delivered.

			( Ticker) Reset(d time.Duration)
				Reset stops a ticker and resets its period to the specified duration. The
				next tick will arrive after the new period elapses. The duration d must be
				greater than zero; if not, Reset will panic.

			( Ticker) Stop()
				Stop turns off a ticker. After Stop, no more ticks will be sent. Stop does
				not close the channel, to prevent a concurrent goroutine reading from the
				channel from seeing an erroneous “tick”.

		Implemented By (at least 4, in which 1 are exported)
			*go.pact.im/x/clock/mockclock.MockTicker
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			*eventTicker
			 runtimeTicker
			*go.pact.im/x/clock/fakeclock.ticker
		As Outputs Of (at least 6, all are exported)
			func (*Clock).Ticker(d time.Duration) Ticker
			func TickerScheduler.Ticker(d time.Duration) Ticker
			func go.pact.im/x/clock/fakeclock.(*Clock).Ticker(d time.Duration) Ticker
			func go.pact.im/x/clock/mockclock.Clock.Ticker(d time.Duration) Ticker
			func go.pact.im/x/clock/mockclock.(*MockClock).Ticker(d time.Duration) Ticker
			func go.pact.im/x/clock/observeclock.(*Clock).Ticker(d time.Duration) Ticker

	 type TickerScheduler (interface)
		TickerScheduler is the interface implemented by a clock that provides an
		optimized implementation of Ticker.

		Methods (total 2, both are exported)
			( TickerScheduler) Schedule(d time.Duration, f func(now time.Time)) Event
				Schedule schedules an event that calls f in its own goroutine when
				the given duration elapses. It returns an Event that can be canceled
				using the Stop method.

			( TickerScheduler) Ticker(d time.Duration) Ticker
				Ticker returns a new Ticker containing a channel that will send the time
				on the channel after each tick. The period of the ticks is specified by the
				duration argument. The ticker will adjust the time interval or drop ticks to
				make up for slow receivers. The duration d must be greater than zero; if
				not, Ticker will panic. Stop the ticker to release associated resources.

		Implemented By (at least 6, in which 5 are exported)
			*Clock
			*go.pact.im/x/clock/fakeclock.Clock
			 go.pact.im/x/clock/mockclock.Clock (interface)
			*go.pact.im/x/clock/mockclock.MockClock
			*go.pact.im/x/clock/observeclock.Clock
			/* at least one unexported ... *//* at least one unexported: */
			*runtimeClock
		Implements (at least one exported)
			 TickerScheduler : Scheduler

	 type Timer (interface)
		The Timer type represents a single event. When the Timer expires, the
		current time will be sent on C.

		Methods (total 3, all are exported)
			( Timer) C() <-chan time.Time
				C returns the channel on which the current time is sent when the
				timer expires.

			( Timer) Reset(d time.Duration)
				Reset changes the timer to expire after duration d. Reset should be
				invoked only on stopped or expired timers with drained channels.

				If a program has already received a value from t.C, the timer is known to
				have expired and the channel drained, so t.Reset can be used directly. If a
				program has not yet received a value from t.C, however, the timer must be
				stopped and—if Stop reports that the timer expired before being stopped—the
				channel explicitly drained:

					select {
					case <-t.C():
						// Timer expired.
					case <-done:
						if !t.Stop() {
							<-t.C()
						}
					}
					t.Reset(d)

				Reset should always be invoked on stopped or expired channels, as
				described above. This should not be done concurrent to other receives
				from the Timer’s channel.

			( Timer) Stop() bool
				Stop prevents the Timer from firing. It returns true if the call stops the
				timer, false if the timer has already expired or been stopped. Stop does not
				close the channel, to prevent a read from the channel succeeding incorrectly.

				To ensure the channel is empty after a call to Stop, check the return value
				and drain the channel. For example, assuming the program has not received
				from t.C already:

					if !t.Stop() {
						<-t.C()
					}

				This cannot be done concurrent to other receives from the Timer’s channel or
				other calls to the Timer’s Stop method.

		Implemented By (at least 4, in which 1 are exported)
			*go.pact.im/x/clock/mockclock.MockTimer
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			*eventTimer
			 runtimeTimer
			*go.pact.im/x/clock/fakeclock.timer
		As Outputs Of (at least 6, all are exported)
			func (*Clock).Timer(d time.Duration) Timer
			func TimerScheduler.Timer(d time.Duration) Timer
			func go.pact.im/x/clock/fakeclock.(*Clock).Timer(d time.Duration) Timer
			func go.pact.im/x/clock/mockclock.Clock.Timer(d time.Duration) Timer
			func go.pact.im/x/clock/mockclock.(*MockClock).Timer(d time.Duration) Timer
			func go.pact.im/x/clock/observeclock.(*Clock).Timer(d time.Duration) Timer

	 type TimerScheduler (interface)
		TimerScheduler is the interface implemented by a clock that provides an
		optimized implementation of ScheduleTimer.

		Methods (total 2, both are exported)
			( TimerScheduler) Schedule(d time.Duration, f func(now time.Time)) Event
				Schedule schedules an event that calls f in its own goroutine when
				the given duration elapses. It returns an Event that can be canceled
				using the Stop method.

			( TimerScheduler) Timer(d time.Duration) Timer
				Timer creates a new Timer that will send the current time on
				its channel after at least duration d.

		Implemented By (at least 6, in which 5 are exported)
			*Clock
			*go.pact.im/x/clock/fakeclock.Clock
			 go.pact.im/x/clock/mockclock.Clock (interface)
			*go.pact.im/x/clock/mockclock.MockClock
			*go.pact.im/x/clock/observeclock.Clock
			/* at least one unexported ... *//* at least one unexported: */
			*runtimeClock
		Implements (at least one exported)
			 TimerScheduler : Scheduler

	/* 5 unexporteds ... *//* 5 unexporteds: */
	 type eventTicker (struct)
		eventTicker implements Ticker interface using a Timer. It intercepts timer’s
		channel and then resets it to continue ticking.

		Fields (total 8, none are exported)
			/* 8 unexporteds ... *//* 8 unexporteds: */
			c chan time.Time
			mu sync.Mutex
			resetTimer bool
			resetc chan time.Duration
			stopc chan struct{}
			stopped bool
			t Timer
			wg sync.WaitGroup
		Methods (total 8, in which 3 are exported)
			(*eventTicker) C() <-chan time.Time
				C implements the Ticker interface.

			(*eventTicker) Reset(d time.Duration)
				Reset implements the Ticker interface.

			(*eventTicker) Stop()
				Stop implements the Ticker interface.

			/* 5 unexporteds ... *//* 5 unexporteds: */
			(*eventTicker) reset(d time.Duration)
			(*eventTicker) run(d time.Duration)
			(*eventTicker) start(d time.Duration)
			(*eventTicker) stop()
			(*eventTicker) stopTimer()
		Implements (at least one exported)
			*eventTicker : Ticker
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newEventTicker(c *Clock, d time.Duration) *eventTicker

	 type eventTimer (struct)
		eventTimer is a Timer adapter for Event.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			c chan time.Time
			e Event
		Methods (total 3, all are exported)
			(*eventTimer) C() <-chan time.Time
				C implements the Timer interface.

			(*eventTimer) Reset(d time.Duration)
				Reset implements the Timer interface.

			(*eventTimer) Stop() bool
				Stop implements the Timer interface.

		Implements (at least one exported)
			*eventTimer : Timer

	 type runtimeClock (struct)
		runtimeClock is a clock provided by the host operating system and Go runtime.

		Methods (total 4, all are exported)
			(*runtimeClock) Now() time.Time
				Now implements the NowScheduler interface.

			(*runtimeClock) Schedule(d time.Duration, f func(now time.Time)) Event
				Scheduler implements the Scheduler interface.

			(*runtimeClock) Ticker(d time.Duration) Ticker
				Ticker implements the TickerScheduler interface.

			(*runtimeClock) Timer(d time.Duration) Timer
				Timer implements the TimerScheduler interface.

		Implements (at least 4, all are exported)
			*runtimeClock : NowScheduler
			*runtimeClock : Scheduler
			*runtimeClock : TickerScheduler
			*runtimeClock : TimerScheduler

	 type runtimeTicker (struct)
		runtimeTicker is a Ticker adapter for time.Ticker type.

		Fields (total 2, in which 1 are exported)
			Ticker *time.Ticker
			/* one unexported ... *//* one unexported: */
			Ticker.r time.runtimeTimer
		Methods (total 3, all are exported)
			( runtimeTicker) C() <-chan time.Time
				C implements the Ticker interface.

			( runtimeTicker) Reset(d time.Duration)
				Reset stops a ticker and resets its period to the specified duration.
				The next tick will arrive after the new period elapses. The duration d
				must be greater than zero; if not, Reset will panic.

			( runtimeTicker) Stop()
				Stop turns off a ticker. After Stop, no more ticks will be sent.
				Stop does not close the channel, to prevent a concurrent goroutine
				reading from the channel from seeing an erroneous "tick".

		Implements (at least one exported)
			 runtimeTicker : Ticker

	 type runtimeTimer (struct)
		runtimeTimer is a Timer adapter for time.Timer type.

		Fields (total 2, in which 1 are exported)
			Timer *time.Timer
			/* one unexported ... *//* one unexported: */
			Timer.r time.runtimeTimer
		Methods (total 3, all are exported)
			( runtimeTimer) C() <-chan time.Time
				C implements the Timer interface.

			( runtimeTimer) Reset(d time.Duration)
				Reset implements the Timer interface.

			( runtimeTimer) Stop() bool
				Stop prevents the Timer from firing.
				It returns true if the call stops the timer, false if the timer has already
				expired or been stopped.
				Stop does not close the channel, to prevent a read from the channel succeeding
				incorrectly.

				To ensure the channel is empty after a call to Stop, check the
				return value and drain the channel.
				For example, assuming the program has not received from t.C already:

					if !t.Stop() {
						<-t.C
					}

				This cannot be done concurrent to other receives from the Timer's
				channel or other calls to the Timer's Stop method.

				For a timer created with AfterFunc(d, f), if t.Stop returns false, then the timer
				has already expired and the function f has been started in its own goroutine;
				Stop does not wait for f to complete before returning.
				If the caller needs to know whether f is completed, it must coordinate
				with f explicitly.

		Implements (at least one exported)
			 runtimeTimer : Timer


Package-Level Functions (total 4, in which 2 are exported)

	 func NewClock(s Scheduler) *Clock
		NewClock returns a new Clock that uses the given Scheduler to schedule events
		and measure time.

	 func System() *Clock
		System returns a clock provided by the host operating system.

	/* 2 unexporteds ... *//* 2 unexporteds: */
	 func newEventTicker(c *Clock, d time.Duration) *eventTicker
	 func newRuntimeClock() Scheduler
		newRuntimeClock returns a new runtimeClock instance that satisfies Scheduler.


Package-Level Variables (only one, which is unexported)

	/* one unexported ... *//* one unexported: */
	  var systemClock Clock
		systemClock is the Clock instance with runtimeClock Scheduler implementation.

The pages are generated with Golds v0.4.9. (GOOS=linux GOARCH=amd64)