/// <summary> /// Searches for the destination at the end of the processing path. /// </summary> /// <param name="path">The processing path to trace.</param> /// <returns>Material destination</returns> private MaterialDestination SearchForDestination(ProcessingPath path) { // Does the processing trace have any history to trace ? if (this.Root == null) { return(null); } // Is there a processing path to trace ? if not then create an empty path to trace. if (path == null) { path = new ProcessingPath(); } if (path.Tag == null) { path.Tag = new ProcessingTag[0]; } // Search the processing tree for the destination associated with the processing path SearchForPathDetails finalSearch = SearchForPath(new SearchForPathDetails(path, 0, this.Root, new List <Procedure>())); //Debug.Assert(finalSearch != null); //Debug.Assert(path.Tag != null); return(finalSearch == null || finalSearch.tagLevel != path.Tag.Length ? null : finalSearch.destination); }
/// <summary> /// Gets the processing history associated with a processing path. /// </summary> /// <param name="processingPath">The processing path.</param> /// <returns></returns> internal ADX4.Process GetProcessingHistory(ProcessingPath processingPath) { // Does this processing tree have a root ? if not then there is not history to return. if (this.Root == null) { return(null); } // If the processing path is null then create an empty processing path to trace. if (processingPath == null) { processingPath = new ProcessingPath(); processingPath.Tag = new ProcessingTag[0]; } // Trace the processing path and build the list of procedures on it SearchForPathDetails finalSearch = SearchForPath(new SearchForPathDetails(processingPath, 0, this.Root, new List <Procedure>())); if (finalSearch == null || (finalSearch.tagLevel < processingPath.Tag.Length)) { this.OnValidationEvent(new ValidationResult(ErrorCodes.SampleProcessingHistory, ErrorLevel.Error, String.Format(Languages.Strings.valResultPathNotFoundInProcessingHistory, processingPath.ToString(), this.SampleRefs[0].IdRef))); return(null); } // Return the list of procedures for this processing path Process history = new Process(); history.Destination = new MaterialDestination(); history.Destination.Target = new MaterialTarget(); history.Destination.Target.Procedure = finalSearch.procedures.ToArray(); return(history); }
public SearchForPathDetails(ProcessingPath path, Int32 tagLevel, MaterialDestination destination, List <Procedure> procedures) { this.tagLevel = tagLevel; this.destination = destination; this.path = path; this.procedures = procedures; this.endOfBranch = false; }
/// <summary> /// Gets the <see cref="ADX4.Tools.AssayRecord"/> associated with the specified processing path. /// </summary> /// <value>The requested assay record.</value> public AssayRecord this[ProcessingPath path] { get { // Search the Assay Records for the record with the requested processing path foreach (AssayRecord assayRecord in this) { if (assayRecord.ProcessingPath == null) { if (path == null) { return(assayRecord); } } else if (assayRecord.ProcessingPath.Equals(path)) { return(assayRecord); } } return(null); } }
/// <summary> /// Appends the processing history onto the end of the specified processing path. /// </summary> /// <param name="parentPath">The parent processing path to append onto.</param> /// <param name="processing">The processing history.</param> internal void AppendProcessingHistory(ProcessingPath parentPath, ADX4.Process processing) { // Any processing history to append ? if (processing == null || processing.Destination == null) { return; } // Expand the processing history into a procedures (i.e. replaces ProcessRef, ProcedureRef, etc... for the actual procedures). MaterialDestination clonedDestination = processing.Destination.Clone(); Debug.Assert(clonedDestination != null); List <Procedure> expandedProcedures = ExpandToProcedures(clonedDestination, 0, new ProcessingTarget()); Debug.Assert(expandedProcedures != null); // Any procedures to append ? if (expandedProcedures.Count == 0) { return; } // Do we have a root destination at the top of the process tree ? MaterialDestination leafDestination; if (this.Root == null) { this.Root = new MaterialDestination(); leafDestination = this.Root; } // Or do we trace the processing path through the current tree. else { leafDestination = SearchForDestination(parentPath); // Find the destination at the end of this processing path ! if (leafDestination == null) { this.OnValidationEvent(new ValidationResult(ErrorCodes.SampleProcessingHistory, ErrorLevel.Error, String.Format(Languages.Strings.valResultPathNotFoundInProcessingHistory, parentPath.ToString(), this.ToString()))); return; } } Debug.Assert(leafDestination != null); // Add a target to the destination at the end of the processing path (if not one there already) if (leafDestination.Target == null) { leafDestination.Target = new MaterialTarget(); } // Add the procedures onto the target (if no procedures have been set on the target yet!) if (leafDestination.Target.Procedure == null) { leafDestination.Target.Procedure = expandedProcedures.ToArray(); } // Otherwise extend the target's procedure list and append the processing history's procedures else { Procedure[] curProcedures = leafDestination.Target.Procedure; leafDestination.Target.Procedure = new Procedure[curProcedures.Length + expandedProcedures.Count]; for (int i = 0; i < curProcedures.Length; i++) { leafDestination.Target.Procedure[i] = curProcedures[i]; } for (int i = 0; i < expandedProcedures.Count; i++) { leafDestination.Target.Procedure[curProcedures.Length + i] = expandedProcedures[i]; } } }
/// <summary> /// Substitutes the processing path with an alternative processing path. /// </summary> /// <param name="processingPath">The new processing path.</param> /// <returns></returns> public ProcessingPath MapProcessingPath(ProcessingPath processingPath) { // Any processing path lookups ? if (this.ProcessingPath == null || processingPath == null || processingPath.Tag == null) { return(processingPath); } // Map each processing tag List <ProcessingTag> mappedTags = new List <ProcessingTag>(); for (Int32 i = 0; i < processingPath.Tag.Length; i++) { ProcessingTag mappedTag = new ProcessingTag(); mappedTag.Type = processingPath.Tag[i].Type; mappedTag.Name = processingPath.Tag[i].Name; // Find the longest matching mapping Boolean mapped = false; for (Int32 j = processingPath.Tag.Length; j > i && !mapped; j--) { // Append these processing tags together StringBuilder appendedTags = new StringBuilder(); for (Int32 k = i; k < j; k++) { if (appendedTags.Length > 0) { appendedTags.Append(c_mappingSeparator); } if (!String.IsNullOrEmpty(processingPath.Tag[k].Type)) { appendedTags.Append(processingPath.Tag[k].Type); } } // Does this appended list of tags types match any mapping ? foreach (Substitution substitution in this.ProcessingPath) { if (!String.IsNullOrEmpty(substitution.Name)) { if (String.Equals(appendedTags.ToString(), substitution.Name)) { mappedTag.Type = substitution.With; mappedTag.Name = processingPath.Tag[j - 1].Name; mapped = true; i = j; break; } } } } mappedTags.Add(mappedTag); } // Return the mapped processing path ProcessingPath mappedPath = new ProcessingPath(); mappedPath.Id = processingPath.Id; mappedPath.Tag = mappedTags.ToArray(); return(mappedPath); }
/// <summary> /// Substitutes the processing path with an alternative processing path. /// </summary> /// <param name="processingPath">The new processing path.</param> /// <returns></returns> public ProcessingPath MapProcessingPath(ProcessingPath processingPath) { // Any processing path lookups ? if (this.ProcessingPath == null || processingPath == null || processingPath.Tag == null) return processingPath; // Map each processing tag List<ProcessingTag> mappedTags = new List<ProcessingTag>(); for (Int32 i = 0; i < processingPath.Tag.Length; i++) { ProcessingTag mappedTag = new ProcessingTag(); mappedTag.Type = processingPath.Tag[i].Type; mappedTag.Name = processingPath.Tag[i].Name; // Find the longest matching mapping Boolean mapped = false; for (Int32 j = processingPath.Tag.Length; j > i && !mapped; j--) { // Append these processing tags together StringBuilder appendedTags = new StringBuilder(); for (Int32 k = i; k < j; k++) { if (appendedTags.Length > 0) appendedTags.Append(c_mappingSeparator); if (!String.IsNullOrEmpty(processingPath.Tag[k].Type)) appendedTags.Append(processingPath.Tag[k].Type); } // Does this appended list of tags types match any mapping ? foreach (Substitution substitution in this.ProcessingPath) if (!String.IsNullOrEmpty(substitution.Name)) { if (String.Equals(appendedTags.ToString(), substitution.Name)) { mappedTag.Type = substitution.With; mappedTag.Name = processingPath.Tag[j - 1].Name; mapped = true; i = j; break; } } } mappedTags.Add(mappedTag); } // Return the mapped processing path ProcessingPath mappedPath = new ProcessingPath(); mappedPath.Id = processingPath.Id; mappedPath.Tag = mappedTags.ToArray(); return mappedPath; }
/// <summary> /// Initializes a new instance of the <see cref="AssayRecord"/> class. /// </summary> /// <param name="processingTree">Sample processing tree</param> /// <param name="processingPath">Path through the processing tree to the assay analysis</param> public AssayRecord(ProcessingTree processingTree, ProcessingPath processingPath) { m_processingTree = processingTree; m_fullProcessingPath = processingPath; m_processingHistory = processingTree.GetProcessingHistory(processingPath); }