- XBT_PUBLIC_CLASS ContextFactory {
- private:
- std::string name_;
- public:
-
- explicit ContextFactory(std::string name) : name_(std::move(name)) {}
- virtual ~ContextFactory();
- virtual Context* create_context(std::function<void()> code,
- void_pfn_smxprocess_t cleanup, smx_actor_t process) = 0;
-
- // Optional methods for attaching main() as a context:
-
- /** Creates a context from the current context of execution
- *
- * This will not work on all implementation of `ContextFactory`.
- */
- virtual Context* attach(void_pfn_smxprocess_t cleanup_func, smx_actor_t process);
- virtual Context* create_maestro(std::function<void()> code, smx_actor_t process);
-
- virtual void run_all() = 0;
- virtual Context* self();
- std::string const& name() const
- {
- return name_;
- }
- private:
- void declare_context(void* T, std::size_t size);
- protected:
- template<class T, class... Args>
- T* new_context(Args&&... args)
- {
- T* context = new T(std::forward<Args>(args)...);
- this->declare_context(context, sizeof(T));
- return context;
- }
- };
-
- XBT_PUBLIC_CLASS Context {
- private:
- std::function<void()> code_;
- void_pfn_smxprocess_t cleanup_func_ = nullptr;
- smx_actor_t process_ = nullptr;
- public:
- bool iwannadie;
-
- Context(std::function<void()> code,
- void_pfn_smxprocess_t cleanup_func,
- smx_actor_t process);
- void operator()()
- {
- code_();
- }
- bool has_code() const
- {
- return static_cast<bool>(code_);
- }
- smx_actor_t process()
- {
- return this->process_;
- }
- void set_cleanup(void_pfn_smxprocess_t cleanup)
- {
- cleanup_func_ = cleanup;
- }
-
- // Virtual methods
- virtual ~Context();
- virtual void stop();
- virtual void suspend() = 0;
- };
-
- XBT_PUBLIC_CLASS AttachContext : public Context {
- public:
-
- AttachContext(std::function<void()> code,
- void_pfn_smxprocess_t cleanup_func,
- smx_actor_t process)
- : Context(std::move(code), cleanup_func, process)
- {}
-
- ~AttachContext() override;
-
- /** Called by the context when it is ready to give control
- * to the maestro.
- */
- virtual void attach_start() = 0;
-
- /** Called by the context when it has finished its job */
- virtual void attach_stop() = 0;
- };
+class XBT_PUBLIC ContextFactory {
+public:
+ explicit ContextFactory() {}
+ ContextFactory(const ContextFactory&) = delete;
+ ContextFactory& operator=(const ContextFactory&) = delete;
+ virtual ~ContextFactory();
+ virtual Context* create_context(std::function<void()>&& code, actor::ActorImpl* actor) = 0;
+
+ /** Turn the current thread into a simulation context */
+ virtual Context* attach(actor::ActorImpl* actor);
+ /** Turn the current thread into maestro (the old maestro becomes a regular actor) */
+ virtual Context* create_maestro(std::function<void()>&& code, actor::ActorImpl* actor);
+
+ virtual void run_all() = 0;
+
+protected:
+ template <class T, class... Args> T* new_context(Args&&... args)
+ {
+ T* context = new T(std::forward<Args>(args)...);
+ context->declare_context(sizeof(T));
+ return context;
+ }
+};
+
+class XBT_PUBLIC Context {
+ friend ContextFactory;
+
+ std::function<void()> code_;
+ actor::ActorImpl* actor_ = nullptr;
+ bool iwannadie_ = false;
+ void declare_context(std::size_t size);
+
+public:
+ Context(std::function<void()>&& code, actor::ActorImpl* actor);
+ Context(const Context&) = delete;
+ Context& operator=(const Context&) = delete;
+ virtual ~Context();
+
+ bool wannadie() const { return iwannadie_; }
+ void set_wannadie(bool value = true) { iwannadie_ = value; }
+ void operator()() { code_(); }
+ bool has_code() const { return static_cast<bool>(code_); }
+ actor::ActorImpl* get_actor() { return this->actor_; }
+
+ // Scheduling methods
+ virtual void stop();
+ virtual void suspend() = 0;
+
+ // Retrieving the self() context
+ /** @brief Retrieves the current context of this thread */
+ static Context* self();
+ /** @brief Sets the current context of this thread */
+ static void set_current(Context* self);
+};
+
+class XBT_PUBLIC AttachContext : public Context {
+public:
+ AttachContext(std::function<void()>&& code, actor::ActorImpl* actor) : Context(std::move(code), actor) {}
+ AttachContext(const AttachContext&) = delete;
+ AttachContext& operator=(const AttachContext&) = delete;
+ ~AttachContext() override;
+
+ /** Called by the context when it is ready to give control
+ * to the maestro.
+ */
+ virtual void attach_start() = 0;
+
+ /** Called by the context when it has finished its job */
+ virtual void attach_stop() = 0;
+};
+