public HexBufferLineImpl(HexBufferLineFormatter hexBufferLineFormatter, HexPosition lineNumber, ReadOnlyCollection<HexColumnType> columnOrder, HexBufferSpan bufferSpan, HexBytes hexBytes, string text, bool isOffsetColumnPresent, bool isValuesColumnPresent, bool isAsciiColumnPresent, HexPosition logicalOffset, HexCellCollection valueCells, HexCellCollection asciiCells, VST.Span offsetSpan, VST.Span fullValuesSpan, VST.Span visibleValuesSpan, VST.Span fullAsciiSpan, VST.Span visibleAsciiSpan) {
if (hexBufferLineFormatter == null)
throw new ArgumentNullException(nameof(hexBufferLineFormatter));
if (columnOrder == null)
throw new ArgumentNullException(nameof(columnOrder));
if (bufferSpan.IsDefault)
throw new ArgumentException();
if (hexBytes.IsDefault)
throw new ArgumentException();
if (text == null)
throw new ArgumentNullException(nameof(text));
if (valueCells.IsDefault)
throw new ArgumentNullException(nameof(valueCells));
if (asciiCells.IsDefault)
throw new ArgumentNullException(nameof(asciiCells));
LineProvider = hexBufferLineFormatter;
LineNumber = lineNumber;
ColumnOrder = columnOrder;
BufferSpan = bufferSpan;
HexBytes = hexBytes;
Text = text;
IsOffsetColumnPresent = isOffsetColumnPresent;
IsValuesColumnPresent = isValuesColumnPresent;
IsAsciiColumnPresent = isAsciiColumnPresent;
LogicalOffset = logicalOffset;
ValueCells = valueCells;
AsciiCells = asciiCells;
this.offsetSpan = offsetSpan;
this.fullValuesSpan = fullValuesSpan;
this.visibleValuesSpan = visibleValuesSpan;
this.fullAsciiSpan = fullAsciiSpan;
this.visibleAsciiSpan = visibleAsciiSpan;
}
HexCell[] WriteAscii(HexBytes hexBytes, HexSpan visibleBytesSpan, out VST.Span fullSpan, out VST.Span visibleSpan) {
Debug.Assert(showAscii);
cellList.Clear();
int fullStart = CurrentTextIndex;
int? visStart = null;
int? visEnd = null;
var pos = visibleBytesSpan.Start;
int cellPos = 0;
for (ulong i = 0; i < bytesPerLine; i++, pos++) {
int groupIndex = (cellPos / groupSizeInBytes) & 1;
HexBufferSpan bufferSpan;
int cellStart = CurrentTextIndex;
if (visibleBytesSpan.Contains(pos)) {
if (visStart == null)
visStart = CurrentTextIndex;
long index = (long)(pos - visibleBytesSpan.Start).ToUInt64();
int b = hexBytes.TryReadByte(index);
if (b < 0)
stringBuilder.Append('?');
else if (b < 0x20 || b > 0x7E)
stringBuilder.Append('.');
else
stringBuilder.Append((char)b);
bufferSpan = new HexBufferSpan(buffer, new HexSpan(pos, 1));
}
else {
if (visStart != null && visEnd == null)
visEnd = CurrentTextIndex;
stringBuilder.Append(' ');
bufferSpan = default(HexBufferSpan);
}
var cellSpan = VST.Span.FromBounds(cellStart, CurrentTextIndex);
var separatorSpan = new VST.Span(cellSpan.End, 0);
cellList.Add(new HexCell((int)i, groupIndex, bufferSpan, cellSpan, cellSpan, separatorSpan, cellSpan));
cellPos++;
}
if ((ulong)fullStart + bytesPerLine != (ulong)CurrentTextIndex)
throw new InvalidOperationException();
if (visStart != null && visEnd == null)
visEnd = CurrentTextIndex;
visibleSpan = visStart == null ? default(VST.Span) : VST.Span.FromBounds(visStart.Value, visEnd.Value);
fullSpan = VST.Span.FromBounds(fullStart, CurrentTextIndex);
if (AsciiSpan != fullSpan)
throw new InvalidOperationException();
return cellList.ToArray();
}
HexCell[] WriteValues(HexBytes hexBytes, HexSpan visibleBytesSpan, out VST.Span fullSpan, out VST.Span visibleSpan) {
Debug.Assert(showValues);
cellList.Clear();
int fullStart = CurrentTextIndex;
ulong cellCount = bytesPerLine / (ulong)valueFormatter.ByteCount;
var flags = valuesLowerCaseHex ? HexValueFormatterFlags.LowerCaseHex : HexValueFormatterFlags.None;
var pos = visibleBytesSpan.Start;
var end = visibleBytesSpan.Start + bytesPerLine;
int? visStart = null;
int? visEnd = null;
int cellPos = 0;
for (ulong i = 0; i < cellCount; i++) {
if (i != 0)
stringBuilder.Append(' ');
int groupIndex = (cellPos / groupSizeInBytes) & 1;
HexBufferSpan bufferSpan;
int cellStart = CurrentTextIndex;
int spaces;
if (visibleBytesSpan.Contains(pos)) {
if (visStart == null)
visStart = CurrentTextIndex;
long valueIndex = (long)(pos - visibleBytesSpan.Start).ToUInt64();
spaces = valueFormatter.FormatValue(stringBuilder, hexBytes, valueIndex, flags);
var endPos = HexPosition.Min(endPosition, pos + (ulong)valueFormatter.ByteCount);
bufferSpan = new HexBufferSpan(new HexBufferPoint(buffer, pos), new HexBufferPoint(buffer, endPos));
}
else {
if (visStart != null && visEnd == null)
visEnd = CurrentTextIndex;
stringBuilder.Append(' ', valueFormatter.FormattedLength);
spaces = valueFormatter.FormattedLength;
bufferSpan = default(HexBufferSpan);
}
if (cellStart + valueFormatter.FormattedLength != CurrentTextIndex)
throw new InvalidOperationException();
var textSpan = VST.Span.FromBounds(cellStart + spaces, CurrentTextIndex);
var cellSpan = VST.Span.FromBounds(cellStart, CurrentTextIndex);
VST.Span separatorSpan;
if (i + 1 < cellCount)
separatorSpan = new VST.Span(CurrentTextIndex, 1);
else
separatorSpan = new VST.Span(CurrentTextIndex, 0);
var cellFullSpan = VST.Span.FromBounds(cellStart, separatorSpan.End);
cellList.Add(new HexCell((int)i, groupIndex, bufferSpan, textSpan, cellSpan, separatorSpan, cellFullSpan));
pos += (ulong)valueFormatter.ByteCount;
cellPos += valueFormatter.ByteCount;
}
if (pos != end)
throw new InvalidOperationException();
if (visStart != null && visEnd == null)
visEnd = CurrentTextIndex;
visibleSpan = visStart == null ? default(VST.Span) : VST.Span.FromBounds(visStart.Value, visEnd.Value);
fullSpan = VST.Span.FromBounds(fullStart, CurrentTextIndex);
if (ValuesSpan != fullSpan)
throw new InvalidOperationException();
return cellList.ToArray();
}
public override int FormatValue(StringBuilder dest, HexBytes hexBytes, long valueIndex, HexValueFormatterFlags flags) {
int b = hexBytes.TryReadByte(valueIndex);
if (b < 0)
return WriteInvalid(dest);
for (int i = 0; i < 8; i++, b <<= 1)
dest.Append((b & 0x80) != 0 ? '1' : '0');
return 0;
}
public override int FormatValue(StringBuilder dest, HexBytes hexBytes, long valueIndex, HexValueFormatterFlags flags) => FormatDouble(dest, flags, hexBytes.TryReadDoubleBigEndian(valueIndex));
public override int FormatValue(StringBuilder dest, HexBytes hexBytes, long valueIndex, HexValueFormatterFlags flags) => FormatDecimalInt64(dest, flags, hexBytes.TryReadInt64(valueIndex));
/// <summary> /// Formats the value and returns the number of spaces that were inserted before the number /// so exactly <see cref="FormattedLength"/> characters were written to <paramref name="dest"/> /// </summary> /// <param name="dest">Destination string builder</param> /// <param name="hexBytes">Bytes</param> /// <param name="valueIndex">Index of value in <paramref name="hexBytes"/></param> /// <param name="flags">Flags</param> /// <returns></returns> public abstract int FormatValue(StringBuilder dest, HexBytes hexBytes, long valueIndex, HexValueFormatterFlags flags);
public override int FormatValue(StringBuilder dest, HexBytes hexBytes, long valueIndex, HexValueFormatterFlags flags) {
int b = hexBytes.TryReadByte(valueIndex);
if (b < 0)
return WriteInvalid(dest);
return WriteFormattedValue(dest, b.ToString(culture));
}
public override int FormatValue(StringBuilder dest, HexBytes hexBytes, long valueIndex, HexValueFormatterFlags flags) => FormatHexUInt32(dest, flags, hexBytes.TryReadUInt32(valueIndex));
public override int FormatValue(StringBuilder dest, HexBytes hexBytes, long valueIndex, HexValueFormatterFlags flags) {
int b = hexBytes.TryReadByte(valueIndex);
if (b < 0)
return WriteInvalid(dest);
WriteHexByte(dest, flags, (byte)b);
return 0;
}