Add support for multivalued designator slots.

Now that we have the TypeDesignatorResolver helper class, we can plug it
into the ObjectConverter to easily deal with both single- and
multi-valued designator slots.

Author: gouttegd

core/src/main/java/org/incenp/linkml/core/ObjectConverter.java

@@ -34,8 +34,6 @@
 
 package org.incenp.linkml.core;
 
-import java.net.URI;
-import java.net.URISyntaxException;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -57,7 +55,6 @@ public class ObjectConverter implements IConverter {
     private final static String STRING_EXPECTED = "Invalid value type, string expected";
     private final static String OBJECT_EXPECTED = "Invalid value type, '%s' expected";
     private final static String NO_IDENTIFIER = "Missing identifier for type '%s'";
-    private final static String INVALID_CLASS_URI = "Missing or invalid class URI for type '%s'";
 
     protected ClassInfo klass;
     private PrefixDeclarationExtractor prefixExtractor;
@@ -166,35 +163,23 @@ public Object convert(Map<String, Object> raw, ConverterContext ctx) throws Link
             Slot designatorSlot = klass.getTypeDesignatorSlot();
             Object designator = raw.get(designatorSlot.getLinkMLName());
             if ( designator != null ) {
-                // FIXME: LinkML allows the type designator slot to be multivalued, in which
-                // case we should pick "the most specific class" among the classes listed (what
-                // to do if the list contains several classes at the same inheritance level is
-                // unspecified). Currently we only support the single-valued case.
-                String designatedName = ctx.getConverter(designatorSlot).convert(designator, ctx).toString();
-                Class<?> designatedType = null;
-
-                // First try looking by class URI. This will only work if the designated class
-                // has already been "seen" by the ClassInfo cache.
-                ClassInfo ci = ClassInfo.get(designatedName);
-                if ( ci != null ) {
-                    designatedType = ci.getType();
-                } else {
-                    // No luck, so look up by class name.
-                    // FIXME: We assume that all classes derived from the initial class will live in
-                    // the same Java package. This is not ideal but, if all we have to refer to a
-                    // class is an unqualified name, it is not an unreasonable assumption.
-                    String pkgName = getType().getPackage().getName();
-                    try {
-                        designatedType = Class.forName(pkgName + "." + designatedName);
-                    } catch ( ClassNotFoundException e ) {
-                        // Do nothing, simply fallback to the type we were originally expecting. This is
-                        // so an application has a chance to process data that would use an unknown
-                        // subclass (possibly defined by an extension).
+                TypeDesignatorResolver resolver = new TypeDesignatorResolver();
+                IConverter designatorConverter = ctx.getConverter(designatorSlot);
+                ClassInfo designatedClass = null;
+
+                if ( designatorSlot.isMultivalued() ) {
+                    ArrayList<String> designatorNames = new ArrayList<>();
+                    for ( Object rawDesignator : toList(designator) ) {
+                        designatorNames.add(designatorConverter.convert(rawDesignator, ctx).toString());
                     }
+                    designatedClass = resolver.resolve(designatorNames, klass);
+                } else {
+                    String designatedName = designatorConverter.convert(designator, ctx).toString();
+                    designatedClass = resolver.resolve(designatedName, klass);
                 }
 
-                if ( designatedType != null ) {
-                    conv = (ObjectConverter) ctx.getConverter(designatedType);
+                if ( designatedClass != null ) {
+                    conv = (ObjectConverter) ctx.getConverter(designatedClass.getType());
                 }
             }
         }
@@ -354,22 +339,11 @@ public Map<String, Object> serialise(Object object, boolean withIdentifier, Conv
             Object slotValue = slot.getValue(object);
             if ( slotValue == null && slot.isTypeDesignator() ) {
                 // Set the slot to the actual type name
-                if ( slot.getInnerType().equals(URI.class) ) {
-                    // URI-typed designator slot, it requires the class URI
-                    try {
-                        slotValue = new URI(klass.getURI());
-                    } catch ( NullPointerException | URISyntaxException e ) {
-                        throw new LinkMLInternalError(String.format(INVALID_CLASS_URI, getType().getName()));
-                    }
-                } else if ( ctx.getConverter(slot) instanceof CurieConverter ) {
-                    // URI-or-CURIE typed designator slot, also requiring the class URI
-                    if ( klass.getURI() == null ) {
-                        throw new LinkMLInternalError(String.format(INVALID_CLASS_URI, getType().getName()));
-                    }
-                    slotValue = klass.getURI();
+                TypeDesignatorResolver resolver = new TypeDesignatorResolver();
+                if ( slot.isMultivalued() ) {
+                    slotValue = resolver.getDesignators(klass);
                 } else {
-                    // Assume a name-based type designator slot
-                    slotValue = getType().getSimpleName();
+                    slotValue = resolver.getDesignator(klass);
                 }
             } else if ( slotValue == null ) {
                 // Ignore all other empty slots

core/src/test/java/org/incenp/linkml/core/ObjectConverterTest.java

@@ -43,9 +43,11 @@
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
 import java.util.ArrayList;
+import java.util.List;
 import java.util.Map;
 
 import org.incenp.linkml.core.sample.BaseCurieSelfDesignatedClass;
+import org.incenp.linkml.core.sample.BaseMultiSelfDesignatedClass;
 import org.incenp.linkml.core.sample.BaseSelfDesignatedClass;
 import org.incenp.linkml.core.sample.BaseURISelfDesignatedClass;
 import org.incenp.linkml.core.sample.ClassWithCustomConverter;
@@ -57,6 +59,7 @@
 import org.incenp.linkml.core.sample.ContainerOfSimpleDicts;
 import org.incenp.linkml.core.sample.ContainerOfSimpleObjects;
 import org.incenp.linkml.core.sample.DerivedCurieSelfDesignatedClass;
+import org.incenp.linkml.core.sample.DerivedMultiSelfDesignatedClass;
 import org.incenp.linkml.core.sample.DerivedSelfDesignatedClass;
 import org.incenp.linkml.core.sample.DerivedURISelfDesignatedClass;
 import org.incenp.linkml.core.sample.ExtensibleSimpleClass;
@@ -424,6 +427,33 @@ void testUnknownTypeDesignator() throws IOException, LinkMLRuntimeException {
         roundtrip(dsdc);
     }
 
+    @Test
+    void testMultivaluedTypeDesignator() throws IOException, LinkMLRuntimeException {
+        String text = "foo: A string\nbar: Another string\ntype:\n - BaseMultiSelfDesignatedClass\n - DerivedMultiSelfDesignatedClass\n";
+        BaseMultiSelfDesignatedClass bmsdc = parseString(text, BaseMultiSelfDesignatedClass.class);
+
+        Assertions.assertInstanceOf(DerivedMultiSelfDesignatedClass.class, bmsdc);
+        DerivedMultiSelfDesignatedClass derived = (DerivedMultiSelfDesignatedClass) bmsdc;
+        Assertions.assertEquals("A string", derived.getFoo());
+        Assertions.assertEquals("Another string", derived.getBar());
+
+        roundtrip(derived);
+
+        // Try serialising again, but without the type designator; the slot should still
+        // be set in the serialised object
+        derived.setType(null);
+        ObjectConverter conv = (ObjectConverter) ctx.getConverter(derived.getClass());
+        Map<String, Object> raw = conv.serialise(derived, true, ctx);
+        Object rawType = raw.get("type");
+        Assertions.assertNotNull(rawType);
+        Assertions.assertInstanceOf(List.class, rawType);
+        @SuppressWarnings("unchecked")
+        List<String> types = (List<String>) rawType;
+        Assertions.assertEquals(2, types.size());
+        Assertions.assertEquals("BaseMultiSelfDesignatedClass", types.get(0));
+        Assertions.assertEquals("DerivedMultiSelfDesignatedClass", types.get(1));
+    }
+
     @Test
     void testReferenceToIRIIdentifiers() throws IOException, LinkMLRuntimeException {
         ctx.addPrefix("PFX", "https://example.org/");

core/src/test/lombok/org/incenp/linkml/core/sample/BaseMultiSelfDesignatedClass.java

@@ -0,0 +1,62 @@
+/*
+ * LinkML-Java - LinkML library for Java
+ * Copyright © 2026 Damien Goutte-Gattat
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   (1) Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ *   (2) Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ *   (3) Neither the name of the copyright holder nor the names its
+ *   contributors may be used to endorse or promote products derived
+ *   from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
+ * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.incenp.linkml.core.sample;
+
+import java.util.List;
+import java.util.Map;
+
+import org.incenp.linkml.core.annotations.ExtensionHolder;
+import org.incenp.linkml.core.annotations.TypeDesignator;
+
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+
+/**
+ * An example of a class that has a multi-valued type designator slot.
+ */
+@NoArgsConstructor
+@AllArgsConstructor(access = AccessLevel.PROTECTED)
+@SuperBuilder(toBuilder = true)
+@Data
+public class BaseMultiSelfDesignatedClass {
+    private String foo;
+    @TypeDesignator
+    private List<String> type;
+    @ExtensionHolder
+    private Map<String, Object> extraSlots;
+}

core/src/test/lombok/org/incenp/linkml/core/sample/DerivedMultiSelfDesignatedClass.java

@@ -0,0 +1,54 @@
+/*
+ * LinkML-Java - LinkML library for Java
+ * Copyright © 2026 Damien Goutte-Gattat
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   (1) Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ *   (2) Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ *   (3) Neither the name of the copyright holder nor the names its
+ *   contributors may be used to endorse or promote products derived
+ *   from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
+ * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.incenp.linkml.core.sample;
+
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+
+/**
+ * An example of a class that derives from a class with a multi-valued type designator slot.
+ */
+@NoArgsConstructor
+@AllArgsConstructor(access = AccessLevel.PROTECTED)
+@SuperBuilder(toBuilder = true)
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class DerivedMultiSelfDesignatedClass extends BaseMultiSelfDesignatedClass {
+    private String bar;
+}