intermediate changes

ref:cde9a383711a11544ce7e107a78147fb96cc4029

1 files changed, 66 insertions, 0 deletions

diff --git a/util/generic/lazy_value.h b/util/generic/lazy_value.h
new file mode 100644
index 0000000000..3c720f76b5
--- /dev/null
+++ b/util/generic/lazy_value.h
@@ -0,0 +1,66 @@
+#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))
+    {
+    }
+
+    explicit operator bool() const noexcept {
+        return Defined();
+    }
+
+    bool Defined() const noexcept {
+        return ValueHolder.Defined();
+    }
+
+    const T& GetRef() const {
+        if (!Defined()) {
+            InitDefault();
+        }
+        return *ValueHolder;
+    }
+
+    const T& operator*() const {
+        return GetRef();
+    }
+
+    const T* operator->() const {
+        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)};
+}