net.i2p.util

## Class Clock

- java.lang.Object
- - net.i2p.util.Clock

- All Implemented Interfaces:
    Timestamper.UpdateListener
  Direct Known Subclasses:
    RouterClock

      public class Clock
      extends Object
      implements Timestamper.UpdateListener

  Alternate location for determining the time which takes into account an offset. This offset will ideally be periodically updated so as to serve as the difference between the local computer's current time and the time as known by some reference (such as an NTP synchronized clock). Protected members are used in the subclass RouterClock, which has access to a router's transports (particularly peer clock skews) to second-guess the sanity of clock adjustments.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static interface` | `Clock.ClockUpdateListener`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected boolean` | `_alreadyChanged`
    `protected I2PAppContext` | `_context`
    `protected long` | `_offset`
    `protected long` | `_startedOn`
    `protected boolean` | `_statCreated`
    `static long` | `MAX_LIVE_OFFSET` after we've started up and shifted the clock, don't allow shifts of more than 10 minutes
    `static long` | `MAX_OFFSET` if the clock is skewed by 3+ days, fuck 'em
    `static long` | `MIN_OFFSET_CHANGE` if the clock skewed changes by less than this, ignore the update (so we don't slide all over the place)

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Clock(I2PAppContext context)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addUpdateListener(Clock.ClockUpdateListener lsnr)`
    `protected void` | `fireOffsetChanged(long delta)`
    `static Clock` | `getInstance()`
    `protected Log` | `getLog()` we fetch it on demand to avoid circular dependencies (logging uses the clock)
    `long` | `getOffset()`
    `Timestamper` | `getTimestamper()`
    `boolean` | `getUpdatedSuccessfully()`
    `long` | `now()` Retrieve the current time synchronized with whatever reference clock is in use.
    `void` | `removeUpdateListener(Clock.ClockUpdateListener lsnr)`
    `void` | `setNow(long realTime)`
    `void` | `setNow(long realTime, int stratum)`
    `void` | `setOffset(long offsetMs)` Specify how far away from the "correct" time the computer is - a positive value means that the system time is slow, while a negative value means the system time is fast.
    `void` | `setOffset(long offsetMs, boolean force)` Specify how far away from the "correct" time the computer is - a positive value means that the system time is slow, while a negative value means the system time is fast.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### _context

          protected final I2PAppContext _context

    - #### _startedOn

          protected final long _startedOn

    - #### _statCreated

          protected boolean _statCreated

    - #### _offset

          protected volatile long _offset

    - #### _alreadyChanged

          protected boolean _alreadyChanged

    - #### MAX_OFFSET

          public static final long MAX_OFFSET

      if the clock is skewed by 3+ days, fuck 'em
      See Also:
        Constant Field Values

    - #### MAX_LIVE_OFFSET

          public static final long MAX_LIVE_OFFSET

      after we've started up and shifted the clock, don't allow shifts of more than 10 minutes
      See Also:
        Constant Field Values

    - #### MIN_OFFSET_CHANGE

          public static final long MIN_OFFSET_CHANGE

      if the clock skewed changes by less than this, ignore the update (so we don't slide all over the place)
      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### Clock

          public Clock(I2PAppContext context)

  - ### Method Detail

    - #### getInstance

          public static Clock getInstance()

    - #### getTimestamper

          public Timestamper getTimestamper()

    - #### getLog

          protected Log getLog()

      we fetch it on demand to avoid circular dependencies (logging uses the clock)

    - #### setOffset

          public void setOffset(long offsetMs)

      Specify how far away from the "correct" time the computer is - a positive value means that the system time is slow, while a negative value means the system time is fast.
      Parameters:
        `offsetMs` - the delta from System.currentTimeMillis() (NOT the delta from now())

    - #### setOffset

          public void setOffset(long offsetMs,
                       boolean force)

      Specify how far away from the "correct" time the computer is - a positive value means that the system time is slow, while a negative value means the system time is fast. Warning - overridden in RouterClock
      Parameters:
        `offsetMs` - the delta from System.currentTimeMillis() (NOT the delta from now())

    - #### getOffset

          public long getOffset()

    - #### getUpdatedSuccessfully

          public boolean getUpdatedSuccessfully()

    - #### setNow

          public void setNow(long realTime)

    - #### setNow

          public void setNow(long realTime,
                    int stratum)

      Specified by:
        `setNow` in interface `Timestamper.UpdateListener`
      Parameters:
        `stratum` - ignored
      Since:
        0.7.12

    - #### now

          public long now()

      Retrieve the current time synchronized with whatever reference clock is in use.

    - #### addUpdateListener

          public void addUpdateListener(Clock.ClockUpdateListener lsnr)

    - #### removeUpdateListener

          public void removeUpdateListener(Clock.ClockUpdateListener lsnr)

    - #### fireOffsetChanged

          protected void fireOffsetChanged(long delta)