Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 1 | #region Copyright notice and license |
| 2 | // Protocol Buffers - Google's data interchange format |
| 3 | // Copyright 2015 Google Inc. All rights reserved. |
| 4 | // https://developers.google.com/protocol-buffers/ |
| 5 | // |
| 6 | // Redistribution and use in source and binary forms, with or without |
| 7 | // modification, are permitted provided that the following conditions are |
| 8 | // met: |
| 9 | // |
| 10 | // * Redistributions of source code must retain the above copyright |
| 11 | // notice, this list of conditions and the following disclaimer. |
| 12 | // * Redistributions in binary form must reproduce the above |
| 13 | // copyright notice, this list of conditions and the following disclaimer |
| 14 | // in the documentation and/or other materials provided with the |
| 15 | // distribution. |
| 16 | // * Neither the name of Google Inc. nor the names of its |
| 17 | // contributors may be used to endorse or promote products derived from |
| 18 | // this software without specific prior written permission. |
| 19 | // |
| 20 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 21 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 22 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 23 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 24 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 25 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 26 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 27 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 28 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 29 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 30 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 31 | #endregion |
| 32 | |
| 33 | using System; |
| 34 | using System.Collections; |
| 35 | using System.Globalization; |
| 36 | using System.Text; |
Jon Skeet | 9f37de9 | 2015-07-14 10:24:52 +0100 | [diff] [blame] | 37 | using Google.Protobuf.Reflection; |
Jon Skeet | c9fd53a | 2015-07-20 11:48:24 +0100 | [diff] [blame] | 38 | using Google.Protobuf.WellKnownTypes; |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 39 | using System.IO; |
Jon Skeet | 0e30de3 | 2015-08-03 11:43:07 +0100 | [diff] [blame] | 40 | using System.Linq; |
Jon Skeet | dd43dcc | 2016-01-20 18:43:00 +0000 | [diff] [blame] | 41 | using System.Collections.Generic; |
Jon Skeet | 790f4c8 | 2016-04-08 13:22:42 +0100 | [diff] [blame] | 42 | using System.Reflection; |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 43 | |
| 44 | namespace Google.Protobuf |
| 45 | { |
| 46 | /// <summary> |
| 47 | /// Reflection-based converter from messages to JSON. |
| 48 | /// </summary> |
| 49 | /// <remarks> |
| 50 | /// <para> |
| 51 | /// Instances of this class are thread-safe, with no mutable state. |
| 52 | /// </para> |
| 53 | /// <para> |
| 54 | /// This is a simple start to get JSON formatting working. As it's reflection-based, |
| 55 | /// it's not as quick as baking calls into generated messages - but is a simpler implementation. |
| 56 | /// (This code is generally not heavily optimized.) |
| 57 | /// </para> |
| 58 | /// </remarks> |
| 59 | public sealed class JsonFormatter |
| 60 | { |
Jon Skeet | 567579b | 2015-11-23 12:43:54 +0000 | [diff] [blame] | 61 | internal const string AnyTypeUrlField = "@type"; |
Jon Skeet | aabc6c4 | 2015-12-15 09:23:38 +0000 | [diff] [blame] | 62 | internal const string AnyDiagnosticValueField = "@value"; |
Jon Skeet | 567579b | 2015-11-23 12:43:54 +0000 | [diff] [blame] | 63 | internal const string AnyWellKnownTypeValueField = "value"; |
| 64 | private const string TypeUrlPrefix = "type.googleapis.com"; |
| 65 | private const string NameValueSeparator = ": "; |
| 66 | private const string PropertySeparator = ", "; |
| 67 | |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 68 | /// <summary> |
| 69 | /// Returns a formatter using the default settings. |
| 70 | /// </summary> |
Jon Skeet | aabc6c4 | 2015-12-15 09:23:38 +0000 | [diff] [blame] | 71 | public static JsonFormatter Default { get; } = new JsonFormatter(Settings.Default); |
| 72 | |
| 73 | // A JSON formatter which *only* exists |
| 74 | private static readonly JsonFormatter diagnosticFormatter = new JsonFormatter(Settings.Default); |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 75 | |
| 76 | /// <summary> |
| 77 | /// The JSON representation of the first 160 characters of Unicode. |
| 78 | /// Empty strings are replaced by the static constructor. |
| 79 | /// </summary> |
| 80 | private static readonly string[] CommonRepresentations = { |
| 81 | // C0 (ASCII and derivatives) control characters |
| 82 | "\\u0000", "\\u0001", "\\u0002", "\\u0003", // 0x00 |
| 83 | "\\u0004", "\\u0005", "\\u0006", "\\u0007", |
| 84 | "\\b", "\\t", "\\n", "\\u000b", |
| 85 | "\\f", "\\r", "\\u000e", "\\u000f", |
| 86 | "\\u0010", "\\u0011", "\\u0012", "\\u0013", // 0x10 |
| 87 | "\\u0014", "\\u0015", "\\u0016", "\\u0017", |
| 88 | "\\u0018", "\\u0019", "\\u001a", "\\u001b", |
| 89 | "\\u001c", "\\u001d", "\\u001e", "\\u001f", |
| 90 | // Escaping of " and \ are required by www.json.org string definition. |
| 91 | // Escaping of < and > are required for HTML security. |
| 92 | "", "", "\\\"", "", "", "", "", "", // 0x20 |
| 93 | "", "", "", "", "", "", "", "", |
| 94 | "", "", "", "", "", "", "", "", // 0x30 |
| 95 | "", "", "", "", "\\u003c", "", "\\u003e", "", |
| 96 | "", "", "", "", "", "", "", "", // 0x40 |
| 97 | "", "", "", "", "", "", "", "", |
| 98 | "", "", "", "", "", "", "", "", // 0x50 |
| 99 | "", "", "", "", "\\\\", "", "", "", |
| 100 | "", "", "", "", "", "", "", "", // 0x60 |
| 101 | "", "", "", "", "", "", "", "", |
| 102 | "", "", "", "", "", "", "", "", // 0x70 |
| 103 | "", "", "", "", "", "", "", "\\u007f", |
| 104 | // C1 (ISO 8859 and Unicode) extended control characters |
| 105 | "\\u0080", "\\u0081", "\\u0082", "\\u0083", // 0x80 |
| 106 | "\\u0084", "\\u0085", "\\u0086", "\\u0087", |
| 107 | "\\u0088", "\\u0089", "\\u008a", "\\u008b", |
| 108 | "\\u008c", "\\u008d", "\\u008e", "\\u008f", |
| 109 | "\\u0090", "\\u0091", "\\u0092", "\\u0093", // 0x90 |
| 110 | "\\u0094", "\\u0095", "\\u0096", "\\u0097", |
| 111 | "\\u0098", "\\u0099", "\\u009a", "\\u009b", |
| 112 | "\\u009c", "\\u009d", "\\u009e", "\\u009f" |
| 113 | }; |
| 114 | |
| 115 | static JsonFormatter() |
| 116 | { |
| 117 | for (int i = 0; i < CommonRepresentations.Length; i++) |
| 118 | { |
| 119 | if (CommonRepresentations[i] == "") |
| 120 | { |
| 121 | CommonRepresentations[i] = ((char) i).ToString(); |
| 122 | } |
| 123 | } |
| 124 | } |
| 125 | |
| 126 | private readonly Settings settings; |
| 127 | |
Jon Skeet | dd43dcc | 2016-01-20 18:43:00 +0000 | [diff] [blame] | 128 | private bool DiagnosticOnly => ReferenceEquals(this, diagnosticFormatter); |
| 129 | |
Jon Skeet | 811fc89 | 2015-08-04 15:58:39 +0100 | [diff] [blame] | 130 | /// <summary> |
| 131 | /// Creates a new formatted with the given settings. |
| 132 | /// </summary> |
| 133 | /// <param name="settings">The settings.</param> |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 134 | public JsonFormatter(Settings settings) |
| 135 | { |
| 136 | this.settings = settings; |
| 137 | } |
| 138 | |
Jon Skeet | 811fc89 | 2015-08-04 15:58:39 +0100 | [diff] [blame] | 139 | /// <summary> |
| 140 | /// Formats the specified message as JSON. |
| 141 | /// </summary> |
| 142 | /// <param name="message">The message to format.</param> |
| 143 | /// <returns>The formatted message.</returns> |
Jon Skeet | 53c399a | 2015-07-20 19:24:31 +0100 | [diff] [blame] | 144 | public string Format(IMessage message) |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 145 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 146 | var writer = new StringWriter(); |
| 147 | Format(message, writer); |
| 148 | return writer.ToString(); |
| 149 | } |
| 150 | |
| 151 | /// <summary> |
| 152 | /// Formats the specified message as JSON. |
| 153 | /// </summary> |
| 154 | /// <param name="message">The message to format.</param> |
| 155 | /// <param name="writer">The TextWriter to write the formatted message to.</param> |
| 156 | /// <returns>The formatted message.</returns> |
| 157 | public void Format(IMessage message, TextWriter writer) |
| 158 | { |
Jon Skeet | 7762f16 | 2016-02-04 06:51:54 +0000 | [diff] [blame] | 159 | ProtoPreconditions.CheckNotNull(message, nameof(message)); |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 160 | ProtoPreconditions.CheckNotNull(writer, nameof(writer)); |
| 161 | |
Jon Skeet | 16e272e | 2015-07-31 13:22:15 +0100 | [diff] [blame] | 162 | if (message.Descriptor.IsWellKnownType) |
| 163 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 164 | WriteWellKnownTypeValue(writer, message.Descriptor, message); |
Jon Skeet | 16e272e | 2015-07-31 13:22:15 +0100 | [diff] [blame] | 165 | } |
| 166 | else |
| 167 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 168 | WriteMessage(writer, message); |
Jon Skeet | 16e272e | 2015-07-31 13:22:15 +0100 | [diff] [blame] | 169 | } |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 170 | } |
| 171 | |
Jon Skeet | aabc6c4 | 2015-12-15 09:23:38 +0000 | [diff] [blame] | 172 | /// <summary> |
| 173 | /// Converts a message to JSON for diagnostic purposes with no extra context. |
| 174 | /// </summary> |
| 175 | /// <remarks> |
| 176 | /// <para> |
| 177 | /// This differs from calling <see cref="Format(IMessage)"/> on the default JSON |
| 178 | /// formatter in its handling of <see cref="Any"/>. As no type registry is available |
| 179 | /// in <see cref="object.ToString"/> calls, the normal way of resolving the type of |
| 180 | /// an <c>Any</c> message cannot be applied. Instead, a JSON property named <c>@value</c> |
| 181 | /// is included with the base64 data from the <see cref="Any.Value"/> property of the message. |
| 182 | /// </para> |
| 183 | /// <para>The value returned by this method is only designed to be used for diagnostic |
| 184 | /// purposes. It may not be parsable by <see cref="JsonParser"/>, and may not be parsable |
| 185 | /// by other Protocol Buffer implementations.</para> |
| 186 | /// </remarks> |
| 187 | /// <param name="message">The message to format for diagnostic purposes.</param> |
| 188 | /// <returns>The diagnostic-only JSON representation of the message</returns> |
| 189 | public static string ToDiagnosticString(IMessage message) |
| 190 | { |
Jon Skeet | 7762f16 | 2016-02-04 06:51:54 +0000 | [diff] [blame] | 191 | ProtoPreconditions.CheckNotNull(message, nameof(message)); |
Jon Skeet | aabc6c4 | 2015-12-15 09:23:38 +0000 | [diff] [blame] | 192 | return diagnosticFormatter.Format(message); |
| 193 | } |
| 194 | |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 195 | private void WriteMessage(TextWriter writer, IMessage message) |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 196 | { |
| 197 | if (message == null) |
| 198 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 199 | WriteNull(writer); |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 200 | return; |
| 201 | } |
Jon Skeet | dd43dcc | 2016-01-20 18:43:00 +0000 | [diff] [blame] | 202 | if (DiagnosticOnly) |
Jon Skeet | 5dba7d7 | 2016-01-06 11:12:56 +0000 | [diff] [blame] | 203 | { |
| 204 | ICustomDiagnosticMessage customDiagnosticMessage = message as ICustomDiagnosticMessage; |
| 205 | if (customDiagnosticMessage != null) |
| 206 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 207 | writer.Write(customDiagnosticMessage.ToDiagnosticString()); |
Jon Skeet | 5dba7d7 | 2016-01-06 11:12:56 +0000 | [diff] [blame] | 208 | return; |
| 209 | } |
| 210 | } |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 211 | writer.Write("{ "); |
| 212 | bool writtenFields = WriteMessageFields(writer, message, false); |
| 213 | writer.Write(writtenFields ? " }" : "}"); |
Jon Skeet | 567579b | 2015-11-23 12:43:54 +0000 | [diff] [blame] | 214 | } |
| 215 | |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 216 | private bool WriteMessageFields(TextWriter writer, IMessage message, bool assumeFirstFieldWritten) |
Jon Skeet | 567579b | 2015-11-23 12:43:54 +0000 | [diff] [blame] | 217 | { |
Jon Skeet | 53c399a | 2015-07-20 19:24:31 +0100 | [diff] [blame] | 218 | var fields = message.Descriptor.Fields; |
Jon Skeet | 567579b | 2015-11-23 12:43:54 +0000 | [diff] [blame] | 219 | bool first = !assumeFirstFieldWritten; |
Jon Skeet | 6ea9bc7 | 2015-07-10 14:05:52 +0100 | [diff] [blame] | 220 | // First non-oneof fields |
Jon Skeet | c1c6b2d | 2015-07-22 19:57:29 +0100 | [diff] [blame] | 221 | foreach (var field in fields.InFieldNumberOrder()) |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 222 | { |
Jon Skeet | 53c399a | 2015-07-20 19:24:31 +0100 | [diff] [blame] | 223 | var accessor = field.Accessor; |
Jon Skeet | 4fed0b5 | 2015-07-31 10:33:31 +0100 | [diff] [blame] | 224 | if (field.ContainingOneof != null && field.ContainingOneof.Accessor.GetCaseFieldDescriptor(message) != field) |
Jon Skeet | 6ea9bc7 | 2015-07-10 14:05:52 +0100 | [diff] [blame] | 225 | { |
| 226 | continue; |
| 227 | } |
Jon Skeet | 4fed0b5 | 2015-07-31 10:33:31 +0100 | [diff] [blame] | 228 | // Omit default values unless we're asked to format them, or they're oneofs (where the default |
| 229 | // value is still formatted regardless, because that's how we preserve the oneof case). |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 230 | object value = accessor.GetValue(message); |
Jon Skeet | 4fed0b5 | 2015-07-31 10:33:31 +0100 | [diff] [blame] | 231 | if (field.ContainingOneof == null && !settings.FormatDefaultValues && IsDefaultValue(accessor, value)) |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 232 | { |
| 233 | continue; |
| 234 | } |
Jon Skeet | 6ea9bc7 | 2015-07-10 14:05:52 +0100 | [diff] [blame] | 235 | |
| 236 | // Okay, all tests complete: let's write the field value... |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 237 | if (!first) |
| 238 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 239 | writer.Write(PropertySeparator); |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 240 | } |
alien | 0d32ab3 | 2016-03-17 15:19:04 +0300 | [diff] [blame] | 241 | |
alien | 6f8dd21 | 2016-03-29 20:56:32 +0300 | [diff] [blame] | 242 | WriteString(writer, accessor.Descriptor.JsonName); |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 243 | writer.Write(NameValueSeparator); |
| 244 | WriteValue(writer, value); |
alien | 0d32ab3 | 2016-03-17 15:19:04 +0300 | [diff] [blame] | 245 | |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 246 | first = false; |
alien | 0d32ab3 | 2016-03-17 15:19:04 +0300 | [diff] [blame] | 247 | } |
Jon Skeet | 567579b | 2015-11-23 12:43:54 +0000 | [diff] [blame] | 248 | return !first; |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 249 | } |
| 250 | |
Jon Skeet | f437b67 | 2016-01-15 12:02:07 +0000 | [diff] [blame] | 251 | /// <summary> |
| 252 | /// Camel-case converter with added strictness for field mask formatting. |
| 253 | /// </summary> |
| 254 | /// <exception cref="InvalidOperationException">The field mask is invalid for JSON representation</exception> |
| 255 | private static string ToCamelCaseForFieldMask(string input) |
| 256 | { |
| 257 | for (int i = 0; i < input.Length; i++) |
| 258 | { |
| 259 | char c = input[i]; |
| 260 | if (c >= 'A' && c <= 'Z') |
| 261 | { |
| 262 | throw new InvalidOperationException($"Invalid field mask to be converted to JSON: {input}"); |
| 263 | } |
| 264 | if (c == '_' && i < input.Length - 1) |
| 265 | { |
| 266 | char next = input[i + 1]; |
| 267 | if (next < 'a' || next > 'z') |
| 268 | { |
| 269 | throw new InvalidOperationException($"Invalid field mask to be converted to JSON: {input}"); |
| 270 | } |
| 271 | } |
| 272 | } |
| 273 | return ToCamelCase(input); |
| 274 | } |
| 275 | |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 276 | // Converted from src/google/protobuf/util/internal/utility.cc ToCamelCase |
Jon Skeet | fb24882 | 2015-09-04 12:41:14 +0100 | [diff] [blame] | 277 | // TODO: Use the new field in FieldDescriptor. |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 278 | internal static string ToCamelCase(string input) |
| 279 | { |
| 280 | bool capitalizeNext = false; |
| 281 | bool wasCap = true; |
| 282 | bool isCap = false; |
| 283 | bool firstWord = true; |
| 284 | StringBuilder result = new StringBuilder(input.Length); |
| 285 | |
| 286 | for (int i = 0; i < input.Length; i++, wasCap = isCap) |
| 287 | { |
| 288 | isCap = char.IsUpper(input[i]); |
| 289 | if (input[i] == '_') |
| 290 | { |
| 291 | capitalizeNext = true; |
| 292 | if (result.Length != 0) |
| 293 | { |
| 294 | firstWord = false; |
| 295 | } |
| 296 | continue; |
| 297 | } |
| 298 | else if (firstWord) |
| 299 | { |
| 300 | // Consider when the current character B is capitalized, |
| 301 | // first word ends when: |
| 302 | // 1) following a lowercase: "...aB..." |
| 303 | // 2) followed by a lowercase: "...ABc..." |
| 304 | if (result.Length != 0 && isCap && |
| 305 | (!wasCap || (i + 1 < input.Length && char.IsLower(input[i + 1])))) |
| 306 | { |
| 307 | firstWord = false; |
| 308 | } |
| 309 | else |
| 310 | { |
| 311 | result.Append(char.ToLowerInvariant(input[i])); |
| 312 | continue; |
| 313 | } |
| 314 | } |
| 315 | else if (capitalizeNext) |
| 316 | { |
| 317 | capitalizeNext = false; |
| 318 | if (char.IsLower(input[i])) |
| 319 | { |
| 320 | result.Append(char.ToUpperInvariant(input[i])); |
| 321 | continue; |
| 322 | } |
| 323 | } |
| 324 | result.Append(input[i]); |
| 325 | } |
| 326 | return result.ToString(); |
| 327 | } |
| 328 | |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 329 | private static void WriteNull(TextWriter writer) |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 330 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 331 | writer.Write("null"); |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 332 | } |
| 333 | |
| 334 | private static bool IsDefaultValue(IFieldAccessor accessor, object value) |
| 335 | { |
| 336 | if (accessor.Descriptor.IsMap) |
| 337 | { |
| 338 | IDictionary dictionary = (IDictionary) value; |
| 339 | return dictionary.Count == 0; |
| 340 | } |
| 341 | if (accessor.Descriptor.IsRepeated) |
| 342 | { |
| 343 | IList list = (IList) value; |
| 344 | return list.Count == 0; |
| 345 | } |
| 346 | switch (accessor.Descriptor.FieldType) |
| 347 | { |
| 348 | case FieldType.Bool: |
| 349 | return (bool) value == false; |
| 350 | case FieldType.Bytes: |
| 351 | return (ByteString) value == ByteString.Empty; |
| 352 | case FieldType.String: |
| 353 | return (string) value == ""; |
| 354 | case FieldType.Double: |
| 355 | return (double) value == 0.0; |
| 356 | case FieldType.SInt32: |
| 357 | case FieldType.Int32: |
| 358 | case FieldType.SFixed32: |
| 359 | case FieldType.Enum: |
| 360 | return (int) value == 0; |
| 361 | case FieldType.Fixed32: |
| 362 | case FieldType.UInt32: |
| 363 | return (uint) value == 0; |
| 364 | case FieldType.Fixed64: |
| 365 | case FieldType.UInt64: |
| 366 | return (ulong) value == 0; |
| 367 | case FieldType.SFixed64: |
| 368 | case FieldType.Int64: |
| 369 | case FieldType.SInt64: |
| 370 | return (long) value == 0; |
| 371 | case FieldType.Float: |
| 372 | return (float) value == 0f; |
| 373 | case FieldType.Message: |
| 374 | case FieldType.Group: // Never expect to get this, but... |
| 375 | return value == null; |
| 376 | default: |
| 377 | throw new ArgumentException("Invalid field type"); |
| 378 | } |
| 379 | } |
Jon Skeet | 9ed6d4d | 2015-09-28 17:28:02 +0100 | [diff] [blame] | 380 | |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 381 | private void WriteValue(TextWriter writer, object value) |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 382 | { |
Jon Skeet | 9ed6d4d | 2015-09-28 17:28:02 +0100 | [diff] [blame] | 383 | if (value == null) |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 384 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 385 | WriteNull(writer); |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 386 | } |
Jon Skeet | 9ed6d4d | 2015-09-28 17:28:02 +0100 | [diff] [blame] | 387 | else if (value is bool) |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 388 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 389 | writer.Write((bool)value ? "true" : "false"); |
Jon Skeet | 9ed6d4d | 2015-09-28 17:28:02 +0100 | [diff] [blame] | 390 | } |
| 391 | else if (value is ByteString) |
| 392 | { |
| 393 | // Nothing in Base64 needs escaping |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 394 | writer.Write('"'); |
| 395 | writer.Write(((ByteString)value).ToBase64()); |
| 396 | writer.Write('"'); |
Jon Skeet | 9ed6d4d | 2015-09-28 17:28:02 +0100 | [diff] [blame] | 397 | } |
| 398 | else if (value is string) |
| 399 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 400 | WriteString(writer, (string)value); |
Jon Skeet | 9ed6d4d | 2015-09-28 17:28:02 +0100 | [diff] [blame] | 401 | } |
| 402 | else if (value is IDictionary) |
| 403 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 404 | WriteDictionary(writer, (IDictionary)value); |
Jon Skeet | 9ed6d4d | 2015-09-28 17:28:02 +0100 | [diff] [blame] | 405 | } |
| 406 | else if (value is IList) |
| 407 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 408 | WriteList(writer, (IList)value); |
Jon Skeet | 9ed6d4d | 2015-09-28 17:28:02 +0100 | [diff] [blame] | 409 | } |
| 410 | else if (value is int || value is uint) |
| 411 | { |
| 412 | IFormattable formattable = (IFormattable) value; |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 413 | writer.Write(formattable.ToString("d", CultureInfo.InvariantCulture)); |
Jon Skeet | 9ed6d4d | 2015-09-28 17:28:02 +0100 | [diff] [blame] | 414 | } |
| 415 | else if (value is long || value is ulong) |
| 416 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 417 | writer.Write('"'); |
Jon Skeet | 9ed6d4d | 2015-09-28 17:28:02 +0100 | [diff] [blame] | 418 | IFormattable formattable = (IFormattable) value; |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 419 | writer.Write(formattable.ToString("d", CultureInfo.InvariantCulture)); |
| 420 | writer.Write('"'); |
Jon Skeet | 9ed6d4d | 2015-09-28 17:28:02 +0100 | [diff] [blame] | 421 | } |
| 422 | else if (value is System.Enum) |
| 423 | { |
Jon Skeet | 790f4c8 | 2016-04-08 13:22:42 +0100 | [diff] [blame] | 424 | string name = OriginalEnumValueHelper.GetOriginalName(value); |
| 425 | if (name != null) |
Jon Skeet | 52db513 | 2016-01-15 13:45:53 +0000 | [diff] [blame] | 426 | { |
Jon Skeet | 790f4c8 | 2016-04-08 13:22:42 +0100 | [diff] [blame] | 427 | WriteString(writer, name); |
Jon Skeet | 52db513 | 2016-01-15 13:45:53 +0000 | [diff] [blame] | 428 | } |
| 429 | else |
| 430 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 431 | WriteValue(writer, (int)value); |
Jon Skeet | 52db513 | 2016-01-15 13:45:53 +0000 | [diff] [blame] | 432 | } |
Jon Skeet | 9ed6d4d | 2015-09-28 17:28:02 +0100 | [diff] [blame] | 433 | } |
| 434 | else if (value is float || value is double) |
| 435 | { |
| 436 | string text = ((IFormattable) value).ToString("r", CultureInfo.InvariantCulture); |
| 437 | if (text == "NaN" || text == "Infinity" || text == "-Infinity") |
| 438 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 439 | writer.Write('"'); |
| 440 | writer.Write(text); |
| 441 | writer.Write('"'); |
Jon Skeet | 9ed6d4d | 2015-09-28 17:28:02 +0100 | [diff] [blame] | 442 | } |
| 443 | else |
| 444 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 445 | writer.Write(text); |
Jon Skeet | 9ed6d4d | 2015-09-28 17:28:02 +0100 | [diff] [blame] | 446 | } |
| 447 | } |
| 448 | else if (value is IMessage) |
| 449 | { |
| 450 | IMessage message = (IMessage) value; |
| 451 | if (message.Descriptor.IsWellKnownType) |
| 452 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 453 | WriteWellKnownTypeValue(writer, message.Descriptor, value); |
Jon Skeet | 9ed6d4d | 2015-09-28 17:28:02 +0100 | [diff] [blame] | 454 | } |
| 455 | else |
| 456 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 457 | WriteMessage(writer, (IMessage)value); |
Jon Skeet | 9ed6d4d | 2015-09-28 17:28:02 +0100 | [diff] [blame] | 458 | } |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 459 | } |
| 460 | else |
| 461 | { |
Jon Skeet | 9ed6d4d | 2015-09-28 17:28:02 +0100 | [diff] [blame] | 462 | throw new ArgumentException("Unable to format value of type " + value.GetType()); |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 463 | } |
| 464 | } |
| 465 | |
Jon Skeet | c9fd53a | 2015-07-20 11:48:24 +0100 | [diff] [blame] | 466 | /// <summary> |
| 467 | /// Central interception point for well-known type formatting. Any well-known types which |
Jon Skeet | 16e272e | 2015-07-31 13:22:15 +0100 | [diff] [blame] | 468 | /// don't need special handling can fall back to WriteMessage. We avoid assuming that the |
| 469 | /// values are using the embedded well-known types, in order to allow for dynamic messages |
| 470 | /// in the future. |
Jon Skeet | c9fd53a | 2015-07-20 11:48:24 +0100 | [diff] [blame] | 471 | /// </summary> |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 472 | private void WriteWellKnownTypeValue(TextWriter writer, MessageDescriptor descriptor, object value) |
Jon Skeet | c9fd53a | 2015-07-20 11:48:24 +0100 | [diff] [blame] | 473 | { |
Jon Skeet | 567579b | 2015-11-23 12:43:54 +0000 | [diff] [blame] | 474 | // Currently, we can never actually get here, because null values are always handled by the caller. But if we *could*, |
| 475 | // this would do the right thing. |
Jon Skeet | e7caf15 | 2015-07-31 15:07:50 +0100 | [diff] [blame] | 476 | if (value == null) |
| 477 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 478 | WriteNull(writer); |
Jon Skeet | e7caf15 | 2015-07-31 15:07:50 +0100 | [diff] [blame] | 479 | return; |
| 480 | } |
Jon Skeet | fb24882 | 2015-09-04 12:41:14 +0100 | [diff] [blame] | 481 | // For wrapper types, the value will either be the (possibly boxed) "native" value, |
| 482 | // or the message itself if we're formatting it at the top level (e.g. just calling ToString on the object itself). |
| 483 | // If it's the message form, we can extract the value first, which *will* be the (possibly boxed) native value, |
| 484 | // and then proceed, writing it as if we were definitely in a field. (We never need to wrap it in an extra string... |
| 485 | // WriteValue will do the right thing.) |
Jon Skeet | 72ec336 | 2015-11-19 17:13:38 +0000 | [diff] [blame] | 486 | if (descriptor.IsWrapperType) |
Jon Skeet | c9fd53a | 2015-07-20 11:48:24 +0100 | [diff] [blame] | 487 | { |
Jon Skeet | fb24882 | 2015-09-04 12:41:14 +0100 | [diff] [blame] | 488 | if (value is IMessage) |
| 489 | { |
| 490 | var message = (IMessage) value; |
Jon Skeet | 284bb45 | 2015-11-05 09:13:53 +0000 | [diff] [blame] | 491 | value = message.Descriptor.Fields[WrappersReflection.WrapperValueFieldNumber].Accessor.GetValue(message); |
Jon Skeet | fb24882 | 2015-09-04 12:41:14 +0100 | [diff] [blame] | 492 | } |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 493 | WriteValue(writer, value); |
Jon Skeet | 16e272e | 2015-07-31 13:22:15 +0100 | [diff] [blame] | 494 | return; |
| 495 | } |
Jon Skeet | e7caf15 | 2015-07-31 15:07:50 +0100 | [diff] [blame] | 496 | if (descriptor.FullName == Timestamp.Descriptor.FullName) |
Jon Skeet | 16e272e | 2015-07-31 13:22:15 +0100 | [diff] [blame] | 497 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 498 | WriteTimestamp(writer, (IMessage)value); |
Jon Skeet | 16e272e | 2015-07-31 13:22:15 +0100 | [diff] [blame] | 499 | return; |
| 500 | } |
Jon Skeet | e7caf15 | 2015-07-31 15:07:50 +0100 | [diff] [blame] | 501 | if (descriptor.FullName == Duration.Descriptor.FullName) |
Jon Skeet | 16e272e | 2015-07-31 13:22:15 +0100 | [diff] [blame] | 502 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 503 | WriteDuration(writer, (IMessage)value); |
Jon Skeet | c9fd53a | 2015-07-20 11:48:24 +0100 | [diff] [blame] | 504 | return; |
| 505 | } |
Jon Skeet | 0e30de3 | 2015-08-03 11:43:07 +0100 | [diff] [blame] | 506 | if (descriptor.FullName == FieldMask.Descriptor.FullName) |
| 507 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 508 | WriteFieldMask(writer, (IMessage)value); |
Jon Skeet | 0e30de3 | 2015-08-03 11:43:07 +0100 | [diff] [blame] | 509 | return; |
| 510 | } |
Jon Skeet | e7caf15 | 2015-07-31 15:07:50 +0100 | [diff] [blame] | 511 | if (descriptor.FullName == Struct.Descriptor.FullName) |
| 512 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 513 | WriteStruct(writer, (IMessage)value); |
Jon Skeet | e7caf15 | 2015-07-31 15:07:50 +0100 | [diff] [blame] | 514 | return; |
| 515 | } |
| 516 | if (descriptor.FullName == ListValue.Descriptor.FullName) |
| 517 | { |
| 518 | var fieldAccessor = descriptor.Fields[ListValue.ValuesFieldNumber].Accessor; |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 519 | WriteList(writer, (IList)fieldAccessor.GetValue((IMessage)value)); |
Jon Skeet | e7caf15 | 2015-07-31 15:07:50 +0100 | [diff] [blame] | 520 | return; |
| 521 | } |
| 522 | if (descriptor.FullName == Value.Descriptor.FullName) |
| 523 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 524 | WriteStructFieldValue(writer, (IMessage)value); |
Jon Skeet | e7caf15 | 2015-07-31 15:07:50 +0100 | [diff] [blame] | 525 | return; |
| 526 | } |
Jon Skeet | 567579b | 2015-11-23 12:43:54 +0000 | [diff] [blame] | 527 | if (descriptor.FullName == Any.Descriptor.FullName) |
| 528 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 529 | WriteAny(writer, (IMessage)value); |
Jon Skeet | 567579b | 2015-11-23 12:43:54 +0000 | [diff] [blame] | 530 | return; |
| 531 | } |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 532 | WriteMessage(writer, (IMessage)value); |
Jon Skeet | c9fd53a | 2015-07-20 11:48:24 +0100 | [diff] [blame] | 533 | } |
| 534 | |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 535 | private void WriteTimestamp(TextWriter writer, IMessage value) |
Jon Skeet | 16e272e | 2015-07-31 13:22:15 +0100 | [diff] [blame] | 536 | { |
| 537 | // TODO: In the common case where this *is* using the built-in Timestamp type, we could |
| 538 | // avoid all the reflection at this point, by casting to Timestamp. In the interests of |
| 539 | // avoiding subtle bugs, don't do that until we've implemented DynamicMessage so that we can prove |
| 540 | // it still works in that case. |
| 541 | int nanos = (int) value.Descriptor.Fields[Timestamp.NanosFieldNumber].Accessor.GetValue(value); |
| 542 | long seconds = (long) value.Descriptor.Fields[Timestamp.SecondsFieldNumber].Accessor.GetValue(value); |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 543 | writer.Write(Timestamp.ToJson(seconds, nanos, DiagnosticOnly)); |
Jon Skeet | 16e272e | 2015-07-31 13:22:15 +0100 | [diff] [blame] | 544 | } |
| 545 | |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 546 | private void WriteDuration(TextWriter writer, IMessage value) |
Jon Skeet | 16e272e | 2015-07-31 13:22:15 +0100 | [diff] [blame] | 547 | { |
Jon Skeet | 801b169 | 2015-08-03 08:45:48 +0100 | [diff] [blame] | 548 | // TODO: Same as for WriteTimestamp |
Jon Skeet | 16e272e | 2015-07-31 13:22:15 +0100 | [diff] [blame] | 549 | int nanos = (int) value.Descriptor.Fields[Duration.NanosFieldNumber].Accessor.GetValue(value); |
| 550 | long seconds = (long) value.Descriptor.Fields[Duration.SecondsFieldNumber].Accessor.GetValue(value); |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 551 | writer.Write(Duration.ToJson(seconds, nanos, DiagnosticOnly)); |
Jon Skeet | 801b169 | 2015-08-03 08:45:48 +0100 | [diff] [blame] | 552 | } |
| 553 | |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 554 | private void WriteFieldMask(TextWriter writer, IMessage value) |
Jon Skeet | 0e30de3 | 2015-08-03 11:43:07 +0100 | [diff] [blame] | 555 | { |
Jon Skeet | dd43dcc | 2016-01-20 18:43:00 +0000 | [diff] [blame] | 556 | var paths = (IList<string>) value.Descriptor.Fields[FieldMask.PathsFieldNumber].Accessor.GetValue(value); |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 557 | writer.Write(FieldMask.ToJson(paths, DiagnosticOnly)); |
Jon Skeet | 0e30de3 | 2015-08-03 11:43:07 +0100 | [diff] [blame] | 558 | } |
| 559 | |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 560 | private void WriteAny(TextWriter writer, IMessage value) |
Jon Skeet | 567579b | 2015-11-23 12:43:54 +0000 | [diff] [blame] | 561 | { |
Jon Skeet | dd43dcc | 2016-01-20 18:43:00 +0000 | [diff] [blame] | 562 | if (DiagnosticOnly) |
Jon Skeet | aabc6c4 | 2015-12-15 09:23:38 +0000 | [diff] [blame] | 563 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 564 | WriteDiagnosticOnlyAny(writer, value); |
Jon Skeet | aabc6c4 | 2015-12-15 09:23:38 +0000 | [diff] [blame] | 565 | return; |
| 566 | } |
| 567 | |
Jon Skeet | 567579b | 2015-11-23 12:43:54 +0000 | [diff] [blame] | 568 | string typeUrl = (string) value.Descriptor.Fields[Any.TypeUrlFieldNumber].Accessor.GetValue(value); |
| 569 | ByteString data = (ByteString) value.Descriptor.Fields[Any.ValueFieldNumber].Accessor.GetValue(value); |
| 570 | string typeName = GetTypeName(typeUrl); |
| 571 | MessageDescriptor descriptor = settings.TypeRegistry.Find(typeName); |
| 572 | if (descriptor == null) |
| 573 | { |
| 574 | throw new InvalidOperationException($"Type registry has no descriptor for type name '{typeName}'"); |
| 575 | } |
| 576 | IMessage message = descriptor.Parser.ParseFrom(data); |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 577 | writer.Write("{ "); |
| 578 | WriteString(writer, AnyTypeUrlField); |
| 579 | writer.Write(NameValueSeparator); |
| 580 | WriteString(writer, typeUrl); |
Jon Skeet | 567579b | 2015-11-23 12:43:54 +0000 | [diff] [blame] | 581 | |
| 582 | if (descriptor.IsWellKnownType) |
| 583 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 584 | writer.Write(PropertySeparator); |
| 585 | WriteString(writer, AnyWellKnownTypeValueField); |
| 586 | writer.Write(NameValueSeparator); |
| 587 | WriteWellKnownTypeValue(writer, descriptor, message); |
Jon Skeet | 567579b | 2015-11-23 12:43:54 +0000 | [diff] [blame] | 588 | } |
| 589 | else |
| 590 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 591 | WriteMessageFields(writer, message, true); |
Jon Skeet | 567579b | 2015-11-23 12:43:54 +0000 | [diff] [blame] | 592 | } |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 593 | writer.Write(" }"); |
Jon Skeet | 567579b | 2015-11-23 12:43:54 +0000 | [diff] [blame] | 594 | } |
| 595 | |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 596 | private void WriteDiagnosticOnlyAny(TextWriter writer, IMessage value) |
Jon Skeet | aabc6c4 | 2015-12-15 09:23:38 +0000 | [diff] [blame] | 597 | { |
| 598 | string typeUrl = (string) value.Descriptor.Fields[Any.TypeUrlFieldNumber].Accessor.GetValue(value); |
| 599 | ByteString data = (ByteString) value.Descriptor.Fields[Any.ValueFieldNumber].Accessor.GetValue(value); |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 600 | writer.Write("{ "); |
| 601 | WriteString(writer, AnyTypeUrlField); |
| 602 | writer.Write(NameValueSeparator); |
| 603 | WriteString(writer, typeUrl); |
| 604 | writer.Write(PropertySeparator); |
| 605 | WriteString(writer, AnyDiagnosticValueField); |
| 606 | writer.Write(NameValueSeparator); |
| 607 | writer.Write('"'); |
| 608 | writer.Write(data.ToBase64()); |
| 609 | writer.Write('"'); |
| 610 | writer.Write(" }"); |
Jon Skeet | aabc6c4 | 2015-12-15 09:23:38 +0000 | [diff] [blame] | 611 | } |
| 612 | |
Jon Skeet | 567579b | 2015-11-23 12:43:54 +0000 | [diff] [blame] | 613 | internal static string GetTypeName(String typeUrl) |
| 614 | { |
| 615 | string[] parts = typeUrl.Split('/'); |
| 616 | if (parts.Length != 2 || parts[0] != TypeUrlPrefix) |
| 617 | { |
| 618 | throw new InvalidProtocolBufferException($"Invalid type url: {typeUrl}"); |
| 619 | } |
| 620 | return parts[1]; |
| 621 | } |
| 622 | |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 623 | private void WriteStruct(TextWriter writer, IMessage message) |
Jon Skeet | e7caf15 | 2015-07-31 15:07:50 +0100 | [diff] [blame] | 624 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 625 | writer.Write("{ "); |
Jon Skeet | e7caf15 | 2015-07-31 15:07:50 +0100 | [diff] [blame] | 626 | IDictionary fields = (IDictionary) message.Descriptor.Fields[Struct.FieldsFieldNumber].Accessor.GetValue(message); |
| 627 | bool first = true; |
| 628 | foreach (DictionaryEntry entry in fields) |
| 629 | { |
| 630 | string key = (string) entry.Key; |
| 631 | IMessage value = (IMessage) entry.Value; |
| 632 | if (string.IsNullOrEmpty(key) || value == null) |
| 633 | { |
| 634 | throw new InvalidOperationException("Struct fields cannot have an empty key or a null value."); |
| 635 | } |
| 636 | |
| 637 | if (!first) |
| 638 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 639 | writer.Write(PropertySeparator); |
Jon Skeet | e7caf15 | 2015-07-31 15:07:50 +0100 | [diff] [blame] | 640 | } |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 641 | WriteString(writer, key); |
| 642 | writer.Write(NameValueSeparator); |
| 643 | WriteStructFieldValue(writer, value); |
Jon Skeet | e7caf15 | 2015-07-31 15:07:50 +0100 | [diff] [blame] | 644 | first = false; |
| 645 | } |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 646 | writer.Write(first ? "}" : " }"); |
Jon Skeet | e7caf15 | 2015-07-31 15:07:50 +0100 | [diff] [blame] | 647 | } |
| 648 | |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 649 | private void WriteStructFieldValue(TextWriter writer, IMessage message) |
Jon Skeet | e7caf15 | 2015-07-31 15:07:50 +0100 | [diff] [blame] | 650 | { |
| 651 | var specifiedField = message.Descriptor.Oneofs[0].Accessor.GetCaseFieldDescriptor(message); |
| 652 | if (specifiedField == null) |
| 653 | { |
| 654 | throw new InvalidOperationException("Value message must contain a value for the oneof."); |
| 655 | } |
| 656 | |
| 657 | object value = specifiedField.Accessor.GetValue(message); |
| 658 | |
| 659 | switch (specifiedField.FieldNumber) |
| 660 | { |
| 661 | case Value.BoolValueFieldNumber: |
| 662 | case Value.StringValueFieldNumber: |
| 663 | case Value.NumberValueFieldNumber: |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 664 | WriteValue(writer, value); |
Jon Skeet | e7caf15 | 2015-07-31 15:07:50 +0100 | [diff] [blame] | 665 | return; |
| 666 | case Value.StructValueFieldNumber: |
| 667 | case Value.ListValueFieldNumber: |
| 668 | // Structs and ListValues are nested messages, and already well-known types. |
| 669 | var nestedMessage = (IMessage) specifiedField.Accessor.GetValue(message); |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 670 | WriteWellKnownTypeValue(writer, nestedMessage.Descriptor, nestedMessage); |
Jon Skeet | e7caf15 | 2015-07-31 15:07:50 +0100 | [diff] [blame] | 671 | return; |
| 672 | case Value.NullValueFieldNumber: |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 673 | WriteNull(writer); |
Jon Skeet | e7caf15 | 2015-07-31 15:07:50 +0100 | [diff] [blame] | 674 | return; |
| 675 | default: |
| 676 | throw new InvalidOperationException("Unexpected case in struct field: " + specifiedField.FieldNumber); |
| 677 | } |
| 678 | } |
| 679 | |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 680 | internal void WriteList(TextWriter writer, IList list) |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 681 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 682 | writer.Write("[ "); |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 683 | bool first = true; |
| 684 | foreach (var value in list) |
| 685 | { |
| 686 | if (!first) |
| 687 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 688 | writer.Write(PropertySeparator); |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 689 | } |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 690 | WriteValue(writer, value); |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 691 | first = false; |
| 692 | } |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 693 | writer.Write(first ? "]" : " ]"); |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 694 | } |
| 695 | |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 696 | internal void WriteDictionary(TextWriter writer, IDictionary dictionary) |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 697 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 698 | writer.Write("{ "); |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 699 | bool first = true; |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 700 | // This will box each pair. Could use IDictionaryEnumerator, but that's ugly in terms of disposal. |
| 701 | foreach (DictionaryEntry pair in dictionary) |
| 702 | { |
| 703 | if (!first) |
| 704 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 705 | writer.Write(PropertySeparator); |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 706 | } |
| 707 | string keyText; |
Jon Skeet | 9ed6d4d | 2015-09-28 17:28:02 +0100 | [diff] [blame] | 708 | if (pair.Key is string) |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 709 | { |
Jon Skeet | 9ed6d4d | 2015-09-28 17:28:02 +0100 | [diff] [blame] | 710 | keyText = (string) pair.Key; |
| 711 | } |
| 712 | else if (pair.Key is bool) |
| 713 | { |
| 714 | keyText = (bool) pair.Key ? "true" : "false"; |
| 715 | } |
| 716 | else if (pair.Key is int || pair.Key is uint | pair.Key is long || pair.Key is ulong) |
| 717 | { |
| 718 | keyText = ((IFormattable) pair.Key).ToString("d", CultureInfo.InvariantCulture); |
| 719 | } |
| 720 | else |
| 721 | { |
| 722 | if (pair.Key == null) |
| 723 | { |
| 724 | throw new ArgumentException("Dictionary has entry with null key"); |
| 725 | } |
| 726 | throw new ArgumentException("Unhandled dictionary key type: " + pair.Key.GetType()); |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 727 | } |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 728 | WriteString(writer, keyText); |
| 729 | writer.Write(NameValueSeparator); |
| 730 | WriteValue(writer, pair.Value); |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 731 | first = false; |
| 732 | } |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 733 | writer.Write(first ? "}" : " }"); |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 734 | } |
| 735 | |
| 736 | /// <summary> |
Jon Skeet | 6ea9bc7 | 2015-07-10 14:05:52 +0100 | [diff] [blame] | 737 | /// Returns whether or not a singular value can be represented in JSON. |
| 738 | /// Currently only relevant for enums, where unknown values can't be represented. |
| 739 | /// For repeated/map fields, this always returns true. |
| 740 | /// </summary> |
Jon Skeet | 9ed6d4d | 2015-09-28 17:28:02 +0100 | [diff] [blame] | 741 | private bool CanWriteSingleValue(object value) |
Jon Skeet | 6ea9bc7 | 2015-07-10 14:05:52 +0100 | [diff] [blame] | 742 | { |
Jon Skeet | 9ed6d4d | 2015-09-28 17:28:02 +0100 | [diff] [blame] | 743 | if (value is System.Enum) |
Jon Skeet | 6ea9bc7 | 2015-07-10 14:05:52 +0100 | [diff] [blame] | 744 | { |
Jon Skeet | 9ed6d4d | 2015-09-28 17:28:02 +0100 | [diff] [blame] | 745 | return System.Enum.IsDefined(value.GetType(), value); |
Jon Skeet | 6ea9bc7 | 2015-07-10 14:05:52 +0100 | [diff] [blame] | 746 | } |
| 747 | return true; |
| 748 | } |
| 749 | |
| 750 | /// <summary> |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 751 | /// Writes a string (including leading and trailing double quotes) to a builder, escaping as required. |
| 752 | /// </summary> |
| 753 | /// <remarks> |
| 754 | /// Other than surrogate pair handling, this code is mostly taken from src/google/protobuf/util/internal/json_escaping.cc. |
| 755 | /// </remarks> |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 756 | internal static void WriteString(TextWriter writer, string text) |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 757 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 758 | writer.Write('"'); |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 759 | for (int i = 0; i < text.Length; i++) |
| 760 | { |
| 761 | char c = text[i]; |
| 762 | if (c < 0xa0) |
| 763 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 764 | writer.Write(CommonRepresentations[c]); |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 765 | continue; |
| 766 | } |
| 767 | if (char.IsHighSurrogate(c)) |
| 768 | { |
| 769 | // Encountered first part of a surrogate pair. |
| 770 | // Check that we have the whole pair, and encode both parts as hex. |
| 771 | i++; |
| 772 | if (i == text.Length || !char.IsLowSurrogate(text[i])) |
| 773 | { |
| 774 | throw new ArgumentException("String contains low surrogate not followed by high surrogate"); |
| 775 | } |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 776 | HexEncodeUtf16CodeUnit(writer, c); |
| 777 | HexEncodeUtf16CodeUnit(writer, text[i]); |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 778 | continue; |
| 779 | } |
| 780 | else if (char.IsLowSurrogate(c)) |
| 781 | { |
| 782 | throw new ArgumentException("String contains high surrogate not preceded by low surrogate"); |
| 783 | } |
| 784 | switch ((uint) c) |
| 785 | { |
| 786 | // These are not required by json spec |
| 787 | // but used to prevent security bugs in javascript. |
| 788 | case 0xfeff: // Zero width no-break space |
| 789 | case 0xfff9: // Interlinear annotation anchor |
| 790 | case 0xfffa: // Interlinear annotation separator |
| 791 | case 0xfffb: // Interlinear annotation terminator |
| 792 | |
| 793 | case 0x00ad: // Soft-hyphen |
| 794 | case 0x06dd: // Arabic end of ayah |
| 795 | case 0x070f: // Syriac abbreviation mark |
| 796 | case 0x17b4: // Khmer vowel inherent Aq |
| 797 | case 0x17b5: // Khmer vowel inherent Aa |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 798 | HexEncodeUtf16CodeUnit(writer, c); |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 799 | break; |
| 800 | |
| 801 | default: |
| 802 | if ((c >= 0x0600 && c <= 0x0603) || // Arabic signs |
| 803 | (c >= 0x200b && c <= 0x200f) || // Zero width etc. |
| 804 | (c >= 0x2028 && c <= 0x202e) || // Separators etc. |
| 805 | (c >= 0x2060 && c <= 0x2064) || // Invisible etc. |
| 806 | (c >= 0x206a && c <= 0x206f)) |
| 807 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 808 | HexEncodeUtf16CodeUnit(writer, c); |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 809 | } |
| 810 | else |
| 811 | { |
| 812 | // No handling of surrogates here - that's done earlier |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 813 | writer.Write(c); |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 814 | } |
| 815 | break; |
| 816 | } |
| 817 | } |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 818 | writer.Write('"'); |
Jon Skeet | 801b169 | 2015-08-03 08:45:48 +0100 | [diff] [blame] | 819 | } |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 820 | |
| 821 | private const string Hex = "0123456789abcdef"; |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 822 | private static void HexEncodeUtf16CodeUnit(TextWriter writer, char c) |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 823 | { |
avgweb | ad2d775 | 2016-03-06 17:50:02 -0800 | [diff] [blame] | 824 | writer.Write("\\u"); |
| 825 | writer.Write(Hex[(c >> 12) & 0xf]); |
| 826 | writer.Write(Hex[(c >> 8) & 0xf]); |
| 827 | writer.Write(Hex[(c >> 4) & 0xf]); |
| 828 | writer.Write(Hex[(c >> 0) & 0xf]); |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 829 | } |
| 830 | |
| 831 | /// <summary> |
| 832 | /// Settings controlling JSON formatting. |
| 833 | /// </summary> |
| 834 | public sealed class Settings |
| 835 | { |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 836 | /// <summary> |
| 837 | /// Default settings, as used by <see cref="JsonFormatter.Default"/> |
| 838 | /// </summary> |
Jon Skeet | 3de2fce | 2015-11-23 16:21:47 +0000 | [diff] [blame] | 839 | public static Settings Default { get; } |
| 840 | |
| 841 | // Workaround for the Mono compiler complaining about XML comments not being on |
| 842 | // valid language elements. |
| 843 | static Settings() |
| 844 | { |
| 845 | Default = new Settings(false); |
| 846 | } |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 847 | |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 848 | /// <summary> |
| 849 | /// Whether fields whose values are the default for the field type (e.g. 0 for integers) |
| 850 | /// should be formatted (true) or omitted (false). |
| 851 | /// </summary> |
Jon Skeet | 567579b | 2015-11-23 12:43:54 +0000 | [diff] [blame] | 852 | public bool FormatDefaultValues { get; } |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 853 | |
Jon Skeet | 811fc89 | 2015-08-04 15:58:39 +0100 | [diff] [blame] | 854 | /// <summary> |
Jon Skeet | 567579b | 2015-11-23 12:43:54 +0000 | [diff] [blame] | 855 | /// The type registry used to format <see cref="Any"/> messages. |
| 856 | /// </summary> |
| 857 | public TypeRegistry TypeRegistry { get; } |
| 858 | |
| 859 | // TODO: Work out how we're going to scale this to multiple settings. "WithXyz" methods? |
| 860 | |
| 861 | /// <summary> |
| 862 | /// Creates a new <see cref="Settings"/> object with the specified formatting of default values |
| 863 | /// and an empty type registry. |
Jon Skeet | 811fc89 | 2015-08-04 15:58:39 +0100 | [diff] [blame] | 864 | /// </summary> |
| 865 | /// <param name="formatDefaultValues"><c>true</c> if default values (0, empty strings etc) should be formatted; <c>false</c> otherwise.</param> |
Jon Skeet | 567579b | 2015-11-23 12:43:54 +0000 | [diff] [blame] | 866 | public Settings(bool formatDefaultValues) : this(formatDefaultValues, TypeRegistry.Empty) |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 867 | { |
Jon Skeet | 567579b | 2015-11-23 12:43:54 +0000 | [diff] [blame] | 868 | } |
| 869 | |
| 870 | /// <summary> |
| 871 | /// Creates a new <see cref="Settings"/> object with the specified formatting of default values |
| 872 | /// and type registry. |
| 873 | /// </summary> |
| 874 | /// <param name="formatDefaultValues"><c>true</c> if default values (0, empty strings etc) should be formatted; <c>false</c> otherwise.</param> |
| 875 | /// <param name="typeRegistry">The <see cref="TypeRegistry"/> to use when formatting <see cref="Any"/> messages.</param> |
| 876 | public Settings(bool formatDefaultValues, TypeRegistry typeRegistry) |
| 877 | { |
| 878 | FormatDefaultValues = formatDefaultValues; |
Jon Skeet | 7762f16 | 2016-02-04 06:51:54 +0000 | [diff] [blame] | 879 | TypeRegistry = ProtoPreconditions.CheckNotNull(typeRegistry, nameof(typeRegistry)); |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 880 | } |
| 881 | } |
Jon Skeet | 790f4c8 | 2016-04-08 13:22:42 +0100 | [diff] [blame] | 882 | |
| 883 | // Effectively a cache of mapping from enum values to the original name as specified in the proto file, |
| 884 | // fetched by reflection. |
| 885 | // The need for this is unfortunate, as is its unbounded size, but realistically it shouldn't cause issues. |
| 886 | private static class OriginalEnumValueHelper |
| 887 | { |
| 888 | // TODO: In the future we might want to use ConcurrentDictionary, at the point where all |
| 889 | // the platforms we target have it. |
| 890 | private static readonly Dictionary<System.Type, Dictionary<object, string>> dictionaries |
| 891 | = new Dictionary<System.Type, Dictionary<object, string>>(); |
| 892 | |
| 893 | internal static string GetOriginalName(object value) |
| 894 | { |
| 895 | var enumType = value.GetType(); |
| 896 | Dictionary<object, string> nameMapping; |
| 897 | lock (dictionaries) |
| 898 | { |
| 899 | if (!dictionaries.TryGetValue(enumType, out nameMapping)) |
| 900 | { |
| 901 | nameMapping = GetNameMapping(enumType); |
| 902 | dictionaries[enumType] = nameMapping; |
| 903 | } |
| 904 | } |
| 905 | |
| 906 | string originalName; |
| 907 | // If this returns false, originalName will be null, which is what we want. |
| 908 | nameMapping.TryGetValue(value, out originalName); |
| 909 | return originalName; |
| 910 | } |
| 911 | |
| 912 | private static Dictionary<object, string> GetNameMapping(System.Type enumType) => |
| 913 | enumType.GetTypeInfo().DeclaredFields |
| 914 | .Where(f => f.IsStatic) |
| 915 | .ToDictionary(f => f.GetValue(null), |
| 916 | f => f.GetCustomAttributes<OriginalNameAttribute>() |
| 917 | .FirstOrDefault() |
| 918 | // If the attribute hasn't been applied, fall back to the name of the field. |
| 919 | ?.Name ?? f.Name); |
| 920 | } |
Jon Skeet | f8c151f | 2015-07-03 11:56:29 +0100 | [diff] [blame] | 921 | } |
| 922 | } |