sdbusplus/message/read.hpp

#pragma once

#include <tuple>
#include <sdbusplus/message/types.hpp>
#include <sdbusplus/utility/type_traits.hpp>
#include <sdbusplus/utility/tuple_to_array.hpp>
#include <systemd/sd-bus.h>

namespace sdbusplus
{

namespace message
{

/** @brief Read data from an sdbus message.
 *
 *  (This is an empty no-op function that is useful in some cases for
 *   variadic template reasons.)
 */
inline void read(sd_bus_message* m){};
/** @brief Read data from an sdbus message.
 *
 *  @param[in] msg - The message to read from.
 *  @tparam Args - C++ types of arguments to read from message.
 *  @param[out] args - References to place contents read from message.
 *
 *  This function will, at compile-time, deduce the DBus types of the passed
 *  C++ values and call the sd_bus_message_read functions with the
 *  appropriate type parameters.  It may also do conversions, where needed,
 *  to convert C++ types into C representations (eg. string, vector).
 */
template <typename... Args> void read(sd_bus_message* m, Args&&... args);

namespace details
{

/** @struct can_read_multiple
 *  @brief Utility to identify C++ types that may not be grouped into a
 *         single sd_bus_message_read call and instead need special
 *         handling.
 *
 *  @tparam T - Type for identification.
 *
 *  User-defined types are expected to inherit from std::false_type.
 *
 */
template <typename T> struct can_read_multiple : std::true_type
{
};
// std::string needs a char* conversion.
template <> struct can_read_multiple<std::string> : std::false_type
{
};
// object_path needs a char* conversion.
template <> struct can_read_multiple<object_path> : std::false_type
{
};
// signature needs a char* conversion.
template <> struct can_read_multiple<signature> : std::false_type
{
};
// bool needs to be resized to int, per sdbus documentation.
template <> struct can_read_multiple<bool> : std::false_type
{
};
// std::vector needs a loop.
template <typename T> struct can_read_multiple<std::vector<T>> : std::false_type
{
};
// std::pair needs to be broken down into components.
template <typename T1, typename T2>
struct can_read_multiple<std::pair<T1, T2>> : std::false_type
{
};
// std::map needs a loop.
template <typename T1, typename T2>
struct can_read_multiple<std::map<T1, T2>> : std::false_type
{
};
// std::tuple needs to be broken down into components.
template <typename... Args>
struct can_read_multiple<std::tuple<Args...>> : std::false_type
{
};
// variant needs to be broken down into components.
template <typename... Args>
struct can_read_multiple<variant<Args...>> : std::false_type
{
};

/** @struct read_single
 *  @brief Utility to read a single C++ element from a sd_bus_message.
 *
 *  User-defined types are expected to specialize this template in order to
 *  get their functionality.
 *
 *  @tparam S - Type of element to read.
 */
template <typename S> struct read_single
{
    // Downcast
    template <typename T> using Td = types::details::type_id_downcast_t<T>;

    /** @brief Do the operation to read element.
     *
     *  @tparam T - Type of element to read.
     *
     *  Template parameters T (function) and S (class) are different
     *  to allow the function to be utilized for many varients of S:
     *  S&, S&&, const S&, volatile S&, etc. The type_id_downcast is used
     *  to ensure T and S are equivalent.  For 'char*', this also allows
     *  use for 'char[N]' types.
     *
     *  @param[in] m - sd_bus_message to read from.
     *  @param[out] t - The reference to read item into.
     */
    template <typename T,
              typename = std::enable_if_t<std::is_same<S, Td<T>>::value>>
    static void op(sd_bus_message* m, T&& t)
    {
        // For this default implementation, we need to ensure that only
        // basic types are used.
        static_assert(std::is_fundamental<Td<T>>::value ||
                          std::is_convertible<Td<T>, const char*>::value,
                      "Non-basic types are not allowed.");

        constexpr auto dbusType = std::get<0>(types::type_id<T>());
        sd_bus_message_read_basic(m, dbusType, &t);
    }
};

template <typename T>
using read_single_t = read_single<types::details::type_id_downcast_t<T>>;

/** @brief Specialization of read_single for std::strings. */
template <> struct read_single<std::string>
{
    template <typename T> static void op(sd_bus_message* m, T&& s)
    {
        constexpr auto dbusType = std::get<0>(types::type_id<T>());
        const char* str = nullptr;
        sd_bus_message_read_basic(m, dbusType, &str);
        s = str;
    }
};

/** @brief Specialization of read_single for details::string_wrapper. */
template <typename T> struct read_single<details::string_wrapper<T>>
{
    template <typename S> static void op(sd_bus_message* m, S&& s)
    {
        constexpr auto dbusType = std::get<0>(types::type_id<S>());
        const char* str = nullptr;
        sd_bus_message_read_basic(m, dbusType, &str);
        s.str = str;
    }
};

/** @brief Specialization of read_single for bools. */
template <> struct read_single<bool>
{
    template <typename T> static void op(sd_bus_message* m, T&& b)
    {
        constexpr auto dbusType = std::get<0>(types::type_id<T>());
        int i = 0;
        sd_bus_message_read_basic(m, dbusType, &i);
        b = (i != 0);
    }
};

/** @brief Specialization of read_single for std::vectors. */
template <typename T> struct read_single<std::vector<T>>
{
    template <typename S> static void op(sd_bus_message* m, S&& s)
    {
        s.clear();

        constexpr auto dbusType = utility::tuple_to_array(types::type_id<T>());
        sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, dbusType.data());

        while (!sd_bus_message_at_end(m, false))
        {
            std::remove_const_t<T> t{};
            sdbusplus::message::read(m, t);
            s.push_back(std::move(t));
        }

        sd_bus_message_exit_container(m);
    }
};

/** @brief Specialization of read_single for std::pairs. */
template <typename T1, typename T2> struct read_single<std::pair<T1, T2>>
{
    template <typename S> static void op(sd_bus_message* m, S&& s)
    {
        constexpr auto dbusType = utility::tuple_to_array(
            std::tuple_cat(types::type_id_nonull<T1>(), types::type_id<T2>()));

        sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY,
                                       dbusType.data());
        sdbusplus::message::read(m, s.first, s.second);
        sd_bus_message_exit_container(m);
    }
};

/** @brief Specialization of read_single for std::maps. */
template <typename T1, typename T2> struct read_single<std::map<T1, T2>>
{
    template <typename S> static void op(sd_bus_message* m, S&& s)
    {
        s.clear();

        constexpr auto dbusType = utility::tuple_to_array(
            types::type_id<typename std::map<T1, T2>::value_type>());

        sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, dbusType.data());

        while (!sd_bus_message_at_end(m, false))
        {
            std::pair<std::remove_const_t<T1>, std::remove_const_t<T2>> p{};
            sdbusplus::message::read(m, p);
            s.insert(std::move(p));
        }

        sd_bus_message_exit_container(m);
    }
};

/** @brief Specialization of read_single for std::tuples. */
template <typename... Args> struct read_single<std::tuple<Args...>>
{
    template <typename S, std::size_t... I>
    static void _op(sd_bus_message* m, S&& s,
                    std::integer_sequence<std::size_t, I...>)
    {
        sdbusplus::message::read(m, std::get<I>(s)...);
    }

    template <typename S> static void op(sd_bus_message* m, S&& s)
    {
        constexpr auto dbusType = utility::tuple_to_array(std::tuple_cat(
            types::type_id_nonull<Args...>(),
            std::make_tuple('\0') /* null terminator for C-string */));

        sd_bus_message_enter_container(m, SD_BUS_TYPE_STRUCT, dbusType.data());
        _op(m, std::forward<S>(s), std::make_index_sequence<sizeof...(Args)>());
        sd_bus_message_exit_container(m);
    }
};

/** @brief Specialization of read_single for std::variant. */
template <typename... Args> struct read_single<variant<Args...>>
{
    template <typename S, typename S1, typename... Args1>
    static void read(sd_bus_message* m, S&& s)
    {
        constexpr auto dbusType = utility::tuple_to_array(types::type_id<S1>());

        auto rc =
            sd_bus_message_verify_type(m, SD_BUS_TYPE_VARIANT, dbusType.data());
        if (0 >= rc)
        {
            read<S, Args1...>(m, s);
            return;
        }

        std::remove_reference_t<S1> s1;

        sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, dbusType.data());
        sdbusplus::message::read(m, s1);
        sd_bus_message_exit_container(m);

        s = std::move(s1);
    }

    template <typename S> static void read(sd_bus_message* m, S&& s)
    {
        sd_bus_message_skip(m, "v");
        s = std::remove_reference_t<S>{};
    }

    template <typename S, typename = std::enable_if_t<0 < sizeof...(Args)>>
    static void op(sd_bus_message* m, S&& s)
    {
        read<S, Args...>(m, s);
    }
};

/** @brief Read a tuple of content from the sd_bus_message.
 *
 *  @tparam Tuple - The tuple type to read.
 *  @param[out] t - The tuple references to read.
 *  @tparam I - The indexes of the tuple type Tuple.
 *  @param[in] [unamed] - unused index_sequence for type deduction of I.
 */
template <typename Tuple, size_t... I>
void read_tuple(sd_bus_message* m, Tuple&& t, std::index_sequence<I...>)
{
    auto dbusTypes =
        utility::tuple_to_array(types::type_id<decltype(std::get<I>(t))...>());

    sd_bus_message_read(m, dbusTypes.data(), &std::get<I>(t)...);
}

/** @brief Read a tuple of 2 or more entries from the sd_bus_message.
 *
 *  @tparam Tuple - The tuple type to read.
 *  @param[out] t - The tuple to read into.
 *
 *  A tuple of 2 or more entries can be read as a set with
 *  sd_bus_message_read.
 */
template <typename Tuple>
std::enable_if_t<2 <= std::tuple_size<Tuple>::value>
read_tuple(sd_bus_message* m, Tuple&& t)
{
    read_tuple(m, std::move(t),
               std::make_index_sequence<std::tuple_size<Tuple>::value>());
}

/** @brief Read a tuple of exactly 1 entry from the sd_bus_message.
 *
 *  @tparam Tuple - The tuple type to read.
 *  @param[out] t - The tuple to read into.
 *
 *  A tuple of 1 entry can be read with sd_bus_message_read_basic.
 *
 *  Note: Some 1-entry tuples may need special handling due to
 *  can_read_multiple::value == false.
 */
template <typename Tuple>
std::enable_if_t<1 == std::tuple_size<Tuple>::value>
read_tuple(sd_bus_message* m, Tuple&& t)
{
    using itemType = decltype(std::get<0>(t));
    read_single_t<itemType>::op(m, std::forward<itemType>(std::get<0>(t)));
}

/** @brief Read a tuple of 0 entries - no-op.
 *
 *  This a no-op function that is useful due to variadic templates.
 */
template <typename Tuple>
std::enable_if_t<0 == std::tuple_size<Tuple>::value> inline read_tuple(
    sd_bus_message* m, Tuple&& t)
{
}

/** @brief Group a sequence of C++ types for reading from an sd_bus_message.
 *  @tparam Tuple - A tuple of previously analyzed types.
 *  @tparam Arg - The argument to analyze for grouping.
 *
 *  Specialization for when can_read_multiple<Arg> is true.
 */
template <typename Tuple, typename Arg>
std::enable_if_t<
    can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
read_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg);
/** @brief Group a sequence of C++ types for reading from an sd_bus_message.
 *  @tparam Tuple - A tuple of previously analyzed types.
 *  @tparam Arg - The argument to analyze for grouping.
 *
 *  Specialization for when can_read_multiple<Arg> is false.
 */
template <typename Tuple, typename Arg>
std::enable_if_t<
    !can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
read_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg);
/** @brief Group a sequence of C++ types for reading from an sd_bus_message.
 *  @tparam Tuple - A tuple of previously analyzed types.
 *  @tparam Arg - The argument to analyze for grouping.
 *  @tparam Rest - The remaining arguments left to analyze.
 *
 *  Specialization for when can_read_multiple<Arg> is true.
 */
template <typename Tuple, typename Arg, typename... Rest>
std::enable_if_t<
    can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
read_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg, Rest&&... rest);
/** @brief Group a sequence of C++ types for reading from an sd_bus_message.
 *  @tparam Tuple - A tuple of previously analyzed types.
 *  @tparam Arg - The argument to analyze for grouping.
 *  @tparam Rest - The remaining arguments left to analyze.
 *
 *  Specialization for when can_read_multiple<Arg> is false.
 */
template <typename Tuple, typename Arg, typename... Rest>
std::enable_if_t<
    !can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
read_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg, Rest&&... rest);

template <typename Tuple, typename Arg>
std::enable_if_t<
    can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
read_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg)
{
    // Last element of a sequence and can_read_multiple, so add it to
    // the tuple and call read_tuple.

    read_tuple(m,
               std::tuple_cat(std::forward<Tuple>(t),
                              std::forward_as_tuple(std::forward<Arg>(arg))));
}

template <typename Tuple, typename Arg>
std::enable_if_t<
    !can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
read_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg)
{
    // Last element of a sequence but !can_read_multiple, so call
    // read_tuple on the previous elements and separately this single
    // element.

    read_tuple(m, std::forward<Tuple>(t));
    read_tuple(m, std::forward_as_tuple(std::forward<Arg>(arg)));
}

template <typename Tuple, typename Arg, typename... Rest>
std::enable_if_t<
    can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
read_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg, Rest&&... rest)
{
    // Not the last element of a sequence and can_read_multiple, so add it
    // to the tuple and keep grouping.

    read_grouping(m,
                  std::tuple_cat(std::forward<Tuple>(t),
                                 std::forward_as_tuple(std::forward<Arg>(arg))),
                  std::forward<Rest>(rest)...);
}

template <typename Tuple, typename Arg, typename... Rest>
std::enable_if_t<
    !can_read_multiple<types::details::type_id_downcast_t<Arg>>::value>
read_grouping(sd_bus_message* m, Tuple&& t, Arg&& arg, Rest&&... rest)
{
    // Not the last element of a sequence but !can_read_multiple, so call
    // read_tuple on the previous elements and separately this single
    // element and then group the remaining elements.

    read_tuple(m, std::forward<Tuple>(t));
    read_tuple(m, std::forward_as_tuple(std::forward<Arg>(arg)));
    read_grouping(m, std::make_tuple(), std::forward<Rest>(rest)...);
}

} // namespace details

template <typename... Args> void read(sd_bus_message* m, Args&&... args)
{
    details::read_grouping(m, std::make_tuple(), std::forward<Args>(args)...);
}

} // namespace message

} // namespace sdbusplus