library/cpp/scheme/util/scheme_holder.h


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

#pragma once

#include <library/cpp/scheme/scheme.h>


// Scheme adapter that holds referenced value
template <typename TScheme>
class TSchemeHolder {
public:
    TSchemeHolder()
        : Value_(NSc::Null())
        , Scheme_(&Value_)
    {
    }

    explicit TSchemeHolder(NSc::TValue&& value)
        : Value_(std::move(value))
        , Scheme_(&Value_)
    {
    }

    explicit TSchemeHolder(const NSc::TValue& value)
        : Value_(value)
        , Scheme_(&Value_)
    {
    }

    TSchemeHolder(TSchemeHolder<TScheme>&& rhs)
        : Value_(std::move(rhs.Value_))
        , Scheme_(&Value_)
    {
    }

    TSchemeHolder(const TSchemeHolder<TScheme>& rhs)
        : Value_(rhs.Value_)
        , Scheme_(&Value_)
    {
    }

    TSchemeHolder<TScheme>& operator=(TSchemeHolder<TScheme>&& rhs) {
        Value_ = std::move(rhs.Value_);
        return *this;
    }
    TSchemeHolder<TScheme>& operator=(const TSchemeHolder<TScheme>& rhs) {
        Value_ = rhs.Value_;
        return *this;
    }

    TScheme& Scheme() {
        return Scheme_;
    }
    const TScheme& Scheme() const {
        return Scheme_;
    }
    TScheme& operator->() {
        return Scheme_;
    }
    const TScheme& operator->() const {
        return Scheme_;
    }

    NSc::TValue& Value() {
        return Value_;
    }
    const NSc::TValue& Value() const {
        return Value_;
    }

    bool IsNull() const {
        return Value_.IsNull();
    }

private:
    NSc::TValue Value_;
    TScheme Scheme_;
};