Пример #1
0
        /// <summary>
        /// Iterates throughtout the lowest reference nodes, the ones closer to the values
        /// </summary>
        /// <typeparam name="TItem"></typeparam>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="self"></param>
        /// <param name="coordinates"></param>
        /// <returns></returns>
        public static IEnumerable <ReferenceNode <TItem, TKey> > IntoLowestRefs <TItem, TKey>(
            this UniqueKeyQuery <TItem, TKey> self, Coordinates[] coordinates)
        {
            var iterator =
                new LowRefsEnumerable <TItem, TKey>();

            return(iterator.FromHereOn(self.Root, coordinates));
        }
Пример #2
0
        protected void ValidateOrder(ReferenceNode <MockItem, int> node, Action <ValueNode <MockItem>, int> expectedException = null)
        {
            var root = node.Root();

            var enu =
                new LowRefsEnumerable <MockItem, int>();

            foreach (var @ref in enu.AllFrom(root))
            {
                ValidateOrder(@ref.Values, expectedException);
            }
        }
        private void StraightUpKeys()
        {
            var @enum =
                new LowRefsEnumerable <TItem, TKey>();

            foreach (var refNode in @enum.LastNLowestRefs(Root))
            {
                var highestKey =
                    SelectKey(refNode.Values[refNode.Values.Length - 1].Value);

                ChangeKey2LastKey(refNode, highestKey);
            }
        }
Пример #4
0
        static void Main(string[] args)
        {
            var query =
                new Query <int>
            {
                SelectKey = item => item.Index
            };

            var list =
                new OptmizedCollection <Coordinates>(query);

            var watch = new Stopwatch();

            watch.Start();
            for (int i = 1; i < (int)(Math.Pow(33, 4)); i++)
            {
                list.Add(new Coordinates()
                {
                    Index = i
                });
                //Write(i, query);
            }
            watch.Stop();
            //watch.Reset();
            //watch.Start();
            list.Add(new Coordinates()
            {
                Index = 0
            });
            //list.Add(new Coordinates() { Index = (int)(Math.Pow(33, 2)) });
            watch.Stop();
            watch.Reset();
            watch.Start();
            var n = query.Get(5);

            watch.Stop();

            var enu =
                new LowRefsEnumerable <Coordinates, int>();

            foreach (var @ref in enu.AllFrom(query.Root))
            {
                Write(@ref.Values);
            }

            query.Key = 5;
            list.Remove <int>(query);

            list.Using <Query <int> >().Get(5);
            //list.Using<Query<string>>().Get("name");
        }
        public override IEnumerable <TItem> Enumerate()
        {
            var iterator =
                new LowRefsEnumerable <TItem, TKey>();

            foreach (var item in iterator.AllFrom(Root))
            {
                var len = item.Values.Length;
                for (var i = 0; i < len; i++)
                {
                    yield return(item.Values[i].Value);
                }
            }
        }