// ReSharper restore LocalizableElement private void WriteCache(ILoadMonitor loader) { using (FileSaver fs = new FileSaver(CachePath, loader.StreamManager)) { using (var stream = loader.StreamManager.CreateStream(fs.SafeName, FileMode.Create, true)) { PrimitiveArrays.WriteOneValue(stream, FORMAT_VERSION_CACHE); PrimitiveArrays.WriteOneValue(stream, _sourceFiles.Count); foreach (var file in _sourceFiles) { byte[] fileNameBytes = Encoding.UTF8.GetBytes(file); PrimitiveArrays.WriteOneValue(stream, fileNameBytes.Length); PrimitiveArrays.Write(stream, fileNameBytes); } PrimitiveArrays.WriteOneValue(stream, _libraryEntries.Length); foreach (var elibSpectrumInfo in _libraryEntries) { elibSpectrumInfo.Write(stream); } loader.StreamManager.Finish(stream); fs.Commit(); loader.StreamManager.SetCache(FilePath, CachePath); } } }
private static void WriteString(Stream stream, string str) { var bytes = Encoding.UTF8.GetBytes(str); PrimitiveArrays.WriteOneValue(stream, bytes.Length); stream.Write(bytes, 0, bytes.Length); }
public void Write(Stream stream) { var memoryStream = new MemoryStream(); ToLibraryKeyProto().WriteTo(memoryStream); PrimitiveArrays.WriteOneValue(stream, (int)memoryStream.Length); memoryStream.Seek(0, SeekOrigin.Begin); memoryStream.CopyTo(stream); }
private void WriteData(Block block, Stream fileStream) { // Create back link to previous spilled block. var lastFilePosition = _filePosition; _filePosition = (int)fileStream.Position; PrimitiveArrays.WriteOneValue(fileStream, lastFilePosition); PrimitiveArrays.Write(fileStream, block._data); }
public void Write(Stream stream) { Key.Write(stream); PrimitiveArrays.WriteOneValue(stream, Id); PrimitiveArrays.WriteOneValue(stream, PeakArea); RetentionTimesByFileId.Write(stream); PrimitiveArrays.WriteOneValue(stream, TransitionAreas.Count); PrimitiveArrays.Write(stream, TransitionAreas.Select(mi => mi.Mz).ToArray()); PrimitiveArrays.Write(stream, TransitionAreas.Select(mi => mi.Intensity).ToArray()); }
public void Write(Stream stream) { PrimitiveArrays.WriteOneValue(stream, Id); WriteString(stream, FilePath); WriteString(stream, SampleName); WriteString(stream, AcquiredTime); WriteString(stream, ModifiedTime); WriteString(stream, InstrumentIonizationType); WriteString(stream, InstrumentAnalyzer); WriteString(stream, InstrumentDetector); }
private void WriteEntries() { _locationEntries = _stream.Position; PrimitiveArrays.WriteOneValue(_stream, _library._libraryEntries.Length); foreach (var entry in _library._libraryEntries) { entry.Write(_stream); } PrimitiveArrays.WriteOneValue(_stream, _library._libraryIrts.Length); foreach (var entry in _library._libraryIrts) { entry.Write(_stream); } }
private void WriteHeader() { _locationHeader = _stream.Position; PrimitiveArrays.WriteOneValue(_stream, CURRENT_VERSION); PrimitiveArrays.WriteOneValue(_stream, _locationEntries); WriteString(_stream, _library.PanoramaServer); PrimitiveArrays.WriteOneValue(_stream, _library.LibraryRevision); WriteString(_stream, _library.SchemaVersion); PrimitiveArrays.WriteOneValue(_stream, _library._librarySourceFiles.Length); foreach (var sampleFile in _library._librarySourceFiles) { sampleFile.Write(_stream); } PrimitiveArrays.WriteOneValue(_stream, _locationEntries); PrimitiveArrays.WriteOneValue(_stream, _locationHeader); }
public void Write(Stream stream) { PrimitiveArrays.WriteOneValue(stream, PeptideModSeq.Length); PrimitiveArrays.Write(stream, Encoding.UTF8.GetBytes(PeptideModSeq)); PrimitiveArrays.WriteOneValue(stream, Key.Charge); PrimitiveArrays.WriteOneValue(stream, BestFileId); PrimitiveArrays.WriteOneValue(stream, FileDatas.Count); foreach (var peakBoundEntry in FileDatas) { PrimitiveArrays.WriteOneValue(stream, peakBoundEntry.Key); PrimitiveArrays.WriteOneValue(stream, peakBoundEntry.Value.PeakBounds.StartTime); PrimitiveArrays.WriteOneValue(stream, peakBoundEntry.Value.PeakBounds.EndTime); if (peakBoundEntry.Value.ApexTime.HasValue) { PrimitiveArrays.WriteOneValue <byte>(stream, 1); PrimitiveArrays.WriteOneValue(stream, peakBoundEntry.Value.ApexTime.Value); } else { PrimitiveArrays.WriteOneValue <byte>(stream, 0); } } }
// ReSharper restore UnusedMember.Local private bool CreateCache(ILoadMonitor loader, IProgressStatus status, int percent) { var sm = loader.StreamManager; BufferedStream stream = new BufferedStream(CreateStream(loader), 32 * 1024); int version = 1; string id = string.Empty, revision = string.Empty; int size = ReadSize(stream); int i; if (size == 0) { version = 2; size = ReadSize(stream); const int countLibHeader = 256 - 8; byte[] libHeader = new byte[countLibHeader]; if (stream.Read(libHeader, 0, libHeader.Length) != libHeader.Length) { throw new InvalidDataException(Resources.XHunterLibrary_CreateCache_Data_truncation_in_library_header_File_may_be_corrupted); } for (i = 0; i < libHeader.Length; i++) { if (libHeader[i] == 0) { break; } } string header = Encoding.UTF8.GetString(libHeader, 0, i); Match match = REGEX_HEADER.Match(header); if (match.Success) { version = int.Parse(match.Groups[1].Value); id = match.Groups[2].Value; revision = match.Groups[3].Value; } } var setLibKeys = new HashSet <LibKey>(size); var libraryEntries = new List <XHunterSpectrumInfo>(size); const int countHeader = ((int)SpectrumHeaders2.count) * sizeof(int); byte[] specHeader = new byte[1024]; byte[] specSequence = new byte[1024]; i = 0; while (stream.Read(specHeader, 0, countHeader) == countHeader) { int percentComplete = (i++ *percent / size); if (status.PercentComplete != percentComplete) { // Check for cancellation after each integer change in percent loaded. if (loader.IsCanceled) { loader.UpdateProgress(status.Cancel()); return(false); } // If not cancelled, update progress. loader.UpdateProgress(status = status.ChangePercentComplete(percentComplete)); } int charge = (version == 1 ? GetInt32(specHeader, ((int)SpectrumHeaders1.charge)) : GetInt32(specHeader, ((int)SpectrumHeaders2.charge))); float i2 = (version == 1 ? GetSingle(specHeader, ((int)SpectrumHeaders1.i2)) : GetSingle(specHeader, ((int)SpectrumHeaders2.i2))); int seqLength = (version == 1 ? GetInt32(specHeader, ((int)SpectrumHeaders1.seq_len)) : GetInt32(specHeader, ((int)SpectrumHeaders2.seq_len))); float expect = (version == 1 ? 0.001f : GetSingle(specHeader, (int)SpectrumHeaders2.expect)); // Read sequence information ReadComplete(stream, specSequence, seqLength); specSequence[seqLength] = 0; short numPeaks = (short)ReadSize(stream); // Save spectrum location long location = stream.Position; // Read over spectrum int countPeaks = (sizeof(byte) + sizeof(float)) * numPeaks; stream.Seek(countPeaks, SeekOrigin.Current); // Skip spectrum // Read modifications int numMods = ReadSize(stream); string modifiedSequence = Encoding.UTF8.GetString(specSequence, 0, seqLength); if (numMods > 0) { StringBuilder sb = new StringBuilder(); ReadComplete(stream, specHeader, (4 + sizeof(double)) * numMods); int iLast = 0; double modTotal = 0; for (int j = 0; j < numMods; j++) { int iPos = GetInt32(specHeader, j * 3); double mod = BitConverter.ToDouble(specHeader, (j * 3 + 1) * 4); // X! Hunter allows multiple modifications on the same // residue. So, they need to be totaled, and assigned to a // single residue to allow them to match Skyline modification // settings. if (iPos > iLast) { if (modTotal != 0) { sb.Append(SequenceMassCalc.GetModDiffDescription(modTotal)); } sb.Append(Encoding.UTF8.GetString(specSequence, iLast, iPos - iLast)); modTotal = 0; } modTotal += mod; iLast = iPos; } if (modTotal != 0) { sb.Append(SequenceMassCalc.GetModDiffDescription(modTotal)); } sb.Append(Encoding.UTF8.GetString(specSequence, iLast, seqLength - iLast)); modifiedSequence = sb.ToString(); } // Skip over homologs (list of protein IDs and start positions from a FASTA // file used to generate the library) int numHomologs = ReadSize(stream); for (int j = 0; j < numHomologs; j++) { stream.Seek(ReadSize(stream) + 4, SeekOrigin.Current); } // These libraries should not have duplicates, but just in case. // Apparently, GPM libraries do contain redundancies, as we found // when a revision lost this test. var key = new LibKey(modifiedSequence, charge); if (setLibKeys.Add(key)) { libraryEntries.Add(new XHunterSpectrumInfo(key, i2, expect, numPeaks, location)); } } libraryEntries = FilterInvalidLibraryEntries(ref status, libraryEntries); using (FileSaver fs = new FileSaver(CachePath, sm)) using (Stream outStream = sm.CreateStream(fs.SafeName, FileMode.Create, true)) { foreach (var info in libraryEntries) { info.Key.Write(outStream); PrimitiveArrays.WriteOneValue(outStream, info.Location); PrimitiveArrays.WriteOneValue(outStream, info.ProcessedIntensity); PrimitiveArrays.WriteOneValue(outStream, info.NumPeaks); PrimitiveArrays.WriteOneValue(outStream, info.Expect); } byte[] revisionBytes = Encoding.UTF8.GetBytes(revision); outStream.Write(revisionBytes, 0, revisionBytes.Length); byte[] idBytes = Encoding.UTF8.GetBytes(id); outStream.Write(idBytes, 0, idBytes.Length); outStream.Write(BitConverter.GetBytes(revisionBytes.Length), 0, sizeof(int)); outStream.Write(BitConverter.GetBytes(idBytes.Length), 0, sizeof(int)); outStream.Write(BitConverter.GetBytes(FORMAT_VERSION_CACHE), 0, sizeof(int)); outStream.Write(BitConverter.GetBytes(libraryEntries.Count), 0, sizeof(int)); outStream.Write(BitConverter.GetBytes((long)0), 0, sizeof(long)); sm.Finish(outStream); fs.Commit(); sm.SetCache(FilePath, CachePath); } loader.UpdateProgress(status.Complete()); return(true); }
public void Write(Stream stream) { WriteString(stream, Sequence.ToSerializableString()); PrimitiveArrays.WriteOneValue(stream, (int)TimeSource); PrimitiveArrays.WriteOneValue(stream, Irt); }