public void Build() { foreach (var methodTranList in MethodTrans) { Console.Error.WriteLine("MESSAGE: Exporting method {0}", Path.GetFileName(methodTranList.FinalMethod)); if (string.IsNullOrEmpty(methodTranList.TransitionList)) { throw new IOException(string.Format("Failure creating method file {0}. The mass list is empty.", methodTranList.FinalMethod)); } string outMeth = EnsureExtension(methodTranList.OutputMethod, ".meth"); // Thermo needs the extension to be .meth if (!Equals(outMeth, methodTranList.OutputMethod) && File.Exists(methodTranList.OutputMethod)) { File.Move(methodTranList.OutputMethod, outMeth); } try { using (IMethodXMLContext mxc = MethodXMLFactory.CreateContext(InstrumentType, InstrumentVersion)) using (IMethodXML mx = mxc.Create()) { mx.Open(TemplateMethod); mx.EnableValidation(true); ListItem[] listItems = ParseList(methodTranList.TransitionList).ToArray(); if (!listItems.Any()) { throw new IOException("Empty mass list found."); } if (InstrumentType.Equals(InstrumentFusion)) { mx.ApplyMethodModificationsFromXML(GetFusionModificationXml(listItems, outMeth)); } else { mx.ImportMassListFromXML(GetTsqMassListXml(listItems, outMeth)); } mx.SaveAs(outMeth); } if (!File.Exists(outMeth)) { throw new IOException(string.Format("Failure creating method file {0}.", methodTranList.FinalMethod)); } } finally { if (!Equals(outMeth, methodTranList.OutputMethod)) { File.Move(outMeth, methodTranList.OutputMethod); } } } }
public static string GetSummary(string methodFile, string instrumentModel, string version) { methodFile = Path.GetFullPath(methodFile); using (IMethodXMLContext mxc = CreateContext(instrumentModel, version)) using (IMethodXML xmlMeth = mxc.Create()) { xmlMeth.Open(methodFile); return(xmlMeth.GetMethodSummary()); } }
/// <summary> /// Validates a .meth file for errors in parameters/settings /// </summary> /// <param name="methodFilePath">The method file path</param> /// <param name="model">The instrument model</param> /// <param name="version">The instrument version</param> /// <returns>A list of errors it detected, or an empty list if no errors are found</returns> public static List <string> Validate(string methodFilePath, string model = "", string version = "") { var validationErrors = new List <string>(); methodFilePath = Path.GetFullPath(methodFilePath); using (IMethodXMLContext mxc = CreateContext(model, version)) using (IMethodXML xmlMeth = mxc.Create()) { xmlMeth.Open(methodFilePath); if (!xmlMeth.ValidateMethod()) { validationErrors.AddRange(xmlMeth.GetLastValidationErrors()); } } return(validationErrors); }
/// <summary> /// Applies the modification XML file to the method template, to produce a modified method file /// </summary> /// <param name="methodTemplate">The method to base off of</param> /// <param name="methodModXML">The modifications to be applied to the template method</param> /// <param name="outputMethod">The file path for the generated method</param> /// <param name="model">The instrument model</param> /// <param name="version">The instrument version</param> /// <param name="enableValidation">Enable automatic validation on saving</param> public static void ModifyMethod(string methodTemplate, string methodModXML, string outputMethod = "", string model = "", string version = "", bool enableValidation = true) { if (string.IsNullOrEmpty(methodTemplate)) { throw new ArgumentException("A method file path must be specified", "Method Template"); } if (string.IsNullOrEmpty(methodModXML)) { throw new ArgumentException("A method modification path must be specified", "Method Modification"); } // Handle relative/absolute paths methodTemplate = Path.GetFullPath(methodTemplate); methodModXML = Path.GetFullPath(methodModXML); // These files are required if (!File.Exists(methodTemplate)) { throw new IOException("File Not Found: " + methodTemplate); } if (!File.Exists(methodModXML)) { throw new IOException("File Not Found: " + methodModXML); } // Create output file path if not specified if (string.IsNullOrEmpty(outputMethod)) { outputMethod = methodTemplate.Replace(".meth", "_modified.meth"); } outputMethod = Path.GetFullPath(outputMethod); // Create output directory if doesn't exist if (!Directory.Exists(Path.GetDirectoryName(outputMethod))) { Directory.CreateDirectory(Path.GetDirectoryName(outputMethod)); } // If the instrument model is not specified, get the default installed one. (might not be the best) if (string.IsNullOrEmpty(model)) { model = MethodXMLFactory.GetInstalledServerModel(); if (string.IsNullOrEmpty(model)) { var instruments = MethodXMLFactory.GetInstalledInstrumentModels(); if (instruments.Count > 1) { throw new Exception(string.Format("Unable to find default installed instrument, you have {0} instruments registered", instruments.Count)); } else if (instruments.Count == 0) { throw new Exception("Unable to find any installed instruments!"); } else { model = instruments[0]; } } } // Get the type of instrument based on its name InstrumentFamily instrumentFamily = GetInstrumentFamilyFromModel(model); // Get the type of instrument modification based on the xml file InstrumentFamily xmlInstrumentFamily = GetInstrumentFamilyFromXml(methodModXML); // These two need to be equivalent to correctly apply the modifications if (instrumentFamily != xmlInstrumentFamily) { throw new ArgumentException(string.Format("The specified xml ({0}) is not compatible with the instrument model ({1}, {2})", xmlInstrumentFamily, instrumentFamily, model)); } using (IMethodXMLContext mxc = CreateContext(model, version)) using (IMethodXML xmlMeth = mxc.Create()) { // Open the template method xmlMeth.Open(methodTemplate); // Set the validation flag xmlMeth.EnableValidation(enableValidation); // Call the correct modification method based on the instrument type switch (instrumentFamily) { case InstrumentFamily.OrbitrapFusion: xmlMeth.ApplyMethodModificationsFromXMLFile(methodModXML); break; case InstrumentFamily.TSQ: xmlMeth.ImportMassListFromXMLFile(methodModXML); break; default: throw new ArgumentException("Unsupported instrument model:" + model); } // Save the in memory method to the output file xmlMeth.SaveAs(outputMethod); } }
/// <include file='doc\VsCodeDomParser.uex' path='docs/doc[@for="VsCodeDomParser.OnMethodPopulateStatements"]/*' /> /// <devdoc> /// Populate the parameter statement list from a method. Here is where we invoke the XmlProcessor /// </devdoc> private void OnMethodPopulateStatements(object sender, EventArgs e) { CodeMemberMethod codeMethod = (CodeMemberMethod)sender; CodeFunction vsFunction = (CodeFunction)GetVsElementFromCodeObject(codeMethod); IMethodXML xmlMethod = null; try { xmlMethod = (IMethodXML)vsFunction; } catch { } if (xmlMethod == null) { Debug.Fail("Couldn't get IMethodXML for method '" + codeMethod.Name + "'"); return; } string xmlCode = null; CodeDomLoader.StartMark(); // get a hold of the XML if possible. // try { xmlMethod.GetXML(ref xmlCode); } catch (Exception ex) { System.Runtime.InteropServices.COMException cex = ex as System.Runtime.InteropServices.COMException; throw new Exception(SR.GetString(SR.FailedToParseMethod, vsFunction.Name, ex.Message)); } finally { CodeDomLoader.EndMark("GetXML"); CodeDomLoader.StartMark(); } // pass it along to the processor. // XmlProcessor.ParseXml(xmlCode, codeMethod.Statements, this.FileName, codeMethod.Name); CodeDomLoader.EndMark("XML -> CodeDom Tree"); // Add the statement count to our user data. We use this as a quick way to tell if we need to // regenerate the contents of a method. // codeMethod.UserData[VsGenerateStatementsKey] = VsGenerateStatementsKey; // clear out the methods that we've generated before... // provider.ClearGeneratedMembers(); // now apply any handlers for default events. // if (provider.IsVB) { CodeTypeDeclaration codeTypeDecl = (CodeTypeDeclaration)codeMethod.UserData[typeof(CodeTypeDeclaration)]; if (codeTypeDecl == null) { return; } Hashtable handlers = (Hashtable)codeTypeDecl.UserData[VbHandlesClausesKey]; // save this so we can compare against it later to see // if we need to reload due to a handler change. // provider.FullParseHandlers = handlers; if (handlers == null || handlers.Count == 0) { return; } GetDelegateHookupsFromHandlesClauses(handlers, codeTypeDecl, codeMethod.Statements); } }