← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to external/Newtonsoft.Json/Src/Newtonsoft.Json/Converters/JsonValueConverter.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
external/Newtonsoft.Json/Src/Newtonsoft.Json/Converters/JsonValueConverter.cs
 
1
#region License
 
2
// Copyright (c) 2007 James Newton-King
 
3
//
 
4
// Permission is hereby granted, free of charge, to any person
 
5
// obtaining a copy of this software and associated documentation
 
6
// files (the "Software"), to deal in the Software without
 
7
// restriction, including without limitation the rights to use,
 
8
// copy, modify, merge, publish, distribute, sublicense, and/or sell
 
9
// copies of the Software, and to permit persons to whom the
 
10
// Software is furnished to do so, subject to the following
 
11
// conditions:
 
12
//
 
13
// The above copyright notice and this permission notice shall be
 
14
// included in all copies or substantial portions of the Software.
 
15
//
 
16
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 
17
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 
18
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 
19
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 
20
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 
21
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 
22
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 
23
// OTHER DEALINGS IN THE SOFTWARE.
 
24
#endregion
 
25
 
 
26
using System;
 
27
using System.Collections.Generic;
 
28
using System.Globalization;
 
29
using System.Security;
 
30
using Newtonsoft.Json.Utilities;
 
31
using Windows.Data.Json;
 
32
 
 
33
namespace Newtonsoft.Json.Converters
 
34
{
 
35
  public class JsonValueConverter : JsonConverter
 
36
  {
 
37
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
 
38
    {
 
39
      WriteJsonValue(writer, (IJsonValue)value);
 
40
    }
 
41
 
 
42
    private void WriteJsonValue(JsonWriter writer, IJsonValue value)
 
43
    {
 
44
      switch (value.ValueType)
 
45
      {
 
46
        case JsonValueType.Array:
 
47
          {
 
48
            JsonArray a = value.GetArray();
 
49
            writer.WriteStartArray();
 
50
            for (int i = 0; i < a.Count; i++)
 
51
            {
 
52
              WriteJsonValue(writer, a[i]);
 
53
            }
 
54
            writer.WriteEndArray();
 
55
          }
 
56
          break;
 
57
        case JsonValueType.Boolean:
 
58
          {
 
59
            writer.WriteValue(value.GetBoolean());
 
60
          }
 
61
          break;
 
62
        case JsonValueType.Null:
 
63
          {
 
64
            writer.WriteNull();
 
65
          }
 
66
          break;
 
67
        case JsonValueType.Number:
 
68
          {
 
69
            // JsonValue doesn't support integers
 
70
            // serialize whole numbers without a decimal point
 
71
            double d = value.GetNumber();
 
72
            bool isInteger = (d % 1 == 0);
 
73
            if (isInteger && d <= long.MaxValue && d >= long.MinValue)
 
74
              writer.WriteValue(Convert.ToInt64(d));
 
75
            else
 
76
              writer.WriteValue(d);
 
77
          }
 
78
          break;
 
79
        case JsonValueType.Object:
 
80
          {
 
81
            JsonObject o = value.GetObject();
 
82
            writer.WriteStartObject();
 
83
            foreach (KeyValuePair<string, IJsonValue> v in o)
 
84
            {
 
85
              writer.WritePropertyName(v.Key);
 
86
              WriteJsonValue(writer, v.Value);
 
87
            }
 
88
            writer.WriteEndObject();
 
89
          }
 
90
          break;
 
91
        case JsonValueType.String:
 
92
          {
 
93
            writer.WriteValue(value.GetString());
 
94
          }
 
95
          break;
 
96
        default:
 
97
          throw new ArgumentOutOfRangeException("ValueType");
 
98
      }
 
99
    }
 
100
 
 
101
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
 
102
    {
 
103
      if (reader.TokenType == JsonToken.None)
 
104
        reader.Read();
 
105
 
 
106
      IJsonValue value = CreateJsonValue(reader);
 
107
 
 
108
      if (!objectType.IsAssignableFrom(value.GetType()))
 
109
        throw JsonSerializationException.Create(reader, "Could not convert '{0}' to '{1}'.".FormatWith(CultureInfo.InvariantCulture, value.GetType(), objectType));
 
110
 
 
111
      return value;
 
112
    }
 
113
 
 
114
    private IJsonValue CreateJsonValue(JsonReader reader)
 
115
    {
 
116
      while (reader.TokenType == JsonToken.Comment)
 
117
      {
 
118
        if (!reader.Read())
 
119
          throw JsonSerializationException.Create(reader, "Unexpected end.");
 
120
      }
 
121
 
 
122
      switch (reader.TokenType)
 
123
      {
 
124
        case JsonToken.StartObject:
 
125
          {
 
126
            return CreateJsonObject(reader);
 
127
          }
 
128
        case JsonToken.StartArray:
 
129
          {
 
130
            JsonArray a = new JsonArray();
 
131
 
 
132
            while (reader.Read())
 
133
            {
 
134
              switch (reader.TokenType)
 
135
              {
 
136
                case JsonToken.EndArray:
 
137
                  return a;
 
138
                default:
 
139
                  IJsonValue value = CreateJsonValue(reader);
 
140
                  a.Add(value);
 
141
                  break;
 
142
              }
 
143
            }
 
144
          }
 
145
          break;
 
146
        case JsonToken.Integer:
 
147
        case JsonToken.Float:
 
148
          return JsonValue.CreateNumberValue(Convert.ToDouble(reader.Value));
 
149
        case JsonToken.String:
 
150
          return JsonValue.CreateStringValue(reader.Value.ToString());
 
151
        case JsonToken.Boolean:
 
152
          return JsonValue.CreateBooleanValue(Convert.ToBoolean(reader.Value));
 
153
        case JsonToken.Null:
 
154
          // surely there is a better way to create a null value than this?
 
155
          return JsonValue.Parse("null");
 
156
        case JsonToken.Date:
 
157
          return JsonValue.CreateStringValue(reader.Value.ToString());
 
158
        case JsonToken.Bytes:
 
159
          return JsonValue.CreateStringValue(reader.Value.ToString());
 
160
        default:
 
161
          throw JsonSerializationException.Create(reader, "Unexpected or unsupported token: {0}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
 
162
      }
 
163
 
 
164
      throw JsonSerializationException.Create(reader, "Unexpected end.");
 
165
    }
 
166
 
 
167
    private JsonObject CreateJsonObject(JsonReader reader)
 
168
    {
 
169
      JsonObject o = new JsonObject();
 
170
      string propertyName = null;
 
171
 
 
172
      while (reader.Read())
 
173
      {
 
174
        switch (reader.TokenType)
 
175
        {
 
176
          case JsonToken.PropertyName:
 
177
            propertyName = (string)reader.Value;
 
178
            break;
 
179
          case JsonToken.EndObject:
 
180
            return o;
 
181
          case JsonToken.Comment:
 
182
            break;
 
183
          default:
 
184
            IJsonValue propertyValue = CreateJsonValue(reader);
 
185
            o.Add(propertyName, propertyValue);
 
186
            break;
 
187
        }
 
188
      }
 
189
 
 
190
      throw JsonSerializationException.Create(reader, "Unexpected end.");
 
191
    }
 
192
 
 
193
    public override bool CanConvert(Type objectType)
 
194
    {
 
195
      return typeof(IJsonValue).IsAssignableFrom(objectType);
 
196
    }
 
197
  }
 
198
}