/// <summary>
/// Parses the sequences from the given filename.
/// </summary>
/// <param name="parser">Sequence Parser</param>
/// <param name="fileName">Filename to open/close</param>
/// <returns>Set of parsed sequences.</returns>
public static IEnumerable <ISequenceAlignment> Parse(this ISequenceAlignmentParser parser, string fileName)
{
using (FileStream fs = File.OpenRead(fileName))
{
foreach (var item in parser.Parse(fs))
{
yield return(item);
}
}
}
/// <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>
/// Returns parser which supports the specified file.
/// </summary>
/// <param name="fileName">File name for which the parser is required.</param>
/// <returns>If found returns the parser as ISequenceAlignmentParser else returns null.</returns>
public static ISequenceAlignmentParser FindParserByFile(string fileName)
{
ISequenceAlignmentParser parser = null;
if (!string.IsNullOrEmpty(fileName))
{
if (Helper.IsSAM(fileName))
{
parser = new SAMParser();
}
else
{
parser = null;
}
}
return(parser);
}
public void ValidateSamParserWithDVIscFile()
{
// Gets the expected sequence from the Xml
string filePath = _utilityObj._xmlUtil.GetTextValue(
Constants.SAMFileWithRefNode, Constants.FilePathNode);
ISequenceAlignmentParser iSeqParser =
SequenceAlignmentParsers.FindParserByFile(filePath);
if (null != iSeqParser)
{
IVirtualSequenceAlignmentParser vParserObj =
iSeqParser as IVirtualSequenceAlignmentParser;
if (null != vParserObj)
{
vParserObj.EnforceDataVirtualization = true;
}
else
{
Assert.Fail("SAM P1 Cases : Could not find the SAM Parser Object.");
}
string iscFilePath =
string.Concat(filePath, ".isc");
iSeqParser.Parse(filePath);
if (File.Exists(iscFilePath))
{
Console.WriteLine(
"SAM P1 Cases : DV enabled as expected and isc file created successfully.");
ApplicationLog.WriteLine(
"SAM P1 Cases : DV enabled as expected and isc file created successfully.");
}
else
{
Assert.Fail("SAM P1 Cases : DV not enabled as expected.");
}
}
else
{
Assert.Fail("SAM P1 Cases : Could not find the SAM file");
}
}
/// <summary>
/// Validates general Sequence Parser.
/// </summary>
/// <param name="nodeName">xml node name.</param>
/// <param name="IsParser">IsParser is true if testcases is validating Parsers,
/// false if formatter validation</param>
void ValidateSequenceFileParser(string nodeName, bool IsParser)
{
// Gets the expected sequence from the Xml
string[] filePaths = _utilityObj._xmlUtil.GetTextValues(nodeName,
Constants.FilePathsNode);
string parserDescription = _utilityObj._xmlUtil.GetTextValue(nodeName,
Constants.DescriptionNode);
string parserName = _utilityObj._xmlUtil.GetTextValue(nodeName,
Constants.ParserNameNode);
string fileTypes = _utilityObj._xmlUtil.GetTextValue(nodeName,
Constants.FileTypesNode);
// Get a default parser for the file types.
for (int i = 0; i < filePaths.Length; i++)
{
if (IsParser)
{
ISequenceAlignmentParser parser = SequenceAlignmentParsers.FindParserByFile(filePaths[i]);
string description = parser.Description.Replace("\r", "").Replace("\n", "");
// Validate parser name, description and the file type supported by parser.
Assert.AreEqual(parserName, parser.Name);
Assert.AreEqual(parserDescription, description);
Assert.AreEqual(fileTypes, parser.FileTypes);
}
else
{
ISequenceAlignmentFormatter formatter =
SequenceAlignmentFormatters.FindFormatterByFile(filePaths[i]);
Console.WriteLine(filePaths[i]);
Console.WriteLine(formatter.Description);
string description =
formatter.Description.Replace("\r", "").Replace("\n", "");
// Validate parser name, description and the file type supported by parser.
Assert.AreEqual(parserName, formatter.Name);
Assert.AreEqual(parserDescription, description);
Assert.AreEqual(fileTypes, formatter.FileTypes);
}
}
Console.WriteLine(string.Format((IFormatProvider)null,
"SequenceAlignmentParser : Type of the parser is validated successfully"));
ApplicationLog.WriteLine("Type of the parser is validated successfully");
}
/// <summary>
/// Initialize the parser and start the service using the config params
/// </summary>
/// <param name="parser"></param>
/// <param name="configparameters"></param>
public TestIClustalWServiceHandler(ISequenceAlignmentParser parser, ConfigParameters configparameters)
{
_ClustalWParser = parser;
Configuration = configparameters;
}
/// <summary>
/// Parses the sequences from the open file.
/// </summary>
/// <param name="parser">Sequence Parser</param>
/// <param name="filename">File to parse</param>
/// <returns>Set of parsed sequences.</returns>
public static T ParseOne <T>(this ISequenceAlignmentParser parser, string filename)
where T : ISequenceAlignment
{
using (var fs = File.OpenRead(filename))
return((T)parser.ParseOne(fs));
}
/// <summary>
/// Parses the sequences from the open file.
/// </summary>
/// <param name="parser">Sequence Parser</param>
/// <param name="filename">File to parse</param>
/// <returns>Set of parsed sequences.</returns>
public static ISequenceAlignment ParseOne(this ISequenceAlignmentParser parser, string filename)
{
using (var fs = File.OpenRead(filename))
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 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);
}
