File Manager

X7ROOT File Manager

Current Path: /opt/golang/1.17.2/src/time

📁 ..
📄 embed.go(325 B)
📄 example_test.go(19.97 KB)
📄 export_android_test.go(318 B)
📄 export_test.go(3.75 KB)
📄 export_windows_test.go(514 B)
📄 format.go(45.91 KB)
📄 format_test.go(28.93 KB)
📄 genzabbrs.go(2.97 KB)
📄 internal_test.go(1.91 KB)
📄 mono_test.go(7.51 KB)
📄 sleep.go(5.83 KB)
📄 sleep_test.go(18.33 KB)
📄 sys_plan9.go(1.01 KB)
📄 sys_unix.go(1.16 KB)
📄 sys_windows.go(996 B)
📁 testdata
📄 tick.go(2.16 KB)
📄 tick_test.go(3.54 KB)
📄 time.go(46.46 KB)
📄 time_test.go(45.1 KB)
📁 tzdata
📄 tzdata_test.go(2.48 KB)
📄 zoneinfo.go(17.2 KB)
📄 zoneinfo_abbrs_windows.go(10.34 KB)
📄 zoneinfo_android.go(2.05 KB)
📄 zoneinfo_android_test.go(408 B)
📄 zoneinfo_ios.go(1.01 KB)
📄 zoneinfo_js.go(1.58 KB)
📄 zoneinfo_plan9.go(2.71 KB)
📄 zoneinfo_read.go(13.98 KB)
📄 zoneinfo_test.go(9.81 KB)
📄 zoneinfo_unix.go(1.84 KB)
📄 zoneinfo_unix_test.go(2.46 KB)
📄 zoneinfo_windows.go(6.68 KB)
📄 zoneinfo_windows_test.go(1.9 KB)

Editing: tick.go

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package time

import "errors"

// A Ticker holds a channel that delivers ``ticks'' of a clock
// at intervals.
type Ticker struct {
	C <-chan Time // The channel on which the ticks are delivered.
	r runtimeTimer
}

// NewTicker 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, NewTicker will
// panic. Stop the ticker to release associated resources.
func NewTicker(d Duration) *Ticker {
	if d <= 0 {
		panic(errors.New("non-positive interval for NewTicker"))
	}
	// Give the channel a 1-element time buffer.
	// If the client falls behind while reading, we drop ticks
	// on the floor until the client catches up.
	c := make(chan Time, 1)
	t := &Ticker{
		C: c,
		r: runtimeTimer{
			when:   when(d),
			period: int64(d),
			f:      sendTime,
			arg:    c,
		},
	}
	startTimer(&t.r)
	return t
}

// 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".
func (t *Ticker) Stop() {
	stopTimer(&t.r)
}

// Reset stops a ticker and resets its period to the specified duration.
// The next tick will arrive after the new period elapses.
func (t *Ticker) Reset(d Duration) {
	if t.r.f == nil {
		panic("time: Reset called on uninitialized Ticker")
	}
	modTimer(&t.r, when(d), int64(d), t.r.f, t.r.arg, t.r.seq)
}

// Tick is a convenience wrapper for NewTicker providing access to the ticking
// channel only. While Tick is useful for clients that have no need to shut down
// the Ticker, be aware that without a way to shut it down the underlying
// Ticker cannot be recovered by the garbage collector; it "leaks".
// Unlike NewTicker, Tick will return nil if d <= 0.
func Tick(d Duration) <-chan Time {
	if d <= 0 {
		return nil
	}
	return NewTicker(d).C
}

X7ROOT File Manager

Editing: tick.go

Upload File

Create Folder