package fxclock

Import Path
	go.uber.org/fx/internal/fxclock (on go.dev)

Dependency Relation
	imports 4 packages, and imported by 2 packages

Involved Source Files

	    clock.go
Package-Level Type Names (total 2)

	/* sort by: alphabet | popularity */
	 type Clock (interface)
		Clock defines how Fx accesses time.
		We keep the interface pretty minimal.

		Methods (total 4)
			( Clock) Now() time.Time
			( Clock) Since(time.Time) time.Duration
			( Clock) Sleep(time.Duration)
			( Clock) WithTimeout(context.Context, time.Duration) (context.Context, context.CancelFunc)
		Implemented By (at least 3)
			*Mock
			 github.com/benbjohnson/clock.Clock (interface)
			*github.com/benbjohnson/clock.Mock
		Implements (at least 5)
			 Clock : go.uber.org/dig/internal/digclock.Clock
			 Clock : github.com/hibiken/asynq/internal/timeutil.Clock
			 Clock : github.com/pion/stun.Clock
			 Clock : github.com/pion/stun/v3.Clock
			 Clock : github.com/quic-go/quic-go/internal/congestion.Clock
		As Inputs Of (at least one exported)
			func go.uber.org/fx/internal/lifecycle.New(logger fxevent.Logger, clock Clock) *lifecycle.Lifecycle
		As Types Of (only one)
			  var System

	 type Mock (struct)
		Mock is a fake source of time.
		It implements standard time operations,
		but allows the user to control the passage of time.
		
		Use the [Add] method to progress time.

		Methods (total 6)
			(*Mock) Add(d time.Duration)
				Add progresses time by the given duration.
				Other operations waiting for the time to advance
				will be resolved if they are within range.
				
				Side effects of operations waiting for the time to advance
				will take effect on a best-effort basis.
				Avoid racing with operations that have side effects.
				
				Panics if the duration is negative.

			(*Mock) AwaitScheduled(n int)
				AwaitScheduled blocks until there are at least N
				operations scheduled for the future.

			(*Mock) Now() time.Time
				Now reports the current time.

			(*Mock) Since(t time.Time) time.Duration
				Since reports the time elapsed since t.
				This is short for Now().Sub(t).

			(*Mock) Sleep(d time.Duration)
				Sleep pauses the current goroutine for the given duration.
				
				With the mock clock, this will freeze
				until the clock is advanced with [Add] past the deadline.

			(*Mock) WithTimeout(ctx context.Context, d time.Duration) (context.Context, context.CancelFunc)
				WithTimeout returns a new context with a deadline of now + d.
				
				When the deadline is passed, the returned context's Done channel is closed
				and the context's Err method returns context.DeadlineExceeded.
				If the cancel function is called before the deadline is passed,
				the context's Err method returns context.Canceled.

		Implements (at least 6)
			*Mock : Clock
			*Mock : go.uber.org/dig/internal/digclock.Clock
			*Mock : github.com/hibiken/asynq/internal/timeutil.Clock
			*Mock : github.com/pion/stun.Clock
			*Mock : github.com/pion/stun/v3.Clock
			*Mock : github.com/quic-go/quic-go/internal/congestion.Clock
		As Outputs Of (at least one exported)
			func NewMock() *Mock


Package-Level Functions (only one)

	 func NewMock() *Mock
		NewMock builds a new mock clock
		using the current actual time as the initial time.


Package-Level Variables (only one)

	  var System Clock
		System is the default implementation of Clock based on real time.

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.