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