Пример #1
0
 internal override void forgetChild(Element child)
 {
     D.assert(child != null);
     D.assert(child.slot != null);
     D.assert(_childElements.ContainsKey((int)child.slot));
     _childElements.Remove((int)child.slot);
     base.forgetChild(child);
 }
Пример #2
0
        public void removeChild(RenderBox child)
        {
            int index = renderObject.indexOf(child);

            owner.buildScope(this, () => {
                D.assert(_childElements.ContainsKey(index));
                Element result = updateChild(_childElements[index], null, index);
                D.assert(result == null);
                _childElements.Remove(index);
                D.assert(!_childElements.ContainsKey(index));
            });
        }
Пример #3
0
        public void removeChild(RenderBox child)
        {
            var index = renderObject.indexOf(child: child);

            owner.buildScope(this, () => {
                D.assert(_childElements.ContainsKey(key: index));
                var result = updateChild(_childElements[key: index], null, newSlot: index);
                D.assert(result == null);
                _childElements.Remove(key: index);
                D.assert(!_childElements.ContainsKey(key: index));
            });
        }
Пример #4
0
        public void Simple()
        {
            var splayTree = new SplayTree<int, string>();
            splayTree.Clear();

            Assert.AreEqual(splayTree.Count, 0);

            splayTree = GetTestTree();
            Assert.IsTrue(splayTree.ContainsKey(19));

            splayTree.Clear();
            Assert.AreEqual(splayTree.Count, 0);
            Assert.IsFalse(splayTree.ContainsKey(19));
        }
        public void SplayTreeContainsKey()
        {
            var tree = new SplayTree <int, int>()
            {
                { 1, 1 },
                { 2, 2 },
                { -1, -1 },
                { -2, -2 },
                { 3, 3 }
            };

            Assert.IsTrue(tree.ContainsKey(1));
            Assert.IsTrue(tree.ContainsKey(-1));
            Assert.IsFalse(tree.ContainsKey(-3));
        }
Пример #6
0
        public void Simple()
        {
            var splayTree = new SplayTree <int, string>();

            splayTree.Clear();

            Assert.AreEqual(splayTree.Count, 0);

            splayTree = GetTestTree();
            Assert.IsTrue(splayTree.ContainsKey(19));

            splayTree.Clear();
            Assert.AreEqual(splayTree.Count, 0);
            Assert.IsFalse(splayTree.ContainsKey(19));
        }
        string _findNearest(SplayTree <float, string> candidates, float value)
        {
            if (candidates.ContainsKey(value))
            {
                return(candidates[value]);
            }
            float lower = candidates.lastKeyBefore(value);
            float upper = candidates.firstKeyAfter(value);

            if (lower == null)
            {
                return(candidates[upper]);
            }
            if (upper == null)
            {
                return(candidates[lower]);
            }
            if (value > (lower + upper) / 2)
            {
                return(candidates[upper]);
            }
            else
            {
                return(candidates[lower]);
            }
        }
Пример #8
0
        public void Simple()
        {
            var splayTree = new SplayTree<int, string>();

            var dictionary = new Dictionary<int, string>();

            var rand = new Random(Convert.ToInt32(DateTime.Now.Ticks % Int32.MaxValue));

            for (var i = 0; i < 50; i++)
            {
                var gen = rand.Next(2000);

                while (dictionary.ContainsKey(gen))
                {
                    gen = rand.Next(2000);
                }

                dictionary.Add(gen, null);

                splayTree.Add(gen, gen.ToString());

                Assert.AreEqual(splayTree.Count, i + 1);
                Assert.IsTrue(splayTree.ContainsKey(gen));
            }
        }
Пример #9
0
        public void KeyValuePair()
        {
            var splayTree = new SplayTree <int, string>();

            var dictionary = new Dictionary <int, string>();

            var rand = new Random(Convert.ToInt32(DateTime.Now.Ticks % Int32.MaxValue));

            for (var i = 0; i < 50; i++)
            {
                var gen = rand.Next(2000);

                while (dictionary.ContainsKey(gen))
                {
                    gen = rand.Next(2000);
                }

                dictionary.Add(gen, null);

                splayTree.Add(new KeyValuePair <int, string>(gen, gen.ToString()));

                Assert.AreEqual(splayTree.Count, i + 1);
                Assert.IsTrue(splayTree.ContainsKey(gen));
            }
        }
Пример #10
0
        public void Simple2()
        {
            var splayTree = new SplayTree <int, string>();

            var dictionary = new Dictionary <int, string>();

            var rand = new Random(Convert.ToInt32(DateTime.Now.Ticks % Int32.MaxValue));

            for (var i = 0; i < 50; i++)
            {
                var gen = rand.Next(2000);

                while (dictionary.ContainsKey(gen))
                {
                    gen = rand.Next(2000);
                }

                dictionary.Add(gen, null);

                splayTree.Add(gen, gen.ToString());

                Assert.AreEqual(splayTree.Count, i + 1);
                Assert.IsTrue(splayTree.ContainsKey(gen));
            }

            using (var enumerator = dictionary.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    Assert.IsTrue(splayTree.Remove(enumerator.Current));
                }
            }
        }
Пример #11
0
        public void Simple()
        {
            var splayTree = new SplayTree <int, string>();

            Assert.IsFalse(splayTree.ContainsKey(5));

            splayTree.Add(4, "4");
            Assert.AreEqual(splayTree[4], "4");
            Assert.IsTrue(splayTree.ContainsKey(4));
            Assert.IsFalse(splayTree.ContainsKey(5));

            splayTree.Add(6, "6");
            Assert.AreEqual(splayTree[6], "6");
            Assert.IsTrue(splayTree.ContainsKey(4));
            Assert.IsFalse(splayTree.ContainsKey(5));
            Assert.IsTrue(splayTree.ContainsKey(6));

            splayTree.Add(2, "2");
            Assert.AreEqual(splayTree[2], "2");
            Assert.IsTrue(splayTree.ContainsKey(2));
            Assert.IsTrue(splayTree.ContainsKey(4));
            Assert.IsFalse(splayTree.ContainsKey(5));
            Assert.IsTrue(splayTree.ContainsKey(6));

            splayTree.Add(5, "5");
            Assert.AreEqual(splayTree[5], "5");
            Assert.IsTrue(splayTree.ContainsKey(2));
            Assert.IsTrue(splayTree.ContainsKey(4));
            Assert.IsTrue(splayTree.ContainsKey(5));
            Assert.IsTrue(splayTree.ContainsKey(6));


            var rand = new Random();

            splayTree = new SplayTree <int, string>();

            var list = new List <int>();

            for (var i = 0; i < 100; i++)
            {
                int r;

                do
                {
                    r = rand.Next(5000);
                }while (list.Contains(r));

                list.Add(r);

                splayTree.Add(r, null);

                Assert.IsTrue(splayTree.ContainsKey(r));
            }
        }
Пример #12
0
        string _findNearest(SplayTree <float, string> candidates, float value)
        {
            if (candidates.ContainsKey(value))
            {
                return(candidates[value]);
            }
            var lower = candidates.lastKeyBefore(value);
            var upper = candidates.firstKeyAfter(value);

            if (value > (lower + upper) / 2)
            {
                return(candidates[upper]);
            }

            return(candidates[lower]);
        }
Пример #13
0
        public List <TextBox> getRectsForRange(int start, int end)
        {
            var lineBoxes = new SplayTree <int, List <TextBox> >();

            for (int runIndex = 0; runIndex < this._codeUnitRunsCount; runIndex++)
            {
                var run = this._codeUnitRuns[runIndex];
                if (run.codeUnits.start >= end)
                {
                    break;
                }

                if (run.codeUnits.end <= start)
                {
                    continue;
                }

                float top = (run.lineNumber == 0) ? 0 : this._lineHeights[run.lineNumber - 1];
                float bottom = this._lineHeights[run.lineNumber];
                float left, right;
                if (run.codeUnits.start >= start && run.codeUnits.end <= end)
                {
                    left  = run.xPos.start;
                    right = run.xPos.end;
                }
                else
                {
                    left  = float.MaxValue;
                    right = float.MinValue;
                    for (int i = 0; i < run.count; i++)
                    {
                        var gp = run.get(i, this._glyphPositions);
                        if (gp.codeUnit >= start && gp.codeUnit + 1 <= end)
                        {
                            left  = Mathf.Min(left, gp.xPos.start);
                            right = Mathf.Max(right, gp.xPos.end);
                        }
                    }

                    if (left == float.MaxValue || right == float.MinValue)
                    {
                        continue;
                    }
                }

                List <TextBox> boxs;
                if (!lineBoxes.TryGetValue(run.lineNumber, out boxs))
                {
                    boxs = new List <TextBox>();
                    lineBoxes.Add(run.lineNumber, boxs);
                }

                boxs.Add(TextBox.fromLTBD(left, top, right, bottom, run.direction));
            }

            for (int lineNumber = 0; lineNumber < this._lineRangeCount; ++lineNumber)
            {
                var line = this._lineRanges[lineNumber];
                if (line.start >= end)
                {
                    break;
                }

                if (line.endIncludingNewLine <= start)
                {
                    continue;
                }

                if (!lineBoxes.ContainsKey(lineNumber))
                {
                    if (line.end != line.endIncludingNewLine && line.end >= start && line.endIncludingNewLine <= end)
                    {
                        var x      = this._lineWidths[lineNumber];
                        var top    = (lineNumber > 0) ? this._lineHeights[lineNumber - 1] : 0;
                        var bottom = this._lineHeights[lineNumber];
                        lineBoxes.Add(lineNumber, new List <TextBox> {
                            TextBox.fromLTBD(
                                x, top, x, bottom, TextDirection.ltr)
                        });
                    }
                }
            }

            var result = new List <TextBox>();

            foreach (var keyValuePair in lineBoxes)
            {
                result.AddRange(keyValuePair.Value);
            }

            return(result);
        }
Пример #14
0
        protected override void performRebuild()
        {
            _childWidgets.Clear();
            base.performRebuild();
            _currentBeforeChild = null;
            D.assert(_currentlyUpdatingChildIndex == null);

            try {
                SplayTree <int, Element> newChildren = new SplayTree <int, Element>();

                Dictionary <int, float> indexToLayoutOffset = new Dictionary <int, float>();

                void processElement(int index)
                {
                    _currentlyUpdatingChildIndex = index;
                    if (_childElements.getOrDefault(index) != null &&
                        _childElements.getOrDefault(index) != newChildren.getOrDefault(index))
                    {
                        _childElements[index] = updateChild(_childElements[index], null, index);
                    }
                    Element newChild = updateChild(newChildren.getOrDefault(index), _build(index), index);

                    if (newChild != null)
                    {
                        _childElements[index] = newChild;
                        SliverMultiBoxAdaptorParentData parentData = newChild.renderObject.parentData as SliverMultiBoxAdaptorParentData;
                        if (index == 0)
                        {
                            parentData.layoutOffset = 0.0f;
                        }
                        else if (indexToLayoutOffset.ContainsKey(index))
                        {
                            parentData.layoutOffset = indexToLayoutOffset[index];
                        }
                        if (!parentData.keptAlive)
                        {
                            _currentBeforeChild = newChild.renderObject as RenderBox;
                        }
                    }
                    else
                    {
                        _childElements.Remove(index);
                    }
                }

                foreach (int index in _childElements.Keys.ToList())
                {
                    Key key      = _childElements[index].widget.key;
                    int?newIndex = key == null ? null : widget.del.findIndexByKey(key);
                    SliverMultiBoxAdaptorParentData childParentData =
                        _childElements[index].renderObject?.parentData as SliverMultiBoxAdaptorParentData;

                    if (childParentData != null && childParentData.layoutOffset != null)
                    {
                        indexToLayoutOffset[index] = (float)childParentData.layoutOffset;
                    }

                    if (newIndex != null && newIndex != index)
                    {
                        if (childParentData != null)
                        {
                            childParentData.layoutOffset = null;
                        }

                        newChildren[(int)newIndex] = _childElements[index];

                        newChildren.putIfAbsent(index, () => null);

                        _childElements.Remove(index);
                    }
                    else
                    {
                        newChildren.putIfAbsent(index, () => _childElements[index]);
                    }
                }

                renderObject.debugChildIntegrityEnabled = false;  // Moving children will temporary violate the integrity.
                foreach (var key in newChildren.Keys)
                {
                    processElement(key);
                }
                if (_didUnderflow)
                {
                    int lastKey       = _childElements.Count == 0 ? -1 : _childElements.Keys.Last();
                    int rightBoundary = lastKey + 1;
                    if (newChildren.ContainsKey(rightBoundary))
                    {
                        newChildren[rightBoundary] = _childElements.getOrDefault(rightBoundary);
                    }
                    processElement(rightBoundary);
                }
            } finally {
                _currentlyUpdatingChildIndex            = null;
                renderObject.debugChildIntegrityEnabled = true;
            }
        }
Пример #15
0
        public void KeyValuePair()
        {
            var splayTree = new SplayTree<int, string>
                                {
                                    {4, "4"},
                                    {6, "6"},
                                    {2, "2"},
                                    {5, "5"},
                                    {19, "19"},
                                    {1, "1"}
                                };

            Assert.AreEqual(splayTree.Count, 6);

            Assert.IsTrue(splayTree.ContainsKey(4));
            Assert.IsTrue(splayTree.ContainsKey(6));
            Assert.IsTrue(splayTree.ContainsKey(2));
            Assert.IsTrue(splayTree.ContainsKey(5));
            Assert.IsTrue(splayTree.ContainsKey(19));
            Assert.IsTrue(splayTree.ContainsKey(1));

            Assert.IsFalse(splayTree.Remove(new KeyValuePair<int, string>(20, "20")));

            Assert.IsTrue(splayTree.Remove(new KeyValuePair<int, string>(4, "4")));
            Assert.AreEqual(splayTree.Count, 5);

            Assert.IsFalse(splayTree.ContainsKey(4));
            Assert.IsTrue(splayTree.ContainsKey(6));
            Assert.IsTrue(splayTree.ContainsKey(2));
            Assert.IsTrue(splayTree.ContainsKey(5));
            Assert.IsTrue(splayTree.ContainsKey(19));
            Assert.IsTrue(splayTree.ContainsKey(1));
        }
Пример #16
0
        public void Simple1()
        {
            var splayTree = new SplayTree<int, string>
                                {
                                    {4, "4"},
                                    {6, "6"},
                                    {2, "2"},
                                    {5, "5"},
                                    {19, "19"},
                                    {1, "1"}
                                };

            Assert.AreEqual(splayTree.Count, 6);

            Assert.IsTrue(splayTree.ContainsKey(4));
            Assert.IsTrue(splayTree.ContainsKey(6));
            Assert.IsTrue(splayTree.ContainsKey(2));
            Assert.IsTrue(splayTree.ContainsKey(5));
            Assert.IsTrue(splayTree.ContainsKey(19));
            Assert.IsTrue(splayTree.ContainsKey(1));

            Assert.IsFalse(splayTree.Remove(20));

            Assert.IsTrue(splayTree.Remove(4));
            Assert.AreEqual(splayTree.Count, 5);

            Assert.IsFalse(splayTree.ContainsKey(4));
            Assert.IsTrue(splayTree.ContainsKey(6));
            Assert.IsTrue(splayTree.ContainsKey(2));
            Assert.IsTrue(splayTree.ContainsKey(5));
            Assert.IsTrue(splayTree.ContainsKey(19));
            Assert.IsTrue(splayTree.ContainsKey(1));

            Assert.IsTrue(splayTree.Remove(2));
            Assert.AreEqual(splayTree.Count, 4);

            Assert.IsFalse(splayTree.ContainsKey(4));
            Assert.IsTrue(splayTree.ContainsKey(6));
            Assert.IsFalse(splayTree.ContainsKey(2));
            Assert.IsTrue(splayTree.ContainsKey(5));
            Assert.IsTrue(splayTree.ContainsKey(19));
            Assert.IsTrue(splayTree.ContainsKey(1));

            Assert.IsTrue(splayTree.Remove(19));
            Assert.AreEqual(splayTree.Count, 3);

            Assert.IsFalse(splayTree.ContainsKey(4));
            Assert.IsTrue(splayTree.ContainsKey(6));
            Assert.IsFalse(splayTree.ContainsKey(2));
            Assert.IsTrue(splayTree.ContainsKey(5));
            Assert.IsFalse(splayTree.ContainsKey(19));
            Assert.IsTrue(splayTree.ContainsKey(1));

            Assert.IsFalse(splayTree.Remove(20));

            Assert.IsTrue(splayTree.Remove(1));
            Assert.AreEqual(splayTree.Count, 2);

            Assert.IsFalse(splayTree.ContainsKey(4));
            Assert.IsTrue(splayTree.ContainsKey(6));
            Assert.IsFalse(splayTree.ContainsKey(2));
            Assert.IsTrue(splayTree.ContainsKey(5));
            Assert.IsFalse(splayTree.ContainsKey(19));
            Assert.IsFalse(splayTree.ContainsKey(1));

            Assert.IsTrue(splayTree.Remove(6));
            Assert.AreEqual(splayTree.Count, 1);

            Assert.IsFalse(splayTree.ContainsKey(4));
            Assert.IsFalse(splayTree.ContainsKey(6));
            Assert.IsFalse(splayTree.ContainsKey(2));
            Assert.IsTrue(splayTree.ContainsKey(5));
            Assert.IsFalse(splayTree.ContainsKey(19));
            Assert.IsFalse(splayTree.ContainsKey(1));

            Assert.IsTrue(splayTree.Remove(5));
            Assert.AreEqual(splayTree.Count, 0);

            Assert.IsFalse(splayTree.ContainsKey(4));
            Assert.IsFalse(splayTree.ContainsKey(6));
            Assert.IsFalse(splayTree.ContainsKey(2));
            Assert.IsFalse(splayTree.ContainsKey(5));
            Assert.IsFalse(splayTree.ContainsKey(19));
            Assert.IsFalse(splayTree.ContainsKey(1));

            Assert.IsFalse(splayTree.Remove(1));
        }
Пример #17
0
        public void Simple1()
        {
            var splayTree = new SplayTree <int, string>
            {
                { 4, "4" },
                { 6, "6" },
                { 2, "2" },
                { 5, "5" },
                { 19, "19" },
                { 1, "1" }
            };

            Assert.AreEqual(splayTree.Count, 6);

            Assert.IsTrue(splayTree.ContainsKey(4));
            Assert.IsTrue(splayTree.ContainsKey(6));
            Assert.IsTrue(splayTree.ContainsKey(2));
            Assert.IsTrue(splayTree.ContainsKey(5));
            Assert.IsTrue(splayTree.ContainsKey(19));
            Assert.IsTrue(splayTree.ContainsKey(1));

            Assert.IsFalse(splayTree.Remove(20));

            Assert.IsTrue(splayTree.Remove(4));
            Assert.AreEqual(splayTree.Count, 5);

            Assert.IsFalse(splayTree.ContainsKey(4));
            Assert.IsTrue(splayTree.ContainsKey(6));
            Assert.IsTrue(splayTree.ContainsKey(2));
            Assert.IsTrue(splayTree.ContainsKey(5));
            Assert.IsTrue(splayTree.ContainsKey(19));
            Assert.IsTrue(splayTree.ContainsKey(1));

            Assert.IsTrue(splayTree.Remove(2));
            Assert.AreEqual(splayTree.Count, 4);

            Assert.IsFalse(splayTree.ContainsKey(4));
            Assert.IsTrue(splayTree.ContainsKey(6));
            Assert.IsFalse(splayTree.ContainsKey(2));
            Assert.IsTrue(splayTree.ContainsKey(5));
            Assert.IsTrue(splayTree.ContainsKey(19));
            Assert.IsTrue(splayTree.ContainsKey(1));

            Assert.IsTrue(splayTree.Remove(19));
            Assert.AreEqual(splayTree.Count, 3);

            Assert.IsFalse(splayTree.ContainsKey(4));
            Assert.IsTrue(splayTree.ContainsKey(6));
            Assert.IsFalse(splayTree.ContainsKey(2));
            Assert.IsTrue(splayTree.ContainsKey(5));
            Assert.IsFalse(splayTree.ContainsKey(19));
            Assert.IsTrue(splayTree.ContainsKey(1));

            Assert.IsFalse(splayTree.Remove(20));


            Assert.IsTrue(splayTree.Remove(1));
            Assert.AreEqual(splayTree.Count, 2);

            Assert.IsFalse(splayTree.ContainsKey(4));
            Assert.IsTrue(splayTree.ContainsKey(6));
            Assert.IsFalse(splayTree.ContainsKey(2));
            Assert.IsTrue(splayTree.ContainsKey(5));
            Assert.IsFalse(splayTree.ContainsKey(19));
            Assert.IsFalse(splayTree.ContainsKey(1));

            Assert.IsTrue(splayTree.Remove(6));
            Assert.AreEqual(splayTree.Count, 1);

            Assert.IsFalse(splayTree.ContainsKey(4));
            Assert.IsFalse(splayTree.ContainsKey(6));
            Assert.IsFalse(splayTree.ContainsKey(2));
            Assert.IsTrue(splayTree.ContainsKey(5));
            Assert.IsFalse(splayTree.ContainsKey(19));
            Assert.IsFalse(splayTree.ContainsKey(1));

            Assert.IsTrue(splayTree.Remove(5));
            Assert.AreEqual(splayTree.Count, 0);

            Assert.IsFalse(splayTree.ContainsKey(4));
            Assert.IsFalse(splayTree.ContainsKey(6));
            Assert.IsFalse(splayTree.ContainsKey(2));
            Assert.IsFalse(splayTree.ContainsKey(5));
            Assert.IsFalse(splayTree.ContainsKey(19));
            Assert.IsFalse(splayTree.ContainsKey(1));

            Assert.IsFalse(splayTree.Remove(1));
        }
Пример #18
0
        public void KeyValuePair()
        {
            var splayTree = new SplayTree <int, string>
            {
                { 4, "4" },
                { 6, "6" },
                { 2, "2" },
                { 5, "5" },
                { 19, "19" },
                { 1, "1" }
            };

            Assert.AreEqual(splayTree.Count, 6);

            Assert.IsTrue(splayTree.ContainsKey(4));
            Assert.IsTrue(splayTree.ContainsKey(6));
            Assert.IsTrue(splayTree.ContainsKey(2));
            Assert.IsTrue(splayTree.ContainsKey(5));
            Assert.IsTrue(splayTree.ContainsKey(19));
            Assert.IsTrue(splayTree.ContainsKey(1));

            Assert.IsFalse(splayTree.Remove(new KeyValuePair <int, string>(20, "20")));

            Assert.IsTrue(splayTree.Remove(new KeyValuePair <int, string>(4, "4")));
            Assert.AreEqual(splayTree.Count, 5);

            Assert.IsFalse(splayTree.ContainsKey(4));
            Assert.IsTrue(splayTree.ContainsKey(6));
            Assert.IsTrue(splayTree.ContainsKey(2));
            Assert.IsTrue(splayTree.ContainsKey(5));
            Assert.IsTrue(splayTree.ContainsKey(19));
            Assert.IsTrue(splayTree.ContainsKey(1));
        }
Пример #19
0
        public void Simple()
        {
            var splayTree = new SplayTree<int, string>();

            Assert.IsFalse(splayTree.ContainsKey(5));

            splayTree.Add(4, "4");
            Assert.AreEqual(splayTree[4], "4");
            Assert.IsTrue(splayTree.ContainsKey(4));
            Assert.IsFalse(splayTree.ContainsKey(5));

            splayTree.Add(6, "6");
            Assert.AreEqual(splayTree[6], "6");
            Assert.IsTrue(splayTree.ContainsKey(4));
            Assert.IsFalse(splayTree.ContainsKey(5));
            Assert.IsTrue(splayTree.ContainsKey(6));

            splayTree.Add(2, "2");
            Assert.AreEqual(splayTree[2], "2");
            Assert.IsTrue(splayTree.ContainsKey(2));
            Assert.IsTrue(splayTree.ContainsKey(4));
            Assert.IsFalse(splayTree.ContainsKey(5));
            Assert.IsTrue(splayTree.ContainsKey(6));

            splayTree.Add(5, "5");
            Assert.AreEqual(splayTree[5], "5");
            Assert.IsTrue(splayTree.ContainsKey(2));
            Assert.IsTrue(splayTree.ContainsKey(4));
            Assert.IsTrue(splayTree.ContainsKey(5));
            Assert.IsTrue(splayTree.ContainsKey(6));

            var rand = new Random();

            splayTree = new SplayTree<int, string>();

            var list = new List<int>();

            for (var i = 0; i < 100; i++)
            {
                int r;

                do
                {
                    r = rand.Next(5000);
                }
                while (list.Contains(r));

                list.Add(r);

                splayTree.Add(r, null);

                Assert.IsTrue(splayTree.ContainsKey(r));
            }
        }