+ const Event& get_event_with_handle(EventHandle handle) const { return contents_[handle]; }
+ aid_t get_actor_with_handle(EventHandle handle) const { return get_event_with_handle(handle).get_transition()->aid_; }
+
+ /**
+ * @brief Returns a set of IDs of events which are in
+ * "immediate conflict" (according to the definition given
+ * in the ODPOR paper) with one another
+ */
+ std::unordered_set<EventHandle> get_racing_events_of(EventHandle) const;
+
+ /**
+ * @brief Returns a handle to the newest event of the execution,
+ * if such an event exists
+ */
+ std::optional<EventHandle> get_latest_event_handle() const
+ {
+ return contents_.empty() ? std::nullopt : std::optional<EventHandle>{static_cast<EventHandle>(size() - 1)};
+ }
+
+ Execution get_prefix_up_to(EventHandle);
+
+ /**
+ * @brief Whether the event represented by `e1`
+ * "happens-before" the event represented by
+ * `e2` in the context of this execution
+ *
+ * In the terminology of the ODPOR paper,
+ * this function computes
+ *
+ * `e1 --->_E e2`
+ *
+ * where `E` is this execution
+ *
+ * @note: The happens-before relation computed by this
+ * execution is "coarse" in the sense that context-sensitive
+ * independence is not exploited. To include such context-sensitive
+ * dependencies requires a new method of keeping track of
+ * the happens-before procedure, which is nontrivial...
+ */
+ bool happens_before(EventHandle e1, EventHandle e2) const;
+
+ /**
+ * @brief Removes the last event of the execution,
+ * if such an event exists
+ *
+ * @note: When you remove events from an execution, any views
+ * of the execution referring to those removed events
+ * become invalidated
+ */
+ void pop_latest();
+
+ /**
+ * @brief Extends the execution by one more step
+ *
+ * Intutively, pushing a transition `t` onto execution `E`
+ * is equivalent to making the execution become (using the
+ * notation of [1]) `E.proc(t)` where `proc(t)` is the
+ * actor which executed transition `t`.
+ */
+ void push_transition(const Transition*);
+
+ /**
+ * @brief The total number of steps contained in the execution
+ */
+ size_t size() const { return this->contents_.size(); }