public int CompareTo(IVariantData rhs) { VariantExceptionInfo rhsEx = (VariantExceptionInfo)rhs; if (Class != rhsEx.Class) { return(Class.CompareTo(rhsEx.Class)); } if (Message != rhsEx.Message) { return(Message.CompareTo(rhsEx.Message)); } if (Source != rhsEx.Source) { return(Source.CompareTo(rhsEx.Source)); } return(Stack.CompareTo(rhsEx.Stack)); }
private void WriteElement(Variant element) { WriteStartTag(m_stack.Peek().m_name); switch (element.Type) { case VariantBase.EnumType.None: { WriteAttributes(m_stack.Peek().m_attributes); break; } case VariantBase.EnumType.Any: case VariantBase.EnumType.String: case VariantBase.EnumType.Float: case VariantBase.EnumType.Double: case VariantBase.EnumType.Int32: case VariantBase.EnumType.UInt32: case VariantBase.EnumType.Int64: case VariantBase.EnumType.UInt64: case VariantBase.EnumType.Boolean: case VariantBase.EnumType.Date: case VariantBase.EnumType.Time: case VariantBase.EnumType.DateTime: { WriteAttributes(m_stack.Peek().m_attributes); WriteText(element); break; } case VariantBase.EnumType.Dictionary: case VariantBase.EnumType.Bag: { WriteAttributes(m_stack.Peek().m_attributes); if ((m_mode & XmlMode.Preserve) != 0) { if (element.ContainsKey(XmlConst.Attributes)) { WriteAttributes(element[XmlConst.Attributes]); } foreach (VariantItem item in element) { if (item.Key == XmlConst.Attributes) { continue; } else if (item.Key == XmlConst.Text) { WriteText(item.Value); } else if (item.Key == XmlConst.Instruction) { WriteInstruction(item.Value); } else if (item.Key == XmlConst.Comment) { WriteComment(item.Value); } else { Push(item.Key); WriteElement(item.Value); Pop(); } } } else { foreach (VariantItem item in element) { Push(item.Key); WriteVariant(item.Value); Pop(); } } break; } case VariantBase.EnumType.List: { WriteAttributes(m_stack.Peek().m_attributes); foreach (VariantItem item in element) { Push(); WriteVariant(item.Value); Pop(); } break; } case VariantBase.EnumType.Tuple: { m_stack.Peek().m_attributes.Add("size", new Variant(element.Count)); WriteAttributes(m_stack.Peek().m_attributes); foreach (VariantItem item in element) { Push(); WriteVariant(item.Value); Pop(); } break; } case VariantBase.EnumType.TimeSeries: { WriteAttributes(m_stack.Peek().m_attributes); foreach (VariantItem item in element) { Push().Add("time", new Variant(item.Time)); WriteVariant(item.Value); Pop(); } break; } case VariantBase.EnumType.Buffer: { WriteAttributes(m_stack.Peek().m_attributes); m_writer.WriteBase64(element.AsBuffer(), 0, element.AsBuffer().Length); break; } case VariantBase.EnumType.Object: { IVariantObject obj = element.AsObject(); // write class name m_stack.Peek().m_attributes.Add("class", new Variant(obj.Class)); m_stack.Peek().m_attributes.Add("version", new Variant(obj.Version)); WriteAttributes(m_stack.Peek().m_attributes); // write parameter dictionary Push("params"); WriteVariant(obj.Deflate()); Pop(); break; } case VariantBase.EnumType.Exception: { WriteAttributes(m_stack.Peek().m_attributes); VariantExceptionInfo e = element.AsException(); Push("type"); WriteElement(new Variant(e.Class)); Pop(); Push("message"); WriteElement(new Variant(e.Message)); Pop(); if (e.Source.Length != 0) { Push("source"); WriteElement(new Variant(e.Source)); Pop(); } if (e.Stack.Length != 0) { Push("stack"); WriteElement(new Variant(e.Stack)); Pop(); } break; } case VariantBase.EnumType.Array: { TypedArray array = element.AsArray(); m_stack.Peek().m_attributes.Add("size", new Variant(array.Count)); m_stack.Peek().m_attributes.Add("elementType", new Variant(array.ElementType.ToString())); WriteAttributes(m_stack.Peek().m_attributes); WriteDelegate writer = null; switch (array.ElementType) { case VariantBase.EnumType.Float: writer = o => m_writer.WriteString(VariantBase.ToString((float)o)); break; case VariantBase.EnumType.Double: writer = o => m_writer.WriteString(VariantBase.ToString((double)o)); break; case VariantBase.EnumType.String: writer = o => m_writer.WriteString((string)o); break; case VariantBase.EnumType.Boolean: writer = o => m_writer.WriteString(VariantBase.ToString((bool)o)); break; case VariantBase.EnumType.Int32: writer = o => m_writer.WriteString(VariantBase.ToString((int)o)); break; case VariantBase.EnumType.UInt32: writer = o => m_writer.WriteString(VariantBase.ToString((uint)o)); break; case VariantBase.EnumType.Int64: writer = o => m_writer.WriteString(VariantBase.ToString((long)o)); break; case VariantBase.EnumType.UInt64: writer = o => m_writer.WriteString(VariantBase.ToString((ulong)o)); break; case VariantBase.EnumType.Time: writer = o => m_writer.WriteString(VariantBase.ToString((TimeSpan)o)); break; case VariantBase.EnumType.DateTime: writer = o => m_writer.WriteString(VariantBase.ToString((DateTime)o)); break; default: throw new VariantException("Case exhaustion: " + array.ElementType); } for (int i = 0; i < array.Count; ++i) { m_writer.WriteStartElement(XmlConst.Default); writer(array[i]); m_writer.WriteEndElement(); } break; } case VariantBase.EnumType.DataTable: { #if !DISABLE_DATATABLE DataTable dataTable = element.AsDataTable(); m_stack.Peek().m_attributes.Add("rows", new Variant(dataTable.Rows.Count)); m_stack.Peek().m_attributes.Add("columns", new Variant(dataTable.Columns.Count)); WriteAttributes(m_stack.Peek().m_attributes); foreach (DataColumn col in dataTable.Columns) { Push("Column"); m_stack.Peek().m_attributes.Add("name", new Variant(col.ColumnName)); m_stack.Peek().m_attributes.Add("type", new Variant(VariantPrimitiveBase.TypeToEnum(col.DataType).ToString())); WriteElement(new Variant()); Pop(); } foreach (DataColumn col in dataTable.Columns) { Action <object> writer; switch (VariantPrimitiveBase.TypeToEnum(col.DataType)) { case VariantBase.EnumType.Float: writer = o => m_writer.WriteString(VariantBase.ToString((float)o)); break; case VariantBase.EnumType.Double: writer = o => m_writer.WriteString(VariantBase.ToString((double)o)); break; case VariantBase.EnumType.String: writer = o => m_writer.WriteString((string)o); break; case VariantBase.EnumType.Boolean: writer = o => m_writer.WriteString(VariantBase.ToString((bool)o)); break; case VariantBase.EnumType.Int32: writer = o => m_writer.WriteString(VariantBase.ToString((int)o)); break; case VariantBase.EnumType.UInt32: writer = o => m_writer.WriteString(VariantBase.ToString((uint)o)); break; case VariantBase.EnumType.Int64: writer = o => m_writer.WriteString(VariantBase.ToString((long)o)); break; case VariantBase.EnumType.UInt64: writer = o => m_writer.WriteString(VariantBase.ToString((ulong)o)); break; case VariantBase.EnumType.Time: writer = o => m_writer.WriteString(VariantBase.ToString((TimeSpan)o)); break; case VariantBase.EnumType.DateTime: writer = o => m_writer.WriteString(VariantBase.ToString((DateTime)o)); break; default: throw new VariantException("Case exhaustion: " + VariantPrimitiveBase.TypeToEnum(col.DataType)); } Push("Column").Add("name", new Variant(col.ColumnName)); WriteStartTag("s"); WriteAttributes(m_stack.Peek().m_attributes); foreach (DataRow row in dataTable.Rows) { m_writer.WriteStartElement(XmlConst.Default); writer(row[col]); m_writer.WriteEndElement(); } WriteEndTag(); Pop(); } break; #else throw new NotSupportedException("Datatables are not supported on this platform."); #endif } default: throw new VariantException("Case exhaustion: " + element.Type); } WriteEndTag(); }
protected void WriteVariant(Variant v) { VariantBase.EnumType type = v.Type; Write((Int32)type); switch (type) { case VariantBase.EnumType.None: break; case VariantBase.EnumType.String: case VariantBase.EnumType.Any: Write(v.As <string>()); break; case VariantBase.EnumType.Float: Write(v.As <float>()); break; case VariantBase.EnumType.Double: Write(v.As <double>()); break; case VariantBase.EnumType.Int32: Write(v.As <Int32>()); break; case VariantBase.EnumType.UInt32: Write(v.As <UInt32>()); break; case VariantBase.EnumType.Int64: Write(v.As <Int64>()); break; case VariantBase.EnumType.UInt64: Write(v.As <UInt64>()); break; case VariantBase.EnumType.Boolean: Write(v.As <bool>()); break; case VariantBase.EnumType.Time: Write(v.As <TimeSpan>()); break; case VariantBase.EnumType.DateTime: Write(v.As <DateTime>()); break; case VariantBase.EnumType.List: case VariantBase.EnumType.Tuple: Write(v.Count); foreach (VariantItem item in v) { WriteVariant(item.Value); } break; case VariantBase.EnumType.Dictionary: case VariantBase.EnumType.Bag: Write(v.Count); foreach (VariantItem item in v) { Write(item.Key); WriteVariant(item.Value); } break; case VariantBase.EnumType.TimeSeries: Write(v.Count); foreach (VariantItem item in v) { Write(item.Time); WriteVariant(item.Value); } break; case VariantBase.EnumType.Object: IVariantObject o = v.AsObject(); Write(o.Class); Write(o.Version); WriteVariant(o.Deflate()); break; case VariantBase.EnumType.Exception: VariantExceptionInfo x = v.AsException(); Write(x.Class); Write(x.Message); Write(x.Source); Write(x.Stack); break; case VariantBase.EnumType.Buffer: Write(v.AsBuffer().Length); Write(v.AsBuffer(), true); break; case VariantBase.EnumType.DataTable: Write(v.AsDataTable()); break; case VariantBase.EnumType.Array: Write(v.AsArray()); break; default: throw new VariantException("Case exhaustion: " + type.ToString()); } }
private StringBuilder ToString(bool summarise, string indent, StringBuilder sb) { const string tab = " "; const string noIndent = ""; sb.Append(indent); switch (Type) { case EnumType.None: sb.Append("None"); break; case EnumType.Any: sb.Append("Any('" + As <string>() + "')"); break; case EnumType.String: sb.Append("'" + As <string>() + "'"); break; case EnumType.Int32: case EnumType.UInt32: case EnumType.Int64: case EnumType.UInt64: case EnumType.Double: case EnumType.Boolean: case EnumType.Time: case EnumType.DateTime: sb.Append(Value.ToString()); break; case EnumType.List: { if (summarise) { sb.Append("List(size=" + Count.ToString() + ")"); } else { sb.Append("[\n"); int count = Count; foreach (VariantItem item in this) { item.Value.ToString(false, indent + tab, sb); if (--count > 0) { sb.Append(","); } sb.Append("\n"); } sb.Append(indent + "]"); } break; } case EnumType.Dictionary: { if (summarise) { sb.Append("Dictionary(size=" + Count.ToString() + ")"); } else { sb.Append("{\n"); int count = Count; foreach (VariantItem item in this) { sb.Append(indent + tab + item.Key + ": "); if (item.Value.Is(EnumType.Primitive | EnumType.None)) { item.Value.ToString(false, noIndent, sb); } else { sb.Append("\n"); item.Value.ToString(false, indent + tab + tab, sb); } if (--count != 0) { sb.Append(","); } sb.Append("\n"); } sb.Append(indent + "}"); } break; } case EnumType.Bag: { if (summarise) { sb.Append("Bag(size=" + Count + ")"); } else { sb.Append("[\n"); int count = Count; foreach (VariantItem item in this) { sb.Append(indent + tab + "(" + item.Key + ", "); if (item.Value.Is(EnumType.Primitive)) { item.Value.ToString(false, noIndent, sb); } else { sb.Append("\n"); item.Value.ToString(false, indent + tab, sb); } sb.Append(")"); if (--count != 0) { sb.Append(","); } sb.Append("\n"); } sb.Append(indent + "]"); } break; } case EnumType.TimeSeries: { if (summarise) { sb.Append("TimeSeries(size=" + Count + ")"); } else { sb.Append("TimeSeries(\n"); int count = Count; foreach (VariantItem item in this) { sb.Append(indent + tab + "(" + item.Time + ", "); if (item.Value.Is(EnumType.Primitive)) { item.Value.ToString(false, noIndent, sb); } else { sb.Append("\n"); item.Value.ToString(false, indent + tab, sb); } sb.Append(")"); if (--count != 0) { sb.Append(","); } sb.Append("\n"); } sb.Append(indent + ")"); } break; } case EnumType.Buffer: { if (summarise) { sb.Append("Buffer(size=").Append(Count).Append(")"); } else { sb.Append("Buffer(").Append(Encoding.ASCII.GetString(AsBuffer())).Append(')'); } break; } case EnumType.Tuple: { if (summarise) { sb.Append("Tuple(size=").Append(Count).Append(")"); } else { sb.Append("(").AppendLine(); int count = Count; foreach (VariantItem item in this) { item.Value.ToString(false, indent + tab, sb); if (--count != 0) { sb.Append(","); } sb.AppendLine(); } sb.Append(indent).Append(")"); } break; } case EnumType.Exception: { VariantExceptionInfo x = AsException(); sb.Append(x.Class).Append("('").Append(x.Message).Append("')"); if (x.Source.Length > 0) { sb.Append(" in: ").Append(x.Source); } if (x.Stack.Length > 0) { sb.AppendLine().Append(x.Stack); } break; } case EnumType.Object: { IVariantObject o = AsObject(); if (summarise) { sb.Append(o.Class).Append("(version=").Append(o.Version).Append(")"); } else { sb.Append(o.Class).Append("(version=").Append(o.Version).Append(")(").AppendLine(); o.Deflate().ToString(false, indent + tab, sb); sb.AppendLine().Append(indent).Append(")"); } break; } case EnumType.Array: { TypedArray a = AsArray(); if (summarise) { sb.Append("Array(size=").Append(a.Count).Append(", type=").Append(a.ElementType).Append(")"); } else { sb.Append("Array("); int lastIndex = a.Count - 1; for (int i = 0; i < a.Count; ++i) { sb.Append(a[i].ToString()).Append(i != lastIndex ? "," : ")"); } } break; } default: sb.Append("UNKNOWN<").Append(Type).Append(">"); break; } return(sb); }
public Variant(VariantExceptionInfo arg) { Value = arg; }
public VariantExceptionInfo(VariantExceptionInfo rhs) : this(rhs.Class, rhs.Message, rhs.Source, rhs.Stack) { }
public static int GetByteCountVariant(Variant v) { VariantBase.EnumType type = v.Type; var writeCount = sizeof(Int32); switch (type) { case VariantBase.EnumType.None: break; case VariantBase.EnumType.String: case VariantBase.EnumType.Any: writeCount += GetByteCountString(v.As <string>()); break; case VariantBase.EnumType.Float: writeCount += sizeof(float); break; case VariantBase.EnumType.Double: writeCount += sizeof(double); break; case VariantBase.EnumType.Int32: writeCount += sizeof(Int32); break; case VariantBase.EnumType.UInt32: writeCount += sizeof(UInt32); break; case VariantBase.EnumType.Int64: writeCount += sizeof(Int64); break; case VariantBase.EnumType.UInt64: writeCount += sizeof(UInt64); break; case VariantBase.EnumType.Boolean: writeCount += sizeof(Int32); break; case VariantBase.EnumType.Time: writeCount += sizeof(Int64); break; case VariantBase.EnumType.DateTime: writeCount += sizeof(Int64); break; case VariantBase.EnumType.List: case VariantBase.EnumType.Tuple: writeCount += sizeof(Int32); foreach (VariantItem item in v) { writeCount += GetByteCountVariant(item.Value); } break; case VariantBase.EnumType.Dictionary: case VariantBase.EnumType.Bag: writeCount += sizeof(Int32); foreach (VariantItem item in v) { writeCount += GetByteCountString(item.Key); writeCount += GetByteCountVariant(item.Value); } break; case VariantBase.EnumType.TimeSeries: writeCount += sizeof(Int32); foreach (VariantItem item in v) { writeCount += sizeof(Int64); writeCount += GetByteCountVariant(item.Value); } break; case VariantBase.EnumType.Object: IVariantObject o = v.AsObject(); writeCount += GetByteCountString(o.Class); writeCount += sizeof(Int32); writeCount += GetByteCountVariant(o.Deflate()); break; case VariantBase.EnumType.Exception: VariantExceptionInfo x = v.AsException(); writeCount += GetByteCountString(x.Class); writeCount += GetByteCountString(x.Message); writeCount += GetByteCountString(x.Source); writeCount += GetByteCountString(x.Stack); break; case VariantBase.EnumType.Buffer: writeCount += sizeof(Int32); writeCount += GetByteCountBytes(v.AsBuffer().Length, true); break; case VariantBase.EnumType.DataTable: writeCount += GetByteCountDataTable(v.AsDataTable()); break; case VariantBase.EnumType.Array: writeCount += GetByteCountArray(v.AsArray()); break; default: throw new VariantException("Case exhaustion: " + type.ToString()); } return(writeCount); }