path: root/src/tests/sbus_codegen_tests_generated.c

/* The following definitions are auto-generated from sbus_codegen_tests.xml */

#include "util/util.h"
#include "sbus/sssd_dbus.h"
#include "sbus/sssd_dbus_meta.h"
#include "sbus_codegen_tests_generated.h"

/* invokes a handler with a 'bu' DBus signature */
static int invoke_bu_method(struct sbus_request *dbus_req, void *function_ptr);

/* invokes a handler with a 's' DBus signature */
static int invoke_s_method(struct sbus_request *dbus_req, void *function_ptr);

/* invokes a handler with a 'u' DBus signature */
static int invoke_u_method(struct sbus_request *dbus_req, void *function_ptr);

/* invokes a handler with a 'ybnqiuxtdsoayanaqaiauaxatadasao' DBus signature */
static int invoke_ybnqiuxtdsoayanaqaiauaxatadasao_method(struct sbus_request *dbus_req, void *function_ptr);
static int invoke_get_s(struct sbus_request *dbus_req, void *function_ptr);
static int invoke_get_y(struct sbus_request *dbus_req, void *function_ptr);
static int invoke_get_b(struct sbus_request *dbus_req, void *function_ptr);
static int invoke_get_n(struct sbus_request *dbus_req, void *function_ptr);
static int invoke_get_q(struct sbus_request *dbus_req, void *function_ptr);
static int invoke_get_i(struct sbus_request *dbus_req, void *function_ptr);
static int invoke_get_u(struct sbus_request *dbus_req, void *function_ptr);
static int invoke_get_x(struct sbus_request *dbus_req, void *function_ptr);
static int invoke_get_t(struct sbus_request *dbus_req, void *function_ptr);
static int invoke_get_d(struct sbus_request *dbus_req, void *function_ptr);
static int invoke_get_o(struct sbus_request *dbus_req, void *function_ptr);
static int invoke_get_ay(struct sbus_request *dbus_req, void *function_ptr);
static int invoke_get_an(struct sbus_request *dbus_req, void *function_ptr);
static int invoke_get_aq(struct sbus_request *dbus_req, void *function_ptr);
static int invoke_get_ai(struct sbus_request *dbus_req, void *function_ptr);
static int invoke_get_au(struct sbus_request *dbus_req, void *function_ptr);
static int invoke_get_ax(struct sbus_request *dbus_req, void *function_ptr);
static int invoke_get_at(struct sbus_request *dbus_req, void *function_ptr);
static int invoke_get_ad(struct sbus_request *dbus_req, void *function_ptr);
static int invoke_get_as(struct sbus_request *dbus_req, void *function_ptr);
static int invoke_get_ao(struct sbus_request *dbus_req, void *function_ptr);

/* arguments for com.planetexpress.Ship.MoveUniverse */
const struct sbus_arg_meta com_planetexpress_Ship_MoveUniverse__in[] = {
    { "smoothly", "b" },
    { "speed_factor", "u" },
    { NULL, }
};

/* arguments for com.planetexpress.Ship.MoveUniverse */
const struct sbus_arg_meta com_planetexpress_Ship_MoveUniverse__out[] = {
    { "where_we_crashed", "s" },
    { NULL, }
};

int com_planetexpress_Ship_MoveUniverse_finish(struct sbus_request *req, const char *arg_where_we_crashed)
{
   return sbus_request_return_and_finish(req,
                                         DBUS_TYPE_STRING, &arg_where_we_crashed,
                                         DBUS_TYPE_INVALID);
}

/* arguments for com.planetexpress.Ship.Crash */
const struct sbus_arg_meta com_planetexpress_Ship_crash_now__in[] = {
    { "where", "s" },
    { NULL, }
};

int com_planetexpress_Ship_crash_now_finish(struct sbus_request *req)
{
   return sbus_request_return_and_finish(req,
                                         DBUS_TYPE_INVALID);
}

/* methods for com.planetexpress.Ship */
const struct sbus_method_meta com_planetexpress_Ship__methods[] = {
    {
        "MoveUniverse", /* name */
        com_planetexpress_Ship_MoveUniverse__in,
        com_planetexpress_Ship_MoveUniverse__out,
        offsetof(struct com_planetexpress_Ship, MoveUniverse),
        invoke_bu_method,
    },
    {
        "Crash", /* name */
        com_planetexpress_Ship_crash_now__in,
        NULL, /* no out_args */
        offsetof(struct com_planetexpress_Ship, crash_now),
        invoke_s_method,
    },
    {
        "Land", /* name */
        NULL, /* no in_args */
        NULL, /* no out_args */
        offsetof(struct com_planetexpress_Ship, Land),
        NULL, /* no invoker */
    },
    { NULL, }
};

/* arguments for com.planetexpress.Ship.BecameSentient */
const struct sbus_arg_meta com_planetexpress_Ship_BecameSentient__args[] = {
    { "gender", "s" },
    { NULL, }
};

/* signals for com.planetexpress.Ship */
const struct sbus_signal_meta com_planetexpress_Ship__signals[] = {
    {
        "BecameSentient", /* name */
        com_planetexpress_Ship_BecameSentient__args
    },
    { NULL, }
};

/* property info for com.planetexpress.Ship */
const struct sbus_property_meta com_planetexpress_Ship__properties[] = {
    {
        "Color", /* name */
        "s", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct com_planetexpress_Ship, com_planetexpress_Ship_get_Color),
        invoke_get_s,
        0, /* not writable */
        NULL, /* no invoker */
    },
    { NULL, }
};

/* invokes GetAll for the 'com.planetexpress.Ship' interface */
static int invoke_com_planetexpress_Ship_get_all(struct sbus_request *dbus_req, void *function_ptr)
{
    DBusMessage *reply;
    dbus_bool_t dbret;
    DBusMessageIter iter;
    DBusMessageIter iter_dict;
    int ret;
    struct sbus_interface *intf = dbus_req->intf;
    const struct sbus_property_meta *property;
    const char * s_prop_val;
    const char * s_out_val;
    void (*s_handler)(struct sbus_request *, void *data, const char * *);

    reply = dbus_message_new_method_return(dbus_req->message);
    if (!reply) return ENOMEM;
    dbus_message_iter_init_append(reply, &iter);
    dbret = dbus_message_iter_open_container(
                                     &iter, DBUS_TYPE_ARRAY,
                                     DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
                                     DBUS_TYPE_STRING_AS_STRING
                                     DBUS_TYPE_VARIANT_AS_STRING
                                     DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
                                     &iter_dict);
    if (!dbret) return ENOMEM;

    property = sbus_meta_find_property(intf->vtable->meta, "Color");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        s_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (s_handler) {
            (s_handler)(dbus_req, dbus_req->intf->instance_data, &s_prop_val);
            s_out_val = s_prop_val == NULL ? "" : s_prop_val;
            ret = sbus_add_variant_to_dict(&iter_dict, "Color", DBUS_TYPE_STRING, &s_out_val);
            if (ret != EOK) return ret;
        }
    }

    dbret = dbus_message_iter_close_container(&iter, &iter_dict);
    if (!dbret) return ENOMEM;

    return sbus_request_finish(dbus_req, reply);
}

/* interface info for com.planetexpress.Ship */
const struct sbus_interface_meta com_planetexpress_Ship_meta = {
    "com.planetexpress.Ship", /* name */
    com_planetexpress_Ship__methods,
    com_planetexpress_Ship__signals,
    com_planetexpress_Ship__properties,
    invoke_com_planetexpress_Ship_get_all, /* GetAll invoker */
};

/* arguments for com.planetexpress.Pilot.Blink */
const struct sbus_arg_meta test_pilot_Blink__in[] = {
    { "duration", "u" },
    { NULL, }
};

/* arguments for com.planetexpress.Pilot.Blink */
const struct sbus_arg_meta test_pilot_Blink__out[] = {
    { "crashed", "b" },
    { NULL, }
};

int test_pilot_Blink_finish(struct sbus_request *req, bool arg_crashed)
{
    dbus_bool_t cast_crashed = arg_crashed;
   return sbus_request_return_and_finish(req,
                                         DBUS_TYPE_BOOLEAN, &cast_crashed,
                                         DBUS_TYPE_INVALID);
}

/* arguments for com.planetexpress.Pilot.Eject */
const struct sbus_arg_meta test_pilot_Eject__in[] = {
    { "byte", "y" },
    { "boolean", "b" },
    { "int16", "n" },
    { "uint16", "q" },
    { "int32", "i" },
    { "uint32", "u" },
    { "int64", "x" },
    { "uint64", "t" },
    { "double", "d" },
    { "string", "s" },
    { "object_path", "o" },
    { "byte_array", "ay" },
    { "int16_array", "an" },
    { "uint16_array", "aq" },
    { "int32_array", "ai" },
    { "uint32_array", "au" },
    { "int64_array", "ax" },
    { "uint64_array", "at" },
    { "double_array", "ad" },
    { "string_array", "as" },
    { "object_path_array", "ao" },
    { NULL, }
};

/* arguments for com.planetexpress.Pilot.Eject */
const struct sbus_arg_meta test_pilot_Eject__out[] = {
    { "byte", "y" },
    { "boolean", "b" },
    { "int16", "n" },
    { "uint16", "q" },
    { "int32", "i" },
    { "uint32", "u" },
    { "int64", "x" },
    { "uint64", "t" },
    { "double", "d" },
    { "string", "s" },
    { "object_path", "o" },
    { "byte_array", "ay" },
    { "int16_array", "an" },
    { "uint16_array", "aq" },
    { "int32_array", "ai" },
    { "uint32_array", "au" },
    { "int64_array", "ax" },
    { "uint64_array", "at" },
    { "double_array", "ad" },
    { "string_array", "as" },
    { "object_path_array", "ao" },
    { NULL, }
};

int test_pilot_Eject_finish(struct sbus_request *req, uint8_t arg_byte, bool arg_boolean, int16_t arg_int16, uint16_t arg_uint16, int32_t arg_int32, uint32_t arg_uint32, int64_t arg_int64, uint64_t arg_uint64, double arg_double, const char *arg_string, const char *arg_object_path, uint8_t arg_byte_array[], int len_byte_array, int16_t arg_int16_array[], int len_int16_array, uint16_t arg_uint16_array[], int len_uint16_array, int32_t arg_int32_array[], int len_int32_array, uint32_t arg_uint32_array[], int len_uint32_array, int64_t arg_int64_array[], int len_int64_array, uint64_t arg_uint64_array[], int len_uint64_array, double arg_double_array[], int len_double_array, const char *arg_string_array[], int len_string_array, const char *arg_object_path_array[], int len_object_path_array)
{
    dbus_bool_t cast_boolean = arg_boolean;
   return sbus_request_return_and_finish(req,
                                         DBUS_TYPE_BYTE, &arg_byte,
                                         DBUS_TYPE_BOOLEAN, &cast_boolean,
                                         DBUS_TYPE_INT16, &arg_int16,
                                         DBUS_TYPE_UINT16, &arg_uint16,
                                         DBUS_TYPE_INT32, &arg_int32,
                                         DBUS_TYPE_UINT32, &arg_uint32,
                                         DBUS_TYPE_INT64, &arg_int64,
                                         DBUS_TYPE_UINT64, &arg_uint64,
                                         DBUS_TYPE_DOUBLE, &arg_double,
                                         DBUS_TYPE_STRING, &arg_string,
                                         DBUS_TYPE_OBJECT_PATH, &arg_object_path,
                                         DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &arg_byte_array, len_byte_array,
                                         DBUS_TYPE_ARRAY, DBUS_TYPE_INT16, &arg_int16_array, len_int16_array,
                                         DBUS_TYPE_ARRAY, DBUS_TYPE_UINT16, &arg_uint16_array, len_uint16_array,
                                         DBUS_TYPE_ARRAY, DBUS_TYPE_INT32, &arg_int32_array, len_int32_array,
                                         DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &arg_uint32_array, len_uint32_array,
                                         DBUS_TYPE_ARRAY, DBUS_TYPE_INT64, &arg_int64_array, len_int64_array,
                                         DBUS_TYPE_ARRAY, DBUS_TYPE_UINT64, &arg_uint64_array, len_uint64_array,
                                         DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE, &arg_double_array, len_double_array,
                                         DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &arg_string_array, len_string_array,
                                         DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &arg_object_path_array, len_object_path_array,
                                         DBUS_TYPE_INVALID);
}

/* methods for com.planetexpress.Pilot */
const struct sbus_method_meta test_pilot__methods[] = {
    {
        "Blink", /* name */
        test_pilot_Blink__in,
        test_pilot_Blink__out,
        offsetof(struct test_pilot, Blink),
        invoke_u_method,
    },
    {
        "Eject", /* name */
        test_pilot_Eject__in,
        test_pilot_Eject__out,
        offsetof(struct test_pilot, Eject),
        invoke_ybnqiuxtdsoayanaqaiauaxatadasao_method,
    },
    { NULL, }
};

/* property info for com.planetexpress.Pilot */
const struct sbus_property_meta test_pilot__properties[] = {
    {
        "FullName", /* name */
        "s", /* type */
        SBUS_PROPERTY_READABLE | SBUS_PROPERTY_WRITABLE,
        offsetof(struct test_pilot, test_pilot_get_FullName),
        invoke_get_s,
        0, /* not writable */
        NULL, /* no invoker */
    },
    {
        "byte", /* name */
        "y", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct test_pilot, test_pilot_get_byte),
        invoke_get_y,
        0, /* not writable */
        NULL, /* no invoker */
    },
    {
        "boolean", /* name */
        "b", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct test_pilot, test_pilot_get_boolean),
        invoke_get_b,
        0, /* not writable */
        NULL, /* no invoker */
    },
    {
        "int16", /* name */
        "n", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct test_pilot, test_pilot_get_int16),
        invoke_get_n,
        0, /* not writable */
        NULL, /* no invoker */
    },
    {
        "uint16", /* name */
        "q", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct test_pilot, test_pilot_get_uint16),
        invoke_get_q,
        0, /* not writable */
        NULL, /* no invoker */
    },
    {
        "int32", /* name */
        "i", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct test_pilot, test_pilot_get_int32),
        invoke_get_i,
        0, /* not writable */
        NULL, /* no invoker */
    },
    {
        "uint32", /* name */
        "u", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct test_pilot, test_pilot_get_uint32),
        invoke_get_u,
        0, /* not writable */
        NULL, /* no invoker */
    },
    {
        "int64", /* name */
        "x", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct test_pilot, test_pilot_get_int64),
        invoke_get_x,
        0, /* not writable */
        NULL, /* no invoker */
    },
    {
        "uint64", /* name */
        "t", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct test_pilot, test_pilot_get_uint64),
        invoke_get_t,
        0, /* not writable */
        NULL, /* no invoker */
    },
    {
        "double", /* name */
        "d", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct test_pilot, test_pilot_get_double),
        invoke_get_d,
        0, /* not writable */
        NULL, /* no invoker */
    },
    {
        "string", /* name */
        "s", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct test_pilot, test_pilot_get_string),
        invoke_get_s,
        0, /* not writable */
        NULL, /* no invoker */
    },
    {
        "object_path", /* name */
        "o", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct test_pilot, test_pilot_get_object_path),
        invoke_get_o,
        0, /* not writable */
        NULL, /* no invoker */
    },
    {
        "null_string", /* name */
        "s", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct test_pilot, test_pilot_get_null_string),
        invoke_get_s,
        0, /* not writable */
        NULL, /* no invoker */
    },
    {
        "null_path", /* name */
        "o", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct test_pilot, test_pilot_get_null_path),
        invoke_get_o,
        0, /* not writable */
        NULL, /* no invoker */
    },
    {
        "byte_array", /* name */
        "ay", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct test_pilot, test_pilot_get_byte_array),
        invoke_get_ay,
        0, /* not writable */
        NULL, /* no invoker */
    },
    {
        "int16_array", /* name */
        "an", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct test_pilot, test_pilot_get_int16_array),
        invoke_get_an,
        0, /* not writable */
        NULL, /* no invoker */
    },
    {
        "uint16_array", /* name */
        "aq", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct test_pilot, test_pilot_get_uint16_array),
        invoke_get_aq,
        0, /* not writable */
        NULL, /* no invoker */
    },
    {
        "int32_array", /* name */
        "ai", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct test_pilot, test_pilot_get_int32_array),
        invoke_get_ai,
        0, /* not writable */
        NULL, /* no invoker */
    },
    {
        "uint32_array", /* name */
        "au", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct test_pilot, test_pilot_get_uint32_array),
        invoke_get_au,
        0, /* not writable */
        NULL, /* no invoker */
    },
    {
        "int64_array", /* name */
        "ax", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct test_pilot, test_pilot_get_int64_array),
        invoke_get_ax,
        0, /* not writable */
        NULL, /* no invoker */
    },
    {
        "uint64_array", /* name */
        "at", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct test_pilot, test_pilot_get_uint64_array),
        invoke_get_at,
        0, /* not writable */
        NULL, /* no invoker */
    },
    {
        "double_array", /* name */
        "ad", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct test_pilot, test_pilot_get_double_array),
        invoke_get_ad,
        0, /* not writable */
        NULL, /* no invoker */
    },
    {
        "string_array", /* name */
        "as", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct test_pilot, test_pilot_get_string_array),
        invoke_get_as,
        0, /* not writable */
        NULL, /* no invoker */
    },
    {
        "object_path_array", /* name */
        "ao", /* type */
        SBUS_PROPERTY_READABLE,
        offsetof(struct test_pilot, test_pilot_get_object_path_array),
        invoke_get_ao,
        0, /* not writable */
        NULL, /* no invoker */
    },
    { NULL, }
};

/* invokes GetAll for the 'com.planetexpress.Pilot' interface */
static int invoke_test_pilot_get_all(struct sbus_request *dbus_req, void *function_ptr)
{
    DBusMessage *reply;
    dbus_bool_t dbret;
    DBusMessageIter iter;
    DBusMessageIter iter_dict;
    int ret;
    struct sbus_interface *intf = dbus_req->intf;
    const struct sbus_property_meta *property;
    uint16_t *aq_prop_val;
    int aq_prop_len;
    uint16_t *aq_out_val;
    void (*aq_handler)(struct sbus_request *, void *data, uint16_t * *, int *);
    bool b_prop_val;
    dbus_bool_t b_out_val;
    void (*b_handler)(struct sbus_request *, void *data, bool *);
    double d_prop_val;
    double d_out_val;
    void (*d_handler)(struct sbus_request *, void *data, double *);
    const char * *ao_prop_val;
    int ao_prop_len;
    const char * *ao_out_val;
    void (*ao_handler)(struct sbus_request *, void *data, const char * * *, int *);
    int32_t i_prop_val;
    int32_t i_out_val;
    void (*i_handler)(struct sbus_request *, void *data, int32_t *);
    const char * *as_prop_val;
    int as_prop_len;
    const char * *as_out_val;
    void (*as_handler)(struct sbus_request *, void *data, const char * * *, int *);
    const char * o_prop_val;
    const char * o_out_val;
    void (*o_handler)(struct sbus_request *, void *data, const char * *);
    int16_t n_prop_val;
    int16_t n_out_val;
    void (*n_handler)(struct sbus_request *, void *data, int16_t *);
    uint16_t q_prop_val;
    uint16_t q_out_val;
    void (*q_handler)(struct sbus_request *, void *data, uint16_t *);
    uint8_t *ay_prop_val;
    int ay_prop_len;
    uint8_t *ay_out_val;
    void (*ay_handler)(struct sbus_request *, void *data, uint8_t * *, int *);
    const char * s_prop_val;
    const char * s_out_val;
    void (*s_handler)(struct sbus_request *, void *data, const char * *);
    uint32_t u_prop_val;
    uint32_t u_out_val;
    void (*u_handler)(struct sbus_request *, void *data, uint32_t *);
    uint64_t t_prop_val;
    uint64_t t_out_val;
    void (*t_handler)(struct sbus_request *, void *data, uint64_t *);
    int64_t *ax_prop_val;
    int ax_prop_len;
    int64_t *ax_out_val;
    void (*ax_handler)(struct sbus_request *, void *data, int64_t * *, int *);
    uint8_t y_prop_val;
    uint8_t y_out_val;
    void (*y_handler)(struct sbus_request *, void *data, uint8_t *);
    int64_t x_prop_val;
    int64_t x_out_val;
    void (*x_handler)(struct sbus_request *, void *data, int64_t *);
    uint32_t *au_prop_val;
    int au_prop_len;
    uint32_t *au_out_val;
    void (*au_handler)(struct sbus_request *, void *data, uint32_t * *, int *);
    int16_t *an_prop_val;
    int an_prop_len;
    int16_t *an_out_val;
    void (*an_handler)(struct sbus_request *, void *data, int16_t * *, int *);
    double *ad_prop_val;
    int ad_prop_len;
    double *ad_out_val;
    void (*ad_handler)(struct sbus_request *, void *data, double * *, int *);
    int32_t *ai_prop_val;
    int ai_prop_len;
    int32_t *ai_out_val;
    void (*ai_handler)(struct sbus_request *, void *data, int32_t * *, int *);
    uint64_t *at_prop_val;
    int at_prop_len;
    uint64_t *at_out_val;
    void (*at_handler)(struct sbus_request *, void *data, uint64_t * *, int *);

    reply = dbus_message_new_method_return(dbus_req->message);
    if (!reply) return ENOMEM;
    dbus_message_iter_init_append(reply, &iter);
    dbret = dbus_message_iter_open_container(
                                     &iter, DBUS_TYPE_ARRAY,
                                     DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
                                     DBUS_TYPE_STRING_AS_STRING
                                     DBUS_TYPE_VARIANT_AS_STRING
                                     DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
                                     &iter_dict);
    if (!dbret) return ENOMEM;

    property = sbus_meta_find_property(intf->vtable->meta, "FullName");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        s_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (s_handler) {
            (s_handler)(dbus_req, dbus_req->intf->instance_data, &s_prop_val);
            s_out_val = s_prop_val == NULL ? "" : s_prop_val;
            ret = sbus_add_variant_to_dict(&iter_dict, "FullName", DBUS_TYPE_STRING, &s_out_val);
            if (ret != EOK) return ret;
        }
    }

    property = sbus_meta_find_property(intf->vtable->meta, "byte");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        y_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (y_handler) {
            (y_handler)(dbus_req, dbus_req->intf->instance_data, &y_prop_val);
            y_out_val = y_prop_val;
            ret = sbus_add_variant_to_dict(&iter_dict, "byte", DBUS_TYPE_BYTE, &y_out_val);
            if (ret != EOK) return ret;
        }
    }

    property = sbus_meta_find_property(intf->vtable->meta, "boolean");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        b_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (b_handler) {
            (b_handler)(dbus_req, dbus_req->intf->instance_data, &b_prop_val);
            b_out_val = b_prop_val;
            ret = sbus_add_variant_to_dict(&iter_dict, "boolean", DBUS_TYPE_BOOLEAN, &b_out_val);
            if (ret != EOK) return ret;
        }
    }

    property = sbus_meta_find_property(intf->vtable->meta, "int16");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        n_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (n_handler) {
            (n_handler)(dbus_req, dbus_req->intf->instance_data, &n_prop_val);
            n_out_val = n_prop_val;
            ret = sbus_add_variant_to_dict(&iter_dict, "int16", DBUS_TYPE_INT16, &n_out_val);
            if (ret != EOK) return ret;
        }
    }

    property = sbus_meta_find_property(intf->vtable->meta, "uint16");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        q_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (q_handler) {
            (q_handler)(dbus_req, dbus_req->intf->instance_data, &q_prop_val);
            q_out_val = q_prop_val;
            ret = sbus_add_variant_to_dict(&iter_dict, "uint16", DBUS_TYPE_UINT16, &q_out_val);
            if (ret != EOK) return ret;
        }
    }

    property = sbus_meta_find_property(intf->vtable->meta, "int32");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        i_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (i_handler) {
            (i_handler)(dbus_req, dbus_req->intf->instance_data, &i_prop_val);
            i_out_val = i_prop_val;
            ret = sbus_add_variant_to_dict(&iter_dict, "int32", DBUS_TYPE_INT32, &i_out_val);
            if (ret != EOK) return ret;
        }
    }

    property = sbus_meta_find_property(intf->vtable->meta, "uint32");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        u_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (u_handler) {
            (u_handler)(dbus_req, dbus_req->intf->instance_data, &u_prop_val);
            u_out_val = u_prop_val;
            ret = sbus_add_variant_to_dict(&iter_dict, "uint32", DBUS_TYPE_UINT32, &u_out_val);
            if (ret != EOK) return ret;
        }
    }

    property = sbus_meta_find_property(intf->vtable->meta, "int64");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        x_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (x_handler) {
            (x_handler)(dbus_req, dbus_req->intf->instance_data, &x_prop_val);
            x_out_val = x_prop_val;
            ret = sbus_add_variant_to_dict(&iter_dict, "int64", DBUS_TYPE_INT64, &x_out_val);
            if (ret != EOK) return ret;
        }
    }

    property = sbus_meta_find_property(intf->vtable->meta, "uint64");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        t_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (t_handler) {
            (t_handler)(dbus_req, dbus_req->intf->instance_data, &t_prop_val);
            t_out_val = t_prop_val;
            ret = sbus_add_variant_to_dict(&iter_dict, "uint64", DBUS_TYPE_UINT64, &t_out_val);
            if (ret != EOK) return ret;
        }
    }

    property = sbus_meta_find_property(intf->vtable->meta, "double");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        d_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (d_handler) {
            (d_handler)(dbus_req, dbus_req->intf->instance_data, &d_prop_val);
            d_out_val = d_prop_val;
            ret = sbus_add_variant_to_dict(&iter_dict, "double", DBUS_TYPE_DOUBLE, &d_out_val);
            if (ret != EOK) return ret;
        }
    }

    property = sbus_meta_find_property(intf->vtable->meta, "string");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        s_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (s_handler) {
            (s_handler)(dbus_req, dbus_req->intf->instance_data, &s_prop_val);
            s_out_val = s_prop_val == NULL ? "" : s_prop_val;
            ret = sbus_add_variant_to_dict(&iter_dict, "string", DBUS_TYPE_STRING, &s_out_val);
            if (ret != EOK) return ret;
        }
    }

    property = sbus_meta_find_property(intf->vtable->meta, "object_path");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        o_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (o_handler) {
            (o_handler)(dbus_req, dbus_req->intf->instance_data, &o_prop_val);
            o_out_val = o_prop_val == NULL ? "/" : o_prop_val;
            ret = sbus_add_variant_to_dict(&iter_dict, "object_path", DBUS_TYPE_OBJECT_PATH, &o_out_val);
            if (ret != EOK) return ret;
        }
    }

    property = sbus_meta_find_property(intf->vtable->meta, "null_string");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        s_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (s_handler) {
            (s_handler)(dbus_req, dbus_req->intf->instance_data, &s_prop_val);
            s_out_val = s_prop_val == NULL ? "" : s_prop_val;
            ret = sbus_add_variant_to_dict(&iter_dict, "null_string", DBUS_TYPE_STRING, &s_out_val);
            if (ret != EOK) return ret;
        }
    }

    property = sbus_meta_find_property(intf->vtable->meta, "null_path");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        o_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (o_handler) {
            (o_handler)(dbus_req, dbus_req->intf->instance_data, &o_prop_val);
            o_out_val = o_prop_val == NULL ? "/" : o_prop_val;
            ret = sbus_add_variant_to_dict(&iter_dict, "null_path", DBUS_TYPE_OBJECT_PATH, &o_out_val);
            if (ret != EOK) return ret;
        }
    }

    property = sbus_meta_find_property(intf->vtable->meta, "byte_array");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        ay_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (ay_handler) {
            (ay_handler)(dbus_req, dbus_req->intf->instance_data, &ay_prop_val, &ay_prop_len);
            ay_out_val = ay_prop_val;
            ret = sbus_add_array_as_variant_to_dict(&iter_dict, "byte_array", DBUS_TYPE_BYTE, (uint8_t*)ay_out_val, ay_prop_len, sizeof(uint8_t));
            if (ret != EOK) return ret;
        }
    }

    property = sbus_meta_find_property(intf->vtable->meta, "int16_array");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        an_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (an_handler) {
            (an_handler)(dbus_req, dbus_req->intf->instance_data, &an_prop_val, &an_prop_len);
            an_out_val = an_prop_val;
            ret = sbus_add_array_as_variant_to_dict(&iter_dict, "int16_array", DBUS_TYPE_INT16, (uint8_t*)an_out_val, an_prop_len, sizeof(int16_t));
            if (ret != EOK) return ret;
        }
    }

    property = sbus_meta_find_property(intf->vtable->meta, "uint16_array");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        aq_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (aq_handler) {
            (aq_handler)(dbus_req, dbus_req->intf->instance_data, &aq_prop_val, &aq_prop_len);
            aq_out_val = aq_prop_val;
            ret = sbus_add_array_as_variant_to_dict(&iter_dict, "uint16_array", DBUS_TYPE_UINT16, (uint8_t*)aq_out_val, aq_prop_len, sizeof(uint16_t));
            if (ret != EOK) return ret;
        }
    }

    property = sbus_meta_find_property(intf->vtable->meta, "int32_array");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        ai_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (ai_handler) {
            (ai_handler)(dbus_req, dbus_req->intf->instance_data, &ai_prop_val, &ai_prop_len);
            ai_out_val = ai_prop_val;
            ret = sbus_add_array_as_variant_to_dict(&iter_dict, "int32_array", DBUS_TYPE_INT32, (uint8_t*)ai_out_val, ai_prop_len, sizeof(int32_t));
            if (ret != EOK) return ret;
        }
    }

    property = sbus_meta_find_property(intf->vtable->meta, "uint32_array");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        au_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (au_handler) {
            (au_handler)(dbus_req, dbus_req->intf->instance_data, &au_prop_val, &au_prop_len);
            au_out_val = au_prop_val;
            ret = sbus_add_array_as_variant_to_dict(&iter_dict, "uint32_array", DBUS_TYPE_UINT32, (uint8_t*)au_out_val, au_prop_len, sizeof(uint32_t));
            if (ret != EOK) return ret;
        }
    }

    property = sbus_meta_find_property(intf->vtable->meta, "int64_array");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        ax_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (ax_handler) {
            (ax_handler)(dbus_req, dbus_req->intf->instance_data, &ax_prop_val, &ax_prop_len);
            ax_out_val = ax_prop_val;
            ret = sbus_add_array_as_variant_to_dict(&iter_dict, "int64_array", DBUS_TYPE_INT64, (uint8_t*)ax_out_val, ax_prop_len, sizeof(int64_t));
            if (ret != EOK) return ret;
        }
    }

    property = sbus_meta_find_property(intf->vtable->meta, "uint64_array");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        at_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (at_handler) {
            (at_handler)(dbus_req, dbus_req->intf->instance_data, &at_prop_val, &at_prop_len);
            at_out_val = at_prop_val;
            ret = sbus_add_array_as_variant_to_dict(&iter_dict, "uint64_array", DBUS_TYPE_UINT64, (uint8_t*)at_out_val, at_prop_len, sizeof(uint64_t));
            if (ret != EOK) return ret;
        }
    }

    property = sbus_meta_find_property(intf->vtable->meta, "double_array");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        ad_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (ad_handler) {
            (ad_handler)(dbus_req, dbus_req->intf->instance_data, &ad_prop_val, &ad_prop_len);
            ad_out_val = ad_prop_val;
            ret = sbus_add_array_as_variant_to_dict(&iter_dict, "double_array", DBUS_TYPE_DOUBLE, (uint8_t*)ad_out_val, ad_prop_len, sizeof(double));
            if (ret != EOK) return ret;
        }
    }

    property = sbus_meta_find_property(intf->vtable->meta, "string_array");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        as_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (as_handler) {
            (as_handler)(dbus_req, dbus_req->intf->instance_data, &as_prop_val, &as_prop_len);
            as_out_val = as_prop_val;
            ret = sbus_add_array_as_variant_to_dict(&iter_dict, "string_array", DBUS_TYPE_STRING, (uint8_t*)as_out_val, as_prop_len, sizeof(const char *));
            if (ret != EOK) return ret;
        }
    }

    property = sbus_meta_find_property(intf->vtable->meta, "object_path_array");
    if (property != NULL && property->flags & SBUS_PROPERTY_READABLE) {
        ao_handler = VTABLE_FUNC(intf->vtable, property->vtable_offset_get);
        if (ao_handler) {
            (ao_handler)(dbus_req, dbus_req->intf->instance_data, &ao_prop_val, &ao_prop_len);
            ao_out_val = ao_prop_val;
            ret = sbus_add_array_as_variant_to_dict(&iter_dict, "object_path_array", DBUS_TYPE_OBJECT_PATH, (uint8_t*)ao_out_val, ao_prop_len, sizeof(const char *));
            if (ret != EOK) return ret;
        }
    }

    dbret = dbus_message_iter_close_container(&iter, &iter_dict);
    if (!dbret) return ENOMEM;

    return sbus_request_finish(dbus_req, reply);
}

/* interface info for com.planetexpress.Pilot */
const struct sbus_interface_meta test_pilot_meta = {
    "com.planetexpress.Pilot", /* name */
    test_pilot__methods,
    NULL, /* no signals */
    test_pilot__properties,
    invoke_test_pilot_get_all, /* GetAll invoker */
};

/* invokes a handler with a 'bu' DBus signature */
static int invoke_bu_method(struct sbus_request *dbus_req, void *function_ptr)
{
    dbus_bool_t arg_0;
    uint32_t arg_1;
    int (*handler)(struct sbus_request *, void *, bool, uint32_t) = function_ptr;

    if (!sbus_request_parse_or_finish(dbus_req,
                               DBUS_TYPE_BOOLEAN, &arg_0,
                               DBUS_TYPE_UINT32, &arg_1,
                               DBUS_TYPE_INVALID)) {
         return EOK; /* request handled */
    }

    return (handler)(dbus_req, dbus_req->intf->instance_data,
                     arg_0,
                     arg_1);
}

/* invokes a handler with a 's' DBus signature */
static int invoke_s_method(struct sbus_request *dbus_req, void *function_ptr)
{
    const char * arg_0;
    int (*handler)(struct sbus_request *, void *, const char *) = function_ptr;

    if (!sbus_request_parse_or_finish(dbus_req,
                               DBUS_TYPE_STRING, &arg_0,
                               DBUS_TYPE_INVALID)) {
         return EOK; /* request handled */
    }

    return (handler)(dbus_req, dbus_req->intf->instance_data,
                     arg_0);
}

/* invokes a handler with a 'u' DBus signature */
static int invoke_u_method(struct sbus_request *dbus_req, void *function_ptr)
{
    uint32_t arg_0;
    int (*handler)(struct sbus_request *, void *, uint32_t) = function_ptr;

    if (!sbus_request_parse_or_finish(dbus_req,
                               DBUS_TYPE_UINT32, &arg_0,
                               DBUS_TYPE_INVALID)) {
         return EOK; /* request handled */
    }

    return (handler)(dbus_req, dbus_req->intf->instance_data,
                     arg_0);
}

/* invokes a handler with a 'ybnqiuxtdsoayanaqaiauaxatadasao' DBus signature */
static int invoke_ybnqiuxtdsoayanaqaiauaxatadasao_method(struct sbus_request *dbus_req, void *function_ptr)
{
    uint8_t arg_0;
    dbus_bool_t arg_1;
    int16_t arg_2;
    uint16_t arg_3;
    int32_t arg_4;
    uint32_t arg_5;
    int64_t arg_6;
    uint64_t arg_7;
    double arg_8;
    const char * arg_9;
    const char * arg_10;
    uint8_t *arg_11;
    int len_11;
    int16_t *arg_12;
    int len_12;
    uint16_t *arg_13;
    int len_13;
    int32_t *arg_14;
    int len_14;
    uint32_t *arg_15;
    int len_15;
    int64_t *arg_16;
    int len_16;
    uint64_t *arg_17;
    int len_17;
    double *arg_18;
    int len_18;
    const char * *arg_19;
    int len_19;
    const char * *arg_20;
    int len_20;
    int (*handler)(struct sbus_request *, void *, uint8_t, bool, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t, double, const char *, const char *, uint8_t[], int, int16_t[], int, uint16_t[], int, int32_t[], int, uint32_t[], int, int64_t[], int, uint64_t[], int, double[], int, const char *[], int, const char *[], int) = function_ptr;

    if (!sbus_request_parse_or_finish(dbus_req,
                               DBUS_TYPE_BYTE, &arg_0,
                               DBUS_TYPE_BOOLEAN, &arg_1,
                               DBUS_TYPE_INT16, &arg_2,
                               DBUS_TYPE_UINT16, &arg_3,
                               DBUS_TYPE_INT32, &arg_4,
                               DBUS_TYPE_UINT32, &arg_5,
                               DBUS_TYPE_INT64, &arg_6,
                               DBUS_TYPE_UINT64, &arg_7,
                               DBUS_TYPE_DOUBLE, &arg_8,
                               DBUS_TYPE_STRING, &arg_9,
                               DBUS_TYPE_OBJECT_PATH, &arg_10,
                               DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &arg_11, &len_11,
                               DBUS_TYPE_ARRAY, DBUS_TYPE_INT16, &arg_12, &len_12,
                               DBUS_TYPE_ARRAY, DBUS_TYPE_UINT16, &arg_13, &len_13,
                               DBUS_TYPE_ARRAY, DBUS_TYPE_INT32, &arg_14, &len_14,
                               DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &arg_15, &len_15,
                               DBUS_TYPE_ARRAY, DBUS_TYPE_INT64, &arg_16, &len_16,
                               DBUS_TYPE_ARRAY, DBUS_TYPE_UINT64, &arg_17, &len_17,
                               DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE, &arg_18, &len_18,
                               DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &arg_19, &len_19,
                               DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &arg_20, &len_20,
                               DBUS_TYPE_INVALID)) {
         return EOK; /* request handled */
    }

    return (handler)(dbus_req, dbus_req->intf->instance_data,
                     arg_0,
                     arg_1,
                     arg_2,
                     arg_3,
                     arg_4,
                     arg_5,
                     arg_6,
                     arg_7,
                     arg_8,
                     arg_9,
                     arg_10,
                     arg_11,
                     len_11,
                     arg_12,
                     len_12,
                     arg_13,
                     len_13,
                     arg_14,
                     len_14,
                     arg_15,
                     len_15,
                     arg_16,
                     len_16,
                     arg_17,
                     len_17,
                     arg_18,
                     len_18,
                     arg_19,
                     len_19,
                     arg_20,
                     len_20);
}

/* invokes a getter with an array of 'uint16_t' DBus type */
static int invoke_get_aq(struct sbus_request *dbus_req, void *function_ptr)
{
    uint16_t *prop_val;
    int prop_len;
    uint16_t *out_val;

    void (*handler)(struct sbus_request *, void *data, uint16_t * *, int *) = function_ptr;

    (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val, &prop_len);

    out_val = prop_val;
    return sbus_request_return_array_as_variant(dbus_req, DBUS_TYPE_UINT16, (uint8_t*)out_val, prop_len, sizeof(uint16_t));
}

/* invokes a getter with a 'dbus_bool_t' DBus type */
static int invoke_get_b(struct sbus_request *dbus_req, void *function_ptr)
{
    bool prop_val;
    dbus_bool_t out_val;

    void (*handler)(struct sbus_request *, void *data, bool *) = function_ptr;

    (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val);

    out_val = prop_val;
    return sbus_request_return_as_variant(dbus_req, DBUS_TYPE_BOOLEAN, &out_val);
}

/* invokes a getter with a 'double' DBus type */
static int invoke_get_d(struct sbus_request *dbus_req, void *function_ptr)
{
    double prop_val;
    double out_val;

    void (*handler)(struct sbus_request *, void *data, double *) = function_ptr;

    (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val);

    out_val = prop_val;
    return sbus_request_return_as_variant(dbus_req, DBUS_TYPE_DOUBLE, &out_val);
}

/* invokes a getter with an array of 'const char *' DBus type */
static int invoke_get_ao(struct sbus_request *dbus_req, void *function_ptr)
{
    const char * *prop_val;
    int prop_len;
    const char * *out_val;

    void (*handler)(struct sbus_request *, void *data, const char * * *, int *) = function_ptr;

    (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val, &prop_len);

    out_val = prop_val;
    return sbus_request_return_array_as_variant(dbus_req, DBUS_TYPE_OBJECT_PATH, (uint8_t*)out_val, prop_len, sizeof(const char *));
}

/* invokes a getter with a 'int32_t' DBus type */
static int invoke_get_i(struct sbus_request *dbus_req, void *function_ptr)
{
    int32_t prop_val;
    int32_t out_val;

    void (*handler)(struct sbus_request *, void *data, int32_t *) = function_ptr;

    (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val);

    out_val = prop_val;
    return sbus_request_return_as_variant(dbus_req, DBUS_TYPE_INT32, &out_val);
}

/* invokes a getter with an array of 'const char *' DBus type */
static int invoke_get_as(struct sbus_request *dbus_req, void *function_ptr)
{
    const char * *prop_val;
    int prop_len;
    const char * *out_val;

    void (*handler)(struct sbus_request *, void *data, const char * * *, int *) = function_ptr;

    (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val, &prop_len);

    out_val = prop_val;
    return sbus_request_return_array_as_variant(dbus_req, DBUS_TYPE_STRING, (uint8_t*)out_val, prop_len, sizeof(const char *));
}

/* invokes a getter with a 'const char *' DBus type */
static int invoke_get_o(struct sbus_request *dbus_req, void *function_ptr)
{
    const char * prop_val;
    const char * out_val;

    void (*handler)(struct sbus_request *, void *data, const char * *) = function_ptr;

    (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val);

    out_val = prop_val == NULL ? "/" : prop_val;
    return sbus_request_return_as_variant(dbus_req, DBUS_TYPE_OBJECT_PATH, &out_val);
}

/* invokes a getter with a 'int16_t' DBus type */
static int invoke_get_n(struct sbus_request *dbus_req, void *function_ptr)
{
    int16_t prop_val;
    int16_t out_val;

    void (*handler)(struct sbus_request *, void *data, int16_t *) = function_ptr;

    (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val);

    out_val = prop_val;
    return sbus_request_return_as_variant(dbus_req, DBUS_TYPE_INT16, &out_val);
}

/* invokes a getter with a 'uint16_t' DBus type */
static int invoke_get_q(struct sbus_request *dbus_req, void *function_ptr)
{
    uint16_t prop_val;
    uint16_t out_val;

    void (*handler)(struct sbus_request *, void *data, uint16_t *) = function_ptr;

    (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val);

    out_val = prop_val;
    return sbus_request_return_as_variant(dbus_req, DBUS_TYPE_UINT16, &out_val);
}

/* invokes a getter with an array of 'uint8_t' DBus type */
static int invoke_get_ay(struct sbus_request *dbus_req, void *function_ptr)
{
    uint8_t *prop_val;
    int prop_len;
    uint8_t *out_val;

    void (*handler)(struct sbus_request *, void *data, uint8_t * *, int *) = function_ptr;

    (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val, &prop_len);

    out_val = prop_val;
    return sbus_request_return_array_as_variant(dbus_req, DBUS_TYPE_BYTE, (uint8_t*)out_val, prop_len, sizeof(uint8_t));
}

/* invokes a getter with a 'const char *' DBus type */
static int invoke_get_s(struct sbus_request *dbus_req, void *function_ptr)
{
    const char * prop_val;
    const char * out_val;

    void (*handler)(struct sbus_request *, void *data, const char * *) = function_ptr;

    (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val);

    out_val = prop_val == NULL ? "" : prop_val;
    return sbus_request_return_as_variant(dbus_req, DBUS_TYPE_STRING, &out_val);
}

/* invokes a getter with a 'uint32_t' DBus type */
static int invoke_get_u(struct sbus_request *dbus_req, void *function_ptr)
{
    uint32_t prop_val;
    uint32_t out_val;

    void (*handler)(struct sbus_request *, void *data, uint32_t *) = function_ptr;

    (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val);

    out_val = prop_val;
    return sbus_request_return_as_variant(dbus_req, DBUS_TYPE_UINT32, &out_val);
}

/* invokes a getter with a 'uint64_t' DBus type */
static int invoke_get_t(struct sbus_request *dbus_req, void *function_ptr)
{
    uint64_t prop_val;
    uint64_t out_val;

    void (*handler)(struct sbus_request *, void *data, uint64_t *) = function_ptr;

    (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val);

    out_val = prop_val;
    return sbus_request_return_as_variant(dbus_req, DBUS_TYPE_UINT64, &out_val);
}

/* invokes a getter with an array of 'int64_t' DBus type */
static int invoke_get_ax(struct sbus_request *dbus_req, void *function_ptr)
{
    int64_t *prop_val;
    int prop_len;
    int64_t *out_val;

    void (*handler)(struct sbus_request *, void *data, int64_t * *, int *) = function_ptr;

    (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val, &prop_len);

    out_val = prop_val;
    return sbus_request_return_array_as_variant(dbus_req, DBUS_TYPE_INT64, (uint8_t*)out_val, prop_len, sizeof(int64_t));
}

/* invokes a getter with a 'uint8_t' DBus type */
static int invoke_get_y(struct sbus_request *dbus_req, void *function_ptr)
{
    uint8_t prop_val;
    uint8_t out_val;

    void (*handler)(struct sbus_request *, void *data, uint8_t *) = function_ptr;

    (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val);

    out_val = prop_val;
    return sbus_request_return_as_variant(dbus_req, DBUS_TYPE_BYTE, &out_val);
}

/* invokes a getter with a 'int64_t' DBus type */
static int invoke_get_x(struct sbus_request *dbus_req, void *function_ptr)
{
    int64_t prop_val;
    int64_t out_val;

    void (*handler)(struct sbus_request *, void *data, int64_t *) = function_ptr;

    (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val);

    out_val = prop_val;
    return sbus_request_return_as_variant(dbus_req, DBUS_TYPE_INT64, &out_val);
}

/* invokes a getter with an array of 'uint32_t' DBus type */
static int invoke_get_au(struct sbus_request *dbus_req, void *function_ptr)
{
    uint32_t *prop_val;
    int prop_len;
    uint32_t *out_val;

    void (*handler)(struct sbus_request *, void *data, uint32_t * *, int *) = function_ptr;

    (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val, &prop_len);

    out_val = prop_val;
    return sbus_request_return_array_as_variant(dbus_req, DBUS_TYPE_UINT32, (uint8_t*)out_val, prop_len, sizeof(uint32_t));
}

/* invokes a getter with an array of 'int16_t' DBus type */
static int invoke_get_an(struct sbus_request *dbus_req, void *function_ptr)
{
    int16_t *prop_val;
    int prop_len;
    int16_t *out_val;

    void (*handler)(struct sbus_request *, void *data, int16_t * *, int *) = function_ptr;

    (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val, &prop_len);

    out_val = prop_val;
    return sbus_request_return_array_as_variant(dbus_req, DBUS_TYPE_INT16, (uint8_t*)out_val, prop_len, sizeof(int16_t));
}

/* invokes a getter with an array of 'double' DBus type */
static int invoke_get_ad(struct sbus_request *dbus_req, void *function_ptr)
{
    double *prop_val;
    int prop_len;
    double *out_val;

    void (*handler)(struct sbus_request *, void *data, double * *, int *) = function_ptr;

    (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val, &prop_len);

    out_val = prop_val;
    return sbus_request_return_array_as_variant(dbus_req, DBUS_TYPE_DOUBLE, (uint8_t*)out_val, prop_len, sizeof(double));
}

/* invokes a getter with an array of 'int32_t' DBus type */
static int invoke_get_ai(struct sbus_request *dbus_req, void *function_ptr)
{
    int32_t *prop_val;
    int prop_len;
    int32_t *out_val;

    void (*handler)(struct sbus_request *, void *data, int32_t * *, int *) = function_ptr;

    (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val, &prop_len);

    out_val = prop_val;
    return sbus_request_return_array_as_variant(dbus_req, DBUS_TYPE_INT32, (uint8_t*)out_val, prop_len, sizeof(int32_t));
}

/* invokes a getter with an array of 'uint64_t' DBus type */
static int invoke_get_at(struct sbus_request *dbus_req, void *function_ptr)
{
    uint64_t *prop_val;
    int prop_len;
    uint64_t *out_val;

    void (*handler)(struct sbus_request *, void *data, uint64_t * *, int *) = function_ptr;

    (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val, &prop_len);

    out_val = prop_val;
    return sbus_request_return_array_as_variant(dbus_req, DBUS_TYPE_UINT64, (uint8_t*)out_val, prop_len, sizeof(uint64_t));
}