cauterize 0.0.1.pre1 → 0.0.1.pre5

data/support/cs/src/ICauterizeTypeFormatter.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace Cauterize
+{
+    public interface ICauterizeTypeFormatter
+    {
+        object Deserialize(Stream serializationStream, Type t);
+        void Serialize(Stream serializationStream, object obj);
+    }
+}

data/support/cs/src/OrderAttribute.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Reflection;
+using System.Text;
+
+namespace Cauterize
+{
+    [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, 
+        Inherited = true, AllowMultiple = false)]
+    [ImmutableObject(true)]
+    public sealed class OrderAttribute : Attribute {
+        private readonly int _order;
+        public int Order { get { return _order; } }
+        public OrderAttribute(int order) {_order = order;}
+        public static IEnumerable<PropertyInfo> GetSortedProperties(Type t)
+        {
+            var propComp = new Comparison<PropertyInfo>(CompareProps);
+            var propList = new List<PropertyInfo>(t.GetProperties());
+
+            propList.Sort(propComp);
+
+            return propList;
+        }
+
+        public static PropertyInfo GetPropertyByOrder(Type t, int order)
+        {
+            foreach (var prop in t.GetProperties())
+            {
+                var orderAttr = ((OrderAttribute)prop.GetCustomAttributes(typeof(OrderAttribute), false)[0]);
+
+                if (orderAttr.Order == order)
+                {
+                    return prop;
+                }
+            }
+
+            return null;
+        }
+
+        private static int CompareProps(PropertyInfo a, PropertyInfo b)
+        {
+            OrderAttribute _a = (OrderAttribute)a.GetCustomAttributes(typeof(OrderAttribute), false)[0];
+            OrderAttribute _b = (OrderAttribute)b.GetCustomAttributes(typeof(OrderAttribute), false)[0];
+
+            return _a.Order - _b.Order;
+        }
+    }
+}
+

data/support/cs/src/PrimitiveSupport.cs

@@ -0,0 +1,134 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Cauterize
+{
+    public class PrimitiveSupport
+    {
+        static public int TypeToByteSize(Type t)
+        {
+            if (t == typeof(Byte) || t == typeof(SByte))
+            {
+                return 1;
+            }
+            else if (t == typeof (UInt16) || t == typeof (Int16))
+            {
+                return 2;
+            }
+            else if (t == typeof (UInt32) || t == typeof (Int32))
+            {
+                return 4;
+            }
+            else if (t == typeof (UInt64) || t == typeof (Int64))
+            {
+                return 8;
+            }
+            else
+            {
+                throw new Exception("Invalid type to get byte size");
+            }
+        }
+
+        static public int TypeToInt(object value)
+        {
+            if (value is Int32)
+            {
+                return (int) value;
+            }
+            else if (value is Int16)
+            {
+                return (Int16)value;
+            }
+            else if (value is Byte)
+            {
+                return (Byte) value;
+            }
+            else if (value is UInt32)
+            {
+                return (int)(UInt32) value;
+            }
+            else if (value is UInt16)
+            {
+                return (UInt16) value;
+            }
+            else if (value is SByte)
+            {
+                return (SByte) value;
+            }
+            else if (value == null)
+            {
+                return 0;
+            }
+            else
+            {
+                throw new Exception("invalid array size type");
+            }
+        }
+
+        static public object IntToType(Type t, int value)
+        {
+            if (t == typeof(Int32))
+            {
+                return value;
+            }
+            else if (t == typeof(Int16))
+            {
+                return (Int16)value;
+            }
+            else if (t == typeof(Byte))
+            {
+                return (Byte)value;
+            }
+            else if (t == typeof (UInt32))
+            {
+                return (UInt32) value;
+            }
+            else if (t == typeof (UInt16))
+            {
+                return (UInt16) value;
+            }
+            else if (t == typeof (SByte))
+            {
+                return (SByte) value;
+            }
+            else
+            {
+                throw new Exception("Invalid type for array size type");
+            }
+
+        }
+
+        static public object TypeFromBytes(Type t, byte[] bytes)
+        {
+            if (t == typeof (Byte))
+            {
+                return bytes[0];
+            }
+            else if (t == typeof (SByte))
+            {
+                return (SByte) bytes[0];
+            }
+            else
+            {
+                return typeof(BitConverter)
+                    .GetMethod("To" + t.Name, new Type[] {typeof(byte[]), typeof(int)})
+                    .Invoke(null,new object[]{bytes, 0});
+            }
+        }
+
+        static public byte[] BytesFromValue(object value)
+        {
+            if (value is Byte || value is SByte)
+            {
+                return new[] {(byte) value};
+            }
+            else
+            {
+                return (byte[]) typeof (BitConverter)
+                    .GetMethod("GetBytes", new Type[] {value.GetType()})
+                    .Invoke(null, new object[] {value});
+            }
+        }
+    }
+}

data/support/cs/src/SerializedRepresentationAttribute.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Reflection;
+using System.Text;
+
+namespace Cauterize
+{
+    [AttributeUsage(AttributeTargets.Enum, Inherited = true, AllowMultiple = false)]
+    [ImmutableObject(true)]
+    public sealed class SerializedRepresentationAttribute : Attribute {
+        public Type Type { get; private set; }
+        public SerializedRepresentationAttribute(Type type) 
+        {
+            Type = type;
+        }
+        public static Type GetRepresentation(Type t)
+        {
+            var attrs = t.GetCustomAttributes(typeof(SerializedRepresentationAttribute), false);
+            return ((SerializedRepresentationAttribute)attrs[0]).Type;
+        }
+    }
+}
+

data/support/cs/test/CauterizeCompositeFormatterTest.cs

@@ -0,0 +1,59 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Collections.Generic;
+using System.Linq;
+using Cauterize;
+using Moq;
+using NUnit.Framework;
+
+namespace Cauterize.Test
+{
+    public class TestComposite : CauterizeComposite
+    {
+        [Order(0)]
+        public Int16 MyIntSmall { get; set; }
+
+        [Order(1)]
+        public Int32 MyIntNormal { get; set; }
+    }
+
+    [TestFixture]
+    public class CauterizeCompositeFormatterTest
+    {
+        [Test]
+        public void TestDeserialize()
+        {
+            var stream = new MemoryStream();
+            var factory = new Mock<CauterizeTypeFormatterFactory>();
+            var sf1 = new Mock<ICauterizeTypeFormatter>();
+            var sf2 = new Mock<ICauterizeTypeFormatter>();
+            factory.Setup(f => f.GetFormatter(It.IsAny<Type>())).Returns((Type t) => t == typeof(Int16) ? sf1.Object : sf2.Object);
+            sf1.Setup(sf => sf.Deserialize(stream, typeof (Int16))).Returns((Int16) 5);
+            sf2.Setup(sf => sf.Deserialize(stream, typeof (Int32))).Returns(15);
+            var formatter = new CauterizeCompositeFormatter(factory.Object);
+            var output = (TestComposite) formatter.Deserialize(stream, typeof (TestComposite));
+            Assert.AreEqual(15, output.MyIntNormal);
+            Assert.AreEqual(5, output.MyIntSmall);
+        }
+
+        [Test]
+        public void TestSerialize()
+        {
+            var stream = new MemoryStream();
+            var factory = new Mock<CauterizeTypeFormatterFactory>();
+            var sf1 = new Mock<ICauterizeTypeFormatter>();
+            var sf2 = new Mock<ICauterizeTypeFormatter>();
+            factory.Setup(f => f.GetFormatter(It.IsAny<Type>())).Returns((Type t) => t == typeof(Int16) ? sf1.Object : sf2.Object);
+            sf1.Setup(sf => sf.Serialize(stream, (Int16)2));
+            sf2.Setup(sf => sf.Serialize(stream, 2222));
+            var formatter = new CauterizeCompositeFormatter(factory.Object);
+            var testObj = new TestComposite();
+            testObj.MyIntNormal = 2222;
+            testObj.MyIntSmall = 2;
+            formatter.Serialize(stream, testObj);
+            sf2.VerifyAll();
+            sf1.VerifyAll();
+        }
+    }
+}

data/support/cs/test/CauterizeEnumFormatterTest.cs

@@ -0,0 +1,110 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+
+namespace Cauterize.Test
+{
+    [SerializedRepresentation(typeof(SByte))]
+    public enum CauterizeEnumTestSmall
+    {
+        Cets01 = 0,
+        Cets02 = 2
+    }
+
+    [SerializedRepresentation(typeof(Int16))]
+    public enum CauterizeEnumTestMedium
+    {
+        Cetm01 = 0,
+        Cetm02 = 512
+    }
+
+    [SerializedRepresentation(typeof(Int64))]
+    public enum CauterizeEnumTestLarge
+    {
+        Cetl01 = 0,
+        Cetl02 = 131072
+    }
+
+    [TestFixture]
+    public class CauterizeEnumFormatterTest
+    {
+        [Test]
+        public void TestDeserialize_Small()
+        {
+            var bytes = new byte[1];
+            bytes[0] = 2;
+            var stream = new MemoryStream(bytes);
+            var formatter = new CauterizeEnumFormatter();
+            Assert.AreEqual(CauterizeEnumTestSmall.Cets02, formatter.Deserialize(stream, typeof (CauterizeEnumTestSmall)));
+        }
+
+        [Test]
+        public void TestDeserialize_Medium()
+        {
+            var bytes = new byte[2];
+            bytes[0] = 0;
+            bytes[1] = 2;
+            var stream = new MemoryStream(bytes);
+            var formatter = new CauterizeEnumFormatter();
+            Assert.AreEqual(CauterizeEnumTestMedium.Cetm02, formatter.Deserialize(stream, typeof (CauterizeEnumTestMedium)));
+        }
+
+        [Test]
+        public void TestDeserialize_Large()
+        {
+            var bytes = new byte[8];
+            bytes[0] = 0;
+            bytes[1] = 0;
+            bytes[2] = 2;
+            bytes[3] = 0;
+            bytes[4] = 0;
+            bytes[5] = 0;
+            bytes[6] = 0;
+            bytes[7] = 0;
+            var stream = new MemoryStream(bytes);
+            var formatter = new CauterizeEnumFormatter();
+            Assert.AreEqual(CauterizeEnumTestLarge.Cetl02, formatter.Deserialize(stream, typeof (CauterizeEnumTestLarge)));
+        }
+
+        [Test]
+        public void TestSerialize_Small()
+        {
+            var bytes = new byte[1];
+            var stream = new MemoryStream(bytes);
+            var formatter = new CauterizeEnumFormatter();
+            formatter.Serialize(stream, CauterizeEnumTestSmall.Cets02);
+            Assert.AreEqual(2, bytes[0]);
+        }
+
+        [Test]
+        public void TestSerialize_Medium()
+        {
+            var bytes = new byte[2];
+            var stream = new MemoryStream(bytes);
+            var formatter = new CauterizeEnumFormatter();
+            formatter.Serialize(stream, CauterizeEnumTestMedium.Cetm02);
+            Assert.AreEqual(0, bytes[0]);
+            Assert.AreEqual(2, bytes[1]);
+        }
+
+        [Test]
+        public void TestSerialize_Large()
+        {
+            var bytes = new byte[8];
+            var stream = new MemoryStream(bytes);
+            var formatter = new CauterizeEnumFormatter();
+            formatter.Serialize(stream, CauterizeEnumTestLarge.Cetl02);
+            Assert.AreEqual(0, bytes[0]);
+            Assert.AreEqual(0, bytes[1]);
+            Assert.AreEqual(2, bytes[2]);
+            Assert.AreEqual(0, bytes[3]);
+            Assert.AreEqual(0, bytes[4]);
+            Assert.AreEqual(0, bytes[5]);
+            Assert.AreEqual(0, bytes[6]);
+            Assert.AreEqual(0, bytes[7]);
+        }
+    }
+}

data/support/cs/test/CauterizeFixedArrayFormatterTest.cs

@@ -0,0 +1,91 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Collections.Generic;
+using System.Linq;
+using Moq;
+using NUnit.Framework;
+using Cauterize;
+
+namespace Cauterize.Test
+{
+    class TestFixedArray : CauterizeFixedArrayTyped<long>
+    {
+        public TestFixedArray()
+        {
+            Allocate(3);
+        }
+        public TestFixedArray(long[] data)
+        {
+            Allocate(data);
+        }
+        protected override int Size
+        {
+            get { return 3; }
+        }
+    }
+    [TestFixture]
+    public class CauterizeFixedArrayFormatterTest
+    {
+        [Test]
+        public void TestDeserialize()
+        {
+            var stream = new MemoryStream();
+            var factory = new Mock<CauterizeTypeFormatterFactory>();
+            var sf = new Mock<ICauterizeTypeFormatter>();
+            factory.Setup(f => f.GetFormatter(typeof (Int64))).Returns(sf.Object);
+            var counter = 0;
+            sf.Setup(f => f.Deserialize(stream, typeof(Int64))).Returns((Stream str, Type t) =>
+                {
+                    var ret = 0;
+                    if (counter == 1)
+                    {
+                        ret = 101;
+                    }
+                    else if (counter == 2)
+                    {
+                        ret = 321;
+                    }
+                    counter++;
+                    return ret;
+                });
+            var formatter = new CauterizeFixedArrayFormatter(factory.Object);
+            var result = (TestFixedArray) formatter.Deserialize(stream, typeof (TestFixedArray));
+            Assert.AreEqual(0, result[0]);
+            Assert.AreEqual(101, result[1]);
+            Assert.AreEqual(321, result[2]);
+        }
+
+        [Test]
+        public void TestSerialize()
+        {
+            var stream = new MemoryStream();
+            var testObj = new TestFixedArray();
+            testObj[0] = 4;
+            testObj[2] = 8;
+            var sf = new Mock<ICauterizeTypeFormatter>();
+            var factory = new Mock<CauterizeTypeFormatterFactory>();
+            factory.Setup(f => f.GetFormatter(typeof (Int64))).Returns(sf.Object);
+            var counter = 0;
+            sf.Setup(f => f.Serialize(stream, It.IsAny<Int64>())).Callback((Stream str, object value) =>
+                {
+                    if (counter == 0)
+                    {
+                        Assert.AreEqual(4, value);
+                    } 
+                    else if (counter == 2)
+                    {
+                        Assert.AreEqual(8, value);
+                    }
+                    else
+                    {
+                        Assert.AreEqual(0, value);
+                    }
+                    counter++;
+                });
+            var formatter = new CauterizeFixedArrayFormatter(factory.Object);
+            formatter.Serialize(stream, testObj);
+            sf.VerifyAll();
+        }
+    }
+}