Beispiel #1
0
        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());
            }
        }
Beispiel #2
0
        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();
        }
Beispiel #3
0
        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);
        }