A Fast/Compact Serialization Framework

/*

OpenNxSerialization Framework
Copyright (C) 2006 - 2007 "NeXtreme Innovations"
[The Next Xtreme Innovations]

This program is free software, distributed under the terms of
the GNU General Public License Version 2. See the "License.txt" file
at the top of the source tree.

*/
using System;
using System.Collections;
using System.Reflection;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters;
using System.Runtime.Serialization.Formatters.Binary;

using NeXtreme.OpenNxSerialization.IO;
using NeXtreme.OpenNxSerialization.Formatters;

namespace NeXtreme.OpenNxSerialization.Surrogates
{
    #region /       Default surrogates       /

    /// <summary>
    /// Surrogate for null values. 
    /// </summary>
    sealed class NxNullSerializationSurrogate : NxSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxNullSerializationSurrogate() : base(typeof(NxNullSerializationSurrogate)) { }
    }

    /// <summary>
    /// Surrogate for <see cref="System.Object"/> objects. Also serves the
    /// purpose of default surrogate. It uses .NET native serialization
    /// </summary>
    sealed class NxObjectSerializationSurrogate : NxSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        static BinaryFormatter formatter = new BinaryFormatter();

        public NxObjectSerializationSurrogate(Type t) : base(t) { }

        /// <summary>
        /// Uses a <see cref="BinaryFormatter"/> to read an object of 
        /// type <see cref="NxSerializationSurrogate.ActualType"/> from the underlying stream.
        /// </summary>
        /// <param name="reader">stream reader</param>
        /// <returns>object read from the stream reader</returns>
        public override object Read(NxBinaryReader reader)
        {
            int cookie = reader.ReadInt32();
            object custom = reader.Context.GetObject(cookie);
            if (custom == null)
            {
                custom = formatter.Deserialize(reader.BaseReader.BaseStream);
                reader.Context.RememberForRead(custom);
            }
            return custom;
        }

        /// <summary>
        /// Uses a <see cref="BinaryFormatter"/> to write an object of 
        /// type <see cref="NxSerializationSurrogate.ActualType"/> to the underlying stream
        /// </summary>
        /// <param name="writer">stream writer</param>
        /// <param name="graph">object to be written to the stream reader</param>
        public override void Write(NxBinaryWriter writer, object graph)
        {
            int cookie = writer.Context.GetCookie(graph);
            if (cookie != NxSerializationContext.INVALID_COOKIE)
            {
                writer.Write(cookie);
                return;
            }

            cookie = writer.Context.RememberForWrite(graph);
            writer.Write(cookie);
            formatter.Serialize(writer.BaseWriter.BaseStream, graph);
        }
    }

    /// <summary>
    /// Surrogate for <see cref="System.Object"/>[] type.
    /// </summary>
    sealed class NxObjectArraySerializationSurrogate : NxContextSensitiveSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxObjectArraySerializationSurrogate() : base(typeof(object[])) { }

        public override object Instantiate(NxBinaryReader reader)
        {
            int length = reader.ReadInt32();
            return new object[length];
        }

        public override object ReadDirect(NxBinaryReader reader, object graph)
        {
            object[] array = (object[])graph;
            for (int i = 0; i < array.Length; i++)
                array[i] = reader.ReadObject();
            return array;
        }

        public override void WriteDirect(NxBinaryWriter writer, object graph)
        {
            object[] array = (object[])graph;
            writer.Write(array.Length);
            for (int i = 0; i < array.Length; i++)
                writer.WriteObject(array[i]);
        }
    }

    /// <summary>
    /// Surrogate for <see cref="System.Enum"/> derived types.
    /// </summary>
    sealed class NxEnumSerializationSurrogate : NxSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxEnumSerializationSurrogate(Type enm) : base(enm) { }
        public override object Read(NxBinaryReader reader)
        {
            // Find an appropriate surrogate by handle
            short handle = reader.ReadInt16();
            INxSerializationSurrogate typeSurr = reader.Context.SurrogateSelector.GetSurrogateForTypeHandle(handle);
            return Enum.ToObject(ActualType, typeSurr.Read(reader));
        }
        public override void Write(NxBinaryWriter writer, object graph)
        {
            Type enumType = Enum.GetUnderlyingType(ActualType);
            INxSerializationSurrogate typeSurr = writer.Context.SurrogateSelector.GetSurrogateForType(enumType);
            writer.Write(typeSurr.TypeHandle);
            typeSurr.Write(writer, graph);
        }
    }

    #endregion

    #region /       .NET Primitive Types' surrogates       /

    /// <summary>
    /// Surrogate for <see cref="System.Boolean"/> type.
    /// </summary>
    sealed class NxBooleanSerializationSurrogate : NxSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxBooleanSerializationSurrogate() : base(typeof(Boolean)) { }
        public override object Read(NxBinaryReader reader) { return reader.ReadBoolean(); }
        public override void Write(NxBinaryWriter writer, object graph) { writer.Write((Boolean)graph); }
    }

    /// <summary>
    /// Surrogate for <see cref="System.Boolean"/>[] type.
    /// </summary>
    sealed class NxBooleanArraySerializationSurrogate : NxContextSensitiveSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxBooleanArraySerializationSurrogate() : base(typeof(Boolean[])) { }

        public override object Instantiate(NxBinaryReader reader)
        {
            int length = reader.ReadInt32();
            return new Boolean[length];
        }

        public override object ReadDirect(NxBinaryReader reader, object graph)
        {
            Boolean[] array = (Boolean[])graph;
            for (int i = 0; i < array.Length; i++) array[i] = reader.ReadBoolean();
            return array;
        }

        public override void WriteDirect(NxBinaryWriter writer, object graph)
        {
            Boolean[] array = (Boolean[])graph;
            writer.Write(array.Length);
            for (int i = 0; i < array.Length; i++)
                writer.Write(array[i]);
        }
    }

    /// <summary>
    /// Surrogate for <see cref="System.Byte"/> type.
    /// </summary>
    sealed class NxByteSerializationSurrogate : NxSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxByteSerializationSurrogate() : base(typeof(Byte)) { }
        public override object Read(NxBinaryReader reader) { return reader.ReadByte(); }
        public override void Write(NxBinaryWriter writer, object graph) { writer.Write((Byte)graph); }
    }

    /// <summary>
    /// Surrogate for <see cref="System.Byte"/>[] type.
    /// </summary>
    sealed class NxByteArraySerializationSurrogate : NxContextSensitiveSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxByteArraySerializationSurrogate() : base(typeof(Byte[])) { }

        public override object Instantiate(NxBinaryReader reader)
        {
            int length = reader.ReadInt32();
            return reader.ReadBytes(length);
        }

        public override object ReadDirect(NxBinaryReader reader, object graph)
        {
            return graph;
        }

        public override void WriteDirect(NxBinaryWriter writer, object graph)
        {
            Byte[] array = (Byte[])graph;
            writer.Write(array.Length);
            writer.Write(array);
        }
    }

    /// <summary>
    /// Surrogate for <see cref="System.Char"/> type.
    /// </summary>
    sealed class NxCharSerializationSurrogate : NxSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxCharSerializationSurrogate() : base(typeof(Char)) { }
        public override object Read(NxBinaryReader reader) { return reader.ReadChar(); }
        public override void Write(NxBinaryWriter writer, object graph) { writer.Write((Char)graph); }
    }

    /// <summary>
    /// Surrogate for <see cref="System.Char"/>[] type.
    /// </summary>
    sealed class NxCharArraySerializationSurrogate : NxContextSensitiveSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxCharArraySerializationSurrogate() : base(typeof(Char[])) { }

        public override object Instantiate(NxBinaryReader reader)
        {
            int length = reader.ReadInt32();
            return reader.ReadChars(length);
        }

        public override object ReadDirect(NxBinaryReader reader, object graph)
        {
            return graph;
        }

        public override void WriteDirect(NxBinaryWriter writer, object graph)
        {
            Char[] array = (Char[])graph;
            writer.Write(array.Length);
            writer.Write(array);
        }
    }

    /// <summary>
    /// Surrogate for <see cref="System.Single"/> type.
    /// </summary>
    sealed class NxSingleSerializationSurrogate : NxSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxSingleSerializationSurrogate() : base(typeof(Single)) { }
        public override object Read(NxBinaryReader reader) { return reader.ReadSingle(); }
        public override void Write(NxBinaryWriter writer, object graph) { writer.Write((Single)graph); }
    }

    /// <summary>
    /// Surrogate for <see cref="System.Single"/>[] type.
    /// </summary>
    sealed class NxSingleArraySerializationSurrogate : NxContextSensitiveSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxSingleArraySerializationSurrogate() : base(typeof(Single[])) { }

        public override object Instantiate(NxBinaryReader reader)
        {
            int length = reader.ReadInt32();
            return new Single[length];
        }

        public override object ReadDirect(NxBinaryReader reader, object graph)
        {
            Single[] array = (Single[])graph;
            for (int i = 0; i < array.Length; i++)
                array[i] = reader.ReadSingle();
            return array;
        }

        public override void WriteDirect(NxBinaryWriter writer, object graph)
        {
            Single[] array = (Single[])graph;
            writer.Write(array.Length);
            for (int i = 0; i < array.Length; i++)
                writer.Write(array[i]);
        }
    }

    /// <summary>
    /// Surrogate for <see cref="System.Double"/> type.
    /// </summary>
    sealed class NxDoubleSerializationSurrogate : NxSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxDoubleSerializationSurrogate() : base(typeof(Double)) { }
        public override object Read(NxBinaryReader reader) { return reader.ReadDouble(); }
        public override void Write(NxBinaryWriter writer, object graph) { writer.Write((Double)graph); }
    }

    /// <summary>
    /// Surrogate for <see cref="System.Double"/>[] type.
    /// </summary>
    sealed class NxDoubleArraySerializationSurrogate : NxContextSensitiveSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxDoubleArraySerializationSurrogate() : base(typeof(Double[])) { }

        public override object Instantiate(NxBinaryReader reader)
        {
            int length = reader.ReadInt32();
            return new Double[length];
        }

        public override object ReadDirect(NxBinaryReader reader, object graph)
        {
            Double[] array = (Double[])graph;
            for (int i = 0; i < array.Length; i++)
                array[i] = reader.ReadDouble();
            return array;
        }

        public override void WriteDirect(NxBinaryWriter writer, object graph)
        {
            Double[] array = (Double[])graph;
            writer.Write(array.Length);
            for (int i = 0; i < array.Length; i++)
                writer.Write(array[i]);
        }
    }

    /// <summary>
    /// Surrogate for <see cref="System.Decimal"/> type.
    /// </summary>
    sealed class NxDecimalSerializationSurrogate : NxSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxDecimalSerializationSurrogate() : base(typeof(Decimal)) { }
        public override object Read(NxBinaryReader reader) { return reader.ReadDecimal(); }
        public override void Write(NxBinaryWriter writer, object graph) { writer.Write((Decimal)graph); }
    }

    /// <summary>
    /// Surrogate for <see cref="System.Decimal"/>[] type.
    /// </summary>
    sealed class NxDecimalArraySerializationSurrogate : NxContextSensitiveSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxDecimalArraySerializationSurrogate() : base(typeof(Decimal)) { }

        public override object Instantiate(NxBinaryReader reader)
        {
            int length = reader.ReadInt32();
            return new Decimal[length];
        }

        public override object ReadDirect(NxBinaryReader reader, object graph)
        {
            Decimal[] array = (Decimal[])graph;
            for (int i = 0; i < array.Length; i++)
                array[i] = reader.ReadDecimal();
            return array;
        }

        public override void WriteDirect(NxBinaryWriter writer, object graph)
        {
            Decimal[] array = (Decimal[])graph;
            writer.Write(array.Length);
            for (int i = 0; i < array.Length; i++)
                writer.Write(array[i]);
        }
    }

    /// <summary>
    /// Surrogate for <see cref="System.Int16"/> type.
    /// </summary>
    sealed class NxInt16SerializationSurrogate : NxSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxInt16SerializationSurrogate() : base(typeof(Int16)) { }
        public override object Read(NxBinaryReader reader) { return reader.ReadInt16(); }
        public override void Write(NxBinaryWriter writer, object graph) { writer.Write((Int16)graph); }
    }

    /// <summary>
    /// Surrogate for <see cref="System.Int16"/>[] type.
    /// </summary>
    sealed class NxInt16ArraySerializationSurrogate : NxContextSensitiveSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxInt16ArraySerializationSurrogate() : base(typeof(Int16[])) { }

        public override object Instantiate(NxBinaryReader reader)
        {
            int length = reader.ReadInt32();
            return new Int16[length];
        }

        public override object ReadDirect(NxBinaryReader reader, object graph)
        {
            Int16[] array = (Int16[])graph;
            for (int i = 0; i < array.Length; i++)
                array[i] = reader.ReadInt16();
            return array;
        }

        public override void WriteDirect(NxBinaryWriter writer, object graph)
        {
            Int16[] array = (Int16[])graph;
            writer.Write(array.Length);
            for (int i = 0; i < array.Length; i++)
                writer.Write(array[i]);
        }
    }

    /// <summary>
    /// Surrogate for <see cref="System.Int32"/> type.
    /// </summary>
    sealed class NxInt32SerializationSurrogate : NxSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxInt32SerializationSurrogate() : base(typeof(Int32)) { }
        public override object Read(NxBinaryReader reader) { return reader.ReadInt32(); }
        public override void Write(NxBinaryWriter writer, object graph) { writer.Write((int)graph); }
    }

    /// <summary>
    /// Surrogate for <see cref="System.Int32"/>[] type.
    /// </summary>
    sealed class NxInt32ArraySerializationSurrogate : NxContextSensitiveSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxInt32ArraySerializationSurrogate() : base(typeof(Int32[])) { }

        public override object Instantiate(NxBinaryReader reader)
        {
            int length = reader.ReadInt32();
            return new Int32[length];
        }

        public override object ReadDirect(NxBinaryReader reader, object graph)
        {
            Int32[] array = (Int32[])graph;
            for (int i = 0; i < array.Length; i++)
                array[i] = reader.ReadInt32();
            return array;
        }

        public override void WriteDirect(NxBinaryWriter writer, object graph)
        {
            Int32[] array = (Int32[])graph;
            writer.Write(array.Length);
            for (int i = 0; i < array.Length; i++)
                writer.Write(array[i]);
        }
    }

    /// <summary>
    /// Surrogate for <see cref="System.Int64"/> type.
    /// </summary>
    sealed class NxInt64SerializationSurrogate : NxSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxInt64SerializationSurrogate() : base(typeof(Int64)) { }
        public override object Read(NxBinaryReader reader) { return reader.ReadInt64(); }
        public override void Write(NxBinaryWriter writer, object graph) { writer.Write((Int64)graph); }
    }

    /// <summary>
    /// Surrogate for <see cref="System.Int64"/>[] type.
    /// </summary>
    sealed class NxInt64ArraySerializationSurrogate : NxContextSensitiveSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxInt64ArraySerializationSurrogate() : base(typeof(Int64)) { }

        public override object Instantiate(NxBinaryReader reader)
        {
            int length = reader.ReadInt32();
            return new Int64[length];
        }

        public override object ReadDirect(NxBinaryReader reader, object graph)
        {
            Int64[] array = (Int64[])graph;
            for (int i = 0; i < array.Length; i++)
                array[i] = reader.ReadInt64();
            return array;
        }

        public override void WriteDirect(NxBinaryWriter writer, object graph)
        {
            Int64[] array = (Int64[])graph;
            writer.Write(array.Length);
            for (int i = 0; i < array.Length; i++)
                writer.Write(array[i]);
        }
    }

    /// <summary>
    /// Surrogate for <see cref="System.DateTime"/> type.
    /// </summary>
    sealed class NxDateTimeSerializationSurrogate : NxSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxDateTimeSerializationSurrogate() : base(typeof(DateTime)) { }
        public override object Read(NxBinaryReader reader) { return reader.ReadDateTime(); }
        public override void Write(NxBinaryWriter writer, object graph) { writer.Write((DateTime)graph); }
    }

    /// <summary>
    /// Surrogate for <see cref="System.DateTime"/>[] type.
    /// </summary>
    sealed class NxDateTimeArraySerializationSurrogate : NxContextSensitiveSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxDateTimeArraySerializationSurrogate() : base(typeof(DateTime[])) { }

        public override object Instantiate(NxBinaryReader reader)
        {
            int length = reader.ReadInt32();
            return new DateTime[length];
        }

        public override object ReadDirect(NxBinaryReader reader, object graph)
        {
            DateTime[] array = (DateTime[])graph;
            for (int i = 0; i < array.Length; i++)
                array[i] = reader.ReadDateTime();
            return array;
        }

        public override void WriteDirect(NxBinaryWriter writer, object graph)
        {
            DateTime[] array = (DateTime[])graph;
            writer.Write(array.Length);
            for (int i = 0; i < array.Length; i++)
                writer.Write(array[i]);
        }
    }

    /// <summary>
    /// Surrogate for <see cref="System.String"/> type.
    /// </summary>
    sealed class NxStringSerializationSurrogate : NxSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxStringSerializationSurrogate() : base(typeof(String)) { }
        public override object Read(NxBinaryReader reader) { return reader.ReadString(); }
        public override void Write(NxBinaryWriter writer, object graph) { writer.Write((string)graph); }
    }

    /// <summary>
    /// Surrogate for <see cref="System.String"/>[] type.
    /// </summary>
    sealed class NxStringArraySerializationSurrogate : NxContextSensitiveSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxStringArraySerializationSurrogate() : base(typeof(String[])) { }

        public override object Instantiate(NxBinaryReader reader)
        {
            int length = reader.ReadInt32();
            return new String[length];
        }

        public override object ReadDirect(NxBinaryReader reader, object graph)
        {
            String[] array = (String[])graph;
            for (int i = 0; i < array.Length; i++)
                array[i] = reader.ReadString();
            return array;
        }

        public override void WriteDirect(NxBinaryWriter writer, object graph)
        {
            String[] array = (String[])graph;
            writer.Write(array.Length);
            for (int i = 0; i < array.Length; i++)
                writer.Write(array[i]);
        }
    }

    /// <summary>
    /// Surrogate for <see cref="System.Guid"/> type.
    /// </summary>
    sealed class NxGuidSerializationSurrogate : NxSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxGuidSerializationSurrogate() : base(typeof(Guid)) { }
        public override object Read(NxBinaryReader reader) { return reader.ReadGuid(); }
        public override void Write(NxBinaryWriter writer, object graph) { writer.Write((Guid)graph); }
    }

    /// <summary>
    /// Surrogate for <see cref="System.Guid"/>[] type.
    /// </summary>
    sealed class NxGuidArraySerializationSurrogate : NxContextSensitiveSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxGuidArraySerializationSurrogate() : base(typeof(Guid[])) { }

        public override object Instantiate(NxBinaryReader reader)
        {
            int length = reader.ReadInt32();
            return new Guid[length];
        }

        public override object ReadDirect(NxBinaryReader reader, object graph)
        {
            Guid[] array = (Guid[])graph;
            for (int i = 0; i < array.Length; i++)
                array[i] = reader.ReadGuid();
            return array;
        }

        public override void WriteDirect(NxBinaryWriter writer, object graph)
        {
            Guid[] array = (Guid[])graph;
            writer.Write(array.Length);
            for (int i = 0; i < array.Length; i++)
                writer.Write(array[i]);
        }
    }

    /// <summary>
    /// Surrogate for <see cref="System.SByte"/> type.
    /// </summary>
    sealed class NxSByteSerializationSurrogate : NxSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxSByteSerializationSurrogate() : base(typeof(SByte)) { }
        public override object Read(NxBinaryReader reader) { return reader.ReadSByte(); }
        public override void Write(NxBinaryWriter writer, object graph) { writer.Write((SByte)graph); }
    }

    /// <summary>
    /// Surrogate for <see cref="System.SByte"/>[] type.
    /// </summary>
    sealed class NxSByteArraySerializationSurrogate : NxContextSensitiveSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxSByteArraySerializationSurrogate() : base(typeof(SByte[])) { }

        public override object Instantiate(NxBinaryReader reader)
        {
            int length = reader.ReadInt32();
            return new SByte[length];
        }

        public override object ReadDirect(NxBinaryReader reader, object graph)
        {
            SByte[] array = (SByte[])graph;
            for (int i = 0; i < array.Length; i++)
                array[i] = reader.ReadSByte();
            return array;
        }

        public override void WriteDirect(NxBinaryWriter writer, object graph)
        {
            SByte[] array = (SByte[])graph;
            writer.Write(array.Length);
            for (int i = 0; i < array.Length; i++)
                writer.Write(array[i]);
        }
    }

    /// <summary>
    /// Surrogate for <see cref="System.UInt16"/> type.
    /// </summary>
    sealed class NxUInt16SerializationSurrogate : NxSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxUInt16SerializationSurrogate() : base(typeof(UInt16)) { }
        public override object Read(NxBinaryReader reader) { return reader.ReadUInt16(); }
        public override void Write(NxBinaryWriter writer, object graph) { writer.Write((UInt16)graph); }
    }

    /// <summary>
    /// Surrogate for <see cref="System.UInt16"/>[] type.
    /// </summary>
    sealed class NxUInt16ArraySerializationSurrogate : NxContextSensitiveSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxUInt16ArraySerializationSurrogate() : base(typeof(UInt16[])) { }

        public override object Instantiate(NxBinaryReader reader)
        {
            int length = reader.ReadInt32();
            return new UInt16[length];
        }

        public override object ReadDirect(NxBinaryReader reader, object graph)
        {
            UInt16[] array = (UInt16[])graph;
            for (int i = 0; i < array.Length; i++)
                array[i] = reader.ReadUInt16();
            return array;
        }

        public override void WriteDirect(NxBinaryWriter writer, object graph)
        {
            UInt16[] array = (UInt16[])graph;
            writer.Write(array.Length);
            for (int i = 0; i < array.Length; i++)
                writer.Write(array[i]);
        }
    }

    /// <summary>
    /// Surrogate for <see cref="System.UInt32"/> type.
    /// </summary>
    sealed class NxUInt32SerializationSurrogate : NxSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxUInt32SerializationSurrogate() : base(typeof(UInt32)) { }
        public override object Read(NxBinaryReader reader) { return reader.ReadUInt32(); }
        public override void Write(NxBinaryWriter writer, object graph) { writer.Write((UInt32)graph); }
    }

    /// <summary>
    /// Surrogate for <see cref="System.UInt32"/>[] type.
    /// </summary>
    sealed class NxUInt32ArraySerializationSurrogate : NxContextSensitiveSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxUInt32ArraySerializationSurrogate() : base(typeof(UInt32[])) { }

        public override object Instantiate(NxBinaryReader reader)
        {
            int length = reader.ReadInt32();
            return new UInt32[length];
        }

        public override object ReadDirect(NxBinaryReader reader, object graph)
        {
            UInt32[] array = (UInt32[])graph;
            for (int i = 0; i < array.Length; i++)
                array[i] = reader.ReadUInt32();
            return array;
        }

        public override void WriteDirect(NxBinaryWriter writer, object graph)
        {
            UInt32[] array = (UInt32[])graph;
            writer.Write(array.Length);
            for (int i = 0; i < array.Length; i++)
                writer.Write(array[i]);
        }
    }

    /// <summary>
    /// Surrogate for <see cref="System.UInt64"/> type.
    /// </summary>
    sealed class NxUInt64SerializationSurrogate : NxSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxUInt64SerializationSurrogate() : base(typeof(UInt64)) { }
        public override object Read(NxBinaryReader reader) { return reader.ReadUInt64(); }
        public override void Write(NxBinaryWriter writer, object graph) { writer.Write((UInt64)graph); }
    }

    /// <summary>
    /// Surrogate for <see cref="System.UInt64"/>[] type.
    /// </summary>
    sealed class NxUInt64ArraySerializationSurrogate : NxContextSensitiveSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxUInt64ArraySerializationSurrogate() : base(typeof(UInt64[])) { }

        public override object Instantiate(NxBinaryReader reader)
        {
            int length = reader.ReadInt32();
            return new UInt64[length];
        }

        public override object ReadDirect(NxBinaryReader reader, object graph)
        {
            UInt64[] array = (UInt64[])graph;
            for (int i = 0; i < array.Length; i++)
                array[i] = reader.ReadUInt64();
            return array;
        }

        public override void WriteDirect(NxBinaryWriter writer, object graph)
        {
            UInt64[] array = (UInt64[])graph;
            writer.Write(array.Length);
            for (int i = 0; i < array.Length; i++)
                writer.Write(array[i]);
        }
    }

    #endregion

    #region /       Generic surrogates for containers      /

    /// <summary>
    /// Surrogate for generic <see cref="System.Array"/> types.
    /// </summary>
    sealed class NxArraySerializationSurrogate : NxContextSensitiveSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxArraySerializationSurrogate(Type t) : base(t) { }

        public override object Instantiate(NxBinaryReader reader)
        {
            int length = reader.ReadInt32();
            return Array.CreateInstance(ActualType.GetElementType(), length);
        }

        public override object ReadDirect(NxBinaryReader reader, object graph)
        {
            Array array = (Array)graph;
            for (int i = 0; i < array.Length; i++)
                array.SetValue(reader.ReadObject(), i);
            return array;
        }

        public override void WriteDirect(NxBinaryWriter writer, object graph)
        {
            Array array = (Array)graph;
            writer.Write(array.Length);
            for (int i = 0; i < array.Length; i++)
                writer.WriteObject(array.GetValue(i));
        }
    }

    /// <summary>
    /// Surrogate for types that inherit from <see cref="System.Collections.IList"/>.
    /// </summary>
    sealed class NxIListSerializationSurrogate : NxContextSensitiveSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxIListSerializationSurrogate(Type t) : base(t) { }

        public override object ReadDirect(NxBinaryReader reader, object graph)
        {
            int length = reader.ReadInt32();
            IList list = (IList)graph;
            for (int i = 0; i < length; i++)
                list.Add(reader.ReadObject());
            return list;
        }

        public override void WriteDirect(NxBinaryWriter writer, object graph)
        {
            IList list = (IList)graph;
            writer.Write(list.Count);
            for (int i = 0; i < list.Count; i++)
                writer.WriteObject(list[i]);
        }
    }

    /// <summary>
    /// Surrogate for types that inherit from <see cref="System.Collections.IDictionary"/>.
    /// </summary>
    sealed class NxIDictionarySerializationSurrogate : NxContextSensitiveSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxIDictionarySerializationSurrogate(Type t) : base(t) { }

        public override object ReadDirect(NxBinaryReader reader, object graph)
        {
            int length = reader.ReadInt32();
            IDictionary dict = (IDictionary)graph;
            for (int i = 0; i < length; i++)
            {
                object key = reader.ReadObject();
                object value = reader.ReadObject();
                dict.Add(key, value);
            }
            return dict;
        }

        public override void WriteDirect(NxBinaryWriter writer, object graph)
        {
            IDictionary dict = (IDictionary)graph;
            writer.Write(dict.Count);
            for (IDictionaryEnumerator i = dict.GetEnumerator(); i.MoveNext(); )
            {
                writer.WriteObject(i.Key);
                writer.WriteObject(i.Value);
            }
        }
    }

    #endregion

    #region /       System.Nullable<T> surrogates      /

    /// <summary>
    /// Surrogate for <see cref="System.Nullable"/> type.
    /// </summary>
    sealed class NxNullableArraySerializationSurrogate<T> : NxSerializationSurrogate, INxBuiltinSerializationSurrogate
           where T : struct
    {
        public NxNullableArraySerializationSurrogate() : base(typeof(T?[])) { }

        public override object Read(NxBinaryReader reader)
        {
            // read type handle
            short handle = reader.ReadInt16();
            int length = reader.ReadInt32();

            // Find an appropriate surrogate by handle
            INxSerializationSurrogate typeSurr = reader.Context.SurrogateSelector.GetSurrogateForTypeHandle(handle);

            Nullable<T>[] array = new Nullable<T>[length];
            while (true)
            {
                int index = reader.ReadInt32();
                if (index < 0) break;

                array[index] = (T)typeSurr.Read(reader);
            }
            return array;
        }

        public override void Write(NxBinaryWriter writer, object graph)
        {
            // Find an appropriate surrogate for the object
            INxSerializationSurrogate typeSurr = writer.Context.SurrogateSelector.GetSurrogateForType(typeof(T));

            Nullable<T>[] array = (Nullable<T>[])graph;

            // write type handle
            writer.Write(typeSurr.TypeHandle);
            writer.Write(array.Length);
            for (int i = 0; i < array.Length; i++)
            {
                if (array[i].HasValue)
                {
                    writer.Write(i);
                    typeSurr.Write(writer, array[i].Value);
                }
            }
            writer.Write(-1);
        }

        //public override object Read(NxBinaryReader reader)
        //{
        //    // read type handle
        //    short handle = reader.ReadInt16();
        //    int length = reader.ReadInt32();

        //    // Find an appropriate surrogate by handle
        //    INxSerializationSurrogate typeSurr = NxTypeSurrogateSelector.GetSurrogateForTypeHandle(handle);

        //    T?[] array = new T?[length];
        //    for (int i = 0; i < length;)
        //    {
        //        bool dataRun = reader.ReadBoolean();
        //        int runLength = reader.ReadInt32();
        //        if (dataRun)
        //        {
        //            for (int k = 0; k < runLength; k++)
        //                array[i + k] = (T?)typeSurr.Read(reader);
        //        }
        //        i += runLength;
        //    }
        //    return array;
        //}

        //public override void Write(NxBinaryWriter writer, object graph)
        //{
        //    // Find an appropriate surrogate for the object
        //    INxSerializationSurrogate typeSurr = NxTypeSurrogateSelector.GetSurrogateForType(typeof(T));

        //    T?[] array = (T?[])graph;

        //    // write type handle
        //    writer.Write(typeSurr.TypeHandle);
        //    writer.Write(array.Length);

        //    bool dataRun = array[0].HasValue;
        //    for (int i = 0; i < array.Length;)
        //    {
        //        int runLength = 0;
        //        for (int j = i; j < array.Length; j++, runLength++)
        //            if (array[j].HasValue != dataRun) break;

        //        writer.Write(dataRun);
        //        writer.Write(runLength);

        //        if (dataRun)
        //        {
        //            for (int k = 0; k < runLength; k++)
        //                typeSurr.Write(writer, array[i + k].Value);
        //        }

        //        i += runLength;
        //        dataRun = !dataRun;
        //    }
        //}
    }

    #endregion

    /// <summary>
    /// Surrogate for types that inherit from <see cref="INxSerializable"/>.
    /// </summary>
    sealed class NxINxSerializableSerializationSurrogate : NxContextSensitiveSerializationSurrogate, INxBuiltinSerializationSurrogate
    {
        public NxINxSerializableSerializationSurrogate(Type t) : base(t) { }

        /// <summary>
        /// Non default object construction. The idea is to circumvent constructor calls
        /// and populate the object in <see cref="INxSerializable.Deserialize"/> method.
        /// </summary>
        /// <returns></returns>
        public override object Instantiate(NxBinaryReader reader)
        {
            return FormatterServices.GetUninitializedObject(ActualType);
        }

        public override object ReadDirect(NxBinaryReader reader, object graph)
        {
            ((INxSerializable)graph).Deserialize(reader);
            return graph;
        }

        public override void WriteDirect(NxBinaryWriter writer, object graph)
        {
            ((INxSerializable)graph).Serialize(writer);
        }
    }
}