cauterize 0.0.1.pre1 → 0.0.1.pre5

data/support/cs/src/CauterizeContainerFormatter.cs

@@ -0,0 +1,18 @@
+using System;
+using System.IO;
+
+namespace Cauterize
+{
+    public abstract class CauterizeContainerFormatter : ICauterizeTypeFormatter
+    {
+        protected CauterizeTypeFormatterFactory _typeFormatterFactory;
+
+        public CauterizeContainerFormatter(CauterizeTypeFormatterFactory factory)
+        {
+            _typeFormatterFactory = factory;
+        }
+
+        public abstract object Deserialize(Stream serializationStream, Type t);
+        public abstract void Serialize(Stream serializationStream, object obj);
+    }
+}

data/support/cs/src/CauterizeEnumFormatter.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace Cauterize
+{
+    public class CauterizeEnumFormatter : ICauterizeTypeFormatter
+    {
+        public object Deserialize(Stream serializationStream, Type t)
+        {
+            var numBytes = GetNumBytesForEnum(t);
+            var bytes = new byte[numBytes];
+            serializationStream.Read(bytes, 0, numBytes);
+            if (!BitConverter.IsLittleEndian)
+            {
+                Array.Reverse(bytes);
+            }
+            Int64 intValue = 0;
+            switch (numBytes)
+            {
+                case 8: intValue = BitConverter.ToInt64(bytes, 0);
+                        break;
+                case 4: intValue = BitConverter.ToInt32(bytes, 0);
+                        break;
+                case 2: intValue = BitConverter.ToInt16(bytes, 0);
+                        break;
+                case 1: intValue = (Int32)bytes[0];
+                        break;
+            }
+            return Enum.ToObject(t, intValue);
+        }
+
+        public void Serialize(Stream serializationStream, object obj)
+        {
+            var longValue = Convert.ToInt64(obj);
+            var bytes = BitConverter.GetBytes(longValue);
+            if (!BitConverter.IsLittleEndian)
+            {
+                Array.Reverse(bytes);
+            }
+            serializationStream.Write(bytes, 0, GetNumBytesForEnum(obj.GetType()));
+        }
+
+        private int GetNumBytesForEnum(Type t)
+        {
+            var type = SerializedRepresentationAttribute.GetRepresentation(t);
+            if (type == typeof(SByte) || type == typeof(Byte))
+            {
+                return 1;
+            }
+            else if (type == typeof(Int16) || type == typeof(UInt16))
+            {
+                return 2;
+            }
+            else if (type == typeof(Int32) || type == typeof(UInt32))
+            {
+                return 4;
+            }
+            else if (type == typeof(Int64) || type == typeof(UInt64))
+            {
+                return 8;
+            }
+            return 0;
+        }
+    }
+}

data/support/cs/src/CauterizeException.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace Cauterize 
+{
+    public class CauterizeException : Exception
+    {
+        public CauterizeException(string message) : base(message)
+        {
+        }
+
+        public CauterizeException(string message, Exception innerException) : base(message, innerException)
+        {
+        }
+    }
+}

data/support/cs/src/CauterizeFixedArrayFormatter.cs

@@ -0,0 +1,39 @@
+using System;
+using System.IO;
+using System.Reflection;
+
+namespace Cauterize
+{
+    public class CauterizeFixedArrayFormatter : CauterizeContainerFormatter
+    {
+        public CauterizeFixedArrayFormatter(CauterizeTypeFormatterFactory factory) : base(factory)
+        {
+        }
+        public override object Deserialize(Stream serializationStream, Type t)
+        {
+            var ret = t.GetConstructor(new Type[] {}).Invoke(new object[] {});
+            var arrayField = t.BaseType.GetField("_data", BindingFlags.NonPublic | BindingFlags.Instance);
+            var array = (Array)arrayField.GetValue(ret);
+            var arrayType = arrayField.FieldType.GetElementType();
+            var subFormatter = _typeFormatterFactory.GetFormatter(arrayType);
+            for (var i = 0; i < array.Length; i++)
+            {
+                array.SetValue(subFormatter.Deserialize(serializationStream, arrayType), i);
+            }
+            return ret;
+        }
+
+        public override void Serialize(Stream serializationStream, object obj)
+        {
+            var t = obj.GetType();
+            var arrayField = t.BaseType.GetField("_data", BindingFlags.NonPublic | BindingFlags.Instance);
+            var array = (Array)arrayField.GetValue(obj);
+            var arrayType = arrayField.FieldType.GetElementType();
+            var subFormatter = _typeFormatterFactory.GetFormatter(arrayType);
+            for (var i = 0; i < array.Length; i++)
+            {
+                subFormatter.Serialize(serializationStream, array.GetValue(i));
+            }
+        }
+    }
+}

data/support/cs/src/CauterizeFormatter.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using System.Runtime.Serialization;
+using System.Text;
+
+namespace Cauterize
+{
+    public class CauterizeFormatter
+    {
+        public SerializationBinder Binder { get; set; }
+        public StreamingContext Context { get; set; }
+        public ISurrogateSelector SurrogateSelector { get; set; }
+
+        private readonly CauterizeTypeFormatterFactory _formatterFactory;
+        public CauterizeFormatter() // only needed for deserialization
+        {
+            _formatterFactory = new CauterizeTypeFormatterFactory();
+        }
+
+        public CauterizeFormatter(CauterizeTypeFormatterFactory factory)
+        {
+            _formatterFactory = factory;
+        }
+
+        public virtual T Deserialize<T>(Stream serializationStream)
+        {
+            var formatter = _formatterFactory.GetFormatter(typeof(T));
+            return (T)formatter.Deserialize(serializationStream, typeof(T));
+        }
+
+        public virtual void Serialize(Stream serializationStream, object obj)
+        {
+            var formatter = _formatterFactory.GetFormatter(obj.GetType());
+            formatter.Serialize(serializationStream, obj);
+        }
+    }
+}
+

data/support/cs/src/CauterizeGroupFormatter.cs

@@ -0,0 +1,46 @@
+using System;
+using System.IO;
+
+namespace Cauterize
+{
+    public class CauterizeGroupFormatter : CauterizeContainerFormatter
+    {
+        public CauterizeGroupFormatter(CauterizeTypeFormatterFactory factory) : base(factory)
+        {
+        }
+        public override object Deserialize(Stream serializationStream, Type t)
+        {
+            var ret = t.GetConstructor(new Type[] {}).Invoke(new object[] {});
+            var typeProp = OrderAttribute.GetPropertyByOrder(t, 0);
+            var enumFormatter = _typeFormatterFactory.GetFormatter(typeProp.PropertyType);
+            var enumValue = enumFormatter.Deserialize(serializationStream, typeProp.PropertyType);
+            typeProp.SetValue(ret, enumValue, null);
+            var index = ((int) enumValue) + 1;
+            var prop = OrderAttribute.GetPropertyByOrder(t, index);
+            if (prop != null)
+            {
+                var subType = prop.PropertyType;
+                var subFormatter = _typeFormatterFactory.GetFormatter(subType);
+                var subObj = subFormatter.Deserialize(serializationStream, subType);
+                prop.SetValue(ret, subObj, null);
+            }
+            return ret;
+        }
+
+        public override void Serialize(Stream serializationStream, object obj)
+        {
+            var typeProp = OrderAttribute.GetPropertyByOrder(obj.GetType(), 0);
+            var enumFormatter = _typeFormatterFactory.GetFormatter(typeProp.PropertyType);
+            var enumValue = typeProp.GetValue(obj, null);
+            enumFormatter.Serialize(serializationStream, enumValue);
+            var index = ((int) enumValue) + 1;
+            var subProp = OrderAttribute.GetPropertyByOrder(obj.GetType(), index);
+            if (subProp != null)
+            {
+                var subType = subProp.PropertyType;
+                var subFormatter = _typeFormatterFactory.GetFormatter(subType);
+                subFormatter.Serialize(serializationStream, subProp.GetValue(obj, null));
+            }
+        }
+    }
+}

data/support/cs/src/CauterizePrimitiveFormatter.cs

@@ -0,0 +1,33 @@
+using System;
+using System.ComponentModel;
+using System.IO;
+using System.Runtime.Serialization;
+using System.Text;
+
+namespace Cauterize
+{
+    public class CauterizePrimitiveFormatter : ICauterizeTypeFormatter
+    {
+        public object Deserialize(Stream serializationStream, Type t)
+        {
+            var numBytes = PrimitiveSupport.TypeToByteSize(t);
+            var bytes = new byte[numBytes];
+            serializationStream.Read(bytes, 0, numBytes);
+            if (!BitConverter.IsLittleEndian)
+            {
+                Array.Reverse(bytes);
+            }
+            return PrimitiveSupport.TypeFromBytes(t, bytes);
+        }
+
+        public void Serialize(Stream serializationStream, object obj)
+        {
+            var bytes = PrimitiveSupport.BytesFromValue(obj);
+            if (!BitConverter.IsLittleEndian)
+            {
+                Array.Reverse(bytes);
+            }
+            serializationStream.Write(bytes, 0, bytes.Length);
+        }
+    }
+}

data/support/cs/src/CauterizeTypeFormatterFactory.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Cauterize
+{
+    public class CauterizeTypeFormatterFactory
+    {
+        public virtual ICauterizeTypeFormatter GetFormatter(Type t)
+        {
+            ICauterizeTypeFormatter formatter;
+            if (t.IsSubclassOf(typeof (CauterizeComposite)))
+            {
+                formatter = new CauterizeCompositeFormatter(this);
+            }
+            else if (t.IsSubclassOf(typeof (CauterizeGroup)))
+            {
+                formatter = new CauterizeGroupFormatter(this);
+            }
+            else if (t.IsSubclassOf(typeof (CauterizeFixedArray)))
+            {
+                formatter = new CauterizeFixedArrayFormatter(this);
+            }
+            else if (t.IsSubclassOf(typeof (CauterizeVariableArray)))
+            {
+                formatter = new CauterizeVariableArrayFormatter(this);
+            }
+            else if (t.IsSubclassOf(typeof (Enum)))
+            {
+                formatter = new CauterizeEnumFormatter();
+            }
+            else 
+            {
+                formatter = new CauterizePrimitiveFormatter();
+            }
+            return formatter;
+        }
+    }
+}

data/support/cs/src/CauterizeTypes.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Cauterize
+{
+    public class CauterizeInfo {
+        public static string Name;
+        public static string GeneratedVersion;
+        public static string GeneratedDate;
+    }
+
+    public class CauterizeComposite
+    {
+    }
+
+    public class CauterizeGroup
+    {
+    }
+
+    public abstract class CauterizeFixedArray
+    {
+    }
+
+    public abstract class CauterizeFixedArrayTyped<T> : CauterizeFixedArray
+    {
+        private T[] _data;
+
+        protected abstract int Size { get; }
+        
+        protected void Allocate(T[] data)
+        {
+            Allocate(data.Length);
+            Array.Copy(data, _data, data.Length);
+        }
+
+        protected void Allocate(int size)
+        {
+            if (size != Size)
+            {
+                throw new CauterizeException("arrays for " + GetType() + " must be size " + Size);
+            }
+            _data = new T[size];
+        }
+
+        public static implicit operator T[](CauterizeFixedArrayTyped<T> array)
+        {
+            return array._data;
+        }
+
+        // implicit conversion won't cover slicing
+        public T this[int i]
+        {
+            get { return _data[i]; }
+            set { _data[i] = value; }
+        }
+
+        public T[] GetArray()
+        {
+          return _data;
+        }
+    }
+
+    public abstract class CauterizeVariableArray
+    {
+    }
+
+    public abstract class CauterizeVariableArrayTyped<T> : CauterizeVariableArray
+    {
+        private T[] _data;
+
+        protected abstract int MaxSize { get; }
+        
+        protected void Allocate(T[] data)
+        {
+            Allocate(data.Length);
+            Array.Copy(data, _data, data.Length);
+        }
+
+        protected void Allocate(int size)
+        {
+            if (size > MaxSize)
+            {
+                throw new CauterizeException("arrays for " + GetType() + " must be smaller than " + MaxSize);
+            }
+            _data = new T[size];
+        }
+
+        public static implicit operator T[](CauterizeVariableArrayTyped<T> array)
+        {
+            return array._data;
+        }
+
+        // implicit conversion won't cover slicing
+        public T this[int i]
+        {
+            get { return _data[i]; }
+            set { _data[i] = value; }
+        }
+
+        public T[] GetArray()
+        {
+          return _data;
+        }
+    }
+}
+

data/support/cs/src/CauterizeVariableArrayFormatter.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+
+namespace Cauterize
+{
+    public class CauterizeVariableArrayFormatter : CauterizeContainerFormatter 
+    {
+        public CauterizeVariableArrayFormatter(CauterizeTypeFormatterFactory factory) : base(factory)
+        {
+        }
+
+
+        public override object Deserialize(Stream serializationStream, Type t)
+        {
+            var sizeType = (Type) t.GetField("SizeType").GetValue(null);
+            var sizeFormatter = _typeFormatterFactory.GetFormatter(sizeType);
+            var rawSize = sizeFormatter.Deserialize(serializationStream, sizeType);
+            var arraySize = PrimitiveSupport.TypeToInt(rawSize);
+            var ret = t.GetConstructor(new Type[] {typeof (int)}).Invoke(new object[] {arraySize});
+            var arrayField = t.BaseType.GetField("_data", BindingFlags.NonPublic | BindingFlags.Instance);
+            var array = (Array)arrayField.GetValue(ret);
+            var arrayType = arrayField.FieldType.GetElementType();
+            var subFormatter = _typeFormatterFactory.GetFormatter(arrayType);
+            for (var i = 0; i < arraySize; i++)
+            {
+                array.SetValue(subFormatter.Deserialize(serializationStream, arrayType), i);
+            }
+            return ret;
+        }
+
+        public override void Serialize(Stream serializationStream, object obj)
+        {
+            var t = obj.GetType();
+            var arrayField = t.BaseType.GetField("_data", BindingFlags.NonPublic | BindingFlags.Instance);
+            var array = (Array)arrayField.GetValue(obj);
+            var sizeType = (Type) t.GetField("SizeType").GetValue(null);
+            var sizeFormatter = _typeFormatterFactory.GetFormatter(sizeType);
+            sizeFormatter.Serialize(serializationStream, PrimitiveSupport.IntToType(sizeType, array.Length));
+            var arrayType = arrayField.FieldType.GetElementType();
+            var subFormatter = _typeFormatterFactory.GetFormatter(arrayType);
+            for (var i = 0; i < array.Length; i++)
+            {
+                subFormatter.Serialize(serializationStream, array.GetValue(i));
+            }
+        }
+    }
+}