public PhaseExecutionHost AddPhase(string WorkflowUniqueName, IPhase Phase)
{
if (this._PhaseExecutionHostsByWorkflowUniqueName.ContainsKey(WorkflowUniqueName))
{
Message.Trace(Severity.Error, Resources.ErrorAttemptedWorkflowDuplicateUniquePhaseName, WorkflowUniqueName);
return null;
}
PhaseExecutionHost Host = new PhaseExecutionHost(WorkflowUniqueName, Phase);
this._PhaseExecutionHostsByWorkflowUniqueName.Add(WorkflowUniqueName, Host);
this._PhaseWorkflow.Add(Host);
return Host;
}
public void AddSuccessor(PhaseExecutionHost Sucessor)
{
if (this._HostedPhase.Equals(Sucessor))
{
Message.Trace(Severity.Error, Resources.ErrorAttemptedWorkflowSelfLoop, this._WorkflowUniqueName);
return;
}
if (this._Successors.Contains(Sucessor))
{
Message.Trace(Severity.Error, Resources.ErrorAttemptedWorkflowDuplicateIRFlowVector, this._WorkflowUniqueName, Sucessor._WorkflowUniqueName);
return;
}
this._Successors.Add(Sucessor);
}
public void SupplyIRFromPredecessor(PhaseExecutionHost Predecessor, IIR IR)
{
if (!this._Predecessors.Contains(Predecessor))
{
Message.Trace(Severity.Error, Resources.ErrorInvalidWorkflowPhaseSpecifier, Predecessor._WorkflowUniqueName);
return;
}
if (this._PredecessorIRs.ContainsKey(Predecessor))
{
Message.Trace(Severity.Error, Resources.ErrorAttemptedWorkflowSupplyDuplicatePhaseIR, Predecessor._WorkflowUniqueName, this._WorkflowUniqueName);
return;
}
this._PredecessorIRs.Add(Predecessor, IR);
}
public PhaseExecutionHost AddPhase(string WorkflowUniqueName, IPhase Phase)
{
if (this._PhaseExecutionHostsByWorkflowUniqueName.ContainsKey(WorkflowUniqueName))
{
Message.Trace(Severity.Error, Resources.ErrorAttemptedWorkflowDuplicateUniquePhaseName, WorkflowUniqueName);
return(null);
}
PhaseExecutionHost Host = new PhaseExecutionHost(WorkflowUniqueName, Phase);
this._PhaseExecutionHostsByWorkflowUniqueName.Add(WorkflowUniqueName, Host);
this._PhaseWorkflow.Add(Host);
return(Host);
}
public PhaseExecutionHost AddPhase(string workflowUniqueName, IPhase phase)
{
if (_phaseExecutionHostsByWorkflowUniqueName.ContainsKey(workflowUniqueName))
{
MessageEngine.Trace(Severity.Error, Resources.ErrorAttemptedWorkflowDuplicateUniquePhaseName, workflowUniqueName);
return(null);
}
var host = new PhaseExecutionHost(workflowUniqueName, phase);
_phaseExecutionHostsByWorkflowUniqueName.Add(workflowUniqueName, host);
_phaseWorkflow.Add(host);
return(host);
}
public void AddSuccessor(PhaseExecutionHost successor)
{
if (_hostedPhase.Equals(successor))
{
MessageEngine.Trace(Severity.Error, Resources.ErrorAttemptedWorkflowSelfLoop, _workflowUniqueName);
return;
}
if (_successors.Contains(successor))
{
MessageEngine.Trace(Severity.Error, Resources.ErrorAttemptedWorkflowDuplicateIRFlowVector, _workflowUniqueName, successor._workflowUniqueName);
return;
}
_successors.Add(successor);
}
public void SupplyIRFromPredecessor(PhaseExecutionHost predecessor, IIR ir)
{
if (!_predecessors.Contains(predecessor))
{
MessageEngine.Trace(Severity.Error, Resources.ErrorInvalidWorkflowPhaseSpecifier, predecessor._workflowUniqueName);
return;
}
if (_predecessorIRs.ContainsKey(predecessor))
{
MessageEngine.Trace(Severity.Error, Resources.ErrorAttemptedWorkflowSupplyDuplicatePhaseIR, predecessor._workflowUniqueName, _workflowUniqueName);
return;
}
_predecessorIRs.Add(predecessor, ir);
}
public void AddIRFlowVector(string SourceWorkflowUniqueName, string SinkWorkflowUniqueName)
{
if (!this._PhaseExecutionHostsByWorkflowUniqueName.ContainsKey(SourceWorkflowUniqueName))
{
Message.Trace(Severity.Error, Resources.ErrorInvalidWorkflowPhaseSpecifier, SourceWorkflowUniqueName);
return;
}
if (!this._PhaseExecutionHostsByWorkflowUniqueName.ContainsKey(SinkWorkflowUniqueName))
{
Message.Trace(Severity.Error, Resources.ErrorInvalidWorkflowPhaseSpecifier, SinkWorkflowUniqueName);
return;
}
PhaseExecutionHost SourceHost = this._PhaseExecutionHostsByWorkflowUniqueName[SourceWorkflowUniqueName];
PhaseExecutionHost SinkHost = this._PhaseExecutionHostsByWorkflowUniqueName[SinkWorkflowUniqueName];
SourceHost.AddSuccessor(SinkHost);
SinkHost.AddPredecessor(SourceHost);
}
public void AddIRFlowVector(string sourceWorkflowUniqueName, string sinkWorkflowUniqueName)
{
if (!_phaseExecutionHostsByWorkflowUniqueName.ContainsKey(sourceWorkflowUniqueName))
{
MessageEngine.Trace(Severity.Error, Resources.ErrorInvalidWorkflowPhaseSpecifier, sourceWorkflowUniqueName);
return;
}
if (!_phaseExecutionHostsByWorkflowUniqueName.ContainsKey(sinkWorkflowUniqueName))
{
MessageEngine.Trace(Severity.Error, Resources.ErrorInvalidWorkflowPhaseSpecifier, sinkWorkflowUniqueName);
return;
}
PhaseExecutionHost sourceHost = _phaseExecutionHostsByWorkflowUniqueName[sourceWorkflowUniqueName];
PhaseExecutionHost sinkHost = _phaseExecutionHostsByWorkflowUniqueName[sinkWorkflowUniqueName];
sourceHost.AddSuccessor(sinkHost);
sinkHost.AddPredecessor(sourceHost);
}
public override bool Equals(object obj)
{
PhaseExecutionHost Host = obj as PhaseExecutionHost;
return(Host != null && this._WorkflowUniqueName.Equals(Host._WorkflowUniqueName));
}
public void SupplyIRFromPredecessor(PhaseExecutionHost predecessor, IIR ir)
{
if (!_predecessors.Contains(predecessor))
{
MessageEngine.Trace(Severity.Error, Resources.ErrorInvalidWorkflowPhaseSpecifier, predecessor._workflowUniqueName);
return;
}
if (_predecessorIRs.ContainsKey(predecessor))
{
MessageEngine.Trace(Severity.Error, Resources.ErrorAttemptedWorkflowSupplyDuplicatePhaseIR, predecessor._workflowUniqueName, _workflowUniqueName);
return;
}
_predecessorIRs.Add(predecessor, ir);
}
public void AddSuccessor(PhaseExecutionHost successor)
{
if (_hostedPhase.Equals(successor))
{
MessageEngine.Trace(Severity.Error, Resources.ErrorAttemptedWorkflowSelfLoop, _workflowUniqueName);
return;
}
if (_successors.Contains(successor))
{
MessageEngine.Trace(Severity.Error, Resources.ErrorAttemptedWorkflowDuplicateIRFlowVector, _workflowUniqueName, successor._workflowUniqueName);
return;
}
_successors.Add(successor);
}
public void AddSuccessor(PhaseExecutionHost Sucessor)
{
if (this._HostedPhase.Equals(Sucessor))
{
Message.Trace(Severity.Error, Resources.ErrorAttemptedWorkflowSelfLoop, this._WorkflowUniqueName);
return;
}
if (this._Successors.Contains(Sucessor))
{
Message.Trace(Severity.Error, Resources.ErrorAttemptedWorkflowDuplicateIRFlowVector, this._WorkflowUniqueName, Sucessor._WorkflowUniqueName);
return;
}
this._Successors.Add(Sucessor);
}
public void SupplyIRFromPredecessor(PhaseExecutionHost Predecessor, IIR IR)
{
if (!this._Predecessors.Contains(Predecessor))
{
Message.Trace(Severity.Error, Resources.ErrorInvalidWorkflowPhaseSpecifier, Predecessor._WorkflowUniqueName);
return;
}
if (this._PredecessorIRs.ContainsKey(Predecessor))
{
Message.Trace(Severity.Error, Resources.ErrorAttemptedWorkflowSupplyDuplicatePhaseIR, Predecessor._WorkflowUniqueName, this._WorkflowUniqueName);
return;
}
this._PredecessorIRs.Add(Predecessor, IR);
}
public PhaseExecutionHost AddPhase(string workflowUniqueName, IPhase phase)
{
if (_phaseExecutionHostsByWorkflowUniqueName.ContainsKey(workflowUniqueName))
{
MessageEngine.Trace(Severity.Error, Resources.ErrorAttemptedWorkflowDuplicateUniquePhaseName, workflowUniqueName);
return null;
}
var host = new PhaseExecutionHost(workflowUniqueName, phase);
_phaseExecutionHostsByWorkflowUniqueName.Add(workflowUniqueName, host);
_phaseWorkflow.Add(host);
return host;
}
