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();
}
