Line data Source code
1 0 : // Distributed under the MIT License.
2 : // See LICENSE.txt for details.
3 :
4 : #pragma once
5 :
6 : #include <cstddef>
7 : #include <pup.h>
8 : #include <utility>
9 :
10 : #include "DataStructures/DataBox/TagTraits.hpp"
11 : #include "Utilities/Gsl.hpp"
12 :
13 : /// \cond
14 : namespace db::detail {
15 :
16 : // Used to label the different types of items in a DataBox (which are described
17 : // in detail below for each specialization of Item).
18 : enum class ItemType { Mutable, Compute, Reference, Invalid };
19 :
20 : // A unique item in a DataBox labeled by Tag
21 : template <typename Tag, ItemType = db::is_mutable_item_tag_v<Tag>
22 : ? ItemType::Mutable
23 : : (db::is_compute_tag_v<Tag>
24 : ? ItemType::Compute
25 : : (db::is_reference_tag_v<Tag>
26 : ? ItemType::Reference
27 : : ItemType::Invalid))>
28 : class Item {
29 : static_assert(
30 : std::is_base_of_v<db::SimpleTag, Tag>,
31 : "The Tag of an Item in the Databox must be derived from db::SimpleTag");
32 : };
33 :
34 : // A mutable item in a DataBox
35 : //
36 : // A mutable item is an item in a DataBox that is initialized when the DataBox
37 : // is constructed using either db::create
38 : //
39 : // Its value may be fetched by calling db::get (which calls get)
40 : //
41 : // Its value may be changed by calling db::mutate (which calls mutate)
42 : template <typename Tag>
43 : class Item<Tag, ItemType::Mutable> {
44 : public:
45 : static constexpr ItemType item_type = ItemType::Mutable;
46 :
47 : using value_type = typename Tag::type;
48 :
49 : constexpr Item() = default;
50 : constexpr Item(Item const&) = default;
51 : constexpr Item(Item&&) = default;
52 : constexpr Item& operator=(Item const&) = default;
53 : constexpr Item& operator=(Item&&) = default;
54 : ~Item() = default;
55 :
56 : explicit Item(value_type value) : value_(std::move(value)) {}
57 :
58 : const value_type& get() const { return value_; }
59 :
60 : value_type& mutate() { return value_; }
61 :
62 : // NOLINTNEXTLINE(google-runtime-references)
63 : void pup(PUP::er& p) { p | value_; }
64 :
65 : private:
66 : value_type value_{};
67 : };
68 :
69 : // A compute item in a DataBox
70 : //
71 : // A compute item is an item in a DataBox whose value depends upon other items
72 : // in the DataBox. It is lazily evaluated (i.e. not computed until it is
73 : // retrieved) and will be reevaluated if any of the items upon which it depends
74 : // is changed.
75 : //
76 : // A compute item is default constructed when the DataBox is constructed.
77 : //
78 : // When a compute item is fetched via db::get, db::get will check whether it has
79 : // already been evaluated (by calling evaluated). If it has been evaluated,
80 : // db::get fetches its value (via get). If it has not been evaluated (either
81 : // initially or after reset has been called), db::get will call evaluate which
82 : // will compute the value using tag::function.
83 : //
84 : // When db::mutate is called on a mutable item, all compute items that depend
85 : // (directly or indirectly) on the mutated item will have their reset function
86 : // called.
87 : //
88 : // A compute item may not be directly mutated (its value only changes after one
89 : // of its dependencies changes and it is fetched again)
90 : template <typename Tag>
91 : class Item<Tag, ItemType::Compute> {
92 : public:
93 : static constexpr ItemType item_type = ItemType::Compute;
94 :
95 : using value_type = typename Tag::type;
96 :
97 : constexpr Item() = default;
98 : constexpr Item(Item const&) = default;
99 : constexpr Item(Item&&) = default;
100 : constexpr Item& operator=(Item const&) = default;
101 : constexpr Item& operator=(Item&&) = default;
102 : ~Item() = default;
103 :
104 : const value_type& get() const { return value_; }
105 :
106 : bool evaluated() const { return evaluated_; }
107 :
108 : void reset() { evaluated_ = false; }
109 :
110 : template <typename... Args>
111 : void evaluate(const Args&... args) const {
112 : Tag::function(make_not_null(&value_), args...);
113 : evaluated_ = true;
114 : }
115 :
116 : private:
117 : // NOLINTNEXTLINE(spectre-mutable)
118 : mutable value_type value_{};
119 : // NOLINTNEXTLINE(spectre-mutable)
120 : mutable bool evaluated_{false};
121 : };
122 :
123 : // A reference item in the DataBox
124 : //
125 : // A reference item is an item in a DataBox used as a const reference to a
126 : // subitem of another item (called the parent item) contained in the DataBox
127 : //
128 : // Its value may be fetched via db::get (by calling Tag::get directly)
129 : //
130 : // A reference item cannot be used to mutate its value.
131 : template <typename Tag>
132 : class Item<Tag, ItemType::Reference> {
133 : public:
134 : static constexpr ItemType item_type = ItemType::Reference;
135 :
136 : constexpr Item() = default;
137 : constexpr Item(Item const&) = default;
138 : constexpr Item(Item&&) = default;
139 : constexpr Item& operator=(Item const&) = default;
140 : constexpr Item& operator=(Item&&) = default;
141 : ~Item() = default;
142 : };
143 : } // namespace db::detail
144 : /// \endcond
|
