public VariantTuple(VariantTuple rhs) { Value = new Variant[rhs.Count]; Array.Copy(rhs.Value, Value, rhs.Count); }
public VariantTuple() { Value = new Variant[0]; }
public VariantTuple(int capacity) { Value = new Variant[capacity]; Clear(); }
public void Add(string key, Variant value) { Value.Add(new KeyValuePair <string, Variant>(key, value)); }
public void Add(Variant value) { Value.Add(value); }
public ElementInfo(string name) { m_name = name; m_attributes = new Variant(VariantBase.EnumType.Dictionary); }
public void Add(string key, Variant value) { Value.Add(key, value); }
public void Write(Variant value) { WriteDocument(value); }
public static string ToString(Variant value) { return(ToString(value, XmlMode.Default)); }
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(); }
private void WriteComment(Variant comment) { m_writer.WriteComment(comment.As <string>()); }
public VariantObjectProxy(string classname) { m_classname = classname; m_params = new Variant(Variant.EnumType.None); m_version = 0; }
public void Inflate(Variant param, int version) { m_params = param; m_version = version; }
public Variant ReadVariant() { Variant.EnumType type = ReadType(); switch (type) { case Variant.EnumType.None: return(new Variant(Variant.EnumType.None)); case Variant.EnumType.String: return(new Variant(ReadString())); case Variant.EnumType.Any: return(new Variant(Variant.EnumType.Any, ReadString())); case Variant.EnumType.Float: return(new Variant(ReadFloat())); case Variant.EnumType.Double: return(new Variant(ReadDouble())); case Variant.EnumType.Int32: return(new Variant(ReadInt32())); case Variant.EnumType.UInt32: return(new Variant(ReadUInt32())); case Variant.EnumType.Int64: return(new Variant(ReadInt64())); case Variant.EnumType.UInt64: return(new Variant(ReadUInt64())); case Variant.EnumType.Boolean: return(new Variant(ReadBoolean())); case Variant.EnumType.Time: if ((m_mode & BinaryMode.DateTimeAsTicks) == 0) { throw new VariantException("Binary data has DateTimeAsTicks mode disabled which is not supported in the protean.NET BinaryReader"); } return(new Variant(ReadTime())); case Variant.EnumType.DateTime: if ((m_mode & BinaryMode.DateTimeAsTicks) == 0) { throw new VariantException("Binary data has DateTimeAsTicks mode disabled which is not supported in the protean.NET BinaryReader"); } return(new Variant(ReadDateTime())); case Variant.EnumType.Date: throw new VariantException("Attempt to read Date variant which is no longer supported"); case Variant.EnumType.Tuple: { int length = ReadInt32(); Variant result = new Variant(Variant.EnumType.Tuple, length); for (int i = 0; i < length; ++i) { result[i] = ReadVariant(); } return(result); } case Variant.EnumType.List: { int length = ReadInt32(); Variant result = new Variant(type, length); for (int i = 0; i < length; ++i) { result.Add(ReadVariant()); } return(result); } case Variant.EnumType.Dictionary: case Variant.EnumType.Bag: { int length = ReadInt32(); Variant result = new Variant(type); for (int i = 0; i < length; ++i) { String key = ReadString(); Variant value = ReadVariant(); result.Add(key, value); } return(result); } case Variant.EnumType.TimeSeries: { Variant result = new Variant(type); int length = ReadInt32(); for (int i = 0; i < length; ++i) { DateTime time = ReadDateTime(); Variant value = ReadVariant(); result.Add(time, value); } return(result); } case Variant.EnumType.Object: { string className = ReadString(); int version = ReadInt32(); Variant param = ReadVariant(); IVariantObject obj = null; if (m_factory != null) { obj = m_factory.Create(className); if (obj == null && (m_mode & BinaryMode.CreateProxy) == 0) { throw new VariantException("Object of class " + className + " is not regsistered in factory"); } } if (obj == null) { obj = new VariantObjectProxy(className); } obj.Inflate(param, version); return(new Variant(obj)); } case Variant.EnumType.Exception: { string xtype = ReadString(); string xmessage = ReadString(); string xsource = ReadString(); string xstack = ReadString(); return(new Variant(new VariantExceptionInfo(xtype, xmessage, xsource, xstack))); } case Variant.EnumType.Buffer: { int length = ReadInt32(); return(new Variant(ReadBytes(length, true))); } case Variant.EnumType.DataTable: { return(new Variant(ReadDataTable())); } case Variant.EnumType.Array: { return(new Variant(ReadArray())); } default: throw new VariantException("Case exhaustion: " + type.ToString()); } }