Verbose test reports on failures.

[stg.git] / projects / stargazer / actions.h

diff --git a/projects/stargazer/actions.h b/projects/stargazer/actions.h
index 53dde92b749aa04c08d2fd56b95c3a1471a9d1c8..360a56e1903c504476c85531ba61417ad068bf20 100644 (file)
--- a/projects/stargazer/actions.h
+++ b/projects/stargazer/actions.h
@@ -1,5 +1,4 @@
-#ifndef __ACTIONS_H__
-#define __ACTIONS_H__
+#pragma once

 
 // Usage:
 //
 
 // Usage:
 //


@@ -13,37 +12,42 @@
 //
 // actionsList.InvokeAll();
 
 //
 // actionsList.InvokeAll();
 

-#include <pthread.h>
-#include <list>
+#include <vector>

 #include <functional>
 #include <functional>

+#include <mutex>

 
 // Generalized actor type - a method of some class with one argument
 template <class ACTIVE_CLASS, typename DATA_TYPE>
 struct ACTOR
 {
 
 // Generalized actor type - a method of some class with one argument
 template <class ACTIVE_CLASS, typename DATA_TYPE>
 struct ACTOR
 {

-typedef void (ACTIVE_CLASS::*TYPE)(DATA_TYPE);
+    using TYPE = void (ACTIVE_CLASS::*)(DATA_TYPE);

 };
 
 // Abstract base action class for polymorphic action invocation
 class BASE_ACTION
 {
 public:
 };
 
 // Abstract base action class for polymorphic action invocation
 class BASE_ACTION
 {
 public:

-    virtual ~BASE_ACTION() {};
+    virtual ~BASE_ACTION() {}

     virtual void Invoke() = 0;
 };
 
 // Concrete generalized action type - an actor with it's data and owner
 template <class ACTIVE_CLASS, typename DATA_TYPE>
     virtual void Invoke() = 0;
 };
 
 // Concrete generalized action type - an actor with it's data and owner
 template <class ACTIVE_CLASS, typename DATA_TYPE>

-class ACTION : public BASE_ACTION,
-               public std::unary_function<ACTIVE_CLASS &, void>
+class ACTION : public BASE_ACTION

 {
 public:
     ACTION(ACTIVE_CLASS & ac,
            typename ACTOR<ACTIVE_CLASS, DATA_TYPE>::TYPE a,
            DATA_TYPE d)
 {
 public:
     ACTION(ACTIVE_CLASS & ac,
            typename ACTOR<ACTIVE_CLASS, DATA_TYPE>::TYPE a,
            DATA_TYPE d)

-        : activeClass(ac), actor(a), data(d) {};
-    void Invoke();
+        : activeClass(ac), actor(a), data(d) {}
+    void Invoke() override
+    {
+        (activeClass.*actor)(data);
+    }

 private:
 private:

+    ACTION(const ACTION<ACTIVE_CLASS, DATA_TYPE> & rvalue);
+    ACTION<ACTIVE_CLASS, DATA_TYPE> & operator=(const ACTION<ACTIVE_CLASS, DATA_TYPE> & rvalue);
+

     ACTIVE_CLASS & activeClass;
     typename ACTOR<ACTIVE_CLASS, DATA_TYPE>::TYPE actor;
     DATA_TYPE data;
     ACTIVE_CLASS & activeClass;
     typename ACTOR<ACTIVE_CLASS, DATA_TYPE>::TYPE actor;
     DATA_TYPE data;


@@ -51,37 +55,42 @@ private:
 
 // A list of an actions
 // All methods are thread-safe
 
 // A list of an actions
 // All methods are thread-safe

-class ACTIONS_LIST : private std::list<BASE_ACTION *>
+class ACTIONS_LIST

 {
 public:
 {
 public:

-    // Just a typedef for parent class
-    typedef std::list<BASE_ACTION *> parent;
-
-    // Initialize mutex
-    ACTIONS_LIST();
-    // Delete actions and destroy mutex
-    ~ACTIONS_LIST();
+    ~ACTIONS_LIST()
+    {
+        std::lock_guard lock(m_mutex);
+        for (auto action : m_list)
+            delete action;
+    }

 
 

-    parent::iterator begin();
-    parent::iterator end();
-    parent::const_iterator begin() const;
-    parent::const_iterator end() const;
+    auto begin() { std::lock_guard lock(m_mutex); return m_list.begin(); }
+    auto end() { std::lock_guard lock(m_mutex); return m_list.end(); }
+    auto begin() const { std::lock_guard lock(m_mutex); return m_list.begin(); }
+    auto end() const { std::lock_guard lock(m_mutex); return m_list.end(); }

 
 

-    bool empty() const;
-    size_t size() const;
-    void swap(ACTIONS_LIST & list);
+    bool empty() const { std::lock_guard lock(m_mutex); return m_list.empty(); }
+    size_t size() const { std::lock_guard lock(m_mutex); return m_list.size(); }
+    void swap(ACTIONS_LIST & rhs) { std::lock_guard lock(m_mutex); m_list.swap(rhs.m_list); }

 
     // Add an action to list
     template <class ACTIVE_CLASS, typename DATA_TYPE>
     void Enqueue(ACTIVE_CLASS & ac,
                  typename ACTOR<ACTIVE_CLASS, DATA_TYPE>::TYPE a,
 
     // Add an action to list
     template <class ACTIVE_CLASS, typename DATA_TYPE>
     void Enqueue(ACTIVE_CLASS & ac,
                  typename ACTOR<ACTIVE_CLASS, DATA_TYPE>::TYPE a,

-                 DATA_TYPE d);
+                 DATA_TYPE d)
+    {
+        std::lock_guard lock(m_mutex);
+        m_list.push_back(new ACTION<ACTIVE_CLASS, DATA_TYPE>(ac, a, d));
+    }

     // Invoke all actions in the list
     // Invoke all actions in the list

-    void InvokeAll();
+    void InvokeAll()
+    {
+        std::lock_guard lock(m_mutex);
+        for (auto action : m_list)
+            action->Invoke();
+    }

 private:
 private:

-    mutable pthread_mutex_t mutex;
+    mutable std::mutex m_mutex;
+    std::vector<BASE_ACTION*> m_list;

 };
 };

-
-#include "actions.inl.h"
-
-#endif