protected void CopyDataToDestination(LogLineIndex[] sourceIndices, string[] lines, int linesRead) { // We allow users to quickly cancel read requests, for example because their // timeout was reached. When that's the case, then it's possible that we're already // trying to fulfill their request. If we were to still copy the data to the destination // buffer AFTER cancellation then we could get all kinds of weird race conditions and // most of all, break the user's expectation that the buffer must not be modified, // when the GetColumn / GetEntries call has returned! // // Therefore we sync the copy to the destination with the cancellation itself, so that // we can make sure that the above doesn't happen. lock (this) { if (_destination == null) { Log.Debug("Read request cancelled in the mean time, skipping copy to destination buffer"); return; } _destination.CopyFrom(Core.Columns.RawContent, _destinationIndex, lines, 0, linesRead); if (_destination.Contains(Core.Columns.Index)) { _destination.CopyFrom(Core.Columns.Index, _destinationIndex, sourceIndices, 0, linesRead); } } }
/// <inheritdoc /> public void CopyFrom <T>(IColumnDescriptor <T> column, int destinationIndex, IReadOnlyList <T> source, int sourceIndex, int length) { if (!_columns.Contains(column)) { throw new NoSuchColumnException(column); } _inner.CopyFrom(column, destinationIndex, source, sourceIndex, length); }
/// <inheritdoc /> public override void GetEntries(IReadOnlyList <LogLineIndex> sourceIndices, ILogBuffer destination, int destinationIndex, LogSourceQueryOptions queryOptions) { foreach (var column in destination.Columns) { destination.CopyFrom(column, destinationIndex, this, sourceIndices, queryOptions); } }
public void GetEntries(IReadOnlyList <LogLineIndex> sourceIndices, ILogBuffer destination, int destinationIndex, LogSourceQueryOptions queryOptions) { var source = _source; if (source == null) { destination.FillDefault(destinationIndex, sourceIndices.Count); return; } source.GetEntries(sourceIndices, destination.Except(MaxAdornedColumns), destinationIndex, queryOptions); var augmentedColumns = FindAugmentedColumns(destination); if (augmentedColumns.Count == 0) { return; } if (destinationIndex != 0) { throw new NotImplementedException(); } foreach (var column in augmentedColumns) { destination.CopyFrom(column, this, sourceIndices, queryOptions); } }
public bool TryRead(LogLineIndex sourceStartIndex, int count, ILogBuffer destination, int destinationIndex, bool requiresValidityCheck) { ++_numReads; _lastAccessTime = DateTime.UtcNow; var pageSourceIndex = sourceStartIndex - _section.Index; var range = new Int32Range(pageSourceIndex, count); foreach (var column in _buffer.Columns) { if (destination.Contains(column)) { destination.CopyFrom(column, destinationIndex, _buffer, range); } } if (requiresValidityCheck) { if (_buffer.ContainsAnyDefault(Columns.Index, range)) { return(false); } } return(true); }
/// <inheritdoc /> public override void GetEntries(IReadOnlyList <LogLineIndex> sourceIndices, ILogBuffer destination, int destinationIndex, LogSourceQueryOptions queryOptions) { // TODO: This can probably be optimized (why are we translating indices each time for every column?! foreach (var column in destination.Columns) { destination.CopyFrom(column, destinationIndex, this, sourceIndices, queryOptions); } }
/// <summary> /// Copies the given *non-contiguous* segment of data from the given log file into this buffer in a contiguous block. /// </summary> /// <remarks> /// This buffer must be large enough already to accomodate the data. /// </remarks> /// <param name="that"></param> /// <param name="column">The column to copy the data from the log file to this buffer</param> /// <param name="destinationIndex">The first index in this buffer to which the data from the given <paramref name="source" /> is copied</param> /// <param name="source">The log file from which data should be copied from</param> /// <param name="sourceIndices">The non-contiguous section of the log file from which to copy from (e.g. from index 5, 10 entries)</param> public static void CopyFrom(this ILogBuffer that, IColumnDescriptor column, int destinationIndex, ILogSource source, IReadOnlyList <LogLineIndex> sourceIndices) { that.CopyFrom(column, destinationIndex, source, sourceIndices, LogSourceQueryOptions.Default); }
/// <inheritdoc /> public void GetEntries(IReadOnlyList <LogLineIndex> sourceIndices, ILogBuffer destination, int destinationIndex, LogSourceQueryOptions queryOptions) { lock (_syncRoot) { foreach (var column in destination.Columns) { destination.CopyFrom(column, destinationIndex, _logBuffer, new Int32View(sourceIndices)); } } }
/// <inheritdoc /> public void GetEntries(LogSourceSection sourceSection, ILogBuffer destination, int destinationIndex, LogSourceQueryOptions queryOptions) { lock (_syncRoot) { foreach (var column in destination.Columns) { destination.CopyFrom(column, destinationIndex, _logBuffer, new Int32View(sourceSection)); } } }
/// <summary> /// /// </summary> /// <param name="sourceIndices"></param> /// <param name="destination"></param> /// <param name="destinationIndex"></param> public void CopyTo(IReadOnlyList <int> sourceIndices, ILogBuffer destination, int destinationIndex) { foreach (var column in destination.Columns) { if (_dataByColumn.TryGetValue(column, out var data)) { destination.CopyFrom(column, destinationIndex, this, sourceIndices); } else { destination.FillDefault(column, destinationIndex, sourceIndices.Count); } } }
/// <inheritdoc /> public void GetEntries(IReadOnlyList <LogLineIndex> sourceIndices, ILogBuffer destination, int destinationIndex, LogSourceQueryOptions queryOptions) { var source = _source; if (source != null) { var columnsToCopy = new IColumnDescriptor[] { Core.Columns.Index, Core.Columns.RawContent }; var tmp = new LogBufferArray(sourceIndices.Count, columnsToCopy); source.GetEntries(sourceIndices, tmp, 0, queryOptions); foreach (var column in columnsToCopy) { if (destination.Contains(column)) { destination.CopyFrom(column, destinationIndex, tmp, new Int32Range(0, sourceIndices.Count)); } } for (var i = 0; i < sourceIndices.Count; ++i) { var parsedLogEntry = _parser.Parse(tmp[i]); if (parsedLogEntry != null) { destination[destinationIndex + i].CopyFrom(parsedLogEntry); } else { destination[destinationIndex + i].CopyFrom(_nothingParsed); } } } else { destination.FillDefault(destinationIndex, sourceIndices.Count); } }
/// <inheritdoc /> public override void GetEntries(IReadOnlyList <LogLineIndex> sourceIndices, ILogBuffer destination, int destinationIndex, LogSourceQueryOptions queryOptions) { if (IsDisposed) { destination.FillDefault(destinationIndex, sourceIndices.Count); return; } var remainingColumns = new List <IColumnDescriptor>(); bool partiallyRetrieved = false; foreach (var column in destination.Columns) { if (_specialColumns.Contains(column)) { destination.CopyFrom(column, destinationIndex, this, sourceIndices, queryOptions); partiallyRetrieved = true; } else { remainingColumns.Add(column); } } if (remainingColumns.Count > 0) { if (partiallyRetrieved) { var view = new LogBufferView(destination, remainingColumns); _source.GetEntries(sourceIndices, view, destinationIndex, queryOptions); } else { _source.GetEntries(sourceIndices, destination, destinationIndex, queryOptions); } } }
/// <summary> /// Copies data from the given array into this buffer. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="section"></param> /// <param name="column">The column to copy data to</param> /// <param name="source">The source from which to copy data from</param> public static void CopyFrom <T>(this ILogBuffer section, IColumnDescriptor <T> column, T[] source) { section.CopyFrom(column, 0, source, 0, source.Length); }