/**
*
* <!-- allCreators -->
*
* @see uk.ac.hutton.obiama.model.AbstractScheduledAction#allCreators()
* @return
*/
@Override
boolean allCreators() {
for (AbstractScheduledAction action : actionSequence) {
if (!action.allCreators()) return false;
}
return true;
}
/*
* (non-Javadoc)
*
* @see uk.ac.hutton.obiama.model.AbstractScheduledActivity#step()
*/
@Override
public void stepImpl() throws IntegrationInconsistencyException, ScheduleException {
if (isTimed()) throw new ScheduleException(this, "A timed sequence cannot be stepped");
for (AbstractScheduledAction action : actionSequence) {
action.step();
}
}
/**
*
* <!-- addAction -->
* Add a sequence to the sequence. A non-timed sequence can always be added to another non-timed
* sequence. A timed sequence can be added to another timed sequence, so long as they both have
* the same increment, and the start time of the sequence being added is the same as the time at
* which the next action in this sequence would occur. A timed sequence can be added to a
* non-timed sequence, with the assumption that any existing actions on the non-timed sequence
* occur before the start time of the timed sequence. A non-timed sequence can be added to a timed
* sequence--all actions in the non-timed sequence then become timed.
*
* @param sequence
* @throws ScheduleException
*/
public void addAction(SequentialActionGroup sequence) throws ScheduleException {
if (!isTimed() && sequence.isTimed()) {
setTime(sequence.time - (actionSequence.size() * sequence.increment));
increment = sequence.increment;
int i = 0;
for (AbstractScheduledAction existingAction : actionSequence) {
existingAction.setTime(time + (i * increment));
i++;
}
} else if (isTimed() && sequence.isTimed()) {
if (increment != sequence.increment) {
throw new ScheduleException(
this,
"Cannot add timed sequence "
+ sequence.getURI()
+ " with different increment (respectively, "
+ increment
+ " and "
+ sequence.increment
+ ")");
}
sequence.setTime(time + (actionSequence.size() * increment));
} else if (isTimed() && !sequence.isTimed()) {
int i = actionSequence.size();
for (AbstractScheduledAction sequenceAction : sequence.actionSequence) {
sequenceAction.setTime(time + (i * increment));
i++;
}
}
actionSequence.addAll(sequence.actionSequence);
}
/**
*
* <!-- getActionSet -->
* Return the actions contained in this sequence
*
* @see uk.ac.hutton.obiama.model.AbstractScheduledAction#getActionSet()
*/
@Override
public Set<Action> getActionSet() {
Set<Action> actionSet = new HashSet<Action>();
for (AbstractScheduledAction action : actionSequence) {
actionSet.addAll(action.getActionSet());
}
return actionSet;
}
/*
* (non-Javadoc)
*
* @see
* uk.ac.hutton.obiama.model.AbstractScheduledActivity#synchroniseWith(uk
* .ac.hutton.obiama.model.AbstractScheduledActivity)
*/
@Override
public void synchroniseWith(AbstractScheduledAction event) throws ScheduleException {
if (!isTimed()) {
throw new ScheduleException(
this, "Non-timed action sequence cannot be synchronised with " + event.getURI());
}
super.synchroniseWith(event);
}
/**
*
* <!-- addAction -->
* Add an action to the sequence
*
* @param action
* @throws ScheduleException
*/
public void addAction(AbstractScheduledAction action) throws ScheduleException {
if (isTimed()) {
action.setTime(time + (actionSequence.size() * increment));
} else if (action.isTimed()) {
throw new ScheduleException(
this, "Cannot add timed action " + action.getURI() + " to non-timed sequence");
}
actionSequence.addLast(action);
}
/**
*
* <!-- getActionList -->
* Return the sequence as a list of actions
*
* @see uk.ac.hutton.obiama.model.AbstractScheduledAction#getActionList()
*/
@Override
public LinkedList<AbstractScheduledAction> getActionList() throws ScheduleException {
if (isTimed()) {
throw new ScheduleException(this, "timed action cannot be used to generate action list");
}
LinkedList<AbstractScheduledAction> actionList = new LinkedList<AbstractScheduledAction>();
for (AbstractScheduledAction action : actionSequence) {
actionList.addAll(action.getActionList());
}
return actionList;
}
/**
* Constructor
*
* @param msb the model state broker
* @param actionURI the URI of the action sequence in the schedule ontology
* @param assertedNonTimed <code>true</code> if the action is asserted non-timed
* @param firstAction the first action in the sequence
* @throws ScheduleException
*/
public SequentialActionGroup(
ModelStateBroker msb,
URI actionURI,
boolean assertedNonTimed,
AbstractScheduledAction firstAction)
throws ScheduleException {
super(msb, actionURI, assertedNonTimed);
init(firstAction);
increment = null;
if (firstAction instanceof SequentialActionGroup) {
synchroniseWith(firstAction);
} else if (firstAction.isTimed()) {
throw new ScheduleException(
actionURI, "Non-timed action sequence with timed sub-action " + firstAction.getURI());
}
}
/**
* Constructor for timed sequences
*
* @param msb the model state broker
* @param actionURI the URI of the action sequence in the schedule ontology
* @param firstAction the first action in the sequence
* @param time the time at which the sequence starts
* @param increment the time gap between consecutive members of the sequence
* @throws ScheduleException
*/
public SequentialActionGroup(
ModelStateBroker msb,
URI actionURI,
AbstractScheduledAction firstAction,
double time,
double increment)
throws ScheduleException {
super(msb, actionURI, time);
init(firstAction);
if (increment <= 0.0 || Double.isNaN(increment) || Double.isInfinite(increment)) {
throw new ScheduleException(
actionURI, "non-positive, infinite, or not-a-number increment: " + increment);
}
this.increment = increment;
firstAction.synchroniseWith(this);
}
/**
*
* <!-- synchroniseWith -->
* Synchronise two sequences. They must have the same start time and increment.
*
* @param event the sequence to synchronise with
* @throws ScheduleException
*/
public void synchroniseWith(SequentialActionGroup event) throws ScheduleException {
boolean wasTimed = isTimed();
super.synchroniseWith(event);
if (!wasTimed && event.isTimed()) {
this.increment = event.increment;
} else if (this.increment != event.increment) {
throw new ScheduleException(
this,
"(time "
+ time
+ ", increment"
+ increment
+ ") cannot be synchronised with "
+ event.getURI()
+ " (time "
+ event.time
+ ", increment "
+ event.increment
+ ")");
}
}
