behavior.hpp

// This file is part of CAF, the C++ Actor Framework. See the file LICENSE in
// the main distribution directory for license terms and copyright or visit
// https://github.com/actor-framework/actor-framework/blob/master/LICENSE.

#pragma once

#include "caf/detail/behavior_impl.hpp"
#include "caf/detail/core_export.hpp"
#include "caf/detail/type_traits.hpp"
#include "caf/none.hpp"
#include "caf/timeout_definition.hpp"
#include "caf/timespan.hpp"
#include "caf/unsafe_behavior_init.hpp"

#include <functional>
#include <type_traits>

namespace caf {

class message_handler;

class CAF_CORE_EXPORT behavior {
public:
  friend class message_handler;

  behavior() = default;
  behavior(behavior&&) = default;
  behavior(const behavior&) = default;
  behavior& operator=(behavior&&) = default;
  behavior& operator=(const behavior&) = default;

  // Convenience overload to allow "unsafe" initialization of any behavior_type.
  behavior(unsafe_behavior_init_t, behavior from) : behavior(std::move(from)) {
    // nop
  }

  behavior(const message_handler& mh);

  template <class T, class... Ts>
  behavior(T arg, Ts&&... args) {
    if constexpr (is_timeout_definition_v<T>
                  || (is_timeout_definition_v<Ts> || ...)) {
      legacy_assign(std::move(arg), std::forward<Ts>(args)...);
    } else {
      impl_ = detail::make_behavior(std::move(arg), std::forward<Ts>(args)...);
    }
  }

  template <class F>
  [[deprecated("use idle timeouts instead of 'after >> ...'")]]
  behavior(timeout_definition<F> tdef)
    : impl_(detail::make_behavior(tdef)) {
    // nop
  }

  template <class... Ts>
  [[deprecated("use idle timeouts instead of 'after >> ...'")]]
  void legacy_assign(Ts&&... xs) {
    static_assert(sizeof...(Ts) > 0, "assign() called without arguments");
    impl_ = detail::make_behavior(std::forward<Ts>(xs)...);
  }

  template <class T, class... Ts>
  void assign(T&& arg, Ts&&... args) {
    if constexpr (is_timeout_definition_v<T>
                  || (is_timeout_definition_v<Ts> || ...)) {
      legacy_assign(std::forward<T>(arg), std::forward<Ts>(args)...);
    } else {
      impl_ = detail::make_behavior(std::forward<T>(arg),
                                    std::forward<Ts>(args)...);
    }
  }

  void swap(behavior& other) {
    impl_.swap(other.impl_);
  }

  void assign(intrusive_ptr<detail::behavior_impl> ptr) {
    impl_.swap(ptr);
  }

  void assign(message_handler other);

  void assign(behavior other);

  void handle_timeout() {
    impl_->handle_timeout();
  }

  timespan timeout() const noexcept {
    return impl_->timeout();
  }

  std::optional<message> operator()(message& xs) {
    return impl_ ? impl_->invoke(xs) : std::nullopt;
  }

  bool operator()(detail::invoke_result_visitor& f, message& xs) {
    return impl_ ? impl_->invoke(f, xs) : false;
  }

  operator bool() const {
    return static_cast<bool>(impl_);
  }


  using impl_ptr = intrusive_ptr<detail::behavior_impl>;

  const impl_ptr& as_behavior_impl() const {
    return impl_;
  }

  behavior(impl_ptr ptr) : impl_(std::move(ptr)) {
    // nop
  }

  behavior& unbox() & {
    return *this;
  }

  behavior&& unbox() && {
    return std::move(*this);
  }


private:
  impl_ptr impl_;
};

} // namespace caf