Пример #1
0
        public static bool IsEqualWhileIgnoreComments(MessageDatabase a, MessageDatabase b, IObserver <string> errors)
        {
            if (a._name != b._name)
            {
                errors.OnNext(string.Format("Message name differs, A = {0}, B = {1}", a._name, b._name));
                return(false);
            }

            if (a._messageDatabaseItems.Count != b._messageDatabaseItems.Count)
            {
                errors.OnNext(string.Format("Looks like you either have removed or added a new datafield"));
                return(false);
            }

            foreach (var aItem in a._messageDatabaseItems)
            {
                var isEqual = b._messageDatabaseItems.FirstOrDefault(bItem => MessageDatabaseItem.IsEqualWhileIgnoreComments(aItem, bItem));

                if (isEqual == null)
                {
                    var errorStringBuilder = new StringBuilder();
                    errorStringBuilder.Append("A property/field has changed, expected to find: " + aItem.Name + "\nWidth: ");
                    foreach (var child in aItem.Children)
                    {
                        errorStringBuilder.Append(child.Name + ",");
                    }

                    errors.OnNext(errorStringBuilder.ToString());
                    return(false);
                }
            }

            return(true);
        }
Пример #2
0
        public static void Write(MessageDatabaseItem item, BinaryWriter writer)
        {
            writer.Write(item.Name);
            writer.Write(item.Comment.Comment);
            writer.Write(item.Comment.Example);
            writer.Write(item.Comment.IsNumber);
            writer.Write(item.Children.Count);

            foreach (var child in item.Children)
            {
                MessageDatabaseItem.Write(child, writer);
            }
        }
Пример #3
0
        public void Dump(AbsoluteFilePath filePath)
        {
            Directory.CreateDirectory(filePath.ContainingDirectory.NativePath);

            using (var file = File.Open(filePath.NativePath, FileMode.Create))
                using (var writer = new BinaryWriter(file))
                {
                    writer.Write(_name);
                    writer.Write(_messageDatabaseItems.Count);
                    foreach (var messageDatabaseItem in _messageDatabaseItems)
                    {
                        MessageDatabaseItem.Write(messageDatabaseItem, writer);
                    }
                }
        }
Пример #4
0
        public static MessageDatabase From(AbsoluteFilePath filePath)
        {
            using (var file = File.Open(filePath.NativePath, FileMode.Open))
                using (var reader = new BinaryReader(file))
                {
                    var databaseItems = new List <MessageDatabaseItem>();
                    var name          = reader.ReadString();
                    var count         = reader.ReadInt32();
                    for (var i = 0; i < count; ++i)
                    {
                        databaseItems.Add(MessageDatabaseItem.Read(reader));
                    }

                    return(new MessageDatabase(name, databaseItems));
                }
        }
Пример #5
0
        public static MessageDatabaseItem Read(BinaryReader reader)
        {
            var name        = reader.ReadString();
            var comment     = reader.ReadString();
            var example     = reader.ReadString();
            var isNumber    = reader.ReadBoolean();
            var numChildren = reader.ReadInt32();

            var children = new List <MessageDatabaseItem>();

            for (var i = 0; i < numChildren; ++i)
            {
                children.Add(MessageDatabaseItem.Read(reader));
            }

            return(new MessageDatabaseItem(name, new PluginCommentAttribute(comment, example, isNumber), children));
        }
Пример #6
0
        public static bool IsEqualWhileIgnoreComments(MessageDatabaseItem a, MessageDatabaseItem b)
        {
            if (a.Name != b.Name)
            {
                return(false);
            }

            if (a.Children.Count != b.Children.Count)
            {
                return(false);
            }

            foreach (var childA in a.Children)
            {
                var isEqual = b.Children.FirstOrDefault(childB => IsEqualWhileIgnoreComments(childA, childB));
                if (isEqual == null)
                {
                    return(false);
                }
            }

            return(true);
        }