public void WriteDataTable(DataTable arg) { #if !DISABLE_DATATABLE int numCols = arg.Columns.Count; int numRows = arg.Rows.Count; VariantBase.EnumType[] colTypes = new VariantBase.EnumType[numCols]; string[] colNames = new string[numCols]; for (int i = 0; i < numCols; ++i) { DataColumn col = arg.Columns[i]; colTypes[i] = VariantPrimitiveBase.TypeToEnum(col.DataType); colNames[i] = col.ColumnName; } // Write number of columns WriteInt(numCols); // Write number of rows WriteInt(numRows); // Write column types foreach (VariantBase.EnumType colType in colTypes) { WriteInt((int)colType); } // Write column names foreach (string colName in colNames) { WriteString(colName); } // Write columns for (int i = 0; i < numCols; ++i) { WriteDelegate colWriter = GetWriterDelegate(colTypes[i]); foreach (DataRow item in arg.Rows) { if (item.IsNull(i)) { throw new VariantException("Cannot serialise DataTables containing null elements."); } colWriter(item[i]); } } #else throw new NotSupportedException("Datatables are not supported on this platform."); #endif }
// Is/As only work for primitive types public T As <T>() where T : IComparable <T> { if (Value is VariantPrimitive <T> ) { return(((VariantPrimitive <T>)Value).Value); } else if (Value is VariantAny) { string str = ((VariantAny)Value).Value; return(VariantPrimitiveBase.Parse <T>(str)); } else { throw new VariantException("Attempt to fetch " + typeof(T).Name + " from " + Type.ToString() + " variant."); } }
private static int GetByteCountDataTable(DataTable arg) { #if !DISABLE_DATATABLE int numCols = arg.Columns.Count; // Write number of columns var writeCount = sizeof(int); // Write number of rows writeCount += sizeof(int); // Write column types writeCount += sizeof(int) * numCols; // Write column names foreach (var column in arg.Columns.Cast <DataColumn>()) { writeCount += GetByteCountString(column.ColumnName); } // Write columns for (int i = 0; i < numCols; ++i) { var colWriteCounter = GetWriteCounterDelegate(VariantPrimitiveBase.TypeToEnum(arg.Columns[i].DataType)); foreach (DataRow item in arg.Rows) { if (item.IsNull(i)) { throw new VariantException("Cannot serialise DataTables containing null elements."); } colWriteCounter(item[i]); } } return(writeCount); #else throw new NotSupportedException("Datatables are not supported on this platform."); #endif }
public int CompareTo(IVariantData value) { #if !DISABLE_DATATABLE DataTable rhsValue = ((VariantDataTable)value).Value; if (Value.Columns.Count != rhsValue.Columns.Count) { return(Value.Columns.Count.CompareTo(rhsValue.Columns.Count)); } else if (Value.Rows.Count != rhsValue.Rows.Count) { return(Value.Rows.Count.CompareTo(rhsValue.Rows.Count)); } else { CompareDelegate[] comparers = new CompareDelegate[Value.Columns.Count]; for (int i = 0; i < Value.Columns.Count; ++i) { if (Value.Columns[i].ColumnName != rhsValue.Columns[i].ColumnName) { return(Value.Columns[i].ColumnName.CompareTo(rhsValue.Columns[i].ColumnName)); } else { Variant.EnumType lhsType = VariantPrimitiveBase.TypeToEnum(Value.Columns[i].DataType); Variant.EnumType rhsType = VariantPrimitiveBase.TypeToEnum(rhsValue.Columns[i].DataType); if (lhsType != rhsType) { return(lhsType.CompareTo(rhsType)); } else { switch (lhsType) { case VariantBase.EnumType.Float: comparers[i] = delegate(object lhs, object rhs) { return(((float)lhs).CompareTo((float)rhs)); }; break; case VariantBase.EnumType.Double: comparers[i] = delegate(object lhs, object rhs) { return(((double)lhs).CompareTo((double)rhs)); }; break; case VariantBase.EnumType.Boolean: comparers[i] = delegate(object lhs, object rhs) { return(((bool)lhs).CompareTo((bool)rhs)); }; break; case VariantBase.EnumType.String: comparers[i] = delegate(object lhs, object rhs) { return(((string)lhs).CompareTo((string)rhs)); }; break; case VariantBase.EnumType.Int32: comparers[i] = delegate(object lhs, object rhs) { return(((Int32)lhs).CompareTo((Int32)rhs)); }; break; case VariantBase.EnumType.UInt32: comparers[i] = delegate(object lhs, object rhs) { return(((UInt32)lhs).CompareTo((UInt32)rhs)); }; break; case VariantBase.EnumType.Int64: comparers[i] = delegate(object lhs, object rhs) { return(((Int64)lhs).CompareTo((Int64)rhs)); }; break; case VariantBase.EnumType.UInt64: comparers[i] = delegate(object lhs, object rhs) { return(((UInt64)lhs).CompareTo((UInt64)rhs)); }; break; case VariantBase.EnumType.Time: comparers[i] = delegate(object lhs, object rhs) { return(((TimeSpan)lhs).CompareTo((TimeSpan)rhs)); }; break; case VariantBase.EnumType.DateTime: comparers[i] = delegate(object lhs, object rhs) { return(((DateTime)lhs).CompareTo((DateTime)rhs)); }; break; default: throw new VariantException("Case exhaustion: " + lhsType); } } } } for (int i = 0; i < Value.Rows.Count; ++i) { DataRow lhsRow = Value.Rows[i]; DataRow rhsRow = rhsValue.Rows[i]; for (int j = 0; j < Value.Columns.Count; ++j) { int cmp = comparers[j](lhsRow[j], rhsRow[j]); if (cmp != 0) { return(cmp); } } } return(0); } #else throw new NotSupportedException("Datatables are not supported on this platform."); #endif }
protected DataTable ReadDataTable() { #if !DISABLE_DATATABLE int numCols = ReadInt32(); int numRows = ReadInt32(); Variant.EnumType[] colTypes = new Variant.EnumType[numCols]; for (int i = 0; i < numCols; ++i) { colTypes[i] = (Variant.EnumType)ReadInt32(); } string[] colNames = new string[numCols]; for (int i = 0; i < numCols; ++i) { colNames[i] = ReadString(); } DataTable dt = new DataTable(); for (int i = 0; i < numCols; ++i) { dt.Columns.Add(new DataColumn(colNames[i], VariantPrimitiveBase.EnumToType(colTypes[i]))); } ; // Write number of rows for (int col = 0; col < numCols; ++col) { ReadDelegate colReader; switch (colTypes[col]) { case VariantBase.EnumType.Float: colReader = () => ReadFloat(); break; case VariantBase.EnumType.Double: colReader = () => ReadDouble(); break; case VariantBase.EnumType.Boolean: colReader = () => ReadBoolean(); break; case VariantBase.EnumType.String: colReader = () => ReadString(); break; case VariantBase.EnumType.Int32: colReader = () => ReadInt32(); break; case VariantBase.EnumType.UInt32: colReader = () => ReadUInt32(); break; case VariantBase.EnumType.Int64: colReader = () => ReadInt64(); break; case VariantBase.EnumType.UInt64: colReader = () => ReadUInt64(); break; case VariantBase.EnumType.Time: colReader = () => ReadTime(); break; case VariantBase.EnumType.DateTime: colReader = () => ReadDateTime(); break; default: throw new VariantException("Case exhaustion: " + colTypes[col]); } for (int row = 0; row < numRows; ++row) { DataRow dr; if (col == 0) { dr = dt.NewRow(); dt.Rows.Add(dr); } else { dr = dt.Rows[row]; } dr[col] = colReader(); } } return(dt); #else throw new NotSupportedException("Datatables not supported on this platform."); #endif }
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 Write(DataTable arg) { #if !DISABLE_DATATABLE int numCols = arg.Columns.Count; int numRows = arg.Rows.Count; VariantBase.EnumType[] colTypes = new VariantBase.EnumType[numCols]; string[] colNames = new string[numCols]; for (int i = 0; i < numCols; ++i) { DataColumn col = arg.Columns[i]; colTypes[i] = VariantPrimitiveBase.TypeToEnum(col.DataType); colNames[i] = col.ColumnName; } // Write number of columns Write(numCols); // Write number of rows Write(numRows); // Write column types foreach (VariantBase.EnumType colType in colTypes) { Write((int)colType); } // Write column names foreach (string colName in colNames) { Write(colName); } // Write columns for (int i = 0; i < numCols; ++i) { WriteDelegate colWriter; switch (colTypes[i]) { case VariantBase.EnumType.Float: colWriter = o => Write((float)o); break; case VariantBase.EnumType.Double: colWriter = o => Write((double)o); break; case VariantBase.EnumType.String: colWriter = o => Write((string)o); break; case VariantBase.EnumType.Boolean: colWriter = o => Write((bool)o); break; case VariantBase.EnumType.Int32: colWriter = o => Write((Int32)o); break; case VariantBase.EnumType.UInt32: colWriter = o => Write((UInt32)o); break; case VariantBase.EnumType.Int64: colWriter = o => Write((Int64)o); break; case VariantBase.EnumType.UInt64: colWriter = o => Write((UInt64)o); break; case VariantBase.EnumType.Time: colWriter = o => Write((TimeSpan)o); break; case VariantBase.EnumType.DateTime: colWriter = o => Write((DateTime)o); break; default: throw new VariantException("Case exhaustion: " + colTypes[i]); } foreach (DataRow item in arg.Rows) { if (item.IsNull(i)) { throw new VariantException("Cannot serialise DataTables containing null elements."); } colWriter(item[i]); } } #else throw new NotSupportedException("Datatables are not supported on this platform."); #endif }
public override string ToString() { return(VariantPrimitiveBase.ToString <T>(Value)); }