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));
}
