/// <summary> /// Parses the sequences from the open file. /// </summary> /// <param name="parser">Sequence Parser</param> /// <returns>Set of parsed sequences.</returns> public static Tree Parse(this IPhylogeneticTreeParser parser) { var fs = ParserFormatterExtensions <IPhylogeneticTreeParser> .GetOpenStream(parser, false); if (fs == null) { throw new Exception("You must open a parser before calling Parse."); } return(parser.Parse(fs)); }
/// <summary> /// Parses the data from the open file. /// </summary> /// <typeparam name="T">Sequence Type</typeparam> /// <param name="parser">Parser</param> /// <returns>Set of parsed data elements.</returns> public static T ParseOne <T>(this IParser <T> parser) { var fs = ParserFormatterExtensions <IParser <T> > .GetOpenStream(parser, false); if (fs == null) { throw new Exception("You must open a parser before calling ParseOne."); } return(parser.ParseOne(fs)); }
/// <summary> /// Parses the sequences from the open file. /// </summary> /// <param name="parser">Sequence Parser</param> /// <returns>Set of parsed sequences.</returns> public static IEnumerable <ISequenceAlignment> Parse(this ISequenceAlignmentParser parser) { var fs = ParserFormatterExtensions <ISequenceAlignmentParser> .GetOpenStream(parser, false); if (fs == null) { throw new Exception("You must open a parser before calling Parse."); } return(parser.Parse(fs)); }
/// <summary> /// Writes a single data element to the formatter. /// </summary> /// <param name="formatter">Formatter</param> /// <param name="data">Data</param> public static void Format <T>(this IFormatter <T> formatter, T data) where T : class { var fs = ParserFormatterExtensions <IFormatter <T> > .GetOpenStream(formatter, true); if (fs != null) { formatter.Format(fs, data); } else { throw new Exception("You must open a formatter before calling Write."); } }
/// <summary> /// Writes a single data element to the formatter. /// </summary> /// <param name="formatter">Formatter</param> /// <param name="data">Tree Data</param> public static void Format(this IPhylogeneticTreeFormatter formatter, Tree data) { var fs = ParserFormatterExtensions <IPhylogeneticTreeFormatter> .GetOpenStream(formatter, true); if (fs != null) { formatter.Format(fs, data); } else { throw new Exception("You must open a formatter before calling Write."); } }
/// <summary> /// Writes a single sequence to the formatter. /// </summary> /// <param name="formatter">Formatter</param> /// <param name="sequence">Sequence</param> public static void Format(this ISequenceAlignmentFormatter formatter, ISequenceAlignment sequence) { var fs = ParserFormatterExtensions <ISequenceAlignmentFormatter> .GetOpenStream(formatter, true); if (fs != null) { formatter.Format(fs, sequence); } else { throw new Exception("You must open a formatter before calling Write."); } }
/// <summary> /// Closes the parser. /// </summary> /// <param name="parser">Parser</param> public static void Close(this IPhylogeneticTreeParser parser) { ParserFormatterExtensions <IPhylogeneticTreeParser> .Close(parser); }
/// <summary> /// Opens a sequence file using the parser. /// </summary> /// <param name="parser">Parser</param> /// <param name="filename">File to open</param> /// <returns>Disposable object to close the stream.</returns> public static IDisposable Open(this IPhylogeneticTreeParser parser, string filename) { return(ParserFormatterExtensions <IPhylogeneticTreeParser> .Open(parser, filename)); }
/// <summary> /// Open a file and parse it with the formatter. /// </summary> /// <param name="formatter">Formatter</param> /// <param name="filename">Filename</param> /// <returns>IDisposable to close stream.</returns> public static IDisposable Open <T>(this IFormatter <T> formatter, string filename) where T : class { return(ParserFormatterExtensions <IFormatter <T> > .Open(formatter, filename)); }
/// <summary> /// Closes the formatter. /// </summary> /// <param name="formatter">Formatter.</param> public static void Close <T>(this IFormatter <T> formatter) where T : class { ParserFormatterExtensions <IFormatter <T> > .Close(formatter); }
/// <summary> /// Closes the parser. /// </summary> /// <typeparam name="T">Sequence type</typeparam> /// <param name="parser">Parser</param> public static void Close <T>(this IParser <T> parser) { ParserFormatterExtensions <IParser <T> > .Close(parser); }
/// <summary> /// Opens a sequence file using the parser. /// </summary> /// <param name="parser">Parser</param> /// <param name="filename">File to open</param> /// <returns>Disposable object to close the stream.</returns> public static IDisposable Open <T>(this IParser <T> parser, string filename) { return(ParserFormatterExtensions <IParser <T> > .Open(parser, filename)); }
/// <summary> /// Parses the sequences from the open file. /// </summary> /// <param name="parser">Sequence Parser</param> /// <returns>Set of parsed sequences.</returns> public static ISequenceAlignment ParseOne(this ISequenceAlignmentParser parser) { var fs = ParserFormatterExtensions <ISequenceAlignmentParser> .GetOpenStream(parser, false); return(parser.ParseOne(fs)); }
/// <summary> /// Opens a sequence file using the parser. /// </summary> /// <param name="parser">Parser</param> /// <param name="filename">File to open</param> /// <returns>Disposable object to close the stream.</returns> public static IDisposable Open(this ISequenceAlignmentParser parser, string filename) { return(ParserFormatterExtensions <ISequenceAlignmentParser> .Open(parser, filename)); }
/// <summary> /// Closes the parser. /// </summary> /// <param name="parser">Parser</param> public static void Close(this ISequenceAlignmentParser parser) { ParserFormatterExtensions <ISequenceAlignmentParser> .Close(parser); }