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