algorithm def

src/Core/Algorithm.h

@@ -0,0 +1,234 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+#ifndef U_CORE_ALGORITHM_H
+#define U_CORE_ALGORITHM_H
+
+#include <atomic>
+#include <chrono>
+#include <condition_variable>
+
+#include "Core/Object.h"
+#include "Core/Monitor.h"
+#include "Core/Threads.h"
+#include "Core/Property.h"
+
+namespace uLib {
+
+////////////////////////////////////////////////////////////////////////////////
+//// ALGORITHM /////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * @brief Algorithm is a template class for containing a functional that can be
+ * dynamically loaded as a plug-in. It derives from Object and supports
+ * properties for serialization and interactive parameter widgets.
+ *
+ * @tparam T_enc Encoder type: the input data type, or a chained algorithm
+ *               whose output is compatible with this algorithm's input.
+ * @tparam T_dec Decoder type: the output data type, or a chained algorithm
+ *               whose input is compatible with this algorithm's output.
+ */
+template <typename T_enc, typename T_dec>
+class Algorithm : public Object {
+public:
+    using EncoderType = T_enc;
+    using DecoderType = T_dec;
+
+    Algorithm() : Object(), m_Encoder(nullptr), m_Decoder(nullptr) {}
+    virtual ~Algorithm() = default;
+
+    virtual const char* GetClassName() const override { return "Algorithm"; }
+
+    /**
+     * @brief Process input data and produce output.
+     * Override this in subclasses to implement the algorithm logic.
+     */
+    virtual T_dec Process(const T_enc& input) = 0;
+
+    /**
+     * @brief Operator form of Process for functional chaining.
+     */
+    T_dec operator()(const T_enc& input) { return Process(input); }
+
+    void SetEncoder(Algorithm* enc) { m_Encoder = enc; }
+    Algorithm* GetEncoder() const { return m_Encoder; }
+
+    void SetDecoder(Algorithm* dec) { m_Decoder = dec; }
+    Algorithm* GetDecoder() const { return m_Decoder; }
+
+signals:
+    virtual void Started() { ULIB_SIGNAL_EMIT(Algorithm::Started); }
+    virtual void Finished() { ULIB_SIGNAL_EMIT(Algorithm::Finished); }
+
+protected:
+    Algorithm* m_Encoder;
+    Algorithm* m_Decoder;
+};
+
+
+////////////////////////////////////////////////////////////////////////////////
+//// ALGORITHM TASK ////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * @brief AlgorithmTask manages the execution of an Algorithm within a
+ * scheduled context. Uses uLib::Thread for execution and uLib::Mutex for
+ * synchronization. Supports cyclic mode (with configurable period) and
+ * asynchronous mode (triggered by Object signal-slot or condition variable
+ * from Monitor.h).
+ */
+template <typename T_enc, typename T_dec>
+class AlgorithmTask : public Thread {
+public:
+    using AlgorithmType = Algorithm<T_enc, T_dec>;
+
+    enum Mode { Cyclic, Async };
+
+    AlgorithmTask()
+        : Thread()
+        , m_Algorithm(nullptr)
+        , m_Mode(Cyclic)
+        , m_CycleTime_ms(1000)
+        , m_StopRequested(false)
+        , m_Triggered(false)
+    {}
+
+    virtual ~AlgorithmTask() { Stop(); }
+
+    virtual const char* GetClassName() const override { return "AlgorithmTask"; }
+
+    void SetAlgorithm(AlgorithmType* alg) { m_Algorithm = alg; }
+    AlgorithmType* GetAlgorithm() const { return m_Algorithm; }
+
+    void SetMode(Mode mode) { m_Mode = mode; }
+    Mode GetMode() const { return m_Mode; }
+
+    void SetCycleTime(int milliseconds) { m_CycleTime_ms = milliseconds; }
+    int GetCycleTime() const { return m_CycleTime_ms; }
+
+    /**
+     * @brief Start the task execution in a separate thread (via Thread::Start).
+     * In Cyclic mode, the algorithm is executed periodically.
+     * In Async mode, call Notify() or connect a signal to trigger execution.
+     */
+    void Run(const T_enc& input) {
+        if (IsRunning()) return;
+        m_StopRequested.store(false);
+        m_Triggered.store(false);
+        m_Input = input;
+        Start();
+    }
+
+    /**
+     * @brief Stop the task execution and join the thread.
+     */
+    void Stop() {
+        m_StopRequested.store(true);
+        {
+            ULIB_MUTEX_LOCK(m_WaitMutex, -1) {
+                m_Condition.notify_all();
+            }
+        }
+        if (IsJoinable()) Join();
+    }
+
+    /**
+     * @brief Notify the task to execute one iteration (Async mode).
+     * Can be called from a signal-slot connection or externally.
+     */
+    void Notify() {
+        m_Triggered.store(true);
+        ULIB_MUTEX_LOCK(m_WaitMutex, -1) {
+            m_Condition.notify_one();
+        }
+    }
+
+    /**
+     * @brief Connect an Object signal to trigger async execution.
+     * Usage: task.ConnectTrigger(sender, &SenderClass::SomeSignal);
+     */
+    template <typename Func1>
+    Connection ConnectTrigger(typename FunctionPointer<Func1>::Object* sender, Func1 sigf) {
+        return Object::connect(sender, sigf, [this]() { Notify(); });
+    }
+
+signals:
+    virtual void Stopped() { ULIB_SIGNAL_EMIT(AlgorithmTask::Stopped); }
+
+protected:
+    /**
+     * @brief Thread entry point — dispatches to cyclic or async loop.
+     */
+    void Run() override {
+        if (m_Mode == Cyclic) {
+            RunCyclic();
+        } else {
+            RunAsync();
+        }
+        Stopped();
+    }
+
+private:
+    void RunCyclic() {
+        while (!m_StopRequested.load()) {
+            if (m_Algorithm) {
+                m_Algorithm->Process(m_Input);
+            }
+            std::unique_lock<std::timed_mutex> lock(m_WaitMutex.GetNative());
+            m_Condition.wait_for(lock,
+                std::chrono::milliseconds(m_CycleTime_ms),
+                [this]() { return m_StopRequested.load(); });
+        }
+    }
+
+    void RunAsync() {
+        while (!m_StopRequested.load()) {
+            std::unique_lock<std::timed_mutex> lock(m_WaitMutex.GetNative());
+            m_Condition.wait(lock, [this]() {
+                return m_StopRequested.load() || m_Triggered.load();
+            });
+            if (m_StopRequested.load()) break;
+            m_Triggered.store(false);
+            if (m_Algorithm) {
+                m_Algorithm->Process(m_Input);
+            }
+        }
+    }
+
+    AlgorithmType* m_Algorithm;
+    Mode m_Mode;
+    int m_CycleTime_ms;
+    T_enc m_Input;
+
+    std::atomic<bool> m_StopRequested;
+    std::atomic<bool> m_Triggered;
+    Mutex m_WaitMutex;
+    std::condition_variable_any m_Condition;
+};
+
+} // namespace uLib
+
+#endif // U_CORE_ALGORITHM_H