Branch data     Line data    Source code

       1                 :             : // Copyright (c) The Bitcoin Core developers
       2                 :             : // Distributed under the MIT software license, see the accompanying
       3                 :             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       4                 :             : 
       5                 :             : #ifndef MP_PROXY_TYPE_MESSAGE_H
       6                 :             : #define MP_PROXY_TYPE_MESSAGE_H
       7                 :             : 
       8                 :             : #include <mp/util.h>
       9                 :             : 
      10                 :             : namespace mp {
      11                 :             : //! Overload CustomBuildField to serialize objects that have CustomBuildMessage
      12                 :             : //! overloads. Defining a CustomBuildMessage overload is simpler than defining a
      13                 :             : //! CustomBuildField overload because it only requires defining a normal
      14                 :             : //! function, not a template function, but less flexible.
      15                 :             : template <typename LocalType, typename Value, typename Output>
      16                 :           0 : void CustomBuildField(TypeList<LocalType>, Priority<2>, InvokeContext& invoke_context, Value&& value, Output&& output,
      17                 :             :                       decltype(CustomBuildMessage(invoke_context, value, std::move(output.get())))* enable = nullptr)
      18                 :             : {
      19                 :           0 :     CustomBuildMessage(invoke_context, value, std::move(output.init()));
      20                 :           0 : }
      21                 :             : 
      22                 :             : //! Overload CustomReadField to serialize objects that have CustomReadMessage
      23                 :             : //! overloads. Defining a CustomReadMessage overload is simpler than defining a
      24                 :             : //! CustomReadField overload because it only requires defining a normal
      25                 :             : //! function, not a template function, but less flexible.
      26                 :             : template <typename LocalType, typename Reader, typename ReadDest>
      27                 :           0 : decltype(auto) CustomReadField(TypeList<LocalType>, Priority<2>, InvokeContext& invoke_context, Reader&& reader,
      28                 :             :                                ReadDest&& read_dest,
      29                 :             :                                decltype(CustomReadMessage(invoke_context, reader.get(),
      30                 :             :                                                           std::declval<LocalType&>()))* enable = nullptr)
      31                 :             : {
      32         [ #  # ]:           0 :     return read_dest.update([&](auto& value) { if (reader.has()) CustomReadMessage(invoke_context, reader.get(), value); });
      33                 :             : }
      34                 :             : 
      35                 :             : //! Helper for CustomPassField below. Call Accessor::init method if it has one,
      36                 :             : //! otherwise do nothing.
      37                 :             : template <typename Accessor, typename Message>
      38                 :           0 : decltype(auto) MaybeInit(Message&& message, decltype(Accessor::get(message))* enable = nullptr)
      39                 :             : {
      40                 :           0 :     return Accessor::init(message);
      41                 :             : }
      42                 :             : 
      43                 :             : template <typename Accessor>
      44                 :             : ::capnp::Void MaybeInit(...)
      45                 :             : {
      46                 :             :     return {};
      47                 :             : }
      48                 :             : 
      49                 :             : //! Overload CustomPassField to serialize objects that have CustomPassMessage
      50                 :             : //! overloads. Defining a CustomPassMessage overload is simpler than defining a
      51                 :             : //! CustomPassField overload because it only requires defining a normal
      52                 :             : //! function, not a template function, but less flexible.
      53                 :             : template <typename Accessor, typename... LocalTypes, typename ServerContext, typename Fn, typename... Args>
      54                 :           0 : auto CustomPassField(TypeList<LocalTypes...>, ServerContext& server_context, Fn&& fn, Args&&... args)
      55                 :             :     -> decltype(CustomPassMessage(server_context, MaybeGet<Accessor>(server_context.call_context.getParams()),
      56                 :             :                                   MaybeGet<Accessor>(server_context.call_context.getResults()), nullptr))
      57                 :             : {
      58   [ #  #  #  #  :           0 :     CustomPassMessage(server_context, MaybeGet<Accessor>(server_context.call_context.getParams()),
             #  #  #  # ]
      59         [ #  # ]:           0 :                       MaybeInit<Accessor>(server_context.call_context.getResults()),
      60                 :           0 :                       [&](LocalTypes... param) { fn.invoke(server_context, std::forward<Args>(args)..., param...); });
      61                 :           0 : }
      62                 :             : } // namespace mp
      63                 :             : 
      64                 :             : #endif // MP_PROXY_TYPE_MESSAGE_H