public IProcessStepObjectBase Build(IProcessStepObject buildFrom,
ISdmxRetrievalManager retrievalManager) {
IList<IINputOutputObjectBase> input = new List<IINputOutputObjectBase>();
IList<IINputOutputObjectBase> output = new List<IINputOutputObjectBase>();
IList<ITransition> transitions = new List<ITransition>();
IList<IProcessStepObjectBase> processSteps = new List<IProcessStepObjectBase>();
/* foreach */
foreach (IInputOutput eachInput in buildFrom.Input) {
ILOG.J2CsMapping.Collections.Collections.Add(input,inputOutputSuperBeanBuilder.Build(eachInput,
retrievalManager));
}
/* foreach */
foreach (IInputOutput eachOutput in buildFrom.Output) {
ILOG.J2CsMapping.Collections.Collections.Add(output,inputOutputSuperBeanBuilder.Build(eachOutput,
retrievalManager));
}
/* foreach */
foreach (ITransition eachTrans in buildFrom.GetTransitions()) {
ILOG.J2CsMapping.Collections.Collections.Add(transitions,eachTrans);
}
/* foreach */
foreach (IProcessStepObject childStep in buildFrom.ProcessSteps) {
ILOG.J2CsMapping.Collections.Collections.Add(processSteps,Build(childStep, retrievalManager));
}
return new ProcessStepObjectBaseCore(buildFrom, input, output,
buildFrom.Computation, transitions, processSteps);
}
public ProcessStepObjectBaseCore(IProcessStepObject processStep,
IList<IInputOutputObjectBase> inputs,
IList<IInputOutputObjectBase> outputs, IComputationObject computation,
IList<ITransition> transitions,
IList<IProcessStepObjectBase> processSteps) : base(processStep) {
this._processStep = processStep;
this._inputs = inputs;
this._outputs = outputs;
this._computation = computation;
this._transitions = transitions;
this._processSteps = processSteps;
}
/// <summary>
/// Walks through Processes and sub processes to set the IProcessStepObject referenced from the targetStep
/// </summary>
/// <param name="processSteps">List of processes.
/// </param>
/// <param name="targetStepSplit">
/// The target Step Split.
/// </param>
/// <param name="currentPosition">
/// The current Position.
/// </param>
private void SetTargetStep(IList<IProcessStepObject> processSteps, string[] targetStepSplit, int currentPosition)
{
foreach (IProcessStepObject currentProcessStep in processSteps)
{
if (currentProcessStep.Id.Equals(targetStepSplit[currentPosition]))
{
int nextPos = currentPosition + 1;
if (targetStepSplit.Length > nextPos)
{
this.SetTargetStep(currentProcessStep.ProcessSteps, targetStepSplit, nextPos);
return;
}
else
{
this.processStep = currentProcessStep;
return;
}
}
}
throw new SdmxSemmanticException(
"Can not resolve reference to ProcessStep with reference '" + this.targetStep + "'");
}
/// <summary>
/// Process <paramref name="buildFrom"/>
/// </summary>
/// <param name="buildFrom">
/// The <see cref="IProcessStepObject"/> to build from
/// </param>
/// <param name="builtObj">
/// The output
/// </param>
private void ProcessProcessStep(IProcessStepObject buildFrom, ProcessStepType builtObj)
{
string value = buildFrom.Id;
if (!string.IsNullOrWhiteSpace(value))
{
builtObj.id = buildFrom.Id;
}
IList<ITextTypeWrapper> names = buildFrom.Names;
if (ObjectUtil.ValidCollection(names))
{
builtObj.Name = this.GetTextType(names);
}
IList<ITextTypeWrapper> descriptions = buildFrom.Descriptions;
if (ObjectUtil.ValidCollection(descriptions))
{
builtObj.Description = this.GetTextType(descriptions);
}
IList<IInputOutputObject> inputObjects = buildFrom.Input;
if (ObjectUtil.ValidCollection(inputObjects))
{
/* foreach */
foreach (IInputOutputObject input in inputObjects)
{
if (input.StructureReference != null)
{
builtObj.Input.Add(
XmlobjectsEnumUtil.GetSdmxObjectIdType(input.StructureReference.TargetReference));
}
}
}
IList<IInputOutputObject> outputObjects = buildFrom.Output;
if (ObjectUtil.ValidCollection(outputObjects))
{
/* foreach */
foreach (IInputOutputObject outputObject in outputObjects)
{
if (outputObject.StructureReference != null)
{
builtObj.Input.Add(
XmlobjectsEnumUtil.GetSdmxObjectIdType(outputObject.StructureReference.TargetReference));
}
}
}
if (buildFrom.Computation != null)
{
builtObj.Computation.AddAll(this.GetTextType(buildFrom.Computation.Description));
}
IList<ITransition> transitions = buildFrom.Transitions;
if (ObjectUtil.ValidCollection(transitions))
{
/* foreach */
foreach (ITransition transition in transitions)
{
var transitionType = new TransitionType();
builtObj.Transition.Add(transitionType);
if (transition.TargetStep != null)
{
transitionType.TargetStep = transition.TargetStep.Id;
}
IList<ITextTypeWrapper> textTypeWrappers = transition.Condition;
if (ObjectUtil.ValidCollection(textTypeWrappers))
{
transitionType.Condition = this.GetTextType(textTypeWrappers[0]);
}
}
}
IList<IProcessStepObject> processStepObjects = buildFrom.ProcessSteps;
if (ObjectUtil.ValidCollection(processStepObjects))
{
/* foreach */
foreach (IProcessStepObject processStep in processStepObjects)
{
var newProcessStepType = new ProcessStepType();
builtObj.ProcessStep.Add(newProcessStepType);
this.ProcessProcessStep(processStep, newProcessStepType);
}
}
if (this.HasAnnotations(buildFrom))
{
builtObj.Annotations = this.GetAnnotationsType(buildFrom);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ProcessStepMutableCore"/> class.
/// </summary>
/// <param name="objTarget">
/// The obj target.
/// </param>
public ProcessStepMutableCore(IProcessStepObject objTarget)
: base(objTarget)
{
this._input = new List<IInputOutputMutableObject>();
this._output = new List<IInputOutputMutableObject>();
this._transitions = new List<ITransitionMutableObject>();
this._processSteps = new List<IProcessStepMutableObject>();
if (objTarget.Input != null)
{
foreach (IInputOutputObject currentIo in objTarget.Input)
{
this._input.Add(new InputOutputMutableCore(currentIo));
}
}
if (objTarget.Output != null)
{
foreach (IInputOutputObject currentIo0 in objTarget.Output)
{
this._output.Add(new InputOutputMutableCore(currentIo0));
}
}
// make into mutable objTarget lists
if (objTarget.ProcessSteps != null)
{
foreach (IProcessStepObject processStepObject in objTarget.ProcessSteps)
{
this.AddProcessStep(new ProcessStepMutableCore(processStepObject));
}
}
if (objTarget.Transitions != null)
{
foreach (ITransition t in objTarget.Transitions)
{
this.AddTransition(new TransitionMutableCore(t));
}
}
if (objTarget.Computation != null)
{
this._computation = new ComputationMutableCore(objTarget.Computation);
}
}
