MessagingSystem.hpp
No OneTemporary
Actions

Size

7 KB

Referenced Files

None

Subscribers

None

MessagingSystem.hpp
View Options

	//===-- rosa/core/MessagingSystem.hpp ---------------------------- C++ --===//
	//
	// The RoSA Framework
	//
	//===----------------------------------------------------------------------===//
	///
	/// \file rosa/core/MessagingSystem.hpp
	///
	/// \author David Juhasz (david.juhasz@tuwien.ac.at)
	///
	/// \date 2017
	///
	/// \brief Declaration of an interface extending \c rosa::System with messaging.
	///
	//===----------------------------------------------------------------------===//

	#ifndef ROSA_CORE_MESSAGINGSYSTEM_HPP
	#define ROSA_CORE_MESSAGINGSYSTEM_HPP

	#include "rosa/core/AgentHandle.hpp"
	#include "rosa/core/System.hpp"

	#include "rosa/support/atom.hpp"

	namespace rosa {

	/// Extends the \c rosa::System interface with features to create \c rosa::Agent
	/// instancess and register \c rosa::Message objects for them.
	class MessagingSystem : public System {
	friend class AgentHandle; ///< \c rosa::AgentHandle is our friend.

	public:
	/// Returns an object implementing the \c rosa::MessagingSystem interface.
	///
	/// \param Name name of the new instance
	///
	/// \return \c std::unique_ptr for the new instance of
	/// \c rosa::MessagingSystem
	static std::unique_ptr<MessagingSystem>
	createSystem(const std::string &Name) noexcept;

	private:
	/// Kind for categorizing \c rosa::Unit instances as agents.
	static constexpr AtomValue AgentKind = atom("agent");

	protected:
	/// Creates a new instance.
	///
	/// \note Protected constructor restricts instantiation for subclasses.
	MessagingSystem(void) noexcept = default;

	protected:
	/// Creates a \c rosa::Agent instance owned by \p this object and returns a
	/// \c rosa::AgentHandle for it.
	///
	/// \tparam T type of the actual \c rosa::Agent to instantiate
	/// \tparam Funs types of the functions to instantiate \c rosa::Agent with
	///
	/// \note \c rosa::Agent requires at least one function for its constructor,
	/// but derived classes may do not need that. That's the reason of allowing
	/// zero \p Funs for this template function.
	///
	/// \param Name name of the new \c rosa::Unit instance
	/// \param Fs functions to instantiate \c rosa::Unit with
	///
	/// \return handle for the new \c rosa::Agent instance
	///
	/// \pre Statically, \p T is a subclass of \c rosa::Agent:
	/// \code
	/// std::is_base_of<Agent, T>::value
	/// \endcode
	template <typename T, typename... Funs>
	AgentHandle createAgent(const std::string &Name, Funs &&... Fs);

	/// Unregisters and destroys a \c rosa::Agent referred by a
	/// \c rosa::AgentHandle.
	///
	/// The function uses \c rosa::System::destroyUnit.
	///
	/// \param H refers to the \c rosa::Agent to destroy
	///
	/// \pre The referred \c rosa::Agent is registered.
	///
	/// \post The referred \c rosa::Agent is not registered and also destroyed.
	void destroyAgent(const AgentHandle &H) noexcept;

	/// Gives the referenced \c rosa::Agent instance for a \c rosa::AgentHandle.
	///
	/// \note Intended for derived classes to be able to inspect
	/// \c rosa::AgentHandle instances.
	///
	/// \param H \c rosa::AgentHandle to take the referenced \c rosa::Agent from
	///
	/// \return reference to the \c rosa::Agent instance from \p H
	static Agent &unwrapAgent(const AgentHandle &H) noexcept { return H.A; }

	/// Gives the owning \c rosa::MessagingSystem of a \c rosa::Agent instance
	/// for a \c rosa::AgentHandle.
	///
	/// \note Intended for for derived classes to be able to inspect
	/// \c rosa::AgentHandle instances.
	///
	/// \param H \c rosa::AgentHandle to take the owning
	/// \c rosa::MessagingSystem from
	///
	/// \return reference to the \c rosa::MessagingSystem owning the
	/// \c rosa::Agent instance from \p H
	static MessagingSystem &unwrapSystem(const AgentHandle &H) noexcept {
	return H.S;
	}

	public:
	/// Sends a \c rosa::message_t instance to the \c rosa::Agent instance
	/// referred by a \c rosa::AgentHandle.
	///
	/// \note If the given \c rosa::Message object cannot be handled by the
	/// referred \c rosa::Agent instance, the \c rosa::Message object is simply
	/// ignored.
	///
	/// \param H refers to the \c rosa::Agent instance to send to
	/// \param M message to send
	///
	/// \pre The referred \c rosa::Agent instance is owned by \p this object and
	/// also registered: \code
	/// &unwrapSystem(H) == this && isUnitRegistered(unwrapAgent(H))
	/// \endcode
	virtual void send(const AgentHandle &H, message_t &&M) noexcept = 0;

	/// Sends a message -- created from given constant lvalue references --
	/// to the \c rosa::Agent instance referred by a \c rosa::AgentHandle.
	///
	/// \note If the given \c rosa::Message object cannot be handled by the
	/// referred \c rosa::Agent instance, the \c rosa::Message object is simply
	/// ignored.
	///
	/// \note The message must consists of at least one value.
	///
	/// \tparam Type type of the first mandatory value
	/// \tparam Types types of any further values
	///
	/// \param H refers to the \c rosa::Agent instance to send to
	/// \param T the first value to include in the message
	/// \param Ts optional further values to include in the message
	///
	/// \pre The referred \c rosa::Agent instance is owned by \p this object and
	/// also registered: \code
	/// &unwrapSystem(H) == this && isUnitRegistered(unwrapAgent(H))
	/// \endcode
	template <typename Type, typename... Types>
	void send(const AgentHandle &H, const Type &T, const Types &... Ts) noexcept;

	/// Sends a message -- created from given rvalue references --
	/// to the \c rosa::Agent instance referred by a \c rosa::AgentHandle.
	///
	/// \note If the given \c rosa::Message object cannot be handled by the
	/// referred \c rosa::Agent instance, the \c rosa::Message object is simply
	/// ignored.
	///
	/// \note The message must consists of at least one value.
	///
	/// \tparam Type type of the first mandatory value
	/// \tparam Types types of any further values
	///
	/// \param H refers to the \c rosa::Agent instance to send to
	/// \param T the first value to include in the message
	/// \param Ts optional further values to include in the message
	///
	/// \pre The referred \c rosa::Agent instance is owned by \p this object and
	/// also registered: \code
	/// &unwrapSystem(H) == this && isUnitRegistered(unwrapAgent(H))
	/// \endcode
	template <typename Type, typename... Types>
	void send(const AgentHandle &H, Type &&T, Types &&... Ts) noexcept;
	};

	template <typename T, typename... Funs>
	AgentHandle MessagingSystem::createAgent(const std::string &Name,
	Funs &&... Fs) {
	STATIC_ASSERT((std::is_base_of<Agent, T>::value), "not an Agent");
	Agent &A = createUnit<T, MessagingSystem>([&](const id_t Id,
	MessagingSystem &S) noexcept {
	return new T(AgentKind, Id, Name, S, std::move(Fs)...);
	});
	return {A};
	}

	template <typename Type, typename... Types>
	void MessagingSystem::send(const AgentHandle &H, const Type &T,
	const Types &... Ts) noexcept {
	send(H, Message::create<Type, Types...>(T, Ts...));
	}

	template <typename Type, typename... Types>
	void MessagingSystem::send(const AgentHandle &H, Type &&T,
	Types &&... Ts) noexcept {
	send(H, Message::create<Type, Types...>(std::move(T), std::move(Ts)...));
	}

	} // End namespace rosa

	#endif // ROSA_CORE_MESSAGINGSYSTEM_HPP

File Metadata

Mime Type: text/x-c++
Expires: Sun, Mar 1, 9:35 PM (1 d, 17 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 277990
Default Alt Text: MessagingSystem.hpp (7 KB)

MessagingSystem.hppNo OneTemporaryActions

MessagingSystem.hppView Options

File Metadata

Event Timeline

MessagingSystem.hpp
No OneTemporary
Actions

MessagingSystem.hpp
View Options