/// <summary>
/// Reads a sequence pointer from a binary stream.
/// </summary>
/// <param name="stream">The stream to deserialize from.</param>
/// <returns>The SequencePointer object.</returns>
private static SequencePointer ReadPointer(FileStream stream)
{
SequencePointer pointer = new SequencePointer();
BinaryReader reader = new BinaryReader(stream);
pointer.StartingLine = reader.ReadInt32();
pointer.IndexOffsets[0] = reader.ReadInt64();
pointer.IndexOffsets[1] = reader.ReadInt64();
string alphabetName = new string(reader.ReadChars(3));
foreach (IAlphabet alphabet in Alphabets.All)
{
if (alphabet.Name.StartsWith(alphabetName, StringComparison.Ordinal))
{
pointer.AlphabetName = alphabet.Name;
break;
}
}
if (string.IsNullOrEmpty(pointer.AlphabetName))
{
throw new FileFormatException("alphabet");
}
return(pointer);
}
/// <summary>
/// Indexer with which one can access the sequences in the indexed file.
/// </summary>
/// <param name="index">The zero-based index of the SequencePointer to fetch.</param>
/// <returns>SequencePointer object at the specified index.</returns>
public SequencePointer this[int index]
{
get
{
if (_streamReader == null || _streamReader.CanRead == false)
{
string sidecarFileName = _sourceFileName + SidecarFileExtension;
OpenSidecar(sidecarFileName);
}
if (IsSidecarValid)
{
if (index >= _header.SequenceCount || index < 0)
{
throw new ArgumentOutOfRangeException("index");
}
_streamReader.Seek(_contentsOffset, SeekOrigin.Begin);
// find the entry for the item at the given index
_streamReader.Seek(index * PayloadBlockSize, SeekOrigin.Current);
// Read the required sequence pointer
SequencePointer loadedSequence = ReadPointer(_streamReader);
return(loadedSequence);
}
else
{
return(null);
}
}
}
/// <summary>
/// Initializes a new instance of MBF.IO.FileVirtualSequenceProvider
/// class to hold a sequence parser, a sidecar file provider and
/// the index of the sequence.
/// </summary>
/// <param name="parser">A virtual parser object.</param>
/// <param name="pointer">The sequence pointer.</param>
/// <param name="sidecarFileProvider">A sidecar file provider.</param>
/// <param name="index">The zero-based index of the sequence within the file.</param>
public FileVirtualSequenceProvider(IVirtualSequenceParser parser, SequencePointer pointer, SidecarFileProvider sidecarFileProvider, int index)
: this(parser, pointer)
{
if (sidecarFileProvider == null)
{
throw new ArgumentNullException("sidecarFileProvider");
}
_sidecarProvider = sidecarFileProvider;
_sequenceIndex = index;
}
/// <summary>
/// Gets the index of a qualitative sequence within the list.
/// Throws a NotSupportedException when attempting to set the position
/// since VirtualSequenceList is read-only.
/// </summary>
/// <param name="index">The zero-based index of the qualitative sequence in the list.</param>
/// <returns>The qualitative sequence found at the specified index.</returns>
public IQualitativeSequence this[int index]
{
get
{
QualitativeSequence virtualQualitativeSequence;
if (_sequenceDictionary.ContainsKey(index))
{
virtualQualitativeSequence = _sequenceDictionary[index].Target as QualitativeSequence;
if (virtualQualitativeSequence != null)
{
return(virtualQualitativeSequence);
}
_sequenceDictionary.Remove(index);
}
SequencePointer pointer = _sidecarProvider[index];
// Get the alphabet from alphabet name.
IAlphabet alphabet = Alphabets.All.Single(A => A.Name.Equals(pointer.AlphabetName));
virtualQualitativeSequence = new QualitativeSequence(alphabet)
{
ID = ((FastQParser)_sequenceParser).GetSequenceID(pointer),
VirtualQualitativeSequenceProvider =
new FileVirtualQualitativeSequenceProvider(_sequenceParser, pointer)
};
if (pointer.IndexOffsets[1] - pointer.IndexOffsets[0] < virtualQualitativeSequence.VirtualQualitativeSequenceProvider.BlockSize)
{
virtualQualitativeSequence.VirtualQualitativeSequenceProvider.BlockSize = (int)(pointer.IndexOffsets[1] - pointer.IndexOffsets[0]);
}
virtualQualitativeSequence.IsReadOnly = CreateSequenceAsReadOnly;
// memory opt : cleanup the weak reference dictionary
if (_sequenceDictionary.Count > 0 && (_sequenceDictionary.Count % MaximumDictionaryLength) == 0)
{
foreach (int key in _sequenceDictionary.Keys.Where(K => _sequenceDictionary[K].IsAlive == false).ToList())
{
_sequenceDictionary.Remove(key);
}
}
_sequenceDictionary.Add(index, new WeakReference(virtualQualitativeSequence, false));
return(virtualQualitativeSequence);
}
set
{
throw new NotSupportedException(Properties.Resource.NotSupportedInVirtualSequence);
}
}
/// <summary>
/// Writes the sequence pointer to a binary stream.
/// </summary>
/// <param name="streamWriter">The outputStream to serialize to.</param>
/// <param name="sequencePointer">Sequence pointer obejct to serialize</param>
public void WritePointer(Stream streamWriter, SequencePointer sequencePointer)
{
if (streamWriter == null)
{
throw new ArgumentNullException("streamWriter");
}
if (sequencePointer == null)
{
throw new ArgumentNullException("sequencePointer");
}
_sequenceCount++;
BinaryWriter writer = new BinaryWriter(streamWriter);
writer.Write(sequencePointer.StartingLine);
writer.Write(sequencePointer.IndexOffsets[0]);
writer.Write(sequencePointer.IndexOffsets[1]);
// Writing only first three chars of alphabet name
writer.Write(sequencePointer.AlphabetName.Substring(0, 3).ToCharArray());
}
/// <summary>
/// Gets the element at the specified index.
/// Throws a NotSupportedException when attempting to set the position
/// since VirtualAlignedSequenceList is read-only.
/// </summary>
/// <param name="index">The zero-based index of the sequence in the list.</param>
/// <returns>The aligned sequence at the specified index.</returns>
public T this[int index]
{
get
{
IAlignedSequence virtualAlignedSequence;
if (_sequenceDictionary.ContainsKey(index))
{
virtualAlignedSequence = _sequenceDictionary[index].Target as IAlignedSequence;
if (virtualAlignedSequence != null)
{
return((T)virtualAlignedSequence);
}
_sequenceDictionary.Remove(index);
}
SequencePointer sequencePointer = _sidecarProvider[index];
virtualAlignedSequence = _sequenceParser.ParseAlignedSequence(sequencePointer);
// memory opt : cleanup the weak reference dictionary
if (_sequenceDictionary.Count > 0 && (_sequenceDictionary.Count % MaximumDictionaryLength) == 0)
{
foreach (int key in _sequenceDictionary.Keys.Where(K => _sequenceDictionary[K].IsAlive == false).ToList())
{
_sequenceDictionary.Remove(key);
}
}
_sequenceDictionary.Add(index, new WeakReference(virtualAlignedSequence, false));
return((T)virtualAlignedSequence);
}
set
{
throw new NotSupportedException(Properties.Resource.NotSupportedInVirtualSequence);
}
}
/// <summary>
/// Initializes a new instance of the MBF.IO.FileVirtualQualitativeSequenceProvider
/// class to hold a sequence pointer with a parser.
/// </summary>
/// <param name="parser">A virtual parser object.</param>
/// <param name="pointer">The sequence pointer.</param>
public FileVirtualQualitativeSequenceProvider(IVirtualSequenceParser parser, SequencePointer pointer)
{
if (parser == null)
{
throw new ArgumentNullException("parser");
}
if (pointer == null)
{
throw new ArgumentNullException("pointer");
}
_parser = parser;
_count = (int)(pointer.IndexOffsets[1] - pointer.IndexOffsets[0]);
SequencePointerInstance = pointer;
//set the default DV properties.
_virtualData = new VirtualData <Sequence>
{
BlockSize = FileLoadHelper.DefaultBlockSize,
MaxNumberOfBlocks = FileLoadHelper.DefaultMaxNumberOfBlocks
};
}
/// <summary>
/// Initializes a new instance of the MBF.IO.FileVirtualSequenceProvider
/// class to hold a sequence pointer with a parser.
/// </summary>
/// <param name="parser">A virtual parser object.</param>
/// <param name="pointer">The sequence pointer.</param>
public FileVirtualSequenceProvider(IVirtualSequenceParser parser, SequencePointer pointer)
{
if (parser == null)
{
throw new ArgumentNullException("parser");
}
if (pointer == null)
{
throw new ArgumentNullException("pointer");
}
_parser = parser;
_count = (int)(pointer.IndexOffsets[1] - pointer.IndexOffsets[0]);
SequencePointerInstance = pointer;
_alphabet = Alphabets.All.FirstOrDefault(A => A.Name.Equals(pointer.AlphabetName));
//set the default DV properties.
_virtualData = new VirtualData <byte[]>
{
BlockSize = FileLoadHelper.DefaultBlockSize,
MaxNumberOfBlocks = FileLoadHelper.DefaultMaxNumberOfBlocks
};
}
/// <summary>
/// Writes a specified sequence pointer to the current position in the
/// file stream of the sidecar file associated with this object.
/// </summary>
/// <param name="sequencePointer">
/// The sequence pointer object to be written.
/// </param>
public void WritePointer(SequencePointer sequencePointer)
{
WritePointer(_streamWriter, sequencePointer);
}
