Esempio n. 1
0
        public void GetNodes()
        {
            var annList = new AnnotationList <int>();

            annList.Add(1, 2, FeatureStruct.New().Value);
            annList.Add(9, 10, FeatureStruct.New().Value);
            annList.Add(24, 25, FeatureStruct.New().Value);
            annList.Add(49, 50, FeatureStruct.New().Value);
            annList.Add(99, 100, FeatureStruct.New().Value);
            annList.Add(new Annotation <int>(Range <int> .Create(20, 70), FeatureStruct.New().Value), false);

            Assert.IsFalse(annList.GetNodes(0, 1).Any());

            Assert.IsFalse(annList.GetNodes(100, 101).Any());

            Annotation <int>[] anns = annList.GetNodes(8, 52).ToArray();
            Assert.AreEqual(3, anns.Length);
            Assert.AreEqual(annList.First.Next, anns[0]);
            Assert.AreEqual(annList.Last.Prev, anns[2]);

            anns = annList.GetNodes(9, 10).ToArray();
            Assert.AreEqual(1, anns.Length);
            Assert.AreEqual(annList.First.Next, anns[0]);

            anns = annList.GetNodes(0, 200).ToArray();
            Assert.AreEqual(6, anns.Length);
        }
Esempio n. 2
0
        public Range <ShapeNode> CopyTo(Range <ShapeNode> srcRange, Shape dest)
        {
            ShapeNode startNode = null;
            ShapeNode endNode   = null;

            foreach (ShapeNode node in GetNodes(srcRange))
            {
                ShapeNode newNode = node.Clone();
                if (startNode == null)
                {
                    startNode = newNode;
                }
                endNode = newNode;
                dest.Add(newNode);
            }

            Range <ShapeNode> destRange = Range <ShapeNode> .Create(startNode, endNode);

            Dictionary <ShapeNode, ShapeNode> mapping = GetNodes(srcRange).Zip(dest.GetNodes(destRange))
                                                        .ToDictionary(tuple => tuple.Item1, tuple => tuple.Item2);

            foreach (Annotation <ShapeNode> ann in _annotations.GetNodes(srcRange))
            {
                CopyAnnotations(dest._annotations, ann, mapping);
            }

            return(destRange);
        }
Esempio n. 3
0
        public Span <ShapeNode> CopyTo(Span <ShapeNode> srcSpan, Shape dest)
        {
            ShapeNode startNode = null;
            ShapeNode endNode   = null;

            foreach (ShapeNode node in GetNodes(srcSpan))
            {
                ShapeNode newNode = node.DeepClone();
                if (startNode == null)
                {
                    startNode = newNode;
                }
                endNode = newNode;
                dest.Add(newNode);
            }

            Span <ShapeNode> destSpan = dest.SpanFactory.Create(startNode, endNode);
            Dictionary <ShapeNode, ShapeNode> mapping = GetNodes(srcSpan).Zip(dest.GetNodes(destSpan)).ToDictionary(tuple => tuple.Item1, tuple => tuple.Item2);

            foreach (Annotation <ShapeNode> ann in _annotations.GetNodes(srcSpan))
            {
                CopyAnnotations(dest._annotations, ann, mapping);
            }

            return(destSpan);
        }
Esempio n. 4
0
        private void UpdateAnnotations(AnnotationList <ShapeNode> annList, ShapeNode node)
        {
            if (annList.Count == 0)
            {
                return;
            }

            Annotation <ShapeNode> startAnn;

            annList.Find(node, Direction.LeftToRight, out startAnn);
            if (startAnn == annList.Begin)
            {
                startAnn = annList.First;
            }

            Annotation <ShapeNode> endAnn;

            annList.Find(node, Direction.RightToLeft, out endAnn);
            if (endAnn == annList.End)
            {
                endAnn = annList.Last;
            }

            if (startAnn.CompareTo(endAnn) > 0)
            {
                return;
            }

            foreach (Annotation <ShapeNode> ann in annList.GetNodes(startAnn, endAnn).Where(ann => ann.Span.Contains(node)).ToArray())
            {
                if (!ann.IsLeaf)
                {
                    UpdateAnnotations(ann.Children, node);
                }

                if (ann.Span.Start == node && ann.Span.End == node)
                {
                    annList.Remove(ann);
                }
                else if (ann.Span.Start == node || ann.Span.End == node)
                {
                    Span <ShapeNode> span = ann.Span.Start == node?_spanFactory.Create(node.Next, ann.Span.End) : _spanFactory.Create(ann.Span.Start, node.Prev);

                    var newAnn = new Annotation <ShapeNode>(span, ann.FeatureStruct.DeepClone())
                    {
                        Optional = ann.Optional
                    };
                    if (!ann.IsLeaf)
                    {
                        foreach (Annotation <ShapeNode> child in ann.Children.ToArray())
                        {
                            newAnn.Children.Add(child, false);
                        }
                    }
                    annList.Remove(ann, false);
                    annList.Add(newAnn, false);
                }
            }
        }