/usr/include/caf/abstract_actor.hpp is in libcaf-dev 0.13.2-3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 | /******************************************************************************
* ____ _ _____ *
* / ___| / \ | ___| C++ *
* | | / _ \ | |_ Actor *
* | |___ / ___ \| _| Framework *
* \____/_/ \_|_| *
* *
* Copyright (C) 2011 - 2015 *
* Dominik Charousset <dominik.charousset (at) haw-hamburg.de> *
* *
* Distributed under the terms and conditions of the BSD 3-Clause License or *
* (at your option) under the terms and conditions of the Boost Software *
* License 1.0. See accompanying files LICENSE and LICENSE_ALTERNATIVE. *
* *
* If you did not receive a copy of the license files, see *
* http://opensource.org/licenses/BSD-3-Clause and *
* http://www.boost.org/LICENSE_1_0.txt. *
******************************************************************************/
#ifndef CAF_ABSTRACT_ACTOR_HPP
#define CAF_ABSTRACT_ACTOR_HPP
#include <set>
#include <mutex>
#include <atomic>
#include <memory>
#include <string>
#include <vector>
#include <cstdint>
#include <exception>
#include <type_traits>
#include <condition_variable>
#include "caf/fwd.hpp"
#include "caf/node_id.hpp"
#include "caf/attachable.hpp"
#include "caf/message_id.hpp"
#include "caf/exit_reason.hpp"
#include "caf/intrusive_ptr.hpp"
#include "caf/abstract_channel.hpp"
#include "caf/detail/type_traits.hpp"
#include "caf/detail/functor_attachable.hpp"
namespace caf {
/**
* A unique actor ID.
* @relates abstract_actor
*/
using actor_id = uint32_t;
/**
* Denotes an ID that is never used by an actor.
*/
constexpr actor_id invalid_actor_id = 0;
using abstract_actor_ptr = intrusive_ptr<abstract_actor>;
/**
* Base class for all actor implementations.
*/
class abstract_actor : public abstract_channel {
public:
/**
* Attaches `ptr` to this actor. The actor will call `ptr->detach(...)` on
* exit, or immediately if it already finished execution.
*/
void attach(attachable_ptr ptr);
/**
* Convenience function that attaches the functor `f` to this actor. The
* actor executes `f()` on exit or immediatley if it is not running.
*/
template <class F>
void attach_functor(F f) {
attach(attachable_ptr{new detail::functor_attachable<F>(std::move(f))});
}
/**
* Returns the logical actor address.
*/
actor_addr address() const;
/**
* Detaches the first attached object that matches `what`.
*/
size_t detach(const attachable::token& what);
/**
* Links this actor to `whom`.
*/
inline void link_to(const actor_addr& whom) {
link_impl(establish_link_op, whom);
}
/**
* Links this actor to `whom`.
*/
template <class ActorHandle>
void link_to(const ActorHandle& whom) {
link_to(whom.address());
}
/**
* Unlinks this actor from `whom`.
*/
inline void unlink_from(const actor_addr& other) {
link_impl(remove_link_op, other);
}
/**
* Unlinks this actor from `whom`.
*/
template <class ActorHandle>
void unlink_from(const ActorHandle& other) {
unlink_from(other.address());
}
/**
* Establishes a link relation between this actor and `other`
* and returns whether the operation succeeded.
*/
inline bool establish_backlink(const actor_addr& other) {
return link_impl(establish_backlink_op, other);
}
/**
* Removes the link relation between this actor and `other`
* and returns whether the operation succeeded.
*/
inline bool remove_backlink(const actor_addr& other) {
return link_impl(remove_backlink_op, other);
}
/**
* Returns the unique ID of this actor.
*/
inline uint32_t id() const {
return m_id;
}
/**
* Returns the actor's exit reason or
* `exit_reason::not_exited` if it's still alive.
*/
inline uint32_t exit_reason() const {
return m_exit_reason;
}
/**
* Returns the set of accepted messages types as strings or
* an empty set if this actor is untyped.
*/
virtual std::set<std::string> message_types() const;
/**
* Returns the execution unit currently used by this actor.
* @warning not thread safe
*/
inline execution_unit* host() const {
return m_host;
}
/**
* Sets the execution unit for this actor.
*/
inline void host(execution_unit* new_host) {
m_host = new_host;
}
protected:
/**
* Creates a non-proxy instance.
*/
abstract_actor();
/**
* Creates a proxy instance for a proxy running on `nid`.
*/
abstract_actor(actor_id aid, node_id nid);
/**
* Called by the runtime system to perform cleanup actions for this actor.
* Subtypes should always call this member function when overriding it.
*/
void cleanup(uint32_t reason);
/**
* Returns `exit_reason() != exit_reason::not_exited`.
*/
inline bool exited() const {
return exit_reason() != exit_reason::not_exited;
}
/****************************************************************************
* here be dragons: end of public interface *
****************************************************************************/
public:
/** @cond PRIVATE */
enum linking_operation {
establish_link_op,
establish_backlink_op,
remove_link_op,
remove_backlink_op
};
// used by ...
static constexpr int trap_exit_flag = 0x01; // local_actor
static constexpr int has_timeout_flag = 0x02; // single_timeout
static constexpr int is_registered_flag = 0x04; // (several actors)
static constexpr int is_initialized_flag = 0x08; // event-based actors
static constexpr int is_blocking_flag = 0x10; // blocking_actor
static constexpr int is_detached_flag = 0x20; // local_actor
static constexpr int is_priority_aware_flag = 0x40; // local_actor
inline void set_flag(bool enable_flag, int mask) {
auto x = flags();
flags(enable_flag ? x | mask : x & ~mask);
}
inline bool get_flag(int mask) const {
return static_cast<bool>(flags() & mask);
}
inline bool has_timeout() const {
return get_flag(has_timeout_flag);
}
inline void has_timeout(bool value) {
set_flag(value, has_timeout_flag);
}
inline bool is_registered() const {
return get_flag(is_registered_flag);
}
void is_registered(bool value);
inline bool is_initialized() const {
return get_flag(is_initialized_flag);
}
inline void is_initialized(bool value) {
set_flag(value, is_initialized_flag);
}
inline bool is_blocking() const {
return get_flag(is_blocking_flag);
}
inline void is_blocking(bool value) {
set_flag(value, is_blocking_flag);
}
inline bool is_detached() const {
return get_flag(is_detached_flag);
}
inline void is_detached(bool value) {
set_flag(value, is_detached_flag);
}
inline bool is_priority_aware() const {
return get_flag(is_priority_aware_flag);
}
inline void is_priority_aware(bool value) {
set_flag(value, is_priority_aware_flag);
}
// Tries to run a custom exception handler for `eptr`.
optional<uint32_t> handle(const std::exception_ptr& eptr);
protected:
virtual bool link_impl(linking_operation op, const actor_addr& other);
bool establish_link_impl(const actor_addr& other);
bool remove_link_impl(const actor_addr& other);
bool establish_backlink_impl(const actor_addr& other);
bool remove_backlink_impl(const actor_addr& other);
inline void attach_impl(attachable_ptr& ptr) {
ptr->next.swap(m_attachables_head);
m_attachables_head.swap(ptr);
}
static size_t detach_impl(const attachable::token& what,
attachable_ptr& ptr,
bool stop_on_first_hit = false,
bool dry_run = false);
// cannot be changed after construction
const actor_id m_id;
// initially set to exit_reason::not_exited
std::atomic<uint32_t> m_exit_reason;
// guards access to m_exit_reason, m_attachables, m_links,
// and enqueue operations if actor is thread-mapped
mutable std::mutex m_mtx;
// only used in blocking and thread-mapped actors
mutable std::condition_variable m_cv;
// attached functors that are executed on cleanup (monitors, links, etc)
attachable_ptr m_attachables_head;
// identifies the execution unit this actor is currently executed by
execution_unit* m_host;
/** @endcond */
};
} // namespace caf
#endif // CAF_ABSTRACT_ACTOR_HPP
|