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