private void WriteComplexArgument(MessageArgument argument, XmlWriter xmlWriter)
{
xmlWriter.WriteStartElement("value");
xmlWriter.WriteStartElement("struct");
for(int i = 0; i < argument.Children.Count; i++) {
MessageArgument child = argument.Children[i];
xmlWriter.WriteStartElement("member");
xmlWriter.WriteStartElement("name");
xmlWriter.WriteValue(child.Name);
xmlWriter.WriteEndElement();
WriteArgument(child, xmlWriter);
xmlWriter.WriteEndElement();
}
xmlWriter.WriteEndElement();
xmlWriter.WriteEndElement();
}
private void ReadParams(Message message, XmlReader xmlReader)
{
while (xmlReader.Read()) {
if (xmlReader.NodeType == XmlNodeType.Comment)
continue;
if (xmlReader.NodeType == XmlNodeType.EndElement) {
if (xmlReader.LocalName == "params")
break;
if (xmlReader.LocalName != "param")
throw new FormatException();
continue;
}
if (xmlReader.NodeType != XmlNodeType.Element)
throw new FormatException();
if (xmlReader.LocalName != "param")
throw new FormatException();
object value = ReadValue(xmlReader);
if (value is IDictionary<string, object>) {
MessageArgument argument = new MessageArgument();
AddValues(argument, (IDictionary<string,object>)value);
message.Arguments.Add(argument);
} else {
message.Arguments.Add(value);
}
}
}
private void WriteArgument(MessageArgument argument, XmlWriter xmlWriter)
{
if (argument.Children.Count == 0) {
WriteValue(argument.Value, argument.Format, xmlWriter);
} else {
WriteComplexArgument(argument, xmlWriter);
}
}
private static void WriteArgument(MessageArgument argument, BinaryWriter writer)
{
writer.Write(argument.Name);
WriteValue(argument.Value, writer);
int sz = argument.Children.Count;
writer.Write(sz);
for (int i = 0; i < sz; i++) {
WriteArgument(argument.Children[i], writer);
}
}
private static void AddValues(MessageArgument argument, IDictionary<string,object> values)
{
foreach (KeyValuePair<string, object> pair in values) {
object value = pair.Value;
if (value is IDictionary<string, object>) {
MessageArgument child = new MessageArgument(pair.Key);
AddValues(argument, (IDictionary<string, object>)value);
argument.Children.Add(child);
} else {
argument.Children.Add(pair.Key, value);
}
}
}
private static MessageArgument ReadArgument(BinaryReader reader)
{
string argName = reader.ReadString();
object value = ReadValue(reader);
MessageArgument argument = new MessageArgument(argName, value);
int sz = reader.ReadInt32();
for (int i = 0; i < sz; i++)
argument.Children.Add(ReadArgument(reader));
return argument;
}
private static void WriteArgument(XmlWriter writer, MessageArgument argument, bool printType)
{
writer.WriteStartElement(argument.Name);
if (argument.Attributes.Count > 0) {
foreach(KeyValuePair<string, object> attribute in argument.Attributes) {
writer.WriteStartAttribute(attribute.Key);
if (attribute.Value != null)
writer.WriteValue(attribute.Value);
writer.WriteEndAttribute();
}
}
object value = argument.Value;
if (value != null) {
string valueType = GetValueType(value);
if (printType)
writer.WriteAttributeString("type", valueType);
if (value is Array) {
string elemType = valueType.Substring(0, valueType.Length - 5);
Array array = (Array) value;
int length = array.GetLength(0);
for (int i = 0; i < length; i++) {
// this is an ugly hack, but speeds work ...
WriteArgument(writer, new MessageArgument(elemType, array.GetValue(i)), false);
}
} else {
if (value is DateTime) {
string format = argument.Format;
value = !String.IsNullOrEmpty(format) ? ((DateTime) value).ToString(format) : ((DateTime) value).ToString();
} else if (value is Stream) {
Stream stream = (Stream) value;
byte[] bytes = new byte[stream.Length];
stream.Read(bytes, 0, bytes.Length);
value = Convert.ToBase64String(bytes);
}
writer.WriteValue(value);
}
}
writer.WriteEndElement();
}
private static MessageArgument ReadArgument(XmlReader reader)
{
MessageArgument argument = null;
string attributeName = reader.LocalName;
string valueType = null;
object value = null;
while (reader.Read()) {
XmlNodeType valueNodeType = reader.NodeType;
if (valueNodeType == XmlNodeType.Comment ||
valueNodeType == XmlNodeType.Whitespace)
continue;
if (valueNodeType == XmlNodeType.Attribute) {
if (reader.LocalName == "type") {
valueType = reader.Value;
continue;
}
if (argument == null)
argument = new MessageArgument(attributeName, value);
argument.Attributes.Add(reader.LocalName, reader.Value);
} else if (reader.NodeType == XmlNodeType.Element) {
if (argument == null)
argument = new MessageArgument(attributeName, value);
argument.Children.Add(ReadArgument(reader));
} else if (reader.NodeType == XmlNodeType.EndElement) {
break;
} else {
value = ReadValue(reader, valueType);
if (argument == null) {
argument = new MessageArgument(attributeName, value);
} else {
argument.Value = value;
}
}
}
return argument;
}
public object Clone()
{
object newValue = Value;
if (newValue is ICloneable)
newValue = ((ICloneable) newValue).Clone();
MessageArgument arg = new MessageArgument(Name, newValue, readOnly);
arg.children = (MessageArguments) children.Clone();
arg.attributes = (MessageAttributes) attributes.Clone();
return arg;
}
private void WriteValue(MessageArgument argument, JsonWriter writer)
{
WriteValue(argument.Value, argument.Format, writer);
}
