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 TypedArray(TypedArray rhs) { ElementType = rhs.ElementType; Value = new Object[rhs.Value.Length]; }
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(); }
public Variant(TypedArray arg) { Value = arg; }
public int CompareTo(IVariantData value) { TypedArray rhsValue = ((TypedArray)value); if (Value.Length != rhsValue.Value.Length) { return(Value.Length.CompareTo(rhsValue.Value.Length)); } else if (ElementType != rhsValue.ElementType) { return(ElementType.CompareTo(rhsValue.ElementType)); } else { CompareDelegate comparer = null; switch (ElementType) { case VariantBase.EnumType.Float: comparer = delegate(object lhs, object rhs) { return(((float)lhs).CompareTo((float)rhs)); }; break; case VariantBase.EnumType.Double: comparer = delegate(object lhs, object rhs) { return(((double)lhs).CompareTo((double)rhs)); }; break; case VariantBase.EnumType.Boolean: comparer = delegate(object lhs, object rhs) { return(((bool)lhs).CompareTo((bool)rhs)); }; break; case VariantBase.EnumType.String: comparer = delegate(object lhs, object rhs) { return(((string)lhs).CompareTo((string)rhs)); }; break; case VariantBase.EnumType.Int32: comparer = delegate(object lhs, object rhs) { return(((Int32)lhs).CompareTo((Int32)rhs)); }; break; case VariantBase.EnumType.UInt32: comparer = delegate(object lhs, object rhs) { return(((UInt32)lhs).CompareTo((UInt32)rhs)); }; break; case VariantBase.EnumType.Int64: comparer = delegate(object lhs, object rhs) { return(((Int64)lhs).CompareTo((Int64)rhs)); }; break; case VariantBase.EnumType.UInt64: comparer = delegate(object lhs, object rhs) { return(((UInt64)lhs).CompareTo((UInt64)rhs)); }; break; case VariantBase.EnumType.Time: comparer = delegate(object lhs, object rhs) { return(((TimeSpan)lhs).CompareTo((TimeSpan)rhs)); }; break; case VariantBase.EnumType.DateTime: comparer = delegate(object lhs, object rhs) { return(((DateTime)lhs).CompareTo((DateTime)rhs)); }; break; default: throw new VariantException("Case exhaustion: " + ElementType); } for (int i = 0; i < Value.Length; ++i) { int cmp = comparer(Value[i], rhsValue.Value[i]); if (cmp != 0) { return(cmp); } } } return(0); }
private TypedArray ReadArray() { int size = ReadInt32(); Variant.EnumType elementType = (Variant.EnumType)ReadInt32(); TypedArray array = new TypedArray(elementType, size); ReadDelegate reader = null; switch (elementType) { case VariantBase.EnumType.Float: reader = () => ReadFloat(); break; case VariantBase.EnumType.Double: reader = () => ReadDouble(); break; case VariantBase.EnumType.Boolean: reader = () => ReadBoolean(); break; case VariantBase.EnumType.String: reader = () => ReadString(); break; case VariantBase.EnumType.Int32: reader = () => ReadInt32(); break; case VariantBase.EnumType.UInt32: reader = () => ReadUInt32(); break; case VariantBase.EnumType.Int64: reader = () => ReadInt64(); break; case VariantBase.EnumType.UInt64: reader = () => ReadUInt64(); break; case VariantBase.EnumType.Time: reader = () => ReadTime(); break; case VariantBase.EnumType.DateTime: reader = () => ReadDateTime(); break; default: throw new VariantException("Case exhaustion: " + array.ElementType); } for (int i = 0; i < size; ++i) { array[i] = reader(); } return array; }
private TypedArray ReadArray() { int size = ReadInt32(); Variant.EnumType elementType = (Variant.EnumType)ReadInt32(); TypedArray array = new TypedArray(elementType, size); ReadDelegate reader = null; switch (elementType) { case VariantBase.EnumType.Float: reader = () => ReadFloat(); break; case VariantBase.EnumType.Double: reader = () => ReadDouble(); break; case VariantBase.EnumType.Boolean: reader = () => ReadBoolean(); break; case VariantBase.EnumType.String: reader = () => ReadString(); break; case VariantBase.EnumType.Int32: reader = () => ReadInt32(); break; case VariantBase.EnumType.UInt32: reader = () => ReadUInt32(); break; case VariantBase.EnumType.Int64: reader = () => ReadInt64(); break; case VariantBase.EnumType.UInt64: reader = () => ReadUInt64(); break; case VariantBase.EnumType.Time: reader = () => ReadTime(); break; case VariantBase.EnumType.DateTime: reader = () => ReadDateTime(); break; default: throw new VariantException("Case exhaustion: " + array.ElementType); } for (int i = 0; i < size; ++i) { array[i] = reader(); } return(array); }
private void Write(TypedArray arg) { WriteDelegate writer; switch (arg.ElementType) { case VariantBase.EnumType.Float: writer = o => Write((float)o); break; case VariantBase.EnumType.Double: writer = o => Write((double)o); break; case VariantBase.EnumType.String: writer = o => Write((string)o); break; case VariantBase.EnumType.Boolean: writer = o => Write((bool)o); break; case VariantBase.EnumType.Int32: writer = o => Write((int)o); break; case VariantBase.EnumType.UInt32: writer = o => Write((uint)o); break; case VariantBase.EnumType.Int64: writer = o => Write((long)o); break; case VariantBase.EnumType.UInt64: writer = o => Write((ulong)o); break; case VariantBase.EnumType.Time: writer = o => Write((TimeSpan)o); break; case VariantBase.EnumType.DateTime: writer = o => Write((DateTime)o); break; default: throw new VariantException("Case exhaustion: " + arg.ElementType); } Write(arg.Count); Write((int)arg.ElementType); for (int i = 0; i < arg.Count; ++i) { writer(arg[i]); } }