github.com/core-coin/go-core/v2@v2.1.9/common/mclock/mclock.go (about)

     1  // Copyright 2016 by the Authors
     2  // This file is part of the go-core library.
     3  //
     4  // The go-core library is free software: you can redistribute it and/or modify
     5  // it under the terms of the GNU Lesser General Public License as published by
     6  // the Free Software Foundation, either version 3 of the License, or
     7  // (at your option) any later version.
     8  //
     9  // The go-core library is distributed in the hope that it will be useful,
    10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    12  // GNU Lesser General Public License for more details.
    13  //
    14  // You should have received a copy of the GNU Lesser General Public License
    15  // along with the go-core library. If not, see <http://www.gnu.org/licenses/>.
    16  
    17  // Package mclock is a wrapper for a monotonic clock source
    18  package mclock
    19  
    20  import (
    21  	"time"
    22  
    23  	"github.com/aristanetworks/goarista/monotime"
    24  )
    25  
    26  // AbsTime represents absolute monotonic time.
    27  type AbsTime time.Duration
    28  
    29  // Now returns the current absolute monotonic time.
    30  func Now() AbsTime {
    31  	return AbsTime(monotime.Now())
    32  }
    33  
    34  // Add returns t + d as absolute time.
    35  func (t AbsTime) Add(d time.Duration) AbsTime {
    36  	return t + AbsTime(d)
    37  }
    38  
    39  // Sub returns t - t2 as a duration.
    40  func (t AbsTime) Sub(t2 AbsTime) time.Duration {
    41  	return time.Duration(t - t2)
    42  }
    43  
    44  // The Clock interface makes it possible to replace the monotonic system clock with
    45  // a simulated clock.
    46  type Clock interface {
    47  	Now() AbsTime
    48  	Sleep(time.Duration)
    49  	NewTimer(time.Duration) ChanTimer
    50  	After(time.Duration) <-chan AbsTime
    51  	AfterFunc(d time.Duration, f func()) Timer
    52  }
    53  
    54  // Timer is a cancellable event created by AfterFunc.
    55  type Timer interface {
    56  	// Stop cancels the timer. It returns false if the timer has already
    57  	// expired or been stopped.
    58  	Stop() bool
    59  }
    60  
    61  // ChanTimer is a cancellable event created by NewTimer.
    62  type ChanTimer interface {
    63  	Timer
    64  
    65  	// The channel returned by C receives a value when the timer expires.
    66  	C() <-chan AbsTime
    67  	// Reset reschedules the timer with a new timeout.
    68  	// It should be invoked only on stopped or expired timers with drained channels.
    69  	Reset(time.Duration)
    70  }
    71  
    72  // System implements Clock using the system clock.
    73  type System struct{}
    74  
    75  // Now returns the current monotonic time.
    76  func (c System) Now() AbsTime {
    77  	return AbsTime(monotime.Now())
    78  }
    79  
    80  // Sleep blocks for the given duration.
    81  func (c System) Sleep(d time.Duration) {
    82  	time.Sleep(d)
    83  }
    84  
    85  // NewTimer creates a timer which can be rescheduled.
    86  func (c System) NewTimer(d time.Duration) ChanTimer {
    87  	ch := make(chan AbsTime, 1)
    88  	t := time.AfterFunc(d, func() {
    89  		// This send is non-blocking because that's how time.Timer
    90  		// behaves. It doesn't matter in the happy case, but does
    91  		// when Reset is misused.
    92  		select {
    93  		case ch <- c.Now():
    94  		default:
    95  		}
    96  	})
    97  	return &systemTimer{t, ch}
    98  }
    99  
   100  // After returns a channel which receives the current time after d has elapsed.
   101  func (c System) After(d time.Duration) <-chan AbsTime {
   102  	ch := make(chan AbsTime, 1)
   103  	time.AfterFunc(d, func() { ch <- c.Now() })
   104  	return ch
   105  }
   106  
   107  // AfterFunc runs f on a new goroutine after the duration has elapsed.
   108  func (c System) AfterFunc(d time.Duration, f func()) Timer {
   109  	return time.AfterFunc(d, f)
   110  }
   111  
   112  type systemTimer struct {
   113  	*time.Timer
   114  	ch <-chan AbsTime
   115  }
   116  
   117  func (st *systemTimer) Reset(d time.Duration) {
   118  	st.Timer.Reset(d)
   119  }
   120  
   121  func (st *systemTimer) C() <-chan AbsTime {
   122  	return st.ch
   123  }