/// <summary>
/// Parses a list of sequences using a BioTextReader.
/// </summary>
/// <remarks>
/// This method should be overridden by any parsers that need to process file-scope
/// metadata that applies to all of the sequences in the file.
/// </remarks>
/// <param name="bioReader">bio text reader</param>
/// <param name="isReadOnly">
/// Flag to indicate whether the resulting sequences should be in readonly mode or not.
/// If this flag is set to true then the resulting sequences's isReadOnly property
/// will be set to true, otherwise it will be set to false.
/// </param>
/// <returns>The list of parsed ISequence objects.</returns>
protected IList <ISequence> Parse(BioTextReader bioReader, bool isReadOnly)
{
_lineCount = 0;
_sequenceCount = 0;
_lineLength = 0;
_sequenceBeginsAt = 1;
if (bioReader == null)
{
throw new ArgumentNullException("bioReader");
}
// no empty files allowed
if (!bioReader.HasLines)
{
string message = Resource.Parser_NoTextErrorMessage;
Trace.Report(message);
throw new InvalidOperationException(message);
}
// Check if DV is enabled and sidecar creation is possible
if (!string.IsNullOrEmpty(bioReader.FileName) && IsDataVirtualizationEnabled && SidecarFileProvider.IsIndexFileExists(bioReader.FileName))
{
while (bioReader.HasLines)
{
// Parse and forget as the list is now maintained by DV using sequence pointers
ParseOne(bioReader, isReadOnly);
}
// Create sidecar
SidecarFileProvider provider = SidecarFileProvider.CreateIndexFile(bioReader.FileName, _sequencePointers);
VirtualSequenceList virtualSequences =
new VirtualSequenceList(provider, this, _sequencePointers.Count)
{
CreateSequenceAsReadOnly = isReadOnly
};
_sequencePointers.Clear();
return(virtualSequences);
}
else
{
List <ISequence> sequences = new List <ISequence>();
while (bioReader.HasLines)
{
sequences.Add(ParseOne(bioReader, isReadOnly));
}
return(sequences);
}
}
public void ValidateVSLIndexOf()
{
VirtualSequenceList seqList = GetVirtualSequenceList(
Constants.MultiSequenceFileNodeName);
Assert.AreEqual(10, seqList.IndexOf(seqList[10]));
ApplicationLog.WriteLine(
"VSL Bvt : Successfully validated the IndexOf() method");
Console.WriteLine(
"VSL Bvt : Successfully validated the IndexOf() method");
}
public void ValidateVSLProperties()
{
VirtualSequenceList seqList = GetVirtualSequenceList(
Constants.MultiSequenceFileNodeName);
Assert.IsTrue(seqList.IsReadOnly);
Assert.AreNotEqual(0, seqList.Count);
ApplicationLog.WriteLine(
"VSL Bvt : Successfully validated the all properties");
Console.WriteLine(
"VSL Bvt : Successfully validated the all properties");
}
public void ValidateVSLContains()
{
VirtualSequenceList seqList =
GetVirtualSequenceList(Constants.MultiSequenceFileNodeName);
Assert.IsTrue(seqList.Contains(seqList[10]));
Assert.IsTrue(seqList.Contains(seqList[100]));
ApplicationLog.WriteLine(
"VSL Bvt : Successfully validated the Contains() method");
Console.WriteLine(
"VSL Bvt : Successfully validated the Contains() method");
}
/// <summary>
/// Gets the virtual sequence list
/// </summary>
/// <param name="nodeName">Xml node name</param>
/// <returns>Virtual Sequence List</returns>
static VirtualSequenceList GetVirtualSequenceList(string nodeName)
{
// Gets the expected sequence from the Xml
string filePath = Utility._xmlUtil.GetTextValue(
nodeName,
Constants.FilePathNode1);
FastaParser parserObj = new FastaParser();
parserObj.EnforceDataVirtualization = true;
VirtualSequenceList seqList =
(VirtualSequenceList)parserObj.Parse(filePath);
return(seqList);
}
public void ValidateVSLCopyTo()
{
VirtualSequenceList seqList = GetVirtualSequenceList(
Constants.MultiSequenceFileNodeName);
ISequence[] seqArray = new Sequence[seqList.Count];
seqList.CopyTo(seqArray, 0);
Assert.AreEqual(seqList[0].ToString(),
seqArray[0].ToString());
Assert.AreEqual(seqList[seqList.Count - 1].ToString(),
seqArray[seqList.Count - 1].ToString());
ApplicationLog.WriteLine(
"VSL Bvt : Successfully validated the CopyTo() method");
Console.WriteLine(
"VSL Bvt : Successfully validated the CopyTo() method");
}
public void ValidateVSLClear()
{
VirtualSequenceList seqList = GetVirtualSequenceList(
Constants.NeedlemanWunschVeryLargeSizeProAlignAlgorithmNodeName);
try
{
seqList.Clear();
Assert.Fail();
}
catch (NotSupportedException)
{
ApplicationLog.WriteLine(
"VSL Bvt : Successfully validated the Clear() method");
Console.WriteLine(
"VSL Bvt : Successfully validated the Clear() method");
}
}
public void ValidateVSLAdd()
{
VirtualSequenceList seqList = GetVirtualSequenceList(
Constants.NeedlemanWunschVeryLargeSizeProAlignAlgorithmNodeName);
try
{
seqList.Add((ISequence) new Sequence(Alphabets.Protein,
"KKLLEE"));
Assert.Fail();
}
catch (NotSupportedException)
{
ApplicationLog.WriteLine(
"VSL Bvt : Successfully validated the Add() method");
Console.WriteLine(
"VSL Bvt : Successfully validated the Add() method");
}
}
/// <summary>
/// Parses a list of biological sequence texts from a file.
/// </summary>
/// <param name="filename">The name of a biological sequence file.</param>
/// <param name="isReadOnly">
/// Flag to indicate whether the resulting sequences should be in readonly mode or not.
/// If this flag is set to true then the resulting sequences's isReadOnly property
/// will be set to true, otherwise it will be set to false.
/// </param>
/// <returns>The list of parsed ISequence objects.</returns>
public IList <ISequence> Parse(string filename, bool isReadOnly)
{
// default to full load
_blockSize = FileLoadHelper.DefaultFullLoadBlockSize;
_maxNumberOfBlocks = 0;
// check if DV is required
if (filename != null)
{
_fileName = filename;
FileInfo fileInfo = new FileInfo(_fileName);
_enforceDataVirtualizationByFileSize = EnforceDataVirtualizationByFileSize * FileLoadHelper.KBytes;
if ((_enforceDataVirtualizationByFileSize != 0 && fileInfo.Length >= _enforceDataVirtualizationByFileSize) ||
_isDataVirtualizationEnforced)
{
_blockSize = FileLoadHelper.DefaultBlockSize;
_maxNumberOfBlocks = FileLoadHelper.DefaultMaxNumberOfBlocks;
}
}
// Check for sidecar
if (IsDataVirtualizationEnabled)
{
_sidecarFileProvider = new SidecarFileProvider(_fileName);
_sidecarFileProvider.Close();
// if valid sidecar file exists
if (_sidecarFileProvider.IsSidecarValid)
{
// Create virtual list and return
return(new VirtualSequenceList(_sidecarFileProvider, this, _sidecarFileProvider.Count)
{
CreateSequenceAsReadOnly = isReadOnly
});
}
// else create new sidecar
_sidecarFileProvider = new SidecarFileProvider(_fileName, true);
if (_sidecarFileProvider.SidecarFileExists)
{
using (_mbfStreamReader = new MBFStreamReader(_fileName))
{
try
{
while (_mbfStreamReader.HasLines)
{
// Parse and forget as the list is now maintained by DV using sequence pointers
ParseOne(_mbfStreamReader, isReadOnly);
}
_sidecarFileProvider.Close();
VirtualSequenceList virtualSequences =
new VirtualSequenceList(_sidecarFileProvider, this, _sidecarFileProvider.Count)
{
CreateSequenceAsReadOnly = isReadOnly
};
return(virtualSequences);
}
catch (Exception)
{
_sidecarFileProvider.Cleanup();
}
}
}
}
// non-DV parsing
using (MBFTextReader mbfReader = new MBFTextReader(filename))
{
return(Parse(mbfReader, isReadOnly));
}
}
