aboutsummaryrefslogtreecommitdiffstats
path: root/util/generic/lazy_value.h
blob: 8dd53b763d8c3739f91c26e507bed1478c885014 (plain) (blame)
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
#pragma once

#include "maybe.h"
#include "function.h"

template <class T>
class TLazyValueBase {
public:
    using TInitializer = std::function<T()>;

    TLazyValueBase() = default;

    TLazyValueBase(TInitializer initializer)
        : Initializer(std::move(initializer))
    {
    }

    bool WasLazilyInitialized() const noexcept {
        return ValueHolder.Defined();
    }

    const T& GetRef() const Y_LIFETIME_BOUND {
        if (!WasLazilyInitialized()) {
            InitDefault();
        }
        return *ValueHolder;
    }

    const T& operator*() const Y_LIFETIME_BOUND {
        return GetRef();
    }

    const T* operator->() const Y_LIFETIME_BOUND {
        return &GetRef();
    }

    void InitDefault() const {
        Y_ASSERT(Initializer);
        ValueHolder = Initializer();
    }

private:
    mutable TMaybe<T> ValueHolder;
    TInitializer Initializer;
};

// we need this to get implicit construction TLazyValue from lambda
// and save default copy constructor and operator= for type TLazyValue
template <class T>
class TLazyValue: public TLazyValueBase<T> {
public:
    template <typename... TArgs>
    TLazyValue(TArgs&&... args)
        : TLazyValueBase<T>(std::forward<TArgs>(args)...)
    {
    }
};

template <typename F>
TLazyValue<TFunctionResult<F>> MakeLazy(F&& f) {
    return {std::forward<F>(f)};
}