1#pragma once
2#include <sdbusplus/async/client.hpp>
3#include <type_traits>
4
5% for h in interface.cpp_includes():
6#include <${h}>
7% endfor
8#include <${interface.headerFile("common")}>
9
10#ifndef SDBUSPP_REMOVE_DEPRECATED_NAMESPACE
11namespace sdbusplus::${interface.old_cppNamespacedClass("client")}
12{
13
14constexpr auto interface =
15    sdbusplus::common::${interface.cppNamespacedClass()}::interface;
16
17} // namespace sdbusplus::${interface.old_cppNamespacedClass("client")}
18#endif
19
20namespace sdbusplus::client::${interface.cppNamespace()}
21{
22
23namespace details
24{
25
26template <typename Proxy>
27class ${interface.classname} :
28    public sdbusplus::common::${interface.cppNamespacedClass()}
29{
30  public:
31    template <bool S, bool P, bool Preserved,
32              template <typename> typename... Types>
33    friend class sdbusplus::async::client::client;
34    // Delete default constructor as these should only be constructed
35    // indirectly through sdbusplus::async::client_t.
36    ${interface.classname}() = delete;
37
38    // To be replaced by generators...
39    template <typename... Rs, typename... Ss>
40    auto call(sdbusplus::async::context& ctx, auto& method, Ss&&... ss) const
41    {
42        return proxy.template call<Rs...>(ctx, method, std::forward<Ss>(ss)...);
43    }
44
45    // To be replaced by generators...
46    template <typename T>
47    auto get_property(sdbusplus::async::context& ctx, auto& property) const
48    {
49        return proxy.template get_property<T>(ctx, property);
50    }
51
52    // To be replaced by generators...
53    template <typename T>
54    auto set_property(sdbusplus::async::context& ctx, auto& property,
55                      T&& value) const
56    {
57        return proxy.template set_property<T>(ctx, property,
58                                              std::forward<T>(value));
59    }
60
61  private:
62    // Conversion constructor from proxy used by client_t.
63    constexpr explicit ${interface.classname}(Proxy p) :
64        proxy(p.interface(interface)) {}
65
66    decltype(std::declval<Proxy>().interface(interface)) proxy = {};
67};
68
69} // namespace details
70
71/** Alias class so we can use the client in both a client_t aggregation
72 *  and individually.
73 *
74 *  sdbusplus::async::client_t<${interface.classname}>() or
75 *  ${interface.classname}() both construct an equivalent instance.
76 */
77template <typename Proxy = void>
78struct ${interface.classname} : public
79    std::conditional_t<
80        std::is_void_v<Proxy>,
81        sdbusplus::async::client_t<details::${interface.classname}>,
82        details::${interface.classname}<Proxy>>
83{
84    template <typename... Args>
85    ${interface.classname}(Args&&... args) :
86        std::conditional_t<std::is_void_v<Proxy>,
87                           sdbusplus::async::client_t<details::${interface.classname}>,
88                           details::${interface.classname}<Proxy>>(
89            std::forward<Args>(args)...) {}
90};
91
92} // namespace sdbusplus::client::${interface.cppNamespacedClass()}
93