protected void WriteHexByte(StringBuilder dest, HexValueFormatterFlags flags, byte b) { bool lower = (flags & HexValueFormatterFlags.LowerCaseHex) != 0; WriteHexNibble(dest, (b >> 4) & 0x0F, lower); WriteHexNibble(dest, b & 0x0F, lower); }
protected void WriteHexUInt16(StringBuilder dest, HexValueFormatterFlags flags, ushort v) { bool lower = (flags & HexValueFormatterFlags.LowerCaseHex) != 0; WriteHexNibble(dest, (v >> 12) & 0x0F, lower); WriteHexNibble(dest, (v >> 8) & 0x0F, lower); WriteHexNibble(dest, (v >> 4) & 0x0F, lower); WriteHexNibble(dest, v & 0x0F, lower); }
protected int FormatDecimalSByte(StringBuilder dest, HexValueFormatterFlags flags, sbyte?v) { if (v is null) { return(WriteInvalid(dest)); } return(WriteFormattedValue(dest, v.Value.ToString(culture))); }
protected int FormatDecimalInt64(StringBuilder dest, HexValueFormatterFlags flags, long?v) { if (v == null) { return(WriteInvalid(dest)); } return(WriteFormattedValue(dest, v.Value.ToString(culture))); }
protected int FormatHexUInt32(StringBuilder dest, HexValueFormatterFlags flags, uint?v) { Debug.Assert(FormattedLength == 8); if (v is null) { return(WriteInvalid(dest)); } WriteHexUInt32(dest, flags, v.Value); return(0); }
protected int FormatHexUInt64(StringBuilder dest, HexValueFormatterFlags flags, ulong?v) { Debug.Assert(FormattedLength == 16); if (v == null) { return(WriteInvalid(dest)); } WriteHexUInt64(dest, flags, v.Value); return(0); }
protected int FormatDouble(StringBuilder dest, HexValueFormatterFlags flags, double?v) { if (v == null) { return(WriteInvalid(dest)); } var value = v.Value; if (double.IsNaN(value)) { return(WriteFormattedValue(dest, stringNaN)); } if (double.IsPositiveInfinity(value)) { return(WriteFormattedValue(dest, stringPositiveInfinity)); } if (double.IsNegativeInfinity(value)) { return(WriteFormattedValue(dest, stringNegativeInfinity)); } return(WriteFormattedValue(dest, value.ToString(DoubleFormatString, culture))); }
protected int FormatHexInt16(StringBuilder dest, HexValueFormatterFlags flags, short?v) { Debug.Assert(FormattedLength == 5); if (v is null) { return(WriteInvalid(dest)); } var value = v.Value; int spaces; if (value < 0) { dest.Append('-'); value = (short)-value; spaces = 0; } else { dest.Append(' '); spaces = 1; } WriteHexUInt16(dest, flags, (ushort)value); return(spaces); }
protected int FormatHexInt64(StringBuilder dest, HexValueFormatterFlags flags, long?v) { Debug.Assert(FormattedLength == 17); if (v == null) { return(WriteInvalid(dest)); } var value = v.Value; int spaces; if (value < 0) { dest.Append('-'); value = -value; spaces = 0; } else { dest.Append(' '); spaces = 1; } WriteHexUInt64(dest, flags, (ulong)value); return(spaces); }
protected int FormatHexSByte(StringBuilder dest, HexValueFormatterFlags flags, sbyte?v) { Debug.Assert(FormattedLength == 3); if (v == null) { return(WriteInvalid(dest)); } var value = v.Value; int spaces; if (value < 0) { dest.Append('-'); value = (sbyte)-value; spaces = 0; } else { dest.Append(' '); spaces = 1; } WriteHexByte(dest, flags, (byte)value); return(spaces); }
protected int FormatDouble(StringBuilder dest, HexValueFormatterFlags flags, double? v) { if (v == null) return WriteInvalid(dest); var value = v.Value; if (double.IsNaN(value)) return WriteFormattedValue(dest, stringNaN); if (double.IsPositiveInfinity(value)) return WriteFormattedValue(dest, stringPositiveInfinity); if (double.IsNegativeInfinity(value)) return WriteFormattedValue(dest, stringNegativeInfinity); return WriteFormattedValue(dest, value.ToString(DoubleFormatString, culture)); }
protected void WriteHexUInt64(StringBuilder dest, HexValueFormatterFlags flags, ulong v) { WriteHexUInt32(dest, flags, (uint)(v >> 32)); WriteHexUInt32(dest, flags, (uint)v); }
public override int FormatValue(StringBuilder dest, HexBytes hexBytes, long valueIndex, HexValueFormatterFlags flags) => FormatDecimalInt64(dest, flags, hexBytes.TryReadInt64BigEndian(valueIndex));
public override int FormatValue(StringBuilder dest, HexBytes hexBytes, long valueIndex, HexValueFormatterFlags flags) => FormatHexUInt32(dest, flags, hexBytes.TryReadUInt32(valueIndex));
protected int FormatDecimalInt64(StringBuilder dest, HexValueFormatterFlags flags, long? v) { if (v == null) return WriteInvalid(dest); return WriteFormattedValue(dest, v.Value.ToString(culture)); }
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); }
protected int FormatHexUInt64(StringBuilder dest, HexValueFormatterFlags flags, ulong? v) { Debug.Assert(FormattedLength == 16); if (v == null) return WriteInvalid(dest); WriteHexUInt64(dest, flags, v.Value); return 0; }
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) => 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)); }
protected int FormatHexSByte(StringBuilder dest, HexValueFormatterFlags flags, sbyte? v) { Debug.Assert(FormattedLength == 3); if (v == null) return WriteInvalid(dest); var value = v.Value; int spaces; if (value < 0) { dest.Append('-'); value = (sbyte)-value; spaces = 0; } else { dest.Append(' '); spaces = 1; } WriteHexByte(dest, flags, (byte)value); return spaces; }
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) { int b = hexBytes.TryReadByte(valueIndex); if (b < 0) return WriteInvalid(dest); WriteHexByte(dest, flags, (byte)b); return 0; }
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) { 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.TryReadUInt32BigEndian(valueIndex));
public override int FormatValue(StringBuilder dest, HexBytes hexBytes, long valueIndex, HexValueFormatterFlags flags) => FormatDouble(dest, flags, hexBytes.TryReadDouble(valueIndex));
protected int FormatHexInt64(StringBuilder dest, HexValueFormatterFlags flags, long? v) { Debug.Assert(FormattedLength == 17); if (v == null) return WriteInvalid(dest); var value = v.Value; int spaces; if (value < 0) { dest.Append('-'); value = -value; spaces = 0; } else { dest.Append(' '); spaces = 1; } WriteHexUInt64(dest, flags, (ulong)value); return spaces; }