removed a number of restrictions

* added helper method link * removed methods: shutdown, startup from supervisor * removed in method launch ( executable_actor, cooperative_actor, blocking_actor )
duckstax · Sep 28, 2019 · 0fdf48e · 0fdf48e
1 parent ff7c733
commit 0fdf48e
Show file tree

Hide file tree

Showing 19 changed files with 205 additions and 212 deletions.
diff --git a/core/actor-zeta/actor/basic_actor.hpp b/core/actor-zeta/actor/basic_actor.hpp
@@ -17,11 +17,10 @@ namespace actor_zeta { namespace actor {
         public:
             using actor_type = Actor;
 
-            template<std::size_t N>
             basic_actor(
                     supervisor *ptr,
-                    const char(&name)[N]
-            ): actor_type(ptr, new MailBox, detail::string_view(name)) {
+                    detail::string_view name
+            ): actor_type(ptr, new MailBox, name) {
 
             }
 
@@ -31,40 +30,4 @@ namespace actor_zeta { namespace actor {
 
         using basic_async_actor = basic_actor<messaging::blocking_mail_queue>;
 
-        template<
-                typename MailBox,
-                typename Actor = cooperative_actor
-        >
-        inline actor make_actor(supervisor *ptr, const std::string &name) {
-            return new basic_actor<MailBox,Actor>(ptr,name);
-        }
-
-        template<typename Actor,typename... Args>
-        inline void send(Actor&a1,Args... args){
-            a1->enqueue(
-                    messaging::make_message(
-                            std::forward<Args>(args)...
-                    )
-            );
-        }
-
-        template<typename Actor,typename... Args>
-        inline void send(const Actor&a1,Args... args){
-            a1->enqueue(
-                    messaging::make_message(
-                            std::forward<Args>(args)...
-                    )
-            );
-        }
-
-        inline void link_imp(const actor_address& a1,const actor_address& a2 ){
-            send(a1,a2,"sync_contacts",a2);
-            send(a2,a1,"sync_contacts",a1);
-        }
-
-        template <typename Actor1, typename Actor2>
-        inline void link(Actor1&actor1,Actor2&actor2){
-            link_imp(actor1->address(),actor2->address());
-        }
-
 }}
diff --git a/core/actor-zeta/actor/blocking_actor.hpp b/core/actor-zeta/actor/blocking_actor.hpp
@@ -21,7 +21,8 @@ namespace actor_zeta { namespace actor {
 
             blocking_actor(supervisor*, mailbox_type*, detail::string_view);
             executor::executable_result run(executor::execution_device *, size_t) final;
-            void launch(executor::execution_device *,bool) final ;
+            ///TODO:
+            ///void launch(executor::execution_device *,bool) final ;
             ~blocking_actor() override;
 
             messaging::message next_message();

diff --git a/core/actor-zeta/actor/cooperative_actor.hpp b/core/actor-zeta/actor/cooperative_actor.hpp
@@ -21,7 +21,8 @@ namespace actor_zeta { namespace actor {
 
             void enqueue(messaging::message, executor::execution_device *) final;
 
-            void launch(executor::execution_device *, bool /*hide*/) final;
+            ///TODO:
+            //void launch(executor::execution_device *, bool /*hide*/) final;
 
             executor::executable_result run(executor::execution_device *, size_t max_throughput) final;
 

diff --git a/core/actor-zeta/actor/executable_actor.hpp b/core/actor-zeta/actor/executable_actor.hpp
@@ -7,7 +7,8 @@ namespace actor_zeta { namespace actor {
 
         class executable_actor : public base_actor  {
         public:
-            virtual void launch(executor::execution_device*, bool /*hide*/) = 0;
+            ///TODO:
+            ///virtual void launch(executor::execution_device*, bool /*hide*/) = 0;
 
             ~executable_actor() override ;
         protected:

diff --git a/core/actor-zeta/actor/supervisor.hpp b/core/actor-zeta/actor/supervisor.hpp
@@ -9,28 +9,16 @@ namespace actor_zeta { namespace actor {
 
     class supervisor : public base_actor {
     public:
-        explicit supervisor(detail::string_view);
+        supervisor(detail::string_view);
 
         ~supervisor() override;
 
-        virtual auto shutdown() noexcept -> void = 0;
-
-        virtual auto startup() noexcept -> void = 0;
-
         virtual auto executor() noexcept -> executor::abstract_executor& = 0;
 
         virtual auto broadcast(message) -> bool = 0;
 
         virtual auto join(base_actor *t) -> actor_zeta::actor::actor_address = 0;
 
-        template<typename Actor, typename Supervisor, typename... Args>
-        inline auto join(Supervisor* supervisor, Args... args) -> actor_zeta::actor::actor_address {
-            return join(new Actor(supervisor, std::forward<Args>(args)...));
-        }
-
-        virtual auto join(supervisor &) -> void = 0;
     };
 
-    auto link(supervisor &g1, supervisor &g2) -> void;
-
 }}
diff --git a/core/actor-zeta/core.hpp b/core/actor-zeta/core.hpp
@@ -24,6 +24,66 @@ namespace actor_zeta {
     using messaging::message;
     using messaging::make_message;
 
-    using actor::send;
+    template<
+            typename MailBox,
+            typename Actor = actor::cooperative_actor
+    >
+    inline auto  make_actor(supervisor *ptr, const std::string &name) -> actor::actor {
+        return new actor::basic_actor<MailBox,Actor>(ptr,name);
+    }
+
+    template<
+            typename Actor,
+            typename Supervisor,
+            typename... Args
+    >
+    inline auto make_actor(Supervisor* supervisor, Args... args) -> actor_zeta::actor::actor_address {
+        return supervisor->join(new Actor(supervisor, std::forward<Args>(args)...));
+    }
+
+    template<typename Actor,typename... Args>
+    inline void send(Actor&a1,Args... args){
+        a1->enqueue(
+                messaging::make_message(
+                        std::forward<Args>(args)...
+                )
+        );
+    }
+
+    template<typename Actor,typename... Args>
+    inline void send(const Actor&a1,Args... args){
+        a1->enqueue(
+                messaging::make_message(
+                        std::forward<Args>(args)...
+                )
+        );
+    }
+
+    inline auto link_imp(actor_zeta::actor_address&a1,actor_zeta::actor_address&a2) -> void {
+        send(a1,a2,"sync_contacts",a2);
+        send(a2,a1,"sync_contacts",a1);
+    }
+
+    inline auto link(basic_async_actor &actor1,basic_async_actor &actor2) -> void {
+        auto a1 = actor1.address();
+        auto a2 = actor2.address();
+        link_imp(a1,a2);
+    }
+
+    inline auto link(supervisor *actor1,supervisor *actor2) -> void {
+        auto a1 = actor1->address();
+        auto a2 = actor2->address();
+        link_imp(a1,a2);
+    }
+
+    inline auto link(supervisor *actor1,actor_address&actor2) -> void {
+        auto a1 = actor1->address();
+        auto a2 = actor2->address();
+        link_imp(a1,a2);
+    }
+
+    inline auto link(actor_address &actor1,actor_address&actor2) -> void {
+        link_imp(actor1,actor2);
+    }
 
 }
diff --git a/core/actor-zeta/executor/worker.hpp b/core/actor-zeta/executor/worker.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cassert>
 #include <cstddef>
 #include <thread>
 

diff --git a/core/source/actor/blocking_actor.cpp b/core/source/actor/blocking_actor.cpp
@@ -22,7 +22,7 @@ namespace actor_zeta { namespace actor {
             return executor::executable_result::done;
 
         }
-
+/*
         void blocking_actor::launch(executor::execution_device *e, bool hide) {
             attach(e);
             if (hide) {//TODO:???
@@ -32,7 +32,7 @@ namespace actor_zeta { namespace actor {
                 this->run(e,std::numeric_limits<std::size_t>::max());
             }
         }
-
+*/
         blocking_actor::blocking_actor(supervisor *env,mailbox_type* mail, detail::string_view type)
             : executable_actor(env, type)
             , mailbox_(mail)

diff --git a/core/source/actor/cooperative_actor.cpp b/core/source/actor/cooperative_actor.cpp
@@ -75,8 +75,7 @@ namespace actor_zeta { namespace actor {
             } else if(env() != nullptr) {
                 env()->executor().execute(this);
             } else {
-                ///TODO: assert -> ?
-                assert(false);
+                while (run(nullptr, 1) != executor::executable_result::awaiting) {}
             }
 
         }
@@ -100,6 +99,7 @@ namespace actor_zeta { namespace actor {
         {
         }
 
+        /*
         void cooperative_actor::launch(executor::execution_device *e, bool hide) {
             attach(e);
 
@@ -114,6 +114,7 @@ namespace actor_zeta { namespace actor {
                 }
             }
         }
+        */
 
         bool cooperative_actor::has_next_message() {
             messaging::message msg_ptr = mailbox().get();

diff --git a/core/source/actor/supervisor.cpp b/core/source/actor/supervisor.cpp
@@ -2,11 +2,6 @@
 
 namespace actor_zeta { namespace actor {
 
-        auto link(supervisor &g1, supervisor &g2) -> void {
-            g1.join(g2);
-            g2.join(g1);
-        }
-
         supervisor::supervisor(detail::string_view name):base_actor(name) {
             type_.type = abstract::supervisor;
         }

diff --git a/environment/CMakeLists.txt b/environment/CMakeLists.txt
@@ -17,17 +17,15 @@ set(HEADER_FILES
         actor-zeta/detail/storage_space.hpp
 
         actor-zeta/environment.hpp
-        actor-zeta/supervisor_heavy.hpp
-
+        #actor-zeta/supervisor_heavy.hpp
 )
 
 set(SOURCE_FILES
 
         source/abstract_environment.cpp
-        source/environment.cpp
-        source/supervisor_heavy.cpp
+        #source/supervisor_heavy.cpp
         source/storage_space.cpp
-        )
+)
 
 add_library(
         ${PROJECT_NAME} OBJECT

diff --git a/environment/actor-zeta/environment.hpp b/environment/actor-zeta/environment.hpp
@@ -15,16 +15,16 @@ namespace actor_zeta { namespace environment {
 
         class abstract_environment {
         public:
-            virtual ~abstract_environment()                       = default;
+            virtual ~abstract_environment()                   = default;
 
-            virtual std::size_t                   start()         = 0;
+            virtual std::size_t                   start()     = 0;
 
             virtual executor::abstract_executor & executor()  = 0;
 
             actor::supervisor& manager_supervisor(detail::string_view name);
 
             template<typename Supervisor,typename... Args>
-            inline auto supervisor(Args... args) -> Supervisor* {
+            inline auto supervisor(Args&&... args) -> Supervisor* {
                 auto*supervisor = new Supervisor(std::forward<Args>(args)...);
                 create_supervisor(supervisor);
                 return supervisor;
@@ -44,48 +44,9 @@ namespace actor_zeta { namespace environment {
 /// @brief An actors workplace platform 
 ///
 
-        class environment final {
-        public:
-            environment() = delete;
-
-            environment(const environment &) = delete;
-
-            environment &operator=(const environment &)= delete;
-
-            environment(environment &&) = default;
-
-            environment &operator=(environment &&)= default;
-
-            ~environment();
-
-            environment(abstract_environment *ptr);
-
-            template<class T>
-            environment &operator=(T *ptr) {
-                environment tmp{ptr};
-                swap(tmp);
-                return *this;
-            }
-
-            auto operator->() noexcept -> abstract_environment *;
-
-            auto get() noexcept  -> abstract_environment*;
-
-            explicit operator bool() const noexcept;
-
-            bool operator!() const noexcept;
-
-        private:
-
-            void swap(environment &) noexcept;
-
-            std::unique_ptr<abstract_environment> environment_;
-        };
-
-        template<typename Env, typename... Args>
-        inline auto make_environment(Args... args) -> environment {
-            return new Env(std::forward<Args>(args)...);
+        template<class Env, typename... Args>
+        inline auto make_environment(Args... args) -> std::unique_ptr<abstract_environment> {
+            return std::unique_ptr<abstract_environment>(new Env(std::forward<Args>(args)...));
         }
 
-    } /// environment
-} /// actor_zeta
+}} /// environment /// actor_zeta
diff --git a/environment/actor-zeta/supervisor_heavy.hpp b/environment/actor-zeta/supervisor_heavy.hpp
@@ -13,9 +13,10 @@ namespace actor_zeta { namespace environment {
 ///
 /// @brief
 ///
+/*
         class supervisor_heavy : public actor::supervisor {
         public:
-            explicit supervisor_heavy(abstract_environment*,char const*);
+            supervisor_heavy(abstract_environment*,detail::string_view);
 
             ~supervisor_heavy() override = default;
 
@@ -33,10 +34,6 @@ namespace actor_zeta { namespace environment {
 
             auto broadcast(messaging::message) -> bool override;
 
-            auto shutdown() noexcept -> void override ;
-
-            auto startup() noexcept -> void override ;
-
             auto executor() noexcept -> executor::abstract_executor& final;
 
         protected:
@@ -47,5 +44,5 @@ namespace actor_zeta { namespace environment {
             abstract_environment* env_;
 
         };
-
+*/
 }}