code.grnet.gr Git - pithos-ms-client/blob - trunk/Libraries/Json40r2/Source/Src/Newtonsoft.Json/Linq/JTokenWriter.cs

   1 using System;
   2 using System.Collections.Generic;
   3 using System.Linq;
   4 using System.Text;
   5 using Newtonsoft.Json.Utilities;
   6
   7 namespace Newtonsoft.Json.Linq
   8 {
   9   /// <summary>
  10   /// Represents a writer that provides a fast, non-cached, forward-only way of generating Json data.
  11   /// </summary>
  12   public class JTokenWriter : JsonWriter
  13   {
  14     private JContainer _token;
  15     private JContainer _parent;
  16     // used when writer is writing single value and the value has no containing parent
  17     private JValue _value;
  18
  19     /// <summary>
  20     /// Gets the token being writen.
  21     /// </summary>
  22     /// <value>The token being writen.</value>
  23     public JToken Token
  24     {
  25       get
  26       {
  27         if (_token != null)
  28           return _token;
  29
  30         return _value;
  31       }
  32     }
  33
  34     /// <summary>
  35     /// Initializes a new instance of the <see cref="JTokenWriter"/> class writing to the given <see cref="JContainer"/>.
  36     /// </summary>
  37     /// <param name="container">The container being written to.</param>
  38     public JTokenWriter(JContainer container)
  39     {
  40       ValidationUtils.ArgumentNotNull(container, "container");
  41
  42       _token = container;
  43       _parent = container;
  44     }
  45
  46     /// <summary>
  47     /// Initializes a new instance of the <see cref="JTokenWriter"/> class.
  48     /// </summary>
  49     public JTokenWriter()
  50     {
  51     }
  52
  53     /// <summary>
  54     /// Flushes whatever is in the buffer to the underlying streams and also flushes the underlying stream.
  55     /// </summary>
  56     public override void Flush()
  57     {
  58     }
  59
  60     /// <summary>
  61     /// Closes this stream and the underlying stream.
  62     /// </summary>
  63     public override void Close()
  64     {
  65       base.Close();
  66     }
  67
  68     /// <summary>
  69     /// Writes the beginning of a Json object.
  70     /// </summary>
  71     public override void WriteStartObject()
  72     {
  73       base.WriteStartObject();
  74
  75       AddParent(new JObject());
  76     }
  77
  78     private void AddParent(JContainer container)
  79     {
  80       if (_parent == null)
  81         _token = container;
  82       else
  83         _parent.Add(container);
  84
  85       _parent = container;
  86     }
  87
  88     private void RemoveParent()
  89     {
  90       _parent = _parent.Parent;
  91
  92       if (_parent != null && _parent.Type == JTokenType.Property)
  93         _parent = _parent.Parent;
  94     }
  95
  96     /// <summary>
  97     /// Writes the beginning of a Json array.
  98     /// </summary>
  99     public override void WriteStartArray()
 100     {
 101       base.WriteStartArray();
 102
 103       AddParent(new JArray());
 104     }
 105
 106     /// <summary>
 107     /// Writes the start of a constructor with the given name.
 108     /// </summary>
 109     /// <param name="name">The name of the constructor.</param>
 110     public override void WriteStartConstructor(string name)
 111     {
 112       base.WriteStartConstructor(name);
 113
 114       AddParent(new JConstructor(name));
 115     }
 116
 117     /// <summary>
 118     /// Writes the end.
 119     /// </summary>
 120     /// <param name="token">The token.</param>
 121     protected override void WriteEnd(JsonToken token)
 122     {
 123       RemoveParent();
 124     }
 125
 126     /// <summary>
 127     /// Writes the property name of a name/value pair on a Json object.
 128     /// </summary>
 129     /// <param name="name">The name of the property.</param>
 130     public override void WritePropertyName(string name)
 131     {
 132       base.WritePropertyName(name);
 133
 134       AddParent(new JProperty(name));
 135     }
 136
 137     private void AddValue(object value, JsonToken token)
 138     {
 139       AddValue(new JValue(value), token);
 140     }
 141
 142     internal void AddValue(JValue value, JsonToken token)
 143     {
 144       if (_parent != null)
 145       {
 146         _parent.Add(value);
 147
 148         if (_parent.Type == JTokenType.Property)
 149           _parent = _parent.Parent;
 150       }
 151       else
 152       {
 153         _value = value;
 154       }
 155     }
 156
 157     #region WriteValue methods
 158     /// <summary>
 159     /// Writes a null value.
 160     /// </summary>
 161     public override void WriteNull()
 162     {
 163       base.WriteNull();
 164       AddValue(null, JsonToken.Null);
 165     }
 166
 167     /// <summary>
 168     /// Writes an undefined value.
 169     /// </summary>
 170     public override void WriteUndefined()
 171     {
 172       base.WriteUndefined();
 173       AddValue(null, JsonToken.Undefined);
 174     }
 175
 176     /// <summary>
 177     /// Writes raw JSON.
 178     /// </summary>
 179     /// <param name="json">The raw JSON to write.</param>
 180     public override void WriteRaw(string json)
 181     {
 182       base.WriteRaw(json);
 183       AddValue(new JRaw(json), JsonToken.Raw);
 184     }
 185
 186     /// <summary>
 187     /// Writes out a comment <code>/*...*/</code> containing the specified text.
 188     /// </summary>
 189     /// <param name="text">Text to place inside the comment.</param>
 190     public override void WriteComment(string text)
 191     {
 192       base.WriteComment(text);
 193       AddValue(JValue.CreateComment(text), JsonToken.Comment);
 194     }
 195
 196     /// <summary>
 197     /// Writes a <see cref="String"/> value.
 198     /// </summary>
 199     /// <param name="value">The <see cref="String"/> value to write.</param>
 200     public override void WriteValue(string value)
 201     {
 202       base.WriteValue(value);
 203       AddValue(value ?? string.Empty, JsonToken.String);
 204     }
 205
 206     /// <summary>
 207     /// Writes a <see cref="Int32"/> value.
 208     /// </summary>
 209     /// <param name="value">The <see cref="Int32"/> value to write.</param>
 210     public override void WriteValue(int value)
 211     {
 212       base.WriteValue(value);
 213       AddValue(value, JsonToken.Integer);
 214     }
 215
 216     /// <summary>
 217     /// Writes a <see cref="UInt32"/> value.
 218     /// </summary>
 219     /// <param name="value">The <see cref="UInt32"/> value to write.</param>
 220     [CLSCompliant(false)]
 221     public override void WriteValue(uint value)
 222     {
 223       base.WriteValue(value);
 224       AddValue(value, JsonToken.Integer);
 225     }
 226
 227     /// <summary>
 228     /// Writes a <see cref="Int64"/> value.
 229     /// </summary>
 230     /// <param name="value">The <see cref="Int64"/> value to write.</param>
 231     public override void WriteValue(long value)
 232     {
 233       base.WriteValue(value);
 234       AddValue(value, JsonToken.Integer);
 235     }
 236
 237     /// <summary>
 238     /// Writes a <see cref="UInt64"/> value.
 239     /// </summary>
 240     /// <param name="value">The <see cref="UInt64"/> value to write.</param>
 241     [CLSCompliant(false)]
 242     public override void WriteValue(ulong value)
 243     {
 244       base.WriteValue(value);
 245       AddValue(value, JsonToken.Integer);
 246     }
 247
 248     /// <summary>
 249     /// Writes a <see cref="Single"/> value.
 250     /// </summary>
 251     /// <param name="value">The <see cref="Single"/> value to write.</param>
 252     public override void WriteValue(float value)
 253     {
 254       base.WriteValue(value);
 255       AddValue(value, JsonToken.Float);
 256     }
 257
 258     /// <summary>
 259     /// Writes a <see cref="Double"/> value.
 260     /// </summary>
 261     /// <param name="value">The <see cref="Double"/> value to write.</param>
 262     public override void WriteValue(double value)
 263     {
 264       base.WriteValue(value);
 265       AddValue(value, JsonToken.Float);
 266     }
 267
 268     /// <summary>
 269     /// Writes a <see cref="Boolean"/> value.
 270     /// </summary>
 271     /// <param name="value">The <see cref="Boolean"/> value to write.</param>
 272     public override void WriteValue(bool value)
 273     {
 274       base.WriteValue(value);
 275       AddValue(value, JsonToken.Boolean);
 276     }
 277
 278     /// <summary>
 279     /// Writes a <see cref="Int16"/> value.
 280     /// </summary>
 281     /// <param name="value">The <see cref="Int16"/> value to write.</param>
 282     public override void WriteValue(short value)
 283     {
 284       base.WriteValue(value);
 285       AddValue(value, JsonToken.Integer);
 286     }
 287
 288     /// <summary>
 289     /// Writes a <see cref="UInt16"/> value.
 290     /// </summary>
 291     /// <param name="value">The <see cref="UInt16"/> value to write.</param>
 292     [CLSCompliant(false)]
 293     public override void WriteValue(ushort value)
 294     {
 295       base.WriteValue(value);
 296       AddValue(value, JsonToken.Integer);
 297     }
 298
 299     /// <summary>
 300     /// Writes a <see cref="Char"/> value.
 301     /// </summary>
 302     /// <param name="value">The <see cref="Char"/> value to write.</param>
 303     public override void WriteValue(char value)
 304     {
 305       base.WriteValue(value);
 306       AddValue(value.ToString(), JsonToken.String);
 307     }
 308
 309     /// <summary>
 310     /// Writes a <see cref="Byte"/> value.
 311     /// </summary>
 312     /// <param name="value">The <see cref="Byte"/> value to write.</param>
 313     public override void WriteValue(byte value)
 314     {
 315       base.WriteValue(value);
 316       AddValue(value, JsonToken.Integer);
 317     }
 318
 319     /// <summary>
 320     /// Writes a <see cref="SByte"/> value.
 321     /// </summary>
 322     /// <param name="value">The <see cref="SByte"/> value to write.</param>
 323     [CLSCompliant(false)]
 324     public override void WriteValue(sbyte value)
 325     {
 326       base.WriteValue(value);
 327       AddValue(value, JsonToken.Integer);
 328     }
 329
 330     /// <summary>
 331     /// Writes a <see cref="Decimal"/> value.
 332     /// </summary>
 333     /// <param name="value">The <see cref="Decimal"/> value to write.</param>
 334     public override void WriteValue(decimal value)
 335     {
 336       base.WriteValue(value);
 337       AddValue(value, JsonToken.Float);
 338     }
 339
 340     /// <summary>
 341     /// Writes a <see cref="DateTime"/> value.
 342     /// </summary>
 343     /// <param name="value">The <see cref="DateTime"/> value to write.</param>
 344     public override void WriteValue(DateTime value)
 345     {
 346       base.WriteValue(value);
 347       AddValue(value, JsonToken.Date);
 348     }
 349
 350 #if !PocketPC && !NET20
 351     /// <summary>
 352     /// Writes a <see cref="DateTimeOffset"/> value.
 353     /// </summary>
 354     /// <param name="value">The <see cref="DateTimeOffset"/> value to write.</param>
 355     public override void WriteValue(DateTimeOffset value)
 356     {
 357       base.WriteValue(value);
 358       AddValue(value, JsonToken.Date);
 359     }
 360 #endif
 361
 362     /// <summary>
 363     /// Writes a <see cref="T:Byte[]"/> value.
 364     /// </summary>
 365     /// <param name="value">The <see cref="T:Byte[]"/> value to write.</param>
 366     public override void WriteValue(byte[] value)
 367     {
 368       base.WriteValue(value);
 369       AddValue(value, JsonToken.Bytes);
 370     }
 371     #endregion
 372   }
 373 }