niko
765 lines
23 KiB
C#
765 lines
23 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using Google.Protobuf.Reflection;
|
|
using Google.Protobuf.WellKnownTypes;
|
|
|
|
namespace Google.Protobuf
|
|
{
|
|
// Token: 0x0200000F RID: 15
|
|
public sealed class JsonFormatter
|
|
{
|
|
// Token: 0x17000015 RID: 21
|
|
// (get) Token: 0x060000D4 RID: 212 RVA: 0x00004564 File Offset: 0x00002764
|
|
public static JsonFormatter Default { get; } = new JsonFormatter(JsonFormatter.Settings.Default);
|
|
|
|
// Token: 0x060000D5 RID: 213 RVA: 0x0000456C File Offset: 0x0000276C
|
|
static JsonFormatter()
|
|
{
|
|
for (int i = 0; i < JsonFormatter.CommonRepresentations.Length; i++)
|
|
{
|
|
if (JsonFormatter.CommonRepresentations[i] == "")
|
|
{
|
|
JsonFormatter.CommonRepresentations[i] = ((char)i).ToString();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000016 RID: 22
|
|
// (get) Token: 0x060000D6 RID: 214 RVA: 0x00004BD3 File Offset: 0x00002DD3
|
|
private bool DiagnosticOnly
|
|
{
|
|
get
|
|
{
|
|
return this == JsonFormatter.diagnosticFormatter;
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000D7 RID: 215 RVA: 0x00004BDD File Offset: 0x00002DDD
|
|
public JsonFormatter(JsonFormatter.Settings settings)
|
|
{
|
|
this.settings = settings;
|
|
}
|
|
|
|
// Token: 0x060000D8 RID: 216 RVA: 0x00004BEC File Offset: 0x00002DEC
|
|
public string Format(IMessage message)
|
|
{
|
|
StringWriter stringWriter = new StringWriter();
|
|
this.Format(message, stringWriter);
|
|
return stringWriter.ToString();
|
|
}
|
|
|
|
// Token: 0x060000D9 RID: 217 RVA: 0x00004C0D File Offset: 0x00002E0D
|
|
public void Format(IMessage message, TextWriter writer)
|
|
{
|
|
ProtoPreconditions.CheckNotNull<IMessage>(message, "message");
|
|
ProtoPreconditions.CheckNotNull<TextWriter>(writer, "writer");
|
|
if (message.Descriptor.IsWellKnownType)
|
|
{
|
|
this.WriteWellKnownTypeValue(writer, message.Descriptor, message);
|
|
return;
|
|
}
|
|
this.WriteMessage(writer, message);
|
|
}
|
|
|
|
// Token: 0x060000DA RID: 218 RVA: 0x00004C4B File Offset: 0x00002E4B
|
|
public static string ToDiagnosticString(IMessage message)
|
|
{
|
|
ProtoPreconditions.CheckNotNull<IMessage>(message, "message");
|
|
return JsonFormatter.diagnosticFormatter.Format(message);
|
|
}
|
|
|
|
// Token: 0x060000DB RID: 219 RVA: 0x00004C64 File Offset: 0x00002E64
|
|
private void WriteMessage(TextWriter writer, IMessage message)
|
|
{
|
|
if (message == null)
|
|
{
|
|
JsonFormatter.WriteNull(writer);
|
|
return;
|
|
}
|
|
if (this.DiagnosticOnly)
|
|
{
|
|
ICustomDiagnosticMessage customDiagnosticMessage = message as ICustomDiagnosticMessage;
|
|
if (customDiagnosticMessage != null)
|
|
{
|
|
writer.Write(customDiagnosticMessage.ToDiagnosticString());
|
|
return;
|
|
}
|
|
}
|
|
writer.Write("{ ");
|
|
writer.Write(this.WriteMessageFields(writer, message, false) ? " }" : "}");
|
|
}
|
|
|
|
// Token: 0x060000DC RID: 220 RVA: 0x00004CC4 File Offset: 0x00002EC4
|
|
private bool WriteMessageFields(TextWriter writer, IMessage message, bool assumeFirstFieldWritten)
|
|
{
|
|
MessageDescriptor.FieldCollection fields = message.Descriptor.Fields;
|
|
bool flag = !assumeFirstFieldWritten;
|
|
foreach (FieldDescriptor fieldDescriptor in fields.InFieldNumberOrder())
|
|
{
|
|
IFieldAccessor accessor = fieldDescriptor.Accessor;
|
|
if (fieldDescriptor.ContainingOneof == null || fieldDescriptor.ContainingOneof.Accessor.GetCaseFieldDescriptor(message) == fieldDescriptor)
|
|
{
|
|
object value = accessor.GetValue(message);
|
|
if (fieldDescriptor.ContainingOneof != null || this.settings.FormatDefaultValues || !JsonFormatter.IsDefaultValue(accessor, value))
|
|
{
|
|
if (!flag)
|
|
{
|
|
writer.Write(", ");
|
|
}
|
|
JsonFormatter.WriteString(writer, accessor.Descriptor.JsonName);
|
|
writer.Write(": ");
|
|
this.WriteValue(writer, value);
|
|
flag = false;
|
|
}
|
|
}
|
|
}
|
|
return !flag;
|
|
}
|
|
|
|
// Token: 0x060000DD RID: 221 RVA: 0x00004DA4 File Offset: 0x00002FA4
|
|
private static string ToCamelCaseForFieldMask(string input)
|
|
{
|
|
for (int i = 0; i < input.Length; i++)
|
|
{
|
|
char c = input[i];
|
|
if (c >= 'A' && c <= 'Z')
|
|
{
|
|
throw new InvalidOperationException(string.Format("Invalid field mask to be converted to JSON: {0}", input));
|
|
}
|
|
if (c == '_' && i < input.Length - 1)
|
|
{
|
|
char c2 = input[i + 1];
|
|
if (c2 < 'a' || c2 > 'z')
|
|
{
|
|
throw new InvalidOperationException(string.Format("Invalid field mask to be converted to JSON: {0}", input));
|
|
}
|
|
}
|
|
}
|
|
return JsonFormatter.ToCamelCase(input);
|
|
}
|
|
|
|
// Token: 0x060000DE RID: 222 RVA: 0x00004E20 File Offset: 0x00003020
|
|
internal static string ToCamelCase(string input)
|
|
{
|
|
bool flag = false;
|
|
bool flag2 = true;
|
|
bool flag3 = true;
|
|
StringBuilder stringBuilder = new StringBuilder(input.Length);
|
|
int i = 0;
|
|
while (i < input.Length)
|
|
{
|
|
bool flag4 = char.IsUpper(input[i]);
|
|
if (input[i] == '_')
|
|
{
|
|
flag = true;
|
|
if (stringBuilder.Length != 0)
|
|
{
|
|
flag3 = false;
|
|
}
|
|
}
|
|
else if (flag3)
|
|
{
|
|
if (stringBuilder.Length != 0 && flag4 && (!flag2 || (i + 1 < input.Length && char.IsLower(input[i + 1]))))
|
|
{
|
|
flag3 = false;
|
|
stringBuilder.Append(input[i]);
|
|
}
|
|
else
|
|
{
|
|
stringBuilder.Append(char.ToLowerInvariant(input[i]));
|
|
}
|
|
}
|
|
else if (flag)
|
|
{
|
|
flag = false;
|
|
if (char.IsLower(input[i]))
|
|
{
|
|
stringBuilder.Append(char.ToUpperInvariant(input[i]));
|
|
}
|
|
else
|
|
{
|
|
stringBuilder.Append(input[i]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
stringBuilder.Append(char.ToLowerInvariant(input[i]));
|
|
}
|
|
i++;
|
|
flag2 = flag4;
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
// Token: 0x060000DF RID: 223 RVA: 0x00004F43 File Offset: 0x00003143
|
|
private static void WriteNull(TextWriter writer)
|
|
{
|
|
writer.Write("null");
|
|
}
|
|
|
|
// Token: 0x060000E0 RID: 224 RVA: 0x00004F50 File Offset: 0x00003150
|
|
private static bool IsDefaultValue(IFieldAccessor accessor, object value)
|
|
{
|
|
if (accessor.Descriptor.IsMap)
|
|
{
|
|
return ((IDictionary)value).Count == 0;
|
|
}
|
|
if (accessor.Descriptor.IsRepeated)
|
|
{
|
|
return ((IList)value).Count == 0;
|
|
}
|
|
switch (accessor.Descriptor.FieldType)
|
|
{
|
|
case FieldType.Double:
|
|
return (double)value == 0.0;
|
|
case FieldType.Float:
|
|
return (float)value == 0f;
|
|
case FieldType.Int64:
|
|
case FieldType.SFixed64:
|
|
case FieldType.SInt64:
|
|
return (long)value == 0L;
|
|
case FieldType.UInt64:
|
|
case FieldType.Fixed64:
|
|
return (ulong)value == 0UL;
|
|
case FieldType.Int32:
|
|
case FieldType.SFixed32:
|
|
case FieldType.SInt32:
|
|
case FieldType.Enum:
|
|
return (int)value == 0;
|
|
case FieldType.Fixed32:
|
|
case FieldType.UInt32:
|
|
return (uint)value == 0U;
|
|
case FieldType.Bool:
|
|
return !(bool)value;
|
|
case FieldType.String:
|
|
return (string)value == "";
|
|
case FieldType.Group:
|
|
case FieldType.Message:
|
|
return value == null;
|
|
case FieldType.Bytes:
|
|
return (ByteString)value == ByteString.Empty;
|
|
default:
|
|
throw new ArgumentException("Invalid field type");
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000E1 RID: 225 RVA: 0x00005078 File Offset: 0x00003278
|
|
public void WriteValue(TextWriter writer, object value)
|
|
{
|
|
if (value == null)
|
|
{
|
|
JsonFormatter.WriteNull(writer);
|
|
return;
|
|
}
|
|
if (value is bool)
|
|
{
|
|
writer.Write(((bool)value) ? "true" : "false");
|
|
return;
|
|
}
|
|
if (value is ByteString)
|
|
{
|
|
writer.Write('"');
|
|
writer.Write(((ByteString)value).ToBase64());
|
|
writer.Write('"');
|
|
return;
|
|
}
|
|
if (value is string)
|
|
{
|
|
JsonFormatter.WriteString(writer, (string)value);
|
|
return;
|
|
}
|
|
if (value is IDictionary)
|
|
{
|
|
this.WriteDictionary(writer, (IDictionary)value);
|
|
return;
|
|
}
|
|
if (value is IList)
|
|
{
|
|
this.WriteList(writer, (IList)value);
|
|
return;
|
|
}
|
|
if (value is int || value is uint)
|
|
{
|
|
IFormattable formattable = (IFormattable)value;
|
|
writer.Write(formattable.ToString("d", CultureInfo.InvariantCulture));
|
|
return;
|
|
}
|
|
if (value is long || value is ulong)
|
|
{
|
|
writer.Write('"');
|
|
IFormattable formattable2 = (IFormattable)value;
|
|
writer.Write(formattable2.ToString("d", CultureInfo.InvariantCulture));
|
|
writer.Write('"');
|
|
return;
|
|
}
|
|
if (value is global::System.Enum)
|
|
{
|
|
string originalName = JsonFormatter.OriginalEnumValueHelper.GetOriginalName(value);
|
|
if (originalName != null)
|
|
{
|
|
JsonFormatter.WriteString(writer, originalName);
|
|
return;
|
|
}
|
|
this.WriteValue(writer, (int)value);
|
|
return;
|
|
}
|
|
else if (value is float || value is double)
|
|
{
|
|
string text = ((IFormattable)value).ToString("r", CultureInfo.InvariantCulture);
|
|
if (text == "NaN" || text == "Infinity" || text == "-Infinity")
|
|
{
|
|
writer.Write('"');
|
|
writer.Write(text);
|
|
writer.Write('"');
|
|
return;
|
|
}
|
|
writer.Write(text);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if (value is IMessage)
|
|
{
|
|
this.Format((IMessage)value, writer);
|
|
return;
|
|
}
|
|
throw new ArgumentException("Unable to format value of type " + value.GetType());
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000E2 RID: 226 RVA: 0x00005250 File Offset: 0x00003450
|
|
private void WriteWellKnownTypeValue(TextWriter writer, MessageDescriptor descriptor, object value)
|
|
{
|
|
if (value == null)
|
|
{
|
|
JsonFormatter.WriteNull(writer);
|
|
return;
|
|
}
|
|
if (descriptor.IsWrapperType)
|
|
{
|
|
if (value is IMessage)
|
|
{
|
|
IMessage message = (IMessage)value;
|
|
value = message.Descriptor.Fields[1].Accessor.GetValue(message);
|
|
}
|
|
this.WriteValue(writer, value);
|
|
return;
|
|
}
|
|
if (descriptor.FullName == Timestamp.Descriptor.FullName)
|
|
{
|
|
this.WriteTimestamp(writer, (IMessage)value);
|
|
return;
|
|
}
|
|
if (descriptor.FullName == Duration.Descriptor.FullName)
|
|
{
|
|
this.WriteDuration(writer, (IMessage)value);
|
|
return;
|
|
}
|
|
if (descriptor.FullName == FieldMask.Descriptor.FullName)
|
|
{
|
|
this.WriteFieldMask(writer, (IMessage)value);
|
|
return;
|
|
}
|
|
if (descriptor.FullName == Struct.Descriptor.FullName)
|
|
{
|
|
this.WriteStruct(writer, (IMessage)value);
|
|
return;
|
|
}
|
|
if (descriptor.FullName == ListValue.Descriptor.FullName)
|
|
{
|
|
IFieldAccessor accessor = descriptor.Fields[1].Accessor;
|
|
this.WriteList(writer, (IList)accessor.GetValue((IMessage)value));
|
|
return;
|
|
}
|
|
if (descriptor.FullName == Value.Descriptor.FullName)
|
|
{
|
|
this.WriteStructFieldValue(writer, (IMessage)value);
|
|
return;
|
|
}
|
|
if (descriptor.FullName == Any.Descriptor.FullName)
|
|
{
|
|
this.WriteAny(writer, (IMessage)value);
|
|
return;
|
|
}
|
|
this.WriteMessage(writer, (IMessage)value);
|
|
}
|
|
|
|
// Token: 0x060000E3 RID: 227 RVA: 0x000053D4 File Offset: 0x000035D4
|
|
private void WriteTimestamp(TextWriter writer, IMessage value)
|
|
{
|
|
int num = (int)value.Descriptor.Fields[2].Accessor.GetValue(value);
|
|
long num2 = (long)value.Descriptor.Fields[1].Accessor.GetValue(value);
|
|
writer.Write(Timestamp.ToJson(num2, num, this.DiagnosticOnly));
|
|
}
|
|
|
|
// Token: 0x060000E4 RID: 228 RVA: 0x00005438 File Offset: 0x00003638
|
|
private void WriteDuration(TextWriter writer, IMessage value)
|
|
{
|
|
int num = (int)value.Descriptor.Fields[2].Accessor.GetValue(value);
|
|
long num2 = (long)value.Descriptor.Fields[1].Accessor.GetValue(value);
|
|
writer.Write(Duration.ToJson(num2, num, this.DiagnosticOnly));
|
|
}
|
|
|
|
// Token: 0x060000E5 RID: 229 RVA: 0x0000549C File Offset: 0x0000369C
|
|
private void WriteFieldMask(TextWriter writer, IMessage value)
|
|
{
|
|
IList<string> list = (IList<string>)value.Descriptor.Fields[1].Accessor.GetValue(value);
|
|
writer.Write(FieldMask.ToJson(list, this.DiagnosticOnly));
|
|
}
|
|
|
|
// Token: 0x060000E6 RID: 230 RVA: 0x000054E0 File Offset: 0x000036E0
|
|
private void WriteAny(TextWriter writer, IMessage value)
|
|
{
|
|
if (this.DiagnosticOnly)
|
|
{
|
|
this.WriteDiagnosticOnlyAny(writer, value);
|
|
return;
|
|
}
|
|
string text = (string)value.Descriptor.Fields[1].Accessor.GetValue(value);
|
|
ByteString byteString = (ByteString)value.Descriptor.Fields[2].Accessor.GetValue(value);
|
|
string typeName = Any.GetTypeName(text);
|
|
MessageDescriptor messageDescriptor = this.settings.TypeRegistry.Find(typeName);
|
|
if (messageDescriptor == null)
|
|
{
|
|
throw new InvalidOperationException(string.Format("Type registry has no descriptor for type name '{0}'", typeName));
|
|
}
|
|
IMessage message = messageDescriptor.Parser.ParseFrom(byteString);
|
|
writer.Write("{ ");
|
|
JsonFormatter.WriteString(writer, "@type");
|
|
writer.Write(": ");
|
|
JsonFormatter.WriteString(writer, text);
|
|
if (messageDescriptor.IsWellKnownType)
|
|
{
|
|
writer.Write(", ");
|
|
JsonFormatter.WriteString(writer, "value");
|
|
writer.Write(": ");
|
|
this.WriteWellKnownTypeValue(writer, messageDescriptor, message);
|
|
}
|
|
else
|
|
{
|
|
this.WriteMessageFields(writer, message, true);
|
|
}
|
|
writer.Write(" }");
|
|
}
|
|
|
|
// Token: 0x060000E7 RID: 231 RVA: 0x000055F0 File Offset: 0x000037F0
|
|
private void WriteDiagnosticOnlyAny(TextWriter writer, IMessage value)
|
|
{
|
|
string text = (string)value.Descriptor.Fields[1].Accessor.GetValue(value);
|
|
ByteString byteString = (ByteString)value.Descriptor.Fields[2].Accessor.GetValue(value);
|
|
writer.Write("{ ");
|
|
JsonFormatter.WriteString(writer, "@type");
|
|
writer.Write(": ");
|
|
JsonFormatter.WriteString(writer, text);
|
|
writer.Write(", ");
|
|
JsonFormatter.WriteString(writer, "@value");
|
|
writer.Write(": ");
|
|
writer.Write('"');
|
|
writer.Write(byteString.ToBase64());
|
|
writer.Write('"');
|
|
writer.Write(" }");
|
|
}
|
|
|
|
// Token: 0x060000E8 RID: 232 RVA: 0x000056B4 File Offset: 0x000038B4
|
|
private void WriteStruct(TextWriter writer, IMessage message)
|
|
{
|
|
writer.Write("{ ");
|
|
IDictionary dictionary = (IDictionary)message.Descriptor.Fields[1].Accessor.GetValue(message);
|
|
bool flag = true;
|
|
foreach (object obj in dictionary)
|
|
{
|
|
DictionaryEntry dictionaryEntry = (DictionaryEntry)obj;
|
|
string text = (string)dictionaryEntry.Key;
|
|
IMessage message2 = (IMessage)dictionaryEntry.Value;
|
|
if (string.IsNullOrEmpty(text) || message2 == null)
|
|
{
|
|
throw new InvalidOperationException("Struct fields cannot have an empty key or a null value.");
|
|
}
|
|
if (!flag)
|
|
{
|
|
writer.Write(", ");
|
|
}
|
|
JsonFormatter.WriteString(writer, text);
|
|
writer.Write(": ");
|
|
this.WriteStructFieldValue(writer, message2);
|
|
flag = false;
|
|
}
|
|
writer.Write(flag ? "}" : " }");
|
|
}
|
|
|
|
// Token: 0x060000E9 RID: 233 RVA: 0x000057A4 File Offset: 0x000039A4
|
|
private void WriteStructFieldValue(TextWriter writer, IMessage message)
|
|
{
|
|
FieldDescriptor caseFieldDescriptor = message.Descriptor.Oneofs[0].Accessor.GetCaseFieldDescriptor(message);
|
|
if (caseFieldDescriptor == null)
|
|
{
|
|
throw new InvalidOperationException("Value message must contain a value for the oneof.");
|
|
}
|
|
object value = caseFieldDescriptor.Accessor.GetValue(message);
|
|
switch (caseFieldDescriptor.FieldNumber)
|
|
{
|
|
case 1:
|
|
JsonFormatter.WriteNull(writer);
|
|
return;
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
this.WriteValue(writer, value);
|
|
return;
|
|
case 5:
|
|
case 6:
|
|
{
|
|
IMessage message2 = (IMessage)caseFieldDescriptor.Accessor.GetValue(message);
|
|
this.WriteWellKnownTypeValue(writer, message2.Descriptor, message2);
|
|
return;
|
|
}
|
|
default:
|
|
throw new InvalidOperationException("Unexpected case in struct field: " + caseFieldDescriptor.FieldNumber);
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000EA RID: 234 RVA: 0x00005860 File Offset: 0x00003A60
|
|
internal void WriteList(TextWriter writer, IList list)
|
|
{
|
|
writer.Write("[ ");
|
|
bool flag = true;
|
|
foreach (object obj in list)
|
|
{
|
|
if (!flag)
|
|
{
|
|
writer.Write(", ");
|
|
}
|
|
this.WriteValue(writer, obj);
|
|
flag = false;
|
|
}
|
|
writer.Write(flag ? "]" : " ]");
|
|
}
|
|
|
|
// Token: 0x060000EB RID: 235 RVA: 0x000058E4 File Offset: 0x00003AE4
|
|
internal void WriteDictionary(TextWriter writer, IDictionary dictionary)
|
|
{
|
|
writer.Write("{ ");
|
|
bool flag = true;
|
|
foreach (object obj in dictionary)
|
|
{
|
|
DictionaryEntry dictionaryEntry = (DictionaryEntry)obj;
|
|
if (!flag)
|
|
{
|
|
writer.Write(", ");
|
|
}
|
|
string text;
|
|
if (dictionaryEntry.Key is string)
|
|
{
|
|
text = (string)dictionaryEntry.Key;
|
|
}
|
|
else if (dictionaryEntry.Key is bool)
|
|
{
|
|
text = (((bool)dictionaryEntry.Key) ? "true" : "false");
|
|
}
|
|
else if (dictionaryEntry.Key is int || ((dictionaryEntry.Key is uint) | (dictionaryEntry.Key is long)) || dictionaryEntry.Key is ulong)
|
|
{
|
|
text = ((IFormattable)dictionaryEntry.Key).ToString("d", CultureInfo.InvariantCulture);
|
|
}
|
|
else
|
|
{
|
|
if (dictionaryEntry.Key == null)
|
|
{
|
|
throw new ArgumentException("Dictionary has entry with null key");
|
|
}
|
|
throw new ArgumentException("Unhandled dictionary key type: " + dictionaryEntry.Key.GetType());
|
|
}
|
|
JsonFormatter.WriteString(writer, text);
|
|
writer.Write(": ");
|
|
this.WriteValue(writer, dictionaryEntry.Value);
|
|
flag = false;
|
|
}
|
|
writer.Write(flag ? "}" : " }");
|
|
}
|
|
|
|
// Token: 0x060000EC RID: 236 RVA: 0x00005A74 File Offset: 0x00003C74
|
|
internal static void WriteString(TextWriter writer, string text)
|
|
{
|
|
writer.Write('"');
|
|
for (int i = 0; i < text.Length; i++)
|
|
{
|
|
char c = text[i];
|
|
if (c < '\u00a0')
|
|
{
|
|
writer.Write(JsonFormatter.CommonRepresentations[(int)c]);
|
|
}
|
|
else if (char.IsHighSurrogate(c))
|
|
{
|
|
i++;
|
|
if (i == text.Length || !char.IsLowSurrogate(text[i]))
|
|
{
|
|
throw new ArgumentException("String contains low surrogate not followed by high surrogate");
|
|
}
|
|
JsonFormatter.HexEncodeUtf16CodeUnit(writer, c);
|
|
JsonFormatter.HexEncodeUtf16CodeUnit(writer, text[i]);
|
|
}
|
|
else
|
|
{
|
|
if (char.IsLowSurrogate(c))
|
|
{
|
|
throw new ArgumentException("String contains high surrogate not preceded by low surrogate");
|
|
}
|
|
uint num = (uint)c;
|
|
if (num <= 1807U)
|
|
{
|
|
if (num != 173U && num != 1757U && num != 1807U)
|
|
{
|
|
goto IL_D4;
|
|
}
|
|
}
|
|
else if (num - 6068U > 1U && num != 65279U && num - 65529U > 2U)
|
|
{
|
|
goto IL_D4;
|
|
}
|
|
JsonFormatter.HexEncodeUtf16CodeUnit(writer, c);
|
|
goto IL_134;
|
|
IL_D4:
|
|
if ((c >= '\u0600' && c <= '\u0603') || (c >= '\u200b' && c <= '\u200f') || (c >= '\u2028' && c <= '\u202e') || (c >= '\u2060' && c <= '\u2064') || (c >= '\u206a' && c <= '\u206f'))
|
|
{
|
|
JsonFormatter.HexEncodeUtf16CodeUnit(writer, c);
|
|
}
|
|
else
|
|
{
|
|
writer.Write(c);
|
|
}
|
|
}
|
|
IL_134:;
|
|
}
|
|
writer.Write('"');
|
|
}
|
|
|
|
// Token: 0x060000ED RID: 237 RVA: 0x00005BD0 File Offset: 0x00003DD0
|
|
private static void HexEncodeUtf16CodeUnit(TextWriter writer, char c)
|
|
{
|
|
writer.Write("\\u");
|
|
writer.Write("0123456789abcdef"[(int)((c >> 12) & '\u000f')]);
|
|
writer.Write("0123456789abcdef"[(int)((c >> 8) & '\u000f')]);
|
|
writer.Write("0123456789abcdef"[(int)((c >> 4) & '\u000f')]);
|
|
writer.Write("0123456789abcdef"[(int)(c & '\u000f')]);
|
|
}
|
|
|
|
// Token: 0x04000029 RID: 41
|
|
internal const string AnyTypeUrlField = "@type";
|
|
|
|
// Token: 0x0400002A RID: 42
|
|
internal const string AnyDiagnosticValueField = "@value";
|
|
|
|
// Token: 0x0400002B RID: 43
|
|
internal const string AnyWellKnownTypeValueField = "value";
|
|
|
|
// Token: 0x0400002C RID: 44
|
|
private const string TypeUrlPrefix = "type.googleapis.com";
|
|
|
|
// Token: 0x0400002D RID: 45
|
|
private const string NameValueSeparator = ": ";
|
|
|
|
// Token: 0x0400002E RID: 46
|
|
private const string PropertySeparator = ", ";
|
|
|
|
// Token: 0x04000030 RID: 48
|
|
private static readonly JsonFormatter diagnosticFormatter = new JsonFormatter(JsonFormatter.Settings.Default);
|
|
|
|
// Token: 0x04000031 RID: 49
|
|
private static readonly string[] CommonRepresentations = new string[]
|
|
{
|
|
"\\u0000", "\\u0001", "\\u0002", "\\u0003", "\\u0004", "\\u0005", "\\u0006", "\\u0007", "\\b", "\\t",
|
|
"\\n", "\\u000b", "\\f", "\\r", "\\u000e", "\\u000f", "\\u0010", "\\u0011", "\\u0012", "\\u0013",
|
|
"\\u0014", "\\u0015", "\\u0016", "\\u0017", "\\u0018", "\\u0019", "\\u001a", "\\u001b", "\\u001c", "\\u001d",
|
|
"\\u001e", "\\u001f", "", "", "\\\"", "", "", "", "", "",
|
|
"", "", "", "", "", "", "", "", "", "",
|
|
"", "", "", "", "", "", "", "", "", "",
|
|
"\\u003c", "", "\\u003e", "", "", "", "", "", "", "",
|
|
"", "", "", "", "", "", "", "", "", "",
|
|
"", "", "", "", "", "", "", "", "", "",
|
|
"", "", "\\\\", "", "", "", "", "", "", "",
|
|
"", "", "", "", "", "", "", "", "", "",
|
|
"", "", "", "", "", "", "", "", "", "",
|
|
"", "", "", "", "", "", "", "\\u007f", "\\u0080", "\\u0081",
|
|
"\\u0082", "\\u0083", "\\u0084", "\\u0085", "\\u0086", "\\u0087", "\\u0088", "\\u0089", "\\u008a", "\\u008b",
|
|
"\\u008c", "\\u008d", "\\u008e", "\\u008f", "\\u0090", "\\u0091", "\\u0092", "\\u0093", "\\u0094", "\\u0095",
|
|
"\\u0096", "\\u0097", "\\u0098", "\\u0099", "\\u009a", "\\u009b", "\\u009c", "\\u009d", "\\u009e", "\\u009f"
|
|
};
|
|
|
|
// Token: 0x04000032 RID: 50
|
|
private readonly JsonFormatter.Settings settings;
|
|
|
|
// Token: 0x04000033 RID: 51
|
|
private const string Hex = "0123456789abcdef";
|
|
|
|
// Token: 0x0200007D RID: 125
|
|
public sealed class Settings
|
|
{
|
|
// Token: 0x170001CC RID: 460
|
|
// (get) Token: 0x060006AB RID: 1707 RVA: 0x0001666F File Offset: 0x0001486F
|
|
public static JsonFormatter.Settings Default { get; } = new JsonFormatter.Settings(false);
|
|
|
|
// Token: 0x170001CD RID: 461
|
|
// (get) Token: 0x060006AD RID: 1709 RVA: 0x00016683 File Offset: 0x00014883
|
|
public bool FormatDefaultValues { get; }
|
|
|
|
// Token: 0x170001CE RID: 462
|
|
// (get) Token: 0x060006AE RID: 1710 RVA: 0x0001668B File Offset: 0x0001488B
|
|
public TypeRegistry TypeRegistry { get; }
|
|
|
|
// Token: 0x060006AF RID: 1711 RVA: 0x00016693 File Offset: 0x00014893
|
|
public Settings(bool formatDefaultValues)
|
|
: this(formatDefaultValues, TypeRegistry.Empty)
|
|
{
|
|
}
|
|
|
|
// Token: 0x060006B0 RID: 1712 RVA: 0x000166A1 File Offset: 0x000148A1
|
|
public Settings(bool formatDefaultValues, TypeRegistry typeRegistry)
|
|
{
|
|
this.FormatDefaultValues = formatDefaultValues;
|
|
this.TypeRegistry = ProtoPreconditions.CheckNotNull<TypeRegistry>(typeRegistry, "typeRegistry");
|
|
}
|
|
}
|
|
|
|
// Token: 0x0200007E RID: 126
|
|
private static class OriginalEnumValueHelper
|
|
{
|
|
// Token: 0x060006B1 RID: 1713 RVA: 0x000166C4 File Offset: 0x000148C4
|
|
internal static string GetOriginalName(object value)
|
|
{
|
|
global::System.Type type = value.GetType();
|
|
Dictionary<global::System.Type, Dictionary<object, string>> dictionary = JsonFormatter.OriginalEnumValueHelper.dictionaries;
|
|
Dictionary<object, string> nameMapping;
|
|
lock (dictionary)
|
|
{
|
|
if (!JsonFormatter.OriginalEnumValueHelper.dictionaries.TryGetValue(type, out nameMapping))
|
|
{
|
|
nameMapping = JsonFormatter.OriginalEnumValueHelper.GetNameMapping(type);
|
|
JsonFormatter.OriginalEnumValueHelper.dictionaries[type] = nameMapping;
|
|
}
|
|
}
|
|
string text;
|
|
nameMapping.TryGetValue(value, out text);
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x060006B2 RID: 1714 RVA: 0x0001672C File Offset: 0x0001492C
|
|
private static Dictionary<object, string> GetNameMapping(global::System.Type enumType)
|
|
{
|
|
return enumType.GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).ToDictionary((FieldInfo f) => f.GetValue(null), delegate(FieldInfo f)
|
|
{
|
|
OriginalNameAttribute originalNameAttribute = f.GetCustomAttributes(typeof(OriginalNameAttribute), false).FirstOrDefault<object>() as OriginalNameAttribute;
|
|
return ((originalNameAttribute != null) ? originalNameAttribute.Name : null) ?? f.Name;
|
|
});
|
|
}
|
|
|
|
// Token: 0x0400029A RID: 666
|
|
private static readonly Dictionary<global::System.Type, Dictionary<object, string>> dictionaries = new Dictionary<global::System.Type, Dictionary<object, string>>();
|
|
}
|
|
}
|
|
}
|