Page MenuHomePhorge
Files F19839991

AbstractAgent.hpp
No OneTemporary
Actions

Size
4 KB
Referenced Files
None
Subscribers
None

AbstractAgent.hpp
View Options

/***************************************************************************//**
*
* \file rosa/core/AbstractAgent.hpp
*
* \author David Juhasz (david.juhasz@tuwien.ac.at)
*
* \date 2017
*
* \brief Declaration of an abstract interface for *Agents*.
*
******************************************************************************/
#ifndef ROSA_CORE_ABSTRACTAGENT_HPP
#define ROSA_CORE_ABSTRACTAGENT_HPP
#include "rosa/core/Message.hpp"
#include "rosa/core/forward_declarations.h"
#include "rosa/support/debug.hpp"
#include <memory>
namespace rosa {
/// Abstract class declaring an interface for *Agents*.
///
/// \tparam Ref type of the derived class implementing `rosa::AbstractAgent` for
/// referencing `this` object
///
/// \note `Ref` is reference for `rosa::AbstractAgent`, whose actual value must
/// be a class derived from `rosa::AbstractAgent<Ref>`.
///
/// \note It can be statically checked if `Ref` is derived from
/// `rosa::AbstractAgent<Ref>`, but the static assertion cannot be defined
/// directly in the class body. That is because a class `C` derived from
/// `rosa::AbstractAgent<C>` is not complete when the static assertion in the
/// definition of `rosa::AbstractAgent<C>` would be evaluated. Thus, the static
/// assertion is placed in the constructor of `rosa::AbstractAgent`.
template <typename Ref> class AbstractAgent {
protected:
/// Creates a new instance of `rosa::AbstractAgent<Ref>`.
///
/// \note The constructor is protected, thus restricting class instantiation
/// for derived classes only.
///
/// \pre `Ref` is derived from `rosa::AbstractAgent<Ref>`:\code
/// std::is_base_of<AbstractAgent<Ref>, Ref>::value
/// \endcode
AbstractAgent(void) noexcept;
public:
/// Destroys `this` object.
virtual ~AbstractAgent(void) = default;
/// Tells if `this` object is in a valid state.
///
/// \return if `this` object is in a valid state
virtual operator bool(void) const noexcept = 0;
/// Tells if a given reference refers to `this` object.
///
/// \param R reference to another object
///
/// \return if `R` refers to `this` object
virtual bool operator==(const Ref &R) const noexcept = 0;
/// Returns a reference to `this` object.
///
/// \return a reference to `this` object
virtual Ref self(void) noexcept = 0;
/// Sends a `rosa::message_t` instance to `this` object.
///
/// \param M message to send
///
/// \pre `this` object is in a valid state:\code
/// bool(*this)
/// \endcode
virtual void sendMessage(message_t &&M) noexcept = 0;
/// Sends a message -- created from given constant lvalue references -- to
/// `this` object.
///
/// \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 T the first value to include in the message
/// \param Ts optional further values to include in the message
///
/// \pre `this` object is in a valid state:\code
/// bool(*this)
/// \endcode
template <typename Type, typename... Types>
void send(const Type &T, const Types &... Ts) noexcept;
/// Sends a message -- created from given rvalue references -- to `this`
/// object.
///
/// \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 T the first value to include in the message
/// \param Ts optional further values to include in the message
///
/// \pre `this` object is in a valid state:\code
/// bool(*this)
/// \endcode
template <typename Type, typename... Types>
void send(Type &&T, Types &&... Ts) noexcept;
};
template <typename Ref> AbstractAgent<Ref>::AbstractAgent(void) noexcept {
STATIC_ASSERT((std::is_base_of<AbstractAgent<Ref>, Ref>::value),
"not derived Agent"); // Sanity check.
}
template <typename Ref>
template <typename Type, typename... Types>
void AbstractAgent<Ref>::send(const Type &T, const Types &... Ts) noexcept {
sendMessage(Message::create<Type, Types...>(T, Ts...));
}
template <typename Ref>
template <typename Type, typename... Types>
void AbstractAgent<Ref>::send(Type &&T, Types &&... Ts) noexcept {
sendMessage(Message::create<Type, Types...>(std::move(T), std::move(Ts)...));
}
} // End namespace rosa
#endif // ROSA_CORE_ABSTRACTAGENT_HPP

File Metadata

Mime Type
text/x-c++
Expires
Sun, Jul 12, 6:56 PM (1 d, 6 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
347623
Default Alt Text
AbstractAgent.hpp (4 KB)

Event Timeline