feat: application

Author: vinniefalco

include/boost/rts.hpp

@@ -10,6 +10,7 @@
 #ifndef BOOST_RTS_HPP
 #define BOOST_RTS_HPP
 
+#include <boost/rts/application.hpp>
 #include <boost/rts/polystore.hpp>
 
 #endif

include/boost/rts/application.hpp

@@ -0,0 +1,78 @@
+//
+// Copyright (c) 2022 Vinnie Falco (vinnie dot falco at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Official repository: https://github.com/cppalliance/beast2
+//
+
+#ifndef BOOST_RTS_APPLICATION_HPP
+#define BOOST_RTS_APPLICATION_HPP
+
+#include <boost/rts/detail/config.hpp>
+#include <boost/rts/polystore.hpp>
+#include <memory>
+#include <type_traits>
+
+namespace boost {
+namespace rts {
+
+/** A collection of type-erased parts and process state
+
+    An object of this type holds a collection of type-erased parts,
+    where each part undergoes two-phase initialization. First the part is
+    constructed by calling @ref emplace. The @ref start function invokes
+    `start()` on each part. When @ref stop is called, each part has its
+    `stop()` member invoked. And when the application object is destroyed,
+    all the parts are destroyed in reverse order of construction.
+*/
+class BOOST_SYMBOL_VISIBLE
+    application : public rts::polystore
+{
+public:
+    application(application const&) = delete;
+    application& operator=(application const&) = delete;
+
+    /** Destructor
+
+        All stored objects will be destroyed in the reverse order of creation.
+    */
+    BOOST_RTS_DECL
+    ~application();
+
+    /** Constructor
+    */
+    BOOST_RTS_DECL
+    application();
+
+    /** Invoke `start` on each part in creation order
+        Each call is performed synchronously; this function blocks until each
+        part returns. Only one invocation of `start` is permitted.
+    */
+    BOOST_RTS_DECL
+    void start();
+
+    /** Invoke `stop` on each part in reverse creation order
+        This function is idempotent and returns immediately.
+        @par Thread Safety
+        May be called concurrently.
+    */
+    BOOST_RTS_DECL
+    void stop();
+
+    /** Wait until the application is stopped
+    */
+    BOOST_RTS_DECL
+    void join();
+
+private:
+    enum state : char;
+    struct impl;
+    impl* impl_;
+};
+
+} // rts
+} // boost
+
+#endif

src/application.cpp

@@ -0,0 +1,120 @@
+//
+// Copyright (c) 2022 Vinnie Falco (vinnie dot falco at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Official repository: https://github.com/cppalliance/beast2
+//
+
+#include <boost/rts/application.hpp>
+#include <boost/rts/detail/except.hpp>
+#include <mutex>
+#include <vector>
+
+namespace boost {
+namespace rts {
+
+enum application::state : char
+{
+    none,
+    starting,
+    running,
+    stopping,
+    stopped
+};
+
+struct application::impl
+{
+    std::mutex m;
+    state st = state::none;
+};
+
+application::
+~application()
+{
+    {
+        std::lock_guard<std::mutex> lock(impl_->m);
+        if( impl_->st != state::stopped &&
+            impl_->st != state::none)
+        {
+            // stop() hasn't returned yet
+            detail::throw_invalid_argument();
+        }
+    }
+    delete impl_;
+}
+
+application::
+application()
+    : impl_(new impl)
+{
+}
+
+void
+application::
+start()
+{
+    {
+        std::lock_guard<std::mutex> lock(impl_->m);
+        if(impl_->st != state::none)
+        {
+            // can't call twice
+            detail::throw_invalid_argument();
+        }
+        impl_->st = state::starting;
+    }
+    auto v = get_elements();
+    for(std::size_t i = 0; i < v.size(); ++i)
+    {
+        try
+        {
+            v[i].start();
+        }
+        catch(std::exception const&)
+        {
+            {
+                std::lock_guard<std::mutex> lock(impl_->m);
+                impl_->st = state::stopping;
+            }
+            do
+            {
+                v[i].stop();
+            }
+            while(i-- != 0);
+            {
+                std::lock_guard<std::mutex> lock(impl_->m);
+                impl_->st = state::stopped;
+            }
+            throw;
+        }
+    }
+    {
+        std::lock_guard<std::mutex> lock(impl_->m);
+        impl_->st = state::running;
+    }
+}
+
+void
+application::
+stop()
+{
+    {
+        std::lock_guard<std::mutex> lock(impl_->m);
+        if(impl_->st != state::running)
+            detail::throw_invalid_argument();
+        impl_->st = state::stopping;
+    }
+
+    auto v = get_elements();
+    for(std::size_t i = v.size(); i--;)
+        v[i].stop();
+
+    {
+        std::lock_guard<std::mutex> lock(impl_->m);
+        impl_->st = state::stopped;
+    }
+}
+
+} // rts
+} // boost

test/unit/application.cpp

@@ -0,0 +1,32 @@
+//
+// Copyright (c) 2025 Vinnie Falco (vinnie dot falco at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Official repository: https://github.com/cppalliance/beast2
+//
+
+// Test that header file is self-contained.
+#include <boost/rts/application.hpp>
+
+#include "test_suite.hpp"
+
+namespace boost {
+namespace rts {
+
+struct application_test
+{
+    void
+    run()
+    {
+        application app;
+    }
+};
+
+TEST_SUITE(
+    application_test,
+    "boost.rts.application");
+
+} // rts
+} // boost

test/unit/rts.cpp

@@ -0,0 +1,11 @@
+//
+// Copyright (c) 2025 Vinnie Falco (vinnie dot falco at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Official repository: https://github.com/cppalliance/rts
+//
+
+// Test that header file is self-contained.
+#include <boost/rts.hpp>