internal override void writeJson(Newtonsoft.Json.JsonTextWriter writer)
{
writer.WriteStartArray();
foreach (Schema schema in this.schemas)
{
schema.writeJson(writer);
}
writer.WriteEndArray();
}
public override void WriteValue(object Value, Newtonsoft.Json.JsonWriter Writer, MudObject Owner)
{
var contents = Value as Dictionary<RelativeLocations, List<MudObject>>;
if (contents == null) throw new InvalidOperationException();
Writer.WriteStartObject();
foreach (var relloc in contents)
{
Writer.WritePropertyName(RelativeLocationToString(relloc.Key));
Writer.WriteStartArray();
foreach (var mudObject in relloc.Value.Where(o => o.IsNamedObject && o.IsInstance))
Writer.WriteValue(mudObject.GetFullName());
Writer.WriteEndArray();
}
Writer.WriteEndObject();
}
public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
{
IList items = (IList)value;
if (value != null && items.Count > 0)
{
if (items.Count == 1 && this.IsSingleItemArray())
{
Control item = (Control)items[0];
if (!item.Visible)
{
writer.WriteNull();
return;
}
if (!(item is IProxyContainer))
{
writer.WriteRawValue(this.Format(items[0] as Control));
}
else
{
List<string> ids = ((IProxyContainer)item).GetIDS();
if (ids != null && ids.Count > 0)
{
if (ids.Count == 1)
{
writer.WriteRawValue(this.Format(ids[0]));
}
else
{
writer.WriteStartArray();
foreach (string id in ids)
{
writer.WriteRawValue(this.Format(id));
}
writer.WriteEndArray();
}
}
}
}
else
{
bool visible = false;
foreach (Observable item in items)
{
if (item.Visible)
{
visible = true;
}
}
if (visible)
{
writer.WriteStartArray();
foreach (Observable item in items)
{
if (item.Visible)
{
if (!(item is IProxyContainer))
{
writer.WriteRawValue(this.Format(item));
}
else
{
List<string> ids = ((IProxyContainer)item).GetIDS();
if (ids != null && ids.Count > 0)
{
foreach (string id in ids)
{
writer.WriteRawValue(this.Format(id));
}
}
}
}
}
writer.WriteEndArray();
}
else
{
writer.WriteNull();
}
}
}
}
/// <summary>
/// Writes the json.
/// </summary>
/// <param name="writer">The writer.</param>
/// <param name="value">The value.</param>
/// <param name="serializer">The serializer.</param>
public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer) {
DataTable table = value as DataTable;
writer.WriteStartObject();
writer.WritePropertyName("TableName");
writer.WriteValue(table.TableName);
writer.WritePropertyName("Columns");
writer.WriteStartArray();
foreach (DataColumn column in table.Columns) {
writer.WriteStartObject();
writer.WritePropertyName("AllowDBNull");
writer.WriteValue(column.AllowDBNull);
writer.WritePropertyName("AutoIncrement");
writer.WriteValue(column.AutoIncrement);
writer.WritePropertyName("AutoIncrementSeed");
writer.WriteValue(column.AutoIncrementSeed);
writer.WritePropertyName("AutoIncrementStep");
writer.WriteValue(column.AutoIncrementStep);
writer.WritePropertyName("Caption");
writer.WriteValue(column.Caption);
writer.WritePropertyName("ColumnName");
writer.WriteValue(column.ColumnName);
writer.WritePropertyName("DataType");
writer.WriteValue(column.DataType.Name);
writer.WritePropertyName("DateTimeMode");
writer.WriteValue(column.DateTimeMode.ToString());
writer.WritePropertyName("DefaultValue");
writer.WriteValue(column.DefaultValue);
writer.WritePropertyName("MaxLength");
writer.WriteValue(column.MaxLength);
writer.WritePropertyName("Ordinal");
writer.WriteValue(column.Ordinal);
writer.WritePropertyName("ReadOnly");
writer.WriteValue(column.ReadOnly);
writer.WritePropertyName("Unique");
writer.WriteValue(column.Unique);
writer.WriteEndObject();
}
writer.WriteEndArray();
writer.WritePropertyName("Rows");
writer.WriteStartArray();
foreach (DataRow row in table.Rows) {
if (row.RowState != DataRowState.Deleted && row.RowState != DataRowState.Detached) {
writer.WriteStartArray();
for (int index = 0; index <= table.Columns.Count - 1; index++) {
writer.WriteValue(row[index]);
}
writer.WriteEndArray();
}
}
writer.WriteEndArray();
// Write out primary key if the table has one. This will be useful when deserializing the table.
// We will write it out as an array of column names
writer.WritePropertyName("PrimaryKey");
writer.WriteStartArray();
if (table.PrimaryKey.Length > 0) {
foreach (DataColumn column in table.PrimaryKey) {
writer.WriteValue(column.ColumnName);
}
}
writer.WriteEndArray();
writer.WriteEndObject();
}
/// <summary>
/// Writes the JSON representation of the object.
/// </summary>
public override void WriteJson( Newtonsoft.Json.JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer )
{
var catalog = (Catalog)value;
if( catalog.Uuid != Guid.Empty )
{
writer.WriteStartObject();
writer.WritePropertyName( "uuid" );
writer.WriteValue( catalog.Uuid );
if( !String.IsNullOrEmpty( catalog.Name ) )
{
writer.WritePropertyName( "name" );
writer.WriteValue( catalog.Name );
}
if( catalog.ValidAttributes.Length > 0 )
{
writer.WritePropertyName( "validAttributes" );
writer.WriteStartArray();
foreach( var att in catalog.ValidAttributes )
{
writer.WriteValue( att );
}
writer.WriteEndArray();
}
if( catalog.CatalogEntries.Length > 0 )
{
writer.WritePropertyName( "catalogEntries" );
serializer.Serialize( writer, catalog.CatalogEntries );
}
writer.WriteEndObject();
}
}
internal void writeJson(Newtonsoft.Json.JsonTextWriter writer)
{
writer.WriteStartObject();
//JsonHelper.writeIfNotNullOrEmpty(writer, "name", this.Name);
JsonHelper.writeIfNotNullOrEmpty(writer, "doc", this.Doc);
if (null != this.Request)
{
writer.WritePropertyName("request");
writer.WriteStartArray();
foreach (Parameter parameter in this.Request)
{
System.Diagnostics.Debug.Assert(parameter != null);
parameter.writeJson(writer);
}
writer.WriteEndArray();
}
if (null != this.Response)
{
writer.WritePropertyName("response");
this.Response.writeJson(writer);
}
if (null != this.Error)
{
writer.WritePropertyName("errors");
this.Error.writeJson(writer);
}
writer.WriteEndObject();
}
public void Write(Newtonsoft.Json.JsonWriter writer, object value)
{
var grid = (TileData[, ,])value;
int w = grid.GetLength(2);
int h = grid.GetLength(1);
int d = grid.GetLength(0);
writer.WriteStartObject();
writer.WritePropertyName("Width");
writer.WriteValue(w);
writer.WritePropertyName("Height");
writer.WriteValue(h);
writer.WritePropertyName("Depth");
writer.WriteValue(d);
writer.WritePropertyName("TileData");
writer.WriteStartArray();
var queue = new BlockingCollection<Tuple<int, byte[]>>();
var writerTask = Task.Factory.StartNew(() =>
{
foreach (var tuple in queue.GetConsumingEnumerable())
{
writer.WriteValue(tuple.Item1);
writer.WriteValue(tuple.Item2);
}
});
Parallel.For(0, d, z =>
{
using (var memStream = new MemoryStream())
{
using (var compressStream = new DeflateStream(memStream, CompressionMode.Compress, true))
using (var bufferedStream = new BufferedStream(compressStream))
using (var streamWriter = new BinaryWriter(bufferedStream))
{
var srcArr = grid;
for (int y = 0; y < h; ++y)
for (int x = 0; x < w; ++x)
streamWriter.Write(srcArr[z, y, x].Raw);
}
queue.Add(new Tuple<int, byte[]>(z, memStream.ToArray()));
}
});
queue.CompleteAdding();
writerTask.Wait();
writer.WriteEndArray();
writer.WriteEndObject();
}
/// <summary>
/// Writes enum schema in JSON format
/// </summary>
/// <param name="writer">JSON writer</param>
/// <param name="names">list of named schema already written</param>
/// <param name="encspace">enclosing namespace of the enum schema</param>
protected internal override void WriteJsonFields(Newtonsoft.Json.JsonTextWriter writer,
SchemaNames names, string encspace)
{
base.WriteJsonFields(writer, names, encspace);
writer.WritePropertyName("symbols");
writer.WriteStartArray();
foreach (string s in this.Symbols)
writer.WriteValue(s);
writer.WriteEndArray();
}
/// <summary>
/// Writes named schema in JSON format
/// </summary>
/// <param name="writer">JSON writer</param>
/// <param name="names">list of named schemas already written</param>
/// <param name="encspace">enclosing namespace of the named schema</param>
protected internal override void WriteJsonFields(Newtonsoft.Json.JsonTextWriter writer, SchemaNames names, string encspace)
{
this.SchemaName.WriteJson(writer, names, encspace);
if (null != aliases)
{
writer.WritePropertyName("aliases");
writer.WriteStartArray();
foreach (SchemaName name in aliases)
{
string fullname = (null != name.Space) ? name.Space + "." + name.Name : name.Name;
writer.WriteValue(fullname);
}
writer.WriteEndArray();
}
}
/// <summary>
/// Writes Protocol in JSON format
/// </summary>
/// <param name="writer">JSON writer</param>
/// <param name="names">list of named schemas already written</param>
internal void WriteJson(Newtonsoft.Json.JsonTextWriter writer, SchemaNames names)
{
writer.WriteStartObject();
JsonHelper.writeIfNotNullOrEmpty(writer, "protocol", this.Name);
JsonHelper.writeIfNotNullOrEmpty(writer, "namespace", this.Namespace);
JsonHelper.writeIfNotNullOrEmpty(writer, "doc", this.Doc);
writer.WritePropertyName("types");
writer.WriteStartArray();
foreach (Schema type in this.Types)
type.WriteJson(writer, names, this.Namespace);
writer.WriteEndArray();
writer.WritePropertyName("messages");
writer.WriteStartObject();
foreach (KeyValuePair<string,Message> message in this.Messages)
{
writer.WritePropertyName(message.Key);
message.Value.writeJson(writer, names, this.Namespace);
}
writer.WriteEndObject();
writer.WriteEndObject();
}
public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
{
IList items = (IList)value;
if (value != null && items.Count > 0)
{
if (items.Count == 1 && this.IsSingleItemArray())
{
Control item = (Control)items[0];
var pnl = item as AbstractPanel;
if (!item.Visible)
{
writer.WriteNull();
return;
}
writer.WriteRawValue(this.Format(items[0] as Control));
}
else
{
bool visible = false;
foreach (Observable item in items)
{
if (item.Visible)
{
visible = true;
}
}
if (visible)
{
writer.WriteStartArray();
foreach (Observable item in items)
{
if (item.Visible)
{
writer.WriteRawValue(this.Format(item));
}
}
writer.WriteEndArray();
}
else
{
writer.WriteNull();
}
}
}
}
/// <summary>
/// Writes union schema in JSON format
/// </summary>
/// <param name="writer">JSON writer</param>
/// <param name="names">list of named schemas already written</param>
/// <param name="encspace">enclosing namespace of the schema</param>
protected internal override void WriteJson(Newtonsoft.Json.JsonTextWriter writer, SchemaNames names, string encspace)
{
writer.WriteStartArray();
foreach (Schema schema in this.Schemas)
schema.WriteJson(writer, names, encspace);
writer.WriteEndArray();
}
protected override void WriteProperties(Newtonsoft.Json.JsonTextWriter writer)
{
base.WriteProperties(writer);
if (null != this.Fields && this.Fields.Count > 0)
{
writer.WritePropertyName("fields");
writer.WriteStartArray();
foreach (Field field in this.Fields.Values)
{
field.writeJson(writer);
}
writer.WriteEndArray();
}
}
private void SerializeGroupedNodes(Newtonsoft.Json.JsonWriter writer, IXmlNode node, XmlNamespaceManager manager, bool writePropertyName)
{
// group nodes together by name
Dictionary<string, List<IXmlNode>> nodesGroupedByName = new Dictionary<string, List<IXmlNode>>();
for (int i = 0; i < node.ChildNodes.Count; i++)
{
IXmlNode childNode = node.ChildNodes[i];
string nodeName = GetPropertyName(childNode, manager);
List<IXmlNode> nodes;
if (!nodesGroupedByName.TryGetValue(nodeName, out nodes))
{
nodes = new List<IXmlNode>();
nodesGroupedByName.Add(nodeName, nodes);
}
nodes.Add(childNode);
}
// loop through grouped nodes. write single name instances as normal,
// write multiple names together in an array
foreach (KeyValuePair<string, List<IXmlNode>> nodeNameGroup in nodesGroupedByName)
{
List<IXmlNode> groupedNodes = nodeNameGroup.Value;
bool writeArray;
if (groupedNodes.Count == 1)
{
writeArray = IsArray(groupedNodes[0]);
}
else
{
writeArray = true;
}
if (!writeArray)
{
SerializeNode(writer, groupedNodes[0], manager, writePropertyName);
}
else
{
string elementNames = nodeNameGroup.Key;
if (writePropertyName)
writer.WritePropertyName(elementNames);
writer.WriteStartArray();
for (int i = 0; i < groupedNodes.Count; i++)
{
SerializeNode(writer, groupedNodes[i], manager, false);
}
writer.WriteEndArray();
}
}
}
/// <summary>
/// Writes the JSON representation of the object.
/// </summary>
public override void WriteJson( Newtonsoft.Json.JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer )
{
var configuration = value as Configuration;
if( configuration != null )
{
writer.WriteStartObject();
if(configuration.PartAttributes.Length > 0 )
{
writer.WritePropertyName( "partAttributes" );
writer.WriteStartArray();
foreach( var att in configuration.PartAttributes )
{
serializer.Serialize( writer, att );
}
writer.WriteEndArray();
}
if( configuration.CharacteristicAttributes.Length > 0 )
{
writer.WritePropertyName( "characteristicAttributes" );
writer.WriteStartArray();
foreach( var att in configuration.CharacteristicAttributes )
{
serializer.Serialize( writer, att );
}
writer.WriteEndArray();
}
if( configuration.MeasurementAttributes.Length > 0 )
{
writer.WritePropertyName( "measurementAttributes" );
writer.WriteStartArray();
foreach( var att in configuration.MeasurementAttributes )
{
serializer.Serialize( writer, att );
}
writer.WriteEndArray();
}
if( configuration.ValueAttributes.Length > 0 )
{
writer.WritePropertyName( "valueAttributes" );
writer.WriteStartArray();
foreach( var att in configuration.ValueAttributes )
{
serializer.Serialize( writer, att );
}
writer.WriteEndArray();
}
if( configuration.CatalogAttributes.Length > 0 )
{
writer.WritePropertyName( "catalogAttributes" );
writer.WriteStartArray();
foreach( var att in configuration.CatalogAttributes )
{
serializer.Serialize( writer, att );
}
writer.WriteEndArray();
}
writer.WriteEndObject();
}
}
internal void writeJson(Newtonsoft.Json.JsonTextWriter writer)
{
writer.WriteStartObject();
JsonHelper.writeIfNotNullOrEmpty(writer, "namespace", this.Namespace);
JsonHelper.writeIfNotNullOrEmpty(writer, "doc", this.Doc);
JsonHelper.writeIfNotNullOrEmpty(writer, "protocol", this.Name);
writer.WritePropertyName("types");
writer.WriteStartArray();
foreach (Schema type in this.Types)
{
type.writeJson(writer);
}
writer.WriteEndArray();
writer.WritePropertyName("messages");
writer.WriteStartObject();
foreach (Message message in this.Messages)
{
writer.WritePropertyName(message.Name);
message.writeJson(writer);
}
writer.WriteEndObject();
writer.WriteEndObject();
}
private void WriteIdsArrayJson(Newtonsoft.Json.JsonWriter writer, IEnumerable<object> value, Newtonsoft.Json.JsonSerializer serializer)
{
IEnumerator<Object> collectionEnumerator = (value as IEnumerable<object>).GetEnumerator();
writer.WriteStartArray();
while (collectionEnumerator.MoveNext())
{
WriteResourceIdentifierObject(writer, collectionEnumerator.Current.GetType(), collectionEnumerator.Current);
}
writer.WriteEndArray();
}
public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer)
{
PointSet pointSet = (PointSet)value;
writer.WriteStartObject();
writer.WritePropertyName("Seed");
writer.WriteValue(pointSet.Seed);
writer.WritePropertyName("Points");
writer.WriteStartArray();
for (int i = 0; i < pointSet.Points.Length; ++i)
{
writer.WriteStartArray();
writer.WriteValue(pointSet.Points[i].X);
writer.WriteValue(pointSet.Points[i].Z);
writer.WriteValue(pointSet.Points[i].Y);
writer.WriteEndArray();
}
writer.WriteEndArray();
writer.WriteEndObject();
}
