/tmp/bitcoin/build/src/ipc/test/ipc_test.capnp.proxy.h

Source
// Generated by mpgen from /tmp/bitcoin/src/ipc/test/ipc_test.capnp

#ifndef TEST_IPC_TEST_CAPNP_PROXY_H
#define TEST_IPC_TEST_CAPNP_PROXY_H

#include <test/ipc_test.capnp.h> // IWYU pragma: keep
#include "ipc/test/ipc_test.h" // IWYU pragma: export
#include <mp/proxy.h>

#if defined(__GNUC__)
#pragma GCC diagnostic push
#if !defined(__has_warning)
#pragma GCC diagnostic ignored "-Wsuggest-override"
#elif __has_warning("-Wsuggest-override")
#pragma GCC diagnostic ignored "-Wsuggest-override"
#endif
#endif
namespace mp {
template<>
struct ProxyMethod<gen::FooInterface::AddParams>
{
    static constexpr auto impl = &FooImplementation::add;
};

template<>
struct ProxyMethod<gen::FooInterface::PassOutPointParams>
{
    static constexpr auto impl = &FooImplementation::passOutPoint;
};

template<>
struct ProxyMethod<gen::FooInterface::PassUniValueParams>
{
    static constexpr auto impl = &FooImplementation::passUniValue;
};

template<>
struct ProxyMethod<gen::FooInterface::PassTransactionParams>
{
    static constexpr auto impl = &FooImplementation::passTransaction;
};

template<>
struct ProxyMethod<gen::FooInterface::PassVectorCharParams>
{
    static constexpr auto impl = &FooImplementation::passVectorChar;
};

template<>
struct ProxyMethod<gen::FooInterface::PassScriptParams>
{
    static constexpr auto impl = &FooImplementation::passScript;
};

template<>
struct ProxyMethod<gen::FooInterface::PassTransactionsParams>
{
    static constexpr auto impl = &FooImplementation::passTransactions;
};

namespace ipc_test_fields {
struct A
{
    template<typename S> static auto get(S&& s) -> decltype(s.getA()) { return s.getA(); }
    template<typename S> static bool has(S&& s) { return s.hasA(); }
    template<typename S, typename A> static void set(S&& s, A&& a) { s.setA(std::forward<A>(a)); }
    template<typename S, typename... A> static decltype(auto) init(S&& s, A&&... a) { return s.initA(std::forward<A>(a)...); }
    template<typename S> static bool getWant(S&& s) { return s.getWantA(); }
    template<typename S> static void setWant(S&& s) { s.setWantA(true); }
    template<typename S> static bool getHas(S&& s) { return s.getHasA(); }
    template<typename S> static void setHas(S&& s) { s.setHasA(true); }
};
struct B
{
    template<typename S> static auto get(S&& s) -> decltype(s.getB()) { return s.getB(); }
    template<typename S> static bool has(S&& s) { return s.hasB(); }
    template<typename S, typename A> static void set(S&& s, A&& a) { s.setB(std::forward<A>(a)); }
    template<typename S, typename... A> static decltype(auto) init(S&& s, A&&... a) { return s.initB(std::forward<A>(a)...); }
    template<typename S> static bool getWant(S&& s) { return s.getWantB(); }
    template<typename S> static void setWant(S&& s) { s.setWantB(true); }
    template<typename S> static bool getHas(S&& s) { return s.getHasB(); }
    template<typename S> static void setHas(S&& s) { s.setHasB(true); }
};
struct Result
{
    template<typename S> static auto get(S&& s) -> decltype(s.getResult()) { return s.getResult(); }
    template<typename S> static bool has(S&& s) { return s.hasResult(); }
    template<typename S, typename A> static void set(S&& s, A&& a) { s.setResult(std::forward<A>(a)); }
    template<typename S, typename... A> static decltype(auto) init(S&& s, A&&... a) { return s.initResult(std::forward<A>(a)...); }
    template<typename S> static bool getWant(S&& s) { return s.getWantResult(); }
    template<typename S> static void setWant(S&& s) { s.setWantResult(true); }
    template<typename S> static bool getHas(S&& s) { return s.getHasResult(); }
    template<typename S> static void setHas(S&& s) { s.setHasResult(true); }
};
struct Arg
{
    template<typename S> static auto get(S&& s) -> decltype(s.getArg()) { return s.getArg(); }
    template<typename S> static bool has(S&& s) { return s.hasArg(); }
    template<typename S, typename A> static void set(S&& s, A&& a) { s.setArg(std::forward<A>(a)); }
    template<typename S, typename... A> static decltype(auto) init(S&& s, A&&... a) { return s.initArg(std::forward<A>(a)...); }
    template<typename S> static bool getWant(S&& s) { return s.getWantArg(); }
    template<typename S> static void setWant(S&& s) { s.setWantArg(true); }
    template<typename S> static bool getHas(S&& s) { return s.getHasArg(); }
    template<typename S> static void setHas(S&& s) { s.setHasArg(true); }
};
} // namespace ipc_test_fields

template<>
struct ProxyClient<gen::FooInterface> final : public ProxyClientCustom<gen::FooInterface, FooImplementation>
{
public:
    using ProxyClientCustom::ProxyClientCustom;
    ~ProxyClient();
    using M0 = ProxyClientMethodTraits<gen::FooInterface::AddParams>;
    typename M0::Result add(M0::Param<0> a,M0::Param<1> b);
    using M1 = ProxyClientMethodTraits<gen::FooInterface::PassOutPointParams>;
    typename M1::Result passOutPoint(M1::Param<0> arg);
    using M2 = ProxyClientMethodTraits<gen::FooInterface::PassUniValueParams>;
    typename M2::Result passUniValue(M2::Param<0> arg);
    using M3 = ProxyClientMethodTraits<gen::FooInterface::PassTransactionParams>;
    typename M3::Result passTransaction(M3::Param<0> arg);
    using M4 = ProxyClientMethodTraits<gen::FooInterface::PassVectorCharParams>;
    typename M4::Result passVectorChar(M4::Param<0> arg);
    using M5 = ProxyClientMethodTraits<gen::FooInterface::PassScriptParams>;
    typename M5::Result passScript(M5::Param<0> arg);
    using M6 = ProxyClientMethodTraits<gen::FooInterface::PassTransactionsParams>;
    typename M6::Result passTransactions(M6::Param<0> arg);
};

template<>
struct ProxyServer<gen::FooInterface> : public ProxyServerCustom<gen::FooInterface, FooImplementation>
{
public:
    using ProxyServerCustom::ProxyServerCustom;
    ~ProxyServer();
    kj::Promise<void> add(AddContext call_context) override;
    kj::Promise<void> passOutPoint(PassOutPointContext call_context) override;
    kj::Promise<void> passUniValue(PassUniValueContext call_context) override;
    kj::Promise<void> passTransaction(PassTransactionContext call_context) override;
    kj::Promise<void> passVectorChar(PassVectorCharContext call_context) override;
    kj::Promise<void> passScript(PassScriptContext call_context) override;
    kj::Promise<void> passTransactions(PassTransactionsContext call_context) override;
};

template<>
struct ProxyType<FooImplementation>
{
    using Type = FooImplementation;
    using Message = gen::FooInterface;
    using Client = ProxyClient<Message>;
    using Server = ProxyServer<Message>;
};
} // namespace mp
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#endif

Coverage Report

Created: 2026-07-23 20:35