예제 #1
0
        private static bool ApplicableToDistributiveTransformation(LogicalTreeNode root)
        {
            var isConjunction       = root.Type == NodeType.Conjunction;
            var hasDisjunctionChild = root.HasChild(x => x.Type == NodeType.Disjunction);

            return(isConjunction && hasDisjunctionChild);
        }
        /// <summary>
        /// Рекурсивно "опускает" отрицание вплоть до листьев
        /// На выходе в дереве отрицание есть только у листовых вершин
        /// </summary>
        /// <param name="root">Корень дерева, для которого производится трансформация</param>
        public void Transform(LogicalTreeNode root)
        {
            ReverseNegation(root);

            foreach (var childNode in root.Children)
            {
                Transform(childNode);
            }
        }
        /// <summary>
        /// Применяет правило Де-Моргана к конкретной вершине, в случае если она содержит отрицание.
        /// Если вершина не содержит отрицания - она не изменяется.
        /// </summary>
        /// <param name="node">Вершина, к которой применяется правило де-моргана</param>
        private static void ReverseNegation(LogicalTreeNode node)
        {
            if (!node.Negated)
            {
                return;
            }

            switch (node.Type)
            {
            case NodeType.Conjunction:
                node.Type    = NodeType.Disjunction;
                node.Negated = false;
                break;

            case NodeType.Disjunction:
                node.Type    = NodeType.Conjunction;
                node.Negated = false;
                break;
            }
        }
예제 #4
0
        public void Transform(LogicalTreeNode root)
        {
            // Для дизъюнкции применимо только удаление лишних скобок
            if (root.Type == NodeType.Disjunction)
            {
                _disjunctionTransformation.Transform(root);
            }
            // Если вершина не дизъюнкция, то первоприоритетно проверяем, можно ли раскрыть дистрибутивность
            else if (ApplicableToDistributiveTransformation(root))
            {
                _distributiveTransformation.Transform(root);
            }
            // Если раскрыть нельзя - пытаемся удалить лишние скобки для конъюнкции
            else if (root.Type == NodeType.Conjunction)
            {
                _conjunctionTransformation.Transform(root);
            }

            // В противном случае вершниа - лист, и для нее никакие трансформации неприменимы
        }
예제 #5
0
        private Control GetHeader(LogicalTreeNode node)
        {
            var result = new StackPanel
            {
                Orientation = Orientation.Horizontal,
                Gap         = 8,
                Children    = new Controls
                {
                    new TextBlock
                    {
                        Text = node.Type,
                    },
                    new TextBlock
                    {
                        [!TextBlock.TextProperty] = node.WhenAnyValue(x => x.Classes),
                    }
                }
            };

            result.PointerEnter += AddAdorner;
            result.PointerLeave += RemoveAdorner;

            return(result);
        }
예제 #6
0
    public void TryPush(LogicalTreeNode logicalTreeNode)
    {
        /*Some logic */

        this.TryPush(new ConditionResult(false));
    }
예제 #7
0
 public LogicalTree(LogicalTreeNode root)
 {
     Root = root;
 }