Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## tesl
Class Clock<T extends java.lang.Comparable<? super T>>

    java.lang.Object
      tesl.Clock<T>

Direct Known Subclasses:
  DrivingClock

    public class Clock<T extends java.lang.Comparable<? super T>>

extends java.lang.Object

A clock with tags of type T.

Nested Class Summary
`private class` | `Clock.ClockBackup`

Field Summary
`private boolean` | `greedy_`
`private java.lang.String` | `name_`
`private Tick<T>` | `now_`
`private ClockSet` | `owner_`
`private TagCalculus<T>` | `tag_calculus_`
`private java.util.Map<Tick<T>,Tag<T>>` | `tags_`
`private java.util.List<Tick<T>>` | `ticks_`

Constructor Summary
`Clock(java.lang.String name, TagCalculus<T> calc)`
`Clock(java.lang.String name, TagCalculus<T> calc, boolean greedy)`

Method Summary
`AffineTags<T>` | `affineTags(Clock<T> clock, T coeff, T offset)`
`ClockBackupInterface<T>` | `backup()`
`void` | `cleanUp()`
`private Tick<T>` | `copyTick(Tick<T> t)`
`
`<U extends java.lang.Comparable<U>> Implication<T,U>`
` | `createMasterImplication(Clock<U> slave)` Deprecated.
`
`<U extends java.lang.Comparable<U>> Implication<U,T>`
` | `createSlaveImplication(Clock<U> master)`
`
`<S extends java.lang.Comparable<S>> FilteredImplication<T,S>`
` | `filteredImplies(Clock<S> slave, int skip, int keep, int repSkip, int repKeep)`
`ClockSet` | `getClockSet()`
`Tick<T>` | `getFirstTaggedTick()`
`Tick<T>` | `getFloatingTick()`
`java.lang.String` | `getName()`
`Tick<T>` | `getNowTick()`
`int` | `getNumberOfTicks()`
`Tag<T>` | `getTag(Tick<T> tick)`
`TagCalculus<T>` | `getTagCalculus()`
`T` | `getTagValue(Tick<T> tick)`
`Tick<T>` | `getTick(int i)`
`Tick<T>` | `getTick(T tag)`
`Tick<T>` | `getTick(Tag<T> tag)`
`java.util.Collection<Tick<T>>` | `getTicks()`
`boolean` | `hasFloatingTick()`
`boolean` | `hasTaggedTick()`
`boolean` | `hasTickNow()`
`boolean` | `hasTicks()`
`
`<S extends java.lang.Comparable<? super S>> Implication<T,S>`
` | `implies(Clock<S> slave)`
`
`<S extends java.lang.Comparable<S>> FilteredImplication<T,S>`
` | `impliesThroughFilter(Clock<S> slave, int skip, int count, int repskip, int repcount)`
`
`<S extends java.lang.Comparable<S>,C extends java.lang.Comparable<C>> DelayedImplication<T,C,S>`
` | `impliesWithDelay(Clock<S> slave, Clock<C> counting, int delay)`
`
`<S extends java.lang.Comparable<S>,C extends java.lang.Comparable<C>> DelayedImplication<T,C,S>`
` | `impliesWithDelay(Clock<S> slave, Clock<C> counting, int delay, boolean immediate)`
`boolean` | `isGreedy()`
`boolean` | `isNow(Tick<T> tick)`
`Tick<T>` | `newTick()`
`Tick<T>` | `newTick(T value)`
`void` | `removeTick(int i)`
`void` | `removeTick(Tick<T> tick)`
`void` | `resetClock()`
`void` | `restore(ClockBackupInterface<T> backup)`
`SameTags<T>` | `sameTags(Clock<T> clock)`
`ClockSet` | `setClockSet(ClockSet cs)`
`void` | `setGreedy(boolean greedy)`
`Tick<T>` | `setNow(Tick<T> tick, boolean now)`
`Tick<T>` | `setTag(Tick<T> tick, Tag<T> tag)`
`Tick<T>` | `setTagValue(Tick<T> tick, T tag)`
`
`<M2 extends java.lang.Comparable<M2>,M3 extends java.lang.Comparable<M3>,S extends java.lang.Comparable<S>> SustainedImplication<T,M2,M3,S>`
` | `sustains(Clock<S> slave, Clock<M2> start, Clock<M3> stop)`
`
`<M2 extends java.lang.Comparable<M2>,M3 extends java.lang.Comparable<M3>,S extends java.lang.Comparable<S>> SustainedImplication<T,M2,M3,S>`
` | `sustains(Clock<S> slave, Clock<M2> start, Clock<M3> stop, Occurrence immediate, Preemption weak)` Make this clock sustain clock `slave` between occurrences of `start` and `stop`.
`T` | `tagDifference(T t1, T t2)`
`T` | `tagProduct(T t1, T t2)`
`T` | `tagQuotient(T t1, T t2)`
`T` | `tagSum(T t1, T t2)`
`java.lang.String` | `toString()`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Field Detail

### tags_

    private java.util.Map<Tick<T extends java.lang.Comparable<? super T>>,Tag<T extends java.lang.Comparable<? super T>>> tags_

### tag_calculus_

    private TagCalculus<T extends java.lang.Comparable<? super T>> tag_calculus_

### ticks_

    private java.util.List<Tick<T extends java.lang.Comparable<? super T>>> ticks_

### now_

    private Tick<T extends java.lang.Comparable<? super T>> now_

### greedy_

    private boolean greedy_

### name_

    private java.lang.String name_

### owner_

    private ClockSet owner_

Constructor Detail

### Clock

    public Clock(java.lang.String name,
                 TagCalculus<T> calc,
                 boolean greedy)

### Clock

    public Clock(java.lang.String name,
                 TagCalculus<T> calc)

Method Detail

### setClockSet

    public ClockSet setClockSet(ClockSet cs)

### getClockSet

    public ClockSet getClockSet()

### implies

    public <S extends java.lang.Comparable<? super S>> Implication<T,S> implies(Clock<S> slave)

### impliesWithDelay

    public <S extends java.lang.Comparable<S>,C extends java.lang.Comparable<C>> DelayedImplication<T,C,S> impliesWithDelay(Clock<S> slave,
                                                                                                                            Clock<C> counting,
                                                                                                                            int delay,
                                                                                                                            boolean immediate)

### impliesWithDelay

    public <S extends java.lang.Comparable<S>,C extends java.lang.Comparable<C>> DelayedImplication<T,C,S> impliesWithDelay(Clock<S> slave,
                                                                                                                            Clock<C> counting,
                                                                                                                            int delay)

### impliesThroughFilter

    public <S extends java.lang.Comparable<S>> FilteredImplication<T,S> impliesThroughFilter(Clock<S> slave,
                                                                                             int skip,
                                                                                             int count,
                                                                                             int repskip,
                                                                                             int repcount)

### sustains

    public <M2 extends java.lang.Comparable<M2>,M3 extends java.lang.Comparable<M3>,S extends java.lang.Comparable<S>> SustainedImplication<T,M2,M3,S> sustains(Clock<S> slave,
                                                                                                                                                                Clock<M2> start,
                                                                                                                                                                Clock<M3> stop,
                                                                                                                                                                Occurrence immediate,
                                                                                                                                                                Preemption weak)

  Make this clock sustain clock `slave` between occurrences of `start` and `stop`.

  Parameters:
    `slave` - the slave clock
    `start` - the clock that starts the sustaining of slave
    `stop` - the clock that stops the sustaining of slave
    `immediate` - if true, slave has a tick when the master and start occur at the same time
    `weak` - if true, slave has a tick when stop occurs at the same time as the master

### sustains

    public <M2 extends java.lang.Comparable<M2>,M3 extends java.lang.Comparable<M3>,S extends java.lang.Comparable<S>> SustainedImplication<T,M2,M3,S> sustains(Clock<S> slave,
                                                                                                                                                                Clock<M2> start,
                                                                                                                                                                Clock<M3> stop)

### filteredImplies

    public <S extends java.lang.Comparable<S>> FilteredImplication<T,S> filteredImplies(Clock<S> slave,
                                                                                        int skip,
                                                                                        int keep,
                                                                                        int repSkip,
                                                                                        int repKeep)

### createMasterImplication

    @Deprecated
    public <U extends java.lang.Comparable<U>> Implication<T,U> createMasterImplication(Clock<U> slave)

  Deprecated.

### createSlaveImplication

    public <U extends java.lang.Comparable<U>> Implication<U,T> createSlaveImplication(Clock<U> master)

### sameTags

    public SameTags<T> sameTags(Clock<T> clock)

### affineTags

    public AffineTags<T> affineTags(Clock<T> clock,
                                    T coeff,
                                    T offset)

### setGreedy

    public void setGreedy(boolean greedy)

### isGreedy

    public boolean isGreedy()

### getTagCalculus

    public TagCalculus<T> getTagCalculus()

### tagSum

    public T tagSum(T t1,
                    T t2)

### tagDifference

    public T tagDifference(T t1,
                           T t2)

### tagProduct

    public T tagProduct(T t1,
                        T t2)

### tagQuotient

    public T tagQuotient(T t1,
                         T t2)

### newTick

    public Tick<T> newTick()

### newTick

    public Tick<T> newTick(T value)

### copyTick

    private Tick<T> copyTick(Tick<T> t)

### setTagValue

    public Tick<T> setTagValue(Tick<T> tick,
                               T tag)

### setTag

    public Tick<T> setTag(Tick<T> tick,
                          Tag<T> tag)

### getTag

    public Tag<T> getTag(Tick<T> tick)

### getTagValue

    public T getTagValue(Tick<T> tick)

### setNow

    public Tick<T> setNow(Tick<T> tick,
                          boolean now)

### isNow

    public boolean isNow(Tick<T> tick)

### getNumberOfTicks

    public int getNumberOfTicks()

### removeTick

    public void removeTick(Tick<T> tick)

### removeTick

    public void removeTick(int i)

### getTick

    public Tick<T> getTick(int i)

### getTick

    public Tick<T> getTick(Tag<T> tag)

### getTick

    public Tick<T> getTick(T tag)

### hasFloatingTick

    public boolean hasFloatingTick()

### getFloatingTick

    public Tick<T> getFloatingTick()

### hasTicks

    public boolean hasTicks()

### hasTickNow

    public boolean hasTickNow()

### getNowTick

    public Tick<T> getNowTick()

### hasTaggedTick

    public boolean hasTaggedTick()

### getFirstTaggedTick

    public Tick<T> getFirstTaggedTick()

### getTicks

    public java.util.Collection<Tick<T>> getTicks()

### resetClock

    public void resetClock()

### getName

    public java.lang.String getName()

### cleanUp

    public void cleanUp()

### backup

    public ClockBackupInterface<T> backup()

### restore

    public void restore(ClockBackupInterface<T> backup)

### toString

    public java.lang.String toString()

  Overrides:
    `toString` in class `java.lang.Object`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD