[PATCH 04/48] qom: define an Aliased interface

["Daniel P. Berrangé" <berrange@redhat.com>]

All QOM types must have a globally unique typename, however, for
user convenience, some might also want to have aliases which are
permitted to be ambiguous. Define an "Aliased" interface which
can be implemented by types which want to support aliases.

When resolving an alias, if there are multiple QOM types with a
matching alias this is considered an error. Ambiguity can be
resolved by matching system state, with the selected target
being the currently implemented filter.

Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
---
 include/qom/object_interfaces.h | 77 +++++++++++++++++++++++++++++++++
 qom/object_interfaces.c         | 57 ++++++++++++++++++++++++
 2 files changed, 134 insertions(+)

diff --git a/include/qom/object_interfaces.h b/include/qom/object_interfaces.h
index d222a3d7481..010e37d63f7 100644
--- a/include/qom/object_interfaces.h
+++ b/include/qom/object_interfaces.h
@@ -27,6 +27,17 @@ DECLARE_CLASS_CHECKERS(TargetSpecificClass, TARGET_SPECIFIC,
 
 typedef struct TargetSpecific TargetSpecific;
 
+#define TYPE_ALIASED "aliased"
+
+typedef struct AliasedClass AliasedClass;
+DECLARE_CLASS_CHECKERS(AliasedClass, ALIASED,
+                       TYPE_ALIASED)
+#define ALIASED(obj) \
+     INTERFACE_CHECK(Aliased, (obj), \
+                     TYPE_ALIASED)
+
+typedef struct Aliased Aliased;
+
 /**
  * UserCreatableClass:
  * @parent_class: the base class
@@ -242,4 +253,70 @@ bool target_specific_class_creatable(ObjectClass *oc);
 ObjectClass *target_specific_class_check(ObjectClass *oc,
                                          Error **errp);
 
+/**
+ * AliasedClass
+ * @parent_class: the base class
+ *
+ * Interface for classes that want to declare they have aliases
+ * for their primary type name.
+ *
+ * While QOM type names are required to be unique, aliases allow
+ * for ambiguity across classes. The ambiguity is resolved at
+ * runtime based on system state, typically by the selection of
+ * a specific target. If ambiguity cannot be resolved, the user
+ * will need to use the unique QOM type name instead.
+ */
+struct AliasedClass {
+    InterfaceClass parent_class;
+
+    const char *const *aliases; /* NULL terminated list of typenames */
+};
+
+
+/**
+ * aliased_class_matches:
+ * @oc: the class object to check
+ * @typename: the possible type name alias to check
+ *
+ * Determine whether @oc implements the Aliased interface
+ * and has declared an alias that matches @typename.
+ *
+ * Returns: true if @oc implements Aliased and has an
+ * alias named @typename, false otherwise
+ */
+bool aliased_class_matches(ObjectClass *oc,
+                           const char *typename);
+
+
+/**
+ * aliased_class_resolve:
+ * @implements: a parent type to validate
+ * @typename: a type name to search for
+ * @errp: pointer to a NULL initialized error object
+ *
+ * Search all registered QOM types that implement
+ * both @implements and the Aliased interface for
+ * one that declares an alias @typename.
+ *
+ * If there is a single QOM class with a matching alias
+ * it will be returned.
+ *
+ * If there are multiple QOM classes with a matching
+ * alias an error will be raised about the ambiguous
+ * match.
+ *
+ * If the QOM class also implements the TargetSpecific
+ * interface and the current system target does not
+ * match the declared supported targets, aliases for
+ * that QOM class will be ignored. This is usually
+ * sufficient to resolve ambiguity between types.
+ *
+ * Returns: a unique QOM class with an alias @typename,
+ * or NULL if zero or multiple aliases match, with @errp
+ * set.
+ */
+ ObjectClass *aliased_class_resolve(const char *implements,
+                                    const char *typename,
+                                    Error **errp);
+
 #endif
diff --git a/qom/object_interfaces.c b/qom/object_interfaces.c
index f523a55b93a..136629f88b2 100644
--- a/qom/object_interfaces.c
+++ b/qom/object_interfaces.c
@@ -305,6 +305,57 @@ ObjectClass *target_specific_class_check(ObjectClass *oc,
 }
 
 
+bool aliased_class_matches(ObjectClass *oc, const char *typename)
+{
+    AliasedClass *alc =
+        (AliasedClass *)object_class_dynamic_cast(
+            oc, TYPE_ALIASED);
+
+    return alc && alc->aliases && g_strv_contains(alc->aliases, typename);
+}
+
+
+ObjectClass *aliased_class_resolve(const char *implements,
+                                   const char *typename,
+                                   Error **errp)
+{
+    g_autoptr(GSList) objs = object_class_get_list(implements, false);
+    GSList *el;
+    ObjectClass *ret = NULL;
+    g_autofree const char **matches = NULL;
+    size_t nmatches = 0;
+
+    for (el = objs; el; el = el->next) {
+        ObjectClass *oc = el->data;
+
+        if (aliased_class_matches(oc, typename) &&
+            target_specific_class_creatable(oc)) {
+            matches = g_renew(const char *, matches, nmatches + 2);
+            matches[nmatches] = object_class_get_name(oc);
+            matches[nmatches + 1] = NULL;
+
+            ret = oc;
+        }
+    }
+
+    if (nmatches > 1) {
+        g_autofree char *matchesstr = g_strjoinv(", ", (char **)matches);
+        error_setg(errp,
+                   "Object alias '%s' is not unique, matches %s",
+                   typename, matchesstr);
+        return NULL;
+    }
+
+    if (!ret) {
+        error_setg(errp, "Object '%s' not found, no child of '%s' registered",
+                   typename, implements);
+        return NULL;
+    }
+
+    return ret;
+}
+
+
 static void register_types(void)
 {
     static const TypeInfo uc_interface_info = {
@@ -317,9 +368,15 @@ static void register_types(void)
         .parent        = TYPE_INTERFACE,
         .class_size = sizeof(TargetSpecificClass),
     };
+    static const TypeInfo al_interface_info = {
+        .name          = TYPE_ALIASED,
+        .parent        = TYPE_INTERFACE,
+        .class_size = sizeof(AliasedClass),
+    };
 
     type_register_static(&uc_interface_info);
     type_register_static(&ts_interface_info);
+    type_register_static(&al_interface_info);
 }
 
 type_init(register_types)
-- 
2.56.1