protected override object ImportFromArray(ImportContext context, JsonReader reader) { if (context == null) throw new ArgumentNullException("context"); if (reader == null) throw new ArgumentNullException("reader"); object collection = CreateCollection(); reader.ReadToken(JsonTokenClass.Array); ImportElements(collection, context, reader); if (reader.TokenClass != JsonTokenClass.EndArray) throw new Exception("Implementation error."); reader.Read(); return collection; }
private static object ReadParameters(Method method, JsonReader reader, ImportContext importContext) { Debug.Assert(method != null); Debug.Assert(reader != null); Debug.Assert(importContext != null); reader.MoveToContent(); Parameter[] parameters = method.GetParameters(); if (reader.TokenClass == JsonTokenClass.Array) { reader.Read(); ArrayList argList = new ArrayList(parameters.Length); // TODO: This loop could bomb when more args are supplied that parameters available. for (int i = 0; i < parameters.Length && reader.TokenClass != JsonTokenClass.EndArray; i++) argList.Add(importContext.Import(parameters[i].ParameterType, reader)); reader.StepOut(); return argList.ToArray(); } else if (reader.TokenClass == JsonTokenClass.Object) { reader.Read(); JsonObject argByName = new JsonObject(); while (reader.TokenClass != JsonTokenClass.EndObject) { // TODO: Imporve this lookup. // FIXME: Does not work when argument is positional. Type parameterType = AnyType.Value; string name = reader.ReadMember(); foreach (Parameter parameter in parameters) { if (parameter.Name.Equals(name)) { parameterType = parameter.ParameterType; break; } } argByName.Put(name, importContext.Import(parameterType, reader)); } reader.Read(); return argByName; } else { return importContext.Import(reader); } }
/// <remarks> /// This method is not exception-safe. If an error occurs while /// reading then the object may be partially imported. /// </remarks> public virtual void Import(JsonReader reader) { if (reader == null) throw new ArgumentNullException("reader"); // FIXME: Consider making this method exception-safe. // Right now this is a problem because of reliance on // DictionaryBase. Clear(); reader.ReadToken(JsonTokenClass.Object); while (reader.TokenClass != JsonTokenClass.EndObject) Put(reader.ReadMember(), reader.ReadValue()); reader.Read(); }
public static JsonBuffer From(JsonReader reader) { if (reader == null) throw new ArgumentNullException("reader"); JsonBufferReader bufferReader = reader as JsonBufferReader; if (bufferReader != null) return bufferReader.BufferValue(); if (!reader.MoveToContent()) return Empty; if (reader.TokenClass == JsonTokenClass.Member) reader.Read(); bool structured = reader.TokenClass == JsonTokenClass.Array || reader.TokenClass == JsonTokenClass.Object; JsonBufferWriter writer = new JsonBufferWriter(); writer.WriteFromReader(reader); JsonBuffer buffer = writer.GetBuffer(); if (!structured) { bufferReader = buffer.CreateReader(); bufferReader.MoveToContent(); bufferReader.Read(); buffer = bufferReader.BufferValue(); } return buffer; }
/// <summary> /// Writes the next value from the given <see cref="JsonReader"/> /// into this writer's output. If the reader is positioned /// at the root of JSON data, then the entire data will be /// written. /// </summary> public virtual void WriteFromReader(JsonReader reader) { if (reader == null) throw new ArgumentNullException("reader"); if (!reader.MoveToContent()) return; if (reader.TokenClass == JsonTokenClass.String) { WriteString(reader.Text); } else if (reader.TokenClass == JsonTokenClass.Number) { WriteNumber(reader.Text); } else if (reader.TokenClass == JsonTokenClass.Boolean) { WriteBoolean(reader.Text == JsonBoolean.TrueText); } else if (reader.TokenClass == JsonTokenClass.Null) { WriteNull(); } else if (reader.TokenClass == JsonTokenClass.Array) { WriteStartArray(); reader.Read(); while (reader.TokenClass != JsonTokenClass.EndArray) WriteFromReader(reader); WriteEndArray(); } else if (reader.TokenClass == JsonTokenClass.Object) { reader.Read(); WriteStartObject(); while (reader.TokenClass != JsonTokenClass.EndObject) { WriteMember(reader.ReadMember()); WriteFromReader(reader); } WriteEndObject(); } else { throw new JsonException(string.Format("{0} not expected.", reader.TokenClass)); } reader.Read(); }
protected virtual void Import(ImportContext context, JsonReader reader) { if (context == null) throw new ArgumentNullException("context"); if (reader == null) throw new ArgumentNullException("reader"); // // IMPORTANT! A new list is created and then committed to make // sure that this method is exception-safe. If something goes // wrong during the import of elements then this instance // will remain largely untouched. // ArrayList list = new ArrayList(); reader.ReadToken(JsonTokenClass.Array); while (reader.TokenClass != JsonTokenClass.EndArray) list.Add(context.Import(reader)); reader.Read(); InnerList.Clear(); InnerList.AddRange(list); }
void IJsonImportable.Import(ImportContext context, JsonReader reader) { reader.MoveToContent(); if (reader.TokenClass != JsonTokenClass.Object) { reader.Skip(); return; } reader.Read(/* object */); do { var brushName = reader.ReadMember().ToLowerInvariant(); var color = reader.ReadString(); var foreground = EnumHelper.TryParse<ConsoleColor>(color, true) ?? DefaultBrush.Foreground; switch (brushName) { case "arr": case "array": Array = Array.ResetForeground(foreground); break; case "obj": case "object": Object = Object.ResetForeground(foreground); break; case "mem": case "member": Member = Member.ResetForeground(foreground); break; case "str": case "string": String = String.ResetForeground(foreground); break; case "num": case "number": Number = Number.ResetForeground(foreground); break; case "bit": case "boolean": Boolean = Boolean.ResetForeground(foreground); break; case "nil": case "null": Null = Null.ResetForeground(foreground); break; default: continue; } } while (reader.TokenClass != JsonTokenClass.EndObject); reader.Read( /* end object */); }
public void WriteValueFromReader(JsonReader reader) { if (reader == null) throw new ArgumentNullException("reader"); if (!reader.MoveToContent()) return; switch (reader.Token) { case JsonToken.String: WriteString(reader.Text); break; case JsonToken.Number: WriteNumber(reader.Text); break; case JsonToken.Boolean : WriteBoolean(reader.Text == JsonReader.FalseText); break; case JsonToken.Null : WriteNull(); break; case JsonToken.Object : { WriteStartObject(); reader.ReadMember(); do { WriteMember(reader.Text); reader.Read(); WriteValueFromReader(reader); } while (reader.Token != JsonToken.EndObject); WriteEndObject(); break; } case JsonToken.Array : { WriteStartArray(); reader.Read(); while (reader.Token != JsonToken.EndArray) WriteValueFromReader(reader); WriteEndArray(); break; } default : throw new JsonException(string.Format("{0} not expected.", reader.Token)); } reader.Read(); }