From 54258abf5edf75ea4a615fb99bb55cf432655b61 Mon Sep 17 00:00:00 2001
From: Paul Harrison <paul.harrison@manchester.ac.uk>
Date: Tue, 18 Jun 2024 14:56:58 +0100
Subject: [PATCH] allow references to be aggregated

all unit-tests working - though perhaps there should be more functions generated to managed the aggregation in the instances.
---
 models/sample/test/lifecycleTest.vo-dml.xml   |  4 +-
 models/sample/test/lifecycleTest.vodsl        |  2 +-
 .../dm/lifecycle/LifeCycleDetailedTest.java   | 14 ++++--
 .../dm/lifecycle/LifecycleTestModelTest.java  |  2 +-
 tools/xslt/common-structure-functions.xsl     | 49 +++++++++++++------
 tools/xslt/jpa.xsl                            | 16 ++++--
 tools/xslt/vo-dml2java.xsl                    | 49 ++++++++++++++++---
 7 files changed, 101 insertions(+), 35 deletions(-)

diff --git a/models/sample/test/lifecycleTest.vo-dml.xml b/models/sample/test/lifecycleTest.vo-dml.xml
index 823680e8..d73d6484 100644
--- a/models/sample/test/lifecycleTest.vo-dml.xml
+++ b/models/sample/test/lifecycleTest.vo-dml.xml
@@ -9,7 +9,7 @@
       <title></title>
       <author>pharriso</author>
       <version>0.1</version>
-      <lastModified>2024-05-16T19:27:45Z</lastModified>
+      <lastModified>2024-06-13T14:50:55Z</lastModified>
       <import>
         <name>null</name><!--should not be needed in modern vo-dml -->
         <url>IVOA-v1.0.vo-dml.xml</url>
@@ -120,7 +120,7 @@
                  </datatype>
                  <multiplicity>
                    <minOccurs>1</minOccurs>
-                   <maxOccurs>1</maxOccurs>
+                   <maxOccurs>-1</maxOccurs>
                  </multiplicity>
                </reference>
                <composition>
diff --git a/models/sample/test/lifecycleTest.vodsl b/models/sample/test/lifecycleTest.vodsl
index 51829577..89da5fca 100644
--- a/models/sample/test/lifecycleTest.vodsl
+++ b/models/sample/test/lifecycleTest.vodsl
@@ -31,7 +31,7 @@ otype ATest2 {
      it is more a lifecycle matter really - as long as there is nothing that can 
 	                                     * delete the referredTo otype */
 	                                     
-	refagg references ReferredTo  "";                                      
+	refagg @+ references ReferredTo  "";                                      
 	atest : ATest as composition "";
 	                                     
 	refcont references ReferredLifeCycle ""; // potentially not OK (should be an error if referenced by something outside the object tree) - here the referred otype is also contained, so the 
diff --git a/tools/gradletooling/sample/src/test/java/org/ivoa/dm/lifecycle/LifeCycleDetailedTest.java b/tools/gradletooling/sample/src/test/java/org/ivoa/dm/lifecycle/LifeCycleDetailedTest.java
index d2643da0..8036e16f 100644
--- a/tools/gradletooling/sample/src/test/java/org/ivoa/dm/lifecycle/LifeCycleDetailedTest.java
+++ b/tools/gradletooling/sample/src/test/java/org/ivoa/dm/lifecycle/LifeCycleDetailedTest.java
@@ -54,7 +54,7 @@ void setUp() throws Exception {
               a.contained = contained;
               a.refandcontained = refcont;
             });
-    atest2 = new ATest2(referredTo, atest, refcont.get(0));
+    atest2 = new ATest2(Arrays.asList(referredTo), atest, refcont.get(0));
     atest3 =
         new ATest3(
             contained, refcont.get(0)); // TODO this will create contradictions.... how best to test
@@ -98,22 +98,26 @@ void MultiContainedJPATest() {
 
   @Test
   void copyTest() {
+   
     model.createContext();
     ATest atestprime = new ATest(atest);
-    atest.ref1.test1 = 4;
+    atest.ref1.test1 = 4; //change the original
     assertEquals(4, atestprime.ref1.test1); // the reference should have changed
+    
+    //now just change one of the contained
     atest.contained.get(0).test2 = "changed";
     assertEquals(
         "firstcontained",
         atestprime.contained.get(0)
-            .test2); // new objects created for the contained so changing original
-    // should not affect the prime
+            .test2); // new objects created for the contained so changing original should not affect the prime
 
+    //now clone something with "contained" references
     ATest2 atest2prime = new ATest2(atest2);
 
     atest2.atest.refandcontained.get(0).test3 = "changed2";
     assertEquals("changed2", atest2.refcont.test3); // this is in atest3
-
+    
+    //TODO this API feels unnatural...
     atest2prime.updateClonedReferences();
     assertEquals(
         "rc1",
diff --git a/tools/gradletooling/sample/src/test/java/org/ivoa/dm/lifecycle/LifecycleTestModelTest.java b/tools/gradletooling/sample/src/test/java/org/ivoa/dm/lifecycle/LifecycleTestModelTest.java
index 39a8b2a4..885d4f32 100644
--- a/tools/gradletooling/sample/src/test/java/org/ivoa/dm/lifecycle/LifecycleTestModelTest.java
+++ b/tools/gradletooling/sample/src/test/java/org/ivoa/dm/lifecycle/LifecycleTestModelTest.java
@@ -67,7 +67,7 @@ public LifecycleTestModel createModel() {
               a.contained = contained;
               a.refandcontained = refcont;
             });
-    atest2 = new ATest2( referredTo, atest, refcont.get(0));
+    atest2 = new ATest2( Arrays.asList(referredTo), atest, refcont.get(0));
 
     LifecycleTestModel model = new LifecycleTestModel();
     model.addContent(atest);
diff --git a/tools/xslt/common-structure-functions.xsl b/tools/xslt/common-structure-functions.xsl
index 5418f08b..17bc0ec0 100644
--- a/tools/xslt/common-structure-functions.xsl
+++ b/tools/xslt/common-structure-functions.xsl
@@ -159,9 +159,11 @@ note - only define functions in here as it is included in the schematron rules
     </xsl:function>
 
 
+    <!-- returns the types that are referenced in the models -->
     <xsl:function name="vf:referencesInModels" as="xsd:string*">
         <xsl:sequence select="distinct-values($models//reference/datatype/vodml-ref)"/>
     </xsl:function>
+    <!-- returns the types that are contained references in models -->
     <xsl:function name="vf:containedReferencesInModels" as="xsd:string*">
         <xsl:sequence select="distinct-values($models//reference/datatype/vodml-ref[vf:isContained(.)])"/>
     </xsl:function>
@@ -219,8 +221,16 @@ note - only define functions in here as it is included in the schematron rules
     </xsl:function>
 
 
+    <!-- return the type hierarchy focussed on the type as argument -->
+    <xsl:function name="vf:typeHierarchy" as="xsd:string*">
+    <xsl:param name="vodml-ref" as="xsd:string"/>
+        <xsl:sequence>
+            <xsl:for-each  select="(vf:baseTypes($vodml-ref),$models/key('ellookup',$vodml-ref),vf:subTypes($vodml-ref))">
+                <xsl:value-of select="vf:asvodmlref(.)"/>
+            </xsl:for-each>
+        </xsl:sequence>
+    </xsl:function>
     <!-- is the type (sub or base) used as a reference -->
-
     <xsl:function name="vf:referredTo" as="xsd:boolean">
         <xsl:param name="vodml-ref" as="xsd:string"/>
         <xsl:sequence select="vf:referredToInModels($vodml-ref,$models/vo-dml:model/name/text())"/>
@@ -231,13 +241,7 @@ note - only define functions in here as it is included in the schematron rules
 
         <xsl:choose>
             <xsl:when test="$models/key('ellookup',$vodml-ref)">
-                <xsl:variable name="hier" as="xsd:string *">
-                    <xsl:sequence>
-                        <xsl:for-each  select="(vf:baseTypes($vodml-ref),$models/key('ellookup',$vodml-ref),vf:subTypes($vodml-ref))">
-                            <xsl:value-of select="vf:asvodmlref(.)"/>
-                        </xsl:for-each>
-                    </xsl:sequence>
-                </xsl:variable>
+                <xsl:variable name="hier" select="vf:typeHierarchy($vodml-ref)"/>
                 <!--                <xsl:message>refs <xsl:value-of select="concat ($vodml-ref,' ',count($models//reference/datatype[vodml-ref = $hier])> 0,' h=',string-join($hier,','))"/></xsl:message>-->
                 <xsl:value-of select="count($models/vo-dml:model[name = $modelsToSearch]//reference/datatype[vodml-ref = $hier])> 0"/>
             </xsl:when>
@@ -247,6 +251,27 @@ note - only define functions in here as it is included in the schematron rules
         </xsl:choose>
     </xsl:function>
 
+    <!-- is the type (sub or base) used as a  contained reference -->
+    <xsl:function name="vf:isContainedReference" as="xsd:boolean">
+        <xsl:param name="vodml-ref" as="xsd:string"/>
+        <xsl:sequence select="vf:isContainedReferenceInModels($vodml-ref,$models/vo-dml:model/name/text())"/>
+    </xsl:function>
+    <xsl:function name="vf:isContainedReferenceInModels" as="xsd:boolean">
+        <xsl:param name="vodml-ref" as="xsd:string"/>
+        <xsl:param name="modelsToSearch" as="xsd:string*"/>
+        <xsl:choose>
+            <xsl:when test="$models/key('ellookup',$vodml-ref)">
+                <xsl:variable name="hier" select="vf:typeHierarchy($vodml-ref)"/>
+                <!--                <xsl:message>refs <xsl:value-of select="concat ($vodml-ref,' ',count($models//reference/datatype[vodml-ref = $hier])> 0,' h=',string-join($hier,','))"/></xsl:message>-->
+                <xsl:value-of select="count($models/vo-dml:model[name = $modelsToSearch]//reference/datatype[vodml-ref = $hier and vf:isContained(.)])> 0"/>
+            </xsl:when>
+            <xsl:otherwise>
+                <xsl:message terminate="yes">type '<xsl:value-of select="$vodml-ref"/>' not in considered models</xsl:message>
+            </xsl:otherwise>
+        </xsl:choose>
+    </xsl:function>
+
+    <!-- vodml-ids of referrers to the type in the argument -->
     <xsl:function name="vf:referredBy" as="xsd:string*">
     <xsl:param name="vodml-ref" as="xsd:string"/>
         <xsl:sequence select="vf:referredByInModels($vodml-ref,$models/vo-dml:model/name/text())"/>
@@ -257,13 +282,7 @@ note - only define functions in here as it is included in the schematron rules
         <xsl:param name="modelsToSearch" as="xsd:string*"/>
         <xsl:choose>
             <xsl:when test="$models/key('ellookup',$vodml-ref)">
-                <xsl:variable name="hier" as="xsd:string *">
-                    <xsl:sequence>
-                        <xsl:for-each  select="(vf:baseTypes($vodml-ref),$models/key('ellookup',$vodml-ref),vf:subTypes($vodml-ref))">
-                            <xsl:value-of select="vf:asvodmlref(.)"/>
-                        </xsl:for-each>
-                    </xsl:sequence>
-                </xsl:variable>
+                <xsl:variable name="hier" select="vf:typeHierarchy($vodml-ref)"/>
                 <!--                <xsl:message>refs <xsl:value-of select="concat ($vodml-ref,' ',count($models//reference/datatype[vodml-ref = $hier])> 0,' h=',string-join($hier,','))"/></xsl:message>-->
                 <xsl:sequence select="for $i in $models/vo-dml:model[name = $modelsToSearch]//(objectType|dataType)[reference/datatype/vodml-ref = $hier] return vf:asvodmlref($i)"/> <!-- FIXME do datypes too - and proper vodml ids -->
             </xsl:when>
diff --git a/tools/xslt/jpa.xsl b/tools/xslt/jpa.xsl
index 84b39bf9..bf754489 100644
--- a/tools/xslt/jpa.xsl
+++ b/tools/xslt/jpa.xsl
@@ -353,9 +353,19 @@
 // TODO    [NOT_SUPPORTED_REFERENCE]
       </xsl:when>
       <xsl:otherwise>
-    <!-- require manual management of references - do not remove referenced entity : do not cascade delete -->
-    @jakarta.persistence.ManyToOne( cascade = {  jakarta.persistence.CascadeType.REFRESH } )
-    @jakarta.persistence.JoinColumn( nullable = <xsl:apply-templates select="." mode="nullable"/> )
+          <xsl:choose>
+              <xsl:when test="xsd:int(multiplicity/maxOccurs) != 1">
+                  <!-- TODO should not really leave join table naming to JPA - should be explicit-->
+                  <!-- require manual management of references - do not remove referenced entity : do not cascade delete -->
+@jakarta.persistence.ManyToMany( cascade = {  jakarta.persistence.CascadeType.REFRESH } )
+              </xsl:when>
+              <xsl:otherwise>
+<!-- require manual management of references - do not remove referenced entity : do not cascade delete -->
+@jakarta.persistence.ManyToOne( cascade = {  jakarta.persistence.CascadeType.REFRESH } )
+@jakarta.persistence.JoinColumn( nullable = <xsl:apply-templates select="." mode="nullable"/> )
+
+              </xsl:otherwise>
+          </xsl:choose>
       </xsl:otherwise>
     </xsl:choose>
   </xsl:template>
diff --git a/tools/xslt/vo-dml2java.xsl b/tools/xslt/vo-dml2java.xsl
index 4a4edf27..17b68a8e 100644
--- a/tools/xslt/vo-dml2java.xsl
+++ b/tools/xslt/vo-dml2java.xsl
@@ -514,8 +514,10 @@
                 </xsl:choose>
                 <xsl:value-of select="').collect(java.util.stream.Collectors.toList())'"/>
                 </xsl:variable>
+
                 <xsl:choose>
-                    <xsl:when test="vf:referredTo($m/datatype/vodml-ref)">
+                    <xsl:when test="vf:isContainedReference($m/datatype/vodml-ref)">
+                        <!-- FIXME this is probably not the right place to do this - better to do it in the clone of the type itself -->
                         <xsl:value-of select="concat('var cache = org.ivoa.vodml.ModelContext.current().cache(',$jt,'.class)')"/>;
                         <xsl:value-of select="concat('var cloned = ',$assn)"/>;
                         <xsl:value-of select="concat('cache.setValues(other.',vf:javaMemberName($m/name),', cloned)')"/>;
@@ -902,7 +904,7 @@ package <xsl:value-of select="$path"/>;
         <xsl:when test="xsd:int(multiplicity/maxOccurs) gt 1">
     protected <xsl:value-of select="concat($type,'[] ',vf:javaMemberName(name))"/>;
         </xsl:when>
-        <xsl:when test="xsd:int(multiplicity/maxOccurs) lt 0">
+        <xsl:when test="xsd:int(multiplicity/maxOccurs) lt 0"> <!-- IMPL - this probably should not be allowed -->
     protected <xsl:value-of select="concat('java.util.List',$lt,$type,$gt,' ',vf:javaMemberName(name))"/>;
         </xsl:when>
         <xsl:otherwise>
@@ -1175,7 +1177,7 @@ package <xsl:value-of select="$path"/>;
     }
     </xsl:template>
 
-    <xsl:template match="composition[multiplicity/maxOccurs != 1]" mode="jpawalker">
+    <xsl:template match="(composition[multiplicity/maxOccurs != 1]|reference[multiplicity/maxOccurs != 1])" mode="jpawalker">
         for( <xsl:value-of select="vf:FullJavaType(datatype/vodml-ref, true())"/> c : <xsl:value-of select="vf:javaMemberName(name)"/> ) {
            c.forceLoad();
         }
@@ -1271,7 +1273,7 @@ package <xsl:value-of select="$path"/>;
 
 
 
-  <xsl:template match="reference" mode="declare"><!-- IMPL could be the same as attribute - actually more usefully so if reference allowed to have >1 multiplicity -->
+  <xsl:template match="reference" mode="declare">
     <xsl:variable name="type" select="vf:JavaType(datatype/vodml-ref)"/>
     /** 
     * ReferenceObject <xsl:value-of select="name"/> :
@@ -1284,13 +1286,21 @@ package <xsl:value-of select="$path"/>;
     <xsl:apply-templates select="." mode="JAXBAnnotation"/>
     <xsl:call-template name="vodmlAnnotation"/>
       <xsl:apply-templates select="." mode="openapiAnnotation"/>
-    protected <xsl:value-of select="$type"/>&bl;<xsl:value-of select="vf:javaMemberName(name)"/> = null;
+      <xsl:choose>
+          <xsl:when test="xsd:int(multiplicity/maxOccurs) lt 0"> <!-- IMPL are allowing for multiplicity > 1 i.e. aggregation-->
+              protected <xsl:value-of select="concat('java.util.List',$lt,$type,$gt,' ',vf:javaMemberName(name))"/>;
+          </xsl:when>
+          <xsl:otherwise>
+              protected <xsl:value-of select="$type"/>&bl;<xsl:value-of select="vf:javaMemberName(name)"/> = null;
+          </xsl:otherwise>
+      </xsl:choose>
+
   </xsl:template>
 
 
 
 
-  <xsl:template match="reference" mode="getset">
+  <xsl:template match="reference[multiplicity/maxOccurs = 1]" mode="getset">
     <xsl:variable name="type" select="vf:JavaType(datatype/vodml-ref)"/>
     <xsl:variable name="name">
       <xsl:call-template name="upperFirst">
@@ -1313,10 +1323,33 @@ package <xsl:value-of select="$path"/>;
     }
   </xsl:template>
 
+    <xsl:template match="reference[multiplicity/maxOccurs != 1]" mode="getset"> <!-- IMPL could use the same rule as composition? -->
+        <xsl:variable name="type" select="vf:JavaType(datatype/vodml-ref)"/>
+        <xsl:variable name="name">
+            <xsl:call-template name="upperFirst">
+                <xsl:with-param name="val" select="name"/>
+            </xsl:call-template>
+        </xsl:variable>
+        /**
+        * Returns <xsl:value-of select="name"/> Reference<br/>
+        * @return <xsl:value-of select="name"/> Reference
+        */
+        public List&lt;<xsl:value-of select="$type"/>&gt;&bl;get<xsl:value-of select="$name"/>() {
+        return this.<xsl:value-of select="vf:javaMemberName(name)"/>;
+        }
+        /**
+        * Defines <xsl:value-of select="name"/> Reference
+        * @param p<xsl:value-of select="$name"/> references to set
+        */
+        public void set<xsl:value-of select="$name"/>(final List&lt;<xsl:value-of select="$type"/>&gt; p<xsl:value-of select="$name"/>) {
+        this.<xsl:value-of select="vf:javaMemberName(name)"/> = p<xsl:value-of select="$name"/>;
+        }
+    </xsl:template>
 
 
 
-  <xsl:template match="reference" mode="setProperty">
+ <!-- deprecated - references work differently now
+ <xsl:template match="reference[multiplicity/maxOccurs != 1]" mode="setProperty">
     <xsl:variable name="type" select="vf:JavaType(datatype/vodml-ref)"/>
     <xsl:variable name="name">
       <xsl:call-template name="upperFirst">
@@ -1331,7 +1364,7 @@ package <xsl:value-of select="$path"/>;
         set<xsl:value-of select="$name"/>((<xsl:value-of select="$type"/>)pValue);
       return true;
     }
-  </xsl:template>
+  </xsl:template> -->
 
   <xsl:template match="literal" >
     /**