Agent.hpp
No OneTemporary
Actions

Size

4 KB

Referenced Files

None

Subscribers

None

Agent.hpp
View Options

	//===-- rosa/core/Agent.hpp -------------------------------------- C++ --===//
	//
	// The RoSA Framework
	//
	//===----------------------------------------------------------------------===//
	///
	/// \file rosa/core/Agent.hpp
	///
	/// \author David Juhasz (david.juhasz@tuwien.ac.at)
	///
	/// \date 2017
	///
	/// \brief Declaration of the base \c rosa::Agent class.
	///
	//===----------------------------------------------------------------------===//

	#ifndef ROSA_CORE_AGENT_HPP
	#define ROSA_CORE_AGENT_HPP

	#include "rosa/core/AgentHandle.hpp"
	#include "rosa/core/MessageHandler.hpp"
	#include "rosa/core/MessagingSystem.hpp"
	#include "rosa/core/Unit.h"

	#include "rosa/support/log.h"

	namespace rosa {

	/// Implements an Agent that is a special \c rosa::Unit owned by a
	/// \c rosa::MessagingSystem, capable of handling \c rosa::Message instances
	/// as \c rosa::MessageHandler, and provides the \c rosa::AbstractAgent
	/// interface with \c rosa::AgentHandle as reference type.
	class Agent : public Unit,
	public MessageHandler,
	public AbstractAgent<AgentHandle> {
	friend class AgentHandle; ///< \c rosa::AgentHandle is our friend.

	protected:
	/// A handle for \p this object.
	const AgentHandle Self;

	public:
	/// Creates a new instance by instantiating all the base-classes.
	///
	/// \tparam Fun type of the first mandatory function for handling messages
	/// \tparam Funs types of any further functions for handling messages
	///
	/// \param Kind kind of the new \c rosa::Unit instance
	/// \param Id unique identifier of the new \c rosa::Unit instance
	/// \param Name name of the new \c rosa::Unit instance
	/// \param S \c rosa::MessagingSystem owning the new instance
	/// \param F the first mandatory function for handling messages
	/// \param Fs optional further functions for handling messages
	template <typename Fun, typename... Funs>
	Agent(const AtomValue Kind, const id_t Id, const std::string &Name,
	MessagingSystem &S, Fun &&F, Funs &&... Fs);

	/// Destroys \p this object.
	~Agent(void);

	/// Tells if \p this object is in a valid state.
	///
	/// \note A \c rosa::Agent instance is always valid.
	///
	/// \return if \p this object is in a valid state
	operator bool(void) const noexcept override;

	/// Tells if a given reference refers to \p this object.
	///
	/// \param H reference to another object
	///
	/// \return if \p H refers to \p this object
	bool operator==(const AgentHandle &H) const noexcept override;

	/// Comapres \p this object to a given reference.
	///
	/// The comparison is based on the memory addresses.
	///
	/// \param H reference to another object
	///
	/// \return if \p this object compares less to \p H
	bool operator<(const AgentHandle &H) const noexcept override;

	/// Returns a reference to \p this object.
	///
	/// \return a reference to \p this object
	AgentHandle self(void) noexcept override;

	/// Sends a given \c rosa::message_t instance to \p this object.
	///
	/// \param M message to send
	///
	/// \note Since a \c rosa::Agent instance is always valid, there is no
	/// precondition for this function.
	/// \see \c rosa::AbstractAgent::sendMessage and
	/// `rosa::Agent::operator bool() const`
	void sendMessage(message_t &&M) noexcept override;

	/// Dumps \p this object into a \c std::string for tracing purposes.
	///
	/// \return \c std::string representing the state of \p this object
	std::string dump(void) const noexcept override;

	protected:
	/// Returns a reference to the \c rosa::MessagingSystem owning \p this object.
	///
	/// \return reference of \c rosa::Unit::S
	MessagingSystem &system(void) const noexcept override;

	/// 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;
	}
	};

	template <typename Fun, typename... Funs>
	Agent::Agent(const AtomValue Kind, const id_t Id, const std::string &Name,
	MessagingSystem &S, Fun &&F, Funs &&... Fs)
	: Unit(Kind, Id, Name, S), MessageHandler(std::move(F), std::move(Fs)...),
	Self(this, /valid*/ true) {
	LOG_TRACE("Agent is created.");
	}

	} // End namespace rosa

	#endif // ROSA_CORE_AGENT_HPP

File Metadata

Mime Type: text/x-c++
Expires: Thu, Jul 3, 6:55 AM (1 d, 8 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 157197
Default Alt Text: Agent.hpp (4 KB)

Agent.hppNo OneTemporaryActions

Agent.hppView Options

File Metadata

Event Timeline

Agent.hpp
No OneTemporary
Actions

Agent.hpp
View Options