C++ (Cpp) check_typed_input 예제들

예제 #1

파일: local_actor.hpp 프로젝트: guigra/actor-framework

 typename detail::deduce_output_type<
   detail::type_list<Sigs...>,
   detail::type_list<
     typename detail::implicit_conversions<
       typename std::decay<Ts>::type
     >::type...
   >
 >::delegated_type
 delegate(message_priority mp, const typed_actor<Sigs...>& dest, Ts&&... xs) {
   static_assert(sizeof...(Ts) > 0, "no message to send");
   using token =
     detail::type_list<
       typename detail::implicit_conversions<
         typename std::decay<Ts>::type
       >::type...>;
   token tk;
   check_typed_input(dest, tk);
   if (! dest)
     return {};
   auto mid = current_element_->mid;
   current_element_->mid = mp == message_priority::high
                            ? mid.with_high_priority()
                            : mid.with_normal_priority();
   current_element_->msg = make_message(std::forward<Ts>(xs)...);
   dest->enqueue(std::move(current_element_), host());
   return {};
 }

예제 #2

파일: local_actor.hpp 프로젝트: chen--oRanGe/actor-framework

 void send(const typed_actor<Rs...>& whom, Ts... what) {
   check_typed_input(whom,
                     detail::type_list<typename detail::implicit_conversions<
                       typename detail::rm_const_and_ref<Ts>::type
                     >::type...>{});
   send_tuple(message_priority::normal, actor{whom.m_ptr.get()},
              make_message(std::forward<Ts>(what)...));
 }

예제 #3

파일: sync_sender.hpp 프로젝트: asmodehn/actor-framework

 response_handle<
   Subtype, typename detail::deduce_output_type<
          detail::type_list<Rs...>, detail::type_list<Ts...>>::type,
   ResponseHandleTag>
 sync_send_impl(message_priority prio, const typed_actor<Rs...>& dest,
          detail::type_list<Ts...> token, message&& what) {
   check_typed_input(dest, token);
   return {dptr()->sync_send_tuple_impl(prio, dest, std::move(what)),
       dptr()};
 }

예제 #4

파일: send.hpp 프로젝트: Neverlord/boost.actor

void send_as(const actor& from, const typed_actor<Sigs...>& to, Ts&&... xs) {
  using token =
    detail::type_list<
      typename detail::implicit_conversions<
        typename std::decay<Ts>::type
      >::type...>;
  token tk;
  check_typed_input(to, tk);
  send_as(from, message_priority::normal,
          actor_cast<channel>(to), std::forward<Ts>(xs)...);
}

예제 #5

파일: send.hpp 프로젝트: Neverlord/boost.actor

void anon_send(message_priority prio, const typed_actor<Sigs...>& to,
               Ts&&... xs) {
  using token =
    detail::type_list<
      typename detail::implicit_conversions<
        typename std::decay<Ts>::type
      >::type...>;
  token tk;
  check_typed_input(to, tk);
  anon_send(prio, actor_cast<channel>(to), std::forward<Ts>(xs)...);
}

예제 #6

파일: local_actor.hpp 프로젝트: guigra/actor-framework

 void send(const typed_actor<Sigs...>& dest, Ts&&... xs) {
   using token =
     detail::type_list<
       typename detail::implicit_conversions<
         typename std::decay<Ts>::type
       >::type...>;
   token tk;
   check_typed_input(dest, tk);
   send_impl(message_id::make(), actor_cast<abstract_channel*>(dest),
             std::forward<Ts>(xs)...);
 }

예제 #7

파일: local_actor.hpp 프로젝트: guigra/actor-framework

 void delayed_send(message_priority mp, const typed_actor<Sigs...>& dest,
                   const duration& rtime, Ts&&... xs) {
   using token =
     detail::type_list<
       typename detail::implicit_conversions<
         typename std::decay<Ts>::type
       >::type...>;
   token tk;
   check_typed_input(dest, tk);
   delayed_send_impl(message_id::make(mp), actor_cast<abstract_channel*>(dest),
                     rtime, make_message(std::forward<Ts>(xs)...));
 }

예제 #8

파일: sync_sender.hpp 프로젝트: Jenuce/actor-framework

 response_handle<Subtype,
                 typename detail::deduce_output_type<
                   detail::type_list<Sigs...>,
                   detail::type_list<
                     typename detail::implicit_conversions<
                       typename std::decay<Ts>::type
                     >::type...>
                 >::type,
                 HandleTag>
 sync_send(message_priority mp, const typed_actor<Sigs...>& dest, Ts&&... xs) {
   static_assert(sizeof...(Ts) > 0, "no message to send");
   using token =
     detail::type_list<
       typename detail::implicit_conversions<
         typename std::decay<Ts>::type
       >::type...>;
   token tk;
   check_typed_input(dest, tk);
   return {dptr()->sync_send_impl(mp, dest, std::forward<Ts>(xs)...),
           dptr()};
 }