public object Read(Newtonsoft.Json.JsonReader reader)
{
if (reader.TokenType != Newtonsoft.Json.JsonToken.StartObject)
throw new Exception();
int w = ReadIntProperty(reader, "Width");
int h = ReadIntProperty(reader, "Height");
int d = ReadIntProperty(reader, "Depth");
var grid = new TileData[d, h, w];
reader.Read();
if (reader.TokenType != Newtonsoft.Json.JsonToken.PropertyName || (string)reader.Value != "TileData")
throw new Exception();
ReadAndValidate(reader, Newtonsoft.Json.JsonToken.StartArray);
var queue = new BlockingCollection<Tuple<int, byte[]>>();
var readerTask = Task.Factory.StartNew(() =>
{
for (int i = 0; i < d; ++i)
{
reader.Read();
int z = (int)(long)reader.Value;
byte[] buf = reader.ReadAsBytes();
queue.Add(new Tuple<int, byte[]>(z, buf));
}
queue.CompleteAdding();
});
Parallel.For(0, d, i =>
{
var tuple = queue.Take();
int z = tuple.Item1;
byte[] arr = tuple.Item2;
using (var memStream = new MemoryStream(arr))
{
using (var decompressStream = new DeflateStream(memStream, CompressionMode.Decompress))
using (var streamReader = new BinaryReader(decompressStream))
{
for (int y = 0; y < h; ++y)
for (int x = 0; x < w; ++x)
grid[z, y, x].Raw = streamReader.ReadUInt64();
}
}
});
readerTask.Wait();
ReadAndValidate(reader, Newtonsoft.Json.JsonToken.EndArray);
ReadAndValidate(reader, Newtonsoft.Json.JsonToken.EndObject);
return grid;
}
public override object ReadJson(Newtonsoft.Json.JsonReader reader, System.Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
Type t = (ReflectionUtils.IsNullableType(objectType))
? Nullable.GetUnderlyingType(objectType)
: objectType;
if (reader.TokenType == JsonToken.Null)
{
if (!ReflectionUtils.IsNullableType(objectType))
throw new Exception("Cannot convert null value to {0}.");
return null;
}
if (reader.TokenType != JsonToken.StartConstructor || string.Compare(reader.Value.ToString(), "Date", StringComparison.Ordinal) != 0)
throw new Exception("Unexpected token or value when parsing date. Token: {0}, Value: {1}");
reader.Read();
if (reader.TokenType != JsonToken.Integer)
throw new Exception("Unexpected token parsing date. Expected Integer, got {0}.");
long ticks = (long)reader.Value;
var d = new DateTime((ticks * 10000) + _tick, DateTimeKind.Local);
reader.Read();
if (reader.TokenType != JsonToken.EndConstructor)
throw new Exception("Unexpected token parsing date. Expected EndConstructor, got {0}.");
return d;
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
public override object ReadJson( Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer )
{
if( typeof( DataService.Attribute ) == objectType )
{
var result = default( DataService.Attribute );
if( reader.Read() && reader.TokenType == Newtonsoft.Json.JsonToken.PropertyName )
{
var key = ushort.Parse( reader.Value.ToString(), System.Globalization.CultureInfo.InvariantCulture );
var value = reader.ReadAsString();
result = new DataService.Attribute( key, value );
}
return result;
}
else
{
var result = new List<DataService.Attribute>();
if( reader.TokenType == Newtonsoft.Json.JsonToken.StartObject )
{
while( reader.Read() && reader.TokenType == Newtonsoft.Json.JsonToken.PropertyName )
{
var key = ushort.Parse( reader.Value.ToString(), System.Globalization.CultureInfo.InvariantCulture );
var value = reader.ReadAsString();
result.Add( new DataService.Attribute( key, value ) );
}
}
return result.ToArray();
}
}
public override object ReadValue(Type ValueType, Newtonsoft.Json.JsonReader Reader, MudObject Owner)
{
var r = new Dictionary<String, Object>();
Reader.Read();
while (Reader.TokenType != Newtonsoft.Json.JsonToken.EndObject)
{
var name = Reader.Value.ToString();
Reader.Read();
var value = PersistAttribute._ReadValue(null, Reader, Owner);
r.Upsert(name, value);
}
Reader.Read();
return r;
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
public override object ReadJson( Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer )
{
var catalogueEntry = new CatalogEntry();
while( reader.Read() && reader.TokenType == Newtonsoft.Json.JsonToken.PropertyName )
{
switch( reader.Value.ToString() )
{
case "key":
catalogueEntry.Key = short.Parse( reader.ReadAsString(), CultureInfo.InvariantCulture );
break;
case "attributes":
reader.Read();
catalogueEntry.Attributes = serializer.Deserialize<DataService.Attribute[]>( reader );
break;
}
}
return catalogueEntry;
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
public override object ReadJson( Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer )
{
var configuration = new Configuration();
while( reader.Read() && reader.TokenType == Newtonsoft.Json.JsonToken.PropertyName )
{
switch( reader.Value.ToString() )
{
case "partAttributes":
reader.Read();
configuration.PartAttributes = serializer.Deserialize<AbstractAttributeDefinition[]>( reader );
break;
case "characteristicAttributes":
reader.Read();
configuration.CharacteristicAttributes = serializer.Deserialize<AbstractAttributeDefinition[]>( reader );
break;
case "measurementAttributes":
reader.Read();
configuration.MeasurementAttributes = serializer.Deserialize<AbstractAttributeDefinition[]>( reader );
break;
case "valueAttributes":
reader.Read();
configuration.ValueAttributes = serializer.Deserialize<AbstractAttributeDefinition[]>( reader );
break;
case "catalogAttributes":
reader.Read();
configuration.CatalogAttributes = serializer.Deserialize<AttributeDefinition[]>( reader );
break;
}
}
return configuration;
}
public override object ReadValue(Type ValueType, Newtonsoft.Json.JsonReader Reader, MudObject Owner)
{
var r = new Dictionary<RelativeLocations, List<MudObject>>();
Reader.Read();
while (Reader.TokenType != Newtonsoft.Json.JsonToken.EndObject)
{
var relloc = StringToRelativeLocation(Reader.Value.ToString());
var l = new List<MudObject>();
Reader.Read();
Reader.Read();
while (Reader.TokenType != Newtonsoft.Json.JsonToken.EndArray)
{
var mudObject = MudObject.GetObject(Reader.Value.ToString());
if (mudObject != null) l.Add(mudObject);
mudObject.Location = Owner;
Reader.Read();
}
Reader.Read();
r.Upsert(relloc, l);
}
Reader.Read();
return r;
}
public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (objectType != typeof(XmlDocument))
throw new JsonSerializationException("XmlNodeConverter only supports deserializing XmlDocuments");
XmlDocument document = new XmlDocument();
XmlNamespaceManager manager = new XmlNamespaceManager(document.NameTable);
if (reader.TokenType != JsonToken.StartObject)
throw new JsonSerializationException("XmlNodeConverter can only convert JSON that begins with an object.");
reader.Read();
DeserializeNode(reader, document, manager, document);
return document;
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
public override object ReadJson( Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer )
{
var key = default( ushort );
var length = default( ushort );
var queryEfficient = default( bool );
var description = default( string );
var attributeDefinitionType = default( string );
var type = default( AttributeType );
var catalogUuid = default( Guid );
while( reader.Read() && reader.TokenType == Newtonsoft.Json.JsonToken.PropertyName )
{
switch( reader.Value.ToString() )
{
case "key":
key = ushort.Parse( reader.ReadAsString(), CultureInfo.InvariantCulture );
break;
case "queryEfficient":
queryEfficient = bool.Parse( reader.ReadAsString() );
break;
case "description":
description = reader.ReadAsString();
break;
case "length":
length = ushort.Parse( reader.ReadAsString(), CultureInfo.InvariantCulture );
break;
case "type":
type = (AttributeType)Enum.Parse( typeof( AttributeType ), reader.ReadAsString() );
break;
case "catalog":
catalogUuid = Guid.Parse( reader.ReadAsString() );
break;
case "definitionType":
attributeDefinitionType = reader.ReadAsString();
break;
}
}
if( attributeDefinitionType == "AttributeDefinition" )
return new AttributeDefinition { Description = description, Key = key, Length = length, QueryEfficient = queryEfficient, Type = type };
if( attributeDefinitionType == "CatalogAttributeDefinition" )
return new CatalogAttributeDefinition { Description = description, Key = key, QueryEfficient = queryEfficient, Catalog = catalogUuid };
return null;
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
public override object ReadJson( Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer )
{
var catalog = new Catalog();
if( reader.TokenType == Newtonsoft.Json.JsonToken.StartObject )
{
while( reader.Read() && reader.TokenType != Newtonsoft.Json.JsonToken.EndObject )
{
switch( reader.Value.ToString() )
{
case "name": catalog.Name = reader.ReadAsString(); break;
case "uuid": catalog.Uuid = new Guid( reader.ReadAsString() ); break;
case "validAttributes":
if( reader.Read() && reader.TokenType == Newtonsoft.Json.JsonToken.StartArray )
{
var atts = new List<ushort>();
while( reader.Read() && reader.TokenType != Newtonsoft.Json.JsonToken.EndArray )
{
atts.Add( Convert.ToUInt16( reader.Value ) );
}
catalog.ValidAttributes = atts.ToArray();
}
break;
case "catalogEntries":
if( reader.Read() && reader.TokenType == Newtonsoft.Json.JsonToken.StartArray )
{
if( reader.Read() && reader.TokenType == Newtonsoft.Json.JsonToken.StartObject )
{
var entries = new List< CatalogEntry >();
while( reader.TokenType != Newtonsoft.Json.JsonToken.EndArray )
{
entries.Add(serializer.Deserialize<CatalogEntry>( reader ));
reader.Read();
}
catalog.CatalogEntries = entries.ToArray();
}
}
break;
}
}
}
return catalog;
}
public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
List<Bot> bots = new List<Bot>();
int d = reader.Depth;
while (reader.Read() && reader.Depth > d)
{
Bot current = new Bot();
int depth = reader.Depth;
current.name = reader.Value.ToString();
reader.Read();
while (reader.Read() && reader.Depth > depth)
{
if (reader.Value == null) break;
switch (reader.Value.ToString())
{
case "image_48":
reader.Read();
current.image_48 = reader.Value.ToString();
break;
case "image_64":
reader.Read();
current.image_48 = reader.Value.ToString();
break;
case "emoji":
reader.Read();
current.emoji = reader.Value.ToString();
break;
}
}
bots.Add(current);
}
return bots.ToArray();
}
private void DeserializeValue(Newtonsoft.Json.JsonReader reader, XmlDocument document, XmlNamespaceManager manager, string propertyName, XmlNode currentNode)
{
// deserialize xml element
bool finishedAttributes = false;
bool finishedElement = false;
Dictionary<string, string> attributeNameValues = new Dictionary<string, string>();
// a string token means the element only has a single text child
if (reader.TokenType != JsonToken.String
&& reader.TokenType != JsonToken.Null
&& reader.TokenType != JsonToken.Boolean
&& reader.TokenType != JsonToken.Integer
&& reader.TokenType != JsonToken.Float
&& reader.TokenType != JsonToken.Date
&& reader.TokenType != JsonToken.StartConstructor)
{
// read properties until first non-attribute is encountered
while (!finishedAttributes && !finishedElement && reader.Read())
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
string attributeName = reader.Value.ToString();
if (attributeName[0] == '@')
{
attributeName = attributeName.Substring(1);
reader.Read();
string attributeValue = reader.Value.ToString();
attributeNameValues.Add(attributeName, attributeValue);
}
else
{
finishedAttributes = true;
}
break;
case JsonToken.EndObject:
finishedElement = true;
break;
default:
throw new JsonSerializationException("Unexpected JsonToken: " + reader.TokenType);
}
}
}
// have to wait until attributes have been parsed before creating element
// attributes may contain namespace info used by the element
XmlElement element = document.CreateElement(propertyName);
currentNode.AppendChild(element);
// add attributes to newly created element
foreach (KeyValuePair<string, string> nameValue in attributeNameValues)
{
XmlAttribute attribute = document.CreateAttribute(nameValue.Key);
attribute.Value = nameValue.Value;
element.SetAttributeNode(attribute);
}
if (reader.TokenType == JsonToken.String)
{
element.AppendChild(document.CreateTextNode(reader.Value.ToString()));
}
else if (reader.TokenType == JsonToken.Integer)
{
element.AppendChild(document.CreateTextNode(XmlConvert.ToString((long)reader.Value)));
}
else if (reader.TokenType == JsonToken.Float)
{
element.AppendChild(document.CreateTextNode(XmlConvert.ToString((double)reader.Value)));
}
else if (reader.TokenType == JsonToken.Boolean)
{
element.AppendChild(document.CreateTextNode(XmlConvert.ToString((bool)reader.Value)));
}
else if (reader.TokenType == JsonToken.Date)
{
DateTime d = (DateTime)reader.Value;
element.AppendChild(document.CreateTextNode(XmlConvert.ToString(d, ToSerializationMode(d.Kind))));
}
else if (reader.TokenType == JsonToken.Null)
{
// empty element. do nothing
}
else
{
// finished element will have no children to deserialize
if (!finishedElement)
{
manager.PushScope();
DeserializeNode(reader, document, manager, element);
manager.PopScope();
}
}
}
private void DeserializeNode(Newtonsoft.Json.JsonReader reader, XmlDocument document, XmlNamespaceManager manager, XmlNode currentNode)
{
if (currentNode.NodeType == XmlNodeType.Document)
{
XmlElement root = document.CreateElement("records");
document.AppendChild(root);
currentNode = root;
}
XmlNode savedNode = currentNode;
do
{
if (savedNode.Name == "records" && savedNode.ParentNode.NodeType == XmlNodeType.Document)
{
currentNode = savedNode;
}
switch (reader.TokenType)
{
case JsonToken.PropertyName:
if (currentNode.NodeType == XmlNodeType.Document && document.DocumentElement != null)
throw new JsonSerializationException("JSON root object has multiple properties. The root object must have a single property in order to create a valid XML document.");
string propertyName = reader.Value.ToString();
reader.Read();
if (reader.TokenType == JsonToken.StartArray)
{
while (reader.Read() && reader.TokenType != JsonToken.EndArray)
{
if (reader.TokenType == JsonToken.StartObject)
{
if (currentNode.Name == "records" && currentNode.ParentNode.NodeType == XmlNodeType.Document &&
(propertyName == "Updated" || propertyName == "Created" || propertyName == "Deleted"))
{
XmlNode tempNode = currentNode.SelectSingleNode(propertyName);
if (tempNode != null)
{
currentNode = tempNode;
propertyName = "record";
}
}
}
DeserializeValue(reader, document, manager, propertyName, currentNode);
}
}
else
{
bool addRecord = currentNode.ParentNode != null && currentNode.ParentNode.ParentNode != null &&
currentNode.ParentNode.Name == "records" && currentNode.ParentNode.ParentNode.NodeType == XmlNodeType.Document;
if ((currentNode.Name == "Updated" || currentNode.Name == "Created" || currentNode.Name == "Deleted") && addRecord)
{
XmlElement record = document.CreateElement("record");
currentNode.AppendChild(record);
currentNode = record;
}
DeserializeValue(reader, document, manager, propertyName, currentNode);
}
break;
case JsonToken.StartConstructor:
string constructorName = reader.Value.ToString();
while (reader.Read() && reader.TokenType != JsonToken.EndConstructor)
{
DeserializeValue(reader, document, manager, "-" + constructorName, currentNode);
}
break;
case JsonToken.EndObject:
case JsonToken.EndArray:
return;
default:
throw new JsonSerializationException("Unexpected JsonToken when deserializing node: " + reader.TokenType);
}
} while (reader.TokenType == JsonToken.PropertyName || reader.Read());
// don't read if current token is a property. token was already read when parsing element attributes
}
private void ReadArrayElements(Newtonsoft.Json.JsonReader reader, IXmlDocument document, string propertyName, IXmlNode currentNode, XmlNamespaceManager manager)
{
string elementPrefix = MiscellaneousUtils.GetPrefix(propertyName);
IXmlElement nestedArrayElement = CreateElement(propertyName, document, elementPrefix, manager);
currentNode.AppendChild(nestedArrayElement);
int count = 0;
while (reader.Read() && reader.TokenType != Newtonsoft.Json.JsonToken.EndArray)
{
DeserializeValue(reader, document, manager, propertyName, nestedArrayElement);
count++;
}
if (WriteArrayAttribute)
{
AddJsonArrayAttribute(nestedArrayElement, document);
}
if (count == 1 && WriteArrayAttribute)
{
IXmlElement arrayElement = nestedArrayElement.ChildNodes.OfType<IXmlElement>().Single(n => n.LocalName == propertyName);
AddJsonArrayAttribute(arrayElement, document);
}
}
private Dictionary<string, string> ReadAttributeElements(Newtonsoft.Json.JsonReader reader, XmlNamespaceManager manager)
{
Dictionary<string, string> attributeNameValues = new Dictionary<string, string>();
bool finishedAttributes = false;
bool finishedElement = false;
// a string token means the element only has a single text child
if (reader.TokenType != Newtonsoft.Json.JsonToken.String &&
reader.TokenType != Newtonsoft.Json.JsonToken.Null &&
reader.TokenType != Newtonsoft.Json.JsonToken.Boolean &&
reader.TokenType != Newtonsoft.Json.JsonToken.Integer &&
reader.TokenType != Newtonsoft.Json.JsonToken.Float &&
reader.TokenType != Newtonsoft.Json.JsonToken.Date &&
reader.TokenType != Newtonsoft.Json.JsonToken.StartConstructor)
{
// read properties until first non-attribute is encountered
while (!finishedAttributes && !finishedElement && reader.Read())
{
switch (reader.TokenType)
{
case Newtonsoft.Json.JsonToken.PropertyName:
string attributeName = reader.Value.ToString();
if (!string.IsNullOrEmpty(attributeName))
{
char firstChar = attributeName[0];
string attributeValue;
switch (firstChar)
{
case '@':
attributeName = attributeName.Substring(1);
reader.Read();
attributeValue = ConvertTokenToXmlValue(reader);
attributeNameValues.Add(attributeName, attributeValue);
string namespacePrefix;
if (IsNamespaceAttribute(attributeName, out namespacePrefix))
{
manager.AddNamespace(namespacePrefix, attributeValue);
}
break;
case '$':
attributeName = attributeName.Substring(1);
reader.Read();
attributeValue = reader.Value.ToString();
// check that JsonNamespaceUri is in scope
// if it isn't then add it to document and namespace manager
string jsonPrefix = manager.LookupPrefix(JsonNamespaceUri);
if (jsonPrefix == null)
{
// ensure that the prefix used is free
int? i = null;
while (manager.LookupNamespace("json" + i) != null)
{
i = i.GetValueOrDefault() + 1;
}
jsonPrefix = "json" + i;
attributeNameValues.Add("xmlns:" + jsonPrefix, JsonNamespaceUri);
manager.AddNamespace(jsonPrefix, JsonNamespaceUri);
}
attributeNameValues.Add(jsonPrefix + ":" + attributeName, attributeValue);
break;
default:
finishedAttributes = true;
break;
}
}
else
{
finishedAttributes = true;
}
break;
case Newtonsoft.Json.JsonToken.EndObject:
finishedElement = true;
break;
case Newtonsoft.Json.JsonToken.Comment:
finishedElement = true;
break;
default:
throw new Newtonsoft.Json.JsonSerializationException("Unexpected JsonToken: " + reader.TokenType);
}
}
}
return attributeNameValues;
}
static int ReadIntProperty(Newtonsoft.Json.JsonReader reader, string propertyName)
{
reader.Read();
if (reader.TokenType != Newtonsoft.Json.JsonToken.PropertyName || (string)reader.Value != propertyName)
throw new Exception();
reader.Read();
if (reader.TokenType != Newtonsoft.Json.JsonToken.Integer)
throw new Exception();
return (int)(long)reader.Value;
}
static void ReadAndValidate(Newtonsoft.Json.JsonReader reader, Newtonsoft.Json.JsonToken token)
{
reader.Read();
if (reader.TokenType != token)
throw new Exception();
}
public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object value, Newtonsoft.Json.JsonSerializer serializer)
{
if (reader.TokenType == Newtonsoft.Json.JsonToken.StartObject && reader.Read())
{
value = deserialize((JsonReader)reader);
if (reader.TokenType != Newtonsoft.Json.JsonToken.EndObject)
throw new FormatException("End object '}' expected");
}
return value;
}
private void CreateInstruction(Newtonsoft.Json.JsonReader reader, IXmlDocument document, IXmlNode currentNode, string propertyName)
{
if (propertyName == DeclarationName)
{
string version = null;
string encoding = null;
string standalone = null;
while (reader.Read() && reader.TokenType != Newtonsoft.Json.JsonToken.EndObject)
{
switch (reader.Value.ToString())
{
case "@version":
reader.Read();
version = reader.Value.ToString();
break;
case "@encoding":
reader.Read();
encoding = reader.Value.ToString();
break;
case "@standalone":
reader.Read();
standalone = reader.Value.ToString();
break;
default:
throw new Newtonsoft.Json.JsonSerializationException("Unexpected property name encountered while deserializing XmlDeclaration: " + reader.Value);
}
}
IXmlNode declaration = document.CreateXmlDeclaration(version, encoding, standalone);
currentNode.AppendChild(declaration);
}
else
{
IXmlNode instruction = document.CreateProcessingInstruction(propertyName.Substring(1), reader.Value.ToString());
currentNode.AppendChild(instruction);
}
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
/// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
/// <param name="objectType">Type of the object.</param>
/// <param name="existingValue">The existing value of object being read.</param>
/// <param name="serializer">The calling serializer.</param>
/// <returns>The object value.</returns>
public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, System.Serialisation.Json.JsonSerializer serializer)
{
if (reader.TokenType == Newtonsoft.Json.JsonToken.Null)
return null;
XmlNamespaceManager manager = new XmlNamespaceManager(new NameTable());
IXmlDocument document = null;
IXmlNode rootNode = null;
#if !NET20
if (typeof(XObject).IsAssignableFrom(objectType))
{
if (objectType != typeof(XDocument) && objectType != typeof(XElement))
throw new Newtonsoft.Json.JsonSerializationException("XmlNodeConverter only supports deserializing XDocument or XElement.");
XDocument d = new XDocument();
document = new XDocumentWrapper(d);
rootNode = document;
}
#endif
#if !(NETFX_CORE || PORTABLE)
if (typeof(XmlNode).IsAssignableFrom(objectType))
{
if (objectType != typeof(XmlDocument))
throw new Newtonsoft.Json.JsonSerializationException("XmlNodeConverter only supports deserializing XmlDocuments");
XmlDocument d = new XmlDocument();
// prevent http request when resolving any DTD references
d.XmlResolver = null;
document = new XmlDocumentWrapper(d);
rootNode = document;
}
#endif
if (document == null || rootNode == null)
throw new Newtonsoft.Json.JsonSerializationException("Unexpected type when converting XML: " + objectType);
if (reader.TokenType != Newtonsoft.Json.JsonToken.StartObject)
throw new Newtonsoft.Json.JsonSerializationException("XmlNodeConverter can only convert JSON that begins with an object.");
if (!string.IsNullOrEmpty(DeserializeRootElementName))
{
//rootNode = document.CreateElement(DeserializeRootElementName);
//document.AppendChild(rootNode);
ReadElement(reader, document, rootNode, DeserializeRootElementName, manager);
}
else
{
reader.Read();
DeserializeNode(reader, document, manager, rootNode);
}
#if !NET20
if (objectType == typeof(XElement))
{
XElement element = (XElement)document.DocumentElement.WrappedNode;
element.Remove();
return element;
}
#endif
return document.WrappedNode;
}
private void CreateDocumentType(Newtonsoft.Json.JsonReader reader, IXmlDocument document, IXmlNode currentNode)
{
string name = null;
string publicId = null;
string systemId = null;
string internalSubset = null;
while (reader.Read() && reader.TokenType != Newtonsoft.Json.JsonToken.EndObject)
{
switch (reader.Value.ToString())
{
case "@name":
reader.Read();
name = reader.Value.ToString();
break;
case "@public":
reader.Read();
publicId = reader.Value.ToString();
break;
case "@system":
reader.Read();
systemId = reader.Value.ToString();
break;
case "@internalSubset":
reader.Read();
internalSubset = reader.Value.ToString();
break;
default:
throw new Newtonsoft.Json.JsonSerializationException("Unexpected property name encountered while deserializing XmlDeclaration: " + reader.Value);
}
}
IXmlNode documentType = document.CreateXmlDocumentType(name, publicId, systemId, internalSubset);
currentNode.AppendChild(documentType);
}
private void DeserializeNode(Newtonsoft.Json.JsonReader reader, IXmlDocument document, XmlNamespaceManager manager, IXmlNode currentNode)
{
do
{
switch (reader.TokenType)
{
case Newtonsoft.Json.JsonToken.PropertyName:
if (currentNode.NodeType == XmlNodeType.Document && document.DocumentElement != null)
throw new Newtonsoft.Json.JsonSerializationException("JSON root object has multiple properties. The root object must have a single property in order to create a valid XML document. Consider specifing a DeserializeRootElementName.");
string propertyName = reader.Value.ToString();
reader.Read();
if (reader.TokenType == Newtonsoft.Json.JsonToken.StartArray)
{
int count = 0;
while (reader.Read() && reader.TokenType != Newtonsoft.Json.JsonToken.EndArray)
{
DeserializeValue(reader, document, manager, propertyName, currentNode);
count++;
}
if (count == 1 && WriteArrayAttribute)
{
IXmlElement arrayElement = currentNode.ChildNodes.OfType<IXmlElement>().Single(n => n.LocalName == propertyName);
AddJsonArrayAttribute(arrayElement, document);
}
}
else
{
DeserializeValue(reader, document, manager, propertyName, currentNode);
}
break;
case Newtonsoft.Json.JsonToken.StartConstructor:
string constructorName = reader.Value.ToString();
while (reader.Read() && reader.TokenType != Newtonsoft.Json.JsonToken.EndConstructor)
{
DeserializeValue(reader, document, manager, constructorName, currentNode);
}
break;
case Newtonsoft.Json.JsonToken.Comment:
currentNode.AppendChild(document.CreateComment((string)reader.Value));
break;
case Newtonsoft.Json.JsonToken.EndObject:
case Newtonsoft.Json.JsonToken.EndArray:
return;
default:
throw new Newtonsoft.Json.JsonSerializationException("Unexpected JsonToken when deserializing node: " + reader.TokenType);
}
}
while (reader.TokenType == Newtonsoft.Json.JsonToken.PropertyName || reader.Read());
// don't read if current token is a property. token was already read when parsing element attributes
}
