event.hpp

Go to the documentation of this file.

/*
 The Real-Time eXperiment Interface (RTXI)
 Copyright (C) 2011 Georgia Institute of Technology, University of Utah,
 Will Cornell Medical College

 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 This program 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 General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

#ifndef EVENT_H
#define EVENT_H

#include <any>
#include <atomic>
#include <condition_variable>
#include <list>
#include <mutex>
#include <queue>
#include <shared_mutex>
#include <string>
#include <thread>
#include <vector>

class eventLogger;

namespace Event
{

enum Type
{
 RT_PERIOD_EVENT = 0,
 RT_PREPERIOD_EVENT,
 RT_POSTPERIOD_EVENT,
 RT_GET_PERIOD_EVENT,
 RT_THREAD_INSERT_EVENT,
 RT_THREAD_REMOVE_EVENT,
 RT_THREAD_PAUSE_EVENT,
 RT_THREAD_UNPAUSE_EVENT,
 RT_DEVICE_INSERT_EVENT,
 RT_DEVICE_REMOVE_EVENT,
 RT_DEVICE_PAUSE_EVENT,
 RT_DEVICE_UNPAUSE_EVENT,
 RT_WIDGET_PARAMETER_CHANGE_EVENT,
 RT_WIDGET_STATE_CHANGE_EVENT,
 RT_SHUTDOWN_EVENT,
 IO_LINK_INSERT_EVENT,
 IO_LINK_REMOVE_EVENT,
 IO_BLOCK_QUERY_EVENT,
 IO_BLOCK_OUTPUTS_QUERY_EVENT,
 IO_CONNECTION_QUERY_EVENT,
 IO_ALL_CONNECTIONS_QUERY_EVENT,
 PLUGIN_INSERT_EVENT,
 PLUGIN_REMOVE_EVENT,
 DAQ_DEVICE_QUERY_EVENT,
 SETTINGS_OBJECT_INSERT_EVENT,
 SETTINGS_OBJECT_REMOVE_EVENT,
 OPEN_FILE_EVENT,
 START_RECORDING_EVENT,
 STOP_RECORDING_EVENT,
 ASYNC_DATA_EVENT,
 THRESHOLD_CROSSING_EVENT,
 START_GENICAM_RECORDING_EVENT,
 PAUSE_GENICAM_RECORDING_EVENT,
 STOP_GENICAM_RECORDING_EVENT,
 GENICAM_SNAPSHOT_EVENT,
 GENERIC_WIDGET_EVENT,
 MANAGER_SHUTDOWN_EVENT,
 NOOP
};

std::string type_to_string(Type event_type);

// TODO: create a standardize way of generating events and their params

class Object
{
public:
 explicit Object(Event::Type et);
 Object(const Object& obj); // copy constructor
 Object& operator=(const Object& obj) = delete; // copy assignment operator
 Object(Object&&) = delete; // move constructor
 Object& operator=(Object&&) = delete; // move assignment operator
 ~Object() = default;

 std::string getName();

 Event::Type getType() const;

 std::any getParam(const std::string& param_name) const;

 void setParam(const std::string& param_name, const std::any& param_value);

 void wait();

 void done();

 bool isdone() const;

 bool paramExists(const std::string& param_name);

private:
 struct param
 {
 std::string name;
 std::any value;
 };

 std::vector<param> params;
 std::mutex processing_done_mut;
 std::condition_variable processing_done_cond;
 Type event_type;
 bool processed = false;
}; // class Object

class Handler
{
public:
 Handler() = default;
 Handler(const Handler&) = default;
 Handler(Handler&&) = delete;
 Handler& operator=(const Handler&) = default;
 Handler& operator=(Handler&&) = delete;
 virtual ~Handler() = default;
 virtual void receiveEvent(Object* event) = 0;
}; // class Handler

/*
 * Managaes the collection of all objects waiting to
 * receive signals from events.
 *
 * All event handlers must register themselves with the manager in order to
 * receive future signals.
 */
class Manager
{
public:
 Manager();
 Manager(const Manager& manager) = delete; // copy constructor
 Manager& operator=(const Manager& manager) =
 delete; // copy assignment operator
 Manager(Manager&&) = delete; // move constructor
 Manager& operator=(Manager&&) = delete; // move assignment operator
 ~Manager();

 void postEvent(Object* event);

 void postEvent(std::vector<Object>& events);

 void registerHandler(Handler* handler);

 void unregisterHandler(Handler* handler);

 bool isRegistered(Handler* handler);

 eventLogger* getLogger() { return this->logger.get(); }

private:
 std::list<Handler*> handlerList;
 std::queue<Event::Object*> event_q;
 std::mutex event_mut; // Mutex for posting events
 std::condition_variable available_event_cond;
 std::atomic<bool> running = true;
 std::thread event_thread;
 std::vector<std::thread> thread_pool;

 // Shared mutex allows for multiple reader single writer scenarios.
 std::shared_mutex handlerlist_mut; // Mutex for modifying event handler queue

 std::unique_ptr<eventLogger> logger;
}; // class Manager

} // namespace Event

#endif // EVENT_H