/// <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);
}
