tree 577aa8b477720432376c2ea51c23c262ecddee7d
parent 52d23e8ad8132ac38c6a393715c47b46d98e9106
author Patrick Williams <patrick@stwcx.xyz> 1705598258 -0600
committer Patrick Williams <patrick@stwcx.xyz> 1705598344 -0600

bus: fix message conflicting definitions

If `sdbusplus/message.hpp` is included before `sdbusplus/bus.hpp`, we
end up with a compile failure as follows:

```
../subprojects/sdbusplus/include/sdbusplus/bus.hpp:660:13: error: no declaration matches ‘auto sdbusplus::message::message::get_bus() const’
  660 | inline auto message_t::get_bus() const
      |             ^~~~~~~~~
In file included from ../utils/dbus.hpp:3,
                 from ../cmd/power-state.cpp:1:
../subprojects/sdbusplus/include/sdbusplus/message.hpp:188:17: note: candidate is: ‘auto sdbusplus::message::message::get_bus() const’
  188 |     inline auto get_bus() const;
      |                 ^~~~~~~
../subprojects/sdbusplus/include/sdbusplus/message.hpp:70:7: note: ‘class sdbusplus::message::message’ defined here
   70 | class message : private sdbusplus::slot::details::slot_friend
      |       ^~~~~~~
```

Fix this by being more explicit about the types rather than relying on
auto in a forward declaration.

Signed-off-by: Patrick Williams <patrick@stwcx.xyz>
Change-Id: I627a7901933d73aeec87f20b65605e4b04951758
