summaryrefslogtreecommitdiffstats
path: root/src/method.hpp
blob: 66c19db90569fd7016053a6fa3eab19e1dafc819 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
#pragma once

#include <experimental/tuple>
#include "callback.hpp"

namespace phosphor
{
namespace dbus
{
namespace monitoring
{
namespace detail
{

/** @class CallDBusMethod
 *  @brief Provide explicit call forwarding to
 *     DBusInterface::callMethodNoReply.
 *
 *  @tparam DBusInterface - The DBus interface to use.
 *  @tparam MethodArgs - DBus method argument types.
 */
template <typename DBusInterface, typename ...MethodArgs>
struct CallDBusMethod
{
    static void op(
        const std::string& bus,
        const std::string& path,
        const std::string& iface,
        const std::string& method,
        MethodArgs&& ...args)
    {
        DBusInterface::callMethodNoReply(
            bus,
            path,
            iface,
            method,
            std::forward<MethodArgs>(args)...);
    }
};
} // namespace detail

/** @class MethodBase
 *  @brief Invoke DBus method callback implementation.
 *
 *  The method callback invokes the client supplied DBus method.
 */
class MethodBase : public Callback
{
    public:
        MethodBase() = delete;
        MethodBase(const MethodBase&) = delete;
        MethodBase(MethodBase&&) = default;
        MethodBase& operator=(const MethodBase&) = delete;
        MethodBase& operator=(MethodBase&&) = default;
        virtual ~MethodBase() = default;
        MethodBase(
            const std::string& b,
            const std::string& p,
            const std::string& i,
            const std::string& m)
            : Callback(),
              bus(b),
              path(p),
              interface(i),
                  method(m) {}

        /** @brief Callback interface implementation. */
        void operator()() override = 0;

    protected:
        const std::string& bus;
        const std::string& path;
        const std::string& interface;
        const std::string& method;
};

/** @class Method
 *  @brief C++ type specific logic for the method callback.
 *
 *  @tparam DBusInterface - The DBus interface to use to call the method.
 *  @tparam MethodArgs - DBus method argument types.
 */
template <typename DBusInterface, typename ...MethodArgs>
class Method : public MethodBase
{
    public:
        Method() = delete;
        Method(const Method&) = default;
        Method(Method&&) = default;
        Method& operator=(const Method&) = default;
        Method& operator=(Method&&) = default;
        ~Method() = default;
        Method(
            const std::string& bus,
            const std::string& path,
            const std::string& iface,
            const std::string& method,
            MethodArgs&& ... arguments)
            : MethodBase(bus, path, iface, method),
              args(std::forward<MethodArgs>(arguments)...) {}

        /** @brief Callback interface implementation. */
        void operator()() override
        {
            std::experimental::apply(
                detail::CallDBusMethod<DBusInterface, MethodArgs...>::op,
                std::tuple_cat(
                    std::make_tuple(bus),
                    std::make_tuple(path),
                    std::make_tuple(interface),
                    std::make_tuple(method),
                    args));
        }

    private:
        std::tuple<MethodArgs...> args;
};

/** @brief Argument type deduction for constructing Method instances. */
template <typename DBusInterface, typename ...MethodArgs>
auto makeMethod(
    const std::string& bus,
    const std::string& path,
    const std::string& iface,
    const std::string& method,
    MethodArgs&& ... arguments)
{
    return std::make_unique<Method<DBusInterface, MethodArgs...>>(
               bus,
               path,
               iface,
               method,
               std::forward<MethodArgs>(arguments)...);
}

} // namespace monitoring
} // namespace dbus
} // namespace phosphor
OpenPOWER on IntegriCloud