Esempio n. 1
0
        /// <summary>
        /// Finds the first name in the hierarchy of <paramref name="name" /> (bottom-up) that is in this set.
        /// If no match is found, <see cref="HierarchicalNameId.Invalid"/> is returned.
        /// </summary>
        public HierarchicalNameId FindInHierarchyBottomUp(HierarchicalNameId name)
        {
            foreach (HierarchicalNameId current in m_nameTable.EnumerateHierarchyBottomUp(name, flagsFilter: m_memberFlags))
            {
                if (m_added.ContainsKey(current))
                {
                    return(current);
                }
            }

            return(HierarchicalNameId.Invalid);
        }
Esempio n. 2
0
        public void EnumeratingBottomUp()
        {
            var ht = new HierarchicalNameTable(new StringTable(), true, Path.DirectorySeparatorChar);
            ht.AddName(R("a", "b", "sibling", "sibling.txt"));
            HierarchicalNameId name = ht.AddName(R("a", "b", "c", "d.cpp"));

            var enumeration = ht.EnumerateHierarchyBottomUp(name).ToArray();
            var expectation = new[]
            {
                ht.AddName(R("a","b","c","d.cpp")),
                ht.AddName(R("a","b","c")),
                ht.AddName(R("a","b")),
                ht.AddName(R("a"))
            };

            Assert.Equal(enumeration, expectation);
        }
        public void Basic()
        {
            var hnt = new HierarchicalNameTable(new StringTable(), true, Path.DirectorySeparatorChar);
            int c1  = hnt.Count;

            XAssert.IsTrue(c1 > 0);

            HierarchicalNameId id  = hnt.AddName(A("c", "a", "b", "c"));
            string             str = hnt.ExpandName(id);

            XAssert.AreEqual(A("c", "a", "b", "c"), str);

            int c2 = hnt.Count;

            XAssert.IsTrue(c2 > c1);

            hnt.AddName(A("c", "a", "b", "c", "d"));
            hnt.AddName(A("c", "a", "b", "c"));

            int c3 = hnt.Count;

            XAssert.IsTrue(c3 > c2);

            long size = hnt.SizeInBytes;

            XAssert.IsTrue(size > 0);

            if (OperatingSystemHelper.IsUnixOS)
            {
                var id2 = hnt.AddName("/");
                c3 = hnt.Count;
                XAssert.AreEqual("/", hnt.ExpandName(id2));
                XAssert.ArrayEqual(new[] { id2 }, hnt.EnumerateHierarchyBottomUp(id2).ToArray());
            }

            hnt.Freeze();

            size = hnt.SizeInBytes;
            XAssert.IsTrue(size > 0);

            int c4 = hnt.Count;

            XAssert.AreEqual(c3, c4);
        }
        public void EnumeratingBottomUpWithFlagFilter()
        {
            var ht = new HierarchicalNameTable(new StringTable(), true, Path.DirectorySeparatorChar);
            HierarchicalNameId tag1     = ht.AddName(R("c", "tag1"));
            HierarchicalNameId tag2     = ht.AddName(R("c", "tag1", "notag", "tag2"));
            HierarchicalNameId wrongTag = ht.AddName(R("c", "tag1", "notag", "tag2", "wrongtag"));
            HierarchicalNameId leafTag  = ht.AddName(R("c", "tag1", "notag", "tag2", "wrongtag", "leaftag"));

            ht.SetFlags(tag1, HierarchicalNameTable.NameFlags.Marked);
            ht.SetFlags(tag2, HierarchicalNameTable.NameFlags.Marked);
            ht.SetFlags(wrongTag, HierarchicalNameTable.NameFlags.Root);
            ht.SetFlags(leafTag, HierarchicalNameTable.NameFlags.Marked);

            Assert.Equal(
                ht.EnumerateHierarchyBottomUp(leafTag, HierarchicalNameTable.NameFlags.Marked).ToArray(),
                new[]
            {
                leafTag,
                tag2,
                tag1,
            });
        }