internal static void WriteValue(uint value, JsonSerializerHandler handler)
{
if (value == uint.MaxValue)
{
handler.WriteString("4294967295");
return;
}
var ptr = 35;
char[] buffer = new char[36];
var copy = value;
do
{
byte ix = (byte)(copy % 100);
copy /= 100;
var chars = SpecialTypeNormal.DigitPairs[ix];
buffer[ptr--] = chars.Second;
buffer[ptr--] = chars.First;
} while (copy != 0);
if (buffer[ptr + 1] == '0')
{
ptr++;
}
handler.WriteChars(buffer, ptr + 1, 35 - ptr);
}
internal static void WriteValue(int value, JsonSerializerHandler handler)
{
// Gotta special case this, we can't negate it
if (value == int.MinValue)
{
handler.WriteString("-2147483648");
return;
}
if (value == int.MaxValue)
{
handler.WriteString("2147483647");
return;
}
var ptr = 35;
char[] buffer = new char[36];
uint copy;
if (value < 0)
{
handler.WriteChar('-');
copy = (uint)(-value);
}
else
{
copy = (uint)value;
}
do
{
byte ix = (byte)(copy % 100);
copy /= 100;
var chars = SpecialTypeNormal.DigitPairs[ix];
buffer[ptr--] = chars.Second;
buffer[ptr--] = chars.First;
} while (copy != 0);
if (buffer[ptr + 1] == '0')
{
ptr++;
}
handler.WriteChars(buffer, ptr + 1, 35 - ptr);
}
internal static void WriteValue(long value, JsonSerializerHandler handler)
{
if (value == long.MinValue)
{
handler.WriteString("-9223372036854775808");
return;
}
char[] buffer = new char[36];
var ptr = 35;
ulong copy;
if (value < 0)
{
handler.WriteChar('-');
copy = (ulong)(-value);
}
else
{
copy = (ulong)value;
}
do
{
byte ix = (byte)(copy % 100);
copy /= 100;
var chars = SpecialTypeNormal.DigitPairs[ix];
buffer[ptr--] = chars.Second;
buffer[ptr--] = chars.First;
} while (copy != 0);
if (buffer[ptr + 1] == '0')
{
ptr++;
}
handler.WriteChars(buffer, ptr + 1, 35 - ptr);
}
internal static void WriteValue(Guid value, JsonSerializerHandler handler)
{
handler.WriteString("\"");
char[] buffer = new char[36];
// 1314FAD4-7505-439D-ABD2-DBD89242928C
// 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
// 8 4 4 4 12,36 char,64byte
// guid -> int short short 8byte => 8byte 4byte 4byte 8byte
// Guid is guaranteed to be a 36 character string
// get all the dashes in place
buffer[8] = '-';
buffer[13] = '-';
buffer[18] = '-';
buffer[23] = '-';
// Bytes are in a different order than you might expect
// For: 35 91 8b c9 - 19 6d - 40 ea - 97 79 - 88 9d 79 b7 53 f0
// Get: C9 8B 91 35 6D 19 EA 40 97 79 88 9D 79 B7 53 F0
// Ix: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
//
// And we have to account for dashes
//
// So the map is like so:
// bytes[0] -> chars[3] -> buffer[ 6, 7]
// bytes[1] -> chars[2] -> buffer[ 4, 5]
// bytes[2] -> chars[1] -> buffer[ 2, 3]
// bytes[3] -> chars[0] -> buffer[ 0, 1]
// bytes[4] -> chars[5] -> buffer[11,12]
// bytes[5] -> chars[4] -> buffer[ 9,10]
// bytes[6] -> chars[7] -> buffer[16,17]
// bytes[7] -> chars[6] -> buffer[14,15]
// bytes[8] -> chars[8] -> buffer[19,20]
// bytes[9] -> chars[9] -> buffer[21,22]
// bytes[10] -> chars[10] -> buffer[24,25]
// bytes[11] -> chars[11] -> buffer[26,27]
// bytes[12] -> chars[12] -> buffer[28,29]
// bytes[13] -> chars[13] -> buffer[30,31]
// bytes[14] -> chars[14] -> buffer[32,33]
// bytes[15] -> chars[15] -> buffer[34,35]
var visibleMembers = new GuidStruct(value);
// bytes[0]
var b = visibleMembers.B00 * 2;
buffer[6] = WriteGuidLookup[b];
buffer[7] = WriteGuidLookup[b + 1];
// bytes[1]
b = visibleMembers.B01 * 2;
buffer[4] = WriteGuidLookup[b];
buffer[5] = WriteGuidLookup[b + 1];
// bytes[2]
b = visibleMembers.B02 * 2;
buffer[2] = WriteGuidLookup[b];
buffer[3] = WriteGuidLookup[b + 1];
// bytes[3]
b = visibleMembers.B03 * 2;
buffer[0] = WriteGuidLookup[b];
buffer[1] = WriteGuidLookup[b + 1];
// bytes[4]
b = visibleMembers.B04 * 2;
buffer[11] = WriteGuidLookup[b];
buffer[12] = WriteGuidLookup[b + 1];
// bytes[5]
b = visibleMembers.B05 * 2;
buffer[9] = WriteGuidLookup[b];
buffer[10] = WriteGuidLookup[b + 1];
// bytes[6]
b = visibleMembers.B06 * 2;
buffer[16] = WriteGuidLookup[b];
buffer[17] = WriteGuidLookup[b + 1];
// bytes[7]
b = visibleMembers.B07 * 2;
buffer[14] = WriteGuidLookup[b];
buffer[15] = WriteGuidLookup[b + 1];
// bytes[8]
b = visibleMembers.B08 * 2;
buffer[19] = WriteGuidLookup[b];
buffer[20] = WriteGuidLookup[b + 1];
// bytes[9]
b = visibleMembers.B09 * 2;
buffer[21] = WriteGuidLookup[b];
buffer[22] = WriteGuidLookup[b + 1];
// bytes[10]
b = visibleMembers.B10 * 2;
buffer[24] = WriteGuidLookup[b];
buffer[25] = WriteGuidLookup[b + 1];
// bytes[11]
b = visibleMembers.B11 * 2;
buffer[26] = WriteGuidLookup[b];
buffer[27] = WriteGuidLookup[b + 1];
// bytes[12]
b = visibleMembers.B12 * 2;
buffer[28] = WriteGuidLookup[b];
buffer[29] = WriteGuidLookup[b + 1];
// bytes[13]
b = visibleMembers.B13 * 2;
buffer[30] = WriteGuidLookup[b];
buffer[31] = WriteGuidLookup[b + 1];
// bytes[14]
b = visibleMembers.B14 * 2;
buffer[32] = WriteGuidLookup[b];
buffer[33] = WriteGuidLookup[b + 1];
// bytes[15]
b = visibleMembers.B15 * 2;
buffer[34] = WriteGuidLookup[b];
buffer[35] = WriteGuidLookup[b + 1];
handler.WriteChars(buffer, 0, 36);
handler.WriteString("\"");
}
internal static void WriteValue(TimeSpan value, JsonSerializerHandler handler)
{
if (handler.Option.TimespanFormat == TimespanFormatEnum.ISO8601)
{
// can't negate this, have to handle it manually
if (value.Ticks == long.MinValue)
{
handler.WriteString("\"-P10675199DT2H48M5.4775808S\"");
return;
}
char[] buffer = new char[36];
handler.WriteChar('"');
if (value.Ticks < 0)
{
handler.WriteChar('-');
value = value.Negate();
}
handler.WriteChar('P');
var days = value.Days;
var hours = value.Hours;
var minutes = value.Minutes;
var seconds = value.Seconds;
// days
if (days > 0)
{
_CustomWriteIntUnrolledSigned(handler, days, buffer);
handler.WriteChar('D');
}
// time separator
handler.WriteChar('T');
// hours
if (hours > 0)
{
_CustomWriteIntUnrolledSigned(handler, hours, buffer);
handler.WriteChar('H');
}
// minutes
if (minutes > 0)
{
_CustomWriteIntUnrolledSigned(handler, minutes, buffer);
handler.WriteChar('M');
}
// seconds
_CustomWriteIntUnrolledSigned(handler, seconds, buffer);
// fractional part
{
var endCount = 0;
var remainingTicks = (value - new TimeSpan(days, hours, minutes, seconds, 0)).Ticks;
if (remainingTicks > 0)
{
int fracEnd;
buffer[0] = '.';
var fracPart = remainingTicks % 100;
remainingTicks /= 100;
TwoDigits digits;
if (fracPart > 0)
{
digits = DigitPairs[fracPart];
buffer[7] = digits.Second;
buffer[6] = digits.First;
fracEnd = 8;
}
else
{
fracEnd = 6;
}
fracPart = remainingTicks % 100;
remainingTicks /= 100;
if (fracPart > 0)
{
digits = DigitPairs[fracPart];
buffer[5] = digits.Second;
buffer[4] = digits.First;
}
else
{
if (fracEnd == 6)
{
fracEnd = 4;
}
else
{
buffer[5] = '0';
buffer[4] = '0';
}
}
fracPart = remainingTicks % 100;
remainingTicks /= 100;
if (fracPart > 0)
{
digits = DigitPairs[fracPart];
buffer[3] = digits.Second;
buffer[2] = digits.First;
}
else
{
if (fracEnd == 4)
{
fracEnd = 2;
}
else
{
buffer[3] = '0';
buffer[2] = '0';
}
}
fracPart = remainingTicks;
buffer[1] = (char)('0' + fracPart);
endCount = fracEnd;
}
handler.WriteChars(buffer, 0, endCount);
}
handler.WriteString("S\"");
}
else
{
if (value.Ticks == long.MinValue)
{
handler.WriteString("\"-10675199.02:48:05.4775808\"");
return;
}
char[] buffer = new char[36];
handler.WriteChar('"');
if (value.Ticks < 0)
{
handler.WriteChar('-');
value = value.Negate();
}
var days = value.Days;
var hours = value.Hours;
var minutes = value.Minutes;
var secs = value.Seconds;
TwoDigits digits;
// days
{
if (days != 0)
{
PrimitiveNormal.WriteValue(days, handler);
handler.WriteChar('.');
}
}
// hours
{
digits = DigitPairs[hours];
buffer[0] = digits.First;
buffer[1] = digits.Second;
}
buffer[2] = ':';
// minutes
{
digits = DigitPairs[minutes];
buffer[3] = digits.First;
buffer[4] = digits.Second;
}
buffer[5] = ':';
// seconds
{
digits = DigitPairs[secs];
buffer[6] = digits.First;
buffer[7] = digits.Second;
}
int endCount = 8;
// factional part
{
var remainingTicks = (value - new TimeSpan(value.Days, value.Hours, value.Minutes, value.Seconds, 0)).Ticks;
if (remainingTicks > 0)
{
int fracEnd;
buffer[8] = '.';
var fracPart = remainingTicks % 100;
remainingTicks /= 100;
if (fracPart > 0)
{
digits = DigitPairs[fracPart];
buffer[15] = digits.Second;
buffer[14] = digits.First;
fracEnd = 16;
}
else
{
fracEnd = 14;
}
fracPart = remainingTicks % 100;
remainingTicks /= 100;
if (fracPart > 0)
{
digits = DigitPairs[fracPart];
buffer[13] = digits.Second;
buffer[12] = digits.First;
}
else
{
if (fracEnd == 14)
{
fracEnd = 12;
}
else
{
buffer[13] = '0';
buffer[12] = '0';
}
}
fracPart = remainingTicks % 100;
remainingTicks /= 100;
if (fracPart > 0)
{
digits = DigitPairs[fracPart];
buffer[11] = digits.Second;
buffer[10] = digits.First;
}
else
{
if (fracEnd == 12)
{
fracEnd = 10;
}
else
{
buffer[11] = '0';
buffer[10] = '0';
}
}
fracPart = remainingTicks;
buffer[9] = (char)('0' + fracPart);
endCount = fracEnd;
}
}
handler.WriteChars(buffer, 0, endCount);
handler.WriteChar('"');
}
}
internal static void WriteValue(DateTime value, JsonSerializerHandler handler)
{
if (handler.Option.DatetimeFormat == DatetimeFormatEnum.ISO8601)
{
// "yyyy-mm-ddThh:mm:ss.fffffffZ"
// 0123456789ABCDEFGHIJKL
//
// Yes, DateTime.Max is in fact guaranteed to have a 4 digit year (and no more)
// f of 7 digits allows for 1 Tick level resolution
char[] buffer = new char[36];
buffer[0] = '"';
// Year
uint val = (uint)value.Year;
var digits = DigitPairs[(byte)(val % 100)];
buffer[4] = digits.Second;
buffer[3] = digits.First;
digits = DigitPairs[(byte)(val / 100)];
buffer[2] = digits.Second;
buffer[1] = digits.First;
// delimiter
buffer[5] = '-';
// Month
digits = DigitPairs[value.Month];
buffer[7] = digits.Second;
buffer[6] = digits.First;
// Delimiter
buffer[8] = '-';
// Day
digits = DigitPairs[value.Day];
buffer[10] = digits.Second;
buffer[9] = digits.First;
// Delimiter
buffer[11] = 'T';
digits = DigitPairs[value.Hour];
buffer[13] = digits.Second;
buffer[12] = digits.First;
// Delimiter
buffer[14] = ':';
digits = DigitPairs[value.Minute];
buffer[16] = digits.Second;
buffer[15] = digits.First;
// Delimiter
buffer[17] = ':';
digits = DigitPairs[value.Second];
buffer[19] = digits.Second;
buffer[18] = digits.First;
int fracEnd;
var remainingTicks = (value - new DateTime(value.Year, value.Month, value.Day, value.Hour, value.Minute, value.Second)).Ticks;
if (remainingTicks > 0)
{
buffer[20] = '.';
var fracPart = remainingTicks % 100;
remainingTicks /= 100;
if (fracPart > 0)
{
digits = DigitPairs[fracPart];
buffer[27] = digits.Second;
buffer[26] = digits.First;
fracEnd = 28;
}
else
{
fracEnd = 26;
}
fracPart = remainingTicks % 100;
remainingTicks /= 100;
if (fracPart > 0)
{
digits = DigitPairs[fracPart];
buffer[25] = digits.Second;
buffer[24] = digits.First;
}
else
{
if (fracEnd == 26)
{
fracEnd = 24;
}
else
{
buffer[25] = '0';
buffer[24] = '0';
}
}
fracPart = remainingTicks % 100;
remainingTicks /= 100;
if (fracPart > 0)
{
digits = DigitPairs[fracPart];
buffer[23] = digits.Second;
buffer[22] = digits.First;
}
else
{
if (fracEnd == 24)
{
fracEnd = 22;
}
else
{
buffer[23] = '0';
buffer[22] = '0';
}
}
fracPart = remainingTicks;
buffer[21] = (char)('0' + fracPart);
}
else
{
fracEnd = 20;
}
buffer[fracEnd] = 'Z';
buffer[fracEnd + 1] = '"';
handler.WriteChars(buffer, 0, fracEnd + 2);
}
else if (handler.Option.DatetimeFormat == DatetimeFormatEnum.RFC1123)
{
// ddd, dd MMM yyyy HH:mm:ss GMT'"
handler.WriteChar('"');
// compiles as a switch
switch (value.DayOfWeek)
{
case DayOfWeek.Sunday: handler.WriteString("Sun, "); break;
case DayOfWeek.Monday: handler.WriteString("Mon, "); break;
case DayOfWeek.Tuesday: handler.WriteString("Tue, "); break;
case DayOfWeek.Wednesday: handler.WriteString("Wed, "); break;
case DayOfWeek.Thursday: handler.WriteString("Thu, "); break;
case DayOfWeek.Friday: handler.WriteString("Fri, "); break;
case DayOfWeek.Saturday: handler.WriteString("Sat, "); break;
}
{
var day = DigitPairs[value.Day];
handler.WriteChar(day.First);
handler.WriteChar(day.Second);
handler.WriteChar(' ');
}
// compiles as a switch
switch (value.Month)
{
case 1: handler.WriteString("Jan "); break;
case 2: handler.WriteString("Feb "); break;
case 3: handler.WriteString("Mar "); break;
case 4: handler.WriteString("Apr "); break;
case 5: handler.WriteString("May "); break;
case 6: handler.WriteString("Jun "); break;
case 7: handler.WriteString("Jul "); break;
case 8: handler.WriteString("Aug "); break;
case 9: handler.WriteString("Sep "); break;
case 10: handler.WriteString("Oct "); break;
case 11: handler.WriteString("Nov "); break;
case 12: handler.WriteString("Dec "); break;
}
{
var year = value.Year;
var firstHalfYear = DigitPairs[year / 100];
handler.WriteChar(firstHalfYear.First);
handler.WriteChar(firstHalfYear.Second);
var secondHalfYear = DigitPairs[year % 100];
handler.WriteChar(secondHalfYear.First);
handler.WriteChar(secondHalfYear.Second);
handler.WriteChar(' ');
}
{
var hour = DigitPairs[value.Hour];
handler.WriteChar(hour.First);
handler.WriteChar(hour.Second);
handler.WriteChar(':');
}
{
var minute = DigitPairs[value.Minute];
handler.WriteChar(minute.First);
handler.WriteChar(minute.Second);
handler.WriteChar(':');
}
{
var second = DigitPairs[value.Second];
handler.WriteChar(second.First);
handler.WriteChar(second.Second);
}
handler.WriteString(" GMT\"");
}
else if (handler.Option.DatetimeFormat == DatetimeFormatEnum.Microsoft)
{
/*
* "\/Date(628318530718)\/"
*/
handler.WriteString("\"\\/Date(");
handler.WriteLong((value.Ticks - 621355968000000000L) / 10000L);
handler.WriteString(")\\/\"");
}
}