Пример #1
0
        internal TrieSegment Add(string newPrefix)
        {
            TrieSegment segment;

            if (newPrefix.Length <= 0)
            {
                return(this.Root);
            }
            this.EnsureRoot();
            TrieTraverser traverser = new TrieTraverser(this.root, newPrefix);

Label_0024:
            segment = traverser.Segment;
            if (traverser.MoveNextByFirstChar())
            {
                int num;
                if ((segment != null) && (-1 != (num = traverser.Segment.FindDivergence(newPrefix, traverser.Offset, traverser.Length))))
                {
                    traverser.Segment = segment.SplitChild(traverser.SegmentIndex, num);
                }
                goto Label_0024;
            }
            if (traverser.Length > 0)
            {
                traverser.Segment = segment.AddChild(new TrieSegment(newPrefix, traverser.Offset, traverser.Length));
                goto Label_0024;
            }
            this.hasDescendants = true;
            return(segment);
        }
        internal TrieSegment Add(string newPrefix)
        {
            if (newPrefix.Length <= 0)
            {
                return(this.Root);
            }

            this.EnsureRoot();
            TrieTraverser traverser = new TrieTraverser(this.root, newPrefix); // struct
            TrieSegment   parent;
            int           indexDivergence;

            while (true)
            {
                parent = traverser.Segment;
                if (traverser.MoveNextByFirstChar())
                {
                    // There is a child segment that starts with the same character as the remainder of newPrefix
                    // We have a shared segment
                    // How much does newPrefix share with the current segment? Find the point at which they diverge
                    if (null != parent && -1 != (indexDivergence = traverser.Segment.FindDivergence(newPrefix, traverser.Offset, traverser.Length)))
                    {
                        // Segments diverge at character # 'indexDivergence'. newPrefix will share the segment upto
                        // that character. Beyond that character, we will now have 2 child segments:
                        // - one for the portion of the current segment that diverged
                        // - one for the portion of the new segment that diverged

                        // Split the current segment into a shared part and a child containing the remainder of the segment..
                        traverser.Segment = parent.SplitChild(traverser.SegmentIndex, indexDivergence);
                    }
                }
                else
                {
                    if (traverser.Length <= 0)
                    {
                        // The entire new prefix has been added to the tree
                        break;
                    }
                    // No existing segment to share. Add a new one
                    traverser.Segment = parent.AddChild(new TrieSegment(newPrefix, traverser.Offset, traverser.Length));
                }
            }

            this.hasDescendants = true;

            return(parent);
        }