LibGit2Sharp/Core/LazyGroup.cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

using System;
using System.Collections.Generic;
using LibGit2Sharp.Core.Compat;

namespace LibGit2Sharp.Core
{
    internal abstract class LazyGroup<T>
    {
        private readonly IList<IEvaluator<T>> evaluators = new List<IEvaluator<T>>();
        private readonly object @lock = new object();
        private bool evaluated;
        protected readonly Repository repo;

        protected LazyGroup(Repository repo)
        {
            this.repo = repo;
        }

        public ILazy<TResult> AddLazy<TResult>(Func<T, TResult> func)
        {
            var prop = new Dependent<T, TResult>(func, this);
            evaluators.Add(prop);
            return prop;
        }

        public void Evaluate()
        {
            if (evaluated)
                return;

            lock (@lock)
            {
                if (evaluated)
                    return;

                EvaluateInternal(input =>
                                 {
                                     foreach (var e in evaluators)
                                         e.Evaluate(input);
                                 });
                evaluated = true;
            }
        }

        protected abstract void EvaluateInternal(Action<T> evaluator);

        protected static ILazy<TResult> Singleton<TResult>(Func<TResult> resultSelector)
        {
            return new LazyWrapper<TResult>(resultSelector);
        }

        private interface IEvaluator<TInput>
        {
            void Evaluate(TInput input);
        }

        private class Dependent<TInput, TOutput> : ILazy<TOutput>, IEvaluator<TInput>
        {
            private readonly Func<TInput, TOutput> valueFactory;
            private readonly LazyGroup<TInput> lazyGroup;

            private TOutput value;
            private bool hasBeenEvaluated;

            public Dependent(Func<TInput, TOutput> valueFactory, LazyGroup<TInput> lazyGroup)
            {
                this.valueFactory = valueFactory;
                this.lazyGroup = lazyGroup;
            }

            public TOutput Value
            {
                get { return Evaluate(); }
            }

            private TOutput Evaluate()
            {
                if (!hasBeenEvaluated)
                {
                    lazyGroup.Evaluate();
                }

                return value;
            }

            void IEvaluator<TInput>.Evaluate(TInput input)
            {
                value = valueFactory(input);
                hasBeenEvaluated = true;
            }
        }

        protected class LazyWrapper<TType> : Lazy<TType>, ILazy<TType>
        {
            public LazyWrapper(Func<TType> evaluator)
                : base(evaluator)
            {
            }
        }
    }
}