test-plug.c

   1 /** stub **/
   2 #include "plug.h"
   3
   4 static int nb_module_init;
   5 static void (*module_initfn[100])(void);
   6
   7 void register_module_init(void (*fn)(void), module_init_type type)
   8 {
   9     int i = nb_module_init++;
  10     module_initfn[i] = fn;
  11 }
  12 typedef struct TestPlug
  13 {
  14     Plug parent;
  15     int x;
  16     Plug child;
  17     Plug *slot;
  18 } TestPlug;
  19
  20 #define TYPE_TEST_PLUG "test-plug"
  21 #define TEST_PLUG(obj) TYPE_CHECK(TestPlug, obj, TYPE_TEST_PLUG)
  22
  23 static void test_plug_initialize(TestPlug *obj, const char *id)
  24 {
  25     type_initialize(obj, TYPE_TEST_PLUG, id);
  26 }
  27
  28 static int64_t test_plug_get_x(Plug *obj)
  29 {
  30     TestPlug *tp = TEST_PLUG(obj);
  31
  32     return tp->x;
  33 }
  34
  35 static void test_plug_set_x(Plug *obj, int64_t value)
  36 {
  37     TestPlug *tp = TEST_PLUG(obj);
  38     tp->x = value;
  39 }
  40
  41 static void test_plug_initfn(TypeInstance *obj)
  42 {
  43     TestPlug *tp = TEST_PLUG(obj);
  44     char name[32];
  45
  46     snprintf(name, sizeof(name), "%s::child", obj->id);
  47     plug_initialize(&tp->child, name);
  48
  49     tp->x = 42;
  50     plug_add_property_int(PLUG(tp), "x", test_plug_get_x, test_plug_set_x, PROP_F_READWRITE);
  51     plug_add_property_plug(PLUG(tp), "child", &tp->child, TYPE_PLUG);
  52     plug_add_property_socket(PLUG(tp), "slot", &tp->slot, TYPE_PLUG, PROP_F_READWRITE | PROP_F_MASKABLE);
  53 }
  54
  55 static const TypeInfo test_plug_type_info = {
  56     .name = TYPE_TEST_PLUG,
  57     .parent = TYPE_PLUG,
  58     .instance_size = sizeof(TestPlug),
  59     .instance_init = test_plug_initfn,
  60 };
  61
  62 static void register_devices(void)
  63 {
  64     type_register_static(&test_plug_type_info);
  65 }
  66
  67 device_init(register_devices);
  68
  69 //////////////////////////////
  70
  71 typedef struct StringInputVisitor
  72 {
  73     Visitor parent;
  74     const char *value;
  75 } StringInputVisitor;
  76
  77 static void string_input_visitor_int(Visitor *v, int64_t *obj, const char *name, Error **errp)
  78 {
  79     StringInputVisitor *sv = container_of(v, StringInputVisitor, parent);
  80     *obj = atoi(sv->value);
  81 }
  82
  83 static void string_input_visitor_str(Visitor *v, char **obj, const char *name, Error **errp)
  84 {
  85     StringInputVisitor *sv = container_of(v, StringInputVisitor, parent);
  86     *obj = qemu_strdup(sv->value);
  87 }
  88
  89 static void string_input_visitor_init(StringInputVisitor *sv, const char *value)
  90 {
  91     memset(sv, 0, sizeof(*sv));
  92     sv->parent.type_int = string_input_visitor_int;
  93     sv->parent.type_str = string_input_visitor_str;
  94     sv->value = value;
  95 }
  96
  97 typedef struct StringOutputVisitor
  98 {
  99     Visitor parent;
 100     char value[256];
 101 } StringOutputVisitor;
 102
 103 static void string_output_visitor_int(Visitor *v, int64_t *obj, const char *name, Error **errp)
 104 {
 105     StringOutputVisitor *sv = container_of(v, StringOutputVisitor, parent);
 106     snprintf(sv->value, sizeof(sv->value), "%" PRId64, *obj);
 107 }
 108
 109 static void string_output_visitor_str(Visitor *v, char **obj, const char *name, Error **errp)
 110 {
 111     StringOutputVisitor *sv = container_of(v, StringOutputVisitor, parent);
 112
 113     snprintf(sv->value, sizeof(sv->value), "%s", *obj);
 114 }
 115
 116 static void string_output_visitor_init(StringOutputVisitor *sv)
 117 {
 118     memset(sv, 0, sizeof(*sv));
 119     sv->parent.type_int = string_output_visitor_int;
 120     sv->parent.type_str = string_output_visitor_str;
 121 }
 122
 123 static void print_props(Plug *plug, const char *name, const char *typename, int flags, void *opaque)
 124 {
 125     StringOutputVisitor sov;
 126
 127     string_output_visitor_init(&sov);
 128     plug_get_property(plug, name, &sov.parent, NULL);
 129     printf("`%s.%s' is a `%s' and has a value of `%s', %s\n", plug_get_id(plug), name, typename, sov.value,
 130            ((flags & PROP_F_READWRITE) == PROP_F_READWRITE) ? "rw" : "ro"); // FIXME
 131 }
 132
 133 int main(int argc, char **argv)
 134 {
 135     TestPlug tp;
 136     int i;
 137     StringInputVisitor siv;
 138     StringOutputVisitor sov;
 139
 140     for (i = 0; i < nb_module_init; i++) {
 141         module_initfn[i]();
 142     }
 143
 144     string_input_visitor_init(&siv, "82");
 145     string_output_visitor_init(&sov);
 146
 147     test_plug_initialize(&tp, "tp");
 148
 149     printf("x - %" PRId64 "\n", test_plug_get_x(PLUG(&tp)));
 150     plug_set_property(PLUG(&tp), "x", &siv.parent, NULL);
 151
 152     printf("x - %" PRId64 "\n", test_plug_get_x(PLUG(&tp)));
 153
 154     plug_get_property(PLUG(&tp), "child", &sov.parent, NULL);
 155     printf("child - %s\n", sov.value);
 156
 157     plug_get_property(PLUG(&tp), "slot", &sov.parent, NULL);
 158     printf("slot - %s\n", sov.value);
 159
 160     string_input_visitor_init(&siv, "tp::child");
 161     plug_set_property(PLUG(&tp), "slot", &siv.parent, NULL);
 162
 163     plug_get_property(PLUG(&tp), "slot", &sov.parent, NULL);
 164     printf("slot - %s\n", sov.value);
 165
 166     printf("tp::child - %p\n", &tp.child);
 167     printf("tp.slot - %p\n", tp.slot);
 168
 169     plug_foreach_property(PLUG(&tp), print_props, NULL);
 170
 171     assert(&tp.child == tp.slot);
 172
 173     return 0;
 174 }