Documentation

Index

Constants

View Source
const InfDuration = time.Duration(math.MaxInt64)

    InfDuration is a duration of infinite length

    Variables

    This section is empty.

    Functions

    func AbsDuration

    func AbsDuration(d time.Duration) time.Duration

      AbsDuration returns the absolute value of a time duration

      func IsIPv4

      func IsIPv4(ip net.IP) bool

      func Max

      func Max(a, b int) int

        Max returns the maximum of two Ints

        func MaxByteCount

        func MaxByteCount(a, b protocol.ByteCount) protocol.ByteCount

          MaxByteCount returns the maximum of two ByteCounts

          func MaxDuration

          func MaxDuration(a, b time.Duration) time.Duration

            MaxDuration returns the max duration

            func MaxInt64

            func MaxInt64(a, b int64) int64

              MaxInt64 returns the minimum of two int64

              func MaxPacketNumber

              func MaxPacketNumber(a, b protocol.PacketNumber) protocol.PacketNumber

                MaxPacketNumber returns the max packet number

                func MaxTime

                func MaxTime(a, b time.Time) time.Time

                  MaxTime returns the later time

                  func MaxUint32

                  func MaxUint32(a, b uint32) uint32

                    MaxUint32 returns the maximum of two uint32

                    func MaxUint64

                    func MaxUint64(a, b uint64) uint64

                      MaxUint64 returns the maximum of two uint64

                      func Min

                      func Min(a, b int) int

                        Min returns the minimum of two Ints

                        func MinByteCount

                        func MinByteCount(a, b protocol.ByteCount) protocol.ByteCount

                          MinByteCount returns the minimum of two ByteCounts

                          func MinDuration

                          func MinDuration(a, b time.Duration) time.Duration

                            MinDuration returns the minimum duration

                            func MinInt64

                            func MinInt64(a, b int64) int64

                              MinInt64 returns the minimum of two int64

                              func MinNonZeroDuration

                              func MinNonZeroDuration(a, b time.Duration) time.Duration

                                MinNonZeroDuration return the minimum duration that's not zero.

                                func MinNonZeroTime

                                func MinNonZeroTime(a, b time.Time) time.Time

                                  MinNonZeroTime returns the earlist time that is not time.Time{} If both a and b are time.Time{}, it returns time.Time{}

                                  func MinPacketNumber

                                  func MinPacketNumber(a, b protocol.PacketNumber) protocol.PacketNumber

                                    MinPacketNumber returns the min packet number

                                    func MinTime

                                    func MinTime(a, b time.Time) time.Time

                                      MinTime returns the earlier time

                                      func MinUint32

                                      func MinUint32(a, b uint32) uint32

                                        MinUint32 returns the maximum of two uint32

                                        func MinUint64

                                        func MinUint64(a, b uint64) uint64

                                          MinUint64 returns the maximum of two uint64

                                          func NewBufferedWriteCloser

                                          func NewBufferedWriteCloser(writer *bufio.Writer, closer io.Closer) io.WriteCloser

                                            NewBufferedWriteCloser creates an io.WriteCloser from a bufio.Writer and an io.Closer

                                            func ReadVarInt

                                            func ReadVarInt(b io.ByteReader) (uint64, error)

                                              ReadVarInt reads a number in the QUIC varint format

                                              func VarIntLen

                                              func VarIntLen(i uint64) protocol.ByteCount

                                                VarIntLen determines the number of bytes that will be needed to write a number

                                                func WriteVarInt

                                                func WriteVarInt(b *bytes.Buffer, i uint64)

                                                  WriteVarInt writes a number in the QUIC varint format

                                                  func WriteVarIntWithLen

                                                  func WriteVarIntWithLen(b *bytes.Buffer, i uint64, length protocol.ByteCount)

                                                    WriteVarIntWithLen writes a number in the QUIC varint format, with the desired length.

                                                    Types

                                                    type AtomicBool

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

                                                      An AtomicBool is an atomic bool

                                                      func (*AtomicBool) Get

                                                      func (a *AtomicBool) Get() bool

                                                        Get gets the value

                                                        func (*AtomicBool) Set

                                                        func (a *AtomicBool) Set(value bool)

                                                          Set sets the value

                                                          type ByteInterval

                                                          type ByteInterval struct {
                                                          	Start protocol.ByteCount
                                                          	End   protocol.ByteCount
                                                          }

                                                            ByteInterval is an interval from one ByteCount to the other

                                                            type ByteIntervalElement

                                                            type ByteIntervalElement struct {
                                                            
                                                            	// The value stored with this element.
                                                            	Value ByteInterval
                                                            	// contains filtered or unexported fields
                                                            }

                                                              ByteIntervalElement is an element of a linked list.

                                                              func (*ByteIntervalElement) Next

                                                                Next returns the next list element or nil.

                                                                func (*ByteIntervalElement) Prev

                                                                  Prev returns the previous list element or nil.

                                                                  type ByteIntervalList

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

                                                                    ByteIntervalList is a linked list of ByteIntervals.

                                                                    func NewByteIntervalList

                                                                    func NewByteIntervalList() *ByteIntervalList

                                                                      NewByteIntervalList returns an initialized list.

                                                                      func (*ByteIntervalList) Back

                                                                        Back returns the last element of list l or nil if the list is empty.

                                                                        func (*ByteIntervalList) Front

                                                                          Front returns the first element of list l or nil if the list is empty.

                                                                          func (*ByteIntervalList) Init

                                                                            Init initializes or clears list l.

                                                                            func (*ByteIntervalList) InsertAfter

                                                                              InsertAfter inserts a new element e with value v immediately after mark and returns e. If mark is not an element of l, the list is not modified. The mark must not be nil.

                                                                              func (*ByteIntervalList) InsertBefore

                                                                                InsertBefore inserts a new element e with value v immediately before mark and returns e. If mark is not an element of l, the list is not modified. The mark must not be nil.

                                                                                func (*ByteIntervalList) Len

                                                                                func (l *ByteIntervalList) Len() int

                                                                                  Len returns the number of elements of list l. The complexity is O(1).

                                                                                  func (*ByteIntervalList) MoveAfter

                                                                                  func (l *ByteIntervalList) MoveAfter(e, mark *ByteIntervalElement)

                                                                                    MoveAfter moves element e to its new position after mark. If e or mark is not an element of l, or e == mark, the list is not modified. The element and mark must not be nil.

                                                                                    func (*ByteIntervalList) MoveBefore

                                                                                    func (l *ByteIntervalList) MoveBefore(e, mark *ByteIntervalElement)

                                                                                      MoveBefore moves element e to its new position before mark. If e or mark is not an element of l, or e == mark, the list is not modified. The element and mark must not be nil.

                                                                                      func (*ByteIntervalList) MoveToBack

                                                                                      func (l *ByteIntervalList) MoveToBack(e *ByteIntervalElement)

                                                                                        MoveToBack moves element e to the back of list l. If e is not an element of l, the list is not modified. The element must not be nil.

                                                                                        func (*ByteIntervalList) MoveToFront

                                                                                        func (l *ByteIntervalList) MoveToFront(e *ByteIntervalElement)

                                                                                          MoveToFront moves element e to the front of list l. If e is not an element of l, the list is not modified. The element must not be nil.

                                                                                          func (*ByteIntervalList) PushBack

                                                                                            PushBack inserts a new element e with value v at the back of list l and returns e.

                                                                                            func (*ByteIntervalList) PushBackList

                                                                                            func (l *ByteIntervalList) PushBackList(other *ByteIntervalList)

                                                                                              PushBackList inserts a copy of an other list at the back of list l. The lists l and other may be the same. They must not be nil.

                                                                                              func (*ByteIntervalList) PushFront

                                                                                                PushFront inserts a new element e with value v at the front of list l and returns e.

                                                                                                func (*ByteIntervalList) PushFrontList

                                                                                                func (l *ByteIntervalList) PushFrontList(other *ByteIntervalList)

                                                                                                  PushFrontList inserts a copy of an other list at the front of list l. The lists l and other may be the same. They must not be nil.

                                                                                                  func (*ByteIntervalList) Remove

                                                                                                    Remove removes e from l if e is an element of list l. It returns the element value e.Value. The element must not be nil.

                                                                                                    type ByteOrder

                                                                                                    type ByteOrder interface {
                                                                                                    	ReadUint32(io.ByteReader) (uint32, error)
                                                                                                    	ReadUint24(io.ByteReader) (uint32, error)
                                                                                                    	ReadUint16(io.ByteReader) (uint16, error)
                                                                                                    
                                                                                                    	WriteUint32(*bytes.Buffer, uint32)
                                                                                                    	WriteUint24(*bytes.Buffer, uint32)
                                                                                                    	WriteUint16(*bytes.Buffer, uint16)
                                                                                                    }

                                                                                                      A ByteOrder specifies how to convert byte sequences into 16-, 32-, or 64-bit unsigned integers.

                                                                                                      var BigEndian ByteOrder = bigEndian{}

                                                                                                        BigEndian is the big-endian implementation of ByteOrder.

                                                                                                        type LogLevel

                                                                                                        type LogLevel uint8

                                                                                                          LogLevel of quic-go

                                                                                                          const (
                                                                                                          	// LogLevelNothing disables
                                                                                                          	LogLevelNothing LogLevel = iota
                                                                                                          	// LogLevelError enables err logs
                                                                                                          	LogLevelError
                                                                                                          	// LogLevelInfo enables info logs (e.g. packets)
                                                                                                          	LogLevelInfo
                                                                                                          	// LogLevelDebug enables debug logs (e.g. packet contents)
                                                                                                          	LogLevelDebug
                                                                                                          )

                                                                                                          type Logger

                                                                                                          type Logger interface {
                                                                                                          	SetLogLevel(LogLevel)
                                                                                                          	SetLogTimeFormat(format string)
                                                                                                          	WithPrefix(prefix string) Logger
                                                                                                          	Debug() bool
                                                                                                          
                                                                                                          	Errorf(format string, args ...interface{})
                                                                                                          	Infof(format string, args ...interface{})
                                                                                                          	Debugf(format string, args ...interface{})
                                                                                                          }

                                                                                                            A Logger logs.

                                                                                                            var DefaultLogger Logger

                                                                                                              DefaultLogger is used by quic-go for logging.

                                                                                                              type NewConnectionID

                                                                                                              type NewConnectionID struct {
                                                                                                              	SequenceNumber      uint64
                                                                                                              	ConnectionID        protocol.ConnectionID
                                                                                                              	StatelessResetToken protocol.StatelessResetToken
                                                                                                              }

                                                                                                                NewConnectionID is a new connection ID

                                                                                                                type NewConnectionIDElement

                                                                                                                type NewConnectionIDElement struct {
                                                                                                                
                                                                                                                	// The value stored with this element.
                                                                                                                	Value NewConnectionID
                                                                                                                	// contains filtered or unexported fields
                                                                                                                }

                                                                                                                  NewConnectionIDElement is an element of a linked list.

                                                                                                                  func (*NewConnectionIDElement) Next

                                                                                                                    Next returns the next list element or nil.

                                                                                                                    func (*NewConnectionIDElement) Prev

                                                                                                                      Prev returns the previous list element or nil.

                                                                                                                      type NewConnectionIDList

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

                                                                                                                        NewConnectionIDList is a linked list of NewConnectionIDs.

                                                                                                                        func NewNewConnectionIDList

                                                                                                                        func NewNewConnectionIDList() *NewConnectionIDList

                                                                                                                          NewNewConnectionIDList returns an initialized list.

                                                                                                                          func (*NewConnectionIDList) Back

                                                                                                                            Back returns the last element of list l or nil if the list is empty.

                                                                                                                            func (*NewConnectionIDList) Front

                                                                                                                              Front returns the first element of list l or nil if the list is empty.

                                                                                                                              func (*NewConnectionIDList) Init

                                                                                                                                Init initializes or clears list l.

                                                                                                                                func (*NewConnectionIDList) InsertAfter

                                                                                                                                  InsertAfter inserts a new element e with value v immediately after mark and returns e. If mark is not an element of l, the list is not modified. The mark must not be nil.

                                                                                                                                  func (*NewConnectionIDList) InsertBefore

                                                                                                                                    InsertBefore inserts a new element e with value v immediately before mark and returns e. If mark is not an element of l, the list is not modified. The mark must not be nil.

                                                                                                                                    func (*NewConnectionIDList) Len

                                                                                                                                    func (l *NewConnectionIDList) Len() int

                                                                                                                                      Len returns the number of elements of list l. The complexity is O(1).

                                                                                                                                      func (*NewConnectionIDList) MoveAfter

                                                                                                                                      func (l *NewConnectionIDList) MoveAfter(e, mark *NewConnectionIDElement)

                                                                                                                                        MoveAfter moves element e to its new position after mark. If e or mark is not an element of l, or e == mark, the list is not modified. The element and mark must not be nil.

                                                                                                                                        func (*NewConnectionIDList) MoveBefore

                                                                                                                                        func (l *NewConnectionIDList) MoveBefore(e, mark *NewConnectionIDElement)

                                                                                                                                          MoveBefore moves element e to its new position before mark. If e or mark is not an element of l, or e == mark, the list is not modified. The element and mark must not be nil.

                                                                                                                                          func (*NewConnectionIDList) MoveToBack

                                                                                                                                          func (l *NewConnectionIDList) MoveToBack(e *NewConnectionIDElement)

                                                                                                                                            MoveToBack moves element e to the back of list l. If e is not an element of l, the list is not modified. The element must not be nil.

                                                                                                                                            func (*NewConnectionIDList) MoveToFront

                                                                                                                                            func (l *NewConnectionIDList) MoveToFront(e *NewConnectionIDElement)

                                                                                                                                              MoveToFront moves element e to the front of list l. If e is not an element of l, the list is not modified. The element must not be nil.

                                                                                                                                              func (*NewConnectionIDList) PushBack

                                                                                                                                                PushBack inserts a new element e with value v at the back of list l and returns e.

                                                                                                                                                func (*NewConnectionIDList) PushBackList

                                                                                                                                                func (l *NewConnectionIDList) PushBackList(other *NewConnectionIDList)

                                                                                                                                                  PushBackList inserts a copy of an other list at the back of list l. The lists l and other may be the same. They must not be nil.

                                                                                                                                                  func (*NewConnectionIDList) PushFront

                                                                                                                                                    PushFront inserts a new element e with value v at the front of list l and returns e.

                                                                                                                                                    func (*NewConnectionIDList) PushFrontList

                                                                                                                                                    func (l *NewConnectionIDList) PushFrontList(other *NewConnectionIDList)

                                                                                                                                                      PushFrontList inserts a copy of an other list at the front of list l. The lists l and other may be the same. They must not be nil.

                                                                                                                                                      func (*NewConnectionIDList) Remove

                                                                                                                                                        Remove removes e from l if e is an element of list l. It returns the element value e.Value. The element must not be nil.

                                                                                                                                                        type PacketInterval

                                                                                                                                                        type PacketInterval struct {
                                                                                                                                                        	Start protocol.PacketNumber
                                                                                                                                                        	End   protocol.PacketNumber
                                                                                                                                                        }

                                                                                                                                                          PacketInterval is an interval from one PacketNumber to the other

                                                                                                                                                          type PacketIntervalElement

                                                                                                                                                          type PacketIntervalElement struct {
                                                                                                                                                          
                                                                                                                                                          	// The value stored with this element.
                                                                                                                                                          	Value PacketInterval
                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                          }

                                                                                                                                                            PacketIntervalElement is an element of a linked list.

                                                                                                                                                            func (*PacketIntervalElement) Next

                                                                                                                                                              Next returns the next list element or nil.

                                                                                                                                                              func (*PacketIntervalElement) Prev

                                                                                                                                                                Prev returns the previous list element or nil.

                                                                                                                                                                type PacketIntervalList

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

                                                                                                                                                                  PacketIntervalList is a linked list of PacketIntervals.

                                                                                                                                                                  func NewPacketIntervalList

                                                                                                                                                                  func NewPacketIntervalList() *PacketIntervalList

                                                                                                                                                                    NewPacketIntervalList returns an initialized list.

                                                                                                                                                                    func (*PacketIntervalList) Back

                                                                                                                                                                      Back returns the last element of list l or nil if the list is empty.

                                                                                                                                                                      func (*PacketIntervalList) Front

                                                                                                                                                                        Front returns the first element of list l or nil if the list is empty.

                                                                                                                                                                        func (*PacketIntervalList) Init

                                                                                                                                                                          Init initializes or clears list l.

                                                                                                                                                                          func (*PacketIntervalList) InsertAfter

                                                                                                                                                                            InsertAfter inserts a new element e with value v immediately after mark and returns e. If mark is not an element of l, the list is not modified. The mark must not be nil.

                                                                                                                                                                            func (*PacketIntervalList) InsertBefore

                                                                                                                                                                              InsertBefore inserts a new element e with value v immediately before mark and returns e. If mark is not an element of l, the list is not modified. The mark must not be nil.

                                                                                                                                                                              func (*PacketIntervalList) Len

                                                                                                                                                                              func (l *PacketIntervalList) Len() int

                                                                                                                                                                                Len returns the number of elements of list l. The complexity is O(1).

                                                                                                                                                                                func (*PacketIntervalList) MoveAfter

                                                                                                                                                                                func (l *PacketIntervalList) MoveAfter(e, mark *PacketIntervalElement)

                                                                                                                                                                                  MoveAfter moves element e to its new position after mark. If e or mark is not an element of l, or e == mark, the list is not modified. The element and mark must not be nil.

                                                                                                                                                                                  func (*PacketIntervalList) MoveBefore

                                                                                                                                                                                  func (l *PacketIntervalList) MoveBefore(e, mark *PacketIntervalElement)

                                                                                                                                                                                    MoveBefore moves element e to its new position before mark. If e or mark is not an element of l, or e == mark, the list is not modified. The element and mark must not be nil.

                                                                                                                                                                                    func (*PacketIntervalList) MoveToBack

                                                                                                                                                                                    func (l *PacketIntervalList) MoveToBack(e *PacketIntervalElement)

                                                                                                                                                                                      MoveToBack moves element e to the back of list l. If e is not an element of l, the list is not modified. The element must not be nil.

                                                                                                                                                                                      func (*PacketIntervalList) MoveToFront

                                                                                                                                                                                      func (l *PacketIntervalList) MoveToFront(e *PacketIntervalElement)

                                                                                                                                                                                        MoveToFront moves element e to the front of list l. If e is not an element of l, the list is not modified. The element must not be nil.

                                                                                                                                                                                        func (*PacketIntervalList) PushBack

                                                                                                                                                                                          PushBack inserts a new element e with value v at the back of list l and returns e.

                                                                                                                                                                                          func (*PacketIntervalList) PushBackList

                                                                                                                                                                                          func (l *PacketIntervalList) PushBackList(other *PacketIntervalList)

                                                                                                                                                                                            PushBackList inserts a copy of an other list at the back of list l. The lists l and other may be the same. They must not be nil.

                                                                                                                                                                                            func (*PacketIntervalList) PushFront

                                                                                                                                                                                              PushFront inserts a new element e with value v at the front of list l and returns e.

                                                                                                                                                                                              func (*PacketIntervalList) PushFrontList

                                                                                                                                                                                              func (l *PacketIntervalList) PushFrontList(other *PacketIntervalList)

                                                                                                                                                                                                PushFrontList inserts a copy of an other list at the front of list l. The lists l and other may be the same. They must not be nil.

                                                                                                                                                                                                func (*PacketIntervalList) Remove

                                                                                                                                                                                                  Remove removes e from l if e is an element of list l. It returns the element value e.Value. The element must not be nil.

                                                                                                                                                                                                  type RTTStats

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

                                                                                                                                                                                                    RTTStats provides round-trip statistics

                                                                                                                                                                                                    func NewRTTStats

                                                                                                                                                                                                    func NewRTTStats() *RTTStats

                                                                                                                                                                                                      NewRTTStats makes a properly initialized RTTStats object

                                                                                                                                                                                                      func (*RTTStats) ExpireSmoothedMetrics

                                                                                                                                                                                                      func (r *RTTStats) ExpireSmoothedMetrics()

                                                                                                                                                                                                        ExpireSmoothedMetrics causes the smoothed_rtt to be increased to the latest_rtt if the latest_rtt is larger. The mean deviation is increased to the most recent deviation if it's larger.

                                                                                                                                                                                                        func (*RTTStats) LatestRTT

                                                                                                                                                                                                        func (r *RTTStats) LatestRTT() time.Duration

                                                                                                                                                                                                          LatestRTT returns the most recent rtt measurement. May return Zero if no valid updates have occurred.

                                                                                                                                                                                                          func (*RTTStats) MaxAckDelay

                                                                                                                                                                                                          func (r *RTTStats) MaxAckDelay() time.Duration

                                                                                                                                                                                                            MaxAckDelay gets the max_ack_delay advertised by the peer

                                                                                                                                                                                                            func (*RTTStats) MeanDeviation

                                                                                                                                                                                                            func (r *RTTStats) MeanDeviation() time.Duration

                                                                                                                                                                                                              MeanDeviation gets the mean deviation

                                                                                                                                                                                                              func (*RTTStats) MinRTT

                                                                                                                                                                                                              func (r *RTTStats) MinRTT() time.Duration

                                                                                                                                                                                                                MinRTT Returns the minRTT for the entire connection. May return Zero if no valid updates have occurred.

                                                                                                                                                                                                                func (*RTTStats) OnConnectionMigration

                                                                                                                                                                                                                func (r *RTTStats) OnConnectionMigration()

                                                                                                                                                                                                                  OnConnectionMigration is called when connection migrates and rtt measurement needs to be reset.

                                                                                                                                                                                                                  func (*RTTStats) PTO

                                                                                                                                                                                                                  func (r *RTTStats) PTO(includeMaxAckDelay bool) time.Duration

                                                                                                                                                                                                                    PTO gets the probe timeout duration.

                                                                                                                                                                                                                    func (*RTTStats) SetInitialRTT

                                                                                                                                                                                                                    func (r *RTTStats) SetInitialRTT(t time.Duration)

                                                                                                                                                                                                                      SetInitialRTT sets the initial RTT. It is used during the 0-RTT handshake when restoring the RTT stats from the session state.

                                                                                                                                                                                                                      func (*RTTStats) SetMaxAckDelay

                                                                                                                                                                                                                      func (r *RTTStats) SetMaxAckDelay(mad time.Duration)

                                                                                                                                                                                                                        SetMaxAckDelay sets the max_ack_delay

                                                                                                                                                                                                                        func (*RTTStats) SmoothedRTT

                                                                                                                                                                                                                        func (r *RTTStats) SmoothedRTT() time.Duration

                                                                                                                                                                                                                          SmoothedRTT returns the smoothed RTT for the connection. May return Zero if no valid updates have occurred.

                                                                                                                                                                                                                          func (*RTTStats) UpdateRTT

                                                                                                                                                                                                                          func (r *RTTStats) UpdateRTT(sendDelta, ackDelay time.Duration, now time.Time)

                                                                                                                                                                                                                            UpdateRTT updates the RTT based on a new sample.

                                                                                                                                                                                                                            type Timer

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

                                                                                                                                                                                                                              A Timer wrapper that behaves correctly when resetting

                                                                                                                                                                                                                              func NewTimer

                                                                                                                                                                                                                              func NewTimer() *Timer

                                                                                                                                                                                                                                NewTimer creates a new timer that is not set

                                                                                                                                                                                                                                func (*Timer) Chan

                                                                                                                                                                                                                                func (t *Timer) Chan() <-chan time.Time

                                                                                                                                                                                                                                  Chan returns the channel of the wrapped timer

                                                                                                                                                                                                                                  func (*Timer) Reset

                                                                                                                                                                                                                                  func (t *Timer) Reset(deadline time.Time)

                                                                                                                                                                                                                                    Reset the timer, no matter whether the value was read or not

                                                                                                                                                                                                                                    func (*Timer) SetRead

                                                                                                                                                                                                                                    func (t *Timer) SetRead()

                                                                                                                                                                                                                                      SetRead should be called after the value from the chan was read

                                                                                                                                                                                                                                      func (*Timer) Stop

                                                                                                                                                                                                                                      func (t *Timer) Stop()

                                                                                                                                                                                                                                        Stop stops the timer

                                                                                                                                                                                                                                        Directories

                                                                                                                                                                                                                                        Path Synopsis