Update esmf-parent

core/esmf-aspect-meta-model-interface/src/main/java/org/eclipse/esmf/metamodel/datatype/SammXsdType.java

@@ -20,53 +20,46 @@
 import java.util.Optional;
 import java.util.function.Function;
 import java.util.function.Predicate;
+
 import javax.xml.datatype.DatatypeConfigurationException;
 import javax.xml.datatype.DatatypeFactory;
 import javax.xml.datatype.Duration;
 import javax.xml.datatype.XMLGregorianCalendar;
 
 import jakarta.xml.bind.DatatypeConverter;
+import org.apache.commons.lang3.NotImplementedException;
+import org.apache.jena.datatypes.DatatypeFormatException;
 import org.apache.jena.datatypes.RDFDatatype;
 import org.apache.jena.datatypes.TypeMapper;
 import org.apache.jena.datatypes.xsd.XSDDatatype;
 import org.apache.jena.datatypes.xsd.impl.RDFLangString;
-import org.apache.jena.ext.xerces.impl.dv.XSSimpleType;
-import org.apache.jena.ext.xerces.impl.dv.xs.ExtendedSchemaDVFactoryImpl;
+import org.apache.jena.graph.impl.LiteralLabel;
 import org.apache.jena.rdf.model.Resource;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+/**
+ * The custom RDF type implementations that have deterministic and typed parsers and unparsers (i.e., serializers).
+ *
+ * @param <T> the Java class that represents values for the type
+ */
 // the order of the variables is required because of the way they reference each other
 public class SammXsdType<T> extends XSDDatatype implements SammType<T> {
    private static final Logger LOG = LoggerFactory.getLogger( SammXsdType.class );
    public static DatatypeFactory datatypeFactory;
 
-   private final Class<T> correspondingJavaClass;
    private final Function<String, T> parser;
    private final Function<T, String> unparser;
    private final Predicate<String> lexicalValidator;
    private static boolean checking = true;
-   private static final ExtendedSchemaDVFactoryImpl EXTENDED_SCHEMA_DV_FACTORY = new ExtendedSchemaDVFactoryImpl();
-
-   public SammXsdType( final Resource dataTypeResource, final Class<T> correspondingJavaClass,
-         final Function<String, T> parser,
-         final Function<T, String> unparser,
-         final Predicate<String> lexicalValidator ) {
-      super( dataTypeResource.getLocalName() );
-      this.correspondingJavaClass = correspondingJavaClass;
-      this.parser = parser;
-      this.unparser = unparser;
-      this.lexicalValidator = lexicalValidator;
-   }
 
-   private SammXsdType( final Resource dataTypeResource, final XSSimpleType xstype,
+   protected SammXsdType( final Resource dataTypeResource,
          final Class<T> correspondingJavaClass,
          final Function<String, T> parser,
          final Function<T, String> unparser,
          final Predicate<String> lexicalValidator ) {
-      //In the namespace the hash symbol should be removed, because jena defines the namespace differently.
-      super( xstype, dataTypeResource.getNameSpace().replace( "#", "" ) );
-      this.correspondingJavaClass = correspondingJavaClass;
+      super( dataTypeResource.getLocalName() );
+      javaClass = correspondingJavaClass;
       this.parser = parser;
       this.unparser = unparser;
       this.lexicalValidator = lexicalValidator;
@@ -139,10 +132,9 @@ private SammXsdType( final Resource dataTypeResource, final XSSimpleType xstype,
          value -> datatypeFactory.newXMLGregorianCalendar( value ), XMLGregorianCalendar::toXMLFormat,
          XSDDatatype.XSDdateTime::isValid );
 
-   public static final SammXsdType<XMLGregorianCalendar> DATE_TIME_STAMP = new SammXsdType<>(
+   public static final SammExtendedXsdType<XMLGregorianCalendar> DATE_TIME_STAMP = new SammExtendedXsdType<>(
          org.apache.jena.vocabulary.XSD.dateTimeStamp,
-         EXTENDED_SCHEMA_DV_FACTORY.getBuiltInType( org.apache.jena.vocabulary.XSD.dateTimeStamp.getLocalName() ),
-         XMLGregorianCalendar.class, value -> datatypeFactory.newXMLGregorianCalendar( value ),
+         XMLGregorianCalendar.class, value -> SammXsdType.datatypeFactory.newXMLGregorianCalendar( value ),
          XMLGregorianCalendar::toXMLFormat, XSDDatatype.XSDdateTimeStamp::isValid );
 
    public static final SammXsdType<XMLGregorianCalendar> G_YEAR = new SammXsdType<>(
@@ -174,16 +166,14 @@ private SammXsdType( final Resource dataTypeResource, final XSSimpleType xstype,
          org.apache.jena.vocabulary.XSD.duration, Duration.class, value -> datatypeFactory.newDuration( value ),
          Duration::toString, XSDDatatype.XSDduration::isValid );
 
-   public static final SammXsdType<Duration> YEAR_MONTH_DURATION = new SammXsdType<>(
+   public static final SammExtendedXsdType<Duration> YEAR_MONTH_DURATION = new SammExtendedXsdType<>(
          org.apache.jena.vocabulary.XSD.yearMonthDuration,
-         EXTENDED_SCHEMA_DV_FACTORY.getBuiltInType( org.apache.jena.vocabulary.XSD.yearMonthDuration.getLocalName() ),
-         Duration.class, value -> datatypeFactory.newDurationYearMonth( value ), Duration::toString,
+         Duration.class, value -> SammXsdType.datatypeFactory.newDurationYearMonth( value ), Duration::toString,
          XSDDatatype.XSDyearMonthDuration::isValid );
 
-   public static final SammXsdType<Duration> DAY_TIME_DURATION = new SammXsdType<>(
+   public static final SammExtendedXsdType<Duration> DAY_TIME_DURATION = new SammExtendedXsdType<>(
          org.apache.jena.vocabulary.XSD.dayTimeDuration,
-         EXTENDED_SCHEMA_DV_FACTORY.getBuiltInType( org.apache.jena.vocabulary.XSD.dayTimeDuration.getLocalName() ),
-         Duration.class, value -> datatypeFactory.newDurationDayTime( value ), Duration::toString,
+         Duration.class, value -> SammXsdType.datatypeFactory.newDurationDayTime( value ), Duration::toString,
          XSDDatatype.XSDdayTimeDuration::isValid );
 
    public static final SammXsdType<Byte> BYTE = new SammXsdType<>( org.apache.jena.vocabulary.XSD.xbyte,
@@ -245,10 +235,6 @@ private SammXsdType( final Resource dataTypeResource, final XSSimpleType xstype,
          value -> URI.create( (String) XSDDatatype.XSDanyURI.parse( value ) ),
          URI::toString, XSDDatatype.XSDanyURI::isValid );
 
-   @SuppressWarnings( "checkstyle:LambdaParameterName" )
-   public static final SammXsdType<String> STRING = new SammXsdType<>(
-         org.apache.jena.vocabulary.XSD.xstring, String.class, Function.identity(), Function.identity(), __ -> true );
-
    public static final List<RDFDatatype> ALL_TYPES = List
          .of( XSDDatatype.XSDstring, BOOLEAN, DECIMAL, INTEGER, DOUBLE, FLOAT, DATE, TIME, DATE_TIME, DATE_TIME_STAMP,
                G_YEAR, G_MONTH, G_YEAR_MONTH, G_DAY, G_MONTH_DAY, DURATION, YEAR_MONTH_DURATION, DAY_TIME_DURATION,
@@ -311,9 +297,10 @@ public boolean isValid( final String lexicalForm ) {
       return lexicalValidator.test( lexicalForm );
    }
 
+   @SuppressWarnings( "unchecked" )
    @Override
    public Class<T> getJavaClass() {
-      return correspondingJavaClass;
+      return (Class<T>) javaClass;
    }
 
    private static boolean setupPerformed = false;
@@ -349,4 +336,116 @@ public static Class<?> getJavaTypeForMetaModelType( final Resource type ) {
             .findAny()
             .orElseThrow( () -> new IllegalStateException( "Invalid data type " + type + " found in model." ) );
    }
+
+   /**
+    * Separate implementation for the "extended" RDF types that can not be based on {@link XSDDatatype}.
+    *
+    * @param <T> the Java class that represents values for the type
+    */
+   public static class SammExtendedXsdType<T> implements SammType<T> {
+      private final String uri;
+      private final Class<T> javaClass;
+      private final Function<String, T> parser;
+      private final Function<T, String> unparser;
+      private final Predicate<String> lexicalValidator;
+
+      public SammExtendedXsdType(
+            final Resource dataTypeResource,
+            final Class<T> javaClass,
+            final Function<String, T> parser,
+            final Function<T, String> unparser,
+            final Predicate<String> lexicalValidator
+      ) {
+         uri = dataTypeResource.getURI();
+         this.javaClass = javaClass;
+         this.parser = parser;
+         this.unparser = unparser;
+         this.lexicalValidator = lexicalValidator;
+      }
+
+      @Override
+      public Optional<T> parseTyped( final String lexicalForm ) {
+         try {
+            return Optional.of( parser.apply( lexicalForm ) );
+         } catch ( final RuntimeException exception ) {
+            if ( checking ) {
+               throw exception;
+            }
+         }
+         return Optional.empty();
+      }
+
+      @Override
+      public String unparseTyped( final T value ) {
+         return unparser.apply( value );
+      }
+
+      @Override
+      public String getURI() {
+         return uri;
+      }
+
+      @Override
+      @SuppressWarnings( "unchecked" )
+      public String unparse( final Object value ) {
+         return unparseTyped( (T) value );
+      }
+
+      @Override
+      public Object parse( final String lexicalForm ) throws DatatypeFormatException {
+         try {
+            return parser.apply( lexicalForm );
+         } catch ( final Exception exception ) {
+            if ( checking ) {
+               throw exception;
+            }
+         }
+         return lexicalForm;
+      }
+
+      @Override
+      public boolean isValid( final String lexicalForm ) {
+         return lexicalValidator.test( lexicalForm );
+      }
+
+      @Override
+      public boolean isValidValue( final Object valueForm ) {
+         return isValid( unparse( valueForm ) );
+      }
+
+      @Override
+      public boolean isValidLiteral( final LiteralLabel lit ) {
+         return isValid( lit.getLexicalForm() );
+      }
+
+      @Override
+      public boolean isEqual( final LiteralLabel value1, final LiteralLabel value2 ) {
+         return value1.getLexicalForm().equals( value2.getLexicalForm() );
+      }
+
+      @Override
+      public int getHashCode( final LiteralLabel lit ) {
+         return lit.getValueHashCode();
+      }
+
+      @Override
+      public Class<T> getJavaClass() {
+         return javaClass;
+      }
+
+      @Override
+      public Object cannonicalise( final Object value ) {
+         return value;
+      }
+
+      @Override
+      public Object extendedTypeDefinition() {
+         throw new NotImplementedException();
+      }
+
+      @Override
+      public RDFDatatype normalizeSubType( final Object value, final RDFDatatype dt ) {
+         return this;
+      }
+   }
 }

core/esmf-aspect-meta-model-java/src/main/java/org/eclipse/esmf/aspectmodel/resolver/parser/TurtleParserProfile.java

@@ -17,6 +17,7 @@
 import org.apache.jena.graph.Graph;
 import org.apache.jena.graph.Node;
 import org.apache.jena.graph.Triple;
+import org.apache.jena.irix.IRIx;
 import org.apache.jena.riot.system.ErrorHandler;
 import org.apache.jena.riot.system.FactoryRDF;
 import org.apache.jena.riot.system.ParserProfile;
@@ -142,4 +143,9 @@ public Node createGraphNode( final Graph graph, final long line, final long col
    public Node createNodeFromToken( final Node scope, final Token token, final long line, final long col ) {
       return parserProfile.createNodeFromToken( scope, token, line, col );
    }
+
+   @Override
+   public Node createURI( final IRIx iriX, final long line, final long col ) {
+      return parserProfile.createURI( iriX, line, col );
+   }
 }

core/esmf-aspect-meta-model-java/src/main/java/org/eclipse/esmf/metamodel/DataTypes.java

@@ -108,10 +108,10 @@ public static class xsd {
    }
 
    public static class samm {
-      public static final Scalar curie = new DefaultScalar( CurieType.INSTANCE.getURI() );
+      public static final Scalar curie = TYPES.get( CurieType.INSTANCE.getURI() );
    }
 
    public static class rdf {
-      public static final Scalar langString = new DefaultScalar( RDF.langString.getURI() );
+      public static final Scalar langString = TYPES.get( RDF.langString.getURI() );
    }
 }

core/esmf-aspect-model-serializer/pom.xml

@@ -87,7 +87,6 @@
          <plugin>
             <groupId>org.codehaus.mojo</groupId>
             <artifactId>properties-maven-plugin</artifactId>
-            <version>1.2.0</version>
             <executions>
                <execution>
                   <phase>generate-resources</phase>

core/esmf-native-support/src/main/java/org/eclipse/esmf/nativefeatures/JenaFeature.java

@@ -71,32 +71,21 @@ public void beforeAnalysis( final Feature.BeforeAnalysisAccess access ) {
             .initializeAtBuildTime();
       Native.forClass( org.apache.jena.ext.xerces.impl.dv.xs.BaseSchemaDVFactory.class )
             .initializeAtBuildTime();
-      Native.forClass( org.apache.jena.ext.xerces.impl.dv.xs.ExtendedSchemaDVFactoryImpl.class )
-            .initializeAtBuildTime();
-      Native.forClass( org.apache.jena.ext.xerces.impl.dv.xs.QNameDV.class )
+      Native.forClass( org.apache.jena.ext.xerces.impl.dv.xs.BaseDVFactory.class )
             .initializeAtBuildTime();
       Native.forClass( org.apache.jena.ext.xerces.impl.dv.xs.SchemaDVFactoryImpl.class )
             .initializeAtBuildTime();
       Native.forClass( org.apache.jena.ext.xerces.impl.dv.xs.XSSimpleTypeDecl.class )
             .initializeAtBuildTime();
-      Native.forClass( org.apache.jena.ext.xerces.impl.dv.xs.XSSimpleTypeDecl.class )
-            .initializeAtBuildTime();
-      Native.forClass( "org.apache.jena.ext.xerces.impl.xpath.regex.Token$CharToken" )
-            .initializeAtBuildTime();
-      Native.forClass( "org.apache.jena.ext.xerces.impl.xpath.regex.Token$ClosureToken" )
-            .initializeAtBuildTime();
-      Native.forClass( "org.apache.jena.ext.xerces.impl.xpath.regex.Token$ParenToken" )
-            .initializeAtBuildTime();
-      Native.forClass( "org.apache.jena.ext.xerces.impl.xpath.regex.Token$UnionToken" )
-            .initializeAtBuildTime();
       Native.forClass( org.apache.jena.ext.xerces.util.XercesXMLChar.class )
             .initializeAtBuildTime();
+      Native.forClass( "com.github.benmanes.caffeine.cache.SSMS" )
+            .registerEverythingForReflection();
+      Native.forClass( "com.github.benmanes.caffeine.cache.PSMS" )
+            .registerEverythingForReflection();
 
       Native.addResource( "META-INF/services/org.apache.jena.sys.JenaSubsystemLifecycle" );
       Native.addResource( "org/apache/jena/arq/arq-properties.xml" );
       Native.addResource( "org/apache/jena/jena-properties.xml" );
-
-      Native.addResourceBundle( "org.apache.jena.ext.xerces.impl.xpath.regex.message" );
-      Native.addResourceBundle( "org.apache.jena.ext.xerces.impl.msg.XMLSchemaMessages" );
    }
 }

core/esmf-test-aspect-models/pom.xml

@@ -42,7 +42,7 @@
       </dependency>
       <dependency>
          <groupId>org.apache.jena</groupId>
-         <artifactId>jena-core</artifactId>
+         <artifactId>jena-arq</artifactId>
       </dependency>
    </dependencies>
 </project>

core/esmf-test-aspect-models/src/main/java/org/eclipse/esmf/test/TestModel.java

@@ -13,11 +13,12 @@
 
 package org.eclipse.esmf.test;
 
-import java.io.StringWriter;
-
 import org.eclipse.esmf.aspectmodel.urn.AspectModelUrn;
 
 import org.apache.jena.rdf.model.Model;
+import org.apache.jena.riot.RDFFormat;
+import org.apache.jena.riot.RDFLanguages;
+import org.apache.jena.riot.RDFWriter;
 
 @SuppressWarnings( "squid:S1214" ) // Can not be avoided because enums can't inherit from an abstract class
 public interface TestModel {
@@ -30,8 +31,12 @@ default AspectModelUrn getUrn() {
    }
 
    static String modelToString( final Model model ) {
-      final StringWriter stringWriter = new StringWriter();
-      model.write( stringWriter, "TURTLE" );
-      return stringWriter.toString();
+      //      org.apache.jena.riot.RDFWriter x;
+      final String string = RDFWriter.create().format( RDFFormat.TURTLE ).lang( RDFLanguages.TURTLE ).source( model ).asString();
+
+      //      final StringWriter stringWriter = new StringWriter();
+      //      model.write( stringWriter, "TURTLE" );
+      //      return stringWriter.toString();
+      return string;
    }
 }

core/esmf-test-aspect-models/src/main/java/org/eclipse/esmf/test/TestSharedModel.java

@@ -18,8 +18,10 @@
 public interface TestSharedModel extends TestModel {
    String TEST_NAMESPACE = "urn:samm:org.eclipse.esmf.test.shared:1.0.0#";
 
+   @Override
    String getName();
 
+   @Override
    default AspectModelUrn getUrn() {
       return AspectModelUrn.fromUrn( TEST_NAMESPACE + getName() );
    }

pom.xml

@@ -18,7 +18,7 @@
    <parent>
       <groupId>org.eclipse.esmf</groupId>
       <artifactId>esmf-parent</artifactId>
-      <version>16</version>
+      <version>DEV-SNAPSHOT</version>
    </parent>
 
    <artifactId>esmf-sdk-parent</artifactId>