Fast setter fix

ZeroLevel.Discovery/obj/Debug/ZeroLevel.Discovery.csproj.CoreCompileInputs.cache

@@ -1 +1 @@
-affe24c0b0d3f87817c2fa3318e87e4ecf28560f
+44c25bb53ca989abffacb949ad26248970e4d0d4

ZeroLevel.UnitTests/SerializationTests.cs

@@ -2,7 +2,9 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Net;
+using DOM.Services;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using ZeroLevel.DocumentObjectModel;
 using ZeroLevel.Network;
 using ZeroLevel.Services.Serialization;
 
@@ -331,5 +333,163 @@ namespace ZeroLevel.UnitTests
 
             MakeCollectionTest<Byte[]>(new Byte[][] { null, new byte[] { }, new byte[] { 1 }, new byte[] { 0, 1, 10, 100, 128, 255 } }, comparator);
         }
+
+        [TestMethod]
+        public void SerializeCompositeObject()
+        {
+            var comparator = new Func<Document, Document, bool>((left, right) =>
+            {
+                var l_bin = MessageSerializer.Serialize(left);
+                var r_bin = MessageSerializer.Serialize(right);
+                return ArrayExtensions.UnsafeEquals(l_bin, r_bin);
+            });
+
+            MakePrimitiveTest<Document>(MakeDocument(), comparator);
+        }
+
+        private static Document MakeDocument()
+        {
+            var doc = new Document();
+            doc.Categories.Add(new Category
+            {
+                Title = "Algorithms",
+                Code = "0",
+                DirectionCode = "Posts"
+            });
+            doc.Categories.Add(new Category
+            {
+                Title = "Data compression",
+                Code = "133",
+                DirectionCode = "Posts"
+            });
+            doc.Header = "Парадоксы о сжатии данных";
+            doc.Summary = "Задача сжатия данных в своей простейшей форме может относиться к числам и их обозначениям. Числа можно обозначать числительными («одиннадцать» для числа 11), математическими выражениями («два в двадцатой» для 1048576), строковыми выражениями («пять девяток» для 99999), именами собственными («число зверя» для 666, «год смерти Тьюринга» для 1954), или произвольными их комбинациями. Годится любое обозначение, по которому собеседник сможет однозначно определить, о каком числе речь. Очевидно, что сообщить собеседнику «факториал восьми» эффективнее, чем эквивалентное обозначение «сорок тысяч триста двадцать». Здесь возникает логичный вопрос: какое обозначение для заданного числа самое короткое?";
+            doc.DescriptiveMetadata.Byline = "tyomitch";
+            doc.DescriptiveMetadata.Source.Title = "HABR";
+
+            doc.TagMetadata.Keywords.Add("парадокс берри");
+            doc.TagMetadata.Keywords.Add("колмогоровская сложность");
+            doc.TagMetadata.Keywords.Add("проблема останова");
+
+            doc.Identifier.Link = "https://habr.com/en/post/446976/";
+
+            var builder = new ContentBuilder(doc);
+            builder.EnterParagraph();
+            builder.WriteText("Философ Бертран Рассел в 1908 опубликовал");
+            builder.WriteLink("https://ru.wikipedia.org/wiki/%D0%9F%D0%B0%D1%80%D0%B0%D0%B4%D0%BE%D0%BA%D1%81_%D0%91%D0%B5%D1%80%D1%80%D0%B8", "«парадокс Берри»");
+            builder.WriteText(", который затрагивает вопрос обозначений чисел с противоположной стороны: какое самое маленькое число, для обозначения которого недостаточно восьмидесяти букв? Такое число обязано существовать: из восьмидесяти русских букв и пробелов можно составить всего 3480 обозначений, значит, с использованием восьмидесяти букв можно обозначить не более 3480 чисел.Значит, некое число, не большее чем 3480, обозначить таким образом невозможно.");
+            builder.EnterParagraph();
+            builder.WriteText("Значит, этому числу будет соответствовать обозначение «самое маленькое число, для обозначения которого недостаточно восьмидесяти букв», в котором всего 78 букв! С одной стороны, это число обязано существовать; с другой, если это число существует, то его обозначение ему не соответствует. Парадокс!");
+            builder.EnterParagraph();
+            builder.WriteText("Самый простой способ отмахнуться от этого парадокса — сослаться на неформальность словесных обозначений. Мол, если бы в обозначениях допускался лишь конкретно определённый набор выражений, то «самое маленькое число, для обозначения которого недостаточно восьмидесяти букв» не было бы допустимым обозначением, тогда как практически полезные обозначения типа «факториал восьми» остались бы допустимыми.");
+            builder.EnterParagraph();
+            builder.WriteText("Есть ли формальные способы описания последовательности (алгоритма) действий над числами? Есть, и в изобилии — их называют языками программирования. Будем вместо словесных обозначений использовать программы (например, на Python), выводящие нужные числа. Например, для пяти девяток подойдёт программа print(\"9\"*5). По-прежнему будем интересоваться самой короткой программой для заданного числа. Длину такой программы называют колмогоровской сложностью числа; это теоретический предел, до которого заданное число можно сжать.");
+            builder.EnterParagraph();
+            builder.WriteText("Вместо парадокса Берри теперь можно рассмотреть аналогичный: какое самое маленькое число, для вывода которого недостаточно килобайтной программы?");
+            builder.EnterParagraph();
+            builder.WriteText("Рассуждать будем так же, как и раньше: существует 2561024 килобайтных текстов, значит, килобайтными программами можно вывести не более 2561024 чисел. Значит, некое число, не большее чем 2561024, вывести таким способом невозможно.");
+            builder.EnterParagraph();
+            builder.WriteText("Но напишем на Python программу, которая генерирует все возможные килобайтные тексты, запускает их на выполнение, и если они выводят какое-то число — то добавляет это число в словарь достижимых. После проверки всех 2561024 возможностей, сколько бы времени это ни заняло — программа ищет, какое самое маленькое число отсутствует в словаре, и выводит это число. Кажется очевидным, что такая программа уложится в килобайт кода — и выведет то самое число, которое невозможно вывести килобайтной программой!");
+            builder.EnterParagraph();
+            builder.WriteText("В чём же подвох теперь? На неформальность обозначений его списать уже нельзя!");
+            builder.EnterParagraph();
+            builder.WriteText("Если вас смущает то, что наша программа потребует астрономического количества памяти для работы — словарь (или битовый массив) из 2561024 элементов — то можно всё то же самое осуществить и без него: для каждого из 2561024 чисел по очереди перебирать все 2561024 возможных программ, пока не найдётся подходящая. Не важно, что такой перебор продлится очень долго: после проверки менее чем (2561024)2 пар из числа и программы он ведь завершится, и найдёт то самое заветное число.");
+            builder.EnterParagraph();
+            builder.WriteText("Или не завершится? Ведь среди всех программ, которые будут испробованы, встретится while True: pass (и её функциональные аналоги) — и дальше проверки такой программы дело уже не пойдёт!");
+            builder.EnterParagraph();
+            builder.WriteText("В отличие от парадокса Берри, где подвох был в неформальности обозначений, во втором случае мы имеем хорошо замаскированную переформулировку «проблемы остановки». Дело в том, что по программе невозможно за конечное время определить её вывод.В частности, колмогоровская сложность невычислима: нет никакого алгоритма, который бы позволил для заданного числа найти длину самой короткой программы, выводящей это число; а значит, нет решения и для задачи Берри — найти для заданного числа длину самого короткого словесного обозначения.");
+            builder.Complete();
+
+            var c1 = new Comment
+            {
+                Id = 0,
+                RefToId = -1,
+                Author = "exception13x",
+                Text = "С каких пор пробелы и запятые стали буквами? Если использовать «символов», то парадокс пропадает.",
+                Votes = 0,
+                DateTime = DateTime.Parse("2019-04-09 10:33")
+            };
+            var c2 = new Comment
+            {
+                Id = 1,
+                RefToId = 0,
+                Author = "tyomitch",
+                Text = "Почему пропадает?",
+                Votes = 1,
+                DateTime = DateTime.Parse("2019-04-09 10:57")
+            };
+            var c3 = new Comment
+            {
+                Id = 2,
+                RefToId = 1,
+                Author = "exception13x",
+                Text = "Потому что в фразе «самое маленькое число, для обозначения которого недостаточно восьмидесяти символов» будет 83 символа. Прошу прощения за придирки, меня просто зацепила фраза про 78 букв(которых 69 в исходной фразе)",
+                Votes = -1,
+                DateTime = DateTime.Parse("2019-04-09 12:12")
+            };
+            var c4 = new Comment
+            {
+                Id = 3,
+                RefToId = 2,
+                Author = "kahi4",
+                Text = "ну поменять 80 на 100 и делов то, \"самое маленькое число, для обозначения которого недостаточно ста символов\".",
+                Votes = -1,
+                DateTime = DateTime.Parse("2019-04-09 12:50")
+            };
+            doc.Attachments.Add(new AttachContent("Comment", ContentType.Raw).Write(c1));
+            doc.Attachments.Add(new AttachContent("Comment", ContentType.Raw).Write(c2));
+            doc.Attachments.Add(new AttachContent("Comment", ContentType.Raw).Write(c3));
+            doc.Attachments.Add(new AttachContent("Comment", ContentType.Raw).Write(c4));
+            return doc;
+        }
+
+        private class Comment :
+            IBinarySerializable, IEquatable<Comment>
+        {
+            public long Id;
+            public long RefToId;
+
+            public DateTime DateTime;
+            public string Author;
+
+            public string Text;
+            public int Votes;
+
+            public void Deserialize(IBinaryReader reader)
+            {
+                this.Id = reader.ReadLong();
+                this.RefToId = reader.ReadLong();
+                this.DateTime = reader.ReadDateTime().Value;
+                this.Author = reader.ReadString();
+                this.Text = reader.ReadString();
+                this.Votes = reader.ReadInt32();
+            }
+
+            public override bool Equals(object obj)
+            {
+                return this.Equals(obj as Comment);
+            }
+
+            public override int GetHashCode()
+            {
+                return this.Id.GetHashCode();
+            }
+
+            public bool Equals(Comment other)
+            {
+                if (other == null) return false;
+                return this.Id == other.Id && this.RefToId == other.RefToId && this.Votes == other.Votes;
+            }
+
+            public void Serialize(IBinaryWriter writer)
+            {
+                writer.WriteLong(this.Id);
+                writer.WriteLong(this.RefToId);
+                writer.WriteDateTime(this.DateTime);
+                writer.WriteString(this.Author);
+                writer.WriteString(this.Text);
+                writer.WriteInt32(this.Votes);
+            }
+        }
     }
 }

ZeroLevel/Services/DOM/Model/AttachContent.cs

@@ -40,9 +40,27 @@ namespace ZeroLevel.DocumentObjectModel
             Deserialize(reader);
         }
 
+        public AttachContent(string identity, ContentType contentType)
+        { Identity = identity; ContentType = contentType; }
+
+        public AttachContent(string identity, string caption, ContentType contentType)
+        { Identity = identity; Caption = caption; ContentType = contentType; }
+
         public AttachContent(string identity, string caption, string description)
         { Identity = identity; Summary = description; Caption = caption; }
 
+        public AttachContent Write<T>(T value)
+        {
+            this.Payload = MessageSerializer.SerializeCompatible<T>(value);
+            return this;
+        }
+
+        public T Read<T>()
+        {
+            if (this.Payload == null || this.Payload.Length == 0) return default(T);
+            return MessageSerializer.DeserializeCompatible<T>(this.Payload);
+        }
+
         #region IBinarySerializable
 
         public void Serialize(IBinaryWriter writer)

ZeroLevel/Services/DOM/Model/Identifier.cs

@@ -31,6 +31,11 @@ namespace ZeroLevel.DocumentObjectModel
         /// </summary>
         public string DateLabel;
 
+        /// <summary>
+        /// Document unique link
+        /// </summary>
+        public string Link;
+
         #endregion Fields
 
         #region IBinarySerializable
@@ -40,6 +45,7 @@ namespace ZeroLevel.DocumentObjectModel
             writer.WriteInt32(this.Version);
             writer.WriteLong(this.Timestamp);
             writer.WriteString(this.DateLabel);
+            writer.WriteString(this.Link);
         }
 
         public void Deserialize(IBinaryReader reader)
@@ -47,6 +53,7 @@ namespace ZeroLevel.DocumentObjectModel
             this.Version = reader.ReadInt32();
             this.Timestamp = reader.ReadLong();
             this.DateLabel = reader.ReadString();
+            this.Link = reader.ReadString();
         }
 
         #endregion IBinarySerializable

ZeroLevel/Services/Reflection/TypeGetterSetterBuilder.cs

@@ -49,11 +49,17 @@ namespace ZeroLevel.Services.Reflection
                             Expression.Unbox(instance, field.DeclaringType) :
                             Expression.Convert(instance, field.DeclaringType);
             var fieldExp = Expression.Field(target, field);
-
+            UnaryExpression convertExpression;
-            var typeCode = Type.GetTypeCode(field.FieldType);
+            if (typeof(IConvertible).IsAssignableFrom(field.FieldType))
-            var changeTypeMethod = typeof(Convert).GetMethod("ChangeType", new Type[] { typeof(object), typeof(TypeCode) });
+            {
-            var convertExpression = Expression.Call(changeTypeMethod, inputValue, Expression.Constant(typeCode));
+                var typeCode = Type.GetTypeCode(field.FieldType);
-
+                var changeTypeMethod = typeof(Convert).GetMethod("ChangeType", new Type[] { typeof(object), typeof(TypeCode) });
+                convertExpression = Expression.Convert(Expression.Call(changeTypeMethod, inputValue, Expression.Constant(typeCode)), field.FieldType);
+            }
+            else
+            {
+                convertExpression = Expression.Convert(inputValue, field.FieldType);
+            }
             var assignExp = Expression.Assign(fieldExp, field.FieldType.IsValueType ?
                 Expression.Convert(convertExpression, field.FieldType) :
                 Expression.TypeAs(convertExpression, field.FieldType));
@@ -76,10 +82,19 @@ namespace ZeroLevel.Services.Reflection
                             Expression.Unbox(instance, property.DeclaringType) :
                             Expression.Convert(instance, property.DeclaringType);
             var method = property.GetSetMethod(true);
-            var typeCode = Type.GetTypeCode(property.PropertyType);
+
-            var changeTypeMethod = typeof(Convert).GetMethod("ChangeType", new Type[] { typeof(object), typeof(TypeCode) });
+            UnaryExpression convertExpression;
-            var convertExpression = Expression.Call(changeTypeMethod, inputValue, Expression.Constant(typeCode));
+            if (typeof(IConvertible).IsAssignableFrom(property.PropertyType))
-            var setterCall = Expression.Call(target, method, Expression.Convert(convertExpression, property.PropertyType));
+            {
+                var typeCode = Type.GetTypeCode(property.PropertyType);
+                var changeTypeMethod = typeof(Convert).GetMethod("ChangeType", new Type[] { typeof(object), typeof(TypeCode) });
+                convertExpression = Expression.Convert(Expression.Call(changeTypeMethod, inputValue, Expression.Constant(typeCode)), property.PropertyType);
+            }
+            else
+            {
+                convertExpression = Expression.Convert(inputValue, property.PropertyType);
+            }
+            var setterCall = Expression.Call(target, method, convertExpression);
             var expr = Expression.Lambda<Action<object, object>>(setterCall, instance, inputValue);
             return expr.Compile();
         }
@@ -96,10 +111,18 @@ namespace ZeroLevel.Services.Reflection
             var targetExp = Expression.Parameter(typeof(T), "target");
             var inputValue = Expression.Parameter(typeof(object), "o");
             var fieldExp = Expression.Field(targetExp, field);
-            var typeCode = Type.GetTypeCode(field.FieldType);
+            UnaryExpression convertExpression;
-            var changeTypeMethod = typeof(Convert).GetMethod("ChangeType", new Type[] { typeof(object), typeof(TypeCode) });
+            if (typeof(IConvertible).IsAssignableFrom(field.FieldType))
-            var convertExpression = Expression.Call(changeTypeMethod, inputValue, Expression.Constant(typeCode));
+            {
-            var assignExp = Expression.Assign(fieldExp, Expression.Convert(convertExpression, field.FieldType));
+                var typeCode = Type.GetTypeCode(field.FieldType);
+                var changeTypeMethod = typeof(Convert).GetMethod("ChangeType", new Type[] { typeof(object), typeof(TypeCode) });
+                convertExpression = Expression.Convert(Expression.Call(changeTypeMethod, inputValue, Expression.Constant(typeCode)), field.FieldType);
+            }
+            else
+            {
+                convertExpression = Expression.Convert(inputValue, field.FieldType);
+            }
+            var assignExp = Expression.Assign(fieldExp, convertExpression);
             return Expression.Lambda<Action<T, object>>(assignExp, targetExp, inputValue).Compile();
         }
 
@@ -118,10 +141,18 @@ namespace ZeroLevel.Services.Reflection
                             Expression.Unbox(instance, method.DeclaringType) :
                             Expression.Convert(instance, method.DeclaringType);
             var value = Expression.Parameter(typeof(object), "v");
-            var typeCode = Type.GetTypeCode(property.PropertyType);
+            UnaryExpression convertExpression;
-            var changeTypeMethod = typeof(Convert).GetMethod("ChangeType", new Type[] { typeof(object), typeof(TypeCode) });
+            if (typeof(IConvertible).IsAssignableFrom(property.PropertyType))
-            var convertExpression = Expression.Call(changeTypeMethod, value, Expression.Constant(typeCode));
+            {
-            var setterCall = Expression.Call(target, method, Expression.Convert(convertExpression, property.PropertyType));
+                var typeCode = Type.GetTypeCode(property.PropertyType);
+                var changeTypeMethod = typeof(Convert).GetMethod("ChangeType", new Type[] { typeof(object), typeof(TypeCode) });
+                convertExpression = Expression.Convert(Expression.Call(changeTypeMethod, value, Expression.Constant(typeCode)), property.PropertyType);
+            }
+            else
+            {
+                convertExpression = Expression.Convert(value, property.PropertyType);
+            }
+            var setterCall = Expression.Call(target, method, convertExpression);
             var expr = Expression.Lambda<Action<T, object>>(setterCall, instance, value);
             return expr.Compile();
         }

ZeroLevel/obj/Debug/ZeroLevel.csproj.CoreCompileInputs.cache

@@ -1 +1 @@
-4d221d21073e6ec70fc75d0c6e7d2458aa0f2b9a
+23b05e1da25edde99ed56a899f894605a2243d39