public void ValidateFVSPProperties()
{
IVirtualSequenceParser parserObj = new FastaParser();
try
{
FileVirtualSequenceProvider provObj =
new FileVirtualSequenceProvider(parserObj, GetSequencePointer());
provObj.BlockSize = 5;
provObj.IsReadOnly = false;
provObj.MaxNumberOfBlocks = 10;
provObj.SequencePointerInstance = GetSequencePointer();
SequencePointer seqPoint = GetSequencePointer();
Assert.AreEqual(5, provObj.BlockSize);
Assert.AreEqual(10, provObj.MaxNumberOfBlocks);
Assert.IsFalse(provObj.IsReadOnly);
Assert.AreEqual(seqPoint.AlphabetName, provObj.SequencePointerInstance.AlphabetName);
Assert.AreEqual(1301, provObj.Count);
ApplicationLog.WriteLine(@"FVSP Bvt : Successfully validated all the properties");
Console.WriteLine(@"FVSP Bvt : Successfully validated all the properties");
}
finally
{
(parserObj as FastaParser).Dispose();
}
}
public void ValidateFVSPClear()
{
FileVirtualSequenceProvider provObj =
GetVirtualSequenceProvider();
// Clear
provObj.Clear();
Assert.AreEqual(0, provObj.Count);
ApplicationLog.WriteLine(@"FVSP Bvt : Successfully validated the Clear() method");
Console.WriteLine(@"FVSP Bvt : Successfully validated the Clear() method");
}
public void ValidateFVSPInsertSeqItem()
{
FileVirtualSequenceProvider provObj =
GetVirtualSequenceProvider();
ISequence seqObj = new Sequence(Alphabets.DNA, "A");
provObj.Insert(0, seqObj[0]);
Assert.AreEqual(seqObj[0], provObj[0]);
ApplicationLog.WriteLine(@"FVSP Bvt : Successfully validated the Insert(int, seqItem) method");
Console.WriteLine(@"FVSP Bvt : Successfully validated the Insert(int, seqItem) method");
}
public void ValidateFVSPAdd()
{
FileVirtualSequenceProvider provObj =
GetVirtualSequenceProvider();
ISequence seqObj =
new Sequence(Alphabets.DNA, "AGGCT");
provObj.Add(seqObj[0]);
Assert.AreEqual(seqObj[0], provObj[provObj.Count - 1]);
ApplicationLog.WriteLine(@"FVSP Bvt : Successfully validated the Add() method");
Console.WriteLine(@"FVSP Bvt : Successfully validated the Add() method");
}
public void ValidateFVSPContains()
{
FileVirtualSequenceProvider provObj =
GetVirtualSequenceProvider();
ISequence seqObj =
new Sequence(Alphabets.DNA, "AGGCT");
provObj.Add(seqObj[0]);
provObj.Add(seqObj[1]);
Assert.IsTrue(provObj.Contains(seqObj[0]));
ApplicationLog.WriteLine(@"FVSP Bvt : Successfully validated the Contains() method");
Console.WriteLine(@"FVSP Bvt : Successfully validated the Contains() method");
}
public void ValidateFVSPVirtualSeqParserSeqPointerConstructor()
{
FileVirtualSequenceProvider provObj =
GetVirtualSequenceProvider();
SequencePointer seqPointerObj = GetSequencePointer();
Assert.AreEqual(1301, provObj.Count);
Assert.AreEqual(seqPointerObj.Id, provObj.SequencePointerInstance.Id);
ApplicationLog.WriteLine(@"FVSP Bvt : Successfully validated the constructor
FileVirtualSequenceProvider(IVirtualSequenceParser, SequencePointer)");
Console.WriteLine(@"FVSP Bvt : Successfully validated the constructor
FileVirtualSequenceProvider(IVirtualSequenceParser, SequencePointer)");
}
/// <summary>
/// Gets the VirtualSequenceProvider
/// </summary>
/// <returns>Virtual Sequence Provider</returns>
static FileVirtualSequenceProvider GetVirtualSequenceProvider()
{
string filePath = Utility._xmlUtil.GetTextValue(
Constants.SimpleFastaDnaNodeName, Constants.FilePathNode);
IVirtualSequenceParser parserObj = new FastaParser();
parserObj.Parse(filePath);
FileVirtualSequenceProvider provObj =
new FileVirtualSequenceProvider(parserObj,
GetSequencePointer());
return(provObj);
}
public void ValidateFVSPRemoveRange()
{
FileVirtualSequenceProvider provObj =
GetVirtualSequenceProvider();
ISequence seqObj = new Sequence(Alphabets.DNA, "GTTCG");
provObj.Add(seqObj[0]);
provObj.Add(seqObj[1]);
provObj.Add(seqObj[2]);
provObj.RemoveRange(0, 1);
Assert.AreEqual(seqObj[1], provObj[0]);
ApplicationLog.WriteLine(@"FVSP Bvt : Successfully validated the RemoveRange() method");
Console.WriteLine(@"FVSP Bvt : Successfully validated the RemoveRange() method");
}
public void ValidateFVSPCopyToByteArray()
{
FileVirtualSequenceProvider provObj =
GetVirtualSequenceProvider();
ISequence seqObj =
new Sequence(Alphabets.DNA, "GGCT");
provObj.Add(seqObj[0]);
byte[] byteArray = new byte[provObj.Count];
provObj.CopyTo(byteArray, 0);
Assert.AreEqual("G", seqObj[0].Symbol.ToString());
ApplicationLog.WriteLine(@"FVSP Bvt : Successfully validated the CopyTo() method");
Console.WriteLine(@"FVSP Bvt : Successfully validated the CopyTo() method");
}
public void ValidateFVSPInsertRange()
{
FileVirtualSequenceProvider provObj =
GetVirtualSequenceProvider();
ISequence seqObj = new Sequence(Alphabets.DNA, "GTTCG");
provObj.InsertRange(0, "GTTCG");
Assert.AreEqual(seqObj[0], provObj.GetISequenceItem(0));
Assert.AreEqual(seqObj[1], provObj.GetISequenceItem(1));
Assert.AreEqual(seqObj[2], provObj.GetISequenceItem(2));
Assert.AreEqual(seqObj[3], provObj.GetISequenceItem(3));
Assert.AreEqual(seqObj[4], provObj.GetISequenceItem(4));
ApplicationLog.WriteLine(@"FVSP Bvt : Successfully validated the InsertRange() method");
Console.WriteLine(@"FVSP Bvt : Successfully validated the InsertRange() method");
}
public void ValidateFVSPReplaceSeqItem()
{
FileVirtualSequenceProvider provObj =
GetVirtualSequenceProvider();
ISequence seqObj = new Sequence(Alphabets.DNA, "GTTCG");
provObj.Add(seqObj[0]);
provObj.Add(seqObj[1]);
provObj.Add(seqObj[2]);
provObj.Add(seqObj[3]);
provObj.Replace(0, seqObj[3]);
Assert.AreEqual(seqObj[3], provObj.GetISequenceItem(0));
ApplicationLog.WriteLine(
"FVSP Bvt : Successfully validated the Replace(int, seqItem) method");
Console.WriteLine(
"FVSP Bvt : Successfully validated the Replace(int, seqItem) method");
}
/// <summary>
/// Gets the VirtualSequenceProvider
/// </summary>
/// <returns>Virtual Sequence Provider</returns>
FileVirtualSequenceProvider GetVirtualSequenceProvider()
{
string filePath = _utilityObj._xmlUtil.GetTextValue(
Constants.SimpleFastaDnaNodeName, Constants.FilePathNode);
IVirtualSequenceParser parserObj = new FastaParser();
try
{
parserObj.Parse(filePath);
FileVirtualSequenceProvider provObj =
new FileVirtualSequenceProvider(parserObj,
GetSequencePointer());
return provObj;
}
finally
{
(parserObj as FastaParser).Dispose();
}
}
/// <summary>
/// Parses a single FASTA sequence from a file using MBFStreamReader.
/// This method is only used in data virtualization scenarios.
/// </summary>
/// <param name="mbfReader">The MBFStreamReader of the file to be parsed.</param>
/// <param name="isReadOnly">
/// Flag to indicate whether the resulting sequence should be in read-only mode.
/// If this flag is set to true then the resulting sequence's IsReadOnly property
/// will be set to true, otherwise it will be set to false.
/// </param>
/// <returns>The parsed sequence.</returns>
protected ISequence ParseOneWithSpecificFormat(MBFStreamReader mbfReader, bool isReadOnly)
{
SequencePointer sequencePointer = new SequencePointer();
if (mbfReader == null)
{
throw new ArgumentNullException("mbfReader");
}
string message;
if (!mbfReader.Line.StartsWith(">", StringComparison.OrdinalIgnoreCase))
{
message = string.Format(CultureInfo.InvariantCulture,
Resource.INVALID_INPUT_FILE,
Resource.FASTA_NAME);
Trace.Report(message);
throw new FileFormatException(message);
}
// Process header line.
Sequence sequence;
string id = mbfReader.GetLineField(2).Trim();
// save initial start and end indices
sequencePointer.StartingLine = (int)(mbfReader.Position - mbfReader.CurrentLineStartingIndex);
sequencePointer.IndexOffsets[0] = mbfReader.Position;
sequencePointer.IndexOffsets[1] = mbfReader.Position;
mbfReader.GoToNextLine();
IAlphabet alphabet = Alphabet;
if (alphabet == null)
{
alphabet = _commonSequenceParser.IdentifyAlphabet(alphabet, mbfReader.Line);
if (alphabet == null)
{
message = string.Format(CultureInfo.InvariantCulture,
Resource.InvalidSymbolInString,
mbfReader.Line);
Trace.Report(message);
throw new FileFormatException(message);
}
}
if (Encoding == null)
{
sequence = new Sequence(alphabet);
}
else
{
sequence = new Sequence(alphabet, Encoding, string.Empty)
{
IsReadOnly = false
};
}
int currentBlockSize = 0;
int symbolCount = -1;
int newLineCharacterCount = mbfReader.NewLineCharacterCount;
int prenewLineCharacterCount = 0;
int lineLength = mbfReader.Line.Length;
sequence.ID = id;
while (mbfReader.HasLines && !mbfReader.Line.StartsWith(">", StringComparison.OrdinalIgnoreCase))
{
sequencePointer.IndexOffsets[1] += mbfReader.Line.Length;
if (Alphabet == null)
{
alphabet = _commonSequenceParser.IdentifyAlphabet(sequence.Alphabet, mbfReader.Line);
if (alphabet == null)
{
message = string.Format(CultureInfo.InvariantCulture,
Resource.InvalidSymbolInString,
mbfReader.Line);
Trace.Report(message);
throw new FileFormatException(message);
}
if (sequence.Alphabet != alphabet)
{
Sequence seq = new Sequence(alphabet, Encoding, sequence)
{
IsReadOnly = false
};
sequence.Clear();
sequence = seq;
}
}
newLineCharacterCount = mbfReader.NewLineCharacterCount;
lineLength = mbfReader.Line.Length;
while (lineLength != 0 && _sidecarFileProvider != null)
{
if (lineLength + currentBlockSize + newLineCharacterCount <= _blockSize)
{
symbolCount += lineLength;
currentBlockSize += lineLength + newLineCharacterCount;
lineLength = 0;
}
else
{
symbolCount += _blockSize - currentBlockSize;
lineLength = lineLength - (_blockSize - currentBlockSize);
if (lineLength <= 0)
{
symbolCount += lineLength;
prenewLineCharacterCount = newLineCharacterCount + lineLength;
lineLength = 0;
}
currentBlockSize = _blockSize;
}
if (currentBlockSize == _blockSize)
{
// write to file.
_sidecarFileProvider.WriteBlockIndex(symbolCount);
currentBlockSize = prenewLineCharacterCount;
prenewLineCharacterCount = 0;
}
}
mbfReader.GoToNextLine();
}
if (_sidecarFileProvider != null)
{
if (sequencePointer.IndexOffsets[1] - sequencePointer.IndexOffsets[0] > _blockSize &&
currentBlockSize - newLineCharacterCount > 0)
{
_sidecarFileProvider.WriteBlockIndex(symbolCount);
}
else
{
_sidecarFileProvider.WriteBlockIndex(0);
}
}
if (sequence.MoleculeType == MoleculeType.Invalid)
{
sequence.MoleculeType = CommonSequenceParser.GetMoleculeType(sequence.Alphabet);
}
sequence.IsReadOnly = isReadOnly;
sequencePointer.AlphabetName = sequence.Alphabet.Name;
sequencePointer.Id = sequence.ID;
if (_sidecarFileProvider != null)
{
// Write each sequence pointer to the sidecar file immediately
_sidecarFileProvider.WritePointer(sequencePointer);
}
FileVirtualSequenceProvider dataprovider = new FileVirtualSequenceProvider(this, sequencePointer)
{
BlockSize = _blockSize,
MaxNumberOfBlocks = _maxNumberOfBlocks
};
sequence.VirtualSequenceProvider = dataprovider;
return(sequence);
}
/// <summary>
/// Parses a single FASTA text from a reader into a sequence.
/// </summary>
/// <param name="bioReader">bio text reader</param>
/// <param name="isReadOnly">
/// Flag to indicate whether the resulting sequence should be in readonly mode or not.
/// If this flag is set to true then the resulting sequence's isReadOnly property
/// will be set to true, otherwise it will be set to false.
/// </param>
/// <returns>A new Sequence instance containing parsed data.</returns>
protected ISequence ParseOneWithSpecificFormat(BioTextReader bioReader, bool isReadOnly)
{
SequencePointer sequencePointer = null;
if (bioReader == null)
{
throw new ArgumentNullException("bioReader");
}
string message;
if (!bioReader.Line.StartsWith(">", StringComparison.OrdinalIgnoreCase))
{
message = string.Format(CultureInfo.InvariantCulture,
Resource.INVAILD_INPUT_FILE,
Resource.FASTA_NAME);
Trace.Report(message);
throw new FileFormatException(message);
}
// Process header line.
Sequence sequence;
string id = bioReader.GetLineField(2).Trim();
if (_blockSize > FileLoadHelper.DefaultFullLoadBlockSize)
{
_lineCount++;
_lineLength += bioReader.Line.Length;
sequencePointer = new SequencePointer {
StartingLine = _lineCount
};
}
bioReader.GoToNextLine();
IAlphabet alphabet = Alphabet;
if (alphabet == null)
{
alphabet = _commonSequenceParser.IdentifyAlphabet(alphabet, bioReader.Line);
if (alphabet == null)
{
message = string.Format(CultureInfo.InvariantCulture,
Resource.InvalidSymbolInString,
bioReader.Line);
Trace.Report(message);
throw new FileFormatException(message);
}
}
if (Encoding == null)
{
sequence = new Sequence(alphabet);
}
else
{
sequence = new Sequence(alphabet, Encoding, string.Empty)
{
IsReadOnly = false
};
}
bool sameSequence = false;
sequence.ID = id;
while (bioReader.HasLines && !bioReader.Line.StartsWith(">", StringComparison.OrdinalIgnoreCase))
{
if (Alphabet == null)
{
alphabet = _commonSequenceParser.IdentifyAlphabet(sequence.Alphabet, bioReader.Line);
if (alphabet == null)
{
message = string.Format(CultureInfo.InvariantCulture,
Resource.InvalidSymbolInString,
bioReader.Line);
Trace.Report(message);
throw new FileFormatException(message);
}
if (sequence.Alphabet != alphabet)
{
Sequence seq = new Sequence(alphabet, Encoding, sequence)
{
IsReadOnly = false
};
sequence.Clear();
sequence = seq;
}
}
// full load
if (_blockSize <= 0)
{
sequence.InsertRange(sequence.Count, bioReader.Line);
}
else
{
if (sameSequence == false)
{
_sequenceBeginsAt = _lineLength;
sameSequence = true;
}
_lineLength += bioReader.Line.Length;
_lineCount++;
}
bioReader.GoToNextLine();
}
if (sequence.MoleculeType == MoleculeType.Invalid)
{
sequence.MoleculeType = CommonSequenceParser.GetMoleculeType(sequence.Alphabet);
}
sequence.IsReadOnly = isReadOnly;
// full load
if (_blockSize == FileLoadHelper.DefaultFullLoadBlockSize)
{
return(sequence);
}
if (sequencePointer != null)
{
sequencePointer.AlphabetName = sequence.Alphabet.Name;
sequencePointer.Id = sequence.ID;
sequencePointer.StartingIndex = _sequenceBeginsAt;
sequencePointer.EndingIndex = _lineLength;
_sequencePointers.Add(sequencePointer);
}
_sequenceCount++;
FileVirtualSequenceProvider dataprovider = new FileVirtualSequenceProvider(this, sequencePointer)
{
BlockSize = _blockSize,
MaxNumberOfBlocks = _maxNumberOfBlocks
};
sequence.VirtualSequenceProvider = dataprovider;
return(sequence);
}
