From 8987f281096c9de31c80f3d053a0e9fed8dff146 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Fri, 30 Jan 2026 09:52:28 +0100 Subject: [PATCH 1/9] Refactor DataManager architecture new Model --- .../datamanager/api/ModelDataManager.java | 72 ++++ .../api/ModelDataManagerBuilder.java | 16 + .../api/lifecycle/DataManagerLifecycle.java | 95 +++++ .../api/lifecycle/LifecycleState.java | 50 +++ .../api/operations/BulkOperations.java | 114 ++++++ .../api/operations/MetadataOperations.java | 56 +++ .../api/operations/MutationOperations.java | 101 +++++ .../api/operations/QueryOperations.java | 58 +++ .../api/support/config/DataManagerConfig.java | 162 ++++++++ .../exception/DataManagerException.java | 50 +++ .../api/support/exception/ErrorCode.java | 56 +++ .../api/support/model/ModelStatistics.java | 76 ++++ .../api/support/model/MutationResult.java | 375 ++++++++++++++++++ .../api/support/model/StatementPattern.java | 238 +++++++++++ .../api/transaction/IsolationLevel.java | 48 +++ .../api/transaction/Transaction.java | 62 +++ .../api/transaction/TransactionManager.java | 70 ++++ .../api/transaction/TransactionState.java | 42 ++ .../impl/CoreseModelDataManager.java | 165 ++++++++ .../impl/CoreseModelDataManagerBuilder.java | 75 ++++ .../impl/lifecycle/LifecycleManagerImpl.java | 227 +++++++++++ .../impl/operations/BulkOperationsImpl.java | 236 +++++++++++ .../operations/MetadataOperationsImpl.java | 189 +++++++++ .../operations/MutationOperationsImpl.java | 245 ++++++++++++ .../impl/operations/QueryOperationsImpl.java | 191 +++++++++ .../impl/transaction/TransactionImpl.java | 209 ++++++++++ .../transaction/TransactionManagerImpl.java | 194 +++++++++ 27 files changed, 3472 insertions(+) create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManager.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManagerBuilder.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/api/lifecycle/DataManagerLifecycle.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/api/lifecycle/LifecycleState.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/api/operations/BulkOperations.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/api/operations/MetadataOperations.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/api/operations/MutationOperations.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/api/operations/QueryOperations.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/api/support/config/DataManagerConfig.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/api/support/exception/DataManagerException.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/api/support/exception/ErrorCode.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/api/support/model/ModelStatistics.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/api/support/model/MutationResult.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/api/support/model/StatementPattern.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/api/transaction/IsolationLevel.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/api/transaction/Transaction.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/api/transaction/TransactionManager.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/api/transaction/TransactionState.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManager.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerBuilder.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/impl/lifecycle/LifecycleManagerImpl.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/BulkOperationsImpl.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/MetadataOperationsImpl.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/MutationOperationsImpl.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/QueryOperationsImpl.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/impl/transaction/TransactionImpl.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/impl/transaction/TransactionManagerImpl.java diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManager.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManager.java new file mode 100644 index 000000000..4fd74f9c6 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManager.java @@ -0,0 +1,72 @@ +package fr.inria.corese.core.next.datamanager.api; + +import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.datamanager.api.lifecycle.DataManagerLifecycle; +import fr.inria.corese.core.next.datamanager.api.operations.BulkOperations; +import fr.inria.corese.core.next.datamanager.api.operations.MetadataOperations; +import fr.inria.corese.core.next.datamanager.api.operations.MutationOperations; +import fr.inria.corese.core.next.datamanager.api.operations.QueryOperations; +import fr.inria.corese.core.next.datamanager.api.transaction.TransactionManager; + +/** + * Main interface for the Model DataManager. + * Provides access to all DataManager operations through specialized operation interfaces. + */ +public interface ModelDataManager { + + /** + * Returns the query operations handler. + * Provides read-only operations for querying statements. + * + * @return QueryOperations instance + */ + QueryOperations getQueryOperations(); + + /** + * Returns the mutation operations handler. + * Provides operations for inserting, updating, and deleting statements. + * + * @return MutationOperations instance + */ + MutationOperations getMutationOperations(); + + /** + * Returns the metadata operations handler. + * Provides access to model structure information (subjects, predicates, objects, contexts, statistics). + * + * @return MetadataOperations instance + */ + MetadataOperations getMetadataOperations(); + + /** + * Returns the bulk operations handler. + * Provides batch operations for efficient processing of multiple statements. + * + * @return BulkOperations instance + */ + BulkOperations getBulkOperations(); + + /** + * Returns the transaction manager. + * Provides transaction support if enabled in configuration. + * + * @return TransactionManager instance + */ + TransactionManager getTransactionManager(); + + /** + * Returns the lifecycle manager. + * Provides initialization, shutdown, and restart operations. + * + * @return DataManagerLifecycle instance + */ + DataManagerLifecycle getLifecycle(); + + /** + * Returns the underlying Model instance. + * Provides direct access to the RDF model for advanced use cases. + * + * @return Model instance + */ + Model getModel(); +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManagerBuilder.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManagerBuilder.java new file mode 100644 index 000000000..d1d2e3478 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManagerBuilder.java @@ -0,0 +1,16 @@ +package fr.inria.corese.core.next.datamanager.api; + +/** + * Builder interface for creating ModelDataManager instances. + */ +public interface ModelDataManagerBuilder { + + /** + * Builds and returns a new ModelDataManager instance + * with the configured settings. + * + * @return a new ModelDataManager instance + * @throws IllegalStateException if required configuration is missing + */ + ModelDataManager build(); +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/lifecycle/DataManagerLifecycle.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/lifecycle/DataManagerLifecycle.java new file mode 100644 index 000000000..c4062bcba --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/lifecycle/DataManagerLifecycle.java @@ -0,0 +1,95 @@ +package fr.inria.corese.core.next.datamanager.api.lifecycle; + +import fr.inria.corese.core.next.datamanager.api.support.config.DataManagerConfig; +import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; +import fr.inria.corese.core.next.datamanager.api.support.exception.ErrorCode; + +/** + * Lifecycle management for the DataManager. + */ +public interface DataManagerLifecycle { + + /** + * Initializes the DataManager with the provided configuration. + * + * @param config DataManager configuration (must not be null) + * @throws DataManagerException if initialization fails + * @throws IllegalStateException if already initialized + * @throws IllegalArgumentException if config is null + */ + void initialize(DataManagerConfig config) throws DataManagerException; + + /** + * Checks if the DataManager is initialized and ready to use. + * + * @return true if initialized (RUNNING state), false otherwise + */ + default boolean isInitialized() { + return getState().isRunning(); + } + + /** + * Cleanly shuts down the DataManager and releases all resources. + * + * @throws DataManagerException if shutdown fails + * @throws IllegalStateException if not initialized + */ + void shutdown() throws DataManagerException; + + /** + * Restarts the DataManager with a new configuration. + * This method attempts to restore the previous configuration if the restart fails. + * However, restoration is not guaranteed if both shutdown and re-initialization fail. + * + * @param config New configuration (must not be null) + * @throws DataManagerException if restart fails + * @throws IllegalArgumentException if config is null + * @throws IllegalStateException if shutdown fails (when already initialized) + */ + default void restart(DataManagerConfig config) throws DataManagerException { + DataManagerConfig oldConfig = getConfig(); + boolean wasInitialized = isInitialized(); + + if (wasInitialized) { + shutdown(); + } + + try { + initialize(config); + } catch (DataManagerException e) { + if (wasInitialized && oldConfig != null) { + try { + initialize(oldConfig); + throw new DataManagerException( + ErrorCode.RESTART_FAILED_ROLLBACK_SUCCESS, + "Failed to restart with new config. Restored previous configuration.", + e); + } catch (DataManagerException rollbackEx) { + DataManagerException criticalFailure = new DataManagerException( + ErrorCode.RESTART_FAILED_ROLLBACK_FAILED, + "Failed to restart and unable to restore previous configuration.", + e); + criticalFailure.addSuppressed(rollbackEx); + throw criticalFailure; + } + } + throw e; + } + } + + /** + * Returns the current lifecycle state. + * + * @return Current state + */ + LifecycleState getState(); + + /** + * Returns the currently used configuration. + * + * @return Current configuration, or null if not initialized + */ + DataManagerConfig getConfig(); + + +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/lifecycle/LifecycleState.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/lifecycle/LifecycleState.java new file mode 100644 index 000000000..4d6b76f2a --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/lifecycle/LifecycleState.java @@ -0,0 +1,50 @@ +package fr.inria.corese.core.next.datamanager.api.lifecycle; + +/** + * Possible lifecycle states of the DataManager. + */ +public enum LifecycleState { + /** + * The DataManager is not yet initialized + */ + NOT_INITIALIZED("Not initialized"), + + /** + * The DataManager is initializing + */ + INITIALIZING("Initializing"), + + /** + * The DataManager is operational and ready + */ + RUNNING("Running"), + + /** + * The DataManager is shutting down + */ + SHUTTING_DOWN("Shutting down"), + + /** + * The DataManager has been shut down + */ + SHUTDOWN("Shutdown"); + + private final String description; + + LifecycleState(String description) { + this.description = description; + } + + public String getDescription() { + return description; + } + + /** + * Checks if the DataManager can be used in this state. + * + * @return true if usable (RUNNING) + */ + public boolean isRunning() { + return this == RUNNING; + } +} diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/BulkOperations.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/BulkOperations.java new file mode 100644 index 000000000..90c43c738 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/BulkOperations.java @@ -0,0 +1,114 @@ +package fr.inria.corese.core.next.datamanager.api.operations; + +import fr.inria.corese.core.next.api.Resource; +import fr.inria.corese.core.next.api.Statement; +import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; +import fr.inria.corese.core.next.datamanager.api.support.model.StatementPattern; +import fr.inria.corese.core.next.datamanager.api.support.model.MutationResult; + +import java.util.List; + +/** + * Bulk mutation operations for batch processing in Model. + */ +public interface BulkOperations { + + /** + * Inserts multiple statements in a single batch operation. + * + * @param statements List of statements to insert + * @return Bulk mutation result with statistics + * @throws DataManagerException if operation fails + * @throws IllegalArgumentException if statements is null or empty + */ + MutationResult insertBatch(List statements) throws DataManagerException; + + /** + * Deletes multiple statements in a single batch operation. + * More efficient than calling deleteStatement() multiple times. + * + * @param statements List of statements to delete + * @return Bulk mutation result with statistics + * @throws DataManagerException if operation fails + * @throws IllegalArgumentException if statements is null or empty + */ + MutationResult deleteBatch(List statements) throws DataManagerException; + + /** + * Deletes all statements matching the given pattern. + * + * @param pattern Pattern to match statements for deletion + * @return Bulk mutation result with deleted statements + * @throws DataManagerException if operation fails + * @throws IllegalArgumentException if pattern is null + */ + MutationResult deleteByPattern(StatementPattern pattern) throws DataManagerException; + + /** + * Clears (deletes all statements from) specific contexts. + * + * @param contexts List of contexts to clear (empty or null for all) + * @param silent If true, don't fail if context doesn't exist + * @return Bulk mutation result + * @throws DataManagerException if operation fails + */ + MutationResult clearContexts(List contexts, boolean silent) throws DataManagerException; + + /** + * Clears all contexts (deletes entire model). + * + * @return Bulk mutation result with all deleted statements + * @throws DataManagerException if operation fails + */ + default MutationResult clearAll() throws DataManagerException { + return clearContexts(null, false); + } + + /** + * Adds statements from source context to target context. + * Statements remain in source context. + * + * @param sourceContext Source context + * @param targetContext Target context + * @param silent If true, don't fail if source doesn't exist + * @return Bulk mutation result + * @throws DataManagerException if operation fails + * @throws IllegalArgumentException if contexts are null + */ + default MutationResult addGraph(Resource sourceContext, Resource targetContext, boolean silent) + throws DataManagerException { + throw new UnsupportedOperationException("addGraph not implemented - Model API doesn't support this operation natively"); + } + + + /** + * Undeclares (deletes) a context and all its statements. + * + * @param context Context to undeclare + * @return Bulk mutation result with deleted statements + * @throws DataManagerException if operation fails + * @throws IllegalArgumentException if context is null + */ + default MutationResult undeclareContext(Resource context) throws DataManagerException { + if (context == null) { + throw new IllegalArgumentException("Context cannot be null"); + } + return clearContexts(List.of(context), false); + } + + /** + * Undeclares (deletes) multiple contexts and all their statements in a single batch operation. + * More efficient than calling undeclareContext() multiple times. + * + * @param contexts List of contexts to undeclare + * @return Bulk mutation result with all deleted statements + * @throws DataManagerException if operation fails + * @throws IllegalArgumentException if contexts is null or empty + */ + default MutationResult undeclareContexts(List contexts) throws DataManagerException { + if (contexts == null || contexts.isEmpty()) { + throw new IllegalArgumentException("Contexts list cannot be null or empty"); + } + return clearContexts(contexts, false); + } +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/MetadataOperations.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/MetadataOperations.java new file mode 100644 index 000000000..e2ae2c0b7 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/MetadataOperations.java @@ -0,0 +1,56 @@ +package fr.inria.corese.core.next.datamanager.api.operations; + +import fr.inria.corese.core.next.api.IRI; +import fr.inria.corese.core.next.api.Resource; +import fr.inria.corese.core.next.api.Value; +import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; +import fr.inria.corese.core.next.datamanager.api.support.model.ModelStatistics; + +import java.util.Set; + +/** + * Metadata operations for the Model. + * Provides access to model structure information (subjects, predicates, objects, contexts, statistics). + */ +public interface MetadataOperations { + + /** + * Returns all predicates in the model. + * + * @return Set of predicates (unmodifiable) + * @throws DataManagerException if query fails + */ + Set getPredicates() throws DataManagerException; + + /** + * Returns all subject resources in the model. + * + * @return Set of subject resources (unmodifiable) + * @throws DataManagerException if query fails + */ + Set getSubjects() throws DataManagerException; + + /** + * Returns all object values in the model. + * + * @return Set of object values (unmodifiable) + * @throws DataManagerException if query fails + */ + Set getObjects() throws DataManagerException; + + /** + * Returns all contexts (named graphs) in the model. + * + * @return Set of context resources (unmodifiable) + * @throws DataManagerException if query fails + */ + Set getContexts() throws DataManagerException; + + /** + * Returns statistics about the model content and structure. + * + * @return Model statistics + * @throws DataManagerException if statistics cannot be computed + */ + ModelStatistics getStatistics() throws DataManagerException; +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/MutationOperations.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/MutationOperations.java new file mode 100644 index 000000000..caae00897 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/MutationOperations.java @@ -0,0 +1,101 @@ +package fr.inria.corese.core.next.datamanager.api.operations; + +import fr.inria.corese.core.next.api.IRI; +import fr.inria.corese.core.next.api.Resource; +import fr.inria.corese.core.next.api.Statement; +import fr.inria.corese.core.next.api.Value; +import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; +import fr.inria.corese.core.next.datamanager.api.support.model.MutationResult; + +/** + * Mutation operations for Model. + * Provides insert, delete, and update operations for statements. + */ +public interface MutationOperations { + + /** + * Inserts a single statement. + * + * @param statement Statement to insert + * @return Mutation result + * @throws DataManagerException if operation fails + * @throws IllegalArgumentException if statement is null + */ + MutationResult insertStatement(Statement statement) throws DataManagerException; + + /** + * Inserts a statement with explicit subject, predicate, object, and contexts. + * + * @param subject Subject resource + * @param predicate Predicate IRI + * @param object Object value + * @param contexts Array of contexts (empty for default graph) + * @return Mutation result + * @throws DataManagerException if operation fails + * @throws IllegalArgumentException if subject, predicate, or object is null + */ + MutationResult insertStatement(Resource subject, IRI predicate, Value object, Resource... contexts) + throws DataManagerException; + + /** + * Deletes a single statement. + * + * @param statement Statement to delete + * @return Mutation result + * @throws DataManagerException if operation fails + * @throws IllegalArgumentException if statement is null + */ + MutationResult deleteStatement(Statement statement) throws DataManagerException; + + /** + * Deletes statements matching the given pattern. + * + * @param subject Subject resource (null for any) + * @param predicate Predicate IRI (null for any) + * @param object Object value (null for any) + * @param contexts Array of contexts (null or empty for all) + * @return Mutation result (bulk result with all deleted statements) + * @throws DataManagerException if operation fails + */ + MutationResult deleteStatements(Resource subject, IRI predicate, Value object, Resource... contexts) + throws DataManagerException; + + /** + * Updates a statement (delete + insert in one operation). + * + * @param oldStatement Statement to delete + * @param newStatement Statement to insert + * @return Mutation result + * @throws DataManagerException if operation fails + * @throws IllegalArgumentException if oldStatement or newStatement is null + */ + default MutationResult updateStatement(Statement oldStatement, Statement newStatement) + throws DataManagerException { + if (oldStatement == null || newStatement == null) { + throw new IllegalArgumentException("Both oldStatement and newStatement must be non-null"); + } + + MutationResult deleteResult = deleteStatement(oldStatement); + if (deleteResult.isFailure()) { + return deleteResult; + } + + MutationResult insertResult = insertStatement(newStatement); + if (insertResult.isFailure()) { + return MutationResult.failure( + "Insert failed after delete: " + insertResult.getMessage() + ); + } + + return insertResult; + } + + /** + * Clears statements from the specified contexts. + * + * @param contexts Array of contexts to clear (empty for all) + * @return Mutation result with count of deleted statements + * @throws DataManagerException if operation fails + */ + MutationResult clear(Resource... contexts) throws DataManagerException; +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/QueryOperations.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/QueryOperations.java new file mode 100644 index 000000000..182eac61c --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/QueryOperations.java @@ -0,0 +1,58 @@ +package fr.inria.corese.core.next.datamanager.api.operations; + +import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.api.Statement; +import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; +import fr.inria.corese.core.next.datamanager.api.support.model.StatementPattern; + +import java.util.stream.Stream; + +/** + * Query operations for reading statements. + * Provides modern Stream-based API for querying the model. + */ +public interface QueryOperations { + + /** + * Queries statements matching the given pattern. + * + * @param pattern Statement pattern to match + * @return Stream of matching statements (must be closed) + * @throws DataManagerException if query fails + * @throws IllegalArgumentException if pattern is null + */ + Stream query(StatementPattern pattern) throws DataManagerException; + + /** + * Counts statements matching the given pattern. + * More efficient than query().count() as it doesn't need to load statements. + * + * @param pattern Statement pattern to match + * @return Number of matching statements + * @throws DataManagerException if count fails + * @throws IllegalArgumentException if pattern is null + */ + long count(StatementPattern pattern) throws DataManagerException; + + /** + * Checks if at least one statement matches the given pattern. + * More efficient than query().findAny() as it can stop after first match. + * + * @param pattern Statement pattern to match + * @return true if at least one statement matches + * @throws DataManagerException if check fails + * @throws IllegalArgumentException if pattern is null + */ + boolean exists(StatementPattern pattern) throws DataManagerException; + + /** + * Filters the model according to the given statement pattern. + * Returns a new Model containing all statements matching the pattern. + * + * @param pattern Statement pattern to match + * @return A new Model containing matching statements + * @throws DataManagerException if filter fails + * @throws IllegalArgumentException if pattern is null + */ + Model filter(StatementPattern pattern) throws DataManagerException; +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/support/config/DataManagerConfig.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/support/config/DataManagerConfig.java new file mode 100644 index 000000000..101deba90 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/support/config/DataManagerConfig.java @@ -0,0 +1,162 @@ +package fr.inria.corese.core.next.datamanager.api.support.config; + +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; + +/** + * Typed configuration for the DataManager. + */ +public final class DataManagerConfig { + + private final Map properties; + private final boolean transactionSupport; + private final boolean debug; + + /** + * Private constructor - use the Builder. + */ + private DataManagerConfig(Builder builder) { + this.properties = Map.copyOf(builder.properties); + this.transactionSupport = builder.transactionSupport; + this.debug = builder.debug; + } + + /** + * Returns a property. + * + * @param key Property key + * @return Property value, or Optional.empty() if absent + */ + public Optional getProperty(String key) { + return Optional.ofNullable(properties.get(key)); + } + + /** + * Returns a property with a specific type. + * + * @param Property type + * @param key Property key + * @param type Expected type class + * @return Typed value, or Optional.empty() if absent or wrong type + */ + @SuppressWarnings("unchecked") + public Optional getProperty(String key, Class type) { + Object value = properties.get(key); + if (type.isInstance(value)) { + return Optional.of((T) value); + } + return Optional.empty(); + } + + /** + * Returns all properties. + * + * @return Immutable map of properties + */ + public Map getProperties() { + return properties; + } + + + /** + * Indicates whether debug mode is enabled. + * + * @return true if debug enabled + */ + public boolean isDebug() { + return debug; + } + + /** + * Creates a new builder. + * + * @return New builder instance + */ + public static Builder builder() { + return new Builder(); + } + + @Override + public String toString() { + return "DataManagerConfig{" + + ", transactionSupport=" + transactionSupport + + ", debug=" + debug + + ", properties=" + properties + + '}'; + } + + /** + * Builder for DataManagerConfig. + */ + public static final class Builder { + private final Map properties = new HashMap<>(); + private boolean transactionSupport = false; + private boolean debug = false; + + private Builder() { + } + + /** + * Adds a custom property to the configuration. + * + * @param key Property key (must not be null, empty, or blank) + * @param value Property value (must not be null) + * @return this builder instance + * @throws IllegalArgumentException if key is null/empty/blank or value is null + */ + public Builder property(String key, Object value) { + if (key == null || key.isBlank()) { + throw new IllegalArgumentException("Property key cannot be null, empty, or blank"); + } + if (value == null) { + throw new IllegalArgumentException("Property value cannot be null"); + } + this.properties.put(key, value); + return this; + } + + /** + * Enables or disables transaction support. + * + * @param enable true to enable + * @return This builder (for chaining) + */ + public Builder enableTransactions(boolean enable) { + this.transactionSupport = enable; + return this; + } + + /** + * Enables or disables transaction support (alias for enableTransactions). + * + * @param enable true to enable + * @return This builder (for chaining) + */ + public Builder transactionSupport(boolean enable) { + return enableTransactions(enable); + } + + + /** + * Enables or disables debug mode. + * + * @param debug true to enable + * @return This builder (for chaining) + */ + public Builder debug(boolean debug) { + this.debug = debug; + return this; + } + + /** + * Builds the DataManagerConfig instance. + * + * @return New configured instance + * @throws IllegalStateException if storagePath has not been set + */ + public DataManagerConfig build() { + return new DataManagerConfig(this); + } + } +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/support/exception/DataManagerException.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/support/exception/DataManagerException.java new file mode 100644 index 000000000..05e23c3a9 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/support/exception/DataManagerException.java @@ -0,0 +1,50 @@ +package fr.inria.corese.core.next.datamanager.api.support.exception; + +/** + * Specific exception for DataManager operations. + */ +public class DataManagerException extends Exception { + + private final ErrorCode code; + + /** + * Constructs an exception with a code and message. + * + * @param code Error code + * @param message Descriptive message + */ + public DataManagerException(ErrorCode code, String message) { + super(message); + this.code = code; + } + + /** + * Constructs an exception with a code, message and cause. + * + * @param code Error code + * @param message Descriptive message + * @param cause Original exception + */ + public DataManagerException(ErrorCode code, String message, Throwable cause) { + super(message, cause); + this.code = code; + } + + /** + * Returns the error code. + * + * @return Error code + */ + public ErrorCode getCode() { + return code; + } + + @Override + public String toString() { + return "DataManagerException{" + + "code=" + code + + ", message='" + getMessage() + '\'' + + '}'; + } + +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/support/exception/ErrorCode.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/support/exception/ErrorCode.java new file mode 100644 index 000000000..d2f039113 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/support/exception/ErrorCode.java @@ -0,0 +1,56 @@ +package fr.inria.corese.core.next.datamanager.api.support.exception; + +/** + * Error codes for DataManager operations. + */ +public enum ErrorCode { + /** Initialization failure */ + INITIALIZATION_FAILED("INIT_FAIL", "Initialization failed"), + + /** Shutdown failure */ + SHUTDOWN_FAILED("SHUTDOWN_FAIL", "Shutdown failed"), + + /** Transaction error */ + TRANSACTION_ERROR("TX_ERROR", "Transaction error"), + + /** Query failure */ + QUERY_FAILED("QUERY_FAIL", "Query failed"), + + /** Mutation failure */ + MUTATION_FAILED("MUTATION_FAIL", "Mutation failed"), + + /** Invalid pattern */ + INVALID_PATTERN("INVALID_PATTERN", "Invalid pattern"), + + /** Context not found */ + CONTEXT_NOT_FOUND("CTX_NOT_FOUND", "Context not found"), + + /** Unsupported operation */ + UNSUPPORTED_OPERATION("UNSUPPORTED", "Operation not supported"), + + /** Invalid state */ + INVALID_STATE("INVALID_STATE", "Invalid state"), + + RESTART_FAILED_ROLLBACK_SUCCESS("RESTART_FAIL_ROLLBACK_OK", + "Restart failed but previous configuration restored"), + + /** Restart failed and rollback also failed (critical) */ + RESTART_FAILED_ROLLBACK_FAILED("RESTART_FAIL_ROLLBACK_FAIL", + "Restart failed and unable to restore previous configuration"),; + + private final String code; + private final String description; + + ErrorCode(String code, String description) { + this.code = code; + this.description = description; + } + + public String getCode() { + return code; + } + + public String getDescription() { + return description; + } +} diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/support/model/ModelStatistics.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/support/model/ModelStatistics.java new file mode 100644 index 000000000..b5b290fe9 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/support/model/ModelStatistics.java @@ -0,0 +1,76 @@ +package fr.inria.corese.core.next.datamanager.api.support.model; + +/** + * Statistics about a Model's content and structure. + * + * @param statementCount Total number of statements + * @param subjectCount Number of unique subjects + * @param predicateCount Number of unique predicates + * @param objectCount Number of unique objects + * @param contextCount Number of contexts (named graphs) + */ +public record ModelStatistics( + long statementCount, + long subjectCount, + long predicateCount, + long objectCount, + long contextCount +) { + + /** + * Compact constructor with validation. + */ + public ModelStatistics { + if (statementCount < 0) { + throw new IllegalArgumentException("Statement count cannot be negative"); + } + if (subjectCount < 0) { + throw new IllegalArgumentException("Subject count cannot be negative"); + } + if (predicateCount < 0) { + throw new IllegalArgumentException("Predicate count cannot be negative"); + } + if (objectCount < 0) { + throw new IllegalArgumentException("Object count cannot be negative"); + } + if (contextCount < 0) { + throw new IllegalArgumentException("Context count cannot be negative"); + } + } + + /** + * Calculates the average statements per subject. + * + * @return Average or 0.0 if no subjects + */ + public double getAverageStatementsPerSubject() { + return subjectCount > 0 ? (double) statementCount / subjectCount : 0.0; + } + + /** + * Calculates the average statements per predicate. + * + * @return Average or 0.0 if no predicates + */ + public double getAverageStatementsPerPredicate() { + return predicateCount > 0 ? (double) statementCount / predicateCount : 0.0; + } + + /** + * Calculates the average statements per context. + * + * @return Average or 0.0 if no contexts + */ + public double getAverageStatementsPerContext() { + return contextCount > 0 ? (double) statementCount / contextCount : 0.0; + } + + /** + * Checks if the model is empty. + * + * @return true if no statements + */ + public boolean isEmpty() { + return statementCount == 0; + } +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/support/model/MutationResult.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/support/model/MutationResult.java new file mode 100644 index 000000000..db8d14514 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/support/model/MutationResult.java @@ -0,0 +1,375 @@ +package fr.inria.corese.core.next.datamanager.api.support.model; + +import fr.inria.corese.core.next.api.Statement; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Optional; + +/** + * Unified result for mutation operations. + */ +public final class MutationResult { + + private final boolean isBulk; + private final boolean success; + private final List affectedStatements; + private final String message; + private final Throwable error; + + // Bulk-specific fields + private final int totalAttempted; + private final int successCount; + private final int failureCount; + private final List errors; + + /** + * Private constructor - use factory methods or Builder. + */ + private MutationResult(boolean isBulk, boolean success, List affectedStatements, + String message, Throwable error, + int totalAttempted, int successCount, int failureCount, + List errors) { + this.isBulk = isBulk; + this.success = success; + this.affectedStatements = affectedStatements != null ? + List.copyOf(affectedStatements) : + Collections.emptyList(); + this.message = message; + this.error = error; + this.totalAttempted = totalAttempted; + this.successCount = successCount; + this.failureCount = failureCount; + this.errors = errors != null ? + List.copyOf(errors) : + Collections.emptyList(); + } + + /** + * Creates a successful single-operation result. + * + * @param affectedStatement The statement that was affected (can be null) + * @return Successful result + */ + public static MutationResult success(Statement affectedStatement) { + return new MutationResult( + false, // not bulk + true, // success + affectedStatement != null ? List.of(affectedStatement) : Collections.emptyList(), + "Success", // message + null, // no error + 1, 1, 0, // attempted=1, success=1, failure=0 + null // no errors list + ); + } + + /** + * Creates a successful single-operation result with custom message. + * + * @param affectedStatement The statement that was affected (can be null) + * @param message Success message + * @return Successful result + */ + public static MutationResult success(Statement affectedStatement, String message) { + return new MutationResult( + false, true, + affectedStatement != null ? List.of(affectedStatement) : Collections.emptyList(), + message, null, + 1, 1, 0, null + ); + } + + /** + * Creates a failure result for single operation. + * + * @param message Failure message + * @return Failed result + */ + public static MutationResult failure(String message) { + return new MutationResult( + false, false, Collections.emptyList(), message, null, + 1, 0, 1, null + ); + } + + /** + * Creates a failure result with error for single operation. + * + * @param message Failure message + * @param error The error that caused the failure + * @return Failed result + */ + public static MutationResult failure(String message, Throwable error) { + return new MutationResult( + false, false, Collections.emptyList(), message, error, + 1, 0, 1, null + ); + } + + /** + * Creates a builder for bulk operations. + * + * @return New builder instance for bulk results + */ + public static BulkBuilder bulkBuilder() { + return new BulkBuilder(); + } + + /** + * Checks if this is a bulk operation result. + * + * @return true if bulk, false if single + */ + public boolean isBulk() { + return isBulk; + } + + /** + * Checks if the operation was successful. + * For bulk: true if ALL operations succeeded. + * For single: true if the operation succeeded. + * + * @return true if successful + */ + public boolean isSuccess() { + return success; + } + + /** + * Checks if the operation failed. + * + * @return true if failed + */ + public boolean isFailure() { + return !success; + } + + /** + * Returns the result message. + * + * @return Result message + */ + public String getMessage() { + return message; + } + + /** + * Returns the error (if any). + * + * @return Optional containing error, or empty if no error + */ + public Optional getError() { + return Optional.ofNullable(error); + } + + /** + * Returns the single affected statement. + * Convenience method for single operations. + * + * @return The affected statement, or null if none or if bulk operation + * @throws IllegalStateException if called on bulk result with multiple statements + */ + public Statement getAffectedStatement() { + if (affectedStatements.isEmpty()) { + return null; + } + if (affectedStatements.size() == 1) { + return affectedStatements.getFirst(); + } + throw new IllegalStateException( + "Multiple statements affected (" + affectedStatements.size() + + "). Use getAffectedStatements() for bulk operations." + ); + } + + /** + * Returns the total number of operations attempted. + * For single operations: always 1. + * + * @return Total attempted + */ + public int getTotalAttempted() { + return totalAttempted; + } + + /** + * Returns the number of successful operations. + * For single operations: 1 if success, 0 if failure. + * + * @return Success count + */ + public int getSuccessCount() { + return successCount; + } + + /** + * Returns the number of failed operations. + * For single operations: 0 if success, 1 if failure. + * + * @return Failure count + */ + public int getFailureCount() { + return failureCount; + } + + /** + * Returns all errors that occurred (bulk operations only). + * For single operations: empty list (use getError() instead). + * + * @return Unmodifiable list of errors + */ + public List getErrors() { + return errors; + } + + /** + * Checks if all operations were successful (bulk). + * For single operations: same as isSuccess(). + * + * @return true if all successful + */ + public boolean isCompleteSuccess() { + return failureCount == 0 && successCount == totalAttempted; + } + + /** + * Returns the success rate (0.0 to 1.0). + * + * @return Success rate + */ + public double getSuccessRate() { + if (totalAttempted == 0) { + return 0.0; + } + return (double) successCount / totalAttempted; + } + + @Override + public String toString() { + if (isBulk) { + return "MutationResult{bulk=true, attempted=" + totalAttempted + + ", success=" + successCount + ", failure=" + failureCount + + ", successRate=" + String.format("%.2f%%", getSuccessRate() * 100) + "}"; + } else { + if (success) { + return "MutationResult{success=true, statement=" + getAffectedStatement() + + ", message='" + message + "'}"; + } else { + return "MutationResult{success=false, message='" + message + "'" + + (error != null ? ", error=" + error.getClass().getSimpleName() : "") + "}"; + } + } + } + + /** + * Represents an error in a bulk operation. + */ + public static class MutationError { + private final Statement statement; + private final String message; + private final Throwable cause; + + public MutationError(Statement statement, String message) { + this(statement, message, null); + } + + public MutationError(Statement statement, String message, Throwable cause) { + this.statement = statement; + this.message = message; + this.cause = cause; + } + + public Statement getStatement() { + return statement; + } + + public String getMessage() { + return message; + } + + public Throwable getCause() { + return cause; + } + + @Override + public String toString() { + return "MutationError{statement=" + statement + ", message='" + message + "'}"; + } + } + + /** + * Builder for bulk operation results. + */ + public static class BulkBuilder { + private int totalAttempted = 0; + private int successCount = 0; + private int failureCount = 0; + private final List affectedStatements = new ArrayList<>(); + private final List errors = new ArrayList<>(); + private String message = "Bulk operation completed"; + + private BulkBuilder() { + } + + public BulkBuilder totalAttempted(int total) { + this.totalAttempted = total; + return this; + } + + public BulkBuilder successCount(int count) { + this.successCount = count; + return this; + } + + public BulkBuilder failureCount(int count) { + this.failureCount = count; + return this; + } + + public BulkBuilder message(String message) { + this.message = message; + return this; + } + + public void incrementSuccess() { + this.successCount++; + } + + + public BulkBuilder addSuccess(Statement statement) { + if (statement != null) { + this.affectedStatements.add(statement); + } + this.successCount++; + return this; + } + + public BulkBuilder addFailure(Statement statement, String errorMessage) { + this.errors.add(new MutationError(statement, errorMessage)); + this.failureCount++; + return this; + } + + public BulkBuilder addFailure(Statement statement, String errorMessage, Throwable cause) { + this.errors.add(new MutationError(statement, errorMessage, cause)); + this.failureCount++; + return this; + } + + public MutationResult build() { + boolean success = failureCount == 0 && successCount == totalAttempted; + return new MutationResult( + true, // is bulk + success, // overall success + affectedStatements, // affected statements + message, // message + null, // no single error + totalAttempted, + successCount, + failureCount, + errors + ); + } + } +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/support/model/StatementPattern.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/support/model/StatementPattern.java new file mode 100644 index 000000000..bcb7216c3 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/support/model/StatementPattern.java @@ -0,0 +1,238 @@ +package fr.inria.corese.core.next.datamanager.api.support.model; + +import fr.inria.corese.core.next.api.IRI; +import fr.inria.corese.core.next.api.Resource; +import fr.inria.corese.core.next.api.Value; + +import java.util.Arrays; +import java.util.Objects; + +/** + * Pattern for matching statements in queries. + * Each component can be null to act as a wildcard. + */ +public class StatementPattern { + + private final Resource subject; + private final IRI predicate; + private final Value object; + private final Resource[] contexts; + + private StatementPattern(Builder builder) { + this.subject = builder.subject; + this.predicate = builder.predicate; + this.object = builder.object; + this.contexts = builder.contexts != null ? builder.contexts.clone() : new Resource[0]; + } + + /** + * Creates a new builder. + * + * @return Builder instance + */ + public static Builder builder() { + return new Builder(); + } + + /** + * Creates a pattern that matches all statements. + * + * @return Pattern matching everything + */ + public static StatementPattern matchAll() { + return new Builder().build(); + } + + /** + * Creates a pattern from components. + * + * @param subject Subject (null for any) + * @param predicate Predicate (null for any) + * @param object Object (null for any) + * @param contexts Contexts (null or empty for any) + * @return Statement pattern + */ + public static StatementPattern of(Resource subject, IRI predicate, Value object, Resource... contexts) { + return new Builder() + .subject(subject) + .predicate(predicate) + .object(object) + .contexts(contexts) + .build(); + } + + /** + * Gets the subject pattern. + * + * @return Subject or null for wildcard + */ + public Resource getSubject() { + return subject; + } + + /** + * Gets the predicate pattern. + * + * @return Predicate or null for wildcard + */ + public IRI getPredicate() { + return predicate; + } + + /** + * Gets the object pattern. + * + * @return Object or null for wildcard + */ + public Value getObject() { + return object; + } + + /** + * Gets the contexts pattern. + * + * @return Array of contexts (empty for any) + */ + public Resource[] getContexts() { + return contexts.clone(); + } + + /** + * Checks if subject is a wildcard. + * + * @return true if subject is null + */ + public boolean isSubject() { + return subject == null; + } + + /** + * Checks if predicate is a wildcard. + * + * @return true if predicate is null + */ + public boolean isPredicate() { + return predicate == null; + } + + /** + * Checks if object is a wildcard. + * + * @return true if object is null + */ + public boolean isObject() { + return object == null; + } + + /** + * Checks if contexts is a wildcard. + * + * @return true if contexts is empty + */ + public boolean isContexts() { + return contexts.length == 0; + } + + /** + * Checks if this pattern matches all statements. + * + * @return true if all components are wildcards + */ + public boolean matchesAll() { + return isSubject() && isPredicate() && isObject() && isContexts(); + } + + @Override + public String toString() { + return "StatementPattern{" + + "subject=" + subject + + ", predicate=" + predicate + + ", object=" + object + + ", contexts=" + Arrays.toString(contexts) + + '}'; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + StatementPattern that = (StatementPattern) o; + return Objects.equals(subject, that.subject) && + Objects.equals(predicate, that.predicate) && + Objects.equals(object, that.object) && + Arrays.equals(contexts, that.contexts); + } + + @Override + public int hashCode() { + int result = Objects.hash(subject, predicate, object); + result = 31 * result + Arrays.hashCode(contexts); + return result; + } + + /** + * Builder for StatementPattern. + */ + public static class Builder { + private Resource subject; + private IRI predicate; + private Value object; + private Resource[] contexts; + + private Builder() { + } + + /** + * Sets the subject pattern. + * + * @param subject Subject (null for wildcard) + * @return this builder + */ + public Builder subject(Resource subject) { + this.subject = subject; + return this; + } + + /** + * Sets the predicate pattern. + * + * @param predicate Predicate (null for wildcard) + * @return this builder + */ + public Builder predicate(IRI predicate) { + this.predicate = predicate; + return this; + } + + /** + * Sets the object pattern. + * + * @param object Object (null for wildcard) + * @return this builder + */ + public Builder object(Value object) { + this.object = object; + return this; + } + + /** + * Sets the contexts pattern. + * + * @param contexts Contexts (null or empty for wildcard) + * @return this builder + */ + public Builder contexts(Resource... contexts) { + this.contexts = contexts; + return this; + } + + /** + * Builds the pattern. + * + * @return StatementPattern instance + */ + public StatementPattern build() { + return new StatementPattern(this); + } + } +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/transaction/IsolationLevel.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/transaction/IsolationLevel.java new file mode 100644 index 000000000..5fef58b8a --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/transaction/IsolationLevel.java @@ -0,0 +1,48 @@ +package fr.inria.corese.core.next.datamanager.api.transaction; + +/** + * Transaction isolation levels. + */ +public enum IsolationLevel { + + /** + * Read Uncommitted. + */ + READ_UNCOMMITTED(1), + + /** + * Read Committed. + */ + READ_COMMITTED(2), + + /** + * Repeatable Read. + * Guarantees that if a transaction reads data multiple times, + * it will always get the same value. + */ + REPEATABLE_READ(3), + + /** + * Serializable. + * Strictest isolation level. + * Transactions execute as if they were sequential. + */ + SERIALIZABLE(4); + + private final int level; + + IsolationLevel(int level) { + this.level = level; + } + + /** + * Returns the numeric isolation level. + * Higher number means stricter isolation. + * + * @return Numeric level + */ + public int getLevel() { + return level; + } + +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/transaction/Transaction.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/transaction/Transaction.java new file mode 100644 index 000000000..0c164ee4b --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/transaction/Transaction.java @@ -0,0 +1,62 @@ +package fr.inria.corese.core.next.datamanager.api.transaction; + +import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; + +/** + * Handle representing an active transaction. + */ +public interface Transaction extends AutoCloseable { + + /** + * Returns the unique identifier of this transaction. + * + * @return Transaction unique ID + */ + String getId(); + + + /** + * Commits (validates) the transaction. + * All modifications made in this transaction become permanent. + * + * @throws DataManagerException if commit fails + * @throws IllegalStateException if transaction is no longer active + */ + void commit() throws DataManagerException; + + /** + * Rolls back (cancels) the transaction. + * All modifications made in this transaction are cancelled. + * + * @throws DataManagerException if rollback fails + * @throws IllegalStateException if transaction is no longer active + */ + void rollback() throws DataManagerException; + + /** + * Checks if the transaction is still active. + * A transaction is active if it has been created but not yet committed or rolled back. + * + * @return true if transaction is active, false otherwise + */ + boolean isActive(); + + /** + * Returns the current transaction state. + * + * @return Transaction state + */ + TransactionState getState(); + + + /** + * Closes the transaction. + * If transaction is still active, performs automatic rollback. + * + * @throws DataManagerException if close fails + */ + @Override + void close() throws DataManagerException; + + +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/transaction/TransactionManager.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/transaction/TransactionManager.java new file mode 100644 index 000000000..b6e780b0d --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/transaction/TransactionManager.java @@ -0,0 +1,70 @@ +package fr.inria.corese.core.next.datamanager.api.transaction; + + +import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; + +import java.util.Optional; +import java.util.Set; + +/** + * Transaction management for the DataManager. + */ +public interface TransactionManager { + + /** + * Checks if this DataManager supports transactions. + * + * @return true if transactions are supported, false otherwise + */ + boolean supportsTransactions(); + + /** + * Starts a new transaction with the default isolation level. + * + * @return Created transaction handle + * @throws DataManagerException if transaction cannot be started + * @throws UnsupportedOperationException if transactions are not supported + */ + Transaction beginTransaction() throws DataManagerException; + + /** + * Starts a new transaction with a specific isolation level. + * + * @param isolationLevel Desired isolation level + * @return Created transaction handle + * @throws DataManagerException if transaction cannot be started + * @throws UnsupportedOperationException if transactions are not supported + * @throws IllegalArgumentException if isolation level is not supported + */ + Transaction beginTransaction(IsolationLevel isolationLevel) throws DataManagerException; + + /** + * Gets the current transaction of the current thread. + * + * @return Current transaction, or Optional.empty() if no active transaction + */ + Optional getCurrentTransaction(); + + /** + * Checks if a transaction is active on the current thread. + * + * @return true if a transaction is active + */ + default boolean hasActiveTransaction() { + return getCurrentTransaction().map(Transaction::isActive).orElse(false); + } + + /** + * Returns the default isolation level used for new transactions. + * + * @return Default isolation level + */ + IsolationLevel getDefaultIsolationLevel(); + + /** + * Returns the isolation levels supported by this manager. + * + * @return Set of supported isolation levels + */ + Set getSupportedIsolationLevels(); +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/transaction/TransactionState.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/transaction/TransactionState.java new file mode 100644 index 000000000..6bee6c689 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/transaction/TransactionState.java @@ -0,0 +1,42 @@ +package fr.inria.corese.core.next.datamanager.api.transaction; + +public enum TransactionState { + /** + * Transaction is active + */ + ACTIVE("Active"), + + /** + * Transaction has been committed + */ + COMMITTED("Committed"), + + /** + * Transaction has been rolled back + */ + ROLLED_BACK("Rolled back"), + + /** + * Transaction is in error + */ + FAILED("Failed"); + + private final String description; + + TransactionState(String description) { + this.description = description; + } + + public String getDescription() { + return description; + } + + /** + * Checks if transaction can still be used. + * + * @return true if active + */ + public boolean isActive() { + return this == ACTIVE; + } +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManager.java b/src/main/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManager.java new file mode 100644 index 000000000..f83c80020 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManager.java @@ -0,0 +1,165 @@ +package fr.inria.corese.core.next.datamanager.impl; + +import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.datamanager.api.ModelDataManager; +import fr.inria.corese.core.next.datamanager.api.lifecycle.DataManagerLifecycle; +import fr.inria.corese.core.next.datamanager.api.operations.BulkOperations; +import fr.inria.corese.core.next.datamanager.api.operations.MetadataOperations; +import fr.inria.corese.core.next.datamanager.api.operations.MutationOperations; +import fr.inria.corese.core.next.datamanager.api.operations.QueryOperations; +import fr.inria.corese.core.next.datamanager.api.transaction.IsolationLevel; +import fr.inria.corese.core.next.datamanager.api.transaction.TransactionManager; +import fr.inria.corese.core.next.datamanager.impl.lifecycle.LifecycleManagerImpl; +import fr.inria.corese.core.next.datamanager.impl.operations.BulkOperationsImpl; +import fr.inria.corese.core.next.datamanager.impl.operations.MetadataOperationsImpl; +import fr.inria.corese.core.next.datamanager.impl.operations.MutationOperationsImpl; +import fr.inria.corese.core.next.datamanager.impl.operations.QueryOperationsImpl; +import fr.inria.corese.core.next.datamanager.impl.transaction.TransactionManagerImpl; + +/** + * Implementation of ModelDataManager for Corese Model. + * Coordinates all DataManager components and provides a unified API. + */ +public class CoreseModelDataManager implements ModelDataManager { + + private final Model model; + private final QueryOperations queryOperations; + private final MutationOperations mutationOperations; + private final MetadataOperations metadataOperations; + private final BulkOperations bulkOperations; + private final TransactionManager transactionManager; + private final DataManagerLifecycle lifecycle; + + /** + * Protected constructor - use Builder to create instances. + * + * @param builder the builder containing configuration + */ + protected CoreseModelDataManager(Builder builder) { + this.model = builder.model; + + // Initialize operation handlers + this.queryOperations = new QueryOperationsImpl(model); + this.mutationOperations = new MutationOperationsImpl(model); + this.metadataOperations = new MetadataOperationsImpl(model); + this.bulkOperations = new BulkOperationsImpl(model); + + // Initialize transaction manager + this.transactionManager = new TransactionManagerImpl( + model, + builder.transactionSupport, + builder.defaultIsolationLevel + ); + + // Initialize lifecycle manager + this.lifecycle = new LifecycleManagerImpl(model); + } + + @Override + public QueryOperations getQueryOperations() { + return queryOperations; + } + + @Override + public MutationOperations getMutationOperations() { + return mutationOperations; + } + + @Override + public MetadataOperations getMetadataOperations() { + return metadataOperations; + } + + @Override + public BulkOperations getBulkOperations() { + return bulkOperations; + } + + @Override + public TransactionManager getTransactionManager() { + return transactionManager; + } + + @Override + public DataManagerLifecycle getLifecycle() { + return lifecycle; + } + + @Override + public Model getModel() { + return model; + } + + /** + * Creates a new builder for CoreseModelDataManager. + * + * @return new Builder instance + */ + public static Builder builder() { + return new Builder(); + } + + /** + * Builder for CoreseModelDataManager. + */ + public static class Builder { + private Model model; + private boolean transactionSupport = false; + private IsolationLevel defaultIsolationLevel = IsolationLevel.READ_COMMITTED; + + /** + * Sets the Corese Model instance. + * + * @param model the Model to use + * @return this builder + */ + public Builder model(Model model) { + this.model = model; + return this; + } + + /** + * Enables or disables transaction support. + * + * @param enable true to enable transactions + * @return this builder + */ + public Builder transactionSupport(boolean enable) { + this.transactionSupport = enable; + return this; + } + + /** + * Sets the default isolation level for transactions. + * + * @param level the isolation level + * @return this builder + */ + public Builder defaultIsolationLevel(IsolationLevel level) { + this.defaultIsolationLevel = level; + return this; + } + + /** + * Builds the CoreseModelDataManager instance. + * + * @return new CoreseModelDataManager instance + * @throws IllegalStateException if model is not set + */ + public CoreseModelDataManager build() { + if (model == null) { + throw new IllegalStateException("Model must be set before building"); + } + return new CoreseModelDataManager(this); + } + } + + @Override + public String toString() { + return "CoreseModelDataManager{" + + "modelSize=" + model.size() + + ", transactionsSupported=" + transactionManager.supportsTransactions() + + ", lifecycleState=" + lifecycle.getState() + + '}'; + } +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerBuilder.java b/src/main/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerBuilder.java new file mode 100644 index 000000000..19f08fe69 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerBuilder.java @@ -0,0 +1,75 @@ +package fr.inria.corese.core.next.datamanager.impl; + +import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.datamanager.api.ModelDataManager; +import fr.inria.corese.core.next.datamanager.api.ModelDataManagerBuilder; +import fr.inria.corese.core.next.datamanager.api.transaction.IsolationLevel; + +/** + * Builder implementation for creating CoreseModelDataManager instances. + * Provides a fluent API for configuring the DataManager. + */ +public class CoreseModelDataManagerBuilder implements ModelDataManagerBuilder { + + private Model model; + private boolean transactionSupport = false; + private IsolationLevel defaultIsolationLevel = IsolationLevel.READ_COMMITTED; + + /** + * Creates a new CoreseModelDataManagerBuilder. + */ + public CoreseModelDataManagerBuilder() { + } + + /** + * Sets the Corese Model instance to use. + * + * @param model the Model instance + * @return this builder + */ + public CoreseModelDataManagerBuilder model(Model model) { + this.model = model; + return this; + } + + /** + * Enables or disables transaction support. + * + * @param enable true to enable transactions + * @return this builder + */ + public CoreseModelDataManagerBuilder withTransactions(boolean enable) { + this.transactionSupport = enable; + return this; + } + + /** + * Sets the default isolation level for transactions. + * + * @param level the isolation level + * @return this builder + */ + public CoreseModelDataManagerBuilder defaultIsolationLevel(IsolationLevel level) { + this.defaultIsolationLevel = level; + return this; + } + + /** + * Builds the CoreseModelDataManager with the configured settings. + * + * @return a new CoreseModelDataManager instance + * @throws IllegalStateException if no model has been provided + */ + @Override + public ModelDataManager build() { + if (model == null) { + throw new IllegalStateException("Model must be provided before building"); + } + + return CoreseModelDataManager.builder() + .model(model) + .transactionSupport(transactionSupport) + .defaultIsolationLevel(defaultIsolationLevel) + .build(); + } +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/impl/lifecycle/LifecycleManagerImpl.java b/src/main/java/fr/inria/corese/core/next/datamanager/impl/lifecycle/LifecycleManagerImpl.java new file mode 100644 index 000000000..9d64802d6 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/impl/lifecycle/LifecycleManagerImpl.java @@ -0,0 +1,227 @@ +package fr.inria.corese.core.next.datamanager.impl.lifecycle; + +import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.datamanager.api.lifecycle.DataManagerLifecycle; +import fr.inria.corese.core.next.datamanager.api.lifecycle.LifecycleState; +import fr.inria.corese.core.next.datamanager.api.support.config.DataManagerConfig; +import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; +import fr.inria.corese.core.next.datamanager.api.support.exception.ErrorCode; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Implementation of lifecycle management for CoreseModelDataManager. + * Handles initialization, shutdown, and restart operations with proper state management. + */ +public class LifecycleManagerImpl implements DataManagerLifecycle { + + private static final Logger logger = LoggerFactory.getLogger(LifecycleManagerImpl.class); + + /** + * The underlying Corese Model instance. + */ + private final Model model; + + /** + * Current lifecycle state. Volatile ensures visibility across threads. + */ + private volatile LifecycleState state; + + /** + * Current configuration. Null until initialized. + */ + private volatile DataManagerConfig config; + + /** + * Lock object for thread-safe state transitions. + */ + private final Object stateLock = new Object(); + + /** + * Constructs a new lifecycle manager. + * + * @param model the Corese Model to manage; must not be null. + * @throws IllegalArgumentException if model is null. + */ + public LifecycleManagerImpl(Model model) { + if (model == null) { + throw new IllegalArgumentException("Model cannot be null"); + } + this.model = model; + this.state = LifecycleState.NOT_INITIALIZED; + this.config = null; + + logger.debug("LifecycleManager created in state: {}", state); + } + + /** + * Initializes the DataManager with the provided configuration. + * + * @param config DataManager configuration (must not be null) + * @throws DataManagerException if initialization fails + * @throws IllegalStateException if already initialized + * @throws IllegalArgumentException if config is null + */ + @Override + public void initialize(DataManagerConfig config) throws DataManagerException { + if (config == null) { + throw new IllegalArgumentException("Configuration cannot be null"); + } + + synchronized (stateLock) { + if (state != LifecycleState.NOT_INITIALIZED) { + throw new IllegalStateException( + "Cannot initialize: current state is " + state + + ". DataManager must be in NOT_INITIALIZED state." + ); + } + + setState(LifecycleState.INITIALIZING); + } + + try { + logger.info("Initializing DataManager with config: {}", config); + + // Store configuration + this.config = config; + + // Model doesn't have an init() method + // So we just validate the model is ready + if (model == null) { + throw new DataManagerException( + ErrorCode.INITIALIZATION_FAILED, + "Model is null - cannot initialize" + ); + } + + // Optional: Perform any custom initialization logic here + synchronized (stateLock) { + setState(LifecycleState.RUNNING); + } + + logger.info("DataManager initialized successfully. State: {}", state); + + } catch (Exception e) { + logger.error("Initialization failed", e); + + // Rollback to NOT_INITIALIZED on failure + synchronized (stateLock) { + this.config = null; + setState(LifecycleState.NOT_INITIALIZED); + } + + if (e instanceof DataManagerException) { + throw (DataManagerException) e; + } + + throw new DataManagerException( + ErrorCode.INITIALIZATION_FAILED, + "Initialization failed: " + e.getMessage(), + e + ); + } + } + + /** + * Cleanly shuts down the DataManager and releases all resources. + * + * @throws DataManagerException if shutdown fails + * @throws IllegalStateException if not initialized + */ + @Override + public void shutdown() throws DataManagerException { + synchronized (stateLock) { + if (state != LifecycleState.RUNNING) { + throw new IllegalStateException( + "Cannot shutdown: current state is " + state + + ". DataManager must be in RUNNING state." + ); + } + + setState(LifecycleState.SHUTTING_DOWN); + } + + try { + logger.info("Shutting down DataManager"); + + // Model doesn't have a close() or shutdown() method + // So we just clean up our internal state + + // Optional: Perform any cleanup logic here + synchronized (stateLock) { + this.config = null; + setState(LifecycleState.SHUTDOWN); + } + + logger.info("DataManager shut down successfully. State: {}", state); + + } catch (Exception e) { + logger.error("Shutdown failed", e); + + // Even on failure, move to SHUTDOWN state + synchronized (stateLock) { + this.config = null; + setState(LifecycleState.SHUTDOWN); + } + + throw new DataManagerException( + ErrorCode.SHUTDOWN_FAILED, + "Shutdown failed: " + e.getMessage(), + e + ); + } + } + + /** + * Returns the current lifecycle state. + * + * @return Current state + */ + @Override + public LifecycleState getState() { + return state; + } + + /** + * Returns the currently used configuration. + * + * @return Current configuration, or null if not initialized + */ + @Override + public DataManagerConfig getConfig() { + return config; + } + + /** + * Sets the lifecycle state. + * This method should only be called within synchronized blocks. + * + * @param newState the new state to set + */ + private void setState(LifecycleState newState) { + logger.debug("State transition: {} -> {}", state, newState); + this.state = newState; + } + + /** + * Checks if the DataManager can be used in the current state. + * + * @throws IllegalStateException if not in RUNNING state + */ + public void checkUsable() { + if (!state.isRunning()) { + throw new IllegalStateException( + "DataManager is not usable in state: " + state + + ". Must be in RUNNING state." + ); + } + } + + @Override + public String toString() { + return "LifecycleManager{" + + "state=" + state + + ", configPresent=" + (config != null) + + '}'; + } +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/BulkOperationsImpl.java b/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/BulkOperationsImpl.java new file mode 100644 index 000000000..a271779fc --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/BulkOperationsImpl.java @@ -0,0 +1,236 @@ +package fr.inria.corese.core.next.datamanager.impl.operations; + +import fr.inria.corese.core.next.api.IRI; +import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.api.Resource; +import fr.inria.corese.core.next.api.Statement; +import fr.inria.corese.core.next.api.Value; +import fr.inria.corese.core.next.datamanager.api.operations.BulkOperations; +import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; +import fr.inria.corese.core.next.datamanager.api.support.exception.ErrorCode; +import fr.inria.corese.core.next.datamanager.api.support.model.StatementPattern; +import fr.inria.corese.core.next.datamanager.api.support.model.MutationResult; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.List; + +/** + * Implementation of bulk operations for CoreseModelDataManager. + */ +public class BulkOperationsImpl implements BulkOperations { + + private static final Logger logger = LoggerFactory.getLogger(BulkOperationsImpl.class); + + /** The underlying Corese model where operations are performed. */ + private final Model model; + + /** + * Constructs a new bulk operations handler for the specified model. + * + * @param model the Corese Model instance to operate on; must not be null. + * @throws IllegalArgumentException if the provided model is null. + */ + public BulkOperationsImpl(Model model) { + if (model == null) { + throw new IllegalArgumentException("Model cannot be null"); + } + this.model = model; + } + + /** + * Inserts a list of statements into the model in a batch. + * + * @param statements the list of statements to insert; must not be null or empty. + * @return a {@link MutationResult} summarizing the successes and failures of the batch operation. + * @throws DataManagerException if a critical system error occurs during insertion. + * @throws IllegalArgumentException if the statements list is null or empty. + */ + @Override + public MutationResult insertBatch(List statements) throws DataManagerException { + if (statements == null || statements.isEmpty()) { + throw new IllegalArgumentException("Statements list cannot be null or empty"); + } + + logger.info("Inserting batch of {} statements", statements.size()); + + MutationResult.BulkBuilder builder = MutationResult.bulkBuilder() + .totalAttempted(statements.size()) + .message("Batch insert of " + statements.size() + " statement(s)"); + + try { + for (Statement statement : statements) { + try { + boolean added = model.add(statement); + if (added) { + builder.addSuccess(statement); + } else { + builder.addFailure(statement, "Statement already exists"); + } + } catch (Exception e) { + builder.addFailure(statement, "Insert failed: " + e.getMessage(), e); + } + } + + MutationResult result = builder.build(); + logger.info("Batch insert completed: success={}, failure={}", + result.getSuccessCount(), result.getFailureCount()); + return result; + + } catch (Exception e) { + logger.error("Batch insert failed", e); + throw new DataManagerException( + ErrorCode.MUTATION_FAILED, + "Batch insert failed: " + e.getMessage(), + e + ); + } + } + + /** + * Deletes a list of specific statements from the model. + * + * @param statements the list of statements to remove; must not be null or empty. + * @return a {@link MutationResult} summarizing the statements removed and any failures. + * @throws DataManagerException if a critical system error occurs during deletion. + * @throws IllegalArgumentException if the statements list is null or empty. + */ + @Override + public MutationResult deleteBatch(List statements) throws DataManagerException { + if (statements == null || statements.isEmpty()) { + throw new IllegalArgumentException("Statements list cannot be null or empty"); + } + + logger.info("Deleting batch of {} statements", statements.size()); + + MutationResult.BulkBuilder builder = MutationResult.bulkBuilder() + .totalAttempted(statements.size()) + .message("Batch delete of " + statements.size() + " statement(s)"); + + try { + for (Statement statement : statements) { + try { + boolean removed = model.remove(statement); + if (removed) { + builder.addSuccess(statement); + } else { + builder.addFailure(statement, "Statement not found"); + } + } catch (Exception e) { + builder.addFailure(statement, "Delete failed: " + e.getMessage(), e); + } + } + + MutationResult result = builder.build(); + logger.info("Batch delete completed: success={}, failure={}", + result.getSuccessCount(), result.getFailureCount()); + return result; + + } catch (Exception e) { + logger.error("Batch delete failed", e); + throw new DataManagerException( + ErrorCode.MUTATION_FAILED, + "Batch delete failed: " + e.getMessage(), + e + ); + } + } + + /** + * Deletes all statements matching the specified pattern. + * + * @param pattern the pattern defining subject, predicate, object, and/or context filters. + * @return a {@link MutationResult} containing the count of affected statements. + * @throws DataManagerException if the pattern-based deletion fails. + * @throws IllegalArgumentException if pattern is null. + */ + @Override + public MutationResult deleteByPattern(StatementPattern pattern) throws DataManagerException { + if (pattern == null) { + throw new IllegalArgumentException("Pattern cannot be null"); + } + + logger.info("Deleting by pattern: {}", pattern); + + try { + Resource subject = pattern.getSubject(); + IRI predicate = pattern.getPredicate(); + Value object = pattern.getObject(); + Resource[] contexts = pattern.getContexts(); + + int sizeBefore = model.size(); + model.remove(subject, predicate, object, contexts); + int sizeAfter = model.size(); + + int deletedCount = sizeBefore - sizeAfter; + + logger.info("Deleted {} statement(s) by pattern", deletedCount); + + MutationResult.BulkBuilder builder = MutationResult.bulkBuilder() + .totalAttempted(deletedCount) + .message("Deleted " + deletedCount + " statement(s) by pattern"); + + for (int i = 0; i < deletedCount; i++) { + builder.incrementSuccess(); + } + + return builder.build(); + + } catch (Exception e) { + logger.error("Delete by pattern failed", e); + throw new DataManagerException( + ErrorCode.MUTATION_FAILED, + "Delete by pattern failed: " + e.getMessage(), + e + ); + } + } + + /** + * Clears all statements from the specified contexts. + * + * @param contexts the contexts to clear; if null or empty, clears all statements. + * @param silent if true, ignores missing contexts. + * @return a {@link MutationResult} representing the clear outcome. + * @throws DataManagerException if the operation fails at the model level. + */ + @Override + public MutationResult clearContexts(List contexts, boolean silent) + throws DataManagerException { + + logger.info("Clearing contexts: {}, silent={}", contexts, silent); + + try { + Resource[] contextArray = (contexts != null && !contexts.isEmpty()) + ? contexts.toArray(new Resource[0]) + : new Resource[0]; + + int sizeBefore = model.size(); + boolean success = model.clear(contextArray); + int sizeAfter = model.size(); + + int deletedCount = sizeBefore - sizeAfter; + + if (success || deletedCount > 0 || silent) { + return MutationResult.bulkBuilder() + .totalAttempted(deletedCount) + .successCount(deletedCount) + .message("Cleared " + deletedCount + " statement(s)") + .build(); + } else { + return MutationResult.bulkBuilder() + .totalAttempted(0) + .message("No statements to clear") + .build(); + } + + } catch (Exception e) { + logger.error("Clear contexts failed", e); + throw new DataManagerException( + ErrorCode.MUTATION_FAILED, + "Clear contexts failed: " + e.getMessage(), + e + ); + } + } +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/MetadataOperationsImpl.java b/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/MetadataOperationsImpl.java new file mode 100644 index 000000000..b84deda30 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/MetadataOperationsImpl.java @@ -0,0 +1,189 @@ +package fr.inria.corese.core.next.datamanager.impl.operations; + +import fr.inria.corese.core.next.api.IRI; +import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.api.Resource; +import fr.inria.corese.core.next.api.Value; +import fr.inria.corese.core.next.datamanager.api.operations.MetadataOperations; +import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; +import fr.inria.corese.core.next.datamanager.api.support.exception.ErrorCode; +import fr.inria.corese.core.next.datamanager.api.support.model.ModelStatistics; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Collections; +import java.util.Set; + +/** + * Implementation of metadata operations for CoreseModelDataManager. + * Provides access to model statistics and structural information. + */ +public class MetadataOperationsImpl implements MetadataOperations { + + private static final Logger logger = LoggerFactory.getLogger(MetadataOperationsImpl.class); + + /** + * The underlying Corese model instance. + */ + private final Model model; + + /** + * Constructs a new metadata operations handler for the specified model. + * + * @param model the Corese Model to query; must not be null. + * @throws IllegalArgumentException if the provided model is null. + */ + public MetadataOperationsImpl(Model model) { + if (model == null) { + throw new IllegalArgumentException("Model cannot be null"); + } + this.model = model; + } + + /** + * Retrieves all unique predicates used within the model. + * + * @return an unmodifiable Set of predicate IRIs. + * @throws DataManagerException if the metadata retrieval fails. + */ + @Override + public Set getPredicates() throws DataManagerException { + try { + logger.debug("Getting predicates from model"); + + Set predicates = model.predicates(); + + logger.debug("Found {} unique predicates", predicates.size()); + return Collections.unmodifiableSet(predicates); + + } catch (Exception e) { + logger.error("Failed to get predicates", e); + throw new DataManagerException( + ErrorCode.QUERY_FAILED, + "Failed to get predicates: " + e.getMessage(), + e + ); + } + } + + /** + * Retrieves all unique subject resources within the model. + * + * @return an unmodifiable Set of subject resources. + * @throws DataManagerException if the subject retrieval fails. + */ + @Override + public Set getSubjects() throws DataManagerException { + try { + logger.debug("Getting subjects from model"); + + Set subjects = model.subjects(); + + logger.debug("Found {} subjects", subjects.size()); + return Collections.unmodifiableSet(subjects); + + } catch (Exception e) { + logger.error("Failed to get subjects", e); + throw new DataManagerException( + ErrorCode.QUERY_FAILED, + "Failed to get subjects: " + e.getMessage(), + e + ); + } + } + + /** + * Retrieves all unique object values within the model. + * + * @return an unmodifiable Set of object values. + * @throws DataManagerException if the object retrieval fails. + */ + @Override + public Set getObjects() throws DataManagerException { + try { + logger.debug("Getting objects from model"); + + Set objects = model.objects(); + + logger.debug("Found {} objects", objects.size()); + return Collections.unmodifiableSet(objects); + + } catch (Exception e) { + logger.error("Failed to get objects", e); + throw new DataManagerException( + ErrorCode.QUERY_FAILED, + "Failed to get objects: " + e.getMessage(), + e + ); + } + } + + /** + * Retrieves all named graph identifiers (contexts) currently defined in the model. + * + * @return an unmodifiable Set of context resources. + * @throws DataManagerException if the context retrieval fails. + */ + @Override + public Set getContexts() throws DataManagerException { + try { + logger.debug("Getting all contexts"); + + Set contexts = model.contexts(); + + logger.debug("Found {} contexts", contexts.size()); + return Collections.unmodifiableSet(contexts); + + } catch (Exception e) { + logger.error("Failed to get contexts", e); + throw new DataManagerException( + ErrorCode.QUERY_FAILED, + "Failed to get contexts: " + e.getMessage(), + e + ); + } + } + + /** + * Collects and returns general statistics about the model size and composition. + * + * @return a {@link ModelStatistics} object containing counts for statements, subjects, predicates, objects, and contexts. + * @throws DataManagerException if statistics collection fails. + */ + @Override + public ModelStatistics getStatistics() throws DataManagerException { + try { + logger.debug("Collecting model statistics"); + + ModelStatistics stats = getModelStatistics(); + + logger.debug("Statistics collected: {}", stats); + return stats; + + } catch (Exception e) { + logger.error("Failed to collect statistics", e); + throw new DataManagerException( + ErrorCode.QUERY_FAILED, + "Failed to collect statistics: " + e.getMessage(), + e + ); + } + } + + private ModelStatistics getModelStatistics() throws DataManagerException { + long statementCount = model.size(); + long subjectCount = getSubjects().size(); + long predicateCount = getPredicates().size(); + long objectCount = getObjects().size(); + long contextCount = getContexts().size(); + + // Create ModelStatistics using Record constructor + return new ModelStatistics( + statementCount, + subjectCount, + predicateCount, + objectCount, + contextCount + ); + } +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/MutationOperationsImpl.java b/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/MutationOperationsImpl.java new file mode 100644 index 000000000..3729b2df0 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/MutationOperationsImpl.java @@ -0,0 +1,245 @@ +package fr.inria.corese.core.next.datamanager.impl.operations; + +import fr.inria.corese.core.next.api.IRI; +import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.api.Resource; +import fr.inria.corese.core.next.api.Statement; +import fr.inria.corese.core.next.api.Value; +import fr.inria.corese.core.next.datamanager.api.operations.MutationOperations; +import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; +import fr.inria.corese.core.next.datamanager.api.support.exception.ErrorCode; +import fr.inria.corese.core.next.datamanager.api.support.model.MutationResult; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + + +/** + * Implementation of mutation operations for CoreseModelDataManager. + */ +public class MutationOperationsImpl implements MutationOperations { + + private static final Logger logger = LoggerFactory.getLogger(MutationOperationsImpl.class); + + /** The underlying Corese model instance to be mutated. */ + private final Model model; + + /** + * Constructs mutation operations for a specific model. + * + * @param model the Corese Model to mutate; must not be null. + * @throws IllegalArgumentException if the provided model is null. + */ + public MutationOperationsImpl(Model model) { + if (model == null) { + throw new IllegalArgumentException("Model cannot be null"); + } + this.model = model; + } + + /** + * Inserts a single statement into the model. + * + * @param statement the statement object to insert. + * @return a {@link MutationResult} indicating success or failure. + * @throws DataManagerException if the insertion fails at the storage level. + */ + @Override + public MutationResult insertStatement(Statement statement) throws DataManagerException { + if (statement == null) { + throw new IllegalArgumentException("Statement cannot be null"); + } + + try { + logger.debug("Inserting statement: {}", statement); + + boolean added = model.add(statement); + + if (added) { + logger.debug("Statement inserted successfully"); + return MutationResult.success(statement, "Statement inserted"); + } else { + logger.warn("Statement was not inserted (may already exist)"); + return MutationResult.success(statement, "Statement already exists"); + } + + } catch (Exception e) { + logger.error("Failed to insert statement: {}", statement, e); + throw new DataManagerException( + ErrorCode.MUTATION_FAILED, + "Failed to insert statement: " + e.getMessage(), + e + ); + } + } + + /** + * Inserts a statement defined by its individual components into the specified contexts. + * + * @param subject the subject resource. + * @param predicate the predicate IRI. + * @param object the object value. + * @param contexts the array of context (named graph) resources where the statement should be stored. + * @return a {@link MutationResult} summarizing the insertion. + * @throws DataManagerException if the insertion fails. + */ + @Override + public MutationResult insertStatement(Resource subject, IRI predicate, Value object, Resource... contexts) + throws DataManagerException { + + if (subject == null || predicate == null || object == null) { + throw new IllegalArgumentException("Subject, predicate, and object cannot be null"); + } + + try { + logger.debug("Inserting statement: ({}, {}, {}) in contexts: {}", + subject, predicate, object, contexts); + + boolean added = model.add(subject, predicate, object, contexts); + + if (added) { + // For now, we return a simple success result + // In a real implementation, you might want to create a Statement object + return MutationResult.success(null, "Statement inserted"); + } else { + return MutationResult.success(null, "Statement already exists"); + } + + } catch (Exception e) { + logger.error("Failed to insert statement: ({}, {}, {})", subject, predicate, object, e); + throw new DataManagerException( + ErrorCode.MUTATION_FAILED, + "Failed to insert statement: " + e.getMessage(), + e + ); + } + } + + /** + * Deletes a specific statement object from the model. + * + * @param statement the statement to delete. + * @return a {@link MutationResult} indicating if the statement was found and deleted. + * @throws DataManagerException if the deletion fails. + */ + @Override + public MutationResult deleteStatement(Statement statement) throws DataManagerException { + if (statement == null) { + throw new IllegalArgumentException("Statement cannot be null"); + } + + try { + logger.debug("Deleting statement: {}", statement); + + boolean removed = model.remove(statement); + + if (removed) { + logger.debug("Statement deleted successfully"); + return MutationResult.success(statement, "Statement deleted"); + } else { + logger.warn("Statement not found or deletion failed"); + return MutationResult.failure("Statement not found"); + } + + } catch (Exception e) { + logger.error("Failed to delete statement: {}", statement, e); + throw new DataManagerException( + ErrorCode.MUTATION_FAILED, + "Failed to delete statement: " + e.getMessage(), + e + ); + } + } + + /** + * Deletes statements matching the specified subject, predicate, object in the given contexts. + * Supports wildcards (null values). + * + * @param subject the subject resource (or null for wildcard). + * @param predicate the predicate IRI (or null for wildcard). + * @param object the object value (or null for wildcard). + * @param contexts the array of contexts to search in. + * @return a {@link MutationResult} summarizing all deleted statements. + * @throws DataManagerException if the deletion process fails. + */ + @Override + public MutationResult deleteStatements(Resource subject, IRI predicate, Value object, Resource... contexts) + throws DataManagerException { + + try { + logger.debug("Deleting statements: ({}, {}, {}) in contexts: {}", + subject, predicate, object, contexts); + + int sizeBefore = model.size(); + boolean removed = model.remove(subject, predicate, object, contexts); + int sizeAfter = model.size(); + + int deletedCount = sizeBefore - sizeAfter; + + logger.debug("Deleted {} statement(s)", deletedCount); + + if (removed || deletedCount > 0) { + return MutationResult.bulkBuilder() + .totalAttempted(deletedCount) + .successCount(deletedCount) + .message("Deleted " + deletedCount + " statement(s)") + .build(); + } else { + return MutationResult.bulkBuilder() + .totalAttempted(0) + .message("No statements matched the pattern") + .build(); + } + + } catch (Exception e) { + logger.error("Failed to delete statements: ({}, {}, {})", subject, predicate, object, e); + throw new DataManagerException( + ErrorCode.MUTATION_FAILED, + "Failed to delete statements: " + e.getMessage(), + e + ); + } + } + + /** + * Clears statements from the specified contexts. + * + * @param contexts the contexts to clear. + * @return a {@link MutationResult} summarizing the operation. + * @throws DataManagerException if the clear operation fails. + */ + @Override + public MutationResult clear(Resource... contexts) throws DataManagerException { + try { + logger.debug("Clearing contexts: {}", (Object[]) contexts); + + int sizeBefore = model.size(); + boolean cleared = model.clear(contexts); + int sizeAfter = model.size(); + + int deletedCount = sizeBefore - sizeAfter; + + logger.debug("Cleared {} statement(s)", deletedCount); + + if (cleared || deletedCount > 0) { + return MutationResult.bulkBuilder() + .totalAttempted(deletedCount) + .successCount(deletedCount) + .message("Cleared " + deletedCount + " statement(s)") + .build(); + } else { + return MutationResult.bulkBuilder() + .totalAttempted(0) + .message("No statements to clear") + .build(); + } + + } catch (Exception e) { + logger.error("Failed to clear contexts", e); + throw new DataManagerException( + ErrorCode.MUTATION_FAILED, + "Failed to clear contexts: " + e.getMessage(), + e + ); + } + } +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/QueryOperationsImpl.java b/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/QueryOperationsImpl.java new file mode 100644 index 000000000..0eab5644e --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/QueryOperationsImpl.java @@ -0,0 +1,191 @@ +package fr.inria.corese.core.next.datamanager.impl.operations; + +import fr.inria.corese.core.next.api.IRI; +import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.api.Resource; +import fr.inria.corese.core.next.api.Statement; +import fr.inria.corese.core.next.api.Value; +import fr.inria.corese.core.next.datamanager.api.operations.QueryOperations; +import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; +import fr.inria.corese.core.next.datamanager.api.support.exception.ErrorCode; +import fr.inria.corese.core.next.datamanager.api.support.model.StatementPattern; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.stream.Stream; +import java.util.stream.StreamSupport; + +/** + * Implementation of query operations for CoreseModelDataManager. + * Converts Model's Iterable-based API to modern Stream-based API. + */ +public class QueryOperationsImpl implements QueryOperations { + + private static final Logger logger = LoggerFactory.getLogger(QueryOperationsImpl.class); + + /** The underlying Corese model instance to be queried. */ + private final Model model; + + /** + * Constructs query operations for a specific model. + * + * @param model the Corese Model instance to query; must not be null. + * @throws IllegalArgumentException if the provided model is null. + */ + public QueryOperationsImpl(Model model) { + if (model == null) { + throw new IllegalArgumentException("Model cannot be null"); + } + this.model = model; + } + + /** + * Executes a query based on the provided statement pattern and returns a stream of results. + * + * @param pattern the pattern defining filters for subject, predicate, object, and contexts. + * @return a {@link Stream} of {@link Statement} objects matching the pattern. + * @throws DataManagerException if the query fails at the model level. + * @throws IllegalArgumentException if the pattern is null. + */ + @Override + public Stream query(StatementPattern pattern) throws DataManagerException { + if (pattern == null) { + throw new IllegalArgumentException("Pattern cannot be null"); + } + + try { + logger.debug("Querying with pattern: {}", pattern); + + // Extract pattern components + Resource subject = pattern.getSubject(); + IRI predicate = pattern.getPredicate(); + Value object = pattern.getObject(); + Resource[] contexts = pattern.getContexts(); + + // Obtain the iterator from the Model + Iterable iterable = model.getStatements(subject, predicate, object, contexts); + + // Convert the Iterable to a Stream for modern API usage + Stream stream = StreamSupport.stream(iterable.spliterator(), false); + + logger.debug("Query executed successfully"); + return stream; + + } catch (Exception e) { + logger.error("Failed to execute query with pattern: {}", pattern, e); + throw new DataManagerException( + ErrorCode.QUERY_FAILED, + "Failed to execute query: " + e.getMessage(), + e + ); + } + } + + /** + * Counts the number of statements matching the provided pattern. + * + * @param pattern the pattern defining the statements to count. + * @return the number of matching statements. + * @throws DataManagerException if the counting operation fails. + */ + @Override + public long count(StatementPattern pattern) throws DataManagerException { + if (pattern == null) { + throw new IllegalArgumentException("Pattern cannot be null"); + } + + try { + logger.debug("Counting with pattern: {}", pattern); + + // General case: perform a query and count the stream elements + try (Stream stream = query(pattern)) { + long count = stream.count(); + logger.debug("Count (general iteration): {}", count); + return count; + } + + } catch (DataManagerException e) { + throw e; + } catch (Exception e) { + logger.error("Failed to count with pattern: {}", pattern, e); + throw new DataManagerException( + ErrorCode.QUERY_FAILED, + "Failed to count statements: " + e.getMessage(), + e + ); + } + } + + /** + * Checks if at least one statement matches the provided pattern. + * + * @param pattern the pattern defining the search criteria. + * @return {@code true} if at least one matching statement exists, {@code false} otherwise. + * @throws DataManagerException if the existence check fails. + */ + @Override + public boolean exists(StatementPattern pattern) throws DataManagerException { + if (pattern == null) { + throw new IllegalArgumentException("Pattern cannot be null"); + } + + try { + logger.debug("Checking existence with pattern: {}", pattern); + + Resource subject = pattern.getSubject(); + IRI predicate = pattern.getPredicate(); + Value object = pattern.getObject(); + Resource[] contexts = pattern.getContexts(); + + // Use Model's contains method for efficient existence check + boolean exists = model.contains(subject, predicate, object, contexts); + + logger.debug("Exists: {}", exists); + return exists; + + } catch (Exception e) { + logger.error("Failed to check existence with pattern: {}", pattern, e); + throw new DataManagerException( + ErrorCode.QUERY_FAILED, + "Failed to check statement existence: " + e.getMessage(), + e + ); + } + } + + /** + * Filters the model according to the given statement pattern. + * + * @param pattern the pattern defining the filter criteria. + * @return a new Model containing all statements matching the pattern. + * @throws DataManagerException if the filter operation fails. + */ + @Override + public Model filter(StatementPattern pattern) throws DataManagerException { + if (pattern == null) { + throw new IllegalArgumentException("Pattern cannot be null"); + } + + try { + logger.debug("Filtering model with pattern: {}", pattern); + + Resource subject = pattern.getSubject(); + IRI predicate = pattern.getPredicate(); + Value object = pattern.getObject(); + Resource[] contexts = pattern.getContexts(); + + Model filtered = model.filter(subject, predicate, object, contexts); + + logger.debug("Filter completed, result size: {}", filtered.size()); + return filtered; + + } catch (Exception e) { + logger.error("Failed to filter model with pattern: {}", pattern, e); + throw new DataManagerException( + ErrorCode.QUERY_FAILED, + "Failed to filter model: " + e.getMessage(), + e + ); + } + } +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/impl/transaction/TransactionImpl.java b/src/main/java/fr/inria/corese/core/next/datamanager/impl/transaction/TransactionImpl.java new file mode 100644 index 000000000..c469ed4dd --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/impl/transaction/TransactionImpl.java @@ -0,0 +1,209 @@ +package fr.inria.corese.core.next.datamanager.impl.transaction; + +import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; +import fr.inria.corese.core.next.datamanager.api.support.exception.ErrorCode; +import fr.inria.corese.core.next.datamanager.api.transaction.IsolationLevel; +import fr.inria.corese.core.next.datamanager.api.transaction.Transaction; +import fr.inria.corese.core.next.datamanager.api.transaction.TransactionState; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.time.Instant; +import java.util.UUID; +import java.util.concurrent.atomic.AtomicReference; + +/** + * Implementation of a transaction handle for Model operations. + */ +public class TransactionImpl implements Transaction { + + private static final Logger logger = LoggerFactory.getLogger(TransactionImpl.class); + + private final String id; + private final IsolationLevel isolationLevel; + private final Instant startTime; + private final TransactionCallback callback; + + /** + * Thread-safe reference to the current state of the transaction. + */ + private final AtomicReference state; + + /** + * Callback interface for transaction operations. + * Allows the TransactionManager or DataManager to be notified of lifecycle changes. + */ + public interface TransactionCallback { + /** + * Invoked when the transaction is requested to commit. + * + * @param transaction the transaction being committed. + * @throws DataManagerException if the commit operation fails. + */ + void onCommit(TransactionImpl transaction) throws DataManagerException; + + /** + * Invoked when the transaction is requested to rollback. + * + * @param transaction the transaction being rolled back. + * @throws DataManagerException if the rollback operation fails. + */ + void onRollback(TransactionImpl transaction) throws DataManagerException; + } + + /** + * Constructs a new transaction handle. + * + * @param isolationLevel the requested isolation level for this transaction. + * @param callback the callback to handle persistence of changes. + */ + public TransactionImpl(IsolationLevel isolationLevel, TransactionCallback callback) { + this.id = UUID.randomUUID().toString(); + this.isolationLevel = isolationLevel; + this.startTime = Instant.now(); + this.callback = callback; + this.state = new AtomicReference<>(TransactionState.ACTIVE); + + logger.debug("Transaction {} started with isolation level {}", id, isolationLevel); + } + + @Override + public String getId() { + return id; + } + + /** + * Commits the changes made during this transaction. + * + * @throws IllegalStateException if the transaction is not in an ACTIVE state. + */ + @Override + public void commit() throws DataManagerException { + TransactionState currentState = state.get(); + + if (!currentState.isActive()) { + throw new IllegalStateException( + "Cannot commit transaction in state: " + currentState + ); + } + + logger.debug("Committing transaction {}", id); + + try { + // Execute the commit logic via the registered callback + callback.onCommit(this); + + // Atomically update state to COMMITTED + if (!state.compareAndSet(TransactionState.ACTIVE, TransactionState.COMMITTED)) { + throw new IllegalStateException( + "Transaction state changed during commit process" + ); + } + + logger.info("Transaction {} committed successfully", id); + + } catch (DataManagerException e) { + state.set(TransactionState.FAILED); + logger.error("Failed to commit transaction {}", id, e); + throw e; + + } catch (Exception e) { + state.set(TransactionState.FAILED); + logger.error("Unexpected error during commit of transaction {}", id, e); + throw new DataManagerException( + ErrorCode.TRANSACTION_ERROR, + "Failed to commit transaction: " + e.getMessage(), + e + ); + } + } + + /** + * Reverts the changes made during this transaction. + * + * @throws IllegalStateException if the transaction is not in an ACTIVE state. + * @throws DataManagerException if the rollback operation fails. + */ + @Override + public void rollback() throws DataManagerException { + TransactionState currentState = state.get(); + + if (!currentState.isActive()) { + throw new IllegalStateException( + "Cannot rollback transaction in state: " + currentState + ); + } + + logger.debug("Rolling back transaction {}", id); + + try { + // Execute the rollback logic via the registered callback + callback.onRollback(this); + + // Atomically update state to ROLLED_BACK + if (!state.compareAndSet(TransactionState.ACTIVE, TransactionState.ROLLED_BACK)) { + throw new IllegalStateException( + "Transaction state changed during rollback process" + ); + } + + logger.info("Transaction {} rolled back successfully", id); + + } catch (DataManagerException e) { + state.set(TransactionState.FAILED); + logger.error("Failed to rollback transaction {}", id, e); + throw e; + + } catch (Exception e) { + state.set(TransactionState.FAILED); + logger.error("Unexpected error during rollback of transaction {}", id, e); + throw new DataManagerException( + ErrorCode.TRANSACTION_ERROR, + "Failed to rollback transaction: " + e.getMessage(), + e + ); + } + } + + @Override + public boolean isActive() { + return state.get().isActive(); + } + + @Override + public TransactionState getState() { + return state.get(); + } + + /** + * Closes the transaction. If the transaction is still active, an automatic rollback is performed. + * + * @throws DataManagerException if an automatic rollback fails. + */ + @Override + public void close() throws DataManagerException { + TransactionState currentState = state.get(); + + if (currentState.isActive()) { + logger.warn("Transaction {} closed while still active; performing automatic rollback", id); + try { + rollback(); + } catch (DataManagerException e) { + logger.error("Failed to perform auto-rollback for transaction {}", id, e); + throw e; + } + } + + logger.debug("Transaction {} closed in state {}", id, state.get()); + } + + @Override + public String toString() { + return "Transaction{" + + "id='" + id + '\'' + + ", isolationLevel=" + isolationLevel + + ", state=" + state.get() + + ", startTime=" + startTime + + '}'; + } +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/impl/transaction/TransactionManagerImpl.java b/src/main/java/fr/inria/corese/core/next/datamanager/impl/transaction/TransactionManagerImpl.java new file mode 100644 index 000000000..5cf75e6ee --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/impl/transaction/TransactionManagerImpl.java @@ -0,0 +1,194 @@ +package fr.inria.corese.core.next.datamanager.impl.transaction; + +import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; +import fr.inria.corese.core.next.datamanager.api.support.exception.ErrorCode; +import fr.inria.corese.core.next.datamanager.api.transaction.IsolationLevel; +import fr.inria.corese.core.next.datamanager.api.transaction.Transaction; +import fr.inria.corese.core.next.datamanager.api.transaction.TransactionManager; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.EnumSet; +import java.util.Optional; +import java.util.Set; + +/** + * Transaction manager implementation for CoreseModelDataManager. + * Note: This is a basic implementation as Model may not support native transactions. + */ +public class TransactionManagerImpl implements TransactionManager { + + private static final Logger logger = LoggerFactory.getLogger(TransactionManagerImpl.class); + + private final boolean transactionSupport; + private final IsolationLevel defaultIsolationLevel; + + /** + * Thread-local storage to track the current active transaction handle for the calling thread. + */ + private final ThreadLocal currentTransaction = new ThreadLocal<>(); + + /** + * Constructs a new TransactionManager. + * + * @param model the underlying Corese Model. + * @param transactionSupport flag indicating if transaction features are enabled. + * @param defaultIsolationLevel the isolation level to use when none is specified. + * @throws IllegalArgumentException if model or defaultIsolationLevel is null. + */ + public TransactionManagerImpl( + Model model, + boolean transactionSupport, + IsolationLevel defaultIsolationLevel) { + + if (model == null) { + throw new IllegalArgumentException("Model cannot be null"); + } + if (defaultIsolationLevel == null) { + throw new IllegalArgumentException("Default isolation level cannot be null"); + } + + this.transactionSupport = transactionSupport; + this.defaultIsolationLevel = defaultIsolationLevel; + + logger.info("TransactionManager initialized: support={}, defaultLevel={}", + transactionSupport, defaultIsolationLevel); + } + + @Override + public boolean supportsTransactions() { + return transactionSupport; + } + + @Override + public Transaction beginTransaction() throws DataManagerException { + return beginTransaction(defaultIsolationLevel); + } + + @Override + public Transaction beginTransaction(IsolationLevel isolationLevel) throws DataManagerException { + if (!supportsTransactions()) { + throw new UnsupportedOperationException("Transactions are not supported by this manager configuration."); + } + + if (isolationLevel == null) { + throw new IllegalArgumentException("Isolation level cannot be null"); + } + + if (!getSupportedIsolationLevels().contains(isolationLevel)) { + throw new IllegalArgumentException( + "Isolation level " + isolationLevel + " is not supported by the current storage backend." + ); + } + + // Check for existing active transaction to prevent unsupported nesting + TransactionImpl existing = currentTransaction.get(); + if (existing != null && existing.isActive()) { + logger.warn("Attempted to start a new transaction while transaction {} is still active.", + existing.getId()); + throw new DataManagerException( + ErrorCode.TRANSACTION_ERROR, + "Nested transactions are not supported. Current active transaction: " + existing.getId() + ); + } + + TransactionImpl.TransactionCallback callback = new TransactionImpl.TransactionCallback() { + @Override + public void onCommit(TransactionImpl transaction) throws DataManagerException { + performCommit(transaction); + } + + @Override + public void onRollback(TransactionImpl transaction) throws DataManagerException { + performRollback(transaction); + } + }; + + // Create the new transaction handle and register it to the current thread + TransactionImpl transaction = new TransactionImpl(isolationLevel, callback); + currentTransaction.set(transaction); + + logger.info("Started transaction {} with isolation level {}", + transaction.getId(), isolationLevel); + + return transaction; + } + + @Override + public Optional getCurrentTransaction() { + return Optional.ofNullable(currentTransaction.get()); + } + + @Override + public IsolationLevel getDefaultIsolationLevel() { + return defaultIsolationLevel; + } + + @Override + public Set getSupportedIsolationLevels() { + // Model currently supports standard levels + return EnumSet.allOf(IsolationLevel.class); + } + + /** + * Executes the internal commit logic for a transaction. + * This method is triggered by the {@link TransactionImpl#commit()} method via the callback. + * + * @param transaction the transaction to commit. + * @throws DataManagerException if the model commit fails. + */ + private void performCommit(TransactionImpl transaction) throws DataManagerException { + try { + logger.debug("Performing commit for transaction {}", transaction.getId()); + + // Model doesn't have a native init() or commit() method + // Changes are already applied to the model + // This is a no-op for now + + // Clear the thread-local reference as the transaction lifecycle is ending + currentTransaction.remove(); + + logger.debug("Commit completed for transaction {}", transaction.getId()); + + } catch (Exception e) { + logger.error("Failed to commit transaction {}", transaction.getId(), e); + throw new DataManagerException( + ErrorCode.TRANSACTION_ERROR, + "Failed to commit transaction changes to the model: " + e.getMessage(), + e + ); + } + } + + /** + * Executes the internal rollback logic for a transaction. + * This method is triggered by the {@link TransactionImpl#rollback()} method via the callback. + * + * @param transaction the transaction to roll back. + * @throws DataManagerException if the rollback operation fails. + */ + private void performRollback(TransactionImpl transaction) throws DataManagerException { + try { + logger.debug("Performing rollback for transaction {}", transaction.getId()); + + // Model doesn't support native rollback + // In a real implementation, you would need to track changes and revert them + // For now, this is a no-op + logger.warn("Model does not support native transaction rollback - changes cannot be reverted"); + + // Clear the thread-local reference + currentTransaction.remove(); + + logger.debug("Rollback completed for transaction {}", transaction.getId()); + + } catch (Exception e) { + logger.error("Failed to rollback transaction {}", transaction.getId(), e); + throw new DataManagerException( + ErrorCode.TRANSACTION_ERROR, + "Failed to rollback transaction changes: " + e.getMessage(), + e + ); + } + } +} \ No newline at end of file From 667d72df5cb085fac991cd1270a867daee17f632 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Fri, 30 Jan 2026 11:24:17 +0100 Subject: [PATCH 2/9] Refactor DataManager architecture new Model TU --- .../api/lifecycle/LifecycleStateTest.java | 59 +++++++ .../support/config/DataManagerConfigTest.java | 164 ++++++++++++++++++ .../support/model/ModelStatisticsTest.java | 124 +++++++++++++ 3 files changed, 347 insertions(+) create mode 100644 src/test/java/fr/inria/corese/core/next/datamanager/api/lifecycle/LifecycleStateTest.java create mode 100644 src/test/java/fr/inria/corese/core/next/datamanager/api/support/config/DataManagerConfigTest.java create mode 100644 src/test/java/fr/inria/corese/core/next/datamanager/api/support/model/ModelStatisticsTest.java diff --git a/src/test/java/fr/inria/corese/core/next/datamanager/api/lifecycle/LifecycleStateTest.java b/src/test/java/fr/inria/corese/core/next/datamanager/api/lifecycle/LifecycleStateTest.java new file mode 100644 index 000000000..94c15727a --- /dev/null +++ b/src/test/java/fr/inria/corese/core/next/datamanager/api/lifecycle/LifecycleStateTest.java @@ -0,0 +1,59 @@ +package fr.inria.corese.core.next.datamanager.api.lifecycle; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for LifecycleState enum. + */ +@DisplayName("LifecycleState Enum Tests") +class LifecycleStateTest { + + @Test + @DisplayName("Should have all 5 lifecycle states defined") + void testAllStatesExist() { + assertNotNull(LifecycleState.NOT_INITIALIZED); + assertNotNull(LifecycleState.INITIALIZING); + assertNotNull(LifecycleState.RUNNING); + assertNotNull(LifecycleState.SHUTTING_DOWN); + assertNotNull(LifecycleState.SHUTDOWN); + } + + @Test + @DisplayName("Should return true for isRunning() only when state is RUNNING") + void testIsRunning() { + assertTrue(LifecycleState.RUNNING.isRunning()); + + assertFalse(LifecycleState.NOT_INITIALIZED.isRunning()); + assertFalse(LifecycleState.INITIALIZING.isRunning()); + assertFalse(LifecycleState.SHUTTING_DOWN.isRunning()); + assertFalse(LifecycleState.SHUTDOWN.isRunning()); + } + + @Test + @DisplayName("Should return correct description for each state") + void testDescriptions() { + assertEquals("Not initialized", LifecycleState.NOT_INITIALIZED.getDescription()); + assertEquals("Initializing", LifecycleState.INITIALIZING.getDescription()); + assertEquals("Running", LifecycleState.RUNNING.getDescription()); + assertEquals("Shutting down", LifecycleState.SHUTTING_DOWN.getDescription()); + assertEquals("Shutdown", LifecycleState.SHUTDOWN.getDescription()); + } + + @Test + @DisplayName("Should have exactly 5 enum values") + void testEnumValues() { + LifecycleState[] states = LifecycleState.values(); + assertEquals(5, states.length); + } + + @Test + @DisplayName("Should correctly resolve valueOf() for valid and invalid state names") + void testValueOf() { + assertEquals(LifecycleState.RUNNING, LifecycleState.valueOf("RUNNING")); + assertThrows(IllegalArgumentException.class, + () -> LifecycleState.valueOf("INVALID")); + } +} \ No newline at end of file diff --git a/src/test/java/fr/inria/corese/core/next/datamanager/api/support/config/DataManagerConfigTest.java b/src/test/java/fr/inria/corese/core/next/datamanager/api/support/config/DataManagerConfigTest.java new file mode 100644 index 000000000..e28907b08 --- /dev/null +++ b/src/test/java/fr/inria/corese/core/next/datamanager/api/support/config/DataManagerConfigTest.java @@ -0,0 +1,164 @@ +package fr.inria.corese.core.next.datamanager.api.support.config; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.util.Map; +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for DataManagerConfig. + */ +@DisplayName("DataManagerConfig Tests") +class DataManagerConfigTest { + + @Test + @DisplayName("Should build config with all properties set") + void testBuilderWithAllProperties() { + DataManagerConfig config = DataManagerConfig.builder() + .debug(true) + .transactionSupport(true) + .property("timeout", 5000) + .property("maxConnections", 100) + .build(); + + assertTrue(config.isDebug()); + assertEquals(Optional.of(5000), config.getProperty("timeout", Integer.class)); + assertEquals(Optional.of(100), config.getProperty("maxConnections", Integer.class)); + } + + @Test + @DisplayName("Should use default values when no properties are set") + void testDefaultValues() { + DataManagerConfig config = DataManagerConfig.builder() + .build(); + + assertFalse(config.isDebug()); + assertTrue(config.getProperties().isEmpty()); + } + + @Test + @DisplayName("Should throw IllegalArgumentException for invalid property keys or values") + void testPropertyValidation() { + DataManagerConfig.Builder builder = DataManagerConfig.builder(); + + assertThrows(IllegalArgumentException.class, + () -> builder.property(null, "value")); + + assertThrows(IllegalArgumentException.class, + () -> builder.property("", "value")); + + assertThrows(IllegalArgumentException.class, + () -> builder.property(" ", "value")); + + assertThrows(IllegalArgumentException.class, + () -> builder.property("key", null)); + } + + @Test + @DisplayName("Should retrieve typed property correctly and return empty for wrong type") + void testGetPropertyTyped() { + DataManagerConfig config = DataManagerConfig.builder() + .property("timeout", 5000) + .property("name", "test") + .build(); + + Optional timeout = config.getProperty("timeout", Integer.class); + assertTrue(timeout.isPresent()); + assertEquals(5000, timeout.get()); + + Optional timeoutAsString = config.getProperty("timeout", String.class); + assertFalse(timeoutAsString.isPresent()); + + Optional missing = config.getProperty("missing", Integer.class); + assertFalse(missing.isPresent()); + } + + @Test + @DisplayName("Should retrieve untyped property as Optional") + void testGetPropertyUntyped() { + DataManagerConfig config = DataManagerConfig.builder() + .property("key", "value") + .build(); + + Optional value = config.getProperty("key"); + assertTrue(value.isPresent()); + assertEquals("value", value.get()); + + Optional missing = config.getProperty("missing"); + assertFalse(missing.isPresent()); + } + + @Test + @DisplayName("Should return all properties as immutable map") + void testGetAllProperties() { + DataManagerConfig config = DataManagerConfig.builder() + .property("key1", "value1") + .property("key2", 123) + .build(); + + Map properties = config.getProperties(); + assertEquals(2, properties.size()); + assertEquals("value1", properties.get("key1")); + assertEquals(123, properties.get("key2")); + } + + @Test + @DisplayName("Should ensure properties map is immutable") + void testPropertiesImmutability() { + DataManagerConfig config = DataManagerConfig.builder() + .property("key", "value") + .build(); + + Map properties = config.getProperties(); + + assertThrows(UnsupportedOperationException.class, + () -> properties.put("newKey", "newValue")); + } + + @Test + @DisplayName("Should include debug and transactionSupport in toString() output") + void testToString() { + DataManagerConfig config = DataManagerConfig.builder() + .debug(true) + .transactionSupport(false) + .property("test", "value") + .build(); + + String str = config.toString(); + assertTrue(str.contains("DataManagerConfig")); + assertTrue(str.contains("debug=true")); + assertTrue(str.contains("transactionSupport=false")); + } + + @Test + @DisplayName("Should support builder method chaining with last value winning") + void testBuilderChaining() { + DataManagerConfig config = DataManagerConfig.builder() + .debug(true) + .transactionSupport(true) + .property("key1", "value1") + .property("key2", 123) + .debug(false) + .build(); + + assertFalse(config.isDebug()); + } + + @Test + @DisplayName("Should create independent instances on multiple builds from same builder") + void testMultipleBuilds() { + DataManagerConfig.Builder builder = DataManagerConfig.builder() + .debug(true) + .property("key", "value"); + + DataManagerConfig config1 = builder.build(); + DataManagerConfig config2 = builder.build(); + + assertTrue(config1.isDebug()); + assertTrue(config2.isDebug()); + assertNotSame(config1, config2); + } +} \ No newline at end of file diff --git a/src/test/java/fr/inria/corese/core/next/datamanager/api/support/model/ModelStatisticsTest.java b/src/test/java/fr/inria/corese/core/next/datamanager/api/support/model/ModelStatisticsTest.java new file mode 100644 index 000000000..e3a1320f7 --- /dev/null +++ b/src/test/java/fr/inria/corese/core/next/datamanager/api/support/model/ModelStatisticsTest.java @@ -0,0 +1,124 @@ +package fr.inria.corese.core.next.datamanager.api.support.model; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for ModelStatistics Record. + */ +@DisplayName("ModelStatistics Record Tests") +class ModelStatisticsTest { + + @Test + @DisplayName("Should create record with all field values correctly assigned") + void testRecordCreation() { + ModelStatistics stats = new ModelStatistics(1000, 250, 50, 400, 5); + + assertEquals(1000, stats.statementCount()); + assertEquals(250, stats.subjectCount()); + assertEquals(50, stats.predicateCount()); + assertEquals(400, stats.objectCount()); + assertEquals(5, stats.contextCount()); + } + + @Test + @DisplayName("Should calculate correct average statements per subject") + void testAverageStatementsPerSubject() { + ModelStatistics stats = new ModelStatistics(1000, 250, 50, 400, 5); + + assertEquals(4.0, stats.getAverageStatementsPerSubject(), 0.01); + } + + @Test + @DisplayName("Should calculate correct average statements per predicate") + void testAverageStatementsPerPredicate() { + ModelStatistics stats = new ModelStatistics(1000, 250, 50, 400, 5); + + assertEquals(20.0, stats.getAverageStatementsPerPredicate(), 0.01); + } + + @Test + @DisplayName("Should calculate correct average statements per context") + void testAverageStatementsPerContext() { + ModelStatistics stats = new ModelStatistics(1000, 250, 50, 400, 5); + + assertEquals(200.0, stats.getAverageStatementsPerContext(), 0.01); + } + + @Test + @DisplayName("Should return 0.0 for averages when divisor is zero") + void testAverageWithZeroDivisor() { + ModelStatistics stats = new ModelStatistics(1000, 0, 0, 400, 0); + + assertEquals(0.0, stats.getAverageStatementsPerSubject()); + assertEquals(0.0, stats.getAverageStatementsPerPredicate()); + assertEquals(0.0, stats.getAverageStatementsPerContext()); + } + + @Test + @DisplayName("Should correctly identify empty and non-empty statistics") + void testIsEmpty() { + ModelStatistics empty = new ModelStatistics(0, 0, 0, 0, 0); + ModelStatistics notEmpty = new ModelStatistics(1, 1, 1, 1, 1); + + assertTrue(empty.isEmpty()); + assertFalse(notEmpty.isEmpty()); + } + + @Test + @DisplayName("Should throw IllegalArgumentException for negative values in any field") + void testNegativeValueValidation() { + assertThrows(IllegalArgumentException.class, + () -> new ModelStatistics(-1, 250, 50, 400, 5), + "Negative statementCount should throw exception"); + + assertThrows(IllegalArgumentException.class, + () -> new ModelStatistics(1000, -1, 50, 400, 5), + "Negative subjectCount should throw exception"); + + assertThrows(IllegalArgumentException.class, + () -> new ModelStatistics(1000, 250, -1, 400, 5), + "Negative predicateCount should throw exception"); + + assertThrows(IllegalArgumentException.class, + () -> new ModelStatistics(1000, 250, 50, -1, 5), + "Negative objectCount should throw exception"); + + assertThrows(IllegalArgumentException.class, + () -> new ModelStatistics(1000, 250, 50, 400, -1), + "Negative contextCount should throw exception"); + } + + @Test + @DisplayName("Should implement equals() correctly for Record") + void testEquality() { + ModelStatistics stats1 = new ModelStatistics(1000, 250, 50, 400, 5); + ModelStatistics stats2 = new ModelStatistics(1000, 250, 50, 400, 5); + ModelStatistics stats3 = new ModelStatistics(2000, 250, 50, 400, 5); + + assertEquals(stats1, stats2); + assertNotEquals(stats1, stats3); + } + + @Test + @DisplayName("Should generate consistent hashCode() for equal records") + void testHashCode() { + ModelStatistics stats1 = new ModelStatistics(1000, 250, 50, 400, 5); + ModelStatistics stats2 = new ModelStatistics(1000, 250, 50, 400, 5); + + assertEquals(stats1.hashCode(), stats2.hashCode()); + } + + @Test + @DisplayName("Should include field values and class name in toString() output") + void testToString() { + ModelStatistics stats = new ModelStatistics(1000, 250, 50, 400, 5); + String str = stats.toString(); + + assertTrue(str.contains("1000")); + assertTrue(str.contains("250")); + assertTrue(str.contains("ModelStatistics")); + } +} \ No newline at end of file From f6247f1c02449f4d90c5c940dc65a28f42d72761 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Fri, 30 Jan 2026 14:47:32 +0100 Subject: [PATCH 3/9] Refactor DataManager architecture new Model TU --- .../api/support/model/MutationResultTest.java | 145 ++++++++++++++++++ .../support/model/StatementPatternTest.java | 134 ++++++++++++++++ .../api/transaction/TransactionStateTest.java | 57 +++++++ 3 files changed, 336 insertions(+) create mode 100644 src/test/java/fr/inria/corese/core/next/datamanager/api/support/model/MutationResultTest.java create mode 100644 src/test/java/fr/inria/corese/core/next/datamanager/api/support/model/StatementPatternTest.java create mode 100644 src/test/java/fr/inria/corese/core/next/datamanager/api/transaction/TransactionStateTest.java diff --git a/src/test/java/fr/inria/corese/core/next/datamanager/api/support/model/MutationResultTest.java b/src/test/java/fr/inria/corese/core/next/datamanager/api/support/model/MutationResultTest.java new file mode 100644 index 000000000..a6b559262 --- /dev/null +++ b/src/test/java/fr/inria/corese/core/next/datamanager/api/support/model/MutationResultTest.java @@ -0,0 +1,145 @@ +package fr.inria.corese.core.next.datamanager.api.support.model; + +import fr.inria.corese.core.next.api.Statement; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for MutationResult. + */ +@DisplayName("MutationResult Tests") +class MutationResultTest { + + @Test + @DisplayName("Should create successful single mutation result") + void testSuccessSingle() { + Statement stmt = Mockito.mock(Statement.class); + MutationResult result = MutationResult.success(stmt); + + assertTrue(result.isSuccess()); + assertFalse(result.isFailure()); + assertFalse(result.isBulk()); + assertEquals(stmt, result.getAffectedStatement()); + assertEquals(1, result.getTotalAttempted()); + assertEquals(1, result.getSuccessCount()); + assertEquals(0, result.getFailureCount()); + } + + @Test + @DisplayName("Should create successful result with custom message") + void testSuccessWithMessage() { + Statement stmt = Mockito.mock(Statement.class); + MutationResult result = MutationResult.success(stmt, "Custom message"); + + assertTrue(result.isSuccess()); + assertEquals("Custom message", result.getMessage()); + } + + @Test + @DisplayName("Should create failure result with message") + void testFailure() { + MutationResult result = MutationResult.failure("Operation failed"); + + assertTrue(result.isFailure()); + assertFalse(result.isSuccess()); + assertEquals("Operation failed", result.getMessage()); + assertEquals(0, result.getSuccessCount()); + assertEquals(1, result.getFailureCount()); + } + + @Test + @DisplayName("Should create failure result with error exception") + void testFailureWithError() { + Exception error = new RuntimeException("Test error"); + MutationResult result = MutationResult.failure("Failed", error); + + assertTrue(result.isFailure()); + assertTrue(result.getError().isPresent()); + assertEquals(error, result.getError().get()); + } + + @Test + @DisplayName("Should build bulk result with mixed successes and failures") + void testBulkBuilder() { + Statement stmt1 = Mockito.mock(Statement.class); + Statement stmt2 = Mockito.mock(Statement.class); + + MutationResult result = MutationResult.bulkBuilder() + .totalAttempted(3) + .addSuccess(stmt1) + .addSuccess(stmt2) + .addFailure(null, "Failed to insert") + .message("Bulk operation") + .build(); + + assertTrue(result.isBulk()); + assertFalse(result.isSuccess()); // Not all succeeded + assertEquals(3, result.getTotalAttempted()); + assertEquals(2, result.getSuccessCount()); + assertEquals(1, result.getFailureCount()); + assertEquals("Bulk operation", result.getMessage()); + } + + @Test + @DisplayName("Should recognize complete success in bulk operations") + void testBulkCompleteSuccess() { + Statement stmt1 = Mockito.mock(Statement.class); + Statement stmt2 = Mockito.mock(Statement.class); + + MutationResult result = MutationResult.bulkBuilder() + .totalAttempted(2) + .addSuccess(stmt1) + .addSuccess(stmt2) + .build(); + + assertTrue(result.isSuccess()); + assertTrue(result.isCompleteSuccess()); + assertEquals(1.0, result.getSuccessRate(), 0.01); + } + + @Test + @DisplayName("Should calculate correct success rate") + void testSuccessRate() { + MutationResult result = MutationResult.bulkBuilder() + .totalAttempted(10) + .successCount(7) + .failureCount(3) + .build(); + + assertEquals(0.7, result.getSuccessRate(), 0.01); + } + + @Test + @DisplayName("Should throw IllegalStateException when getting single statement from bulk result") + void testGetAffectedStatementThrowsForMultiple() { + Statement stmt1 = Mockito.mock(Statement.class); + Statement stmt2 = Mockito.mock(Statement.class); + + MutationResult result = MutationResult.bulkBuilder() + .addSuccess(stmt1) + .addSuccess(stmt2) + .build(); + + assertThrows(IllegalStateException.class, result::getAffectedStatement); + } + + @Test + @DisplayName("Should track error details for failed mutations") + void testErrorTracking() { + Statement stmt = Mockito.mock(Statement.class); + Exception error = new RuntimeException("Test"); + + MutationResult result = MutationResult.bulkBuilder() + .addFailure(stmt, "Error occurred", error) + .build(); + + assertEquals(1, result.getErrors().size()); + MutationResult.MutationError mutError = result.getErrors().getFirst(); + assertEquals(stmt, mutError.getStatement()); + assertEquals("Error occurred", mutError.getMessage()); + assertEquals(error, mutError.getCause()); + } +} \ No newline at end of file diff --git a/src/test/java/fr/inria/corese/core/next/datamanager/api/support/model/StatementPatternTest.java b/src/test/java/fr/inria/corese/core/next/datamanager/api/support/model/StatementPatternTest.java new file mode 100644 index 000000000..bb4f43f35 --- /dev/null +++ b/src/test/java/fr/inria/corese/core/next/datamanager/api/support/model/StatementPatternTest.java @@ -0,0 +1,134 @@ +package fr.inria.corese.core.next.datamanager.api.support.model; + +import fr.inria.corese.core.next.api.IRI; +import fr.inria.corese.core.next.api.Resource; +import fr.inria.corese.core.next.api.Value; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for StatementPattern. + */ +@DisplayName("StatementPattern Tests") +class StatementPatternTest { + + @Test + @DisplayName("Should build pattern with all components using builder") + void testBuilder() { + Resource subject = Mockito.mock(Resource.class); + IRI predicate = Mockito.mock(IRI.class); + Value object = Mockito.mock(Value.class); + Resource ctx1 = Mockito.mock(Resource.class); + Resource ctx2 = Mockito.mock(Resource.class); + + StatementPattern pattern = StatementPattern.builder() + .subject(subject) + .predicate(predicate) + .object(object) + .contexts(ctx1, ctx2) + .build(); + + assertEquals(subject, pattern.getSubject()); + assertEquals(predicate, pattern.getPredicate()); + assertEquals(object, pattern.getObject()); + assertEquals(2, pattern.getContexts().length); + } + + @Test + @DisplayName("Should create match-all pattern with all wildcards") + void testMatchAll() { + StatementPattern pattern = StatementPattern.matchAll(); + + assertNull(pattern.getSubject()); + assertNull(pattern.getPredicate()); + assertNull(pattern.getObject()); + assertEquals(0, pattern.getContexts().length); + assertTrue(pattern.matchesAll()); + } + + @Test + @DisplayName("Should create pattern using factory method of()") + void testFactoryMethod() { + Resource subject = Mockito.mock(Resource.class); + IRI predicate = Mockito.mock(IRI.class); + Value object = Mockito.mock(Value.class); + Resource ctx = Mockito.mock(Resource.class); + + StatementPattern pattern = StatementPattern.of(subject, predicate, object, ctx); + + assertEquals(subject, pattern.getSubject()); + assertEquals(predicate, pattern.getPredicate()); + assertEquals(object, pattern.getObject()); + assertEquals(1, pattern.getContexts().length); + assertFalse(pattern.matchesAll()); + } + + @Test + @DisplayName("Should correctly identify wildcard components") + void testWildcardCheckers() { + StatementPattern allWildcards = StatementPattern.matchAll(); + + assertTrue(allWildcards.isSubject()); + assertTrue(allWildcards.isPredicate()); + assertTrue(allWildcards.isObject()); + assertTrue(allWildcards.isContexts()); + + Resource subject = Mockito.mock(Resource.class); + StatementPattern withSubject = StatementPattern.builder() + .subject(subject) + .build(); + + assertFalse(withSubject.isSubject()); + assertTrue(withSubject.isPredicate()); + assertTrue(withSubject.isObject()); + assertTrue(withSubject.isContexts()); + } + + @Test + @DisplayName("Should implement equals() and hashCode() correctly") + void testEquality() { + Resource subject = Mockito.mock(Resource.class); + IRI predicate = Mockito.mock(IRI.class); + + StatementPattern pattern1 = StatementPattern.builder() + .subject(subject) + .predicate(predicate) + .build(); + + StatementPattern pattern2 = StatementPattern.builder() + .subject(subject) + .predicate(predicate) + .build(); + + assertEquals(pattern1, pattern2); + assertEquals(pattern1.hashCode(), pattern2.hashCode()); + } + + @Test + @DisplayName("Should include class name in toString() output") + void testToString() { + StatementPattern pattern = StatementPattern.matchAll(); + String str = pattern.toString(); + + assertTrue(str.contains("StatementPattern")); + } + + @Test + @DisplayName("Should ensure contexts array is immutable") + void testContextsImmutability() { + Resource ctx1 = Mockito.mock(Resource.class); + Resource ctx2 = Mockito.mock(Resource.class); + + StatementPattern pattern = StatementPattern.builder() + .contexts(ctx1, ctx2) + .build(); + + Resource[] contexts = pattern.getContexts(); + contexts[0] = null; + + assertNotNull(pattern.getContexts()[0]); + } +} \ No newline at end of file diff --git a/src/test/java/fr/inria/corese/core/next/datamanager/api/transaction/TransactionStateTest.java b/src/test/java/fr/inria/corese/core/next/datamanager/api/transaction/TransactionStateTest.java new file mode 100644 index 000000000..7ad6d81ab --- /dev/null +++ b/src/test/java/fr/inria/corese/core/next/datamanager/api/transaction/TransactionStateTest.java @@ -0,0 +1,57 @@ +package fr.inria.corese.core.next.datamanager.api.transaction; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for TransactionState enum. + */ +@DisplayName("TransactionState Enum Tests") +class TransactionStateTest { + + @Test + @DisplayName("Should have all 4 transaction states defined") + void testAllStatesExist() { + assertNotNull(TransactionState.ACTIVE); + assertNotNull(TransactionState.COMMITTED); + assertNotNull(TransactionState.ROLLED_BACK); + assertNotNull(TransactionState.FAILED); + } + + @Test + @DisplayName("Should return true for isActive() only when state is ACTIVE") + void testIsActive() { + assertTrue(TransactionState.ACTIVE.isActive()); + + assertFalse(TransactionState.COMMITTED.isActive()); + assertFalse(TransactionState.ROLLED_BACK.isActive()); + assertFalse(TransactionState.FAILED.isActive()); + } + + @Test + @DisplayName("Should return correct description for each state") + void testDescriptions() { + assertEquals("Active", TransactionState.ACTIVE.getDescription()); + assertEquals("Committed", TransactionState.COMMITTED.getDescription()); + assertEquals("Rolled back", TransactionState.ROLLED_BACK.getDescription()); + assertEquals("Failed", TransactionState.FAILED.getDescription()); + } + + @Test + @DisplayName("Should have exactly 4 enum values") + void testEnumValues() { + TransactionState[] states = TransactionState.values(); + assertEquals(4, states.length); + } + + @Test + @DisplayName("Should correctly resolve valueOf() for valid and invalid state names") + void testValueOf() { + assertEquals(TransactionState.ACTIVE, TransactionState.valueOf("ACTIVE")); + assertEquals(TransactionState.COMMITTED, TransactionState.valueOf("COMMITTED")); + + assertThrows(IllegalArgumentException.class, + () -> TransactionState.valueOf("INVALID")); + } +} \ No newline at end of file From f289fdf617cd01e5e3c7549873ed38a07883e3c8 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Fri, 30 Jan 2026 17:11:54 +0100 Subject: [PATCH 4/9] Refactor DataManager architecture new Model TU --- .../operations/BulkOperationsImplTest.java | 209 ++++++++++++++++++ 1 file changed, 209 insertions(+) create mode 100644 src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/BulkOperationsImplTest.java diff --git a/src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/BulkOperationsImplTest.java b/src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/BulkOperationsImplTest.java new file mode 100644 index 000000000..add565b37 --- /dev/null +++ b/src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/BulkOperationsImplTest.java @@ -0,0 +1,209 @@ +package fr.inria.corese.core.next.datamanager.impl.operations; + +import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; +import fr.inria.corese.core.next.datamanager.api.support.model.MutationResult; +import fr.inria.corese.core.next.datamanager.api.support.model.StatementPattern; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +/** + * Unit tests for BulkOperationsImpl. + */ +@DisplayName("BulkOperationsImpl Tests") +class BulkOperationsImplTest { + + @Mock + private Model model; + + @Mock + private Statement stmt1, stmt2, stmt3; + + @Mock + private Resource context; + + private BulkOperationsImpl bulkOps; + + @BeforeEach + void setUp() { + MockitoAnnotations.openMocks(this); + bulkOps = new BulkOperationsImpl(model); + } + + @Test + @DisplayName("Should throw IllegalArgumentException when constructed with null model") + void testConstructorNullModel() { + assertThrows(IllegalArgumentException.class, + () -> new BulkOperationsImpl(null)); + } + + @Test + @DisplayName("Should successfully insert all statements in batch") + void testInsertBatchSuccess() throws DataManagerException { + when(model.add(stmt1)).thenReturn(true); + when(model.add(stmt2)).thenReturn(true); + when(model.add(stmt3)).thenReturn(true); + + List statements = Arrays.asList(stmt1, stmt2, stmt3); + MutationResult result = bulkOps.insertBatch(statements); + + assertTrue(result.isSuccess()); + assertEquals(3, result.getTotalAttempted()); + assertEquals(3, result.getSuccessCount()); + assertEquals(0, result.getFailureCount()); + + verify(model).add(stmt1); + verify(model).add(stmt2); + verify(model).add(stmt3); + } + + @Test + @DisplayName("Should handle partial success when some statements already exist") + void testInsertBatchPartialSuccess() throws DataManagerException { + when(model.add(stmt1)).thenReturn(true); + when(model.add(stmt2)).thenReturn(false); // Already exists + when(model.add(stmt3)).thenReturn(true); + + List statements = Arrays.asList(stmt1, stmt2, stmt3); + MutationResult result = bulkOps.insertBatch(statements); + + assertFalse(result.isSuccess()); + assertEquals(3, result.getTotalAttempted()); + assertEquals(2, result.getSuccessCount()); + assertEquals(1, result.getFailureCount()); + } + + @Test + @DisplayName("Should throw IllegalArgumentException when insertBatch called with null list") + void testInsertBatchNullList() { + assertThrows(IllegalArgumentException.class, + () -> bulkOps.insertBatch(null)); + } + + @Test + @DisplayName("Should throw IllegalArgumentException when insertBatch called with empty list") + void testInsertBatchEmptyList() { + assertThrows(IllegalArgumentException.class, + () -> bulkOps.insertBatch(Collections.emptyList())); + } + + @Test + @DisplayName("Should successfully delete all statements in batch") + void testDeleteBatchSuccess() throws DataManagerException { + when(model.remove(stmt1)).thenReturn(true); + when(model.remove(stmt2)).thenReturn(true); + + List statements = Arrays.asList(stmt1, stmt2); + MutationResult result = bulkOps.deleteBatch(statements); + + assertTrue(result.isSuccess()); + assertEquals(2, result.getTotalAttempted()); + assertEquals(2, result.getSuccessCount()); + assertEquals(0, result.getFailureCount()); + + verify(model).remove(stmt1); + verify(model).remove(stmt2); + } + + @Test + @DisplayName("Should report failure when statement to delete is not found") + void testDeleteBatchNotFound() throws DataManagerException { + when(model.remove(stmt1)).thenReturn(false); // Not found + + List statements = List.of(stmt1); + MutationResult result = bulkOps.deleteBatch(statements); + + assertFalse(result.isSuccess()); + assertEquals(1, result.getTotalAttempted()); + assertEquals(0, result.getSuccessCount()); + assertEquals(1, result.getFailureCount()); + } + + @Test + @DisplayName("Should throw IllegalArgumentException when deleteBatch called with null list") + void testDeleteBatchNullList() { + assertThrows(IllegalArgumentException.class, + () -> bulkOps.deleteBatch(null)); + } + + @Test + @DisplayName("Should delete statements matching the given pattern") + void testDeleteByPattern() throws DataManagerException { + Resource subject = mock(Resource.class); + IRI predicate = mock(IRI.class); + Value object = mock(Value.class); + Resource[] contexts = new Resource[]{context}; + + StatementPattern pattern = StatementPattern.builder() + .subject(subject) + .predicate(predicate) + .object(object) + .contexts(contexts) + .build(); + + when(model.remove(subject, predicate, object, contexts)).thenReturn(true); + + MutationResult result = bulkOps.deleteByPattern(pattern); + + assertTrue(result.isSuccess()); + assertEquals(0, result.getSuccessCount()); + verify(model).remove(subject, predicate, object, contexts); + } + + @Test + @DisplayName("Should throw IllegalArgumentException when deleteByPattern called with null pattern") + void testDeleteByPatternNull() { + assertThrows(IllegalArgumentException.class, + () -> bulkOps.deleteByPattern(null)); + } + + @Test + @DisplayName("Should succeed in silent mode even when clear returns false") + void testClearContextsSilentMode() throws DataManagerException { + when(model.clear(any(Resource[].class))).thenReturn(false); + + MutationResult result = bulkOps.clearContexts(List.of(context), true); + + assertTrue(result.isSuccess()); + } + + @Test + @DisplayName("Should handle exceptions during batch insert and continue processing") + void testInsertBatchWithException() throws DataManagerException { + when(model.add(stmt1)).thenReturn(true); + when(model.add(stmt2)).thenThrow(new RuntimeException("Test error")); + when(model.add(stmt3)).thenReturn(true); + + List statements = Arrays.asList(stmt1, stmt2, stmt3); + MutationResult result = bulkOps.insertBatch(statements); + + assertFalse(result.isSuccess()); + assertEquals(3, result.getTotalAttempted()); + assertEquals(2, result.getSuccessCount()); + assertEquals(1, result.getFailureCount()); + assertEquals(1, result.getErrors().size()); + } + + @Test + @DisplayName("Should track errors when exception occurs during batch delete") + void testDeleteBatchWithException() throws DataManagerException { + when(model.remove(stmt1)).thenThrow(new RuntimeException("Test error")); + + List statements = List.of(stmt1); + MutationResult result = bulkOps.deleteBatch(statements); + + assertFalse(result.isSuccess()); + assertEquals(1, result.getFailureCount()); + assertEquals(1, result.getErrors().size()); + } +} \ No newline at end of file From 9a0632e31c476e40c88e8b695449b98192c8d47c Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Mon, 2 Feb 2026 10:30:40 +0100 Subject: [PATCH 5/9] Refactor DataManager architecture new Model TU --- .../datamanager/api/ModelDataManager.java | 35 +---- .../datamanager/api/ModelDataManagerRead.java | 21 +++ .../api/ModelDataManagerUpdate.java | 21 +++ .../CoreseModelDataManagerBuilderTest.java | 145 +++++++++++++++++ .../impl/CoreseModelDataManagerTest.java | 147 ++++++++++++++++++ 5 files changed, 335 insertions(+), 34 deletions(-) create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManagerRead.java create mode 100644 src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManagerUpdate.java create mode 100644 src/test/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerBuilderTest.java create mode 100644 src/test/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerTest.java diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManager.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManager.java index 4fd74f9c6..c2ee5398b 100644 --- a/src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManager.java +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManager.java @@ -10,41 +10,8 @@ /** * Main interface for the Model DataManager. - * Provides access to all DataManager operations through specialized operation interfaces. */ -public interface ModelDataManager { - - /** - * Returns the query operations handler. - * Provides read-only operations for querying statements. - * - * @return QueryOperations instance - */ - QueryOperations getQueryOperations(); - - /** - * Returns the mutation operations handler. - * Provides operations for inserting, updating, and deleting statements. - * - * @return MutationOperations instance - */ - MutationOperations getMutationOperations(); - - /** - * Returns the metadata operations handler. - * Provides access to model structure information (subjects, predicates, objects, contexts, statistics). - * - * @return MetadataOperations instance - */ - MetadataOperations getMetadataOperations(); - - /** - * Returns the bulk operations handler. - * Provides batch operations for efficient processing of multiple statements. - * - * @return BulkOperations instance - */ - BulkOperations getBulkOperations(); +public interface ModelDataManager extends ModelDataManagerRead, ModelDataManagerUpdate { /** * Returns the transaction manager. diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManagerRead.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManagerRead.java new file mode 100644 index 000000000..216472087 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManagerRead.java @@ -0,0 +1,21 @@ +package fr.inria.corese.core.next.datamanager.api; + +import fr.inria.corese.core.next.datamanager.api.operations.MetadataOperations; +import fr.inria.corese.core.next.datamanager.api.operations.QueryOperations; + +/** + * Read operations for Model DataManager. + * Groups all read-only operations. + */ +public interface ModelDataManagerRead { + + /** + * Returns the query operations handler. + */ + QueryOperations getQueryOperations(); + + /** + * Returns the metadata operations handler. + */ + MetadataOperations getMetadataOperations(); +} diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManagerUpdate.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManagerUpdate.java new file mode 100644 index 000000000..b36e0c4a6 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManagerUpdate.java @@ -0,0 +1,21 @@ +package fr.inria.corese.core.next.datamanager.api; + +import fr.inria.corese.core.next.datamanager.api.operations.BulkOperations; +import fr.inria.corese.core.next.datamanager.api.operations.MutationOperations; + +/** + * Update operations for Model DataManager. + * Groups all write operations. + */ +public interface ModelDataManagerUpdate { + + /** + * Returns the mutation operations handler. + */ + MutationOperations getMutationOperations(); + + /** + * Returns the bulk operations handler. + */ + BulkOperations getBulkOperations(); +} diff --git a/src/test/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerBuilderTest.java b/src/test/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerBuilderTest.java new file mode 100644 index 000000000..91e6f0d4a --- /dev/null +++ b/src/test/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerBuilderTest.java @@ -0,0 +1,145 @@ +package fr.inria.corese.core.next.datamanager.impl; + +import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.datamanager.api.ModelDataManager; +import fr.inria.corese.core.next.datamanager.api.transaction.IsolationLevel; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for CoreseModelDataManagerBuilder. + */ +@DisplayName("CoreseModelDataManagerBuilder Tests") +class CoreseModelDataManagerBuilderTest { + + @Mock + private Model model; + + private CoreseModelDataManagerBuilder builder; + + @BeforeEach + void setUp() { + MockitoAnnotations.openMocks(this); + builder = new CoreseModelDataManagerBuilder(); + } + + @Test + @DisplayName("Should build DataManager with minimal configuration (only model)") + void testBuildWithMinimalConfig() { + ModelDataManager dataManager = builder + .model(model) + .build(); + + assertNotNull(dataManager); + assertEquals(model, dataManager.getModel()); + } + + @Test + @DisplayName("Should build DataManager with full configuration") + void testBuildWithAllConfig() { + ModelDataManager dataManager = builder + .model(model) + .withTransactions(true) + .defaultIsolationLevel(IsolationLevel.SERIALIZABLE) + .build(); + + assertNotNull(dataManager); + assertEquals(model, dataManager.getModel()); + assertTrue(dataManager.getTransactionManager().supportsTransactions()); + assertEquals(IsolationLevel.SERIALIZABLE, + dataManager.getTransactionManager().getDefaultIsolationLevel()); + } + + @Test + @DisplayName("Should throw IllegalStateException when building without model") + void testBuildWithoutModel() { + assertThrows(IllegalStateException.class, + () -> builder.build()); + } + + @Test + @DisplayName("Should disable transaction support by default") + void testDefaultTransactionSupport() { + ModelDataManager dataManager = builder + .model(model) + .build(); + + assertFalse(dataManager.getTransactionManager().supportsTransactions()); + } + + @Test + @DisplayName("Should use READ_COMMITTED as default isolation level") + void testDefaultIsolationLevel() { + ModelDataManager dataManager = builder + .model(model) + .build(); + + assertEquals(IsolationLevel.READ_COMMITTED, + dataManager.getTransactionManager().getDefaultIsolationLevel()); + } + + @Test + @DisplayName("Should support builder method chaining with last value winning") + void testBuilderChaining() { + ModelDataManager dataManager = builder + .model(model) + .withTransactions(true) + .withTransactions(false) + .defaultIsolationLevel(IsolationLevel.SERIALIZABLE) + .defaultIsolationLevel(IsolationLevel.READ_UNCOMMITTED) + .build(); + + assertNotNull(dataManager); + assertFalse(dataManager.getTransactionManager().supportsTransactions()); + assertEquals(IsolationLevel.READ_UNCOMMITTED, + dataManager.getTransactionManager().getDefaultIsolationLevel()); + } + + @Test + @DisplayName("Should create independent instances on multiple builds") + void testMultipleBuilds() { + builder.model(model); + + ModelDataManager dm1 = builder.build(); + ModelDataManager dm2 = builder.build(); + + assertNotNull(dm1); + assertNotNull(dm2); + assertNotSame(dm1, dm2); + assertEquals(dm1.getModel(), dm2.getModel()); + } + + @Test + @DisplayName("Should initialize all operation handlers on build") + void testAllOperationsAvailable() { + ModelDataManager dataManager = builder + .model(model) + .build(); + + assertNotNull(dataManager.getQueryOperations()); + assertNotNull(dataManager.getMutationOperations()); + assertNotNull(dataManager.getMetadataOperations()); + assertNotNull(dataManager.getBulkOperations()); + assertNotNull(dataManager.getTransactionManager()); + assertNotNull(dataManager.getLifecycle()); + } + + @Test + @DisplayName("Should allow builder reuse with different configurations") + void testBuilderReuse() { + builder.model(model).withTransactions(true); + + ModelDataManager dm1 = builder.build(); + + builder.withTransactions(false); + ModelDataManager dm2 = builder.build(); + + assertTrue(dm1.getTransactionManager().supportsTransactions()); + assertFalse(dm2.getTransactionManager().supportsTransactions()); + } +} \ No newline at end of file diff --git a/src/test/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerTest.java b/src/test/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerTest.java new file mode 100644 index 000000000..6ed04d4b6 --- /dev/null +++ b/src/test/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerTest.java @@ -0,0 +1,147 @@ +package fr.inria.corese.core.next.datamanager.impl; + +import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.datamanager.api.transaction.IsolationLevel; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for CoreseModelDataManager. + */ +@DisplayName("CoreseModelDataManager Tests") +class CoreseModelDataManagerTest { + + @Mock + private Model model; + + private CoreseModelDataManager dataManager; + + @BeforeEach + void setUp() { + MockitoAnnotations.openMocks(this); + + dataManager = CoreseModelDataManager.builder() + .model(model) + .transactionSupport(true) + .defaultIsolationLevel(IsolationLevel.READ_COMMITTED) + .build(); + } + + @Test + @DisplayName("Should return the configured model instance") + void testGetModel() { + assertEquals(model, dataManager.getModel()); + } + + @Test + @DisplayName("Should provide query operations handler") + void testGetQueryOperations() { + assertNotNull(dataManager.getQueryOperations()); + } + + @Test + @DisplayName("Should provide mutation operations handler") + void testGetMutationOperations() { + assertNotNull(dataManager.getMutationOperations()); + } + + @Test + @DisplayName("Should provide metadata operations handler") + void testGetMetadataOperations() { + assertNotNull(dataManager.getMetadataOperations()); + } + + @Test + @DisplayName("Should provide bulk operations handler") + void testGetBulkOperations() { + assertNotNull(dataManager.getBulkOperations()); + } + + @Test + @DisplayName("Should provide transaction manager with correct configuration") + void testGetTransactionManager() { + assertNotNull(dataManager.getTransactionManager()); + assertTrue(dataManager.getTransactionManager().supportsTransactions()); + } + + @Test + @DisplayName("Should provide lifecycle manager") + void testGetLifecycle() { + assertNotNull(dataManager.getLifecycle()); + } + + @Test + @DisplayName("Should provide static builder factory method") + void testBuilderStaticMethod() { + assertNotNull(CoreseModelDataManager.builder()); + } + + @Test + @DisplayName("Should support disabled transaction mode") + void testTransactionSupportDisabled() { + CoreseModelDataManager dm = CoreseModelDataManager.builder() + .model(model) + .transactionSupport(false) + .build(); + + assertFalse(dm.getTransactionManager().supportsTransactions()); + } + + @Test + @DisplayName("Should support custom isolation levels") + void testCustomIsolationLevel() { + CoreseModelDataManager dm = CoreseModelDataManager.builder() + .model(model) + .transactionSupport(true) + .defaultIsolationLevel(IsolationLevel.SERIALIZABLE) + .build(); + + assertEquals(IsolationLevel.SERIALIZABLE, + dm.getTransactionManager().getDefaultIsolationLevel()); + } + + @Test + @DisplayName("Should ensure all operations share the same model instance") + void testOperationsShareSameModel() { + assertEquals(model, dataManager.getModel()); + + assertNotNull(dataManager.getQueryOperations()); + assertNotNull(dataManager.getMutationOperations()); + assertNotNull(dataManager.getMetadataOperations()); + assertNotNull(dataManager.getBulkOperations()); + } + + @Test + @DisplayName("Should start with lifecycle in NOT_INITIALIZED state") + void testLifecycleInitialState() { + assertNotNull(dataManager.getLifecycle()); + assertFalse(dataManager.getLifecycle().isInitialized()); + } + + @Test + @DisplayName("Should throw IllegalStateException when builder has no model") + void testBuilderRequiresModel() { + assertThrows(IllegalStateException.class, + () -> CoreseModelDataManager.builder().build()); + } + + @Test + @DisplayName("Should create independent DataManager instances") + void testMultipleInstancesIndependent() { + CoreseModelDataManager dm1 = CoreseModelDataManager.builder() + .model(model) + .build(); + + CoreseModelDataManager dm2 = CoreseModelDataManager.builder() + .model(model) + .build(); + + assertNotSame(dm1, dm2); + assertNotSame(dm1.getLifecycle(), dm2.getLifecycle()); + } +} From 499a704a21eab2bf7d19beeedd566052df8d65d0 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Mon, 2 Feb 2026 10:32:16 +0100 Subject: [PATCH 6/9] Refactor DataManager architecture new Model TU --- .../lifecycle/LifecycleManagerImplTest.java | 181 +++++++++++++ .../MetadataOperationsImplTest.java | 246 ++++++++++++++++++ .../operations/QueryOperationsImplTest.java | 241 +++++++++++++++++ 3 files changed, 668 insertions(+) create mode 100644 src/test/java/fr/inria/corese/core/next/datamanager/impl/lifecycle/LifecycleManagerImplTest.java create mode 100644 src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/MetadataOperationsImplTest.java create mode 100644 src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/QueryOperationsImplTest.java diff --git a/src/test/java/fr/inria/corese/core/next/datamanager/impl/lifecycle/LifecycleManagerImplTest.java b/src/test/java/fr/inria/corese/core/next/datamanager/impl/lifecycle/LifecycleManagerImplTest.java new file mode 100644 index 000000000..bcee841b8 --- /dev/null +++ b/src/test/java/fr/inria/corese/core/next/datamanager/impl/lifecycle/LifecycleManagerImplTest.java @@ -0,0 +1,181 @@ +package fr.inria.corese.core.next.datamanager.impl.lifecycle; + +import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.datamanager.api.lifecycle.LifecycleState; +import fr.inria.corese.core.next.datamanager.api.support.config.DataManagerConfig; +import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for LifecycleManagerImpl. + */ +@DisplayName("LifecycleManagerImpl Tests") +class LifecycleManagerImplTest { + + @Mock + private Model model; + + private LifecycleManagerImpl lifecycle; + private DataManagerConfig config; + + @BeforeEach + void setUp() { + MockitoAnnotations.openMocks(this); + lifecycle = new LifecycleManagerImpl(model); + config = DataManagerConfig.builder() + .debug(true) + .build(); + } + + @Test + @DisplayName("Should throw IllegalArgumentException when constructed with null model") + void testConstructorNullModel() { + assertThrows(IllegalArgumentException.class, + () -> new LifecycleManagerImpl(null)); + } + + @Test + @DisplayName("Should start in NOT_INITIALIZED state with no config") + void testInitialState() { + assertEquals(LifecycleState.NOT_INITIALIZED, lifecycle.getState()); + assertNull(lifecycle.getConfig()); + assertFalse(lifecycle.isInitialized()); + } + + @Test + @DisplayName("Should successfully initialize and transition to RUNNING state") + void testInitializeSuccess() throws DataManagerException { + lifecycle.initialize(config); + + assertEquals(LifecycleState.RUNNING, lifecycle.getState()); + assertEquals(config, lifecycle.getConfig()); + assertTrue(lifecycle.isInitialized()); + } + + @Test + @DisplayName("Should throw IllegalArgumentException when initialized with null config") + void testInitializeNullConfig() { + assertThrows(IllegalArgumentException.class, + () -> lifecycle.initialize(null)); + } + + @Test + @DisplayName("Should throw IllegalStateException when attempting to initialize twice") + void testInitializeWhenAlreadyInitialized() throws DataManagerException { + lifecycle.initialize(config); + + assertThrows(IllegalStateException.class, + () -> lifecycle.initialize(config)); + } + + @Test + @DisplayName("Should successfully shutdown and transition to SHUTDOWN state") + void testShutdownSuccess() throws DataManagerException { + lifecycle.initialize(config); + lifecycle.shutdown(); + + assertEquals(LifecycleState.SHUTDOWN, lifecycle.getState()); + assertNull(lifecycle.getConfig()); + assertFalse(lifecycle.isInitialized()); + } + + @Test + @DisplayName("Should throw IllegalStateException when shutting down without initialization") + void testShutdownWhenNotInitialized() { + assertThrows(IllegalStateException.class, + () -> lifecycle.shutdown()); + } + + @Test + @DisplayName("Should throw IllegalStateException when attempting to shutdown twice") + void testShutdownWhenAlreadyShutdown() throws DataManagerException { + lifecycle.initialize(config); + lifecycle.shutdown(); + + assertThrows(IllegalStateException.class, + () -> lifecycle.shutdown()); + } + + @Test + @DisplayName("Should allow restart without previous initialization") + void testRestartWithoutPreviousInit() throws DataManagerException { + DataManagerConfig newConfig = DataManagerConfig.builder() + .debug(false) + .build(); + + lifecycle.restart(newConfig); + + assertEquals(LifecycleState.RUNNING, lifecycle.getState()); + assertEquals(newConfig, lifecycle.getConfig()); + } + + @Test + @DisplayName("Should not throw when checkUsable() is called in RUNNING state") + void testCheckUsableWhenRunning() throws DataManagerException { + lifecycle.initialize(config); + + assertDoesNotThrow(() -> lifecycle.checkUsable()); + } + + @Test + @DisplayName("Should throw IllegalStateException when checkUsable() called before initialization") + void testCheckUsableWhenNotRunning() { + assertThrows(IllegalStateException.class, + () -> lifecycle.checkUsable()); + } + + @Test + @DisplayName("Should throw IllegalStateException when checkUsable() called after shutdown") + void testCheckUsableAfterShutdown() throws DataManagerException { + lifecycle.initialize(config); + lifecycle.shutdown(); + + assertThrows(IllegalStateException.class, + () -> lifecycle.checkUsable()); + } + + @Test + @DisplayName("Should transition through states correctly: NOT_INITIALIZED -> RUNNING -> SHUTDOWN") + void testStateTransitions() throws DataManagerException { + assertEquals(LifecycleState.NOT_INITIALIZED, lifecycle.getState()); + + lifecycle.initialize(config); + assertEquals(LifecycleState.RUNNING, lifecycle.getState()); + + lifecycle.shutdown(); + assertEquals(LifecycleState.SHUTDOWN, lifecycle.getState()); + } + + @Test + @DisplayName("Should include state and config presence in toString() output") + void testToString() throws DataManagerException { + String beforeInit = lifecycle.toString(); + assertTrue(beforeInit.contains("LifecycleManager")); + assertTrue(beforeInit.contains("NOT_INITIALIZED")); + assertTrue(beforeInit.contains("configPresent=false")); + + lifecycle.initialize(config); + + String afterInit = lifecycle.toString(); + assertTrue(afterInit.contains("RUNNING")); + assertTrue(afterInit.contains("configPresent=true")); + } + + @Test + @DisplayName("Should clear config reference on shutdown while preserving original config instance") + void testConfigImmutabilityAfterShutdown() throws DataManagerException { + lifecycle.initialize(config); + DataManagerConfig originalConfig = lifecycle.getConfig(); + + lifecycle.shutdown(); + + assertNull(lifecycle.getConfig()); + assertNotNull(originalConfig); + } +} \ No newline at end of file diff --git a/src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/MetadataOperationsImplTest.java b/src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/MetadataOperationsImplTest.java new file mode 100644 index 000000000..cb3e64d18 --- /dev/null +++ b/src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/MetadataOperationsImplTest.java @@ -0,0 +1,246 @@ +package fr.inria.corese.core.next.datamanager.impl.operations; + +import fr.inria.corese.core.next.api.IRI; +import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.api.Resource; +import fr.inria.corese.core.next.api.Value; +import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; +import fr.inria.corese.core.next.datamanager.api.support.model.ModelStatistics; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import java.util.HashSet; +import java.util.Set; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +/** + * Unit tests for MetadataOperationsImpl. + */ +@DisplayName("MetadataOperationsImpl Tests") +class MetadataOperationsImplTest { + + @Mock + private Model model; + + @Mock + private IRI pred1, pred2; + + @Mock + private Resource subj1, subj2, ctx1, ctx2; + + @Mock + private Value obj1, obj2; + + private MetadataOperationsImpl metadataOps; + + @BeforeEach + void setUp() { + MockitoAnnotations.openMocks(this); + metadataOps = new MetadataOperationsImpl(model); + } + + @Test + @DisplayName("Should throw IllegalArgumentException when constructed with null model") + void testConstructorNullModel() { + assertThrows(IllegalArgumentException.class, + () -> new MetadataOperationsImpl(null)); + } + + @Test + @DisplayName("Should retrieve all unique predicates from model") + void testGetPredicates() throws DataManagerException { + Set predicates = new HashSet<>(); + predicates.add(pred1); + predicates.add(pred2); + + when(model.predicates()).thenReturn(predicates); + + Set result = metadataOps.getPredicates(); + + assertNotNull(result); + assertEquals(2, result.size()); + assertTrue(result.contains(pred1)); + assertTrue(result.contains(pred2)); + + verify(model).predicates(); + } + + @Test + @DisplayName("Should return empty set when model has no predicates") + void testGetPredicatesEmpty() throws DataManagerException { + when(model.predicates()).thenReturn(new HashSet<>()); + + Set result = metadataOps.getPredicates(); + + assertNotNull(result); + assertTrue(result.isEmpty()); + } + + @Test + @DisplayName("Should return unmodifiable set of predicates") + void testGetPredicatesUnmodifiable() throws DataManagerException { + Set predicates = new HashSet<>(); + predicates.add(pred1); + + when(model.predicates()).thenReturn(predicates); + + Set result = metadataOps.getPredicates(); + + assertThrows(UnsupportedOperationException.class, + () -> result.add(pred2)); + } + + @Test + @DisplayName("Should retrieve all unique subjects from model") + void testGetSubjects() throws DataManagerException { + Set subjects = new HashSet<>(); + subjects.add(subj1); + subjects.add(subj2); + + when(model.subjects()).thenReturn(subjects); + + Set result = metadataOps.getSubjects(); + + assertNotNull(result); + assertEquals(2, result.size()); + assertTrue(result.contains(subj1)); + assertTrue(result.contains(subj2)); + + verify(model).subjects(); + } + + @Test + @DisplayName("Should retrieve all unique objects from model") + void testGetObjects() throws DataManagerException { + Set objects = new HashSet<>(); + objects.add(obj1); + objects.add(obj2); + + when(model.objects()).thenReturn(objects); + + Set result = metadataOps.getObjects(); + + assertNotNull(result); + assertEquals(2, result.size()); + assertTrue(result.contains(obj1)); + assertTrue(result.contains(obj2)); + + verify(model).objects(); + } + + @Test + @DisplayName("Should retrieve all unique contexts from model") + void testGetContexts() throws DataManagerException { + Set contexts = new HashSet<>(); + contexts.add(ctx1); + contexts.add(ctx2); + + when(model.contexts()).thenReturn(contexts); + + Set result = metadataOps.getContexts(); + + assertNotNull(result); + assertEquals(2, result.size()); + assertTrue(result.contains(ctx1)); + assertTrue(result.contains(ctx2)); + + verify(model).contexts(); + } + + @Test + @DisplayName("Should calculate model statistics with correct counts") + void testGetStatistics() throws DataManagerException { + Set subjects = new HashSet<>(); + subjects.add(subj1); + subjects.add(subj2); + when(model.subjects()).thenReturn(subjects); + + Set predicates = new HashSet<>(); + predicates.add(pred1); + when(model.predicates()).thenReturn(predicates); + + Set objects = new HashSet<>(); + objects.add(obj1); + objects.add(obj2); + when(model.objects()).thenReturn(objects); + + Set contexts = new HashSet<>(); + contexts.add(ctx1); + when(model.contexts()).thenReturn(contexts); + + ModelStatistics stats = metadataOps.getStatistics(); + + assertNotNull(stats); + assertEquals(0, stats.statementCount()); + assertEquals(2, stats.subjectCount()); + assertEquals(1, stats.predicateCount()); + assertEquals(2, stats.objectCount()); + assertEquals(1, stats.contextCount()); + } + + @Test + @DisplayName("Should return empty statistics for empty model") + void testGetStatisticsEmptyModel() throws DataManagerException { + when(model.subjects()).thenReturn(new HashSet<>()); + when(model.predicates()).thenReturn(new HashSet<>()); + when(model.objects()).thenReturn(new HashSet<>()); + when(model.contexts()).thenReturn(new HashSet<>()); + + ModelStatistics stats = metadataOps.getStatistics(); + + assertNotNull(stats); + assertEquals(0, stats.statementCount()); + assertTrue(stats.isEmpty()); + } + + @Test + @DisplayName("Should throw DataManagerException when predicates() fails") + void testGetPredicatesWithException() { + when(model.predicates()).thenThrow(new RuntimeException("Test error")); + + assertThrows(DataManagerException.class, + () -> metadataOps.getPredicates()); + } + + @Test + @DisplayName("Should throw DataManagerException when subjects() fails") + void testGetSubjectsWithException() { + when(model.subjects()).thenThrow(new RuntimeException("Test error")); + + assertThrows(DataManagerException.class, + () -> metadataOps.getSubjects()); + } + + @Test + @DisplayName("Should throw DataManagerException when objects() fails") + void testGetObjectsWithException() { + when(model.objects()).thenThrow(new RuntimeException("Test error")); + + assertThrows(DataManagerException.class, + () -> metadataOps.getObjects()); + } + + @Test + @DisplayName("Should throw DataManagerException when contexts() fails") + void testGetContextsWithException() { + when(model.contexts()).thenThrow(new RuntimeException("Test error")); + + assertThrows(DataManagerException.class, + () -> metadataOps.getContexts()); + } + + @Test + @DisplayName("Should throw DataManagerException when getStatistics() fails") + void testGetStatisticsWithException() { + when(model.size()).thenThrow(new RuntimeException("Test error")); + + assertThrows(DataManagerException.class, + () -> metadataOps.getStatistics()); + } +} \ No newline at end of file diff --git a/src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/QueryOperationsImplTest.java b/src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/QueryOperationsImplTest.java new file mode 100644 index 000000000..d81aecb83 --- /dev/null +++ b/src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/QueryOperationsImplTest.java @@ -0,0 +1,241 @@ +package fr.inria.corese.core.next.datamanager.impl.operations; + +import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; +import fr.inria.corese.core.next.datamanager.api.support.model.StatementPattern; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import java.util.Arrays; +import java.util.Collections; +import java.util.stream.Stream; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +/** + * Unit tests for QueryOperationsImpl. + */ +@DisplayName("QueryOperationsImpl Tests") +class QueryOperationsImplTest { + + @Mock + private Model model; + + @Mock + private Statement stmt1, stmt2, stmt3; + + @Mock + private Resource subject, context; + + @Mock + private IRI predicate; + + @Mock + private Value object; + + private QueryOperationsImpl queryOps; + + @BeforeEach + void setUp() { + MockitoAnnotations.openMocks(this); + queryOps = new QueryOperationsImpl(model); + } + + @Test + @DisplayName("Should throw IllegalArgumentException when constructed with null model") + void testConstructorNullModel() { + assertThrows(IllegalArgumentException.class, + () -> new QueryOperationsImpl(null)); + } + + @Test + @DisplayName("Should query statements matching the given pattern") + void testQueryWithPattern() throws DataManagerException { + StatementPattern pattern = StatementPattern.builder() + .subject(subject) + .predicate(predicate) + .object(object) + .contexts(context) + .build(); + + Iterable iterable = Arrays.asList(stmt1, stmt2, stmt3); + when(model.getStatements(subject, predicate, object, context)) + .thenReturn(iterable); + + Stream stream = queryOps.query(pattern); + + assertNotNull(stream); + assertEquals(3, stream.count()); + + verify(model).getStatements(subject, predicate, object, context); + } + + @Test + @DisplayName("Should query all statements when using matchAll pattern") + void testQueryMatchAll() throws DataManagerException { + StatementPattern pattern = StatementPattern.matchAll(); + + Iterable iterable = Arrays.asList(stmt1, stmt2); + when(model.getStatements(null, null, null)) + .thenReturn(iterable); + + Stream stream = queryOps.query(pattern); + + assertNotNull(stream); + assertEquals(2, stream.count()); + } + + @Test + @DisplayName("Should return empty stream when no statements match pattern") + void testQueryEmpty() throws DataManagerException { + StatementPattern pattern = StatementPattern.matchAll(); + + when(model.getStatements(any(), any(), any(), any())) + .thenReturn(Collections.emptyList()); + + Stream stream = queryOps.query(pattern); + + assertNotNull(stream); + assertEquals(0, stream.count()); + } + + @Test + @DisplayName("Should throw IllegalArgumentException when query called with null pattern") + void testQueryNullPattern() { + assertThrows(IllegalArgumentException.class, + () -> queryOps.query(null)); + } + + @Test + @DisplayName("Should count statements matching the given pattern") + void testCountWithPattern() throws DataManagerException { + StatementPattern pattern = StatementPattern.builder() + .predicate(predicate) + .build(); + + Iterable iterable = Arrays.asList(stmt1, stmt2, stmt3); + when(model.getStatements(null, predicate, null)) + .thenReturn(iterable); + + long count = queryOps.count(pattern); + + assertEquals(3, count); + } + + @Test + @DisplayName("Should return zero when no statements match count pattern") + void testCountEmpty() throws DataManagerException { + StatementPattern pattern = StatementPattern.builder() + .subject(subject) + .build(); + + when(model.getStatements(subject, null, null)) + .thenReturn(Collections.emptyList()); + + long count = queryOps.count(pattern); + + assertEquals(0, count); + } + + @Test + @DisplayName("Should throw IllegalArgumentException when count called with null pattern") + void testCountNullPattern() { + assertThrows(IllegalArgumentException.class, + () -> queryOps.count(null)); + } + + @Test + @DisplayName("Should return true when statement matching pattern exists") + void testExistsTrue() throws DataManagerException { + StatementPattern pattern = StatementPattern.builder() + .subject(subject) + .predicate(predicate) + .build(); + + when(model.contains(subject, predicate, null)) + .thenReturn(true); + + boolean exists = queryOps.exists(pattern); + + assertTrue(exists); + verify(model).contains(subject, predicate, null); + } + + @Test + @DisplayName("Should return false when no statement matching pattern exists") + void testExistsFalse() throws DataManagerException { + StatementPattern pattern = StatementPattern.builder() + .subject(subject) + .build(); + + when(model.contains(subject, null, null)) + .thenReturn(false); + + boolean exists = queryOps.exists(pattern); + + assertFalse(exists); + } + + @Test + @DisplayName("Should throw IllegalArgumentException when exists called with null pattern") + void testExistsNullPattern() { + assertThrows(IllegalArgumentException.class, + () -> queryOps.exists(null)); + } + + @Test + @DisplayName("Should filter model and return filtered subset") + void testFilter() throws DataManagerException { + StatementPattern pattern = StatementPattern.builder() + .predicate(predicate) + .build(); + + Model filteredModel = mock(Model.class); + when(model.filter(null, predicate, null)) + .thenReturn(filteredModel); + + Model result = queryOps.filter(pattern); + + assertNotNull(result); + assertEquals(filteredModel, result); + verify(model).filter(null, predicate, null); + } + + @Test + @DisplayName("Should filter with matchAll pattern") + void testFilterMatchAll() throws DataManagerException { + StatementPattern pattern = StatementPattern.matchAll(); + + Model filteredModel = mock(Model.class); + when(model.filter(null, null, null)) + .thenReturn(filteredModel); + + Model result = queryOps.filter(pattern); + + assertNotNull(result); + verify(model).filter(null, null, null); + } + + @Test + @DisplayName("Should throw IllegalArgumentException when filter called with null pattern") + void testFilterNullPattern() { + assertThrows(IllegalArgumentException.class, + () -> queryOps.filter(null)); + } + + @Test + @DisplayName("Should throw DataManagerException when filter operation fails") + void testFilterWithException() { + StatementPattern pattern = StatementPattern.matchAll(); + + when(model.filter(any(), any(), any(), any())) + .thenThrow(new RuntimeException("Test error")); + + assertThrows(DataManagerException.class, + () -> queryOps.filter(pattern)); + } +} \ No newline at end of file From c34379a859ef5a8f4ce166cf26997e5b7f8c540a Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Tue, 3 Feb 2026 13:10:29 +0100 Subject: [PATCH 7/9] Refactor DataManager architecture revue --- .../core/next/{ => data}/api/BNode.java | 2 +- .../next/{ => data}/api/IPrefixHandler.java | 2 +- .../corese/core/next/{ => data}/api/IRI.java | 2 +- .../core/next/{ => data}/api/Literal.java | 4 +- .../core/next/{ => data}/api/Model.java | 4 +- .../core/next/{ => data}/api/Namespace.java | 2 +- .../next/{ => data}/api/NamespaceAware.java | 2 +- .../core/next/{ => data}/api/Resource.java | 2 +- .../core/next/{ => data}/api/Statement.java | 2 +- .../core/next/{ => data}/api/Triple.java | 2 +- .../core/next/{ => data}/api/Value.java | 2 +- .../next/{ => data}/api/ValueFactory.java | 4 +- .../api/base/exception/CoreseException.java | 2 +- .../api/base/io/AbstractIOOptions.java | 4 +- .../{ => data}/api/base/io/FileFormat.java | 2 +- .../{ => data}/api/base/io/RDFFormat.java | 2 +- .../api/base/io/parser/AbstractRDFParser.java | 14 +- .../io/parser/AbstractRDFParserFactory.java | 12 +- .../api/base/model/AbstractBNode.java | 4 +- .../api/base/model/AbstractIRI.java | 8 +- .../api/base/model/AbstractModel.java | 16 +- .../api/base/model/AbstractNamespace.java | 4 +- .../api/base/model/AbstractStatement.java | 4 +- .../api/base/model/ReadOnlyModel.java | 14 +- .../base/model/literal/AbstractDuration.java | 6 +- .../base/model/literal/AbstractLiteral.java | 12 +- .../base/model/literal/AbstractNumber.java | 4 +- .../model/literal/AbstractStringLiteral.java | 4 +- .../literal/AbstractTemporalPointLiteral.java | 4 +- .../base/model/literal/DefaultDatatype.java | 6 +- .../{ => data}/api/literal/CoreDatatype.java | 6 +- .../next/{ => data}/impl/common/BasicIRI.java | 6 +- .../impl/common/literal/BasicDuration.java | 12 +- .../next/data/impl/common/literal/RDF.java | 30 +++ .../next/data/impl/common/literal/XSD.java | 205 ++++++++++++++++++ .../impl/common/prefix/PrefixHandler.java | 8 +- .../{ => data}/impl/common/util/IRIUtils.java | 2 +- .../util/literal/CoreDatatypeHelper.java | 10 +- .../impl/common/vocabulary/FOAF.java | 6 +- .../impl/common/vocabulary/OWL.java | 6 +- .../impl/common/vocabulary/RDF.java | 8 +- .../impl/common/vocabulary/RDFS.java | 8 +- .../impl/common/vocabulary/RDFa.java | 8 +- .../impl/common/vocabulary/Vocabulary.java | 4 +- .../impl/common/vocabulary/XSD.java | 6 +- .../{ => data}/impl/config/CoreConfig.java | 2 +- .../exception/IncorrectDatatypeException.java | 4 +- .../exception/IncorrectFormatException.java | 4 +- .../IncorrectOperationException.java | 4 +- .../impl/exception/InternalException.java | 4 +- .../impl/exception/ParsingErrorException.java | 4 +- .../exception/SerializationException.java | 4 +- .../impl/exception/SparqlException.java | 0 .../UnsupportedFileFormatException.java | 4 +- .../impl/inmemory/InMemoryModel.java | 16 +- .../impl/io/common/IOConstants.java | 2 +- .../impl/io/common/JSONLDOptions.java | 10 +- .../impl/io/parser/ParserFactory.java | 28 +-- .../AbstractNTriplesNQuadsListener.java | 16 +- .../common/AbstractTurtleTriGListener.java | 18 +- .../impl/io/parser/jsonld/JSONLDParser.java | 23 +- .../impl/io/parser/nquads/NQuadsListener.java | 20 +- .../impl/io/parser/nquads/NQuadsParser.java | 16 +- .../io/parser/nquads/NQuadsParserOptions.java | 4 +- .../io/parser/ntriples/NTriplesListener.java | 30 +-- .../io/parser/ntriples/NTriplesParser.java | 16 +- .../ntriples/NTriplesParserOptions.java | 4 +- .../impl/io/parser/rdfa/RDFaParser.java | 24 +- .../io/parser/rdfa/RDFaParserOptions.java | 9 +- .../io/parser/rdfa/model/RDFaAttributes.java | 2 +- .../rdfa/model/RDFaEvaluationContext.java | 8 +- .../rdfa/model/RDFaIncompleteStatement.java | 8 +- .../rdfa/model/RDFaInitialPrefixes.java | 17 +- .../rdfa/model/RDFaProcessingContext.java | 8 +- .../impl/io/parser/rdfxml/RDFXMLParser.java | 26 +-- .../io/parser/rdfxml/RDFXMLParserOptions.java | 8 +- .../parser/rdfxml/RDFXMLStatementEmitter.java | 12 +- .../impl/io/parser/rdfxml/RDFXMLUtils.java | 20 +- .../parser/rdfxml/context/RDFXMLContext.java | 5 +- .../impl/io/parser/trig/TriGListerner.java | 18 +- .../impl/io/parser/trig/TriGParser.java | 16 +- .../io/parser/trig/TriGParserOptions.java | 8 +- .../impl/io/parser/turtle/TurtleListener.java | 18 +- .../impl/io/parser/turtle/TurtleParser.java | 16 +- .../io/parser/turtle/TurtleParserOptions.java | 8 +- .../impl/io/parser/util/ParserConstants.java | 5 +- .../io/serialization/SerializerFactory.java | 42 ++-- .../base/AbstractGraphSerializer.java | 25 ++- .../base/AbstractLineBasedSerializer.java | 28 +-- .../canonical/RDFC10Canonicalizer.java | 16 +- .../canonical/RDFC10Serializer.java | 18 +- .../canonical/RDFC10SerializerOptions.java | 4 +- .../jsonld/JSONLDSerializer.java | 14 +- ...itaniumRDFDatasetSerializationAdapter.java | 30 +-- .../nquads/NQuadsSerializer.java | 26 +-- .../nquads/NQuadsSerializerOptions.java | 4 +- .../ntriples/NTriplesSerializer.java | 22 +- .../ntriples/NTriplesSerializerOptions.java | 4 +- .../option/AbstractNFamilyOptions.java | 2 +- .../option/AbstractSerializerOptions.java | 16 +- .../option/AbstractTFamilyOptions.java | 12 +- .../option/BlankNodeStyleEnum.java | 2 +- .../option/LiteralDatatypePolicyEnum.java | 2 +- .../option/PrefixOrderingEnum.java | 2 +- .../rdfxml/RDFXMLSerializer.java | 33 ++- .../rdfxml/RDFXMLSerializerOptions.java | 18 +- .../io/serialization/trig/TriGSerializer.java | 26 +-- .../trig/TriGSerializerOptions.java | 6 +- .../turtle/TurtleSerializer.java | 18 +- .../turtle/TurtleSerializerOptions.java | 10 +- .../util/SerializationConstants.java | 4 +- .../io/serialization/util/StatementUtils.java | 6 +- .../impl/temp/CoreseAdaptedValueFactory.java | 47 ++-- .../impl/temp/CoreseEdgeAdapter.java | 2 +- .../next/{ => data}/impl/temp/CoreseIRI.java | 6 +- .../{ => data}/impl/temp/CoreseModel.java | 16 +- .../impl/temp/CoreseNodeAdapter.java | 2 +- .../{ => data}/impl/temp/CoreseStatement.java | 10 +- .../impl/temp/CoreseValueConverter.java | 14 +- .../next/{ => data}/impl/temp/EmptyModel.java | 16 +- .../{ => data}/impl/temp/FilteredModel.java | 16 +- .../{ => data}/impl/temp/ModelNamespace.java | 4 +- .../temp/literal/AbstractCoreseNumber.java | 6 +- .../impl/temp/literal/CoreseBNode.java | 8 +- .../impl/temp/literal/CoreseBoolean.java | 12 +- .../temp/literal/CoreseDatatypeAdapter.java | 4 +- .../impl/temp/literal/CoreseDate.java | 16 +- .../impl/temp/literal/CoreseDatetime.java | 16 +- .../impl/temp/literal/CoreseDecimal.java | 16 +- .../impl/temp/literal/CoreseDuration.java | 10 +- .../impl/temp/literal/CoreseInteger.java | 18 +- .../CoreseLanguageTaggedStringLiteral.java | 14 +- .../impl/temp/literal/CoreseTime.java | 8 +- .../impl/temp/literal/CoreseTyped.java | 18 +- .../core/next/{api => data}/io/IOOptions.java | 2 +- .../io/common/BaseIRIOptions.java | 2 +- .../{api => data}/io/parser/RDFParser.java | 6 +- .../io/parser/RDFParserFactory.java | 10 +- .../BlankNodeIdGenerationOptions.java | 2 +- .../io/serializer/DatatypePolicyOptions.java | 4 +- .../io/serializer/LineEndingOptions.java | 2 +- .../io/serializer/PrettyPrintOptions.java | 4 +- .../io/serializer/RDFSerializer.java | 8 +- .../io/serializer/SerializerFactory.java | 8 +- .../io/serializer/UsesPrefixOptions.java | 6 +- .../datamanager/api/ModelDataManager.java | 6 +- .../api/operations/BulkOperations.java | 4 +- .../api/operations/MetadataOperations.java | 6 +- .../api/operations/MutationOperations.java | 8 +- .../api/operations/QueryOperations.java | 4 +- .../api/support/model/MutationResult.java | 2 +- .../api/support/model/StatementPattern.java | 6 +- .../impl/CoreseModelDataManager.java | 2 +- .../impl/CoreseModelDataManagerBuilder.java | 2 +- .../impl/lifecycle/LifecycleManagerImpl.java | 2 +- .../impl/operations/BulkOperationsImpl.java | 10 +- .../operations/MetadataOperationsImpl.java | 8 +- .../operations/MutationOperationsImpl.java | 10 +- .../impl/operations/QueryOperationsImpl.java | 10 +- .../transaction/TransactionManagerImpl.java | 2 +- .../core/next/impl/common/literal/RDF.java | 30 --- .../core/next/impl/common/literal/XSD.java | 205 ------------------ .../core/next/kgram/api/query/DQPFactory.java | 12 - .../core/next/kgram/api/query/Provider.java | 21 -- .../kgram/adapter/BindingAdapter.java | 22 +- .../kgram/adapter/DatatypeAdapter.java | 4 +- .../kgram/api/core/BindingContext.java | 2 +- .../kgram/api/core/DatatypeValue.java | 2 +- .../kgram/api/core/DatatypeValueFactory.java | 2 +- .../next/{ => query}/kgram/api/core/Edge.java | 2 +- .../kgram/api/core/ExpPattern.java | 2 +- .../{ => query}/kgram/api/core/ExpType.java | 2 +- .../next/{ => query}/kgram/api/core/Expr.java | 8 +- .../{ => query}/kgram/api/core/ExprType.java | 2 +- .../{ => query}/kgram/api/core/Filter.java | 2 +- .../{ => query}/kgram/api/core/Graph.java | 2 +- .../{ => query}/kgram/api/core/Loopable.java | 2 +- .../next/{ => query}/kgram/api/core/Node.java | 6 +- .../kgram/api/core/PointerType.java | 2 +- .../kgram/api/core/Pointerable.java | 10 +- .../{ => query}/kgram/api/core/Regex.java | 2 +- .../kgram/api/core/TripleStore.java | 2 +- .../next/{ => query}/kgram/api/query/AST.java | 2 +- .../query/kgram/api/query/DQPFactory.java | 12 + .../kgram/api/query/Environment.java | 20 +- .../kgram/api/query/Evaluator.java | 4 +- .../kgram/api/query/Graphable.java | 2 +- .../{ => query}/kgram/api/query/Matcher.java | 6 +- .../{ => query}/kgram/api/query/Plugin.java | 4 +- .../kgram/api/query/ProcessVisitor.java | 16 +- .../{ => query}/kgram/api/query/Producer.java | 12 +- .../next/query/kgram/api/query/Provider.java | 21 ++ .../{ => query}/kgram/api/query/Result.java | 4 +- .../{ => query}/kgram/api/query/Results.java | 4 +- .../kgram/api/query/SPARQLEngine.java | 12 +- .../{ => query}/kgram/core/BgpGenerator.java | 2 +- .../next/{ => query}/kgram/core/Checker.java | 12 +- .../kgram/core/CompleteSPARQL.java | 8 +- .../next/{ => query}/kgram/core/Eval.java | 25 +-- .../{ => query}/kgram/core/EvalGraph.java | 8 +- .../next/{ => query}/kgram/core/EvalJoin.java | 8 +- .../{ => query}/kgram/core/EvalOptional.java | 10 +- .../{ => query}/kgram/core/EvalSPARQL.java | 6 +- .../core/next/{ => query}/kgram/core/Exp.java | 8 +- .../next/{ => query}/kgram/core/ExpEdge.java | 10 +- .../{ => query}/kgram/core/ExpHandler.java | 4 +- .../next/{ => query}/kgram/core/Group.java | 4 +- .../kgram/core/IterableEntity.java | 6 +- .../next/{ => query}/kgram/core/Mapping.java | 25 ++- .../{ => query}/kgram/core/MappingSet.java | 4 +- .../next/{ => query}/kgram/core/Mappings.java | 20 +- .../next/{ => query}/kgram/core/Memory.java | 19 +- .../next/{ => query}/kgram/core/Merge.java | 2 +- .../{ => query}/kgram/core/PointerObject.java | 4 +- .../kgram/core/ProcessVisitorDefault.java | 6 +- .../next/{ => query}/kgram/core/Query.java | 18 +- .../{ => query}/kgram/core/QuerySorter.java | 8 +- .../next/{ => query}/kgram/core/Sorter.java | 4 +- .../{ => query}/kgram/core/SorterNew.java | 20 +- .../kgram/core/SparqlException.java | 2 +- .../next/{ => query}/kgram/core/Stack.java | 4 +- .../next/{ => query}/kgram/event/Event.java | 4 +- .../{ => query}/kgram/event/EventImpl.java | 6 +- .../kgram/event/EventListener.java | 2 +- .../{ => query}/kgram/event/EventManager.java | 2 +- .../kgram/event/ResultListener.java | 14 +- .../next/{ => query}/kgram/event/User.java | 2 +- .../{ => query}/kgram/filter/Checker.java | 8 +- .../{ => query}/kgram/filter/Compile.java | 8 +- .../{ => query}/kgram/filter/Extension.java | 4 +- .../{ => query}/kgram/filter/MatchBind.java | 4 +- .../{ => query}/kgram/filter/Matcher.java | 6 +- .../{ => query}/kgram/filter/Pattern.java | 12 +- .../next/{ => query}/kgram/path/Buffer.java | 4 +- .../{ => query}/kgram/path/GraphPath.java | 6 +- .../next/{ => query}/kgram/path/Path.java | 20 +- .../{ => query}/kgram/path/PathFinder.java | 28 +-- .../next/{ => query}/kgram/path/Record.java | 6 +- .../next/{ => query}/kgram/path/Stack.java | 2 +- .../next/{ => query}/kgram/path/State.java | 2 +- .../next/{ => query}/kgram/path/Step.java | 4 +- .../next/{ => query}/kgram/path/Visit.java | 6 +- .../kgram/sorter/core/AbstractCostModel.java | 2 +- .../{ => query}/kgram/sorter/core/Const.java | 4 +- .../kgram/sorter/core/IEstimate.java | 4 +- .../kgram/sorter/core/IProducerQP.java | 2 +- .../{ => query}/kgram/sorter/core/ISort.java | 4 +- .../kgram/sorter/core/QPGEdge.java | 4 +- .../kgram/sorter/core/QPGNode.java | 16 +- .../kgram/sorter/core/QPGraph.java | 6 +- .../impl/qpv1/BasicPatternGenerator.java | 4 +- .../impl/qpv1/DepthFirstBestSearch.java | 8 +- .../impl/qpv1/HeuristicsBasedEstimation.java | 8 +- .../sorter/impl/qpv1/QPGEdgeCostModel.java | 6 +- .../sorter/impl/qpv1/QPGNodeCostModel.java | 12 +- .../kgram/tool/ApproximateSearchEnv.java | 8 +- .../next/{ => query}/kgram/tool/EdgeInv.java | 12 +- .../kgram/tool/EnvironmentImpl.java | 22 +- .../next/{ => query}/kgram/tool/Message.java | 2 +- .../next/{ => query}/kgram/tool/NodeImpl.java | 10 +- .../kgram/tool/ProducerDefault.java | 16 +- .../{ => query}/kgram/tool/ResultsImpl.java | 12 +- .../sparql/triple/function/term/Binding.java | 4 +- .../core/next/{ => data}/api/IRITest.java | 3 +- .../next/{ => data}/api/ValueFactoryTest.java | 10 +- .../api/base/AbstractModelTest.java | 6 +- .../api/base/io/FileFormatTest.java | 37 ++-- .../{ => data}/api/base/io/RDFFormatTest.java | 3 +- .../api/model/ValueFactoryTest.java | 12 +- .../model/base/CoreDatatypeHelperTest.java | 16 +- .../api/support/model/MutationResultTest.java | 2 +- .../support/model/StatementPatternTest.java | 6 +- .../CoreseModelDataManagerBuilderTest.java | 2 +- .../impl/CoreseModelDataManagerTest.java | 2 +- .../lifecycle/LifecycleManagerImplTest.java | 2 +- .../operations/BulkOperationsImplTest.java | 2 +- .../MetadataOperationsImplTest.java | 8 +- .../operations/QueryOperationsImplTest.java | 2 +- .../core/next/impl/common/BasicIRITest.java | 5 +- .../common/literal/BasicDurationTest.java | 6 +- .../impl/common/prefix/PrefixHandlerTest.java | 1 + .../next/impl/common/util/IRIUtilsTest.java | 1 + .../core/next/impl/config/CoreConfigTest.java | 2 + .../impl/io/option/JSONLDOptionsTest.java | 12 +- .../impl/io/parser/ParserFactoryTest.java | 19 +- .../io/parser/jsonld/JSONLDCircularTest.java | 20 +- .../io/parser/jsonld/JSONLDParserTest.java | 27 +-- .../io/parser/nquads/NQuadsCircularTest.java | 20 +- .../io/parser/nquads/NQuadsListenerTest.java | 7 +- .../io/parser/nquads/NQuadsParserTest.java | 7 +- .../parser/ntriples/NTriplesCircularTest.java | 20 +- .../parser/ntriples/NTriplesListenerTest.java | 7 +- .../parser/ntriples/NTriplesParserTest.java | 7 +- .../impl/io/parser/rdfa/RDFaParserTest.java | 21 +- .../io/parser/rdfxml/RDFXMLCircularTest.java | 20 +- .../io/parser/rdfxml/RDFXMLParserTest.java | 13 +- .../rdfxml/RDFXMLStatementEmitterTest.java | 11 +- .../io/parser/rdfxml/RDFXMLUtilsTest.java | 15 +- .../impl/io/parser/trig/TriGCircularTest.java | 28 +-- .../io/parser/trig/TriGListenerImplTest.java | 9 +- .../impl/io/parser/trig/TriGParserTest.java | 15 +- .../io/parser/turtle/TurtleCircularTest.java | 28 +-- .../io/parser/turtle/TurtleListenerTest.java | 9 +- .../io/parser/turtle/TurtleParserTest.java | 16 +- .../serialization/SerializerFactoryTest.java | 37 ++-- .../serialization/TestStatementFactory.java | 12 +- .../RDFC10SerializerOptionsTest.java | 1 + .../canonical/RDFC10SerializerTest.java | 21 +- .../jsonld/JSONLDSerializerTest.java | 11 +- .../nquads/NQuadsSerializerOptionsTest.java | 3 +- .../nquads/NQuadsSerializerTest.java | 6 +- .../NTriplesSerializerOptionsTest.java | 3 +- .../ntriples/NTriplesSerializerTest.java | 6 +- .../rdfxml/RDFXMLSerializerTest.java | 21 +- .../serialization/rdfxml/XmlConfigTest.java | 17 +- .../trig/TriGSerializerOptionsTest.java | 19 +- .../trig/TriGSerializerTest.java | 20 +- .../turtle/TurtleSerializerOptionsTest.java | 19 +- .../turtle/TurtleSerializerTest.java | 24 +- .../temp/CoreseAdaptedValueFactoryTest.java | 40 ++-- .../core/next/impl/temp/CoreseIRITest.java | 7 +- .../core/next/impl/temp/CoreseModelTest.java | 16 +- .../next/impl/temp/CoreseStatementTest.java | 10 +- .../literal/AbstractCoreseNumberTest.java | 1 + .../impl/temp/literal/CoreseBNodeTest.java | 1 + .../impl/temp/literal/CoreseBooleanTest.java | 3 +- .../impl/temp/literal/CoreseDateTest.java | 3 +- .../impl/temp/literal/CoreseDatetimeTest.java | 3 +- .../impl/temp/literal/CoreseDecimalTest.java | 4 +- .../impl/temp/literal/CoreseIntegerTest.java | 4 +- .../CoreseLanguageTaggedStringTest.java | 3 +- .../impl/temp/literal/CoreseTypedTest.java | 13 +- .../kgram/adapter/BindingAdapterTest.java | 14 +- .../kgram/adapter/DatatypeAdapterTest.java | 3 +- .../corese/core/next/kgram/core/EvalTest.java | 11 +- .../corese/core/next/kgram/core/ExpTest.java | 7 +- .../core/next/kgram/core/MappingTest.java | 5 +- .../core/next/kgram/core/MappingsTest.java | 8 +- .../core/next/kgram/core/MemoryTest.java | 13 +- .../core/next/kgram/core/QueryTest.java | 8 +- 340 files changed, 1854 insertions(+), 1779 deletions(-) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/BNode.java (94%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/IPrefixHandler.java (99%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/IRI.java (94%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/Literal.java (96%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/Model.java (98%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/Namespace.java (92%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/NamespaceAware.java (94%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/Resource.java (85%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/Statement.java (94%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/Triple.java (89%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/Value.java (95%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/ValueFactory.java (98%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/base/exception/CoreseException.java (95%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/base/io/AbstractIOOptions.java (79%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/base/io/FileFormat.java (98%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/base/io/RDFFormat.java (99%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/base/io/parser/AbstractRDFParser.java (87%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/base/io/parser/AbstractRDFParserFactory.java (72%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/base/model/AbstractBNode.java (95%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/base/model/AbstractIRI.java (90%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/base/model/AbstractModel.java (97%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/base/model/AbstractNamespace.java (92%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/base/model/AbstractStatement.java (96%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/base/model/ReadOnlyModel.java (90%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/base/model/literal/AbstractDuration.java (95%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/base/model/literal/AbstractLiteral.java (93%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/base/model/literal/AbstractNumber.java (76%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/base/model/literal/AbstractStringLiteral.java (90%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/base/model/literal/AbstractTemporalPointLiteral.java (93%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/base/model/literal/DefaultDatatype.java (50%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/literal/CoreDatatype.java (61%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/common/BasicIRI.java (79%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/common/literal/BasicDuration.java (96%) create mode 100644 src/main/java/fr/inria/corese/core/next/data/impl/common/literal/RDF.java create mode 100644 src/main/java/fr/inria/corese/core/next/data/impl/common/literal/XSD.java rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/common/prefix/PrefixHandler.java (98%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/common/util/IRIUtils.java (99%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/common/util/literal/CoreDatatypeHelper.java (65%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/common/vocabulary/FOAF.java (80%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/common/vocabulary/OWL.java (92%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/common/vocabulary/RDF.java (86%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/common/vocabulary/RDFS.java (92%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/common/vocabulary/RDFa.java (85%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/common/vocabulary/Vocabulary.java (85%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/common/vocabulary/XSD.java (97%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/config/CoreConfig.java (95%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/exception/IncorrectDatatypeException.java (75%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/exception/IncorrectFormatException.java (89%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/exception/IncorrectOperationException.java (83%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/exception/InternalException.java (81%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/exception/ParsingErrorException.java (88%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/exception/SerializationException.java (96%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/exception/SparqlException.java (100%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/exception/UnsupportedFileFormatException.java (89%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/inmemory/InMemoryModel.java (86%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/common/IOConstants.java (96%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/common/JSONLDOptions.java (96%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/ParserFactory.java (77%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/common/AbstractNTriplesNQuadsListener.java (94%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/common/AbstractTurtleTriGListener.java (97%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/jsonld/JSONLDParser.java (90%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/nquads/NQuadsListener.java (91%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/nquads/NQuadsParser.java (92%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/nquads/NQuadsParserOptions.java (74%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/ntriples/NTriplesListener.java (86%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/ntriples/NTriplesParser.java (92%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/ntriples/NTriplesParserOptions.java (74%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/rdfa/RDFaParser.java (98%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/rdfa/RDFaParserOptions.java (77%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/rdfa/model/RDFaAttributes.java (88%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/rdfa/model/RDFaEvaluationContext.java (96%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/rdfa/model/RDFaIncompleteStatement.java (94%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/rdfa/model/RDFaInitialPrefixes.java (80%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/rdfa/model/RDFaProcessingContext.java (98%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/rdfxml/RDFXMLParser.java (97%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/rdfxml/RDFXMLParserOptions.java (79%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/rdfxml/RDFXMLStatementEmitter.java (94%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/rdfxml/RDFXMLUtils.java (96%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/rdfxml/context/RDFXMLContext.java (96%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/trig/TriGListerner.java (97%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/trig/TriGParser.java (93%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/trig/TriGParserOptions.java (79%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/turtle/TurtleListener.java (96%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/turtle/TurtleParser.java (93%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/turtle/TurtleParserOptions.java (79%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/util/ParserConstants.java (91%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/SerializerFactory.java (82%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/base/AbstractGraphSerializer.java (98%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/base/AbstractLineBasedSerializer.java (94%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/canonical/RDFC10Canonicalizer.java (97%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/canonical/RDFC10Serializer.java (86%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/canonical/RDFC10SerializerOptions.java (95%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/jsonld/JSONLDSerializer.java (80%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/jsonld/TitaniumRDFDatasetSerializationAdapter.java (94%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/nquads/NQuadsSerializer.java (80%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/nquads/NQuadsSerializerOptions.java (93%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/ntriples/NTriplesSerializer.java (83%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/ntriples/NTriplesSerializerOptions.java (93%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/option/AbstractNFamilyOptions.java (97%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/option/AbstractSerializerOptions.java (96%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/option/AbstractTFamilyOptions.java (98%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/option/BlankNodeStyleEnum.java (82%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/option/LiteralDatatypePolicyEnum.java (86%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/option/PrefixOrderingEnum.java (85%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/rdfxml/RDFXMLSerializer.java (95%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/rdfxml/RDFXMLSerializerOptions.java (95%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/trig/TriGSerializer.java (93%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/trig/TriGSerializerOptions.java (90%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/turtle/TurtleSerializer.java (93%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/turtle/TurtleSerializerOptions.java (89%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/util/SerializationConstants.java (95%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/util/StatementUtils.java (98%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/temp/CoreseAdaptedValueFactory.java (90%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/temp/CoreseEdgeAdapter.java (90%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/temp/CoreseIRI.java (90%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/temp/CoreseModel.java (96%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/temp/CoreseNodeAdapter.java (89%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/temp/CoreseStatement.java (93%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/temp/CoreseValueConverter.java (92%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/temp/EmptyModel.java (85%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/temp/FilteredModel.java (95%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/temp/ModelNamespace.java (84%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/temp/literal/AbstractCoreseNumber.java (91%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/temp/literal/CoreseBNode.java (90%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/temp/literal/CoreseBoolean.java (91%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/temp/literal/CoreseDatatypeAdapter.java (76%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/temp/literal/CoreseDate.java (91%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/temp/literal/CoreseDatetime.java (92%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/temp/literal/CoreseDecimal.java (90%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/temp/literal/CoreseDuration.java (91%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/temp/literal/CoreseInteger.java (89%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/temp/literal/CoreseLanguageTaggedStringLiteral.java (89%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/temp/literal/CoreseTime.java (83%) rename src/main/java/fr/inria/corese/core/next/{ => data}/impl/temp/literal/CoreseTyped.java (90%) rename src/main/java/fr/inria/corese/core/next/{api => data}/io/IOOptions.java (76%) rename src/main/java/fr/inria/corese/core/next/{api => data}/io/common/BaseIRIOptions.java (81%) rename src/main/java/fr/inria/corese/core/next/{api => data}/io/parser/RDFParser.java (89%) rename src/main/java/fr/inria/corese/core/next/{api => data}/io/parser/RDFParserFactory.java (79%) rename src/main/java/fr/inria/corese/core/next/{api => data}/io/serializer/BlankNodeIdGenerationOptions.java (87%) rename src/main/java/fr/inria/corese/core/next/{api => data}/io/serializer/DatatypePolicyOptions.java (72%) rename src/main/java/fr/inria/corese/core/next/{api => data}/io/serializer/LineEndingOptions.java (79%) rename src/main/java/fr/inria/corese/core/next/{api => data}/io/serializer/PrettyPrintOptions.java (90%) rename src/main/java/fr/inria/corese/core/next/{api => data}/io/serializer/RDFSerializer.java (85%) rename src/main/java/fr/inria/corese/core/next/{api => data}/io/serializer/SerializerFactory.java (87%) rename src/main/java/fr/inria/corese/core/next/{api => data}/io/serializer/UsesPrefixOptions.java (81%) delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/literal/RDF.java delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/literal/XSD.java delete mode 100644 src/main/java/fr/inria/corese/core/next/kgram/api/query/DQPFactory.java delete mode 100644 src/main/java/fr/inria/corese/core/next/kgram/api/query/Provider.java rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/adapter/BindingAdapter.java (89%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/adapter/DatatypeAdapter.java (95%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/core/BindingContext.java (98%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/core/DatatypeValue.java (97%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/core/DatatypeValueFactory.java (76%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/core/Edge.java (98%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/core/ExpPattern.java (74%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/core/ExpType.java (95%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/core/Expr.java (90%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/core/ExprType.java (97%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/core/Filter.java (94%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/core/Graph.java (79%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/core/Loopable.java (70%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/core/Node.java (91%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/core/PointerType.java (92%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/core/Pointerable.java (81%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/core/Regex.java (95%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/core/TripleStore.java (78%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/query/AST.java (81%) create mode 100644 src/main/java/fr/inria/corese/core/next/query/kgram/api/query/DQPFactory.java rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/query/Environment.java (80%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/query/Evaluator.java (79%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/query/Graphable.java (74%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/query/Matcher.java (90%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/query/Plugin.java (67%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/query/ProcessVisitor.java (92%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/query/Producer.java (95%) create mode 100644 src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Provider.java rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/query/Result.java (59%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/query/Results.java (62%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/api/query/SPARQLEngine.java (51%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/BgpGenerator.java (54%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/Checker.java (88%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/CompleteSPARQL.java (94%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/Eval.java (99%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/EvalGraph.java (95%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/EvalJoin.java (96%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/EvalOptional.java (94%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/EvalSPARQL.java (97%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/Exp.java (99%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/ExpEdge.java (92%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/ExpHandler.java (97%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/Group.java (97%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/IterableEntity.java (81%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/Mapping.java (97%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/MappingSet.java (98%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/Mappings.java (98%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/Memory.java (98%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/Merge.java (97%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/PointerObject.java (53%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/ProcessVisitorDefault.java (91%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/Query.java (99%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/QuerySorter.java (98%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/Sorter.java (96%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/SorterNew.java (82%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/SparqlException.java (93%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/core/Stack.java (90%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/event/Event.java (90%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/event/EventImpl.java (94%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/event/EventListener.java (83%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/event/EventManager.java (95%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/event/ResultListener.java (64%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/event/User.java (75%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/filter/Checker.java (94%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/filter/Compile.java (96%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/filter/Extension.java (85%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/filter/MatchBind.java (91%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/filter/Matcher.java (97%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/filter/Pattern.java (93%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/path/Buffer.java (92%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/path/GraphPath.java (77%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/path/Path.java (87%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/path/PathFinder.java (97%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/path/Record.java (88%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/path/Stack.java (87%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/path/State.java (90%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/path/Step.java (88%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/path/Visit.java (98%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/sorter/core/AbstractCostModel.java (92%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/sorter/core/Const.java (89%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/sorter/core/IEstimate.java (81%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/sorter/core/IProducerQP.java (91%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/sorter/core/ISort.java (80%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/sorter/core/QPGEdge.java (94%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/sorter/core/QPGNode.java (95%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/sorter/core/QPGraph.java (97%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/sorter/impl/qpv1/BasicPatternGenerator.java (95%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/sorter/impl/qpv1/DepthFirstBestSearch.java (96%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/sorter/impl/qpv1/HeuristicsBasedEstimation.java (91%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/sorter/impl/qpv1/QPGEdgeCostModel.java (94%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/sorter/impl/qpv1/QPGNodeCostModel.java (96%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/tool/ApproximateSearchEnv.java (95%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/tool/EdgeInv.java (82%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/tool/EnvironmentImpl.java (90%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/tool/Message.java (92%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/tool/NodeImpl.java (92%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/tool/ProducerDefault.java (90%) rename src/main/java/fr/inria/corese/core/next/{ => query}/kgram/tool/ResultsImpl.java (65%) rename src/test/java/fr/inria/corese/core/next/{ => data}/api/IRITest.java (93%) rename src/test/java/fr/inria/corese/core/next/{ => data}/api/ValueFactoryTest.java (98%) rename src/test/java/fr/inria/corese/core/next/{ => data}/api/base/AbstractModelTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/api/base/io/FileFormatTest.java (71%) rename src/test/java/fr/inria/corese/core/next/{ => data}/api/base/io/RDFFormatTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/api/model/ValueFactoryTest.java (95%) rename src/test/java/fr/inria/corese/core/next/{ => data}/api/model/base/CoreDatatypeHelperTest.java (75%) diff --git a/src/main/java/fr/inria/corese/core/next/api/BNode.java b/src/main/java/fr/inria/corese/core/next/data/api/BNode.java similarity index 94% rename from src/main/java/fr/inria/corese/core/next/api/BNode.java rename to src/main/java/fr/inria/corese/core/next/data/api/BNode.java index a7753de4b..d259fee28 100644 --- a/src/main/java/fr/inria/corese/core/next/api/BNode.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/BNode.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api; +package fr.inria.corese.core.next.data.api; /** * Represents a blank node in a RDF graph. diff --git a/src/main/java/fr/inria/corese/core/next/api/IPrefixHandler.java b/src/main/java/fr/inria/corese/core/next/data/api/IPrefixHandler.java similarity index 99% rename from src/main/java/fr/inria/corese/core/next/api/IPrefixHandler.java rename to src/main/java/fr/inria/corese/core/next/data/api/IPrefixHandler.java index e2555c2d5..02c7b7af5 100644 --- a/src/main/java/fr/inria/corese/core/next/api/IPrefixHandler.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/IPrefixHandler.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api; +package fr.inria.corese.core.next.data.api; import java.util.Map; import java.util.Set; diff --git a/src/main/java/fr/inria/corese/core/next/api/IRI.java b/src/main/java/fr/inria/corese/core/next/data/api/IRI.java similarity index 94% rename from src/main/java/fr/inria/corese/core/next/api/IRI.java rename to src/main/java/fr/inria/corese/core/next/data/api/IRI.java index 09f3053bb..5f8be81fd 100644 --- a/src/main/java/fr/inria/corese/core/next/api/IRI.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/IRI.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api; +package fr.inria.corese.core.next.data.api; /** * Represents an IRI diff --git a/src/main/java/fr/inria/corese/core/next/api/Literal.java b/src/main/java/fr/inria/corese/core/next/data/api/Literal.java similarity index 96% rename from src/main/java/fr/inria/corese/core/next/api/Literal.java rename to src/main/java/fr/inria/corese/core/next/data/api/Literal.java index 2945f5bf6..137196906 100644 --- a/src/main/java/fr/inria/corese/core/next/api/Literal.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/Literal.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.api; +package fr.inria.corese.core.next.data.api; -import fr.inria.corese.core.next.api.literal.CoreDatatype ; +import fr.inria.corese.core.next.data.api.literal.CoreDatatype; import javax.xml.datatype.XMLGregorianCalendar; import java.math.BigDecimal; diff --git a/src/main/java/fr/inria/corese/core/next/api/Model.java b/src/main/java/fr/inria/corese/core/next/data/api/Model.java similarity index 98% rename from src/main/java/fr/inria/corese/core/next/api/Model.java rename to src/main/java/fr/inria/corese/core/next/data/api/Model.java index a4f7d146a..102e8b4e4 100644 --- a/src/main/java/fr/inria/corese/core/next/api/Model.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/Model.java @@ -1,10 +1,10 @@ -package fr.inria.corese.core.next.api; +package fr.inria.corese.core.next.data.api; import java.io.Serializable; import java.util.Optional; import java.util.Set; -import fr.inria.corese.core.next.impl.exception.IncorrectOperationException; +import fr.inria.corese.core.next.data.impl.exception.IncorrectOperationException; /** * This class represents an RDF model, a set of statements. diff --git a/src/main/java/fr/inria/corese/core/next/api/Namespace.java b/src/main/java/fr/inria/corese/core/next/data/api/Namespace.java similarity index 92% rename from src/main/java/fr/inria/corese/core/next/api/Namespace.java rename to src/main/java/fr/inria/corese/core/next/data/api/Namespace.java index 28e62fa9c..4ea603480 100644 --- a/src/main/java/fr/inria/corese/core/next/api/Namespace.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/Namespace.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api; +package fr.inria.corese.core.next.data.api; import java.io.Serializable; diff --git a/src/main/java/fr/inria/corese/core/next/api/NamespaceAware.java b/src/main/java/fr/inria/corese/core/next/data/api/NamespaceAware.java similarity index 94% rename from src/main/java/fr/inria/corese/core/next/api/NamespaceAware.java rename to src/main/java/fr/inria/corese/core/next/data/api/NamespaceAware.java index edc2e8568..f20a8bd34 100644 --- a/src/main/java/fr/inria/corese/core/next/api/NamespaceAware.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/NamespaceAware.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api; +package fr.inria.corese.core.next.data.api; import java.util.Optional; import java.util.Set; diff --git a/src/main/java/fr/inria/corese/core/next/api/Resource.java b/src/main/java/fr/inria/corese/core/next/data/api/Resource.java similarity index 85% rename from src/main/java/fr/inria/corese/core/next/api/Resource.java rename to src/main/java/fr/inria/corese/core/next/data/api/Resource.java index 151a0f099..7314c5be6 100644 --- a/src/main/java/fr/inria/corese/core/next/api/Resource.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/Resource.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api; +package fr.inria.corese.core.next.data.api; /** * Super interface of all resources of an RDF graph (statements, IRI, blank diff --git a/src/main/java/fr/inria/corese/core/next/api/Statement.java b/src/main/java/fr/inria/corese/core/next/data/api/Statement.java similarity index 94% rename from src/main/java/fr/inria/corese/core/next/api/Statement.java rename to src/main/java/fr/inria/corese/core/next/data/api/Statement.java index 415349043..a81ca3ceb 100644 --- a/src/main/java/fr/inria/corese/core/next/api/Statement.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/Statement.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api; +package fr.inria.corese.core.next.data.api; import java.io.Serializable; diff --git a/src/main/java/fr/inria/corese/core/next/api/Triple.java b/src/main/java/fr/inria/corese/core/next/data/api/Triple.java similarity index 89% rename from src/main/java/fr/inria/corese/core/next/api/Triple.java rename to src/main/java/fr/inria/corese/core/next/data/api/Triple.java index e6a6ee279..a0ded0898 100644 --- a/src/main/java/fr/inria/corese/core/next/api/Triple.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/Triple.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api; +package fr.inria.corese.core.next.data.api; public interface Triple extends Resource { diff --git a/src/main/java/fr/inria/corese/core/next/api/Value.java b/src/main/java/fr/inria/corese/core/next/data/api/Value.java similarity index 95% rename from src/main/java/fr/inria/corese/core/next/api/Value.java rename to src/main/java/fr/inria/corese/core/next/data/api/Value.java index 1bf971f23..20003ba5a 100644 --- a/src/main/java/fr/inria/corese/core/next/api/Value.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/Value.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api; +package fr.inria.corese.core.next.data.api; import java.io.Serializable; diff --git a/src/main/java/fr/inria/corese/core/next/api/ValueFactory.java b/src/main/java/fr/inria/corese/core/next/data/api/ValueFactory.java similarity index 98% rename from src/main/java/fr/inria/corese/core/next/api/ValueFactory.java rename to src/main/java/fr/inria/corese/core/next/data/api/ValueFactory.java index caf60833f..aed4de6d3 100644 --- a/src/main/java/fr/inria/corese/core/next/api/ValueFactory.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/ValueFactory.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.api; +package fr.inria.corese.core.next.data.api; -import fr.inria.corese.core.next.api.literal.CoreDatatype; +import fr.inria.corese.core.next.data.api.literal.CoreDatatype; import javax.xml.datatype.XMLGregorianCalendar; import java.math.BigDecimal; diff --git a/src/main/java/fr/inria/corese/core/next/api/base/exception/CoreseException.java b/src/main/java/fr/inria/corese/core/next/data/api/base/exception/CoreseException.java similarity index 95% rename from src/main/java/fr/inria/corese/core/next/api/base/exception/CoreseException.java rename to src/main/java/fr/inria/corese/core/next/data/api/base/exception/CoreseException.java index 986da1f4c..a00cf4464 100644 --- a/src/main/java/fr/inria/corese/core/next/api/base/exception/CoreseException.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/base/exception/CoreseException.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api.base.exception; +package fr.inria.corese.core.next.data.api.base.exception; /** * CoreseException is the superclass for all exceptions thrown by the Corese framework. diff --git a/src/main/java/fr/inria/corese/core/next/api/base/io/AbstractIOOptions.java b/src/main/java/fr/inria/corese/core/next/data/api/base/io/AbstractIOOptions.java similarity index 79% rename from src/main/java/fr/inria/corese/core/next/api/base/io/AbstractIOOptions.java rename to src/main/java/fr/inria/corese/core/next/data/api/base/io/AbstractIOOptions.java index 780894d7f..114067748 100644 --- a/src/main/java/fr/inria/corese/core/next/api/base/io/AbstractIOOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/base/io/AbstractIOOptions.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.api.base.io; +package fr.inria.corese.core.next.data.api.base.io; -import fr.inria.corese.core.next.api.io.IOOptions; +import fr.inria.corese.core.next.data.io.IOOptions; /** * Abstract class for parser/serializers that sets up the necessity of implementing a builder pattern. diff --git a/src/main/java/fr/inria/corese/core/next/api/base/io/FileFormat.java b/src/main/java/fr/inria/corese/core/next/data/api/base/io/FileFormat.java similarity index 98% rename from src/main/java/fr/inria/corese/core/next/api/base/io/FileFormat.java rename to src/main/java/fr/inria/corese/core/next/data/api/base/io/FileFormat.java index 59867eaa2..70da54c25 100644 --- a/src/main/java/fr/inria/corese/core/next/api/base/io/FileFormat.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/base/io/FileFormat.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api.base.io; +package fr.inria.corese.core.next.data.api.base.io; import java.util.List; import java.util.Objects; diff --git a/src/main/java/fr/inria/corese/core/next/api/base/io/RDFFormat.java b/src/main/java/fr/inria/corese/core/next/data/api/base/io/RDFFormat.java similarity index 99% rename from src/main/java/fr/inria/corese/core/next/api/base/io/RDFFormat.java rename to src/main/java/fr/inria/corese/core/next/data/api/base/io/RDFFormat.java index 46606499a..2918c82c5 100644 --- a/src/main/java/fr/inria/corese/core/next/api/base/io/RDFFormat.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/base/io/RDFFormat.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api.base.io; +package fr.inria.corese.core.next.data.api.base.io; import java.util.List; import java.util.Locale; diff --git a/src/main/java/fr/inria/corese/core/next/api/base/io/parser/AbstractRDFParser.java b/src/main/java/fr/inria/corese/core/next/data/api/base/io/parser/AbstractRDFParser.java similarity index 87% rename from src/main/java/fr/inria/corese/core/next/api/base/io/parser/AbstractRDFParser.java rename to src/main/java/fr/inria/corese/core/next/data/api/base/io/parser/AbstractRDFParser.java index a7670372a..6a6892ebd 100644 --- a/src/main/java/fr/inria/corese/core/next/api/base/io/parser/AbstractRDFParser.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/base/io/parser/AbstractRDFParser.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api.base.io.parser; +package fr.inria.corese.core.next.data.api.base.io.parser; import java.io.InputStream; import java.io.InputStreamReader; @@ -6,12 +6,12 @@ import java.nio.charset.StandardCharsets; import java.util.Objects; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.api.base.io.AbstractIOOptions; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.api.io.common.BaseIRIOptions; -import fr.inria.corese.core.next.api.io.parser.RDFParser; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.api.base.io.AbstractIOOptions; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.io.common.BaseIRIOptions; +import fr.inria.corese.core.next.data.io.parser.RDFParser; /** * Abstract class for RDFParser that set up the inner Model and ValueFactory diff --git a/src/main/java/fr/inria/corese/core/next/api/base/io/parser/AbstractRDFParserFactory.java b/src/main/java/fr/inria/corese/core/next/data/api/base/io/parser/AbstractRDFParserFactory.java similarity index 72% rename from src/main/java/fr/inria/corese/core/next/api/base/io/parser/AbstractRDFParserFactory.java rename to src/main/java/fr/inria/corese/core/next/data/api/base/io/parser/AbstractRDFParserFactory.java index 38f3c142e..7f1aa3209 100644 --- a/src/main/java/fr/inria/corese/core/next/api/base/io/parser/AbstractRDFParserFactory.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/base/io/parser/AbstractRDFParserFactory.java @@ -1,10 +1,10 @@ -package fr.inria.corese.core.next.api.base.io.parser; +package fr.inria.corese.core.next.data.api.base.io.parser; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.io.parser.RDFParser; -import fr.inria.corese.core.next.api.io.parser.RDFParserFactory; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.io.parser.RDFParser; +import fr.inria.corese.core.next.data.io.parser.RDFParserFactory; /** * Abstract base class for {@link RDFParserFactory}s. diff --git a/src/main/java/fr/inria/corese/core/next/api/base/model/AbstractBNode.java b/src/main/java/fr/inria/corese/core/next/data/api/base/model/AbstractBNode.java similarity index 95% rename from src/main/java/fr/inria/corese/core/next/api/base/model/AbstractBNode.java rename to src/main/java/fr/inria/corese/core/next/data/api/base/model/AbstractBNode.java index 069fce952..52044c2af 100644 --- a/src/main/java/fr/inria/corese/core/next/api/base/model/AbstractBNode.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/base/model/AbstractBNode.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.api.base.model; +package fr.inria.corese.core.next.data.api.base.model; -import fr.inria.corese.core.next.api.BNode; +import fr.inria.corese.core.next.data.api.BNode; /** * Abstract implementation of the {@link BNode} interface, providing common functionality for blank node representations. diff --git a/src/main/java/fr/inria/corese/core/next/api/base/model/AbstractIRI.java b/src/main/java/fr/inria/corese/core/next/data/api/base/model/AbstractIRI.java similarity index 90% rename from src/main/java/fr/inria/corese/core/next/api/base/model/AbstractIRI.java rename to src/main/java/fr/inria/corese/core/next/data/api/base/model/AbstractIRI.java index c5b519008..50ca12730 100644 --- a/src/main/java/fr/inria/corese/core/next/api/base/model/AbstractIRI.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/base/model/AbstractIRI.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.api.base.model; +package fr.inria.corese.core.next.data.api.base.model; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.impl.common.util.IRIUtils; -import fr.inria.corese.core.next.impl.exception.IncorrectFormatException; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.impl.common.util.IRIUtils; +import fr.inria.corese.core.next.data.impl.exception.IncorrectFormatException; import java.io.Serial; diff --git a/src/main/java/fr/inria/corese/core/next/api/base/model/AbstractModel.java b/src/main/java/fr/inria/corese/core/next/data/api/base/model/AbstractModel.java similarity index 97% rename from src/main/java/fr/inria/corese/core/next/api/base/model/AbstractModel.java rename to src/main/java/fr/inria/corese/core/next/data/api/base/model/AbstractModel.java index 3da788dc3..7d2efb033 100644 --- a/src/main/java/fr/inria/corese/core/next/api/base/model/AbstractModel.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/base/model/AbstractModel.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api.base.model; +package fr.inria.corese.core.next.data.api.base.model; import java.util.AbstractSet; import java.util.ArrayList; @@ -10,13 +10,13 @@ import java.util.Optional; import java.util.Set; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Namespace; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.api.Value; -import fr.inria.corese.core.next.impl.temp.ModelNamespace; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Namespace; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.api.Value; +import fr.inria.corese.core.next.data.impl.temp.ModelNamespace; /** * Abstract class that implements the Model interface. diff --git a/src/main/java/fr/inria/corese/core/next/api/base/model/AbstractNamespace.java b/src/main/java/fr/inria/corese/core/next/data/api/base/model/AbstractNamespace.java similarity index 92% rename from src/main/java/fr/inria/corese/core/next/api/base/model/AbstractNamespace.java rename to src/main/java/fr/inria/corese/core/next/data/api/base/model/AbstractNamespace.java index 8c15b1b4d..aa41fb397 100644 --- a/src/main/java/fr/inria/corese/core/next/api/base/model/AbstractNamespace.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/base/model/AbstractNamespace.java @@ -1,9 +1,9 @@ -package fr.inria.corese.core.next.api.base.model; +package fr.inria.corese.core.next.data.api.base.model; import java.io.Serial; import java.util.Objects; -import fr.inria.corese.core.next.api.Namespace; +import fr.inria.corese.core.next.data.api.Namespace; /** * A base implementation of the {@link Namespace} interface. diff --git a/src/main/java/fr/inria/corese/core/next/api/base/model/AbstractStatement.java b/src/main/java/fr/inria/corese/core/next/data/api/base/model/AbstractStatement.java similarity index 96% rename from src/main/java/fr/inria/corese/core/next/api/base/model/AbstractStatement.java rename to src/main/java/fr/inria/corese/core/next/data/api/base/model/AbstractStatement.java index 3b5a5749a..36924b456 100644 --- a/src/main/java/fr/inria/corese/core/next/api/base/model/AbstractStatement.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/base/model/AbstractStatement.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.api.base.model; +package fr.inria.corese.core.next.data.api.base.model; -import fr.inria.corese.core.next.api.Statement; +import fr.inria.corese.core.next.data.api.Statement; import java.util.Objects; /** diff --git a/src/main/java/fr/inria/corese/core/next/api/base/model/ReadOnlyModel.java b/src/main/java/fr/inria/corese/core/next/data/api/base/model/ReadOnlyModel.java similarity index 90% rename from src/main/java/fr/inria/corese/core/next/api/base/model/ReadOnlyModel.java rename to src/main/java/fr/inria/corese/core/next/data/api/base/model/ReadOnlyModel.java index f569e85e4..d4964d0b8 100644 --- a/src/main/java/fr/inria/corese/core/next/api/base/model/ReadOnlyModel.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/base/model/ReadOnlyModel.java @@ -1,16 +1,16 @@ -package fr.inria.corese.core.next.api.base.model; +package fr.inria.corese.core.next.data.api.base.model; import java.util.Collections; import java.util.Iterator; import java.util.Optional; import java.util.Set; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Namespace; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.api.Value; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Namespace; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.api.Value; /** * A read-only wrapper for a {@link Model}. All modification operations throw diff --git a/src/main/java/fr/inria/corese/core/next/api/base/model/literal/AbstractDuration.java b/src/main/java/fr/inria/corese/core/next/data/api/base/model/literal/AbstractDuration.java similarity index 95% rename from src/main/java/fr/inria/corese/core/next/api/base/model/literal/AbstractDuration.java rename to src/main/java/fr/inria/corese/core/next/data/api/base/model/literal/AbstractDuration.java index f5475f737..345b33bdf 100644 --- a/src/main/java/fr/inria/corese/core/next/api/base/model/literal/AbstractDuration.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/base/model/literal/AbstractDuration.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api.base.model.literal; +package fr.inria.corese.core.next.data.api.base.model.literal; import java.time.DateTimeException; import java.time.temporal.TemporalAmount; @@ -9,8 +9,8 @@ import java.util.SortedSet; import java.util.TreeSet; -import fr.inria.corese.core.next.api.literal.CoreDatatype; -import fr.inria.corese.core.next.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.api.literal.CoreDatatype; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; /** * Abstract class representing a duration literal in RDF. diff --git a/src/main/java/fr/inria/corese/core/next/api/base/model/literal/AbstractLiteral.java b/src/main/java/fr/inria/corese/core/next/data/api/base/model/literal/AbstractLiteral.java similarity index 93% rename from src/main/java/fr/inria/corese/core/next/api/base/model/literal/AbstractLiteral.java rename to src/main/java/fr/inria/corese/core/next/data/api/base/model/literal/AbstractLiteral.java index c11def7ab..4de1caa4d 100644 --- a/src/main/java/fr/inria/corese/core/next/api/base/model/literal/AbstractLiteral.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/base/model/literal/AbstractLiteral.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api.base.model.literal; +package fr.inria.corese.core.next.data.api.base.model.literal; import java.math.BigDecimal; import java.math.BigInteger; @@ -9,11 +9,11 @@ import javax.xml.datatype.XMLGregorianCalendar; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Literal; -import fr.inria.corese.core.next.api.literal.CoreDatatype; -import fr.inria.corese.core.next.impl.common.literal.XSD; -import fr.inria.corese.core.next.impl.exception.IncorrectOperationException; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Literal; +import fr.inria.corese.core.next.data.api.literal.CoreDatatype; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.exception.IncorrectOperationException; /** * Base class for all literals. All value accessors throw an exception by default. diff --git a/src/main/java/fr/inria/corese/core/next/api/base/model/literal/AbstractNumber.java b/src/main/java/fr/inria/corese/core/next/data/api/base/model/literal/AbstractNumber.java similarity index 76% rename from src/main/java/fr/inria/corese/core/next/api/base/model/literal/AbstractNumber.java rename to src/main/java/fr/inria/corese/core/next/data/api/base/model/literal/AbstractNumber.java index 5fab96188..d85d0f4f8 100644 --- a/src/main/java/fr/inria/corese/core/next/api/base/model/literal/AbstractNumber.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/base/model/literal/AbstractNumber.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.api.base.model.literal; +package fr.inria.corese.core.next.data.api.base.model.literal; -import fr.inria.corese.core.next.api.IRI; +import fr.inria.corese.core.next.data.api.IRI; /** * Abstract class representing a number literal in RDF. diff --git a/src/main/java/fr/inria/corese/core/next/api/base/model/literal/AbstractStringLiteral.java b/src/main/java/fr/inria/corese/core/next/data/api/base/model/literal/AbstractStringLiteral.java similarity index 90% rename from src/main/java/fr/inria/corese/core/next/api/base/model/literal/AbstractStringLiteral.java rename to src/main/java/fr/inria/corese/core/next/data/api/base/model/literal/AbstractStringLiteral.java index 8804be1ee..4f876a865 100644 --- a/src/main/java/fr/inria/corese/core/next/api/base/model/literal/AbstractStringLiteral.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/base/model/literal/AbstractStringLiteral.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.api.base.model.literal; +package fr.inria.corese.core.next.data.api.base.model.literal; -import fr.inria.corese.core.next.api.IRI; +import fr.inria.corese.core.next.data.api.IRI; /** * Abstract class representing a string literal in Corese. It extends {@link AbstractLiteral} diff --git a/src/main/java/fr/inria/corese/core/next/api/base/model/literal/AbstractTemporalPointLiteral.java b/src/main/java/fr/inria/corese/core/next/data/api/base/model/literal/AbstractTemporalPointLiteral.java similarity index 93% rename from src/main/java/fr/inria/corese/core/next/api/base/model/literal/AbstractTemporalPointLiteral.java rename to src/main/java/fr/inria/corese/core/next/data/api/base/model/literal/AbstractTemporalPointLiteral.java index ef5c158a9..a5d5f17df 100644 --- a/src/main/java/fr/inria/corese/core/next/api/base/model/literal/AbstractTemporalPointLiteral.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/base/model/literal/AbstractTemporalPointLiteral.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.api.base.model.literal; +package fr.inria.corese.core.next.data.api.base.model.literal; -import fr.inria.corese.core.next.api.IRI; +import fr.inria.corese.core.next.data.api.IRI; /** * Represents a temporal literal representing a point in time. Typically a date or a date and time. Implements the comparison between temporal literals. diff --git a/src/main/java/fr/inria/corese/core/next/api/base/model/literal/DefaultDatatype.java b/src/main/java/fr/inria/corese/core/next/data/api/base/model/literal/DefaultDatatype.java similarity index 50% rename from src/main/java/fr/inria/corese/core/next/api/base/model/literal/DefaultDatatype.java rename to src/main/java/fr/inria/corese/core/next/data/api/base/model/literal/DefaultDatatype.java index 79afb087d..82f7fe30c 100644 --- a/src/main/java/fr/inria/corese/core/next/api/base/model/literal/DefaultDatatype.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/base/model/literal/DefaultDatatype.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.api.base.model.literal; +package fr.inria.corese.core.next.data.api.base.model.literal; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.literal.CoreDatatype; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.literal.CoreDatatype; public enum DefaultDatatype implements CoreDatatype { NONE(); diff --git a/src/main/java/fr/inria/corese/core/next/api/literal/CoreDatatype.java b/src/main/java/fr/inria/corese/core/next/data/api/literal/CoreDatatype.java similarity index 61% rename from src/main/java/fr/inria/corese/core/next/api/literal/CoreDatatype.java rename to src/main/java/fr/inria/corese/core/next/data/api/literal/CoreDatatype.java index 7f8b3a765..75db0e8a7 100644 --- a/src/main/java/fr/inria/corese/core/next/api/literal/CoreDatatype.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/literal/CoreDatatype.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.api.literal; +package fr.inria.corese.core.next.data.api.literal; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.base.model.literal.DefaultDatatype; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.base.model.literal.DefaultDatatype; /** * Represents a literal datatype. diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/BasicIRI.java b/src/main/java/fr/inria/corese/core/next/data/impl/common/BasicIRI.java similarity index 79% rename from src/main/java/fr/inria/corese/core/next/impl/common/BasicIRI.java rename to src/main/java/fr/inria/corese/core/next/data/impl/common/BasicIRI.java index d9fa75c16..73d33e753 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/BasicIRI.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/common/BasicIRI.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.impl.common; +package fr.inria.corese.core.next.data.impl.common; -import fr.inria.corese.core.next.api.base.model.AbstractIRI; -import fr.inria.corese.core.next.impl.exception.IncorrectFormatException; +import fr.inria.corese.core.next.data.api.base.model.AbstractIRI; +import fr.inria.corese.core.next.data.impl.exception.IncorrectFormatException; /** * Basic implementation of IRI diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/literal/BasicDuration.java b/src/main/java/fr/inria/corese/core/next/data/impl/common/literal/BasicDuration.java similarity index 96% rename from src/main/java/fr/inria/corese/core/next/impl/common/literal/BasicDuration.java rename to src/main/java/fr/inria/corese/core/next/data/impl/common/literal/BasicDuration.java index d29574925..4d5bf79ed 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/literal/BasicDuration.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/common/literal/BasicDuration.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.common.literal; +package fr.inria.corese.core.next.data.impl.common.literal; import static java.time.temporal.ChronoUnit.DAYS; import static java.time.temporal.ChronoUnit.HOURS; @@ -21,11 +21,11 @@ import java.util.regex.Matcher; import java.util.regex.Pattern; -import fr.inria.corese.core.next.api.Literal; -import fr.inria.corese.core.next.api.base.model.literal.AbstractDuration; -import fr.inria.corese.core.next.api.literal.CoreDatatype; -import fr.inria.corese.core.next.impl.exception.IncorrectFormatException; -import fr.inria.corese.core.next.impl.exception.IncorrectOperationException; +import fr.inria.corese.core.next.data.api.Literal; +import fr.inria.corese.core.next.data.api.base.model.literal.AbstractDuration; +import fr.inria.corese.core.next.data.api.literal.CoreDatatype; +import fr.inria.corese.core.next.data.impl.exception.IncorrectFormatException; +import fr.inria.corese.core.next.data.impl.exception.IncorrectOperationException; /** * A basic implementation of the {@link Literal} interface for durations. diff --git a/src/main/java/fr/inria/corese/core/next/data/impl/common/literal/RDF.java b/src/main/java/fr/inria/corese/core/next/data/impl/common/literal/RDF.java new file mode 100644 index 000000000..f2b0040ad --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/data/impl/common/literal/RDF.java @@ -0,0 +1,30 @@ +package fr.inria.corese.core.next.data.impl.common.literal; + +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.literal.CoreDatatype; + +/** + * Enumeration of the RDF datatypes usable as core datatypes of literals. + */ +public enum RDF implements CoreDatatype { + LANGSTRING(fr.inria.corese.core.next.data.impl.common.vocabulary.RDF.langString.getIRI()), + HTML(fr.inria.corese.core.next.data.impl.common.vocabulary.RDF.HTML.getIRI()), + JSON(fr.inria.corese.core.next.data.impl.common.vocabulary.RDF.JSON.getIRI()), + XML_LITERAL(fr.inria.corese.core.next.data.impl.common.vocabulary.RDF.XMLLiteral.getIRI()), + ; + private final IRI iri; + + /** + * Constructor for the RDF core datatype enum. + * + * @param iri the IRI of the datatype + */ + RDF(IRI iri) { + this.iri = iri; + } + + @Override + public IRI getIRI() { + return iri; + } +} diff --git a/src/main/java/fr/inria/corese/core/next/data/impl/common/literal/XSD.java b/src/main/java/fr/inria/corese/core/next/data/impl/common/literal/XSD.java new file mode 100644 index 000000000..959b5fb98 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/data/impl/common/literal/XSD.java @@ -0,0 +1,205 @@ +/** + * Enumeration of the XML Schema Datatypes (XSD) to be used as core datatype in literals. + */ +package fr.inria.corese.core.next.data.impl.common.literal; + +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.literal.CoreDatatype; + +public enum XSD implements CoreDatatype { + /** + * true, false + */ + BOOLEAN(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdBoolean.getIRI()), + + /** + * Arbitrary-size integer numbers + */ + INTEGER(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdInteger.getIRI()), + + /** + * -9223372036854775808…+9223372036854775807 (64 bit) + */ + LONG(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdLong.getIRI()), + + /** + * Arbitrary-precision decimal numbers + */ + DECIMAL(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdDecimal.getIRI()), + + /** + * -2147483648…+2147483647 (32 bit) + */ + INT(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdInt.getIRI()), + + /** + * -32768…+32767 (16 bit) + */ + SHORT(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdShort.getIRI()), + + /** + * -128…+127 (8 bit) + */ + BYTE(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdByte.getIRI()), + + /** + * 32-bit floating point numbers incl. ±Inf, ±0, NaN + */ + FLOAT(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdFloat.getIRI()), + + /** + * 64-bit floating point numbers incl. ±Inf, ±0, NaN + */ + DOUBLE(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdDouble.getIRI()), + + /** + * Integer numbers >0 + */ + POSITIVE_INTEGER(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdPositiveInteger.getIRI()), + + /** + * Integer numbers <0 + */ + NEGATIVE_INTEGER(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdNegativeInteger.getIRI()), + + /** + * Integer numbers ≥0 + */ + NON_NEGATIVE_INTEGER(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdNonNegativeInteger.getIRI()), + + /** + * Integer numbers ≤0 + */ + NON_POSITIVE_INTEGER(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdNonPositiveInteger.getIRI()), + + /** + * 0…18446744073709551615 (64 bit) + */ + UNSIGNED_LONG(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdUnsignedLong.getIRI()), + + /** + * 0…4294967295 (32 bit) + */ + UNSIGNED_INT(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdUnsignedInt.getIRI()), + + /** + * 0…65535 (16 bit) + */ + UNSIGNED_SHORT(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdUnsignedShort.getIRI()), + + /** + * 0…255 (8 bit) + */ + UNSIGNED_BYTE(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdUnsignedByte.getIRI()), + + /** + * Duration of time + */ + DURATION(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdDuration.getIRI()), + + /** + * Duration of time (days, hours, minutes, seconds only) + */ + DAYTIME_DURATION(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdDayTimeDuration.getIRI()), + + /** + * Duration of time (months and years only) + */ + YEARMONTH_DURATION(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdYearMonthDuration.getIRI()), + + /** + * Dates (yyyy-mm-dd) with or without timezone + */ + DATE(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdDate.getIRI()), + + /** + * Date and time with or without timezone + */ + DATETIME(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdDateTime.getIRI()), + + /** + * Gregorian calendar day of the month + */ + DAY(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdDay.getIRI()), + + /** + * Gregorian calendar month + */ + MONTH(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdMonth.getIRI()), + + /** + * Gregorian calendar year + */ + YEAR(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdYear.getIRI()), + + /** + * Gregorian calendar year and month + */ + YEARMONTH(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdYearMonth.getIRI()), + + /** + * Gregorian calendar month and day + */ + MONTHDAY(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdMonthDay.getIRI()), + + /** + * Times (hh:mm:ss.sss…) with or without timezone + */ + TIME(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdTime.getIRI()), + + /** + * Hex-encoded binary data + */ + HEXBINARY(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdHexBinary.getIRI()), + + /** + * Base64-encoded binary data + */ + BASE64BINARY(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdBase64Binary.getIRI()), + + /** + * Resolved or relative URI and IRI references + */ + ANYURI(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdAnyURI.getIRI()), + + /** + * Character strings + */ + STRING(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdString.getIRI()), + + /** + * Whitespace-normalized strings + */ + NORMALIZEDSTRING(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdNormalizedString.getIRI()), + + /** + * Tokenized strings + */ + TOKEN(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdToken.getIRI()), + + /** + * Language tags per <a href="https://www.rfc-editor.org/rfc/rfc5646">rfc5646</> + */ + LANGUAGE(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdLanguage.getIRI()), + + /** + * XML Names + */ + NAME(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdName.getIRI()), + + /** + * XML NCNames + */ + NCNAME(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdNCName.getIRI()), + ; + IRI iri; + + XSD(IRI iri) { + this.iri = iri; + } + + @Override + public IRI getIRI() { + return iri; + } +} diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/prefix/PrefixHandler.java b/src/main/java/fr/inria/corese/core/next/data/impl/common/prefix/PrefixHandler.java similarity index 98% rename from src/main/java/fr/inria/corese/core/next/impl/common/prefix/PrefixHandler.java rename to src/main/java/fr/inria/corese/core/next/data/impl/common/prefix/PrefixHandler.java index a862494ae..70601ab79 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/prefix/PrefixHandler.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/common/prefix/PrefixHandler.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.impl.common.prefix; +package fr.inria.corese.core.next.data.impl.common.prefix; -import fr.inria.corese.core.next.api.IPrefixHandler; -import fr.inria.corese.core.next.api.Namespace; -import fr.inria.corese.core.next.impl.common.vocabulary.*; +import fr.inria.corese.core.next.data.api.IPrefixHandler; +import fr.inria.corese.core.next.data.api.Namespace; +import fr.inria.corese.core.next.data.impl.common.vocabulary.*; import java.io.Serial; import java.util.*; diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/util/IRIUtils.java b/src/main/java/fr/inria/corese/core/next/data/impl/common/util/IRIUtils.java similarity index 99% rename from src/main/java/fr/inria/corese/core/next/impl/common/util/IRIUtils.java rename to src/main/java/fr/inria/corese/core/next/data/impl/common/util/IRIUtils.java index edf0c3c6c..fe2abff8f 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/util/IRIUtils.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/common/util/IRIUtils.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.common.util; +package fr.inria.corese.core.next.data.impl.common.util; import java.net.URI; import java.net.URISyntaxException; diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/util/literal/CoreDatatypeHelper.java b/src/main/java/fr/inria/corese/core/next/data/impl/common/util/literal/CoreDatatypeHelper.java similarity index 65% rename from src/main/java/fr/inria/corese/core/next/impl/common/util/literal/CoreDatatypeHelper.java rename to src/main/java/fr/inria/corese/core/next/data/impl/common/util/literal/CoreDatatypeHelper.java index e1689ec77..119413931 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/util/literal/CoreDatatypeHelper.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/common/util/literal/CoreDatatypeHelper.java @@ -1,9 +1,9 @@ -package fr.inria.corese.core.next.impl.common.util.literal; +package fr.inria.corese.core.next.data.impl.common.util.literal; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.literal.CoreDatatype; -import fr.inria.corese.core.next.impl.common.literal.RDF; -import fr.inria.corese.core.next.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.literal.CoreDatatype; +import fr.inria.corese.core.next.data.impl.common.literal.RDF; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; public class CoreDatatypeHelper { diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/FOAF.java b/src/main/java/fr/inria/corese/core/next/data/impl/common/vocabulary/FOAF.java similarity index 80% rename from src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/FOAF.java rename to src/main/java/fr/inria/corese/core/next/data/impl/common/vocabulary/FOAF.java index c45fcf186..2ec833c3c 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/FOAF.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/common/vocabulary/FOAF.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.impl.common.vocabulary; +package fr.inria.corese.core.next.data.impl.common.vocabulary; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.impl.common.BasicIRI; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.impl.common.BasicIRI; public enum FOAF implements Vocabulary { ; diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/OWL.java b/src/main/java/fr/inria/corese/core/next/data/impl/common/vocabulary/OWL.java similarity index 92% rename from src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/OWL.java rename to src/main/java/fr/inria/corese/core/next/data/impl/common/vocabulary/OWL.java index 88360f476..2a557c4d2 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/OWL.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/common/vocabulary/OWL.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.impl.common.vocabulary; +package fr.inria.corese.core.next.data.impl.common.vocabulary; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.impl.common.BasicIRI; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.impl.common.BasicIRI; /** * Defines the OWL (Web Ontology Language) vocabulary. diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/RDF.java b/src/main/java/fr/inria/corese/core/next/data/impl/common/vocabulary/RDF.java similarity index 86% rename from src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/RDF.java rename to src/main/java/fr/inria/corese/core/next/data/impl/common/vocabulary/RDF.java index 123b9e156..3881e2a42 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/RDF.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/common/vocabulary/RDF.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.impl.common.vocabulary; +package fr.inria.corese.core.next.data.impl.common.vocabulary; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.impl.common.BasicIRI; -import fr.inria.corese.core.next.impl.exception.IncorrectFormatException; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.impl.common.BasicIRI; +import fr.inria.corese.core.next.data.impl.exception.IncorrectFormatException; /** * Defines the RDF vocabulary. diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/RDFS.java b/src/main/java/fr/inria/corese/core/next/data/impl/common/vocabulary/RDFS.java similarity index 92% rename from src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/RDFS.java rename to src/main/java/fr/inria/corese/core/next/data/impl/common/vocabulary/RDFS.java index 00872986c..9b4e37b4c 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/RDFS.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/common/vocabulary/RDFS.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.impl.common.vocabulary; +package fr.inria.corese.core.next.data.impl.common.vocabulary; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.impl.common.BasicIRI; -import fr.inria.corese.core.next.impl.exception.IncorrectFormatException; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.impl.common.BasicIRI; +import fr.inria.corese.core.next.data.impl.exception.IncorrectFormatException; /** * Vocabulary for RDF Schema (RDFS). diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/RDFa.java b/src/main/java/fr/inria/corese/core/next/data/impl/common/vocabulary/RDFa.java similarity index 85% rename from src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/RDFa.java rename to src/main/java/fr/inria/corese/core/next/data/impl/common/vocabulary/RDFa.java index a25b74f26..80218fc03 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/RDFa.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/common/vocabulary/RDFa.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.impl.common.vocabulary; +package fr.inria.corese.core.next.data.impl.common.vocabulary; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.impl.common.BasicIRI; -import fr.inria.corese.core.next.impl.exception.IncorrectFormatException; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.impl.common.BasicIRI; +import fr.inria.corese.core.next.data.impl.exception.IncorrectFormatException; public enum RDFa implements Vocabulary { diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/Vocabulary.java b/src/main/java/fr/inria/corese/core/next/data/impl/common/vocabulary/Vocabulary.java similarity index 85% rename from src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/Vocabulary.java rename to src/main/java/fr/inria/corese/core/next/data/impl/common/vocabulary/Vocabulary.java index b64200467..b9d422472 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/Vocabulary.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/common/vocabulary/Vocabulary.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.impl.common.vocabulary; +package fr.inria.corese.core.next.data.impl.common.vocabulary; -import fr.inria.corese.core.next.api.IRI; +import fr.inria.corese.core.next.data.api.IRI; /** * Common interface for the definition of enum-based vocabularies. diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/XSD.java b/src/main/java/fr/inria/corese/core/next/data/impl/common/vocabulary/XSD.java similarity index 97% rename from src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/XSD.java rename to src/main/java/fr/inria/corese/core/next/data/impl/common/vocabulary/XSD.java index a9765cab7..e30d3f355 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/XSD.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/common/vocabulary/XSD.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.impl.common.vocabulary; +package fr.inria.corese.core.next.data.impl.common.vocabulary; -import fr.inria.corese.core.next.api.IRI ; -import fr.inria.corese.core.next.impl.common.BasicIRI; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.impl.common.BasicIRI; /** * Defines the XSD vocabulary. diff --git a/src/main/java/fr/inria/corese/core/next/impl/config/CoreConfig.java b/src/main/java/fr/inria/corese/core/next/data/impl/config/CoreConfig.java similarity index 95% rename from src/main/java/fr/inria/corese/core/next/impl/config/CoreConfig.java rename to src/main/java/fr/inria/corese/core/next/data/impl/config/CoreConfig.java index 3de64dc91..3a8d70920 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/config/CoreConfig.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/config/CoreConfig.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.config; +package fr.inria.corese.core.next.data.impl.config; import com.typesafe.config.Config; import com.typesafe.config.ConfigFactory; diff --git a/src/main/java/fr/inria/corese/core/next/impl/exception/IncorrectDatatypeException.java b/src/main/java/fr/inria/corese/core/next/data/impl/exception/IncorrectDatatypeException.java similarity index 75% rename from src/main/java/fr/inria/corese/core/next/impl/exception/IncorrectDatatypeException.java rename to src/main/java/fr/inria/corese/core/next/data/impl/exception/IncorrectDatatypeException.java index 8024cfc56..c45256af9 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/exception/IncorrectDatatypeException.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/exception/IncorrectDatatypeException.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.impl.exception; +package fr.inria.corese.core.next.data.impl.exception; -import fr.inria.corese.core.next.api.base.exception.CoreseException; +import fr.inria.corese.core.next.data.api.base.exception.CoreseException; /** * Used to indicate that a literal object has been used incorrectly diff --git a/src/main/java/fr/inria/corese/core/next/impl/exception/IncorrectFormatException.java b/src/main/java/fr/inria/corese/core/next/data/impl/exception/IncorrectFormatException.java similarity index 89% rename from src/main/java/fr/inria/corese/core/next/impl/exception/IncorrectFormatException.java rename to src/main/java/fr/inria/corese/core/next/data/impl/exception/IncorrectFormatException.java index 77d6846b7..a44bfaaac 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/exception/IncorrectFormatException.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/exception/IncorrectFormatException.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.impl.exception; +package fr.inria.corese.core.next.data.impl.exception; -import fr.inria.corese.core.next.api.base.exception.CoreseException; +import fr.inria.corese.core.next.data.api.base.exception.CoreseException; /** * Used for any error raised from parsing of a string that should have been in a standard format (i.e RDF/XML, Turtle, JSON-LD, etc.) diff --git a/src/main/java/fr/inria/corese/core/next/impl/exception/IncorrectOperationException.java b/src/main/java/fr/inria/corese/core/next/data/impl/exception/IncorrectOperationException.java similarity index 83% rename from src/main/java/fr/inria/corese/core/next/impl/exception/IncorrectOperationException.java rename to src/main/java/fr/inria/corese/core/next/data/impl/exception/IncorrectOperationException.java index 96c0e6e0b..e15067078 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/exception/IncorrectOperationException.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/exception/IncorrectOperationException.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.impl.exception; +package fr.inria.corese.core.next.data.impl.exception; -import fr.inria.corese.core.next.api.base.exception.CoreseException; +import fr.inria.corese.core.next.data.api.base.exception.CoreseException; /** * Used to indicate that a function should not be used with the current object or with the object in its current state diff --git a/src/main/java/fr/inria/corese/core/next/impl/exception/InternalException.java b/src/main/java/fr/inria/corese/core/next/data/impl/exception/InternalException.java similarity index 81% rename from src/main/java/fr/inria/corese/core/next/impl/exception/InternalException.java rename to src/main/java/fr/inria/corese/core/next/data/impl/exception/InternalException.java index a17d25357..f9da9c118 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/exception/InternalException.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/exception/InternalException.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.impl.exception; +package fr.inria.corese.core.next.data.impl.exception; -import fr.inria.corese.core.next.api.base.exception.CoreseException; +import fr.inria.corese.core.next.data.api.base.exception.CoreseException; /** * Used for exception related to the inner workings of the system. diff --git a/src/main/java/fr/inria/corese/core/next/impl/exception/ParsingErrorException.java b/src/main/java/fr/inria/corese/core/next/data/impl/exception/ParsingErrorException.java similarity index 88% rename from src/main/java/fr/inria/corese/core/next/impl/exception/ParsingErrorException.java rename to src/main/java/fr/inria/corese/core/next/data/impl/exception/ParsingErrorException.java index 806ab08e4..8f36b6ee1 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/exception/ParsingErrorException.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/exception/ParsingErrorException.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.impl.exception; +package fr.inria.corese.core.next.data.impl.exception; -import fr.inria.corese.core.next.api.base.exception.CoreseException; +import fr.inria.corese.core.next.data.api.base.exception.CoreseException; /** * Exception thrown when an error occurs during parsing diff --git a/src/main/java/fr/inria/corese/core/next/impl/exception/SerializationException.java b/src/main/java/fr/inria/corese/core/next/data/impl/exception/SerializationException.java similarity index 96% rename from src/main/java/fr/inria/corese/core/next/impl/exception/SerializationException.java rename to src/main/java/fr/inria/corese/core/next/data/impl/exception/SerializationException.java index 28bf2180d..12ab60fc3 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/exception/SerializationException.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/exception/SerializationException.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.impl.exception; +package fr.inria.corese.core.next.data.impl.exception; -import fr.inria.corese.core.next.api.base.exception.CoreseException; +import fr.inria.corese.core.next.data.api.base.exception.CoreseException; /** * Exception thrown during RDF serialization or deserialization failures. diff --git a/src/main/java/fr/inria/corese/core/next/impl/exception/SparqlException.java b/src/main/java/fr/inria/corese/core/next/data/impl/exception/SparqlException.java similarity index 100% rename from src/main/java/fr/inria/corese/core/next/impl/exception/SparqlException.java rename to src/main/java/fr/inria/corese/core/next/data/impl/exception/SparqlException.java diff --git a/src/main/java/fr/inria/corese/core/next/impl/exception/UnsupportedFileFormatException.java b/src/main/java/fr/inria/corese/core/next/data/impl/exception/UnsupportedFileFormatException.java similarity index 89% rename from src/main/java/fr/inria/corese/core/next/impl/exception/UnsupportedFileFormatException.java rename to src/main/java/fr/inria/corese/core/next/data/impl/exception/UnsupportedFileFormatException.java index b14326c65..14d5c4dd9 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/exception/UnsupportedFileFormatException.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/exception/UnsupportedFileFormatException.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.impl.exception; +package fr.inria.corese.core.next.data.impl.exception; -import fr.inria.corese.core.next.api.base.exception.CoreseException; +import fr.inria.corese.core.next.data.api.base.exception.CoreseException; /** * Exception thrown when a file format is not supported. diff --git a/src/main/java/fr/inria/corese/core/next/impl/inmemory/InMemoryModel.java b/src/main/java/fr/inria/corese/core/next/data/impl/inmemory/InMemoryModel.java similarity index 86% rename from src/main/java/fr/inria/corese/core/next/impl/inmemory/InMemoryModel.java rename to src/main/java/fr/inria/corese/core/next/data/impl/inmemory/InMemoryModel.java index c98fe16b8..d5e025c1d 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/inmemory/InMemoryModel.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/inmemory/InMemoryModel.java @@ -1,16 +1,16 @@ -package fr.inria.corese.core.next.impl.inmemory; +package fr.inria.corese.core.next.data.impl.inmemory; import java.util.Iterator; import java.util.Optional; import java.util.Set; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Namespace; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.api.Value; -import fr.inria.corese.core.next.api.base.model.AbstractModel; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Namespace; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.api.Value; +import fr.inria.corese.core.next.data.api.base.model.AbstractModel; /** * InMemoryModel is a model that stores RDF data in memory. diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/common/IOConstants.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/common/IOConstants.java similarity index 96% rename from src/main/java/fr/inria/corese/core/next/impl/io/common/IOConstants.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/common/IOConstants.java index 2e97653fc..65aab6384 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/common/IOConstants.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/common/IOConstants.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.common; +package fr.inria.corese.core.next.data.impl.io.common; import fr.inria.corese.core.util.Property; diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/common/JSONLDOptions.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/common/JSONLDOptions.java similarity index 96% rename from src/main/java/fr/inria/corese/core/next/impl/io/common/JSONLDOptions.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/common/JSONLDOptions.java index bf7f88443..cd4beb3e8 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/common/JSONLDOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/common/JSONLDOptions.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.common; +package fr.inria.corese.core.next.data.impl.io.common; import java.net.URI; import java.time.Duration; @@ -6,10 +6,10 @@ import com.apicatalog.jsonld.JsonLdOptions; import com.apicatalog.jsonld.JsonLdVersion; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.base.io.AbstractIOOptions; -import fr.inria.corese.core.next.api.io.common.BaseIRIOptions; -import fr.inria.corese.core.next.impl.io.parser.util.ParserConstants; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.base.io.AbstractIOOptions; +import fr.inria.corese.core.next.data.io.common.BaseIRIOptions; +import fr.inria.corese.core.next.data.impl.io.parser.util.ParserConstants; /** * Wrapper around the JsonLdOptions class for the Titanium JSONLD parser and diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/ParserFactory.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/ParserFactory.java similarity index 77% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/ParserFactory.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/ParserFactory.java index 0293f1ff0..1c32a554e 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/ParserFactory.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/ParserFactory.java @@ -1,18 +1,18 @@ -package fr.inria.corese.core.next.impl.io.parser; +package fr.inria.corese.core.next.data.impl.io.parser; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.base.io.parser.AbstractRDFParserFactory; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.api.io.parser.RDFParser; -import fr.inria.corese.core.next.impl.io.parser.jsonld.JSONLDParser; -import fr.inria.corese.core.next.impl.io.parser.nquads.NQuadsParser; -import fr.inria.corese.core.next.impl.io.parser.ntriples.NTriplesParser; -import fr.inria.corese.core.next.impl.io.parser.rdfa.RDFaParser; -import fr.inria.corese.core.next.impl.io.parser.rdfxml.RDFXMLParser; -import fr.inria.corese.core.next.impl.io.parser.turtle.TurtleParser; -import fr.inria.corese.core.next.impl.io.parser.trig.TriGParser; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.api.base.io.parser.AbstractRDFParserFactory; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.io.parser.RDFParser; +import fr.inria.corese.core.next.data.impl.io.parser.jsonld.JSONLDParser; +import fr.inria.corese.core.next.data.impl.io.parser.nquads.NQuadsParser; +import fr.inria.corese.core.next.data.impl.io.parser.ntriples.NTriplesParser; +import fr.inria.corese.core.next.data.impl.io.parser.rdfa.RDFaParser; +import fr.inria.corese.core.next.data.impl.io.parser.rdfxml.RDFXMLParser; +import fr.inria.corese.core.next.data.impl.io.parser.turtle.TurtleParser; +import fr.inria.corese.core.next.data.impl.io.parser.trig.TriGParser; /** * Factory class for creating RDF parsers. Generates according to the RDFFormat provided. diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/common/AbstractNTriplesNQuadsListener.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/common/AbstractNTriplesNQuadsListener.java similarity index 94% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/common/AbstractNTriplesNQuadsListener.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/common/AbstractNTriplesNQuadsListener.java index cea7290ee..63f3719d3 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/common/AbstractNTriplesNQuadsListener.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/common/AbstractNTriplesNQuadsListener.java @@ -1,12 +1,12 @@ -package fr.inria.corese.core.next.impl.io.parser.common; +package fr.inria.corese.core.next.data.impl.io.parser.common; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Literal; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.impl.exception.ParsingErrorException; -import fr.inria.corese.core.next.impl.io.parser.util.ParserConstants; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Literal; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.impl.exception.ParsingErrorException; +import fr.inria.corese.core.next.data.impl.io.parser.util.ParserConstants; /** * Base class for N-Triples/N-Quads parsers providing common escape handling diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/common/AbstractTurtleTriGListener.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/common/AbstractTurtleTriGListener.java similarity index 97% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/common/AbstractTurtleTriGListener.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/common/AbstractTurtleTriGListener.java index f3e9da782..9e7d120e2 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/common/AbstractTurtleTriGListener.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/common/AbstractTurtleTriGListener.java @@ -1,12 +1,12 @@ -package fr.inria.corese.core.next.impl.io.parser.common; - -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.impl.common.literal.XSD; -import fr.inria.corese.core.next.impl.common.prefix.PrefixHandler; -import fr.inria.corese.core.next.impl.common.util.IRIUtils; -import fr.inria.corese.core.next.impl.common.vocabulary.RDF; -import fr.inria.corese.core.next.impl.exception.ParsingErrorException; -import fr.inria.corese.core.next.impl.io.parser.util.ParserConstants; +package fr.inria.corese.core.next.data.impl.io.parser.common; + +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.common.prefix.PrefixHandler; +import fr.inria.corese.core.next.data.impl.common.util.IRIUtils; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF; +import fr.inria.corese.core.next.data.impl.exception.ParsingErrorException; +import fr.inria.corese.core.next.data.impl.io.parser.util.ParserConstants; import java.net.URI; import java.net.URISyntaxException; diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/jsonld/JSONLDParser.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/jsonld/JSONLDParser.java similarity index 90% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/jsonld/JSONLDParser.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/jsonld/JSONLDParser.java index 527f6e54c..50bef9c80 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/jsonld/JSONLDParser.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/jsonld/JSONLDParser.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.parser.jsonld; +package fr.inria.corese.core.next.data.impl.io.parser.jsonld; import com.apicatalog.jsonld.JsonLdError; import com.apicatalog.jsonld.JsonLdOptions; @@ -7,15 +7,16 @@ import com.apicatalog.jsonld.processor.ToRdfProcessor; import com.apicatalog.rdf.api.RdfConsumerException; import com.apicatalog.rdf.api.RdfQuadConsumer; -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.base.io.parser.AbstractRDFParser; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.impl.common.literal.XSD; -import fr.inria.corese.core.next.impl.common.prefix.PrefixHandler; -import fr.inria.corese.core.next.impl.common.util.IRIUtils; -import fr.inria.corese.core.next.impl.exception.ParsingErrorException; -import fr.inria.corese.core.next.impl.io.common.JSONLDOptions; +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.api.base.io.parser.AbstractRDFParser; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.common.prefix.PrefixHandler; +import fr.inria.corese.core.next.data.impl.common.util.IRIUtils; +import fr.inria.corese.core.next.data.impl.exception.ParsingErrorException; +import fr.inria.corese.core.next.data.impl.io.common.JSONLDOptions; +import fr.inria.corese.core.next.data.impl.io.parser.ParserFactory; import java.io.InputStream; import java.io.Reader; @@ -24,7 +25,7 @@ /** * Parser for JSON-LD RDF files. This parser is based on the Titanium JSON-LD library. * - * @see fr.inria.corese.core.next.impl.io.parser.ParserFactory + * @see ParserFactory * @see Titanium JSON-LD */ public class JSONLDParser extends AbstractRDFParser { diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsListener.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/nquads/NQuadsListener.java similarity index 91% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsListener.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/nquads/NQuadsListener.java index eb147add8..61cffd8f1 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsListener.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/nquads/NQuadsListener.java @@ -1,9 +1,9 @@ -package fr.inria.corese.core.next.impl.io.parser.nquads; +package fr.inria.corese.core.next.data.impl.io.parser.nquads; -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.impl.exception.ParsingErrorException; -import fr.inria.corese.core.next.impl.io.parser.common.AbstractNTriplesNQuadsListener; +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.impl.exception.ParsingErrorException; +import fr.inria.corese.core.next.data.impl.io.parser.common.AbstractNTriplesNQuadsListener; import fr.inria.corese.core.next.impl.parser.antlr.NQuadsBaseListener; import fr.inria.corese.core.next.impl.parser.antlr.NQuadsParser; @@ -76,7 +76,7 @@ public void exitStatement(NQuadsParser.StatementContext ctx) { /** * Extracts a resource (IRI or Blank Node) from the subject context. */ - protected Resource extractSubject(NQuadsParser.SubjectContext ctx) { + public Resource extractSubject(NQuadsParser.SubjectContext ctx) { if (ctx.IRIREF() != null) { String iri = abstractNTriplesQuadsListener.unescapeUri(stripAngles(ctx.IRIREF().getText())); return factory.createIRI(iri); @@ -92,7 +92,7 @@ protected Resource extractSubject(NQuadsParser.SubjectContext ctx) { /** * Extracts a predicate (IRI) from the predicate context. */ - protected IRI extractPredicate(NQuadsParser.PredicateContext ctx) { + public IRI extractPredicate(NQuadsParser.PredicateContext ctx) { if (ctx.IRIREF() != null) { String iri = abstractNTriplesQuadsListener.unescapeUri(stripAngles(ctx.IRIREF().getText())); return factory.createIRI(iri); @@ -103,7 +103,7 @@ protected IRI extractPredicate(NQuadsParser.PredicateContext ctx) { /** * Extracts a value (IRI, Blank Node, or Literal) from the object context. */ - protected Value extractObject(NQuadsParser.ObjectContext ctx) { + public Value extractObject(NQuadsParser.ObjectContext ctx) { if (ctx.IRIREF() != null) { String iri = abstractNTriplesQuadsListener.unescapeUri(stripAngles(ctx.IRIREF().getText())); return factory.createIRI(iri); @@ -122,7 +122,7 @@ protected Value extractObject(NQuadsParser.ObjectContext ctx) { /** * Extracts a graph (IRI or Blank Node) from the graph label context. */ - protected Resource extractGraph(NQuadsParser.GraphLabelContext ctx) { + public Resource extractGraph(NQuadsParser.GraphLabelContext ctx) { if (ctx.IRIREF() != null) { String iri = abstractNTriplesQuadsListener.unescapeUri(stripAngles(ctx.IRIREF().getText())); return factory.createIRI(iri); @@ -192,7 +192,7 @@ protected void validateBlankNodeLabel(String label) { * @deprecated Use helper.unescapeLiteral instead */ @Deprecated - protected String unescapeLiteral(String literalText) { + public String unescapeLiteral(String literalText) { return abstractNTriplesQuadsListener.unescapeLiteral(literalText); } diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsParser.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/nquads/NQuadsParser.java similarity index 92% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsParser.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/nquads/NQuadsParser.java index bb202d062..317650c66 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsParser.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/nquads/NQuadsParser.java @@ -1,11 +1,11 @@ -package fr.inria.corese.core.next.impl.io.parser.nquads; - -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.base.io.parser.AbstractRDFParser; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.impl.exception.ParsingErrorException; +package fr.inria.corese.core.next.data.impl.io.parser.nquads; + +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.api.base.io.parser.AbstractRDFParser; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.impl.exception.ParsingErrorException; import fr.inria.corese.core.next.impl.parser.antlr.NQuadsLexer; import org.antlr.v4.runtime.*; import org.antlr.v4.runtime.tree.ParseTree; diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsParserOptions.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/nquads/NQuadsParserOptions.java similarity index 74% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsParserOptions.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/nquads/NQuadsParserOptions.java index a83b657aa..7ddd2e780 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsParserOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/nquads/NQuadsParserOptions.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.impl.io.parser.nquads; +package fr.inria.corese.core.next.data.impl.io.parser.nquads; -import fr.inria.corese.core.next.api.base.io.AbstractIOOptions; +import fr.inria.corese.core.next.data.api.base.io.AbstractIOOptions; /** * Options used to configure a NQuads parser diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesListener.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/ntriples/NTriplesListener.java similarity index 86% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesListener.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/ntriples/NTriplesListener.java index e45277a63..62d73981e 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesListener.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/ntriples/NTriplesListener.java @@ -1,14 +1,14 @@ -package fr.inria.corese.core.next.impl.io.parser.ntriples; - -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Literal; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Value; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.impl.exception.ParsingErrorException; -import fr.inria.corese.core.next.impl.io.parser.common.AbstractNTriplesNQuadsListener; +package fr.inria.corese.core.next.data.impl.io.parser.ntriples; + +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Literal; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Value; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.impl.exception.ParsingErrorException; +import fr.inria.corese.core.next.data.impl.io.parser.common.AbstractNTriplesNQuadsListener; import fr.inria.corese.core.next.impl.parser.antlr.NTriplesBaseListener; import fr.inria.corese.core.next.impl.parser.antlr.NTriplesParser; @@ -56,7 +56,7 @@ public void exitTriple(NTriplesParser.TripleContext ctx) { /** * Extracts a resource (IRI or Blank Node) from the subject context. */ - protected Resource extractSubject(NTriplesParser.SubjectContext ctx) { + public Resource extractSubject(NTriplesParser.SubjectContext ctx) { if (ctx.IRIREF() != null) { String iri = abstractNTriplesQuadsListener.unescapeUri(abstractNTriplesQuadsListener.stripAngles(ctx.IRIREF().getText())); return factory.createIRI(iri); @@ -72,7 +72,7 @@ protected Resource extractSubject(NTriplesParser.SubjectContext ctx) { /** * Extracts a predicate (IRI) from the predicate context. */ - protected IRI extractPredicate(NTriplesParser.PredicateContext ctx) { + public IRI extractPredicate(NTriplesParser.PredicateContext ctx) { if (ctx.IRIREF() != null) { String iri = abstractNTriplesQuadsListener.unescapeUri(abstractNTriplesQuadsListener.stripAngles(ctx.IRIREF().getText())); return factory.createIRI(iri); @@ -83,7 +83,7 @@ protected IRI extractPredicate(NTriplesParser.PredicateContext ctx) { /** * Extracts a value (IRI, Blank Node, or Literal) from the object context. */ - protected Value extractObject(NTriplesParser.ObjectContext ctx) { + public Value extractObject(NTriplesParser.ObjectContext ctx) { if (ctx.IRIREF() != null) { String iri = abstractNTriplesQuadsListener.unescapeUri(abstractNTriplesQuadsListener.stripAngles(ctx.IRIREF().getText())); return factory.createIRI(iri); @@ -140,7 +140,7 @@ protected void validateBlankNodeLabel(String label) throws ParsingErrorException * @deprecated Use helper.unescapeLiteral instead */ @Deprecated - protected String unescapeLiteral(String literalText) { + public String unescapeLiteral(String literalText) { return abstractNTriplesQuadsListener.unescapeLiteral(literalText); } diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesParser.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/ntriples/NTriplesParser.java similarity index 92% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesParser.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/ntriples/NTriplesParser.java index e90895fd9..a11c11f5a 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesParser.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/ntriples/NTriplesParser.java @@ -1,11 +1,11 @@ -package fr.inria.corese.core.next.impl.io.parser.ntriples; - -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.base.io.parser.AbstractRDFParser; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.impl.exception.ParsingErrorException; +package fr.inria.corese.core.next.data.impl.io.parser.ntriples; + +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.api.base.io.parser.AbstractRDFParser; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.impl.exception.ParsingErrorException; import fr.inria.corese.core.next.impl.parser.antlr.NTriplesLexer; import org.antlr.v4.runtime.CharStream; import org.antlr.v4.runtime.CharStreams; diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesParserOptions.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/ntriples/NTriplesParserOptions.java similarity index 74% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesParserOptions.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/ntriples/NTriplesParserOptions.java index 8fd03dd38..f9b605ab6 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesParserOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/ntriples/NTriplesParserOptions.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.impl.io.parser.ntriples; +package fr.inria.corese.core.next.data.impl.io.parser.ntriples; -import fr.inria.corese.core.next.api.base.io.AbstractIOOptions; +import fr.inria.corese.core.next.data.api.base.io.AbstractIOOptions; /** * Options used to configure a NTriples parser diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfa/RDFaParser.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/RDFaParser.java similarity index 98% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfa/RDFaParser.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/RDFaParser.java index 03cd432e3..3b1a6093d 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfa/RDFaParser.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/RDFaParser.java @@ -1,15 +1,15 @@ -package fr.inria.corese.core.next.impl.io.parser.rdfa; - -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.base.io.parser.AbstractRDFParser; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.api.io.common.BaseIRIOptions; -import fr.inria.corese.core.next.impl.common.util.IRIUtils; -import fr.inria.corese.core.next.impl.common.vocabulary.RDF; -import fr.inria.corese.core.next.impl.exception.ParsingErrorException; -import fr.inria.corese.core.next.impl.io.parser.rdfa.model.*; -import fr.inria.corese.core.next.impl.io.serialization.util.SerializationConstants; +package fr.inria.corese.core.next.data.impl.io.parser.rdfa; + +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.api.base.io.parser.AbstractRDFParser; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.io.common.BaseIRIOptions; +import fr.inria.corese.core.next.data.impl.common.util.IRIUtils; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF; +import fr.inria.corese.core.next.data.impl.exception.ParsingErrorException; +import fr.inria.corese.core.next.data.impl.io.parser.rdfa.model.*; +import fr.inria.corese.core.next.data.impl.io.serialization.util.SerializationConstants; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.xml.sax.Attributes; diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfa/RDFaParserOptions.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/RDFaParserOptions.java similarity index 77% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfa/RDFaParserOptions.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/RDFaParserOptions.java index e10a1cc4c..763270f0c 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfa/RDFaParserOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/RDFaParserOptions.java @@ -1,9 +1,8 @@ -package fr.inria.corese.core.next.impl.io.parser.rdfa; +package fr.inria.corese.core.next.data.impl.io.parser.rdfa; -import fr.inria.corese.core.next.api.base.io.AbstractIOOptions; -import fr.inria.corese.core.next.api.io.common.BaseIRIOptions; -import fr.inria.corese.core.next.impl.io.common.IOConstants; -import fr.inria.corese.core.next.impl.io.parser.util.ParserConstants; +import fr.inria.corese.core.next.data.api.base.io.AbstractIOOptions; +import fr.inria.corese.core.next.data.io.common.BaseIRIOptions; +import fr.inria.corese.core.next.data.impl.io.common.IOConstants; /** * Configuration class for the parsing of RDFa HTML documents diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfa/model/RDFaAttributes.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/model/RDFaAttributes.java similarity index 88% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfa/model/RDFaAttributes.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/model/RDFaAttributes.java index 265712e3d..293fd5e28 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfa/model/RDFaAttributes.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/model/RDFaAttributes.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.parser.rdfa.model; +package fr.inria.corese.core.next.data.impl.io.parser.rdfa.model; public enum RDFaAttributes { ABOUT("about"), diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfa/model/RDFaEvaluationContext.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/model/RDFaEvaluationContext.java similarity index 96% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfa/model/RDFaEvaluationContext.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/model/RDFaEvaluationContext.java index 8071de201..135e5a1bc 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfa/model/RDFaEvaluationContext.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/model/RDFaEvaluationContext.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.impl.io.parser.rdfa.model; +package fr.inria.corese.core.next.data.impl.io.parser.rdfa.model; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Value; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Value; import java.util.*; diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfa/model/RDFaIncompleteStatement.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/model/RDFaIncompleteStatement.java similarity index 94% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfa/model/RDFaIncompleteStatement.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/model/RDFaIncompleteStatement.java index d023a6e7d..1b91d0853 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfa/model/RDFaIncompleteStatement.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/model/RDFaIncompleteStatement.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.impl.io.parser.rdfa.model; +package fr.inria.corese.core.next.data.impl.io.parser.rdfa.model; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Value; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Value; /** * This utility class represents triples in the process of creation during the chaining of element in an RDFa document. diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfa/model/RDFaInitialPrefixes.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/model/RDFaInitialPrefixes.java similarity index 80% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfa/model/RDFaInitialPrefixes.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/model/RDFaInitialPrefixes.java index 64b81e987..c456cbac7 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfa/model/RDFaInitialPrefixes.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/model/RDFaInitialPrefixes.java @@ -1,6 +1,7 @@ -package fr.inria.corese.core.next.impl.io.parser.rdfa.model; +package fr.inria.corese.core.next.data.impl.io.parser.rdfa.model; -import fr.inria.corese.core.next.api.Namespace; +import fr.inria.corese.core.next.data.api.Namespace; +import fr.inria.corese.core.next.data.impl.common.vocabulary.*; /** * https://www.w3.org/2011/rdfa-context/rdfa-1.1 sets a list of predefined prefixes for RDFa contexts. @@ -28,7 +29,7 @@ public enum RDFaInitialPrefixes implements Namespace { // duv "https://www.w3.org/ns/duv#" DUV("duv", "https://www.w3.org/ns/duv#"), // foaf "http://xmlns.com/foaf/0.1/" - FOAF(fr.inria.corese.core.next.impl.common.vocabulary.FOAF.getVocabularyPreferredPrefix(), fr.inria.corese.core.next.impl.common.vocabulary.FOAF.getVocabularyNamespace()), + FOAF(fr.inria.corese.core.next.data.impl.common.vocabulary.FOAF.getVocabularyPreferredPrefix(), fr.inria.corese.core.next.data.impl.common.vocabulary.FOAF.getVocabularyNamespace()), // gr "http://purl.org/goodrelations/v1#" GR("gr", "http://purl.org/goodrelations/v1#"), // grddl "http://www.w3.org/2003/g/data-view#" @@ -50,17 +51,17 @@ public enum RDFaInitialPrefixes implements Namespace { // org "http://www.w3.org/ns/org#" ORG("org", "http://www.w3.org/ns/org#"), // owl "http://www.w3.org/2002/07/owl#" - OWL(fr.inria.corese.core.next.impl.common.vocabulary.OWL.getVocabularyPreferredPrefix(), fr.inria.corese.core.next.impl.common.vocabulary.OWL.getVocabularyNamespace()), + OWL(fr.inria.corese.core.next.data.impl.common.vocabulary.OWL.getVocabularyPreferredPrefix(), fr.inria.corese.core.next.data.impl.common.vocabulary.OWL.getVocabularyNamespace()), // prov "http://www.w3.org/ns/prov#" PROV("prov", "http://www.w3.org/ns/prov#"), // qb "http://purl.org/linked-data/cube#" QB("qb", "http://purl.org/linked-data/cube#"), // rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#" - RDF(fr.inria.corese.core.next.impl.common.vocabulary.RDF.getVocabularyPreferredPrefix(), fr.inria.corese.core.next.impl.common.vocabulary.RDF.getVocabularyNamespace()), + RDF(fr.inria.corese.core.next.data.impl.common.vocabulary.RDF.getVocabularyPreferredPrefix(), fr.inria.corese.core.next.data.impl.common.vocabulary.RDF.getVocabularyNamespace()), // rdfa "http://www.w3.org/ns/rdfa#" - RDFA(fr.inria.corese.core.next.impl.common.vocabulary.RDFa.getVocabularyPreferredPrefix(), fr.inria.corese.core.next.impl.common.vocabulary.RDFa.getVocabularyNamespace()), + RDFA(RDFa.getVocabularyPreferredPrefix(), RDFa.getVocabularyNamespace()), // rdfs "http://www.w3.org/2000/01/rdf-schema#" - RDFS(fr.inria.corese.core.next.impl.common.vocabulary.RDFS.getVocabularyPreferredPrefix(), fr.inria.corese.core.next.impl.common.vocabulary.RDFS.getVocabularyNamespace()), + RDFS(fr.inria.corese.core.next.data.impl.common.vocabulary.RDFS.getVocabularyPreferredPrefix(), fr.inria.corese.core.next.data.impl.common.vocabulary.RDFS.getVocabularyNamespace()), // rev "http://purl.org/stuff/rev#" REV("rev", "http://purl.org/stuff/rev#"), // rif "http://www.w3.org/2007/rif#" @@ -98,7 +99,7 @@ public enum RDFaInitialPrefixes implements Namespace { // xml "http://www.w3.org/XML/1998/namespace" XML("xml", "http://www.w3.org/XML/1998/namespace"), // xsd "http://www.w3.org/2001/XMLSchema#" - XSD(fr.inria.corese.core.next.impl.common.vocabulary.XSD.getVocabularyPreferredPrefix(), fr.inria.corese.core.next.impl.common.vocabulary.XSD.getVocabularyNamespace()), + XSD(fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.getVocabularyPreferredPrefix(), fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.getVocabularyNamespace()), ; private final String prefix; diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfa/model/RDFaProcessingContext.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/model/RDFaProcessingContext.java similarity index 98% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfa/model/RDFaProcessingContext.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/model/RDFaProcessingContext.java index 9fe7801bb..904c2e9c3 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfa/model/RDFaProcessingContext.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/model/RDFaProcessingContext.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.impl.io.parser.rdfa.model; +package fr.inria.corese.core.next.data.impl.io.parser.rdfa.model; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Value; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Value; import org.xml.sax.Attributes; import java.util.HashMap; diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLParser.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLParser.java similarity index 97% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLParser.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLParser.java index d1572c672..8cd65edbd 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLParser.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLParser.java @@ -1,15 +1,15 @@ -package fr.inria.corese.core.next.impl.io.parser.rdfxml; - -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.base.io.parser.AbstractRDFParser; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.impl.common.vocabulary.RDF; -import fr.inria.corese.core.next.impl.exception.ParsingErrorException; -import fr.inria.corese.core.next.impl.io.parser.rdfxml.context.RDFXMLContext; +package fr.inria.corese.core.next.data.impl.io.parser.rdfxml; + +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.api.base.io.parser.AbstractRDFParser; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF; +import fr.inria.corese.core.next.data.impl.exception.ParsingErrorException; +import fr.inria.corese.core.next.data.impl.io.parser.rdfxml.context.RDFXMLContext; import org.xml.sax.Attributes; import org.xml.sax.InputSource; import org.xml.sax.SAXException; @@ -24,7 +24,7 @@ import java.nio.charset.StandardCharsets; import java.util.*; -import static fr.inria.corese.core.next.impl.io.parser.rdfxml.RDFXMLUtils.*; +import static fr.inria.corese.core.next.data.impl.io.parser.rdfxml.RDFXMLUtils.*; /** * SAX-based RDF/XML parser implementation. diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLParserOptions.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLParserOptions.java similarity index 79% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLParserOptions.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLParserOptions.java index bfc4cd8f7..ee57b5909 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLParserOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLParserOptions.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.impl.io.parser.rdfxml; +package fr.inria.corese.core.next.data.impl.io.parser.rdfxml; -import fr.inria.corese.core.next.api.base.io.AbstractIOOptions; -import fr.inria.corese.core.next.api.io.common.BaseIRIOptions; -import fr.inria.corese.core.next.impl.io.parser.util.ParserConstants; +import fr.inria.corese.core.next.data.api.base.io.AbstractIOOptions; +import fr.inria.corese.core.next.data.io.common.BaseIRIOptions; +import fr.inria.corese.core.next.data.impl.io.parser.util.ParserConstants; /** * Configuration class for the parsing of RDF/XML documents diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLStatementEmitter.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLStatementEmitter.java similarity index 94% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLStatementEmitter.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLStatementEmitter.java index 6535e789b..a82b0e8b8 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLStatementEmitter.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLStatementEmitter.java @@ -1,16 +1,16 @@ -package fr.inria.corese.core.next.impl.io.parser.rdfxml; +package fr.inria.corese.core.next.data.impl.io.parser.rdfxml; -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.impl.common.literal.XSD; -import fr.inria.corese.core.next.impl.common.vocabulary.RDF; -import fr.inria.corese.core.next.impl.exception.ParsingErrorException; +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF; +import fr.inria.corese.core.next.data.impl.exception.ParsingErrorException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.xml.sax.Attributes; import java.util.Optional; -import static fr.inria.corese.core.next.impl.io.parser.rdfxml.RDFXMLUtils.*; +import static fr.inria.corese.core.next.data.impl.io.parser.rdfxml.RDFXMLUtils.*; /** * Emits RDF statements from parsed RDF/XML constructs using a given RDF Model diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLUtils.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLUtils.java similarity index 96% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLUtils.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLUtils.java index 0f386ceee..1d855e0ad 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLUtils.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLUtils.java @@ -1,13 +1,13 @@ -package fr.inria.corese.core.next.impl.io.parser.rdfxml; - -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.impl.common.literal.XSD; -import fr.inria.corese.core.next.impl.common.vocabulary.RDF; -import fr.inria.corese.core.next.impl.exception.IncorrectFormatException; -import fr.inria.corese.core.next.impl.exception.ParsingErrorException; -import fr.inria.corese.core.next.impl.io.common.IOConstants; +package fr.inria.corese.core.next.data.impl.io.parser.rdfxml; + +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF; +import fr.inria.corese.core.next.data.impl.exception.IncorrectFormatException; +import fr.inria.corese.core.next.data.impl.exception.ParsingErrorException; +import fr.inria.corese.core.next.data.impl.io.common.IOConstants; import org.xml.sax.Attributes; import java.util.List; diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/context/RDFXMLContext.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/context/RDFXMLContext.java similarity index 96% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/context/RDFXMLContext.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/context/RDFXMLContext.java index 4807977d3..f33a3826d 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/context/RDFXMLContext.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/context/RDFXMLContext.java @@ -1,6 +1,7 @@ -package fr.inria.corese.core.next.impl.io.parser.rdfxml.context; +package fr.inria.corese.core.next.data.impl.io.parser.rdfxml.context; + +import fr.inria.corese.core.next.data.api.*; -import fr.inria.corese.core.next.api.*; import java.util.ArrayDeque; import java.util.ArrayList; import java.util.Deque; diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGListerner.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/trig/TriGListerner.java similarity index 97% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGListerner.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/trig/TriGListerner.java index 505c9f311..54deec646 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGListerner.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/trig/TriGListerner.java @@ -1,12 +1,12 @@ -package fr.inria.corese.core.next.impl.io.parser.trig; - -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.api.io.common.BaseIRIOptions; -import fr.inria.corese.core.next.impl.common.vocabulary.RDF; -import fr.inria.corese.core.next.impl.exception.ParsingErrorException; -import fr.inria.corese.core.next.impl.io.parser.common.AbstractTurtleTriGListener; -import fr.inria.corese.core.next.impl.io.parser.util.ParserConstants; +package fr.inria.corese.core.next.data.impl.io.parser.trig; + +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.io.common.BaseIRIOptions; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF; +import fr.inria.corese.core.next.data.impl.exception.ParsingErrorException; +import fr.inria.corese.core.next.data.impl.io.parser.common.AbstractTurtleTriGListener; +import fr.inria.corese.core.next.data.impl.io.parser.util.ParserConstants; import fr.inria.corese.core.next.impl.parser.antlr.TriGBaseListener; import fr.inria.corese.core.next.impl.parser.antlr.TriGParser; diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGParser.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/trig/TriGParser.java similarity index 93% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGParser.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/trig/TriGParser.java index e813b1e0f..2aa3bf7df 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGParser.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/trig/TriGParser.java @@ -1,11 +1,11 @@ -package fr.inria.corese.core.next.impl.io.parser.trig; - -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.base.io.parser.AbstractRDFParser; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.impl.exception.ParsingErrorException; +package fr.inria.corese.core.next.data.impl.io.parser.trig; + +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.api.base.io.parser.AbstractRDFParser; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.impl.exception.ParsingErrorException; import fr.inria.corese.core.next.impl.parser.antlr.TriGLexer; import org.antlr.v4.runtime.*; import org.antlr.v4.runtime.tree.ParseTree; diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGParserOptions.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/trig/TriGParserOptions.java similarity index 79% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGParserOptions.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/trig/TriGParserOptions.java index f43dbff4b..4e5b9f4c9 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGParserOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/trig/TriGParserOptions.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.impl.io.parser.trig; +package fr.inria.corese.core.next.data.impl.io.parser.trig; -import fr.inria.corese.core.next.api.base.io.AbstractIOOptions; -import fr.inria.corese.core.next.api.io.common.BaseIRIOptions; -import fr.inria.corese.core.next.impl.io.parser.util.ParserConstants; +import fr.inria.corese.core.next.data.api.base.io.AbstractIOOptions; +import fr.inria.corese.core.next.data.io.common.BaseIRIOptions; +import fr.inria.corese.core.next.data.impl.io.parser.util.ParserConstants; /** * Configuration class for the parsing of TriG documents diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleListener.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/turtle/TurtleListener.java similarity index 96% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleListener.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/turtle/TurtleListener.java index 95365e16c..283b886f1 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleListener.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/turtle/TurtleListener.java @@ -1,12 +1,12 @@ -package fr.inria.corese.core.next.impl.io.parser.turtle; - -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.api.io.common.BaseIRIOptions; -import fr.inria.corese.core.next.impl.common.vocabulary.RDF; -import fr.inria.corese.core.next.impl.exception.ParsingErrorException; -import fr.inria.corese.core.next.impl.io.parser.common.AbstractTurtleTriGListener; -import fr.inria.corese.core.next.impl.io.parser.util.ParserConstants; +package fr.inria.corese.core.next.data.impl.io.parser.turtle; + +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.io.common.BaseIRIOptions; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF; +import fr.inria.corese.core.next.data.impl.exception.ParsingErrorException; +import fr.inria.corese.core.next.data.impl.io.parser.common.AbstractTurtleTriGListener; +import fr.inria.corese.core.next.data.impl.io.parser.util.ParserConstants; import fr.inria.corese.core.next.impl.parser.antlr.TurtleBaseListener; import fr.inria.corese.core.next.impl.parser.antlr.TurtleParser; diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleParser.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/turtle/TurtleParser.java similarity index 93% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleParser.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/turtle/TurtleParser.java index b6b152e61..d97b86e5b 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleParser.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/turtle/TurtleParser.java @@ -1,11 +1,11 @@ -package fr.inria.corese.core.next.impl.io.parser.turtle; - -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.base.io.parser.AbstractRDFParser; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.impl.exception.ParsingErrorException; +package fr.inria.corese.core.next.data.impl.io.parser.turtle; + +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.api.base.io.parser.AbstractRDFParser; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.impl.exception.ParsingErrorException; import fr.inria.corese.core.next.impl.parser.antlr.TurtleLexer; import org.antlr.v4.runtime.*; import org.antlr.v4.runtime.tree.ParseTree; diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleParserOptions.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/turtle/TurtleParserOptions.java similarity index 79% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleParserOptions.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/turtle/TurtleParserOptions.java index 7b013d589..149f61787 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleParserOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/turtle/TurtleParserOptions.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.impl.io.parser.turtle; +package fr.inria.corese.core.next.data.impl.io.parser.turtle; -import fr.inria.corese.core.next.api.base.io.AbstractIOOptions; -import fr.inria.corese.core.next.api.io.common.BaseIRIOptions; -import fr.inria.corese.core.next.impl.io.parser.util.ParserConstants; +import fr.inria.corese.core.next.data.api.base.io.AbstractIOOptions; +import fr.inria.corese.core.next.data.io.common.BaseIRIOptions; +import fr.inria.corese.core.next.data.impl.io.parser.util.ParserConstants; /** * Configuration class for the parsing of Turtle documents diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/parser/util/ParserConstants.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/util/ParserConstants.java similarity index 91% rename from src/main/java/fr/inria/corese/core/next/impl/io/parser/util/ParserConstants.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/parser/util/ParserConstants.java index a60a53de8..6d191c86e 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/parser/util/ParserConstants.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/util/ParserConstants.java @@ -1,7 +1,6 @@ -package fr.inria.corese.core.next.impl.io.parser.util; +package fr.inria.corese.core.next.data.impl.io.parser.util; -import fr.inria.corese.core.next.impl.io.common.IOConstants; -import fr.inria.corese.core.util.Property; +import fr.inria.corese.core.next.data.impl.io.common.IOConstants; /** * A utility class containing constants for characters and keywords diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/SerializerFactory.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/SerializerFactory.java similarity index 82% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/SerializerFactory.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/SerializerFactory.java index 4468b8a74..eb12585e0 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/SerializerFactory.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/SerializerFactory.java @@ -1,21 +1,21 @@ -package fr.inria.corese.core.next.impl.io.serialization; - -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.api.io.serializer.RDFSerializer; -import fr.inria.corese.core.next.impl.exception.SerializationException; -import fr.inria.corese.core.next.impl.io.serialization.canonical.RDFC10Canonicalizer; -import fr.inria.corese.core.next.impl.io.serialization.canonical.RDFC10Serializer; -import fr.inria.corese.core.next.impl.io.serialization.canonical.RDFC10SerializerOptions; -import fr.inria.corese.core.next.impl.io.serialization.jsonld.JSONLDSerializer; -import fr.inria.corese.core.next.impl.io.serialization.nquads.NQuadsSerializer; -import fr.inria.corese.core.next.impl.io.serialization.ntriples.NTriplesSerializer; -import fr.inria.corese.core.next.impl.io.serialization.rdfxml.RDFXMLSerializer; -import fr.inria.corese.core.next.impl.io.serialization.trig.TriGSerializer; -import fr.inria.corese.core.next.impl.io.serialization.turtle.TurtleSerializer; -import fr.inria.corese.core.next.impl.temp.CoreseAdaptedValueFactory; +package fr.inria.corese.core.next.data.impl.io.serialization; + +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.io.serializer.RDFSerializer; +import fr.inria.corese.core.next.data.impl.exception.SerializationException; +import fr.inria.corese.core.next.data.impl.io.serialization.canonical.RDFC10Canonicalizer; +import fr.inria.corese.core.next.data.impl.io.serialization.canonical.RDFC10Serializer; +import fr.inria.corese.core.next.data.impl.io.serialization.canonical.RDFC10SerializerOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.jsonld.JSONLDSerializer; +import fr.inria.corese.core.next.data.impl.io.serialization.nquads.NQuadsSerializer; +import fr.inria.corese.core.next.data.impl.io.serialization.ntriples.NTriplesSerializer; +import fr.inria.corese.core.next.data.impl.io.serialization.rdfxml.RDFXMLSerializer; +import fr.inria.corese.core.next.data.impl.io.serialization.trig.TriGSerializer; +import fr.inria.corese.core.next.data.impl.io.serialization.turtle.TurtleSerializer; +import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; import java.util.Collections; import java.util.HashMap; @@ -25,20 +25,20 @@ import java.util.function.Function; /** - * Default implementation of {@link fr.inria.corese.core.next.api.io.serializer.SerializerFactory}. + * Default implementation of {@link fr.inria.corese.core.next.data.io.serializer.SerializerFactory}. * This factory is responsible for creating instances of {@link RDFSerializer} * based on the requested {@link RDFFormat}. It uses a registry pattern * to map each format to its corresponding serializer constructor, * providing a flexible and extensible way to manage serializer instances. * *

- * It adapts the generic {@link fr.inria.corese.core.next.api.io.IOOptions} provided to the specific + * It adapts the generic {@link IOOptions} provided to the specific * configuration type expected by each serializer in the hierarchy, with a * fallback * to default configurations if an incompatible type is provided. *

*/ -public class SerializerFactory implements fr.inria.corese.core.next.api.io.serializer.SerializerFactory { +public class SerializerFactory implements fr.inria.corese.core.next.data.io.serializer.SerializerFactory { private final Map> registry; private final Map> defaultRegistry; diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/base/AbstractGraphSerializer.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/base/AbstractGraphSerializer.java similarity index 98% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/base/AbstractGraphSerializer.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/base/AbstractGraphSerializer.java index a25b83e4f..a566b89e7 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/base/AbstractGraphSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/base/AbstractGraphSerializer.java @@ -1,15 +1,16 @@ -package fr.inria.corese.core.next.impl.io.serialization.base; - -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.api.io.common.BaseIRIOptions; -import fr.inria.corese.core.next.api.io.serializer.*; -import fr.inria.corese.core.next.impl.common.prefix.PrefixHandler; -import fr.inria.corese.core.next.impl.common.util.IRIUtils; -import fr.inria.corese.core.next.impl.common.vocabulary.*; -import fr.inria.corese.core.next.impl.exception.SerializationException; -import fr.inria.corese.core.next.impl.io.serialization.option.*; -import fr.inria.corese.core.next.impl.io.serialization.util.SerializationConstants; +package fr.inria.corese.core.next.data.impl.io.serialization.base; + +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.io.common.BaseIRIOptions; +import fr.inria.corese.core.next.data.io.serializer.*; +import fr.inria.corese.core.next.data.impl.common.prefix.PrefixHandler; +import fr.inria.corese.core.next.data.impl.common.util.IRIUtils; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF; +import fr.inria.corese.core.next.data.impl.common.vocabulary.XSD; +import fr.inria.corese.core.next.data.impl.exception.SerializationException; +import fr.inria.corese.core.next.data.impl.io.serialization.option.*; +import fr.inria.corese.core.next.data.impl.io.serialization.util.SerializationConstants; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/base/AbstractLineBasedSerializer.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/base/AbstractLineBasedSerializer.java similarity index 94% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/base/AbstractLineBasedSerializer.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/base/AbstractLineBasedSerializer.java index 6d9298ed9..bc6bcbaef 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/base/AbstractLineBasedSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/base/AbstractLineBasedSerializer.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.serialization.base; +package fr.inria.corese.core.next.data.impl.io.serialization.base; import java.io.BufferedWriter; import java.io.IOException; @@ -7,22 +7,22 @@ import java.util.Objects; import java.util.Set; -import fr.inria.corese.core.next.impl.common.literal.XSD; -import fr.inria.corese.core.next.impl.io.serialization.option.AbstractSerializerOptions; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.io.serialization.option.AbstractSerializerOptions; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Literal; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.api.Value; -import fr.inria.corese.core.next.api.io.serializer.RDFSerializer; -import fr.inria.corese.core.next.impl.common.literal.RDF; -import fr.inria.corese.core.next.impl.exception.SerializationException; -import fr.inria.corese.core.next.impl.io.serialization.option.LiteralDatatypePolicyEnum; -import fr.inria.corese.core.next.impl.io.serialization.util.SerializationConstants; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Literal; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.api.Value; +import fr.inria.corese.core.next.data.io.serializer.RDFSerializer; +import fr.inria.corese.core.next.data.impl.common.literal.RDF; +import fr.inria.corese.core.next.data.impl.exception.SerializationException; +import fr.inria.corese.core.next.data.impl.io.serialization.option.LiteralDatatypePolicyEnum; +import fr.inria.corese.core.next.data.impl.io.serialization.util.SerializationConstants; /** * Base class for line-based RDF serializers (N-Triples, N-Quads). diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/canonical/RDFC10Canonicalizer.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/canonical/RDFC10Canonicalizer.java similarity index 97% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/canonical/RDFC10Canonicalizer.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/canonical/RDFC10Canonicalizer.java index 0b32a5185..f41e59dd4 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/canonical/RDFC10Canonicalizer.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/canonical/RDFC10Canonicalizer.java @@ -1,11 +1,11 @@ -package fr.inria.corese.core.next.impl.io.serialization.canonical; - -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.impl.exception.SerializationException; -import fr.inria.corese.core.next.impl.io.serialization.util.SerializationConstants; -import fr.inria.corese.core.next.impl.io.serialization.util.StatementUtils; +package fr.inria.corese.core.next.data.impl.io.serialization.canonical; + +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.impl.exception.SerializationException; +import fr.inria.corese.core.next.data.impl.io.serialization.util.SerializationConstants; +import fr.inria.corese.core.next.data.impl.io.serialization.util.StatementUtils; import java.nio.charset.StandardCharsets; import java.security.MessageDigest; diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/canonical/RDFC10Serializer.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/canonical/RDFC10Serializer.java similarity index 86% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/canonical/RDFC10Serializer.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/canonical/RDFC10Serializer.java index 87c19afd5..464d00624 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/canonical/RDFC10Serializer.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/canonical/RDFC10Serializer.java @@ -1,12 +1,12 @@ -package fr.inria.corese.core.next.impl.io.serialization.canonical; +package fr.inria.corese.core.next.data.impl.io.serialization.canonical; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.impl.exception.SerializationException; -import fr.inria.corese.core.next.impl.io.serialization.base.AbstractLineBasedSerializer; -import fr.inria.corese.core.next.impl.io.serialization.util.SerializationConstants; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.impl.exception.SerializationException; +import fr.inria.corese.core.next.data.impl.io.serialization.base.AbstractLineBasedSerializer; +import fr.inria.corese.core.next.data.impl.io.serialization.util.SerializationConstants; import java.io.BufferedWriter; import java.io.IOException; @@ -77,7 +77,7 @@ public void write(Writer writer) { * @throws IOException if an I/O error occurs. */ @Override - protected void writeContext(Writer writer, Statement stmt) throws IOException { + public void writeContext(Writer writer, Statement stmt) throws IOException { Resource context = stmt.getContext(); if (context != null) { writer.write(SerializationConstants.SPACE); diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/canonical/RDFC10SerializerOptions.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/canonical/RDFC10SerializerOptions.java similarity index 95% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/canonical/RDFC10SerializerOptions.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/canonical/RDFC10SerializerOptions.java index 5615d78a4..efbaff7c1 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/canonical/RDFC10SerializerOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/canonical/RDFC10SerializerOptions.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.impl.io.serialization.canonical; +package fr.inria.corese.core.next.data.impl.io.serialization.canonical; -import fr.inria.corese.core.next.impl.io.serialization.option.AbstractSerializerOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.option.AbstractSerializerOptions; /** * Configuration for Canonical RDF serialization format (RDFC-1.0). diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/jsonld/JSONLDSerializer.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/jsonld/JSONLDSerializer.java similarity index 80% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/jsonld/JSONLDSerializer.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/jsonld/JSONLDSerializer.java index 5f12daec1..db2f0301a 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/jsonld/JSONLDSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/jsonld/JSONLDSerializer.java @@ -1,15 +1,15 @@ -package fr.inria.corese.core.next.impl.io.serialization.jsonld; +package fr.inria.corese.core.next.data.impl.io.serialization.jsonld; import com.apicatalog.jsonld.JsonLd; import com.apicatalog.jsonld.JsonLdError; import com.apicatalog.jsonld.api.FromRdfApi; import com.apicatalog.jsonld.document.RdfDocument; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.io.serializer.RDFSerializer; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.impl.exception.SerializationException; -import fr.inria.corese.core.next.impl.io.common.JSONLDOptions; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.io.serializer.RDFSerializer; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.impl.exception.SerializationException; +import fr.inria.corese.core.next.data.impl.io.common.JSONLDOptions; import java.io.IOException; import java.io.Writer; diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/jsonld/TitaniumRDFDatasetSerializationAdapter.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/jsonld/TitaniumRDFDatasetSerializationAdapter.java similarity index 94% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/jsonld/TitaniumRDFDatasetSerializationAdapter.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/jsonld/TitaniumRDFDatasetSerializationAdapter.java index 085446c98..6ea5d2bae 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/jsonld/TitaniumRDFDatasetSerializationAdapter.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/jsonld/TitaniumRDFDatasetSerializationAdapter.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.serialization.jsonld; +package fr.inria.corese.core.next.data.impl.io.serialization.jsonld; import java.math.BigDecimal; import java.math.BigInteger; @@ -24,20 +24,20 @@ import com.apicatalog.rdf.RdfTriple; import com.apicatalog.rdf.RdfValue; -import fr.inria.corese.core.next.api.BNode; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Literal; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.api.Value; -import fr.inria.corese.core.next.api.literal.CoreDatatype; -import fr.inria.corese.core.next.impl.common.util.IRIUtils; -import fr.inria.corese.core.next.impl.common.vocabulary.RDF; -import fr.inria.corese.core.next.impl.common.vocabulary.XSD; -import fr.inria.corese.core.next.impl.exception.SerializationException; -import fr.inria.corese.core.next.impl.io.common.IOConstants; -import fr.inria.corese.core.next.impl.io.parser.util.ParserConstants; +import fr.inria.corese.core.next.data.api.BNode; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Literal; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.api.Value; +import fr.inria.corese.core.next.data.api.literal.CoreDatatype; +import fr.inria.corese.core.next.data.impl.common.util.IRIUtils; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF; +import fr.inria.corese.core.next.data.impl.common.vocabulary.XSD; +import fr.inria.corese.core.next.data.impl.exception.SerializationException; +import fr.inria.corese.core.next.data.impl.io.common.IOConstants; +import fr.inria.corese.core.next.data.impl.io.parser.util.ParserConstants; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/nquads/NQuadsSerializer.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/nquads/NQuadsSerializer.java similarity index 80% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/nquads/NQuadsSerializer.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/nquads/NQuadsSerializer.java index 9c9134460..d6763250b 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/nquads/NQuadsSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/nquads/NQuadsSerializer.java @@ -1,17 +1,17 @@ -package fr.inria.corese.core.next.impl.io.serialization.nquads; +package fr.inria.corese.core.next.data.impl.io.serialization.nquads; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.api.io.common.BaseIRIOptions; -import fr.inria.corese.core.next.api.io.serializer.BlankNodeIdGenerationOptions; -import fr.inria.corese.core.next.api.io.serializer.LineEndingOptions; -import fr.inria.corese.core.next.impl.io.serialization.base.AbstractLineBasedSerializer; -import fr.inria.corese.core.next.impl.io.serialization.ntriples.NTriplesSerializerOptions; -import fr.inria.corese.core.next.impl.io.serialization.option.AbstractNFamilyOptions; -import fr.inria.corese.core.next.impl.io.serialization.util.SerializationConstants; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.io.common.BaseIRIOptions; +import fr.inria.corese.core.next.data.io.serializer.BlankNodeIdGenerationOptions; +import fr.inria.corese.core.next.data.io.serializer.LineEndingOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.base.AbstractLineBasedSerializer; +import fr.inria.corese.core.next.data.impl.io.serialization.ntriples.NTriplesSerializerOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.option.AbstractNFamilyOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.util.SerializationConstants; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/nquads/NQuadsSerializerOptions.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/nquads/NQuadsSerializerOptions.java similarity index 93% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/nquads/NQuadsSerializerOptions.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/nquads/NQuadsSerializerOptions.java index 935f2f752..52bc9fafa 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/nquads/NQuadsSerializerOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/nquads/NQuadsSerializerOptions.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.impl.io.serialization.nquads; +package fr.inria.corese.core.next.data.impl.io.serialization.nquads; -import fr.inria.corese.core.next.impl.io.serialization.option.AbstractNFamilyOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.option.AbstractNFamilyOptions; /** * Configuration for N-Quads serialization format. diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/ntriples/NTriplesSerializer.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/ntriples/NTriplesSerializer.java similarity index 83% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/ntriples/NTriplesSerializer.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/ntriples/NTriplesSerializer.java index eb6c50840..0e2743f2b 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/ntriples/NTriplesSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/ntriples/NTriplesSerializer.java @@ -1,22 +1,22 @@ -package fr.inria.corese.core.next.impl.io.serialization.ntriples; +package fr.inria.corese.core.next.data.impl.io.serialization.ntriples; import java.io.IOException; import java.io.Writer; import java.util.Objects; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.api.io.common.BaseIRIOptions; -import fr.inria.corese.core.next.api.io.serializer.BlankNodeIdGenerationOptions; -import fr.inria.corese.core.next.api.io.serializer.LineEndingOptions; -import fr.inria.corese.core.next.impl.io.serialization.option.AbstractNFamilyOptions; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.io.common.BaseIRIOptions; +import fr.inria.corese.core.next.data.io.serializer.BlankNodeIdGenerationOptions; +import fr.inria.corese.core.next.data.io.serializer.LineEndingOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.option.AbstractNFamilyOptions; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.impl.io.serialization.base.AbstractLineBasedSerializer; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.impl.io.serialization.base.AbstractLineBasedSerializer; /** * Serializes a Corese {@link Model} into N-Triples format. diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/ntriples/NTriplesSerializerOptions.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/ntriples/NTriplesSerializerOptions.java similarity index 93% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/ntriples/NTriplesSerializerOptions.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/ntriples/NTriplesSerializerOptions.java index 4cdec4029..121bc6a39 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/ntriples/NTriplesSerializerOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/ntriples/NTriplesSerializerOptions.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.impl.io.serialization.ntriples; +package fr.inria.corese.core.next.data.impl.io.serialization.ntriples; -import fr.inria.corese.core.next.impl.io.serialization.option.AbstractNFamilyOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.option.AbstractNFamilyOptions; /** * Configuration for N-Triples serialization format. diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/option/AbstractNFamilyOptions.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/option/AbstractNFamilyOptions.java similarity index 97% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/option/AbstractNFamilyOptions.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/option/AbstractNFamilyOptions.java index a43616d09..4b4e23c04 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/option/AbstractNFamilyOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/option/AbstractNFamilyOptions.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.serialization.option; +package fr.inria.corese.core.next.data.impl.io.serialization.option; /** * An abstract base class for serialization configurations of N-Family RDF formats (e.g., N-Triples, N-Quads). diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/option/AbstractSerializerOptions.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/option/AbstractSerializerOptions.java similarity index 96% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/option/AbstractSerializerOptions.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/option/AbstractSerializerOptions.java index 9a971efa1..8d929f348 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/option/AbstractSerializerOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/option/AbstractSerializerOptions.java @@ -1,11 +1,11 @@ -package fr.inria.corese.core.next.impl.io.serialization.option; - -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.api.io.common.BaseIRIOptions; -import fr.inria.corese.core.next.api.io.serializer.BlankNodeIdGenerationOptions; -import fr.inria.corese.core.next.api.io.serializer.DatatypePolicyOptions; -import fr.inria.corese.core.next.api.io.serializer.LineEndingOptions; -import fr.inria.corese.core.next.impl.io.serialization.util.SerializationConstants; +package fr.inria.corese.core.next.data.impl.io.serialization.option; + +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.io.common.BaseIRIOptions; +import fr.inria.corese.core.next.data.io.serializer.BlankNodeIdGenerationOptions; +import fr.inria.corese.core.next.data.io.serializer.DatatypePolicyOptions; +import fr.inria.corese.core.next.data.io.serializer.LineEndingOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.util.SerializationConstants; import java.util.Objects; diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/option/AbstractTFamilyOptions.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/option/AbstractTFamilyOptions.java similarity index 98% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/option/AbstractTFamilyOptions.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/option/AbstractTFamilyOptions.java index 8bf85d17e..c303ab14a 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/option/AbstractTFamilyOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/option/AbstractTFamilyOptions.java @@ -1,10 +1,10 @@ -package fr.inria.corese.core.next.impl.io.serialization.option; +package fr.inria.corese.core.next.data.impl.io.serialization.option; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.api.io.serializer.PrettyPrintOptions; -import fr.inria.corese.core.next.api.io.serializer.UsesPrefixOptions; -import fr.inria.corese.core.next.impl.common.prefix.PrefixHandler; -import fr.inria.corese.core.next.impl.io.serialization.util.SerializationConstants; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.io.serializer.PrettyPrintOptions; +import fr.inria.corese.core.next.data.io.serializer.UsesPrefixOptions; +import fr.inria.corese.core.next.data.impl.common.prefix.PrefixHandler; +import fr.inria.corese.core.next.data.impl.io.serialization.util.SerializationConstants; import java.util.Map; import java.util.Objects; diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/option/BlankNodeStyleEnum.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/option/BlankNodeStyleEnum.java similarity index 82% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/option/BlankNodeStyleEnum.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/option/BlankNodeStyleEnum.java index 996901cd8..f8addf084 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/option/BlankNodeStyleEnum.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/option/BlankNodeStyleEnum.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.serialization.option; +package fr.inria.corese.core.next.data.impl.io.serialization.option; /** * Defines the style for serializing blank nodes. diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/option/LiteralDatatypePolicyEnum.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/option/LiteralDatatypePolicyEnum.java similarity index 86% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/option/LiteralDatatypePolicyEnum.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/option/LiteralDatatypePolicyEnum.java index 3f4d80807..488ac263b 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/option/LiteralDatatypePolicyEnum.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/option/LiteralDatatypePolicyEnum.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.serialization.option; +package fr.inria.corese.core.next.data.impl.io.serialization.option; /** * Defines the policy for serializing literal datatypes. diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/option/PrefixOrderingEnum.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/option/PrefixOrderingEnum.java similarity index 85% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/option/PrefixOrderingEnum.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/option/PrefixOrderingEnum.java index 9a45b7f28..26805cdb0 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/option/PrefixOrderingEnum.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/option/PrefixOrderingEnum.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.serialization.option; +package fr.inria.corese.core.next.data.impl.io.serialization.option; /** * Defines the ordering policy for prefix declarations. diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/rdfxml/RDFXMLSerializer.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/rdfxml/RDFXMLSerializer.java similarity index 95% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/rdfxml/RDFXMLSerializer.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/rdfxml/RDFXMLSerializer.java index d70917a06..2af6b44f9 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/rdfxml/RDFXMLSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/rdfxml/RDFXMLSerializer.java @@ -1,4 +1,17 @@ -package fr.inria.corese.core.next.impl.io.serialization.rdfxml; +package fr.inria.corese.core.next.data.impl.io.serialization.rdfxml; + +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.io.serializer.*; +import fr.inria.corese.core.next.data.impl.common.prefix.PrefixHandler; +import fr.inria.corese.core.next.data.impl.common.util.IRIUtils; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF; +import fr.inria.corese.core.next.data.impl.common.vocabulary.XSD; +import fr.inria.corese.core.next.data.impl.exception.SerializationException; +import fr.inria.corese.core.next.data.impl.io.serialization.option.LiteralDatatypePolicyEnum; +import fr.inria.corese.core.next.data.impl.io.serialization.option.PrefixOrderingEnum; +import fr.inria.corese.core.next.data.impl.io.serialization.util.SerializationConstants; import java.io.BufferedWriter; import java.io.IOException; @@ -7,24 +20,6 @@ import java.util.*; import java.util.stream.Collectors; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.api.io.serializer.*; -import fr.inria.corese.core.next.impl.common.prefix.PrefixHandler; -import fr.inria.corese.core.next.impl.common.util.IRIUtils; -import fr.inria.corese.core.next.impl.common.vocabulary.*; - -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Literal; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.api.Value; -import fr.inria.corese.core.next.impl.exception.SerializationException; -import fr.inria.corese.core.next.impl.io.serialization.option.LiteralDatatypePolicyEnum; -import fr.inria.corese.core.next.impl.io.serialization.option.PrefixOrderingEnum; -import fr.inria.corese.core.next.impl.io.serialization.util.SerializationConstants; - /** * Serializes a {@link Model} to RDF/XML format. * This class provides a method to write the statements of a model to a {@link Writer} diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/rdfxml/RDFXMLSerializerOptions.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/rdfxml/RDFXMLSerializerOptions.java similarity index 95% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/rdfxml/RDFXMLSerializerOptions.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/rdfxml/RDFXMLSerializerOptions.java index 7876e181f..b58558ad9 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/rdfxml/RDFXMLSerializerOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/rdfxml/RDFXMLSerializerOptions.java @@ -1,12 +1,12 @@ -package fr.inria.corese.core.next.impl.io.serialization.rdfxml; - -import fr.inria.corese.core.next.api.io.serializer.PrettyPrintOptions; -import fr.inria.corese.core.next.api.io.serializer.UsesPrefixOptions; -import fr.inria.corese.core.next.impl.common.prefix.PrefixHandler; -import fr.inria.corese.core.next.impl.io.serialization.option.AbstractSerializerOptions; -import fr.inria.corese.core.next.impl.io.serialization.option.LiteralDatatypePolicyEnum; -import fr.inria.corese.core.next.impl.io.serialization.option.PrefixOrderingEnum; -import fr.inria.corese.core.next.impl.io.serialization.util.SerializationConstants; +package fr.inria.corese.core.next.data.impl.io.serialization.rdfxml; + +import fr.inria.corese.core.next.data.io.serializer.PrettyPrintOptions; +import fr.inria.corese.core.next.data.io.serializer.UsesPrefixOptions; +import fr.inria.corese.core.next.data.impl.common.prefix.PrefixHandler; +import fr.inria.corese.core.next.data.impl.io.serialization.option.AbstractSerializerOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.option.LiteralDatatypePolicyEnum; +import fr.inria.corese.core.next.data.impl.io.serialization.option.PrefixOrderingEnum; +import fr.inria.corese.core.next.data.impl.io.serialization.util.SerializationConstants; import java.util.Map; import java.util.Objects; diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/trig/TriGSerializer.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/trig/TriGSerializer.java similarity index 93% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/trig/TriGSerializer.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/trig/TriGSerializer.java index a3f7cfab9..8d5544947 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/trig/TriGSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/trig/TriGSerializer.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.serialization.trig; +package fr.inria.corese.core.next.data.impl.io.serialization.trig; import java.io.IOException; import java.io.Writer; @@ -10,18 +10,18 @@ import java.util.TreeMap; import java.util.HashMap; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.api.io.serializer.LineEndingOptions; -import fr.inria.corese.core.next.api.io.serializer.PrettyPrintOptions; -import fr.inria.corese.core.next.impl.io.serialization.base.AbstractGraphSerializer; -import fr.inria.corese.core.next.impl.io.serialization.option.AbstractSerializerOptions; -import fr.inria.corese.core.next.impl.io.serialization.option.AbstractTFamilyOptions; -import fr.inria.corese.core.next.impl.io.serialization.util.SerializationConstants; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.io.serializer.LineEndingOptions; +import fr.inria.corese.core.next.data.io.serializer.PrettyPrintOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.base.AbstractGraphSerializer; +import fr.inria.corese.core.next.data.impl.io.serialization.option.AbstractSerializerOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.option.AbstractTFamilyOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.util.SerializationConstants; /** * Serializes a {@link Model} to TriG format with comprehensive syntax support. diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/trig/TriGSerializerOptions.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/trig/TriGSerializerOptions.java similarity index 90% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/trig/TriGSerializerOptions.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/trig/TriGSerializerOptions.java index 31adeb113..669a47178 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/trig/TriGSerializerOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/trig/TriGSerializerOptions.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.impl.io.serialization.trig; +package fr.inria.corese.core.next.data.impl.io.serialization.trig; -import fr.inria.corese.core.next.impl.io.serialization.option.AbstractTFamilyOptions; -import fr.inria.corese.core.next.impl.io.serialization.option.BlankNodeStyleEnum; +import fr.inria.corese.core.next.data.impl.io.serialization.option.AbstractTFamilyOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.option.BlankNodeStyleEnum; /** * Configuration for TriG serialization format. diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/turtle/TurtleSerializer.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/turtle/TurtleSerializer.java similarity index 93% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/turtle/TurtleSerializer.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/turtle/TurtleSerializer.java index 14f5115ef..652ed4255 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/turtle/TurtleSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/turtle/TurtleSerializer.java @@ -1,20 +1,20 @@ -package fr.inria.corese.core.next.impl.io.serialization.turtle; +package fr.inria.corese.core.next.data.impl.io.serialization.turtle; import java.io.IOException; import java.io.Writer; import java.util.Objects; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.impl.io.serialization.option.AbstractSerializerOptions; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.option.AbstractSerializerOptions; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.impl.io.serialization.base.AbstractGraphSerializer; -import fr.inria.corese.core.next.impl.io.serialization.option.AbstractTFamilyOptions; -import fr.inria.corese.core.next.impl.io.serialization.util.SerializationConstants; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.impl.io.serialization.base.AbstractGraphSerializer; +import fr.inria.corese.core.next.data.impl.io.serialization.option.AbstractTFamilyOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.util.SerializationConstants; /** * Serializes a {@link Model} to Turtle format with comprehensive syntax support. diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/turtle/TurtleSerializerOptions.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/turtle/TurtleSerializerOptions.java similarity index 89% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/turtle/TurtleSerializerOptions.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/turtle/TurtleSerializerOptions.java index 8a001358c..d75d5fcd9 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/turtle/TurtleSerializerOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/turtle/TurtleSerializerOptions.java @@ -1,9 +1,9 @@ -package fr.inria.corese.core.next.impl.io.serialization.turtle; +package fr.inria.corese.core.next.data.impl.io.serialization.turtle; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.api.io.serializer.LineEndingOptions; -import fr.inria.corese.core.next.impl.io.serialization.option.AbstractTFamilyOptions; -import fr.inria.corese.core.next.impl.io.serialization.option.BlankNodeStyleEnum; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.io.serializer.LineEndingOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.option.AbstractTFamilyOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.option.BlankNodeStyleEnum; /** * Configuration for Turtle serialization format. diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/util/SerializationConstants.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/util/SerializationConstants.java similarity index 95% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/util/SerializationConstants.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/util/SerializationConstants.java index 9c4d08c6d..197521bcf 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/util/SerializationConstants.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/util/SerializationConstants.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.impl.io.serialization.util; +package fr.inria.corese.core.next.data.impl.io.serialization.util; -import fr.inria.corese.core.next.impl.io.common.IOConstants; +import fr.inria.corese.core.next.data.impl.io.common.IOConstants; /** * Provides common constants used throughout the RDF serialization process. diff --git a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/util/StatementUtils.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/util/StatementUtils.java similarity index 98% rename from src/main/java/fr/inria/corese/core/next/impl/io/serialization/util/StatementUtils.java rename to src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/util/StatementUtils.java index eb8ce9f75..737b1fff0 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/io/serialization/util/StatementUtils.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/util/StatementUtils.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.impl.io.serialization.util; +package fr.inria.corese.core.next.data.impl.io.serialization.util; -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.impl.common.vocabulary.XSD; +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.impl.common.vocabulary.XSD; import java.util.Map; diff --git a/src/main/java/fr/inria/corese/core/next/impl/temp/CoreseAdaptedValueFactory.java b/src/main/java/fr/inria/corese/core/next/data/impl/temp/CoreseAdaptedValueFactory.java similarity index 90% rename from src/main/java/fr/inria/corese/core/next/impl/temp/CoreseAdaptedValueFactory.java rename to src/main/java/fr/inria/corese/core/next/data/impl/temp/CoreseAdaptedValueFactory.java index e067eb246..ba5a29d3e 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/temp/CoreseAdaptedValueFactory.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/temp/CoreseAdaptedValueFactory.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.temp; +package fr.inria.corese.core.next.data.impl.temp; import java.math.BigDecimal; import java.math.BigInteger; @@ -7,33 +7,32 @@ import java.time.temporal.TemporalAccessor; import java.time.temporal.TemporalAmount; import java.util.Date; -import java.util.concurrent.ThreadLocalRandom; import java.util.concurrent.atomic.AtomicLong; import javax.xml.datatype.XMLGregorianCalendar; -import fr.inria.corese.core.next.api.BNode; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Literal; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.api.Triple; -import fr.inria.corese.core.next.api.Value; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.api.base.model.literal.AbstractLiteral; -import fr.inria.corese.core.next.api.literal.CoreDatatype; -import fr.inria.corese.core.next.impl.common.literal.XSD; -import fr.inria.corese.core.next.impl.exception.InternalException; -import fr.inria.corese.core.next.impl.temp.literal.CoreseBNode; -import fr.inria.corese.core.next.impl.temp.literal.CoreseBoolean; -import fr.inria.corese.core.next.impl.temp.literal.CoreseDate; -import fr.inria.corese.core.next.impl.temp.literal.CoreseDatetime; -import fr.inria.corese.core.next.impl.temp.literal.CoreseDecimal; -import fr.inria.corese.core.next.impl.temp.literal.CoreseDuration; -import fr.inria.corese.core.next.impl.temp.literal.CoreseInteger; -import fr.inria.corese.core.next.impl.temp.literal.CoreseLanguageTaggedStringLiteral; -import fr.inria.corese.core.next.impl.temp.literal.CoreseTime; -import fr.inria.corese.core.next.impl.temp.literal.CoreseTyped; +import fr.inria.corese.core.next.data.api.BNode; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Literal; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.api.Triple; +import fr.inria.corese.core.next.data.api.Value; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.api.base.model.literal.AbstractLiteral; +import fr.inria.corese.core.next.data.api.literal.CoreDatatype; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.exception.InternalException; +import fr.inria.corese.core.next.data.impl.temp.literal.CoreseBNode; +import fr.inria.corese.core.next.data.impl.temp.literal.CoreseBoolean; +import fr.inria.corese.core.next.data.impl.temp.literal.CoreseDate; +import fr.inria.corese.core.next.data.impl.temp.literal.CoreseDatetime; +import fr.inria.corese.core.next.data.impl.temp.literal.CoreseDecimal; +import fr.inria.corese.core.next.data.impl.temp.literal.CoreseDuration; +import fr.inria.corese.core.next.data.impl.temp.literal.CoreseInteger; +import fr.inria.corese.core.next.data.impl.temp.literal.CoreseLanguageTaggedStringLiteral; +import fr.inria.corese.core.next.data.impl.temp.literal.CoreseTime; +import fr.inria.corese.core.next.data.impl.temp.literal.CoreseTyped; /** * Factory for all the Corese adapted values. diff --git a/src/main/java/fr/inria/corese/core/next/impl/temp/CoreseEdgeAdapter.java b/src/main/java/fr/inria/corese/core/next/data/impl/temp/CoreseEdgeAdapter.java similarity index 90% rename from src/main/java/fr/inria/corese/core/next/impl/temp/CoreseEdgeAdapter.java rename to src/main/java/fr/inria/corese/core/next/data/impl/temp/CoreseEdgeAdapter.java index 301ebfb3e..c6486c244 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/temp/CoreseEdgeAdapter.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/temp/CoreseEdgeAdapter.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.temp; +package fr.inria.corese.core.next.data.impl.temp; import fr.inria.corese.core.kgram.api.core.Edge; diff --git a/src/main/java/fr/inria/corese/core/next/impl/temp/CoreseIRI.java b/src/main/java/fr/inria/corese/core/next/data/impl/temp/CoreseIRI.java similarity index 90% rename from src/main/java/fr/inria/corese/core/next/impl/temp/CoreseIRI.java rename to src/main/java/fr/inria/corese/core/next/data/impl/temp/CoreseIRI.java index 1ef7445d1..362fee9d3 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/temp/CoreseIRI.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/temp/CoreseIRI.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.impl.temp; +package fr.inria.corese.core.next.data.impl.temp; import fr.inria.corese.core.kgram.api.core.Node; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.base.model.AbstractIRI; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.base.model.AbstractIRI; import fr.inria.corese.core.sparql.api.IDatatype; import fr.inria.corese.core.sparql.datatype.CoreseURI; diff --git a/src/main/java/fr/inria/corese/core/next/impl/temp/CoreseModel.java b/src/main/java/fr/inria/corese/core/next/data/impl/temp/CoreseModel.java similarity index 96% rename from src/main/java/fr/inria/corese/core/next/impl/temp/CoreseModel.java rename to src/main/java/fr/inria/corese/core/next/data/impl/temp/CoreseModel.java index def34c0e7..c15ce78c0 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/temp/CoreseModel.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/temp/CoreseModel.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.temp; +package fr.inria.corese.core.next.data.impl.temp; import java.util.ArrayList; import java.util.Collection; @@ -13,13 +13,13 @@ import fr.inria.corese.core.Graph; import fr.inria.corese.core.kgram.api.core.Edge; import fr.inria.corese.core.kgram.api.core.Node; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Namespace; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.api.Value; -import fr.inria.corese.core.next.api.base.model.AbstractModel; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Namespace; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.api.Value; +import fr.inria.corese.core.next.data.api.base.model.AbstractModel; /** * CoreseModel provides an implementation of the RDF Model interface diff --git a/src/main/java/fr/inria/corese/core/next/impl/temp/CoreseNodeAdapter.java b/src/main/java/fr/inria/corese/core/next/data/impl/temp/CoreseNodeAdapter.java similarity index 89% rename from src/main/java/fr/inria/corese/core/next/impl/temp/CoreseNodeAdapter.java rename to src/main/java/fr/inria/corese/core/next/data/impl/temp/CoreseNodeAdapter.java index cafd4494a..610d23563 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/temp/CoreseNodeAdapter.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/temp/CoreseNodeAdapter.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.temp; +package fr.inria.corese.core.next.data.impl.temp; import fr.inria.corese.core.kgram.api.core.Node; diff --git a/src/main/java/fr/inria/corese/core/next/impl/temp/CoreseStatement.java b/src/main/java/fr/inria/corese/core/next/data/impl/temp/CoreseStatement.java similarity index 93% rename from src/main/java/fr/inria/corese/core/next/impl/temp/CoreseStatement.java rename to src/main/java/fr/inria/corese/core/next/data/impl/temp/CoreseStatement.java index 14752290b..202860534 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/temp/CoreseStatement.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/temp/CoreseStatement.java @@ -1,12 +1,12 @@ -package fr.inria.corese.core.next.impl.temp; +package fr.inria.corese.core.next.data.impl.temp; import fr.inria.corese.core.edge.EdgeImpl; import fr.inria.corese.core.kgram.api.core.Edge; import fr.inria.corese.core.kgram.api.core.Node; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Value; -import fr.inria.corese.core.next.api.base.model.AbstractStatement; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Value; +import fr.inria.corese.core.next.data.api.base.model.AbstractStatement; /** * Represents a statement in Corese. A Corese statement consists of a subject, diff --git a/src/main/java/fr/inria/corese/core/next/impl/temp/CoreseValueConverter.java b/src/main/java/fr/inria/corese/core/next/data/impl/temp/CoreseValueConverter.java similarity index 92% rename from src/main/java/fr/inria/corese/core/next/impl/temp/CoreseValueConverter.java rename to src/main/java/fr/inria/corese/core/next/data/impl/temp/CoreseValueConverter.java index 9d6ff57a1..0f9f7de9d 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/temp/CoreseValueConverter.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/temp/CoreseValueConverter.java @@ -1,13 +1,13 @@ -package fr.inria.corese.core.next.impl.temp; +package fr.inria.corese.core.next.data.impl.temp; import fr.inria.corese.core.kgram.api.core.ExpType; import fr.inria.corese.core.kgram.api.core.Node; -import fr.inria.corese.core.next.api.BNode; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Literal; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Value; -import fr.inria.corese.core.next.api.ValueFactory; +import fr.inria.corese.core.next.data.api.BNode; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Literal; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Value; +import fr.inria.corese.core.next.data.api.ValueFactory; import fr.inria.corese.core.sparql.api.IDatatype; import fr.inria.corese.core.sparql.datatype.DatatypeMap; diff --git a/src/main/java/fr/inria/corese/core/next/impl/temp/EmptyModel.java b/src/main/java/fr/inria/corese/core/next/data/impl/temp/EmptyModel.java similarity index 85% rename from src/main/java/fr/inria/corese/core/next/impl/temp/EmptyModel.java rename to src/main/java/fr/inria/corese/core/next/data/impl/temp/EmptyModel.java index 568e24f8f..6f8ac2ede 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/temp/EmptyModel.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/temp/EmptyModel.java @@ -1,17 +1,17 @@ -package fr.inria.corese.core.next.impl.temp; +package fr.inria.corese.core.next.data.impl.temp; import java.util.Collections; import java.util.Iterator; import java.util.Optional; import java.util.Set; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Namespace; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.api.Value; -import fr.inria.corese.core.next.api.base.model.AbstractModel; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Namespace; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.api.Value; +import fr.inria.corese.core.next.data.api.base.model.AbstractModel; /** * A model wrapper that blocks access to all statements, allowing only namespace diff --git a/src/main/java/fr/inria/corese/core/next/impl/temp/FilteredModel.java b/src/main/java/fr/inria/corese/core/next/data/impl/temp/FilteredModel.java similarity index 95% rename from src/main/java/fr/inria/corese/core/next/impl/temp/FilteredModel.java rename to src/main/java/fr/inria/corese/core/next/data/impl/temp/FilteredModel.java index 94dd309de..e4b039905 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/temp/FilteredModel.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/temp/FilteredModel.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.temp; +package fr.inria.corese.core.next.data.impl.temp; import java.util.Arrays; import java.util.Iterator; @@ -6,13 +6,13 @@ import java.util.Optional; import java.util.Set; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Namespace; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.api.Value; -import fr.inria.corese.core.next.api.base.model.AbstractModel; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Namespace; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.api.Value; +import fr.inria.corese.core.next.data.api.base.model.AbstractModel; public abstract class FilteredModel extends AbstractModel { diff --git a/src/main/java/fr/inria/corese/core/next/impl/temp/ModelNamespace.java b/src/main/java/fr/inria/corese/core/next/data/impl/temp/ModelNamespace.java similarity index 84% rename from src/main/java/fr/inria/corese/core/next/impl/temp/ModelNamespace.java rename to src/main/java/fr/inria/corese/core/next/data/impl/temp/ModelNamespace.java index 518355474..22d7afe96 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/temp/ModelNamespace.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/temp/ModelNamespace.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.impl.temp; +package fr.inria.corese.core.next.data.impl.temp; import java.io.Serial; -import fr.inria.corese.core.next.api.base.model.AbstractNamespace; +import fr.inria.corese.core.next.data.api.base.model.AbstractNamespace; /* * A simple implementation of the {@link Namespace} interface. diff --git a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/AbstractCoreseNumber.java b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/AbstractCoreseNumber.java similarity index 91% rename from src/main/java/fr/inria/corese/core/next/impl/temp/literal/AbstractCoreseNumber.java rename to src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/AbstractCoreseNumber.java index 924daf2a4..9468ff464 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/AbstractCoreseNumber.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/AbstractCoreseNumber.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.impl.temp.literal; +package fr.inria.corese.core.next.data.impl.temp.literal; import fr.inria.corese.core.kgram.api.core.Node; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.base.model.literal.AbstractNumber; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.base.model.literal.AbstractNumber; import fr.inria.corese.core.sparql.api.IDatatype; import fr.inria.corese.core.sparql.datatype.CoreseNumber; diff --git a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseBNode.java b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseBNode.java similarity index 90% rename from src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseBNode.java rename to src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseBNode.java index bd0cc8f99..c3f76894c 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseBNode.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseBNode.java @@ -1,9 +1,9 @@ -package fr.inria.corese.core.next.impl.temp.literal; +package fr.inria.corese.core.next.data.impl.temp.literal; import fr.inria.corese.core.kgram.api.core.Node; -import fr.inria.corese.core.next.api.base.model.AbstractBNode; -import fr.inria.corese.core.next.impl.exception.IncorrectOperationException; -import fr.inria.corese.core.next.impl.temp.CoreseNodeAdapter; +import fr.inria.corese.core.next.data.api.base.model.AbstractBNode; +import fr.inria.corese.core.next.data.impl.exception.IncorrectOperationException; +import fr.inria.corese.core.next.data.impl.temp.CoreseNodeAdapter; import fr.inria.corese.core.sparql.api.IDatatype; import fr.inria.corese.core.sparql.datatype.CoreseBlankNode; diff --git a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseBoolean.java b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseBoolean.java similarity index 91% rename from src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseBoolean.java rename to src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseBoolean.java index bd36570e8..23e5c9216 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseBoolean.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseBoolean.java @@ -1,11 +1,11 @@ -package fr.inria.corese.core.next.impl.temp.literal; +package fr.inria.corese.core.next.data.impl.temp.literal; import fr.inria.corese.core.kgram.api.core.Node; -import fr.inria.corese.core.next.api.base.model.literal.AbstractLiteral; -import fr.inria.corese.core.next.api.literal.CoreDatatype; -import fr.inria.corese.core.next.impl.common.literal.XSD; -import fr.inria.corese.core.next.impl.exception.IncorrectOperationException; -import fr.inria.corese.core.next.impl.temp.CoreseIRI; +import fr.inria.corese.core.next.data.api.base.model.literal.AbstractLiteral; +import fr.inria.corese.core.next.data.api.literal.CoreDatatype; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.exception.IncorrectOperationException; +import fr.inria.corese.core.next.data.impl.temp.CoreseIRI; import fr.inria.corese.core.sparql.api.IDatatype; /** diff --git a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDatatypeAdapter.java b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDatatypeAdapter.java similarity index 76% rename from src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDatatypeAdapter.java rename to src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDatatypeAdapter.java index f5ce4a0ed..38f00987d 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDatatypeAdapter.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDatatypeAdapter.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.impl.temp.literal; +package fr.inria.corese.core.next.data.impl.temp.literal; -import fr.inria.corese.core.next.impl.temp.CoreseNodeAdapter; +import fr.inria.corese.core.next.data.impl.temp.CoreseNodeAdapter; import fr.inria.corese.core.sparql.api.IDatatype; /** diff --git a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDate.java b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDate.java similarity index 91% rename from src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDate.java rename to src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDate.java index 85a221e0d..a600e1e60 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDate.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDate.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.temp.literal; +package fr.inria.corese.core.next.data.impl.temp.literal; import java.math.BigDecimal; import java.math.BigInteger; @@ -10,13 +10,13 @@ import javax.xml.datatype.XMLGregorianCalendar; import fr.inria.corese.core.kgram.api.core.Node; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.base.model.literal.AbstractTemporalPointLiteral; -import fr.inria.corese.core.next.api.literal.CoreDatatype; -import fr.inria.corese.core.next.impl.common.literal.XSD; -import fr.inria.corese.core.next.impl.exception.IncorrectDatatypeException; -import fr.inria.corese.core.next.impl.exception.IncorrectOperationException; -import fr.inria.corese.core.next.impl.temp.CoreseIRI; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.base.model.literal.AbstractTemporalPointLiteral; +import fr.inria.corese.core.next.data.api.literal.CoreDatatype; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.exception.IncorrectDatatypeException; +import fr.inria.corese.core.next.data.impl.exception.IncorrectOperationException; +import fr.inria.corese.core.next.data.impl.temp.CoreseIRI; import fr.inria.corese.core.sparql.api.IDatatype; public class CoreseDate extends AbstractTemporalPointLiteral implements CoreseDatatypeAdapter { diff --git a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDatetime.java b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDatetime.java similarity index 92% rename from src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDatetime.java rename to src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDatetime.java index b833e44d9..22f1d20e0 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDatetime.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDatetime.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.temp.literal; +package fr.inria.corese.core.next.data.impl.temp.literal; import java.math.BigDecimal; import java.math.BigInteger; @@ -8,13 +8,13 @@ import javax.xml.datatype.XMLGregorianCalendar; import fr.inria.corese.core.kgram.api.core.Node; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.base.model.literal.AbstractTemporalPointLiteral; -import fr.inria.corese.core.next.api.literal.CoreDatatype; -import fr.inria.corese.core.next.impl.common.literal.XSD; -import fr.inria.corese.core.next.impl.exception.IncorrectDatatypeException; -import fr.inria.corese.core.next.impl.exception.IncorrectOperationException; -import fr.inria.corese.core.next.impl.temp.CoreseIRI; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.base.model.literal.AbstractTemporalPointLiteral; +import fr.inria.corese.core.next.data.api.literal.CoreDatatype; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.exception.IncorrectDatatypeException; +import fr.inria.corese.core.next.data.impl.exception.IncorrectOperationException; +import fr.inria.corese.core.next.data.impl.temp.CoreseIRI; import fr.inria.corese.core.sparql.api.IDatatype; /** diff --git a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDecimal.java b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDecimal.java similarity index 90% rename from src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDecimal.java rename to src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDecimal.java index 06968d08c..9f69c1c80 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDecimal.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDecimal.java @@ -1,11 +1,11 @@ -package fr.inria.corese.core.next.impl.temp.literal; - -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.base.model.literal.AbstractLiteral; -import fr.inria.corese.core.next.api.base.model.literal.AbstractNumber; -import fr.inria.corese.core.next.impl.common.literal.XSD; -import fr.inria.corese.core.next.api.literal.CoreDatatype; -import fr.inria.corese.core.next.impl.exception.IncorrectDatatypeException; +package fr.inria.corese.core.next.data.impl.temp.literal; + +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.base.model.literal.AbstractLiteral; +import fr.inria.corese.core.next.data.api.base.model.literal.AbstractNumber; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.api.literal.CoreDatatype; +import fr.inria.corese.core.next.data.impl.exception.IncorrectDatatypeException; import fr.inria.corese.core.sparql.datatype.CoreseDouble; import java.math.BigDecimal; diff --git a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDuration.java b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDuration.java similarity index 91% rename from src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDuration.java rename to src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDuration.java index 662a6be44..34f78ecb7 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDuration.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDuration.java @@ -1,10 +1,10 @@ -package fr.inria.corese.core.next.impl.temp.literal; +package fr.inria.corese.core.next.data.impl.temp.literal; import fr.inria.corese.core.kgram.api.core.Node; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.literal.CoreDatatype; -import fr.inria.corese.core.next.impl.common.literal.XSD; -import fr.inria.corese.core.next.api.base.model.literal.AbstractDuration; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.literal.CoreDatatype; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.api.base.model.literal.AbstractDuration; import fr.inria.corese.core.sparql.api.IDatatype; import fr.inria.corese.core.sparql.datatype.CoreseUndefLiteral; diff --git a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseInteger.java b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseInteger.java similarity index 89% rename from src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseInteger.java rename to src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseInteger.java index c108d9e39..9637914ea 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseInteger.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseInteger.java @@ -1,12 +1,12 @@ -package fr.inria.corese.core.next.impl.temp.literal; - -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.base.model.literal.AbstractLiteral; -import fr.inria.corese.core.next.api.base.model.literal.AbstractNumber; -import fr.inria.corese.core.next.impl.common.literal.XSD; -import fr.inria.corese.core.next.api.literal.CoreDatatype; -import fr.inria.corese.core.next.impl.exception.IncorrectDatatypeException; -import fr.inria.corese.core.next.impl.exception.IncorrectOperationException; +package fr.inria.corese.core.next.data.impl.temp.literal; + +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.base.model.literal.AbstractLiteral; +import fr.inria.corese.core.next.data.api.base.model.literal.AbstractNumber; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.api.literal.CoreDatatype; +import fr.inria.corese.core.next.data.impl.exception.IncorrectDatatypeException; +import fr.inria.corese.core.next.data.impl.exception.IncorrectOperationException; import java.math.BigDecimal; import java.math.BigInteger; diff --git a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseLanguageTaggedStringLiteral.java b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseLanguageTaggedStringLiteral.java similarity index 89% rename from src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseLanguageTaggedStringLiteral.java rename to src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseLanguageTaggedStringLiteral.java index a1ac7f753..9e46a1713 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseLanguageTaggedStringLiteral.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseLanguageTaggedStringLiteral.java @@ -1,14 +1,14 @@ -package fr.inria.corese.core.next.impl.temp.literal; +package fr.inria.corese.core.next.data.impl.temp.literal; import java.util.Optional; import fr.inria.corese.core.kgram.api.core.Node; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.base.model.literal.AbstractStringLiteral; -import fr.inria.corese.core.next.api.literal.CoreDatatype; -import fr.inria.corese.core.next.impl.common.literal.RDF; -import fr.inria.corese.core.next.impl.exception.IncorrectOperationException; -import fr.inria.corese.core.next.impl.temp.CoreseIRI; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.base.model.literal.AbstractStringLiteral; +import fr.inria.corese.core.next.data.api.literal.CoreDatatype; +import fr.inria.corese.core.next.data.impl.common.literal.RDF; +import fr.inria.corese.core.next.data.impl.exception.IncorrectOperationException; +import fr.inria.corese.core.next.data.impl.temp.CoreseIRI; import fr.inria.corese.core.sparql.api.IDatatype; /** diff --git a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseTime.java b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseTime.java similarity index 83% rename from src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseTime.java rename to src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseTime.java index 687e8e910..fc7583844 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseTime.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseTime.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.impl.temp.literal; +package fr.inria.corese.core.next.data.impl.temp.literal; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.literal.CoreDatatype; -import fr.inria.corese.core.next.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.literal.CoreDatatype; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; /** * There are no dedicated implementation to represent xsd:time in Corese. diff --git a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseTyped.java b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseTyped.java similarity index 90% rename from src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseTyped.java rename to src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseTyped.java index d3408b855..ab15c2f50 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/temp/literal/CoreseTyped.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseTyped.java @@ -1,20 +1,20 @@ -package fr.inria.corese.core.next.impl.temp.literal; +package fr.inria.corese.core.next.data.impl.temp.literal; import java.util.Objects; import fr.inria.corese.core.kgram.api.core.Node; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.base.model.literal.AbstractStringLiteral; -import fr.inria.corese.core.next.api.literal.CoreDatatype; -import fr.inria.corese.core.next.impl.common.literal.XSD; -import fr.inria.corese.core.next.impl.common.util.literal.CoreDatatypeHelper; -import fr.inria.corese.core.next.impl.exception.IncorrectOperationException; -import fr.inria.corese.core.next.impl.temp.CoreseIRI; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.base.model.literal.AbstractStringLiteral; +import fr.inria.corese.core.next.data.api.literal.CoreDatatype; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.common.util.literal.CoreDatatypeHelper; +import fr.inria.corese.core.next.data.impl.exception.IncorrectOperationException; +import fr.inria.corese.core.next.data.impl.temp.CoreseIRI; import fr.inria.corese.core.sparql.api.IDatatype; import fr.inria.corese.core.sparql.datatype.CoreseGeneric; import fr.inria.corese.core.sparql.datatype.CoreseString; -import static fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdString; +import static fr.inria.corese.core.next.data.impl.common.vocabulary.XSD.xsdString; /** * An implementation of the {@code xsd:string} datatype used by Corese. diff --git a/src/main/java/fr/inria/corese/core/next/api/io/IOOptions.java b/src/main/java/fr/inria/corese/core/next/data/io/IOOptions.java similarity index 76% rename from src/main/java/fr/inria/corese/core/next/api/io/IOOptions.java rename to src/main/java/fr/inria/corese/core/next/data/io/IOOptions.java index 3992e744d..f83b672c1 100644 --- a/src/main/java/fr/inria/corese/core/next/api/io/IOOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/io/IOOptions.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api.io; +package fr.inria.corese.core.next.data.io; /** * Super-interface for configuration objects for IO operations (i.e. parsing, diff --git a/src/main/java/fr/inria/corese/core/next/api/io/common/BaseIRIOptions.java b/src/main/java/fr/inria/corese/core/next/data/io/common/BaseIRIOptions.java similarity index 81% rename from src/main/java/fr/inria/corese/core/next/api/io/common/BaseIRIOptions.java rename to src/main/java/fr/inria/corese/core/next/data/io/common/BaseIRIOptions.java index 9205cfd14..092eae50e 100644 --- a/src/main/java/fr/inria/corese/core/next/api/io/common/BaseIRIOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/io/common/BaseIRIOptions.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api.io.common; +package fr.inria.corese.core.next.data.io.common; /** diff --git a/src/main/java/fr/inria/corese/core/next/api/io/parser/RDFParser.java b/src/main/java/fr/inria/corese/core/next/data/io/parser/RDFParser.java similarity index 89% rename from src/main/java/fr/inria/corese/core/next/api/io/parser/RDFParser.java rename to src/main/java/fr/inria/corese/core/next/data/io/parser/RDFParser.java index fab2aaebf..601f3ea78 100644 --- a/src/main/java/fr/inria/corese/core/next/api/io/parser/RDFParser.java +++ b/src/main/java/fr/inria/corese/core/next/data/io/parser/RDFParser.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.api.io.parser; +package fr.inria.corese.core.next.data.io.parser; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.io.IOOptions; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.io.IOOptions; import java.io.InputStream; import java.io.Reader; diff --git a/src/main/java/fr/inria/corese/core/next/api/io/parser/RDFParserFactory.java b/src/main/java/fr/inria/corese/core/next/data/io/parser/RDFParserFactory.java similarity index 79% rename from src/main/java/fr/inria/corese/core/next/api/io/parser/RDFParserFactory.java rename to src/main/java/fr/inria/corese/core/next/data/io/parser/RDFParserFactory.java index de6e2c6dc..9fa5dbc00 100644 --- a/src/main/java/fr/inria/corese/core/next/api/io/parser/RDFParserFactory.java +++ b/src/main/java/fr/inria/corese/core/next/data/io/parser/RDFParserFactory.java @@ -1,9 +1,9 @@ -package fr.inria.corese.core.next.api.io.parser; +package fr.inria.corese.core.next.data.io.parser; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.io.IOOptions; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.io.IOOptions; /** * A factory for creating RDF parsers. diff --git a/src/main/java/fr/inria/corese/core/next/api/io/serializer/BlankNodeIdGenerationOptions.java b/src/main/java/fr/inria/corese/core/next/data/io/serializer/BlankNodeIdGenerationOptions.java similarity index 87% rename from src/main/java/fr/inria/corese/core/next/api/io/serializer/BlankNodeIdGenerationOptions.java rename to src/main/java/fr/inria/corese/core/next/data/io/serializer/BlankNodeIdGenerationOptions.java index 5fe2d6379..cdb632d0a 100644 --- a/src/main/java/fr/inria/corese/core/next/api/io/serializer/BlankNodeIdGenerationOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/io/serializer/BlankNodeIdGenerationOptions.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api.io.serializer; +package fr.inria.corese.core.next.data.io.serializer; /** * Interface for options that determine the generation of blank node Ids for serializers. diff --git a/src/main/java/fr/inria/corese/core/next/api/io/serializer/DatatypePolicyOptions.java b/src/main/java/fr/inria/corese/core/next/data/io/serializer/DatatypePolicyOptions.java similarity index 72% rename from src/main/java/fr/inria/corese/core/next/api/io/serializer/DatatypePolicyOptions.java rename to src/main/java/fr/inria/corese/core/next/data/io/serializer/DatatypePolicyOptions.java index b21dcaa48..56a4f683a 100644 --- a/src/main/java/fr/inria/corese/core/next/api/io/serializer/DatatypePolicyOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/io/serializer/DatatypePolicyOptions.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.api.io.serializer; +package fr.inria.corese.core.next.data.io.serializer; -import fr.inria.corese.core.next.impl.io.serialization.option.LiteralDatatypePolicyEnum; +import fr.inria.corese.core.next.data.impl.io.serialization.option.LiteralDatatypePolicyEnum; /** * Interface for serializer options to determine the policy for the literal datatypes diff --git a/src/main/java/fr/inria/corese/core/next/api/io/serializer/LineEndingOptions.java b/src/main/java/fr/inria/corese/core/next/data/io/serializer/LineEndingOptions.java similarity index 79% rename from src/main/java/fr/inria/corese/core/next/api/io/serializer/LineEndingOptions.java rename to src/main/java/fr/inria/corese/core/next/data/io/serializer/LineEndingOptions.java index 2b0478b2a..329345d5b 100644 --- a/src/main/java/fr/inria/corese/core/next/api/io/serializer/LineEndingOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/io/serializer/LineEndingOptions.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api.io.serializer; +package fr.inria.corese.core.next.data.io.serializer; /** * Interface to specify which line ending a serializer must use. diff --git a/src/main/java/fr/inria/corese/core/next/api/io/serializer/PrettyPrintOptions.java b/src/main/java/fr/inria/corese/core/next/data/io/serializer/PrettyPrintOptions.java similarity index 90% rename from src/main/java/fr/inria/corese/core/next/api/io/serializer/PrettyPrintOptions.java rename to src/main/java/fr/inria/corese/core/next/data/io/serializer/PrettyPrintOptions.java index ad371aae0..1287b2099 100644 --- a/src/main/java/fr/inria/corese/core/next/api/io/serializer/PrettyPrintOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/io/serializer/PrettyPrintOptions.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.api.io.serializer; +package fr.inria.corese.core.next.data.io.serializer; -import fr.inria.corese.core.next.impl.io.serialization.option.PrefixOrderingEnum; +import fr.inria.corese.core.next.data.impl.io.serialization.option.PrefixOrderingEnum; /** * Interface for the options of serializer allowing for pretty printing. diff --git a/src/main/java/fr/inria/corese/core/next/api/io/serializer/RDFSerializer.java b/src/main/java/fr/inria/corese/core/next/data/io/serializer/RDFSerializer.java similarity index 85% rename from src/main/java/fr/inria/corese/core/next/api/io/serializer/RDFSerializer.java rename to src/main/java/fr/inria/corese/core/next/data/io/serializer/RDFSerializer.java index 5fd4a2da4..3a4606292 100644 --- a/src/main/java/fr/inria/corese/core/next/api/io/serializer/RDFSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/data/io/serializer/RDFSerializer.java @@ -1,10 +1,10 @@ -package fr.inria.corese.core.next.api.io.serializer; +package fr.inria.corese.core.next.data.io.serializer; import java.io.Writer; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.impl.exception.SerializationException; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.impl.exception.SerializationException; /** * Factory interface for creating {@link RDFSerializer} instances. diff --git a/src/main/java/fr/inria/corese/core/next/api/io/serializer/SerializerFactory.java b/src/main/java/fr/inria/corese/core/next/data/io/serializer/SerializerFactory.java similarity index 87% rename from src/main/java/fr/inria/corese/core/next/api/io/serializer/SerializerFactory.java rename to src/main/java/fr/inria/corese/core/next/data/io/serializer/SerializerFactory.java index 7560ff072..b227cd5a0 100644 --- a/src/main/java/fr/inria/corese/core/next/api/io/serializer/SerializerFactory.java +++ b/src/main/java/fr/inria/corese/core/next/data/io/serializer/SerializerFactory.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.api.io.serializer; +package fr.inria.corese.core.next.data.io.serializer; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.io.IOOptions; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.io.IOOptions; /** * Factory interface for creating {@link RDFSerializer} instances. diff --git a/src/main/java/fr/inria/corese/core/next/api/io/serializer/UsesPrefixOptions.java b/src/main/java/fr/inria/corese/core/next/data/io/serializer/UsesPrefixOptions.java similarity index 81% rename from src/main/java/fr/inria/corese/core/next/api/io/serializer/UsesPrefixOptions.java rename to src/main/java/fr/inria/corese/core/next/data/io/serializer/UsesPrefixOptions.java index 5059bb46f..416c520ee 100644 --- a/src/main/java/fr/inria/corese/core/next/api/io/serializer/UsesPrefixOptions.java +++ b/src/main/java/fr/inria/corese/core/next/data/io/serializer/UsesPrefixOptions.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.api.io.serializer; +package fr.inria.corese.core.next.data.io.serializer; -import fr.inria.corese.core.next.impl.common.prefix.PrefixHandler; -import fr.inria.corese.core.next.impl.io.serialization.option.PrefixOrderingEnum; +import fr.inria.corese.core.next.data.impl.common.prefix.PrefixHandler; +import fr.inria.corese.core.next.data.impl.io.serialization.option.PrefixOrderingEnum; /** * Interface for the options of serializer that can declare prefixes diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManager.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManager.java index c2ee5398b..5c3e824d8 100644 --- a/src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManager.java +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/ModelDataManager.java @@ -1,11 +1,7 @@ package fr.inria.corese.core.next.datamanager.api; -import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.data.api.Model; import fr.inria.corese.core.next.datamanager.api.lifecycle.DataManagerLifecycle; -import fr.inria.corese.core.next.datamanager.api.operations.BulkOperations; -import fr.inria.corese.core.next.datamanager.api.operations.MetadataOperations; -import fr.inria.corese.core.next.datamanager.api.operations.MutationOperations; -import fr.inria.corese.core.next.datamanager.api.operations.QueryOperations; import fr.inria.corese.core.next.datamanager.api.transaction.TransactionManager; /** diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/BulkOperations.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/BulkOperations.java index 90c43c738..97058852b 100644 --- a/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/BulkOperations.java +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/BulkOperations.java @@ -1,7 +1,7 @@ package fr.inria.corese.core.next.datamanager.api.operations; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Statement; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Statement; import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; import fr.inria.corese.core.next.datamanager.api.support.model.StatementPattern; import fr.inria.corese.core.next.datamanager.api.support.model.MutationResult; diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/MetadataOperations.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/MetadataOperations.java index e2ae2c0b7..d3628fd56 100644 --- a/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/MetadataOperations.java +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/MetadataOperations.java @@ -1,8 +1,8 @@ package fr.inria.corese.core.next.datamanager.api.operations; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Value; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Value; import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; import fr.inria.corese.core.next.datamanager.api.support.model.ModelStatistics; diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/MutationOperations.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/MutationOperations.java index caae00897..960001187 100644 --- a/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/MutationOperations.java +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/MutationOperations.java @@ -1,9 +1,9 @@ package fr.inria.corese.core.next.datamanager.api.operations; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.api.Value; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.api.Value; import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; import fr.inria.corese.core.next.datamanager.api.support.model.MutationResult; diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/QueryOperations.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/QueryOperations.java index 182eac61c..085f41454 100644 --- a/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/QueryOperations.java +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/operations/QueryOperations.java @@ -1,7 +1,7 @@ package fr.inria.corese.core.next.datamanager.api.operations; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Statement; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Statement; import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; import fr.inria.corese.core.next.datamanager.api.support.model.StatementPattern; diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/support/model/MutationResult.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/support/model/MutationResult.java index db8d14514..dfbcdf8fa 100644 --- a/src/main/java/fr/inria/corese/core/next/datamanager/api/support/model/MutationResult.java +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/support/model/MutationResult.java @@ -1,6 +1,6 @@ package fr.inria.corese.core.next.datamanager.api.support.model; -import fr.inria.corese.core.next.api.Statement; +import fr.inria.corese.core.next.data.api.Statement; import java.util.ArrayList; import java.util.Collections; diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/api/support/model/StatementPattern.java b/src/main/java/fr/inria/corese/core/next/datamanager/api/support/model/StatementPattern.java index bcb7216c3..3f490d886 100644 --- a/src/main/java/fr/inria/corese/core/next/datamanager/api/support/model/StatementPattern.java +++ b/src/main/java/fr/inria/corese/core/next/datamanager/api/support/model/StatementPattern.java @@ -1,8 +1,8 @@ package fr.inria.corese.core.next.datamanager.api.support.model; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Value; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Value; import java.util.Arrays; import java.util.Objects; diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManager.java b/src/main/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManager.java index f83c80020..1a98e6276 100644 --- a/src/main/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManager.java +++ b/src/main/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManager.java @@ -1,6 +1,6 @@ package fr.inria.corese.core.next.datamanager.impl; -import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.data.api.Model; import fr.inria.corese.core.next.datamanager.api.ModelDataManager; import fr.inria.corese.core.next.datamanager.api.lifecycle.DataManagerLifecycle; import fr.inria.corese.core.next.datamanager.api.operations.BulkOperations; diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerBuilder.java b/src/main/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerBuilder.java index 19f08fe69..0c07527bd 100644 --- a/src/main/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerBuilder.java +++ b/src/main/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerBuilder.java @@ -1,6 +1,6 @@ package fr.inria.corese.core.next.datamanager.impl; -import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.data.api.Model; import fr.inria.corese.core.next.datamanager.api.ModelDataManager; import fr.inria.corese.core.next.datamanager.api.ModelDataManagerBuilder; import fr.inria.corese.core.next.datamanager.api.transaction.IsolationLevel; diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/impl/lifecycle/LifecycleManagerImpl.java b/src/main/java/fr/inria/corese/core/next/datamanager/impl/lifecycle/LifecycleManagerImpl.java index 9d64802d6..2134081f0 100644 --- a/src/main/java/fr/inria/corese/core/next/datamanager/impl/lifecycle/LifecycleManagerImpl.java +++ b/src/main/java/fr/inria/corese/core/next/datamanager/impl/lifecycle/LifecycleManagerImpl.java @@ -1,6 +1,6 @@ package fr.inria.corese.core.next.datamanager.impl.lifecycle; -import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.data.api.Model; import fr.inria.corese.core.next.datamanager.api.lifecycle.DataManagerLifecycle; import fr.inria.corese.core.next.datamanager.api.lifecycle.LifecycleState; import fr.inria.corese.core.next.datamanager.api.support.config.DataManagerConfig; diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/BulkOperationsImpl.java b/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/BulkOperationsImpl.java index a271779fc..dc6300366 100644 --- a/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/BulkOperationsImpl.java +++ b/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/BulkOperationsImpl.java @@ -1,10 +1,10 @@ package fr.inria.corese.core.next.datamanager.impl.operations; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.api.Value; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.api.Value; import fr.inria.corese.core.next.datamanager.api.operations.BulkOperations; import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; import fr.inria.corese.core.next.datamanager.api.support.exception.ErrorCode; diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/MetadataOperationsImpl.java b/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/MetadataOperationsImpl.java index b84deda30..12ccf35fd 100644 --- a/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/MetadataOperationsImpl.java +++ b/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/MetadataOperationsImpl.java @@ -1,9 +1,9 @@ package fr.inria.corese.core.next.datamanager.impl.operations; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Value; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Value; import fr.inria.corese.core.next.datamanager.api.operations.MetadataOperations; import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; import fr.inria.corese.core.next.datamanager.api.support.exception.ErrorCode; diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/MutationOperationsImpl.java b/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/MutationOperationsImpl.java index 3729b2df0..95c15de9d 100644 --- a/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/MutationOperationsImpl.java +++ b/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/MutationOperationsImpl.java @@ -1,10 +1,10 @@ package fr.inria.corese.core.next.datamanager.impl.operations; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.api.Value; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.api.Value; import fr.inria.corese.core.next.datamanager.api.operations.MutationOperations; import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; import fr.inria.corese.core.next.datamanager.api.support.exception.ErrorCode; diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/QueryOperationsImpl.java b/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/QueryOperationsImpl.java index 0eab5644e..91986c5df 100644 --- a/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/QueryOperationsImpl.java +++ b/src/main/java/fr/inria/corese/core/next/datamanager/impl/operations/QueryOperationsImpl.java @@ -1,10 +1,10 @@ package fr.inria.corese.core.next.datamanager.impl.operations; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.api.Value; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.api.Value; import fr.inria.corese.core.next.datamanager.api.operations.QueryOperations; import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; import fr.inria.corese.core.next.datamanager.api.support.exception.ErrorCode; diff --git a/src/main/java/fr/inria/corese/core/next/datamanager/impl/transaction/TransactionManagerImpl.java b/src/main/java/fr/inria/corese/core/next/datamanager/impl/transaction/TransactionManagerImpl.java index 5cf75e6ee..62eb7ae98 100644 --- a/src/main/java/fr/inria/corese/core/next/datamanager/impl/transaction/TransactionManagerImpl.java +++ b/src/main/java/fr/inria/corese/core/next/datamanager/impl/transaction/TransactionManagerImpl.java @@ -1,6 +1,6 @@ package fr.inria.corese.core.next.datamanager.impl.transaction; -import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.data.api.Model; import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; import fr.inria.corese.core.next.datamanager.api.support.exception.ErrorCode; import fr.inria.corese.core.next.datamanager.api.transaction.IsolationLevel; diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/literal/RDF.java b/src/main/java/fr/inria/corese/core/next/impl/common/literal/RDF.java deleted file mode 100644 index 62dc65334..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/common/literal/RDF.java +++ /dev/null @@ -1,30 +0,0 @@ -package fr.inria.corese.core.next.impl.common.literal; - -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.literal.CoreDatatype; - -/** - * Enumeration of the RDF datatypes usable as core datatypes of literals. - */ -public enum RDF implements CoreDatatype { - LANGSTRING(fr.inria.corese.core.next.impl.common.vocabulary.RDF.langString.getIRI()), - HTML(fr.inria.corese.core.next.impl.common.vocabulary.RDF.HTML.getIRI()), - JSON(fr.inria.corese.core.next.impl.common.vocabulary.RDF.JSON.getIRI()), - XML_LITERAL(fr.inria.corese.core.next.impl.common.vocabulary.RDF.XMLLiteral.getIRI()), - ; - private final IRI iri; - - /** - * Constructor for the RDF core datatype enum. - * - * @param iri the IRI of the datatype - */ - RDF(IRI iri) { - this.iri = iri; - } - - @Override - public IRI getIRI() { - return iri; - } -} diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/literal/XSD.java b/src/main/java/fr/inria/corese/core/next/impl/common/literal/XSD.java deleted file mode 100644 index 6d294bcaa..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/common/literal/XSD.java +++ /dev/null @@ -1,205 +0,0 @@ -/** - * Enumeration of the XML Schema Datatypes (XSD) to be used as core datatype in literals. - */ -package fr.inria.corese.core.next.impl.common.literal; - -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.literal.CoreDatatype; - -public enum XSD implements CoreDatatype { - /** - * true, false - */ - BOOLEAN(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdBoolean.getIRI()), - - /** - * Arbitrary-size integer numbers - */ - INTEGER(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdInteger.getIRI()), - - /** - * -9223372036854775808…+9223372036854775807 (64 bit) - */ - LONG(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdLong.getIRI()), - - /** - * Arbitrary-precision decimal numbers - */ - DECIMAL(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdDecimal.getIRI()), - - /** - * -2147483648…+2147483647 (32 bit) - */ - INT(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdInt.getIRI()), - - /** - * -32768…+32767 (16 bit) - */ - SHORT(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdShort.getIRI()), - - /** - * -128…+127 (8 bit) - */ - BYTE(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdByte.getIRI()), - - /** - * 32-bit floating point numbers incl. ±Inf, ±0, NaN - */ - FLOAT(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdFloat.getIRI()), - - /** - * 64-bit floating point numbers incl. ±Inf, ±0, NaN - */ - DOUBLE(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdDouble.getIRI()), - - /** - * Integer numbers >0 - */ - POSITIVE_INTEGER(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdPositiveInteger.getIRI()), - - /** - * Integer numbers <0 - */ - NEGATIVE_INTEGER(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdNegativeInteger.getIRI()), - - /** - * Integer numbers ≥0 - */ - NON_NEGATIVE_INTEGER(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdNonNegativeInteger.getIRI()), - - /** - * Integer numbers ≤0 - */ - NON_POSITIVE_INTEGER(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdNonPositiveInteger.getIRI()), - - /** - * 0…18446744073709551615 (64 bit) - */ - UNSIGNED_LONG(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdUnsignedLong.getIRI()), - - /** - * 0…4294967295 (32 bit) - */ - UNSIGNED_INT(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdUnsignedInt.getIRI()), - - /** - * 0…65535 (16 bit) - */ - UNSIGNED_SHORT(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdUnsignedShort.getIRI()), - - /** - * 0…255 (8 bit) - */ - UNSIGNED_BYTE(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdUnsignedByte.getIRI()), - - /** - * Duration of time - */ - DURATION(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdDuration.getIRI()), - - /** - * Duration of time (days, hours, minutes, seconds only) - */ - DAYTIME_DURATION(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdDayTimeDuration.getIRI()), - - /** - * Duration of time (months and years only) - */ - YEARMONTH_DURATION(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdYearMonthDuration.getIRI()), - - /** - * Dates (yyyy-mm-dd) with or without timezone - */ - DATE(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdDate.getIRI()), - - /** - * Date and time with or without timezone - */ - DATETIME(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdDateTime.getIRI()), - - /** - * Gregorian calendar day of the month - */ - DAY(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdDay.getIRI()), - - /** - * Gregorian calendar month - */ - MONTH(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdMonth.getIRI()), - - /** - * Gregorian calendar year - */ - YEAR(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdYear.getIRI()), - - /** - * Gregorian calendar year and month - */ - YEARMONTH(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdYearMonth.getIRI()), - - /** - * Gregorian calendar month and day - */ - MONTHDAY(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdMonthDay.getIRI()), - - /** - * Times (hh:mm:ss.sss…) with or without timezone - */ - TIME(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdTime.getIRI()), - - /** - * Hex-encoded binary data - */ - HEXBINARY(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdHexBinary.getIRI()), - - /** - * Base64-encoded binary data - */ - BASE64BINARY(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdBase64Binary.getIRI()), - - /** - * Resolved or relative URI and IRI references - */ - ANYURI(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdAnyURI.getIRI()), - - /** - * Character strings - */ - STRING(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdString.getIRI()), - - /** - * Whitespace-normalized strings - */ - NORMALIZEDSTRING(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdNormalizedString.getIRI()), - - /** - * Tokenized strings - */ - TOKEN(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdToken.getIRI()), - - /** - * Language tags per <a href="https://www.rfc-editor.org/rfc/rfc5646">rfc5646</> - */ - LANGUAGE(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdLanguage.getIRI()), - - /** - * XML Names - */ - NAME(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdName.getIRI()), - - /** - * XML NCNames - */ - NCNAME(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdNCName.getIRI()), - ; - IRI iri; - - XSD(IRI iri) { - this.iri = iri; - } - - @Override - public IRI getIRI() { - return iri; - } -} diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/query/DQPFactory.java b/src/main/java/fr/inria/corese/core/next/kgram/api/query/DQPFactory.java deleted file mode 100644 index 3d3ba805c..000000000 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/query/DQPFactory.java +++ /dev/null @@ -1,12 +0,0 @@ -package fr.inria.corese.core.next.kgram.api.query; - -import fr.inria.corese.core.next.kgram.core.BgpGenerator; - -/** - * @author corby - */ -public interface DQPFactory { - - BgpGenerator instance(); - -} diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/query/Provider.java b/src/main/java/fr/inria/corese/core/next/kgram/api/query/Provider.java deleted file mode 100644 index 26a3b72bb..000000000 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/query/Provider.java +++ /dev/null @@ -1,21 +0,0 @@ -package fr.inria.corese.core.next.kgram.api.query; - -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.core.Eval; -import fr.inria.corese.core.next.kgram.core.Exp; -import fr.inria.corese.core.next.kgram.core.Mappings; -import fr.inria.corese.core.next.kgram.core.SparqlException; - -/** - * Service Provider - * - * @author Olivier Corby, Edelweiss, INRIA 2011 - */ -public interface Provider { - @SuppressWarnings("unused") - default Mappings service(Node serv, Exp exp, Mappings map, Eval eval) - throws SparqlException { - return null; - } - -} diff --git a/src/main/java/fr/inria/corese/core/next/kgram/adapter/BindingAdapter.java b/src/main/java/fr/inria/corese/core/next/query/kgram/adapter/BindingAdapter.java similarity index 89% rename from src/main/java/fr/inria/corese/core/next/kgram/adapter/BindingAdapter.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/adapter/BindingAdapter.java index 11752ad0b..eee4b9922 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/adapter/BindingAdapter.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/adapter/BindingAdapter.java @@ -1,8 +1,10 @@ -package fr.inria.corese.core.next.kgram.adapter; +package fr.inria.corese.core.next.query.kgram.adapter; -import fr.inria.corese.core.next.kgram.api.core.BindingContext; -import fr.inria.corese.core.next.kgram.api.core.Expr; -import fr.inria.corese.core.next.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.core.BindingContext; +import fr.inria.corese.core.next.query.kgram.api.core.Expr; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.core.Exp; +import fr.inria.corese.core.next.query.kgram.core.Mappings; import fr.inria.corese.core.sparql.api.IDatatype; import fr.inria.corese.core.sparql.triple.function.term.Binding; @@ -156,16 +158,16 @@ public void setVisitor(Object visitor) { public void visit(Object e, Object g, Object m1, Object m2) { try { // Check for "next" kgram types - if (e instanceof fr.inria.corese.core.next.kgram.core.Exp && + if (e instanceof Exp && (g == null || g instanceof Node) && - (m1 == null || m1 instanceof fr.inria.corese.core.next.kgram.core.Mappings) && - (m2 == null || m2 instanceof fr.inria.corese.core.next.kgram.core.Mappings)) { + (m1 == null || m1 instanceof Mappings) && + (m2 == null || m2 instanceof Mappings)) { delegate.visit( - (fr.inria.corese.core.next.kgram.core.Exp) e, + (Exp) e, (Node) g, - (fr.inria.corese.core.next.kgram.core.Mappings) m1, - (fr.inria.corese.core.next.kgram.core.Mappings) m2 + (Mappings) m1, + (Mappings) m2 ); return; } diff --git a/src/main/java/fr/inria/corese/core/next/kgram/adapter/DatatypeAdapter.java b/src/main/java/fr/inria/corese/core/next/query/kgram/adapter/DatatypeAdapter.java similarity index 95% rename from src/main/java/fr/inria/corese/core/next/kgram/adapter/DatatypeAdapter.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/adapter/DatatypeAdapter.java index 6f51107d3..787c54a94 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/adapter/DatatypeAdapter.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/adapter/DatatypeAdapter.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.kgram.adapter; +package fr.inria.corese.core.next.query.kgram.adapter; -import fr.inria.corese.core.next.kgram.api.core.DatatypeValue; +import fr.inria.corese.core.next.query.kgram.api.core.DatatypeValue; import fr.inria.corese.core.sparql.api.IDatatype; import fr.inria.corese.core.sparql.exceptions.CoreseDatatypeException; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/core/BindingContext.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/BindingContext.java similarity index 98% rename from src/main/java/fr/inria/corese/core/next/kgram/api/core/BindingContext.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/core/BindingContext.java index e54eacbc1..15bb5e25f 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/core/BindingContext.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/BindingContext.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.api.core; +package fr.inria.corese.core.next.query.kgram.api.core; import java.util.Map; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/core/DatatypeValue.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/DatatypeValue.java similarity index 97% rename from src/main/java/fr/inria/corese/core/next/kgram/api/core/DatatypeValue.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/core/DatatypeValue.java index 8eba8a96b..a0461f088 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/core/DatatypeValue.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/DatatypeValue.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.api.core; +package fr.inria.corese.core.next.query.kgram.api.core; import fr.inria.corese.core.sparql.exceptions.CoreseDatatypeException; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/core/DatatypeValueFactory.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/DatatypeValueFactory.java similarity index 76% rename from src/main/java/fr/inria/corese/core/next/kgram/api/core/DatatypeValueFactory.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/core/DatatypeValueFactory.java index b7757eec5..d38956ec1 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/core/DatatypeValueFactory.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/DatatypeValueFactory.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.api.core; +package fr.inria.corese.core.next.query.kgram.api.core; import java.util.List; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/core/Edge.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Edge.java similarity index 98% rename from src/main/java/fr/inria/corese/core/next/kgram/api/core/Edge.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Edge.java index 52c0ded7b..848336110 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/core/Edge.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Edge.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.api.core; +package fr.inria.corese.core.next.query.kgram.api.core; import fr.inria.corese.core.sparql.api.IDatatype; import fr.inria.corese.core.sparql.triple.parser.AccessRight; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/core/ExpPattern.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/ExpPattern.java similarity index 74% rename from src/main/java/fr/inria/corese/core/next/kgram/api/core/ExpPattern.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/core/ExpPattern.java index e5ae878b1..c81e222e3 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/core/ExpPattern.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/ExpPattern.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.api.core; +package fr.inria.corese.core.next.query.kgram.api.core; import java.util.List; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/core/ExpType.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/ExpType.java similarity index 95% rename from src/main/java/fr/inria/corese/core/next/kgram/api/core/ExpType.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/core/ExpType.java index d41873b7c..23668c275 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/core/ExpType.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/ExpType.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.api.core; +package fr.inria.corese.core.next.query.kgram.api.core; /** * Types of expression of KGRAM query language diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/core/Expr.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Expr.java similarity index 90% rename from src/main/java/fr/inria/corese/core/next/kgram/api/core/Expr.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Expr.java index b07f0208b..970d7e091 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/core/Expr.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Expr.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.kgram.api.core; +package fr.inria.corese.core.next.query.kgram.api.core; -import fr.inria.corese.core.next.kgram.api.query.Environment; -import fr.inria.corese.core.next.kgram.api.query.Evaluator; -import fr.inria.corese.core.next.kgram.api.query.Producer; +import fr.inria.corese.core.next.query.kgram.api.query.Environment; +import fr.inria.corese.core.next.query.kgram.api.query.Evaluator; +import fr.inria.corese.core.next.query.kgram.api.query.Producer; import fr.inria.corese.core.sparql.api.IDatatype; import java.util.List; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/core/ExprType.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/ExprType.java similarity index 97% rename from src/main/java/fr/inria/corese/core/next/kgram/api/core/ExprType.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/core/ExprType.java index 4476c225f..b5e5703b4 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/core/ExprType.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/ExprType.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.api.core; +package fr.inria.corese.core.next.query.kgram.api.core; public interface ExprType { diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/core/Filter.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Filter.java similarity index 94% rename from src/main/java/fr/inria/corese/core/next/kgram/api/core/Filter.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Filter.java index 3d1317e37..1482d3a87 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/core/Filter.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Filter.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.api.core; +package fr.inria.corese.core.next.query.kgram.api.core; import fr.inria.corese.core.sparql.triple.parser.Expression; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/core/Graph.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Graph.java similarity index 79% rename from src/main/java/fr/inria/corese/core/next/kgram/api/core/Graph.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Graph.java index bc3e8db8c..95eb300b9 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/core/Graph.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Graph.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.api.core; +package fr.inria.corese.core.next.query.kgram.api.core; /** * diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/core/Loopable.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Loopable.java similarity index 70% rename from src/main/java/fr/inria/corese/core/next/kgram/api/core/Loopable.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Loopable.java index 31ee69731..3a034f54d 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/core/Loopable.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Loopable.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.api.core; +package fr.inria.corese.core.next.query.kgram.api.core; /** * Interface for (var in exp) {} diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/core/Node.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Node.java similarity index 91% rename from src/main/java/fr/inria/corese/core/next/kgram/api/core/Node.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Node.java index 017546f73..91b96636d 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/core/Node.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Node.java @@ -1,9 +1,9 @@ -package fr.inria.corese.core.next.kgram.api.core; +package fr.inria.corese.core.next.query.kgram.api.core; -import fr.inria.corese.core.next.kgram.path.Path; +import fr.inria.corese.core.next.query.kgram.path.Path; import fr.inria.corese.core.sparql.api.IDatatype; -import static fr.inria.corese.core.next.kgram.api.core.PointerType.NODE; +import static fr.inria.corese.core.next.query.kgram.api.core.PointerType.NODE; /** * Interface of Node provided by graph implementation diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/core/PointerType.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/PointerType.java similarity index 92% rename from src/main/java/fr/inria/corese/core/next/kgram/api/core/PointerType.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/core/PointerType.java index 2a22b598a..83dbce7ef 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/core/PointerType.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/PointerType.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.api.core; +package fr.inria.corese.core.next.query.kgram.api.core; import static fr.inria.corese.core.kgram.api.core.ExpType.DT; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/core/Pointerable.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Pointerable.java similarity index 81% rename from src/main/java/fr/inria/corese/core/next/kgram/api/core/Pointerable.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Pointerable.java index 0733a0c06..d2e217ba7 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/core/Pointerable.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Pointerable.java @@ -1,9 +1,9 @@ -package fr.inria.corese.core.next.kgram.api.core; +package fr.inria.corese.core.next.query.kgram.api.core; -import fr.inria.corese.core.next.kgram.core.Exp; -import fr.inria.corese.core.next.kgram.core.Mapping; -import fr.inria.corese.core.next.kgram.core.Mappings; -import fr.inria.corese.core.next.kgram.core.Query; +import fr.inria.corese.core.next.query.kgram.core.Exp; +import fr.inria.corese.core.next.query.kgram.core.Mapping; +import fr.inria.corese.core.next.query.kgram.core.Mappings; +import fr.inria.corese.core.next.query.kgram.core.Query; import java.util.ArrayList; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/core/Regex.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Regex.java similarity index 95% rename from src/main/java/fr/inria/corese/core/next/kgram/api/core/Regex.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Regex.java index 3a0b928e7..9f63b0f89 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/core/Regex.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/Regex.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.api.core; +package fr.inria.corese.core.next.query.kgram.api.core; import fr.inria.corese.core.sparql.api.IDatatype; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/core/TripleStore.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/TripleStore.java similarity index 78% rename from src/main/java/fr/inria/corese/core/next/kgram/api/core/TripleStore.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/core/TripleStore.java index 7ff5d870c..e781e043b 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/core/TripleStore.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/core/TripleStore.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.api.core; +package fr.inria.corese.core.next.query.kgram.api.core; import fr.inria.corese.core.sparql.api.IDatatype; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/query/AST.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/AST.java similarity index 81% rename from src/main/java/fr/inria/corese/core/next/kgram/api/query/AST.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/query/AST.java index d70abf892..362621c7d 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/query/AST.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/AST.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.api.query; +package fr.inria.corese.core.next.query.kgram.api.query; /** * Olivier Corby - Wimmics INRIA I3S - 2020 diff --git a/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/DQPFactory.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/DQPFactory.java new file mode 100644 index 000000000..db744464b --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/DQPFactory.java @@ -0,0 +1,12 @@ +package fr.inria.corese.core.next.query.kgram.api.query; + +import fr.inria.corese.core.next.query.kgram.core.BgpGenerator; + +/** + * @author corby + */ +public interface DQPFactory { + + BgpGenerator instance(); + +} diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/query/Environment.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Environment.java similarity index 80% rename from src/main/java/fr/inria/corese/core/next/kgram/api/query/Environment.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Environment.java index 0b539b89b..4750ddc07 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/query/Environment.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Environment.java @@ -1,13 +1,13 @@ -package fr.inria.corese.core.next.kgram.api.query; - -import fr.inria.corese.core.next.kgram.api.core.BindingContext; -import fr.inria.corese.core.next.kgram.api.core.Edge; -import fr.inria.corese.core.next.kgram.api.core.Expr; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.core.*; -import fr.inria.corese.core.next.kgram.event.EventManager; -import fr.inria.corese.core.next.kgram.path.Path; -import fr.inria.corese.core.next.kgram.tool.ApproximateSearchEnv; +package fr.inria.corese.core.next.query.kgram.api.query; + +import fr.inria.corese.core.next.query.kgram.api.core.BindingContext; +import fr.inria.corese.core.next.query.kgram.api.core.Edge; +import fr.inria.corese.core.next.query.kgram.api.core.Expr; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.core.*; +import fr.inria.corese.core.next.query.kgram.event.EventManager; +import fr.inria.corese.core.next.query.kgram.path.Path; +import fr.inria.corese.core.next.query.kgram.tool.ApproximateSearchEnv; import fr.inria.corese.core.sparql.api.IDatatype; import fr.inria.corese.core.sparql.triple.parser.ASTExtension; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/query/Evaluator.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Evaluator.java similarity index 79% rename from src/main/java/fr/inria/corese/core/next/kgram/api/query/Evaluator.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Evaluator.java index 41e6065e1..7936463f9 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/query/Evaluator.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Evaluator.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.kgram.api.query; +package fr.inria.corese.core.next.query.kgram.api.query; -import fr.inria.corese.core.next.kgram.core.Eval; +import fr.inria.corese.core.next.query.kgram.core.Eval; /** * Interface for the connector that evaluates filters diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/query/Graphable.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Graphable.java similarity index 74% rename from src/main/java/fr/inria/corese/core/next/kgram/api/query/Graphable.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Graphable.java index dd666cd29..5eb58f8e9 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/query/Graphable.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Graphable.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.api.query; +package fr.inria.corese.core.next.query.kgram.api.query; /** * Olivier Corby - Wimmics INRIA I3S - 2014 diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/query/Matcher.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Matcher.java similarity index 90% rename from src/main/java/fr/inria/corese/core/next/kgram/api/query/Matcher.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Matcher.java index ab6574572..8e22bf601 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/query/Matcher.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Matcher.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.kgram.api.query; +package fr.inria.corese.core.next.query.kgram.api.query; -import fr.inria.corese.core.next.kgram.api.core.Edge; -import fr.inria.corese.core.next.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.core.Edge; +import fr.inria.corese.core.next.query.kgram.api.core.Node; /** * Interface for the Matcher that checks conformity of candidate edges and nodes diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/query/Plugin.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Plugin.java similarity index 67% rename from src/main/java/fr/inria/corese/core/next/kgram/api/query/Plugin.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Plugin.java index 09f47a3f3..aec558c2b 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/query/Plugin.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Plugin.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.kgram.api.query; +package fr.inria.corese.core.next.query.kgram.api.query; -import fr.inria.corese.core.next.kgram.core.Exp; +import fr.inria.corese.core.next.query.kgram.core.Exp; /** * Draft KGRAM Plugin for EXTERN expression. diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/query/ProcessVisitor.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/ProcessVisitor.java similarity index 92% rename from src/main/java/fr/inria/corese/core/next/kgram/api/query/ProcessVisitor.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/query/ProcessVisitor.java index 57d62a4c1..996cd8c2a 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/query/ProcessVisitor.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/ProcessVisitor.java @@ -1,11 +1,11 @@ -package fr.inria.corese.core.next.kgram.api.query; - -import fr.inria.corese.core.next.kgram.api.core.Edge; -import fr.inria.corese.core.next.kgram.api.core.Expr; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.api.core.Pointerable; -import fr.inria.corese.core.next.kgram.core.*; -import fr.inria.corese.core.next.kgram.path.Path; +package fr.inria.corese.core.next.query.kgram.api.query; + +import fr.inria.corese.core.next.query.kgram.api.core.Edge; +import fr.inria.corese.core.next.query.kgram.api.core.Expr; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.core.Pointerable; +import fr.inria.corese.core.next.query.kgram.core.*; +import fr.inria.corese.core.next.query.kgram.path.Path; import fr.inria.corese.core.sparql.api.IDatatype; import java.util.List; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/query/Producer.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Producer.java similarity index 95% rename from src/main/java/fr/inria/corese/core/next/kgram/api/query/Producer.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Producer.java index 2da32d4a7..96aa9c169 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/query/Producer.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Producer.java @@ -1,10 +1,10 @@ -package fr.inria.corese.core.next.kgram.api.query; +package fr.inria.corese.core.next.query.kgram.api.query; -import fr.inria.corese.core.next.kgram.api.core.*; -import fr.inria.corese.core.next.kgram.core.Exp; -import fr.inria.corese.core.next.kgram.core.Mappings; -import fr.inria.corese.core.next.kgram.core.Query; -import fr.inria.corese.core.next.kgram.core.SparqlException; +import fr.inria.corese.core.next.query.kgram.api.core.*; +import fr.inria.corese.core.next.query.kgram.core.Exp; +import fr.inria.corese.core.next.query.kgram.core.Mappings; +import fr.inria.corese.core.next.query.kgram.core.Query; +import fr.inria.corese.core.next.query.kgram.core.SparqlException; import fr.inria.corese.core.sparql.api.IDatatype; import fr.inria.corese.core.sparql.datatype.DatatypeMap; diff --git a/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Provider.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Provider.java new file mode 100644 index 000000000..74c5de156 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Provider.java @@ -0,0 +1,21 @@ +package fr.inria.corese.core.next.query.kgram.api.query; + +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.core.Eval; +import fr.inria.corese.core.next.query.kgram.core.Exp; +import fr.inria.corese.core.next.query.kgram.core.Mappings; +import fr.inria.corese.core.next.query.kgram.core.SparqlException; + +/** + * Service Provider + * + * @author Olivier Corby, Edelweiss, INRIA 2011 + */ +public interface Provider { + @SuppressWarnings("unused") + default Mappings service(Node serv, Exp exp, Mappings map, Eval eval) + throws SparqlException { + return null; + } + +} diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/query/Result.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Result.java similarity index 59% rename from src/main/java/fr/inria/corese/core/next/kgram/api/query/Result.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Result.java index 458bbd934..9d8340f58 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/query/Result.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Result.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.kgram.api.query; +package fr.inria.corese.core.next.query.kgram.api.query; -import fr.inria.corese.core.next.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.core.Node; /** * Interface to KGRAM elementary result (a mapping) diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/query/Results.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Results.java similarity index 62% rename from src/main/java/fr/inria/corese/core/next/kgram/api/query/Results.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Results.java index 8371e334d..d967a5bc2 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/query/Results.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/Results.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.kgram.api.query; +package fr.inria.corese.core.next.query.kgram.api.query; -import fr.inria.corese.core.next.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.core.Node; import java.util.List; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/api/query/SPARQLEngine.java b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/SPARQLEngine.java similarity index 51% rename from src/main/java/fr/inria/corese/core/next/kgram/api/query/SPARQLEngine.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/api/query/SPARQLEngine.java index 895512859..3cf35043f 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/api/query/SPARQLEngine.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/api/query/SPARQLEngine.java @@ -1,10 +1,10 @@ -package fr.inria.corese.core.next.kgram.api.query; +package fr.inria.corese.core.next.query.kgram.api.query; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.core.Mapping; -import fr.inria.corese.core.next.kgram.core.Mappings; -import fr.inria.corese.core.next.kgram.core.Query; -import fr.inria.corese.core.next.kgram.core.SparqlException; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.core.Mapping; +import fr.inria.corese.core.next.query.kgram.core.Mappings; +import fr.inria.corese.core.next.query.kgram.core.Query; +import fr.inria.corese.core.next.query.kgram.core.SparqlException; /** * @author corby diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/BgpGenerator.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/BgpGenerator.java similarity index 54% rename from src/main/java/fr/inria/corese/core/next/kgram/core/BgpGenerator.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/BgpGenerator.java index 0e2172e55..2b043ded1 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/BgpGenerator.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/BgpGenerator.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.core; +package fr.inria.corese.core.next.query.kgram.core; public interface BgpGenerator { diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/Checker.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/Checker.java similarity index 88% rename from src/main/java/fr/inria/corese/core/next/kgram/core/Checker.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/Checker.java index 61e92fdff..901f82a26 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/Checker.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/Checker.java @@ -1,10 +1,10 @@ -package fr.inria.corese.core.next.kgram.core; +package fr.inria.corese.core.next.query.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.Edge; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.api.query.Environment; -import fr.inria.corese.core.next.kgram.api.query.Matcher; -import fr.inria.corese.core.next.kgram.api.query.Producer; +import fr.inria.corese.core.next.query.kgram.api.core.Edge; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.query.Environment; +import fr.inria.corese.core.next.query.kgram.api.query.Matcher; +import fr.inria.corese.core.next.query.kgram.api.query.Producer; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/CompleteSPARQL.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/CompleteSPARQL.java similarity index 94% rename from src/main/java/fr/inria/corese/core/next/kgram/core/CompleteSPARQL.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/CompleteSPARQL.java index 685a4acfb..259325870 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/CompleteSPARQL.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/CompleteSPARQL.java @@ -3,11 +3,11 @@ * and open the template in the editor. */ -package fr.inria.corese.core.next.kgram.core; +package fr.inria.corese.core.next.query.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.Filter; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.api.query.Producer; +import fr.inria.corese.core.next.query.kgram.api.core.Filter; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.query.Producer; import fr.inria.corese.core.sparql.api.IDatatype; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/Eval.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/Eval.java similarity index 99% rename from src/main/java/fr/inria/corese/core/next/kgram/core/Eval.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/Eval.java index b30967a64..120b71ed9 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/Eval.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/Eval.java @@ -1,17 +1,16 @@ -package fr.inria.corese.core.next.kgram.core; - -import fr.inria.corese.core.next.kgram.api.core.*; -import fr.inria.corese.core.next.kgram.api.query.*; -import fr.inria.corese.core.next.kgram.event.Event; -import fr.inria.corese.core.next.kgram.event.EventImpl; -import fr.inria.corese.core.next.kgram.event.EventManager; -import fr.inria.corese.core.next.kgram.event.ResultListener; -import fr.inria.corese.core.next.kgram.path.PathFinder; -import fr.inria.corese.core.next.kgram.tool.ResultsImpl; +package fr.inria.corese.core.next.query.kgram.core; + +import fr.inria.corese.core.next.query.kgram.adapter.DatatypeAdapter; +import fr.inria.corese.core.next.query.kgram.api.core.*; +import fr.inria.corese.core.next.query.kgram.api.query.*; +import fr.inria.corese.core.next.query.kgram.event.Event; +import fr.inria.corese.core.next.query.kgram.event.EventImpl; +import fr.inria.corese.core.next.query.kgram.event.EventManager; +import fr.inria.corese.core.next.query.kgram.event.ResultListener; +import fr.inria.corese.core.next.query.kgram.path.PathFinder; +import fr.inria.corese.core.next.query.kgram.tool.ResultsImpl; import fr.inria.corese.core.sparql.api.IDatatype; import fr.inria.corese.core.sparql.datatype.DatatypeMap; -import fr.inria.corese.core.next.kgram.api.core.BindingContext; -import fr.inria.corese.core.next.kgram.adapter.DatatypeAdapter; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -19,7 +18,7 @@ import java.util.HashMap; import java.util.List; -import static fr.inria.corese.core.next.kgram.api.core.ExprType.UNNEST; +import static fr.inria.corese.core.next.query.kgram.api.core.ExprType.UNNEST; /** * KGRAM Knowledge Graph Abstract Machine Compute graph homomorphism and diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/EvalGraph.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/EvalGraph.java similarity index 95% rename from src/main/java/fr/inria/corese/core/next/kgram/core/EvalGraph.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/EvalGraph.java index 2216653d3..af302af0f 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/EvalGraph.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/EvalGraph.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.kgram.core; +package fr.inria.corese.core.next.query.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.api.query.Matcher; -import fr.inria.corese.core.next.kgram.api.query.Producer; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.query.Matcher; +import fr.inria.corese.core.next.query.kgram.api.query.Producer; import java.util.List; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/EvalJoin.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/EvalJoin.java similarity index 96% rename from src/main/java/fr/inria/corese/core/next/kgram/core/EvalJoin.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/EvalJoin.java index a056c2c62..446a1c2ea 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/EvalJoin.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/EvalJoin.java @@ -1,9 +1,9 @@ -package fr.inria.corese.core.next.kgram.core; +package fr.inria.corese.core.next.query.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.api.query.Producer; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.query.Producer; -import static fr.inria.corese.core.next.kgram.core.Eval.STOP; +import static fr.inria.corese.core.next.query.kgram.core.Eval.STOP; /** * @author corby diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/EvalOptional.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/EvalOptional.java similarity index 94% rename from src/main/java/fr/inria/corese/core/next/kgram/core/EvalOptional.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/EvalOptional.java index 76abde3b2..a96cfceb8 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/EvalOptional.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/EvalOptional.java @@ -1,10 +1,10 @@ -package fr.inria.corese.core.next.kgram.core; +package fr.inria.corese.core.next.query.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.api.query.Environment; -import fr.inria.corese.core.next.kgram.api.query.Producer; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.query.Environment; +import fr.inria.corese.core.next.query.kgram.api.query.Producer; -import static fr.inria.corese.core.next.kgram.core.Eval.STOP; +import static fr.inria.corese.core.next.query.kgram.core.Eval.STOP; /** * @author corby diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/EvalSPARQL.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/EvalSPARQL.java similarity index 97% rename from src/main/java/fr/inria/corese/core/next/kgram/core/EvalSPARQL.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/EvalSPARQL.java index 75daba39a..3cfa47302 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/EvalSPARQL.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/EvalSPARQL.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.kgram.core; +package fr.inria.corese.core.next.query.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.api.query.Producer; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.query.Producer; import fr.inria.corese.core.sparql.api.IDatatype; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/Exp.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/Exp.java similarity index 99% rename from src/main/java/fr/inria/corese/core/next/kgram/core/Exp.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/Exp.java index 0d89f4ba8..6dd8858f1 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/Exp.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/Exp.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.kgram.core; +package fr.inria.corese.core.next.query.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.*; -import fr.inria.corese.core.next.kgram.api.query.Producer; +import fr.inria.corese.core.next.query.kgram.api.core.*; +import fr.inria.corese.core.next.query.kgram.api.query.Producer; import fr.inria.corese.core.sparql.triple.parser.Expression; import java.util.ArrayList; @@ -9,7 +9,7 @@ import java.util.Iterator; import java.util.List; -import static fr.inria.corese.core.next.kgram.api.core.PointerType.STATEMENT; +import static fr.inria.corese.core.next.query.kgram.api.core.PointerType.STATEMENT; /** * KGRAM/SPARQL expressions: bgp, union, optional, etc. diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/ExpEdge.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/ExpEdge.java similarity index 92% rename from src/main/java/fr/inria/corese/core/next/kgram/core/ExpEdge.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/ExpEdge.java index 58857ae6a..8fbc6eb21 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/ExpEdge.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/ExpEdge.java @@ -1,9 +1,9 @@ -package fr.inria.corese.core.next.kgram.core; +package fr.inria.corese.core.next.query.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.Expr; -import fr.inria.corese.core.next.kgram.api.core.ExprType; -import fr.inria.corese.core.next.kgram.api.core.Filter; -import fr.inria.corese.core.next.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.core.Expr; +import fr.inria.corese.core.next.query.kgram.api.core.ExprType; +import fr.inria.corese.core.next.query.kgram.api.core.Filter; +import fr.inria.corese.core.next.query.kgram.api.core.Node; import java.util.ArrayList; import java.util.List; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/ExpHandler.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/ExpHandler.java similarity index 97% rename from src/main/java/fr/inria/corese/core/next/kgram/core/ExpHandler.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/ExpHandler.java index 797848f9a..e7aa1aed3 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/ExpHandler.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/ExpHandler.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.kgram.core; +package fr.inria.corese.core.next.query.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.core.Node; import java.util.ArrayList; import java.util.List; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/Group.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/Group.java similarity index 97% rename from src/main/java/fr/inria/corese/core/next/kgram/core/Group.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/Group.java index 3809aeee9..33ec8b0f7 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/Group.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/Group.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.kgram.core; +package fr.inria.corese.core.next.query.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.core.Node; import java.util.*; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/IterableEntity.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/IterableEntity.java similarity index 81% rename from src/main/java/fr/inria/corese/core/next/kgram/core/IterableEntity.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/IterableEntity.java index 19ca68221..13ee8cc09 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/IterableEntity.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/IterableEntity.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.kgram.core; +package fr.inria.corese.core.next.query.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.Edge; -import fr.inria.corese.core.next.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.core.Edge; +import fr.inria.corese.core.next.query.kgram.api.core.Node; import java.util.Iterator; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/Mapping.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/Mapping.java similarity index 97% rename from src/main/java/fr/inria/corese/core/next/kgram/core/Mapping.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/Mapping.java index 1def8505c..d1a2d422a 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/Mapping.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/Mapping.java @@ -1,18 +1,19 @@ -package fr.inria.corese.core.next.kgram.core; - -import fr.inria.corese.core.next.kgram.api.core.*; -import fr.inria.corese.core.next.kgram.api.query.Environment; -import fr.inria.corese.core.next.kgram.api.query.ProcessVisitor; -import fr.inria.corese.core.next.kgram.api.query.Result; -import fr.inria.corese.core.next.kgram.path.Path; -import fr.inria.corese.core.next.kgram.tool.ApproximateSearchEnv; -import fr.inria.corese.core.next.kgram.tool.EnvironmentImpl; +package fr.inria.corese.core.next.query.kgram.core; + +import fr.inria.corese.core.next.query.kgram.adapter.BindingAdapter; +import fr.inria.corese.core.next.query.kgram.api.core.*; +import fr.inria.corese.core.next.query.kgram.api.query.Environment; +import fr.inria.corese.core.next.query.kgram.api.query.ProcessVisitor; +import fr.inria.corese.core.next.query.kgram.api.query.Result; +import fr.inria.corese.core.next.query.kgram.path.Path; +import fr.inria.corese.core.next.query.kgram.tool.ApproximateSearchEnv; +import fr.inria.corese.core.next.query.kgram.tool.EnvironmentImpl; import fr.inria.corese.core.sparql.api.IDatatype; import fr.inria.corese.core.sparql.triple.parser.ASTExtension; import java.util.*; -import static fr.inria.corese.core.next.kgram.api.core.PointerType.MAPPING; +import static fr.inria.corese.core.next.query.kgram.api.core.PointerType.MAPPING; /** * An elementary result of a query or a subquery @@ -121,9 +122,9 @@ public static Mapping create(Node qnode, Node node) { * variable ?x appears twice in the stack because it is redefined in the let clause */ public static Mapping create(Query q, BindingContext b) { - if (b instanceof fr.inria.corese.core.next.kgram.adapter.BindingAdapter) { + if (b instanceof BindingAdapter) { fr.inria.corese.core.sparql.triple.function.term.Binding binding = - ((fr.inria.corese.core.next.kgram.adapter.BindingAdapter) b).delegate(); + ((BindingAdapter) b).delegate(); ArrayList lvar = new ArrayList<>(); ArrayList lval = new ArrayList<>(); diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/MappingSet.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/MappingSet.java similarity index 98% rename from src/main/java/fr/inria/corese/core/next/kgram/core/MappingSet.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/MappingSet.java index e6bd5c25c..32f3949bf 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/MappingSet.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/MappingSet.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.kgram.core; +package fr.inria.corese.core.next.query.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.core.Node; import java.util.ArrayList; import java.util.HashMap; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/Mappings.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/Mappings.java similarity index 98% rename from src/main/java/fr/inria/corese/core/next/kgram/core/Mappings.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/Mappings.java index ba07c78e3..201c1bd23 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/Mappings.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/Mappings.java @@ -1,12 +1,12 @@ -package fr.inria.corese.core.next.kgram.core; - -import fr.inria.corese.core.next.kgram.api.core.*; -import fr.inria.corese.core.next.kgram.api.query.Environment; -import fr.inria.corese.core.next.kgram.api.query.Evaluator; -import fr.inria.corese.core.next.kgram.api.query.Producer; -import fr.inria.corese.core.next.kgram.event.Event; -import fr.inria.corese.core.next.kgram.event.EventImpl; -import fr.inria.corese.core.next.kgram.event.EventManager; +package fr.inria.corese.core.next.query.kgram.core; + +import fr.inria.corese.core.next.query.kgram.api.core.*; +import fr.inria.corese.core.next.query.kgram.api.query.Environment; +import fr.inria.corese.core.next.query.kgram.api.query.Evaluator; +import fr.inria.corese.core.next.query.kgram.api.query.Producer; +import fr.inria.corese.core.next.query.kgram.event.Event; +import fr.inria.corese.core.next.query.kgram.event.EventImpl; +import fr.inria.corese.core.next.query.kgram.event.EventManager; import fr.inria.corese.core.sparql.api.IDatatype; import fr.inria.corese.core.sparql.triple.parser.ASTQuery; import fr.inria.corese.core.sparql.triple.parser.Context; @@ -14,7 +14,7 @@ import java.util.*; -import static fr.inria.corese.core.next.kgram.api.core.PointerType.MAPPINGS; +import static fr.inria.corese.core.next.query.kgram.api.core.PointerType.MAPPINGS; /* * Manage list of Mapping, result of a query diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/Memory.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/Memory.java similarity index 98% rename from src/main/java/fr/inria/corese/core/next/kgram/core/Memory.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/Memory.java index c7edccb82..0a98a6cc8 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/Memory.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/Memory.java @@ -1,10 +1,11 @@ -package fr.inria.corese.core.next.kgram.core; - -import fr.inria.corese.core.next.kgram.api.core.*; -import fr.inria.corese.core.next.kgram.api.query.*; -import fr.inria.corese.core.next.kgram.event.EventManager; -import fr.inria.corese.core.next.kgram.path.Path; -import fr.inria.corese.core.next.kgram.tool.ApproximateSearchEnv; +package fr.inria.corese.core.next.query.kgram.core; + +import fr.inria.corese.core.next.query.kgram.adapter.BindingAdapter; +import fr.inria.corese.core.next.query.kgram.api.core.*; +import fr.inria.corese.core.next.query.kgram.api.query.*; +import fr.inria.corese.core.next.query.kgram.event.EventManager; +import fr.inria.corese.core.next.query.kgram.path.Path; +import fr.inria.corese.core.next.query.kgram.tool.ApproximateSearchEnv; import fr.inria.corese.core.sparql.api.IDatatype; import fr.inria.corese.core.sparql.triple.function.term.Binding; import fr.inria.corese.core.sparql.triple.parser.ASTExtension; @@ -316,8 +317,8 @@ void copy(Binding bind, Exp exp) { * Copy this BindingContext local variable stack into this memory */ void copy(BindingContext bindCtx, Exp exp) { - if (bindCtx instanceof fr.inria.corese.core.next.kgram.adapter.BindingAdapter) { - Binding binding = ((fr.inria.corese.core.next.kgram.adapter.BindingAdapter) bindCtx).delegate(); + if (bindCtx instanceof BindingAdapter) { + Binding binding = ((BindingAdapter) bindCtx).delegate(); copy(binding, exp); } else { List list = exp.getNodes(); diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/Merge.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/Merge.java similarity index 97% rename from src/main/java/fr/inria/corese/core/next/kgram/core/Merge.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/Merge.java index 9c4144678..9f75b7db2 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/Merge.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/Merge.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.core; +package fr.inria.corese.core.next.query.kgram.core; import java.util.ArrayList; import java.util.Collection; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/PointerObject.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/PointerObject.java similarity index 53% rename from src/main/java/fr/inria/corese/core/next/kgram/core/PointerObject.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/PointerObject.java index 26219d39a..1b89acf51 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/PointerObject.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/PointerObject.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.kgram.core; +package fr.inria.corese.core.next.query.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.Pointerable; +import fr.inria.corese.core.next.query.kgram.api.core.Pointerable; /** * diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/ProcessVisitorDefault.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/ProcessVisitorDefault.java similarity index 91% rename from src/main/java/fr/inria/corese/core/next/kgram/core/ProcessVisitorDefault.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/ProcessVisitorDefault.java index a7cf8be9d..78d230061 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/ProcessVisitorDefault.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/ProcessVisitorDefault.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.kgram.core; +package fr.inria.corese.core.next.query.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.api.query.ProcessVisitor; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.query.ProcessVisitor; import fr.inria.corese.core.sparql.api.IDatatype; import fr.inria.corese.core.sparql.triple.parser.Metadata; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/Query.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/Query.java similarity index 99% rename from src/main/java/fr/inria/corese/core/next/kgram/core/Query.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/Query.java index 1aff6e9c2..e3922c6b1 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/Query.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/Query.java @@ -1,12 +1,12 @@ -package fr.inria.corese.core.next.kgram.core; - -import fr.inria.corese.core.next.kgram.api.core.*; -import fr.inria.corese.core.next.kgram.api.core.Filter; -import fr.inria.corese.core.next.kgram.api.query.DQPFactory; -import fr.inria.corese.core.next.kgram.api.query.Matcher; -import fr.inria.corese.core.next.kgram.api.query.Producer; -import fr.inria.corese.core.next.kgram.filter.Compile; -import fr.inria.corese.core.next.kgram.tool.Message; +package fr.inria.corese.core.next.query.kgram.core; + +import fr.inria.corese.core.next.query.kgram.api.core.*; +import fr.inria.corese.core.next.query.kgram.api.core.Filter; +import fr.inria.corese.core.next.query.kgram.api.query.DQPFactory; +import fr.inria.corese.core.next.query.kgram.api.query.Matcher; +import fr.inria.corese.core.next.query.kgram.api.query.Producer; +import fr.inria.corese.core.next.query.kgram.filter.Compile; +import fr.inria.corese.core.next.query.kgram.tool.Message; import fr.inria.corese.core.sparql.triple.parser.*; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/QuerySorter.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/QuerySorter.java similarity index 98% rename from src/main/java/fr/inria/corese/core/next/kgram/core/QuerySorter.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/QuerySorter.java index d37c9419c..e2666701c 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/QuerySorter.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/QuerySorter.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.kgram.core; +package fr.inria.corese.core.next.query.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.*; -import fr.inria.corese.core.next.kgram.api.query.Producer; -import fr.inria.corese.core.next.kgram.filter.Compile; +import fr.inria.corese.core.next.query.kgram.api.core.*; +import fr.inria.corese.core.next.query.kgram.api.query.Producer; +import fr.inria.corese.core.next.query.kgram.filter.Compile; import java.util.ArrayList; import java.util.List; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/Sorter.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/Sorter.java similarity index 96% rename from src/main/java/fr/inria/corese/core/next/kgram/core/Sorter.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/Sorter.java index 54447cc92..30ff88feb 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/Sorter.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/Sorter.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.kgram.core; +package fr.inria.corese.core.next.query.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.core.Node; import java.util.ArrayList; import java.util.List; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/SorterNew.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/SorterNew.java similarity index 82% rename from src/main/java/fr/inria/corese/core/next/kgram/core/SorterNew.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/SorterNew.java index 6a59c4dc9..763c4e18b 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/SorterNew.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/SorterNew.java @@ -1,13 +1,13 @@ -package fr.inria.corese.core.next.kgram.core; +package fr.inria.corese.core.next.query.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.ExpType; -import fr.inria.corese.core.next.kgram.api.query.Producer; -import fr.inria.corese.core.next.kgram.sorter.core.IEstimate; -import fr.inria.corese.core.next.kgram.sorter.core.ISort; -import fr.inria.corese.core.next.kgram.sorter.core.QPGNode; -import fr.inria.corese.core.next.kgram.sorter.core.QPGraph; -import fr.inria.corese.core.next.kgram.sorter.impl.qpv1.DepthFirstBestSearch; -import fr.inria.corese.core.next.kgram.sorter.impl.qpv1.HeuristicsBasedEstimation; +import fr.inria.corese.core.next.query.kgram.api.core.ExpType; +import fr.inria.corese.core.next.query.kgram.api.query.Producer; +import fr.inria.corese.core.next.query.kgram.sorter.core.IEstimate; +import fr.inria.corese.core.next.query.kgram.sorter.core.ISort; +import fr.inria.corese.core.next.query.kgram.sorter.core.QPGNode; +import fr.inria.corese.core.next.query.kgram.sorter.core.QPGraph; +import fr.inria.corese.core.next.query.kgram.sorter.impl.qpv1.DepthFirstBestSearch; +import fr.inria.corese.core.next.query.kgram.sorter.impl.qpv1.HeuristicsBasedEstimation; import java.util.ArrayList; import java.util.LinkedHashMap; @@ -15,7 +15,7 @@ import java.util.Map; import java.util.Map.Entry; -import static fr.inria.corese.core.next.kgram.sorter.core.Const.plannable; +import static fr.inria.corese.core.next.query.kgram.sorter.core.Const.plannable; /** * A new sorter for QP diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/SparqlException.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/SparqlException.java similarity index 93% rename from src/main/java/fr/inria/corese/core/next/kgram/core/SparqlException.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/SparqlException.java index fd4d7fc6a..c765d140f 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/SparqlException.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/SparqlException.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.core; +package fr.inria.corese.core.next.query.kgram.core; /** * diff --git a/src/main/java/fr/inria/corese/core/next/kgram/core/Stack.java b/src/main/java/fr/inria/corese/core/next/query/kgram/core/Stack.java similarity index 90% rename from src/main/java/fr/inria/corese/core/next/kgram/core/Stack.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/core/Stack.java index 36c293a8c..89216d3ba 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/core/Stack.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/core/Stack.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.kgram.core; +package fr.inria.corese.core.next.query.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.ExpType; +import fr.inria.corese.core.next.query.kgram.api.core.ExpType; import java.util.ArrayList; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/event/Event.java b/src/main/java/fr/inria/corese/core/next/query/kgram/event/Event.java similarity index 90% rename from src/main/java/fr/inria/corese/core/next/kgram/event/Event.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/event/Event.java index a5723375a..835744b29 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/event/Event.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/event/Event.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.kgram.event; +package fr.inria.corese.core.next.query.kgram.event; -import fr.inria.corese.core.next.kgram.core.Exp; +import fr.inria.corese.core.next.query.kgram.core.Exp; /** * Event to trace KGRAM execution diff --git a/src/main/java/fr/inria/corese/core/next/kgram/event/EventImpl.java b/src/main/java/fr/inria/corese/core/next/query/kgram/event/EventImpl.java similarity index 94% rename from src/main/java/fr/inria/corese/core/next/kgram/event/EventImpl.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/event/EventImpl.java index 432d2cd97..307215047 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/event/EventImpl.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/event/EventImpl.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.kgram.event; +package fr.inria.corese.core.next.query.kgram.event; -import fr.inria.corese.core.next.kgram.core.Exp; -import fr.inria.corese.core.next.kgram.core.Stack; +import fr.inria.corese.core.next.query.kgram.core.Exp; +import fr.inria.corese.core.next.query.kgram.core.Stack; import java.util.Hashtable; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/event/EventListener.java b/src/main/java/fr/inria/corese/core/next/query/kgram/event/EventListener.java similarity index 83% rename from src/main/java/fr/inria/corese/core/next/kgram/event/EventListener.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/event/EventListener.java index c0f34daa4..b476e28f4 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/event/EventListener.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/event/EventListener.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.event; +package fr.inria.corese.core.next.query.kgram.event; /** diff --git a/src/main/java/fr/inria/corese/core/next/kgram/event/EventManager.java b/src/main/java/fr/inria/corese/core/next/query/kgram/event/EventManager.java similarity index 95% rename from src/main/java/fr/inria/corese/core/next/kgram/event/EventManager.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/event/EventManager.java index 51ab7dd39..c89ac8e1d 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/event/EventManager.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/event/EventManager.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.event; +package fr.inria.corese.core.next.query.kgram.event; import java.util.ArrayList; import java.util.Iterator; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/event/ResultListener.java b/src/main/java/fr/inria/corese/core/next/query/kgram/event/ResultListener.java similarity index 64% rename from src/main/java/fr/inria/corese/core/next/kgram/event/ResultListener.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/event/ResultListener.java index 6921d6dad..8e6c1c1e5 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/event/ResultListener.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/event/ResultListener.java @@ -1,11 +1,11 @@ -package fr.inria.corese.core.next.kgram.event; +package fr.inria.corese.core.next.query.kgram.event; -import fr.inria.corese.core.next.kgram.api.core.Edge; -import fr.inria.corese.core.next.kgram.api.core.Expr; -import fr.inria.corese.core.next.kgram.api.core.Regex; -import fr.inria.corese.core.next.kgram.api.query.Environment; -import fr.inria.corese.core.next.kgram.core.Exp; -import fr.inria.corese.core.next.kgram.path.Path; +import fr.inria.corese.core.next.query.kgram.api.core.Edge; +import fr.inria.corese.core.next.query.kgram.api.core.Expr; +import fr.inria.corese.core.next.query.kgram.api.core.Regex; +import fr.inria.corese.core.next.query.kgram.api.query.Environment; +import fr.inria.corese.core.next.query.kgram.core.Exp; +import fr.inria.corese.core.next.query.kgram.path.Path; /** * Result Listener to process KGRAM result on the fly diff --git a/src/main/java/fr/inria/corese/core/next/kgram/event/User.java b/src/main/java/fr/inria/corese/core/next/query/kgram/event/User.java similarity index 75% rename from src/main/java/fr/inria/corese/core/next/kgram/event/User.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/event/User.java index 1faedabd4..c4a3dc127 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/event/User.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/event/User.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.event; +package fr.inria.corese.core.next.query.kgram.event; /** * Model user interaction with debugger diff --git a/src/main/java/fr/inria/corese/core/next/kgram/filter/Checker.java b/src/main/java/fr/inria/corese/core/next/query/kgram/filter/Checker.java similarity index 94% rename from src/main/java/fr/inria/corese/core/next/kgram/filter/Checker.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/filter/Checker.java index ef299678c..29ba6b700 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/filter/Checker.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/filter/Checker.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.kgram.filter; +package fr.inria.corese.core.next.query.kgram.filter; -import fr.inria.corese.core.next.kgram.api.core.Expr; -import fr.inria.corese.core.next.kgram.api.core.ExprType; -import fr.inria.corese.core.next.kgram.core.Query; +import fr.inria.corese.core.next.query.kgram.api.core.Expr; +import fr.inria.corese.core.next.query.kgram.api.core.ExprType; +import fr.inria.corese.core.next.query.kgram.core.Query; import java.util.ArrayList; import java.util.List; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/filter/Compile.java b/src/main/java/fr/inria/corese/core/next/query/kgram/filter/Compile.java similarity index 96% rename from src/main/java/fr/inria/corese/core/next/kgram/filter/Compile.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/filter/Compile.java index d7c9a231e..f8645e2be 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/filter/Compile.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/filter/Compile.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.kgram.filter; +package fr.inria.corese.core.next.query.kgram.filter; -import fr.inria.corese.core.next.kgram.api.core.*; -import fr.inria.corese.core.next.kgram.core.Exp; -import fr.inria.corese.core.next.kgram.core.Query; +import fr.inria.corese.core.next.query.kgram.api.core.*; +import fr.inria.corese.core.next.query.kgram.core.Exp; +import fr.inria.corese.core.next.query.kgram.core.Query; import java.util.ArrayList; import java.util.List; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/filter/Extension.java b/src/main/java/fr/inria/corese/core/next/query/kgram/filter/Extension.java similarity index 85% rename from src/main/java/fr/inria/corese/core/next/kgram/filter/Extension.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/filter/Extension.java index 389da1a25..bad183424 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/filter/Extension.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/filter/Extension.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.kgram.filter; +package fr.inria.corese.core.next.query.kgram.filter; -import fr.inria.corese.core.next.kgram.api.core.Expr; +import fr.inria.corese.core.next.query.kgram.api.core.Expr; import fr.inria.corese.core.sparql.api.IDatatype; /** diff --git a/src/main/java/fr/inria/corese/core/next/kgram/filter/MatchBind.java b/src/main/java/fr/inria/corese/core/next/query/kgram/filter/MatchBind.java similarity index 91% rename from src/main/java/fr/inria/corese/core/next/kgram/filter/MatchBind.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/filter/MatchBind.java index 7276ccced..1233d55b9 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/filter/MatchBind.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/filter/MatchBind.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.kgram.filter; +package fr.inria.corese.core.next.query.kgram.filter; -import fr.inria.corese.core.next.kgram.api.core.Expr; +import fr.inria.corese.core.next.query.kgram.api.core.Expr; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/filter/Matcher.java b/src/main/java/fr/inria/corese/core/next/query/kgram/filter/Matcher.java similarity index 97% rename from src/main/java/fr/inria/corese/core/next/kgram/filter/Matcher.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/filter/Matcher.java index 5be940352..3c521b53c 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/filter/Matcher.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/filter/Matcher.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.kgram.filter; +package fr.inria.corese.core.next.query.kgram.filter; -import fr.inria.corese.core.next.kgram.api.core.Expr; -import fr.inria.corese.core.next.kgram.api.core.ExprType; +import fr.inria.corese.core.next.query.kgram.api.core.Expr; +import fr.inria.corese.core.next.query.kgram.api.core.ExprType; /** diff --git a/src/main/java/fr/inria/corese/core/next/kgram/filter/Pattern.java b/src/main/java/fr/inria/corese/core/next/query/kgram/filter/Pattern.java similarity index 93% rename from src/main/java/fr/inria/corese/core/next/kgram/filter/Pattern.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/filter/Pattern.java index d240bd8ac..af0b6e012 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/filter/Pattern.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/filter/Pattern.java @@ -1,10 +1,10 @@ -package fr.inria.corese.core.next.kgram.filter; +package fr.inria.corese.core.next.query.kgram.filter; -import fr.inria.corese.core.next.kgram.api.core.*; -import fr.inria.corese.core.next.kgram.api.query.Environment; -import fr.inria.corese.core.next.kgram.api.query.Evaluator; -import fr.inria.corese.core.next.kgram.api.query.Producer; -import fr.inria.corese.core.next.kgram.core.Exp; +import fr.inria.corese.core.next.query.kgram.api.core.*; +import fr.inria.corese.core.next.query.kgram.api.query.Environment; +import fr.inria.corese.core.next.query.kgram.api.query.Evaluator; +import fr.inria.corese.core.next.query.kgram.api.query.Producer; +import fr.inria.corese.core.next.query.kgram.core.Exp; import fr.inria.corese.core.sparql.api.IDatatype; import java.util.ArrayList; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/path/Buffer.java b/src/main/java/fr/inria/corese/core/next/query/kgram/path/Buffer.java similarity index 92% rename from src/main/java/fr/inria/corese/core/next/kgram/path/Buffer.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/path/Buffer.java index 73b070e0d..98a1dc80d 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/path/Buffer.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/path/Buffer.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.kgram.path; +package fr.inria.corese.core.next.query.kgram.path; -import fr.inria.corese.core.next.kgram.core.Mapping; +import fr.inria.corese.core.next.query.kgram.core.Mapping; import java.util.Iterator; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/path/GraphPath.java b/src/main/java/fr/inria/corese/core/next/query/kgram/path/GraphPath.java similarity index 77% rename from src/main/java/fr/inria/corese/core/next/kgram/path/GraphPath.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/path/GraphPath.java index bbbe81c33..8d5a6d1f8 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/path/GraphPath.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/path/GraphPath.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.kgram.path; +package fr.inria.corese.core.next.query.kgram.path; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.api.query.Environment; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.query.Environment; /** * Draft to compute path in the graph diff --git a/src/main/java/fr/inria/corese/core/next/kgram/path/Path.java b/src/main/java/fr/inria/corese/core/next/query/kgram/path/Path.java similarity index 87% rename from src/main/java/fr/inria/corese/core/next/kgram/path/Path.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/path/Path.java index e23d325f8..1adaba45c 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/path/Path.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/path/Path.java @@ -1,18 +1,18 @@ -package fr.inria.corese.core.next.kgram.path; +package fr.inria.corese.core.next.query.kgram.path; -import fr.inria.corese.core.next.kgram.api.core.Edge; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.api.core.PointerType; -import fr.inria.corese.core.next.kgram.api.core.Pointerable; -import fr.inria.corese.core.next.kgram.api.query.Environment; -import fr.inria.corese.core.next.kgram.api.query.Producer; -import fr.inria.corese.core.next.kgram.tool.EdgeInv; -import fr.inria.corese.core.next.kgram.tool.ProducerDefault; +import fr.inria.corese.core.next.query.kgram.api.core.Edge; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.core.PointerType; +import fr.inria.corese.core.next.query.kgram.api.core.Pointerable; +import fr.inria.corese.core.next.query.kgram.api.query.Environment; +import fr.inria.corese.core.next.query.kgram.api.query.Producer; +import fr.inria.corese.core.next.query.kgram.tool.EdgeInv; +import fr.inria.corese.core.next.query.kgram.tool.ProducerDefault; import java.util.ArrayList; import java.util.List; -import static fr.inria.corese.core.next.kgram.api.core.PointerType.PATH; +import static fr.inria.corese.core.next.query.kgram.api.core.PointerType.PATH; /** * List of relations between two resources found by path Can be used as a diff --git a/src/main/java/fr/inria/corese/core/next/kgram/path/PathFinder.java b/src/main/java/fr/inria/corese/core/next/query/kgram/path/PathFinder.java similarity index 97% rename from src/main/java/fr/inria/corese/core/next/kgram/path/PathFinder.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/path/PathFinder.java index 6f7f395f4..47440a774 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/path/PathFinder.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/path/PathFinder.java @@ -1,17 +1,17 @@ -package fr.inria.corese.core.next.kgram.path; - -import fr.inria.corese.core.next.kgram.api.core.Edge; -import fr.inria.corese.core.next.kgram.api.core.Filter; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.api.core.Regex; -import fr.inria.corese.core.next.kgram.api.query.Environment; -import fr.inria.corese.core.next.kgram.api.query.Evaluator; -import fr.inria.corese.core.next.kgram.api.query.Matcher; -import fr.inria.corese.core.next.kgram.api.query.Producer; -import fr.inria.corese.core.next.kgram.core.*; -import fr.inria.corese.core.next.kgram.event.EventManager; -import fr.inria.corese.core.next.kgram.event.ResultListener; -import fr.inria.corese.core.next.kgram.tool.EdgeInv; +package fr.inria.corese.core.next.query.kgram.path; + +import fr.inria.corese.core.next.query.kgram.api.core.Edge; +import fr.inria.corese.core.next.query.kgram.api.core.Filter; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.core.Regex; +import fr.inria.corese.core.next.query.kgram.api.query.Environment; +import fr.inria.corese.core.next.query.kgram.api.query.Evaluator; +import fr.inria.corese.core.next.query.kgram.api.query.Matcher; +import fr.inria.corese.core.next.query.kgram.api.query.Producer; +import fr.inria.corese.core.next.query.kgram.core.*; +import fr.inria.corese.core.next.query.kgram.event.EventManager; +import fr.inria.corese.core.next.query.kgram.event.ResultListener; +import fr.inria.corese.core.next.query.kgram.tool.EdgeInv; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/path/Record.java b/src/main/java/fr/inria/corese/core/next/query/kgram/path/Record.java similarity index 88% rename from src/main/java/fr/inria/corese/core/next/kgram/path/Record.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/path/Record.java index 781bb9057..f17b03a0b 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/path/Record.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/path/Record.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.kgram.path; +package fr.inria.corese.core.next.query.kgram.path; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.api.core.Regex; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.core.Regex; import java.util.ArrayList; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/path/Stack.java b/src/main/java/fr/inria/corese/core/next/query/kgram/path/Stack.java similarity index 87% rename from src/main/java/fr/inria/corese/core/next/kgram/path/Stack.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/path/Stack.java index eab490979..4132ef5c8 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/path/Stack.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/path/Stack.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.path; +package fr.inria.corese.core.next.query.kgram.path; import java.util.ArrayList; import java.util.List; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/path/State.java b/src/main/java/fr/inria/corese/core/next/query/kgram/path/State.java similarity index 90% rename from src/main/java/fr/inria/corese/core/next/kgram/path/State.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/path/State.java index b6b89e946..c1fc721d1 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/path/State.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/path/State.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.path; +package fr.inria.corese.core.next.query.kgram.path; import java.util.ArrayList; import java.util.List; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/path/Step.java b/src/main/java/fr/inria/corese/core/next/query/kgram/path/Step.java similarity index 88% rename from src/main/java/fr/inria/corese/core/next/kgram/path/Step.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/path/Step.java index 5e559d6bd..28207dd18 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/path/Step.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/path/Step.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.kgram.path; +package fr.inria.corese.core.next.query.kgram.path; -import fr.inria.corese.core.next.kgram.api.core.Regex; +import fr.inria.corese.core.next.query.kgram.api.core.Regex; import java.util.List; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/path/Visit.java b/src/main/java/fr/inria/corese/core/next/query/kgram/path/Visit.java similarity index 98% rename from src/main/java/fr/inria/corese/core/next/kgram/path/Visit.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/path/Visit.java index 257a21d76..12796d659 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/path/Visit.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/path/Visit.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.kgram.path; +package fr.inria.corese.core.next.query.kgram.path; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.api.core.Regex; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.core.Regex; import java.util.*; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/sorter/core/AbstractCostModel.java b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/AbstractCostModel.java similarity index 92% rename from src/main/java/fr/inria/corese/core/next/kgram/sorter/core/AbstractCostModel.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/AbstractCostModel.java index baaf4601e..4b3c787ed 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/sorter/core/AbstractCostModel.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/AbstractCostModel.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.sorter.core; +package fr.inria.corese.core.next.query.kgram.sorter.core; import java.util.List; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/sorter/core/Const.java b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/Const.java similarity index 89% rename from src/main/java/fr/inria/corese/core/next/kgram/sorter/core/Const.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/Const.java index c358d78f4..f5eb43623 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/sorter/core/Const.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/Const.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.kgram.sorter.core; +package fr.inria.corese.core.next.query.kgram.sorter.core; -import fr.inria.corese.core.next.kgram.api.core.ExpType; +import fr.inria.corese.core.next.query.kgram.api.core.ExpType; /** * Constants diff --git a/src/main/java/fr/inria/corese/core/next/kgram/sorter/core/IEstimate.java b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/IEstimate.java similarity index 81% rename from src/main/java/fr/inria/corese/core/next/kgram/sorter/core/IEstimate.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/IEstimate.java index 02af8cfb7..626a05d3f 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/sorter/core/IEstimate.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/IEstimate.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.kgram.sorter.core; +package fr.inria.corese.core.next.query.kgram.sorter.core; -import fr.inria.corese.core.next.kgram.api.query.Producer; +import fr.inria.corese.core.next.query.kgram.api.query.Producer; /** * Interface for estimating the cost of nodes and edges in QPGraph diff --git a/src/main/java/fr/inria/corese/core/next/kgram/sorter/core/IProducerQP.java b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/IProducerQP.java similarity index 91% rename from src/main/java/fr/inria/corese/core/next/kgram/sorter/core/IProducerQP.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/IProducerQP.java index aaf9939b3..98af28fe4 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/sorter/core/IProducerQP.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/IProducerQP.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.sorter.core; +package fr.inria.corese.core.next.query.kgram.sorter.core; /** * Interface for calling Producer from kgraph, these methods are implemented diff --git a/src/main/java/fr/inria/corese/core/next/kgram/sorter/core/ISort.java b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/ISort.java similarity index 80% rename from src/main/java/fr/inria/corese/core/next/kgram/sorter/core/ISort.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/ISort.java index 072ce26ac..8787968fe 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/sorter/core/ISort.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/ISort.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.kgram.sorter.core; +package fr.inria.corese.core.next.query.kgram.sorter.core; -import fr.inria.corese.core.next.kgram.core.Exp; +import fr.inria.corese.core.next.query.kgram.core.Exp; import java.util.List; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/sorter/core/QPGEdge.java b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/QPGEdge.java similarity index 94% rename from src/main/java/fr/inria/corese/core/next/kgram/sorter/core/QPGEdge.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/QPGEdge.java index 3cc8aa903..6558e8ea2 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/sorter/core/QPGEdge.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/QPGEdge.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.kgram.sorter.core; +package fr.inria.corese.core.next.query.kgram.sorter.core; -import fr.inria.corese.core.next.kgram.sorter.impl.qpv1.QPGEdgeCostModel; +import fr.inria.corese.core.next.query.kgram.sorter.impl.qpv1.QPGEdgeCostModel; import java.util.ArrayList; import java.util.List; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/sorter/core/QPGNode.java b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/QPGNode.java similarity index 95% rename from src/main/java/fr/inria/corese/core/next/kgram/sorter/core/QPGNode.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/QPGNode.java index a700bff76..fdc505c9c 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/sorter/core/QPGNode.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/QPGNode.java @@ -1,11 +1,11 @@ -package fr.inria.corese.core.next.kgram.sorter.core; - -import fr.inria.corese.core.next.kgram.api.core.Edge; -import fr.inria.corese.core.next.kgram.api.core.ExpType; -import fr.inria.corese.core.next.kgram.api.core.Filter; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.core.Exp; -import fr.inria.corese.core.next.kgram.sorter.impl.qpv1.QPGNodeCostModel; +package fr.inria.corese.core.next.query.kgram.sorter.core; + +import fr.inria.corese.core.next.query.kgram.api.core.Edge; +import fr.inria.corese.core.next.query.kgram.api.core.ExpType; +import fr.inria.corese.core.next.query.kgram.api.core.Filter; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.core.Exp; +import fr.inria.corese.core.next.query.kgram.sorter.impl.qpv1.QPGNodeCostModel; import java.util.*; import java.util.stream.Collectors; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/sorter/core/QPGraph.java b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/QPGraph.java similarity index 97% rename from src/main/java/fr/inria/corese/core/next/kgram/sorter/core/QPGraph.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/QPGraph.java index ff2127f49..f49743fb9 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/sorter/core/QPGraph.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/core/QPGraph.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.kgram.sorter.core; +package fr.inria.corese.core.next.query.kgram.sorter.core; -import fr.inria.corese.core.next.kgram.api.core.ExpType; -import fr.inria.corese.core.next.kgram.core.Exp; +import fr.inria.corese.core.next.query.kgram.api.core.ExpType; +import fr.inria.corese.core.next.query.kgram.core.Exp; import java.util.ArrayList; import java.util.HashMap; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/sorter/impl/qpv1/BasicPatternGenerator.java b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/impl/qpv1/BasicPatternGenerator.java similarity index 95% rename from src/main/java/fr/inria/corese/core/next/kgram/sorter/impl/qpv1/BasicPatternGenerator.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/sorter/impl/qpv1/BasicPatternGenerator.java index 033ddf36a..8146d7937 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/sorter/impl/qpv1/BasicPatternGenerator.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/impl/qpv1/BasicPatternGenerator.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.kgram.sorter.impl.qpv1; +package fr.inria.corese.core.next.query.kgram.sorter.impl.qpv1; -import fr.inria.corese.core.next.kgram.sorter.core.IProducerQP; +import fr.inria.corese.core.next.query.kgram.sorter.core.IProducerQP; import static fr.inria.corese.core.kgram.sorter.core.Const.*; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/sorter/impl/qpv1/DepthFirstBestSearch.java b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/impl/qpv1/DepthFirstBestSearch.java similarity index 96% rename from src/main/java/fr/inria/corese/core/next/kgram/sorter/impl/qpv1/DepthFirstBestSearch.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/sorter/impl/qpv1/DepthFirstBestSearch.java index f9189358c..0dc71233e 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/sorter/impl/qpv1/DepthFirstBestSearch.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/impl/qpv1/DepthFirstBestSearch.java @@ -1,14 +1,14 @@ -package fr.inria.corese.core.next.kgram.sorter.impl.qpv1; +package fr.inria.corese.core.next.query.kgram.sorter.impl.qpv1; -import fr.inria.corese.core.next.kgram.core.Exp; -import fr.inria.corese.core.next.kgram.sorter.core.*; +import fr.inria.corese.core.next.query.kgram.core.Exp; +import fr.inria.corese.core.next.query.kgram.sorter.core.*; import java.util.ArrayList; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; -import static fr.inria.corese.core.next.kgram.api.core.ExpType.Type; +import static fr.inria.corese.core.next.query.kgram.api.core.ExpType.Type; /** * An implementation for sorting the triple pattern depth-first & best greedy diff --git a/src/main/java/fr/inria/corese/core/next/kgram/sorter/impl/qpv1/HeuristicsBasedEstimation.java b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/impl/qpv1/HeuristicsBasedEstimation.java similarity index 91% rename from src/main/java/fr/inria/corese/core/next/kgram/sorter/impl/qpv1/HeuristicsBasedEstimation.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/sorter/impl/qpv1/HeuristicsBasedEstimation.java index e7c536622..893f34fbe 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/sorter/impl/qpv1/HeuristicsBasedEstimation.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/impl/qpv1/HeuristicsBasedEstimation.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.kgram.sorter.impl.qpv1; +package fr.inria.corese.core.next.query.kgram.sorter.impl.qpv1; -import fr.inria.corese.core.next.kgram.api.core.ExpType; -import fr.inria.corese.core.next.kgram.api.query.Producer; -import fr.inria.corese.core.next.kgram.sorter.core.*; +import fr.inria.corese.core.next.query.kgram.api.core.ExpType; +import fr.inria.corese.core.next.query.kgram.api.query.Producer; +import fr.inria.corese.core.next.query.kgram.sorter.core.*; import java.util.ArrayList; import java.util.Arrays; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/sorter/impl/qpv1/QPGEdgeCostModel.java b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/impl/qpv1/QPGEdgeCostModel.java similarity index 94% rename from src/main/java/fr/inria/corese/core/next/kgram/sorter/impl/qpv1/QPGEdgeCostModel.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/sorter/impl/qpv1/QPGEdgeCostModel.java index 13a8e27ab..7a42f4fbf 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/sorter/impl/qpv1/QPGEdgeCostModel.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/impl/qpv1/QPGEdgeCostModel.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.kgram.sorter.impl.qpv1; +package fr.inria.corese.core.next.query.kgram.sorter.impl.qpv1; -import fr.inria.corese.core.next.kgram.api.core.ExpType; -import fr.inria.corese.core.next.kgram.sorter.core.*; +import fr.inria.corese.core.next.query.kgram.api.core.ExpType; +import fr.inria.corese.core.next.query.kgram.sorter.core.*; import java.util.List; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/sorter/impl/qpv1/QPGNodeCostModel.java b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/impl/qpv1/QPGNodeCostModel.java similarity index 96% rename from src/main/java/fr/inria/corese/core/next/kgram/sorter/impl/qpv1/QPGNodeCostModel.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/sorter/impl/qpv1/QPGNodeCostModel.java index 5ec608e53..30f4a1dc4 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/sorter/impl/qpv1/QPGNodeCostModel.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/sorter/impl/qpv1/QPGNodeCostModel.java @@ -1,10 +1,10 @@ -package fr.inria.corese.core.next.kgram.sorter.impl.qpv1; +package fr.inria.corese.core.next.query.kgram.sorter.impl.qpv1; -import fr.inria.corese.core.next.kgram.api.core.Edge; -import fr.inria.corese.core.next.kgram.api.core.ExpType; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.core.Exp; -import fr.inria.corese.core.next.kgram.sorter.core.*; +import fr.inria.corese.core.next.query.kgram.api.core.Edge; +import fr.inria.corese.core.next.query.kgram.api.core.ExpType; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.core.Exp; +import fr.inria.corese.core.next.query.kgram.sorter.core.*; import java.util.ArrayList; import java.util.List; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/tool/ApproximateSearchEnv.java b/src/main/java/fr/inria/corese/core/next/query/kgram/tool/ApproximateSearchEnv.java similarity index 95% rename from src/main/java/fr/inria/corese/core/next/kgram/tool/ApproximateSearchEnv.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/tool/ApproximateSearchEnv.java index 428810428..f55bef818 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/tool/ApproximateSearchEnv.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/tool/ApproximateSearchEnv.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.kgram.tool; +package fr.inria.corese.core.next.query.kgram.tool; -import fr.inria.corese.core.next.kgram.api.core.Expr; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.api.query.Environment; +import fr.inria.corese.core.next.query.kgram.api.core.Expr; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.query.Environment; import java.util.*; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/tool/EdgeInv.java b/src/main/java/fr/inria/corese/core/next/query/kgram/tool/EdgeInv.java similarity index 82% rename from src/main/java/fr/inria/corese/core/next/kgram/tool/EdgeInv.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/tool/EdgeInv.java index b3c647624..950bf0e81 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/tool/EdgeInv.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/tool/EdgeInv.java @@ -1,11 +1,11 @@ -package fr.inria.corese.core.next.kgram.tool; +package fr.inria.corese.core.next.query.kgram.tool; -import fr.inria.corese.core.next.kgram.api.core.Edge; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.api.core.PointerType; -import fr.inria.corese.core.next.kgram.core.PointerObject; +import fr.inria.corese.core.next.query.kgram.api.core.Edge; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.core.PointerType; +import fr.inria.corese.core.next.query.kgram.core.PointerObject; -import static fr.inria.corese.core.next.kgram.api.core.PointerType.TRIPLE; +import static fr.inria.corese.core.next.query.kgram.api.core.PointerType.TRIPLE; public class EdgeInv extends PointerObject implements Edge { diff --git a/src/main/java/fr/inria/corese/core/next/kgram/tool/EnvironmentImpl.java b/src/main/java/fr/inria/corese/core/next/query/kgram/tool/EnvironmentImpl.java similarity index 90% rename from src/main/java/fr/inria/corese/core/next/kgram/tool/EnvironmentImpl.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/tool/EnvironmentImpl.java index 2d3a3f093..508685b2a 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/tool/EnvironmentImpl.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/tool/EnvironmentImpl.java @@ -1,14 +1,14 @@ -package fr.inria.corese.core.next.kgram.tool; - -import fr.inria.corese.core.next.kgram.api.core.BindingContext; -import fr.inria.corese.core.next.kgram.api.core.Edge; -import fr.inria.corese.core.next.kgram.api.core.Expr; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.api.query.Environment; -import fr.inria.corese.core.next.kgram.api.query.ProcessVisitor; -import fr.inria.corese.core.next.kgram.core.*; -import fr.inria.corese.core.next.kgram.event.EventManager; -import fr.inria.corese.core.next.kgram.path.Path; +package fr.inria.corese.core.next.query.kgram.tool; + +import fr.inria.corese.core.next.query.kgram.api.core.BindingContext; +import fr.inria.corese.core.next.query.kgram.api.core.Edge; +import fr.inria.corese.core.next.query.kgram.api.core.Expr; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.query.Environment; +import fr.inria.corese.core.next.query.kgram.api.query.ProcessVisitor; +import fr.inria.corese.core.next.query.kgram.core.*; +import fr.inria.corese.core.next.query.kgram.event.EventManager; +import fr.inria.corese.core.next.query.kgram.path.Path; import fr.inria.corese.core.sparql.api.IDatatype; import fr.inria.corese.core.sparql.triple.parser.ASTExtension; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/tool/Message.java b/src/main/java/fr/inria/corese/core/next/query/kgram/tool/Message.java similarity index 92% rename from src/main/java/fr/inria/corese/core/next/kgram/tool/Message.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/tool/Message.java index fdcb84d89..1aaab9748 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/tool/Message.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/tool/Message.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.kgram.tool; +package fr.inria.corese.core.next.query.kgram.tool; public class Message { diff --git a/src/main/java/fr/inria/corese/core/next/kgram/tool/NodeImpl.java b/src/main/java/fr/inria/corese/core/next/query/kgram/tool/NodeImpl.java similarity index 92% rename from src/main/java/fr/inria/corese/core/next/kgram/tool/NodeImpl.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/tool/NodeImpl.java index ca9baf485..d1ed89043 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/tool/NodeImpl.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/tool/NodeImpl.java @@ -1,9 +1,9 @@ -package fr.inria.corese.core.next.kgram.tool; +package fr.inria.corese.core.next.query.kgram.tool; -import fr.inria.corese.core.next.kgram.path.Path; -import fr.inria.corese.core.next.kgram.api.core.Edge; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.api.core.TripleStore; +import fr.inria.corese.core.next.query.kgram.path.Path; +import fr.inria.corese.core.next.query.kgram.api.core.Edge; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.core.TripleStore; import fr.inria.corese.core.sparql.api.IDatatype; import fr.inria.corese.core.sparql.triple.parser.Atom; import fr.inria.corese.core.sparql.triple.parser.Constant; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/tool/ProducerDefault.java b/src/main/java/fr/inria/corese/core/next/query/kgram/tool/ProducerDefault.java similarity index 90% rename from src/main/java/fr/inria/corese/core/next/kgram/tool/ProducerDefault.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/tool/ProducerDefault.java index 33dd3c581..7db7309a8 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/tool/ProducerDefault.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/tool/ProducerDefault.java @@ -1,11 +1,11 @@ -package fr.inria.corese.core.next.kgram.tool; - -import fr.inria.corese.core.next.kgram.api.core.*; -import fr.inria.corese.core.next.kgram.api.query.Environment; -import fr.inria.corese.core.next.kgram.api.query.Producer; -import fr.inria.corese.core.next.kgram.core.Exp; -import fr.inria.corese.core.next.kgram.core.Mappings; -import fr.inria.corese.core.next.kgram.core.Query; +package fr.inria.corese.core.next.query.kgram.tool; + +import fr.inria.corese.core.next.query.kgram.api.core.*; +import fr.inria.corese.core.next.query.kgram.api.query.Environment; +import fr.inria.corese.core.next.query.kgram.api.query.Producer; +import fr.inria.corese.core.next.query.kgram.core.Exp; +import fr.inria.corese.core.next.query.kgram.core.Mappings; +import fr.inria.corese.core.next.query.kgram.core.Query; import fr.inria.corese.core.sparql.api.IDatatype; import java.util.ArrayList; diff --git a/src/main/java/fr/inria/corese/core/next/kgram/tool/ResultsImpl.java b/src/main/java/fr/inria/corese/core/next/query/kgram/tool/ResultsImpl.java similarity index 65% rename from src/main/java/fr/inria/corese/core/next/kgram/tool/ResultsImpl.java rename to src/main/java/fr/inria/corese/core/next/query/kgram/tool/ResultsImpl.java index e6271390a..794ab654b 100644 --- a/src/main/java/fr/inria/corese/core/next/kgram/tool/ResultsImpl.java +++ b/src/main/java/fr/inria/corese/core/next/query/kgram/tool/ResultsImpl.java @@ -1,10 +1,10 @@ -package fr.inria.corese.core.next.kgram.tool; +package fr.inria.corese.core.next.query.kgram.tool; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.api.query.Result; -import fr.inria.corese.core.next.kgram.api.query.Results; -import fr.inria.corese.core.next.kgram.core.Mapping; -import fr.inria.corese.core.next.kgram.core.Mappings; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.query.Result; +import fr.inria.corese.core.next.query.kgram.api.query.Results; +import fr.inria.corese.core.next.query.kgram.core.Mapping; +import fr.inria.corese.core.next.query.kgram.core.Mappings; import java.util.Iterator; import java.util.List; diff --git a/src/main/java/fr/inria/corese/core/sparql/triple/function/term/Binding.java b/src/main/java/fr/inria/corese/core/sparql/triple/function/term/Binding.java index c303c9849..eaeeebcdc 100644 --- a/src/main/java/fr/inria/corese/core/sparql/triple/function/term/Binding.java +++ b/src/main/java/fr/inria/corese/core/sparql/triple/function/term/Binding.java @@ -858,7 +858,7 @@ public void visit(Exp exp, Node g, Mappings m1, Mappings m2) { dt.set(URI, g.getDatatypeValue()); } } - public void visit(fr.inria.corese.core.next.kgram.core.Exp exp, fr.inria.corese.core.next.kgram.api.core.Node g, fr.inria.corese.core.next.kgram.core.Mappings m1, fr.inria.corese.core.next.kgram.core.Mappings m2) { + public void visit(fr.inria.corese.core.next.query.kgram.core.Exp exp, fr.inria.corese.core.next.query.kgram.api.core.Node g, fr.inria.corese.core.next.query.kgram.core.Mappings m1, fr.inria.corese.core.next.query.kgram.core.Mappings m2) { IDatatype dt = getReport(exp); dt.set(NUMBER, exp.getNum()); dt.set(EXP, exp.toString()); @@ -874,7 +874,7 @@ public void visit(fr.inria.corese.core.next.kgram.core.Exp exp, fr.inria.corese. * share same report for every call on same named graph pattern or service exp * exp report contains list(rep_1 rep_n) one rep_i for each uri */ - IDatatype getReport(fr.inria.corese.core.next.kgram.core.Exp exp) { + IDatatype getReport(fr.inria.corese.core.next.query.kgram.core.Exp exp) { IDatatype dt = DatatypeMap.newServiceReport(); if (exp.isGraph() || exp.isService()) { diff --git a/src/test/java/fr/inria/corese/core/next/api/IRITest.java b/src/test/java/fr/inria/corese/core/next/data/api/IRITest.java similarity index 93% rename from src/test/java/fr/inria/corese/core/next/api/IRITest.java rename to src/test/java/fr/inria/corese/core/next/data/api/IRITest.java index 7fa63420a..edc86ab33 100644 --- a/src/test/java/fr/inria/corese/core/next/api/IRITest.java +++ b/src/test/java/fr/inria/corese/core/next/data/api/IRITest.java @@ -1,8 +1,9 @@ -package fr.inria.corese.core.next.api; +package fr.inria.corese.core.next.data.api; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; +import fr.inria.corese.core.next.data.api.IRI; import org.junit.jupiter.api.Test; public abstract class IRITest { diff --git a/src/test/java/fr/inria/corese/core/next/api/ValueFactoryTest.java b/src/test/java/fr/inria/corese/core/next/data/api/ValueFactoryTest.java similarity index 98% rename from src/test/java/fr/inria/corese/core/next/api/ValueFactoryTest.java rename to src/test/java/fr/inria/corese/core/next/data/api/ValueFactoryTest.java index d5d07b5fa..cf92fb3dc 100644 --- a/src/test/java/fr/inria/corese/core/next/api/ValueFactoryTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/api/ValueFactoryTest.java @@ -1,8 +1,10 @@ -package fr.inria.corese.core.next.api; +package fr.inria.corese.core.next.data.api; -import fr.inria.corese.core.next.impl.common.BasicIRI; -import fr.inria.corese.core.next.impl.common.literal.XSD; -import fr.inria.corese.core.next.impl.exception.IncorrectFormatException; +import fr.inria.corese.core.next.data.api.Literal; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.impl.common.BasicIRI; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.exception.IncorrectFormatException; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/api/base/AbstractModelTest.java b/src/test/java/fr/inria/corese/core/next/data/api/base/AbstractModelTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/api/base/AbstractModelTest.java rename to src/test/java/fr/inria/corese/core/next/data/api/base/AbstractModelTest.java index 50745cbdf..c80e5938a 100644 --- a/src/test/java/fr/inria/corese/core/next/api/base/AbstractModelTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/api/base/AbstractModelTest.java @@ -1,10 +1,10 @@ -package fr.inria.corese.core.next.api.base; +package fr.inria.corese.core.next.data.api.base; import static org.junit.jupiter.api.Assertions.*; -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.api.base.model.AbstractModel; +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.api.base.model.AbstractModel; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/api/base/io/FileFormatTest.java b/src/test/java/fr/inria/corese/core/next/data/api/base/io/FileFormatTest.java similarity index 71% rename from src/test/java/fr/inria/corese/core/next/api/base/io/FileFormatTest.java rename to src/test/java/fr/inria/corese/core/next/data/api/base/io/FileFormatTest.java index 92302b3d7..10c05cbfa 100644 --- a/src/test/java/fr/inria/corese/core/next/api/base/io/FileFormatTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/api/base/io/FileFormatTest.java @@ -1,5 +1,6 @@ -package fr.inria.corese.core.next.api.base.io; +package fr.inria.corese.core.next.data.api.base.io; +import fr.inria.corese.core.next.data.api.base.io.FileFormat; import org.junit.jupiter.api.*; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; @@ -13,7 +14,7 @@ import static org.junit.jupiter.api.Assertions.*; /** - * Unit tests for {@link fr.inria.corese.core.next.api.base.io.FileFormat}. + * Unit tests for {@link FileFormat}. * *

* Coverage : @@ -56,7 +57,7 @@ void constructor_sets_all_fields(String name, List extensions, List mimeTypes) { - fr.inria.corese.core.next.api.base.io.FileFormat format = new fr.inria.corese.core.next.api.base.io.FileFormat(name, extensions, mimeTypes); + FileFormat format = new FileFormat(name, extensions, mimeTypes); assertAll("All getters reflect constructor arguments", () -> assertEquals(name, format.getName(), "name"), @@ -80,31 +81,31 @@ class Constructor_argument_validation { @Test void null_name_throws_NPE() { assertThrows(NullPointerException.class, - () -> new fr.inria.corese.core.next.api.base.io.FileFormat(null, EXT, MIME)); + () -> new FileFormat(null, EXT, MIME)); } @Test void null_extensions_throws_NPE() { assertThrows(NullPointerException.class, - () -> new fr.inria.corese.core.next.api.base.io.FileFormat("Turtle", null, MIME)); + () -> new FileFormat("Turtle", null, MIME)); } @Test void null_mimeTypes_throws_NPE() { assertThrows(NullPointerException.class, - () -> new fr.inria.corese.core.next.api.base.io.FileFormat("Turtle", EXT, null)); + () -> new FileFormat("Turtle", EXT, null)); } @Test void empty_extensions_throws_IAE() { assertThrows(IllegalArgumentException.class, - () -> new fr.inria.corese.core.next.api.base.io.FileFormat("Turtle", List.of(), MIME)); + () -> new FileFormat("Turtle", List.of(), MIME)); } @Test void empty_mimeTypes_throws_IAE() { assertThrows(IllegalArgumentException.class, - () -> new fr.inria.corese.core.next.api.base.io.FileFormat("Turtle", EXT, List.of())); + () -> new FileFormat("Turtle", EXT, List.of())); } } @@ -118,7 +119,7 @@ void internal_lists_are_immutable_and_defensively_copied() { // Build mutable lists List ext = new ArrayList<>(List.of("ttl")); List mime = new ArrayList<>(List.of("text/turtle")); - fr.inria.corese.core.next.api.base.io.FileFormat format = new fr.inria.corese.core.next.api.base.io.FileFormat("Turtle", ext, mime); + FileFormat format = new FileFormat("Turtle", ext, mime); // Mutate originals AFTER construction ext.add("bad"); @@ -144,11 +145,11 @@ void internal_lists_are_immutable_and_defensively_copied() { @Nested class Equals_and_hashCode_contract { - private final fr.inria.corese.core.next.api.base.io.FileFormat base = new fr.inria.corese.core.next.api.base.io.FileFormat("Turtle", List.of("ttl"), List.of("text/turtle")); + private final FileFormat base = new FileFormat("Turtle", List.of("ttl"), List.of("text/turtle")); @Test void symmetry_and_case_insensitivity() { - fr.inria.corese.core.next.api.base.io.FileFormat sameDifferentCase = new fr.inria.corese.core.next.api.base.io.FileFormat("tUrTlE", List.of("ttl"), List.of("text/turtle")); + FileFormat sameDifferentCase = new FileFormat("tUrTlE", List.of("ttl"), List.of("text/turtle")); assertEquals(base, sameDifferentCase); assertEquals(sameDifferentCase, base); @@ -157,9 +158,9 @@ void symmetry_and_case_insensitivity() { @Test void transitivity() { - fr.inria.corese.core.next.api.base.io.FileFormat a = new fr.inria.corese.core.next.api.base.io.FileFormat("Turtle", List.of("ttl"), List.of("text/turtle")); - fr.inria.corese.core.next.api.base.io.FileFormat b = new fr.inria.corese.core.next.api.base.io.FileFormat("TURTLE", List.of("ttl"), List.of("text/turtle")); - fr.inria.corese.core.next.api.base.io.FileFormat c = new fr.inria.corese.core.next.api.base.io.FileFormat("turtle", List.of("ttl"), List.of("text/turtle")); + FileFormat a = new FileFormat("Turtle", List.of("ttl"), List.of("text/turtle")); + FileFormat b = new FileFormat("TURTLE", List.of("ttl"), List.of("text/turtle")); + FileFormat c = new FileFormat("turtle", List.of("ttl"), List.of("text/turtle")); assertAll( () -> assertEquals(a, b), @@ -169,9 +170,9 @@ void transitivity() { @Test void inequality_when_any_field_differs() { - fr.inria.corese.core.next.api.base.io.FileFormat diffName = new fr.inria.corese.core.next.api.base.io.FileFormat("N-Triples", List.of("ttl"), List.of("text/turtle")); - fr.inria.corese.core.next.api.base.io.FileFormat diffExt = new fr.inria.corese.core.next.api.base.io.FileFormat("Turtle", List.of("nt"), List.of("text/turtle")); - fr.inria.corese.core.next.api.base.io.FileFormat diffMime = new fr.inria.corese.core.next.api.base.io.FileFormat("Turtle", List.of("ttl"), List.of("application/n-triples")); + FileFormat diffName = new FileFormat("N-Triples", List.of("ttl"), List.of("text/turtle")); + FileFormat diffExt = new FileFormat("Turtle", List.of("nt"), List.of("text/turtle")); + FileFormat diffMime = new FileFormat("Turtle", List.of("ttl"), List.of("application/n-triples")); assertAll( () -> assertNotEquals(base, diffName), @@ -189,7 +190,7 @@ void inequality_when_any_field_differs() { */ @Test void toString_contains_all_relevant_information() { - fr.inria.corese.core.next.api.base.io.FileFormat format = new FileFormat("Turtle", List.of("ttl"), List.of("text/turtle")); + FileFormat format = new FileFormat("Turtle", List.of("ttl"), List.of("text/turtle")); String out = format.toString(); assertTrue( diff --git a/src/test/java/fr/inria/corese/core/next/api/base/io/RDFFormatTest.java b/src/test/java/fr/inria/corese/core/next/data/api/base/io/RDFFormatTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/api/base/io/RDFFormatTest.java rename to src/test/java/fr/inria/corese/core/next/data/api/base/io/RDFFormatTest.java index 949c0408c..1db507ddb 100644 --- a/src/test/java/fr/inria/corese/core/next/api/base/io/RDFFormatTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/api/base/io/RDFFormatTest.java @@ -1,5 +1,6 @@ -package fr.inria.corese.core.next.api.base.io; +package fr.inria.corese.core.next.data.api.base.io; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/api/model/ValueFactoryTest.java b/src/test/java/fr/inria/corese/core/next/data/api/model/ValueFactoryTest.java similarity index 95% rename from src/test/java/fr/inria/corese/core/next/api/model/ValueFactoryTest.java rename to src/test/java/fr/inria/corese/core/next/data/api/model/ValueFactoryTest.java index 717729403..e8e9395f2 100644 --- a/src/test/java/fr/inria/corese/core/next/api/model/ValueFactoryTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/api/model/ValueFactoryTest.java @@ -1,10 +1,10 @@ -package fr.inria.corese.core.next.api.model; +package fr.inria.corese.core.next.data.api.model; -import fr.inria.corese.core.next.api.BNode; -import fr.inria.corese.core.next.api.Literal; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.impl.common.BasicIRI; -import fr.inria.corese.core.next.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.api.BNode; +import fr.inria.corese.core.next.data.api.Literal; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.impl.common.BasicIRI; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/api/model/base/CoreDatatypeHelperTest.java b/src/test/java/fr/inria/corese/core/next/data/api/model/base/CoreDatatypeHelperTest.java similarity index 75% rename from src/test/java/fr/inria/corese/core/next/api/model/base/CoreDatatypeHelperTest.java rename to src/test/java/fr/inria/corese/core/next/data/api/model/base/CoreDatatypeHelperTest.java index 8ca0628fd..3882f8119 100644 --- a/src/test/java/fr/inria/corese/core/next/api/model/base/CoreDatatypeHelperTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/api/model/base/CoreDatatypeHelperTest.java @@ -1,11 +1,11 @@ -package fr.inria.corese.core.next.api.model.base; - -import fr.inria.corese.core.next.api.literal.CoreDatatype; -import fr.inria.corese.core.next.impl.common.literal.RDF; -import fr.inria.corese.core.next.impl.common.literal.XSD; -import fr.inria.corese.core.next.impl.common.util.literal.CoreDatatypeHelper; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.impl.common.BasicIRI; +package fr.inria.corese.core.next.data.api.model.base; + +import fr.inria.corese.core.next.data.api.literal.CoreDatatype; +import fr.inria.corese.core.next.data.impl.common.literal.RDF; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.common.util.literal.CoreDatatypeHelper; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.impl.common.BasicIRI; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.*; diff --git a/src/test/java/fr/inria/corese/core/next/datamanager/api/support/model/MutationResultTest.java b/src/test/java/fr/inria/corese/core/next/datamanager/api/support/model/MutationResultTest.java index a6b559262..a8793418c 100644 --- a/src/test/java/fr/inria/corese/core/next/datamanager/api/support/model/MutationResultTest.java +++ b/src/test/java/fr/inria/corese/core/next/datamanager/api/support/model/MutationResultTest.java @@ -1,6 +1,6 @@ package fr.inria.corese.core.next.datamanager.api.support.model; -import fr.inria.corese.core.next.api.Statement; +import fr.inria.corese.core.next.data.api.Statement; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.mockito.Mockito; diff --git a/src/test/java/fr/inria/corese/core/next/datamanager/api/support/model/StatementPatternTest.java b/src/test/java/fr/inria/corese/core/next/datamanager/api/support/model/StatementPatternTest.java index bb4f43f35..9124cd098 100644 --- a/src/test/java/fr/inria/corese/core/next/datamanager/api/support/model/StatementPatternTest.java +++ b/src/test/java/fr/inria/corese/core/next/datamanager/api/support/model/StatementPatternTest.java @@ -1,8 +1,8 @@ package fr.inria.corese.core.next.datamanager.api.support.model; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Value; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Value; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.mockito.Mockito; diff --git a/src/test/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerBuilderTest.java b/src/test/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerBuilderTest.java index 91e6f0d4a..367b0fb3b 100644 --- a/src/test/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerBuilderTest.java +++ b/src/test/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerBuilderTest.java @@ -1,6 +1,6 @@ package fr.inria.corese.core.next.datamanager.impl; -import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.data.api.Model; import fr.inria.corese.core.next.datamanager.api.ModelDataManager; import fr.inria.corese.core.next.datamanager.api.transaction.IsolationLevel; import org.junit.jupiter.api.BeforeEach; diff --git a/src/test/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerTest.java b/src/test/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerTest.java index 6ed04d4b6..890819610 100644 --- a/src/test/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerTest.java +++ b/src/test/java/fr/inria/corese/core/next/datamanager/impl/CoreseModelDataManagerTest.java @@ -1,6 +1,6 @@ package fr.inria.corese.core.next.datamanager.impl; -import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.data.api.Model; import fr.inria.corese.core.next.datamanager.api.transaction.IsolationLevel; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; diff --git a/src/test/java/fr/inria/corese/core/next/datamanager/impl/lifecycle/LifecycleManagerImplTest.java b/src/test/java/fr/inria/corese/core/next/datamanager/impl/lifecycle/LifecycleManagerImplTest.java index bcee841b8..a112b90c7 100644 --- a/src/test/java/fr/inria/corese/core/next/datamanager/impl/lifecycle/LifecycleManagerImplTest.java +++ b/src/test/java/fr/inria/corese/core/next/datamanager/impl/lifecycle/LifecycleManagerImplTest.java @@ -1,6 +1,6 @@ package fr.inria.corese.core.next.datamanager.impl.lifecycle; -import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.data.api.Model; import fr.inria.corese.core.next.datamanager.api.lifecycle.LifecycleState; import fr.inria.corese.core.next.datamanager.api.support.config.DataManagerConfig; import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; diff --git a/src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/BulkOperationsImplTest.java b/src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/BulkOperationsImplTest.java index add565b37..554600e63 100644 --- a/src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/BulkOperationsImplTest.java +++ b/src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/BulkOperationsImplTest.java @@ -1,6 +1,6 @@ package fr.inria.corese.core.next.datamanager.impl.operations; -import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.data.api.*; import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; import fr.inria.corese.core.next.datamanager.api.support.model.MutationResult; import fr.inria.corese.core.next.datamanager.api.support.model.StatementPattern; diff --git a/src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/MetadataOperationsImplTest.java b/src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/MetadataOperationsImplTest.java index cb3e64d18..7ca1d9b76 100644 --- a/src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/MetadataOperationsImplTest.java +++ b/src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/MetadataOperationsImplTest.java @@ -1,9 +1,9 @@ package fr.inria.corese.core.next.datamanager.impl.operations; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Value; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Value; import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; import fr.inria.corese.core.next.datamanager.api.support.model.ModelStatistics; import org.junit.jupiter.api.BeforeEach; diff --git a/src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/QueryOperationsImplTest.java b/src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/QueryOperationsImplTest.java index d81aecb83..23c7d1682 100644 --- a/src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/QueryOperationsImplTest.java +++ b/src/test/java/fr/inria/corese/core/next/datamanager/impl/operations/QueryOperationsImplTest.java @@ -1,6 +1,6 @@ package fr.inria.corese.core.next.datamanager.impl.operations; -import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.data.api.*; import fr.inria.corese.core.next.datamanager.api.support.exception.DataManagerException; import fr.inria.corese.core.next.datamanager.api.support.model.StatementPattern; import org.junit.jupiter.api.BeforeEach; diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/BasicIRITest.java b/src/test/java/fr/inria/corese/core/next/impl/common/BasicIRITest.java index c886177d5..a6cdb6f0b 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/BasicIRITest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/BasicIRITest.java @@ -1,7 +1,8 @@ package fr.inria.corese.core.next.impl.common; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.IRITest; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.IRITest; +import fr.inria.corese.core.next.data.impl.common.BasicIRI; public class BasicIRITest extends IRITest { @Override diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/literal/BasicDurationTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/literal/BasicDurationTest.java index b9161bff7..c35717ab1 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/literal/BasicDurationTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/literal/BasicDurationTest.java @@ -11,10 +11,12 @@ import java.time.Period; import java.util.Optional; +import fr.inria.corese.core.next.data.impl.common.literal.BasicDuration; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; import org.junit.jupiter.api.Test; -import fr.inria.corese.core.next.impl.exception.IncorrectFormatException; -import fr.inria.corese.core.next.impl.exception.IncorrectOperationException; +import fr.inria.corese.core.next.data.impl.exception.IncorrectFormatException; +import fr.inria.corese.core.next.data.impl.exception.IncorrectOperationException; public class BasicDurationTest { diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/prefix/PrefixHandlerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/prefix/PrefixHandlerTest.java index b2f9ab0d1..5a736049d 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/prefix/PrefixHandlerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/prefix/PrefixHandlerTest.java @@ -1,5 +1,6 @@ package fr.inria.corese.core.next.impl.common.prefix; +import fr.inria.corese.core.next.data.impl.common.prefix.PrefixHandler; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/util/IRIUtilsTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/util/IRIUtilsTest.java index b1626962b..380b7126a 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/util/IRIUtilsTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/util/IRIUtilsTest.java @@ -4,6 +4,7 @@ import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; +import fr.inria.corese.core.next.data.impl.common.util.IRIUtils; import org.junit.jupiter.api.Test; public class IRIUtilsTest { diff --git a/src/test/java/fr/inria/corese/core/next/impl/config/CoreConfigTest.java b/src/test/java/fr/inria/corese/core/next/impl/config/CoreConfigTest.java index 1f2f12985..ab5f521bc 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/config/CoreConfigTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/config/CoreConfigTest.java @@ -1,6 +1,8 @@ package fr.inria.corese.core.next.impl.config; import static org.junit.jupiter.api.Assertions.assertEquals; + +import fr.inria.corese.core.next.data.impl.config.CoreConfig; import org.junit.jupiter.api.Test; public class CoreConfigTest { diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/option/JSONLDOptionsTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/option/JSONLDOptionsTest.java index df046a960..73d77a542 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/option/JSONLDOptionsTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/option/JSONLDOptionsTest.java @@ -1,7 +1,7 @@ package fr.inria.corese.core.next.impl.io.option; import com.apicatalog.jsonld.JsonLdVersion; -import fr.inria.corese.core.next.impl.io.common.JSONLDOptions; +import fr.inria.corese.core.next.data.impl.io.common.JSONLDOptions; import org.junit.jupiter.api.Test; import java.time.Duration; @@ -14,7 +14,7 @@ */ class JSONLDOptionsTest { - private final fr.inria.corese.core.next.impl.io.common.JSONLDOptions optionAllTrue = new fr.inria.corese.core.next.impl.io.common.JSONLDOptions.Builder().base("http://example.org/AllTrue") + private final JSONLDOptions optionAllTrue = new JSONLDOptions.Builder().base("http://example.org/AllTrue") .extractAllScripts(true) .compactToRelative(true) .compactArrays(true) @@ -23,7 +23,7 @@ class JSONLDOptionsTest { .useNativeTypes(true) .build(); - private final fr.inria.corese.core.next.impl.io.common.JSONLDOptions optionAllFalse = new fr.inria.corese.core.next.impl.io.common.JSONLDOptions.Builder().base("http://example.org/AllFalse") + private final JSONLDOptions optionAllFalse = new JSONLDOptions.Builder().base("http://example.org/AllFalse") .extractAllScripts(false) .compactArrays(false) .compactToRelative(false) @@ -58,15 +58,15 @@ void isOrdered() { @Test void getProcessingMode() { - fr.inria.corese.core.next.impl.io.common.JSONLDOptions option10 = new fr.inria.corese.core.next.impl.io.common.JSONLDOptions.Builder().processingMode(JsonLdVersion.V1_0).build(); - fr.inria.corese.core.next.impl.io.common.JSONLDOptions option11 = new fr.inria.corese.core.next.impl.io.common.JSONLDOptions.Builder().processingMode(JsonLdVersion.V1_1).build(); + JSONLDOptions option10 = new JSONLDOptions.Builder().processingMode(JsonLdVersion.V1_0).build(); + JSONLDOptions option11 = new JSONLDOptions.Builder().processingMode(JsonLdVersion.V1_1).build(); assertEquals(JsonLdVersion.V1_0, option10.getProcessingMode()); assertEquals(JsonLdVersion.V1_1, option11.getProcessingMode()); } @Test void getTimeout() { - fr.inria.corese.core.next.impl.io.common.JSONLDOptions option10seconds = new JSONLDOptions.Builder().timeout(Duration.of(10, ChronoUnit.SECONDS)).build(); + JSONLDOptions option10seconds = new JSONLDOptions.Builder().timeout(Duration.of(10, ChronoUnit.SECONDS)).build(); assertNull(optionAllTrue.getTimeout()); assertEquals(Duration.of(10, ChronoUnit.SECONDS), option10seconds.getTimeout()); } diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/ParserFactoryTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/parser/ParserFactoryTest.java index 2f4cedb6b..06ceb7491 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/ParserFactoryTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/parser/ParserFactoryTest.java @@ -1,14 +1,15 @@ package fr.inria.corese.core.next.impl.io.parser; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.api.io.parser.RDFParser; -import fr.inria.corese.core.next.impl.io.parser.jsonld.JSONLDParser; -import fr.inria.corese.core.next.impl.io.parser.nquads.NQuadsParser; -import fr.inria.corese.core.next.impl.io.parser.ntriples.NTriplesParser; -import fr.inria.corese.core.next.impl.io.parser.turtle.TurtleParser; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.io.parser.RDFParser; +import fr.inria.corese.core.next.data.impl.io.parser.ParserFactory; +import fr.inria.corese.core.next.data.impl.io.parser.jsonld.JSONLDParser; +import fr.inria.corese.core.next.data.impl.io.parser.nquads.NQuadsParser; +import fr.inria.corese.core.next.data.impl.io.parser.ntriples.NTriplesParser; +import fr.inria.corese.core.next.data.impl.io.parser.turtle.TurtleParser; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/jsonld/JSONLDCircularTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/parser/jsonld/JSONLDCircularTest.java index c79c85d3c..fcef3ed93 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/jsonld/JSONLDCircularTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/parser/jsonld/JSONLDCircularTest.java @@ -1,14 +1,14 @@ package fr.inria.corese.core.next.impl.io.parser.jsonld; -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.io.parser.RDFParser; -import fr.inria.corese.core.next.api.io.serializer.RDFSerializer; -import fr.inria.corese.core.next.impl.io.common.JSONLDOptions; -import fr.inria.corese.core.next.impl.io.parser.ParserFactory; -import fr.inria.corese.core.next.impl.io.serialization.SerializerFactory; -import fr.inria.corese.core.next.impl.temp.CoreseAdaptedValueFactory; -import fr.inria.corese.core.next.impl.temp.CoreseModel; +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.io.parser.RDFParser; +import fr.inria.corese.core.next.data.io.serializer.RDFSerializer; +import fr.inria.corese.core.next.data.impl.io.common.JSONLDOptions; +import fr.inria.corese.core.next.data.impl.io.parser.ParserFactory; +import fr.inria.corese.core.next.data.impl.io.serialization.SerializerFactory; +import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; +import fr.inria.corese.core.next.data.impl.temp.CoreseModel; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; @@ -33,7 +33,7 @@ class JSONLDCircularTest { private ValueFactory valueFactory; - private fr.inria.corese.core.next.api.io.serializer.SerializerFactory serializerFactory; + private fr.inria.corese.core.next.data.io.serializer.SerializerFactory serializerFactory; private ParserFactory parserFactory; private JSONLDOptions defaultConfig; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/jsonld/JSONLDParserTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/parser/jsonld/JSONLDParserTest.java index 383ac42a1..725ce6ee0 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/jsonld/JSONLDParserTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/parser/jsonld/JSONLDParserTest.java @@ -9,21 +9,22 @@ import java.io.Reader; import java.io.StringReader; -import fr.inria.corese.core.next.impl.io.common.JSONLDOptions; +import fr.inria.corese.core.next.data.impl.io.common.JSONLDOptions; +import fr.inria.corese.core.next.data.impl.io.parser.jsonld.JSONLDParser; import org.junit.jupiter.api.Test; -import fr.inria.corese.core.next.api.BNode; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Literal; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.io.parser.RDFParser; -import fr.inria.corese.core.next.impl.io.parser.ParserFactory; -import fr.inria.corese.core.next.impl.temp.CoreseAdaptedValueFactory; -import fr.inria.corese.core.next.impl.temp.CoreseModel; +import fr.inria.corese.core.next.data.api.BNode; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Literal; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.io.parser.RDFParser; +import fr.inria.corese.core.next.data.impl.io.parser.ParserFactory; +import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; +import fr.inria.corese.core.next.data.impl.temp.CoreseModel; public class JSONLDParserTest { diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsCircularTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsCircularTest.java index 1bad1a5cc..719db3a36 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsCircularTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsCircularTest.java @@ -1,14 +1,14 @@ package fr.inria.corese.core.next.impl.io.parser.nquads; -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.io.parser.RDFParser; -import fr.inria.corese.core.next.api.io.serializer.RDFSerializer; -import fr.inria.corese.core.next.impl.io.parser.ParserFactory; -import fr.inria.corese.core.next.impl.io.serialization.SerializerFactory; -import fr.inria.corese.core.next.impl.io.serialization.nquads.NQuadsSerializerOptions; -import fr.inria.corese.core.next.impl.temp.CoreseAdaptedValueFactory; -import fr.inria.corese.core.next.impl.temp.CoreseModel; +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.io.parser.RDFParser; +import fr.inria.corese.core.next.data.io.serializer.RDFSerializer; +import fr.inria.corese.core.next.data.impl.io.parser.ParserFactory; +import fr.inria.corese.core.next.data.impl.io.serialization.SerializerFactory; +import fr.inria.corese.core.next.data.impl.io.serialization.nquads.NQuadsSerializerOptions; +import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; +import fr.inria.corese.core.next.data.impl.temp.CoreseModel; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; @@ -32,7 +32,7 @@ class NQuadsCircularTest { private ValueFactory valueFactory; - private fr.inria.corese.core.next.api.io.serializer.SerializerFactory serializerFactory; + private fr.inria.corese.core.next.data.io.serializer.SerializerFactory serializerFactory; private ParserFactory parserFactory; private NQuadsSerializerOptions defaultConfig; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsListenerTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsListenerTest.java index 8869b2700..99761eb22 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsListenerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsListenerTest.java @@ -1,8 +1,9 @@ package fr.inria.corese.core.next.impl.io.parser.nquads; -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.impl.exception.ParsingErrorException; +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.impl.exception.ParsingErrorException; +import fr.inria.corese.core.next.data.impl.io.parser.nquads.NQuadsListener; import fr.inria.corese.core.next.impl.parser.antlr.NQuadsParser; import org.antlr.v4.runtime.ParserRuleContext; import org.antlr.v4.runtime.tree.TerminalNode; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsParserTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsParserTest.java index f5bff4918..96a61d24e 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsParserTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsParserTest.java @@ -1,8 +1,9 @@ package fr.inria.corese.core.next.impl.io.parser.nquads; -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.impl.exception.ParsingErrorException; +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.impl.exception.ParsingErrorException; +import fr.inria.corese.core.next.data.impl.io.parser.nquads.NQuadsParser; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesCircularTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesCircularTest.java index 155b601a7..0aa2ba2c0 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesCircularTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesCircularTest.java @@ -1,14 +1,14 @@ package fr.inria.corese.core.next.impl.io.parser.ntriples; -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.io.parser.RDFParser; -import fr.inria.corese.core.next.api.io.serializer.RDFSerializer; -import fr.inria.corese.core.next.impl.io.parser.ParserFactory; -import fr.inria.corese.core.next.impl.io.serialization.SerializerFactory; -import fr.inria.corese.core.next.impl.io.serialization.ntriples.NTriplesSerializerOptions; -import fr.inria.corese.core.next.impl.temp.CoreseAdaptedValueFactory; -import fr.inria.corese.core.next.impl.temp.CoreseModel; +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.io.parser.RDFParser; +import fr.inria.corese.core.next.data.io.serializer.RDFSerializer; +import fr.inria.corese.core.next.data.impl.io.parser.ParserFactory; +import fr.inria.corese.core.next.data.impl.io.serialization.SerializerFactory; +import fr.inria.corese.core.next.data.impl.io.serialization.ntriples.NTriplesSerializerOptions; +import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; +import fr.inria.corese.core.next.data.impl.temp.CoreseModel; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; @@ -30,7 +30,7 @@ class NTriplesCircularTest { private ValueFactory valueFactory; - private fr.inria.corese.core.next.api.io.serializer.SerializerFactory serializerFactory; + private fr.inria.corese.core.next.data.io.serializer.SerializerFactory serializerFactory; private ParserFactory parserFactory; private NTriplesSerializerOptions defaultConfig; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesListenerTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesListenerTest.java index 3a75bd055..221aefc79 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesListenerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesListenerTest.java @@ -1,8 +1,9 @@ package fr.inria.corese.core.next.impl.io.parser.ntriples; -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.impl.exception.ParsingErrorException; +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.impl.exception.ParsingErrorException; +import fr.inria.corese.core.next.data.impl.io.parser.ntriples.NTriplesListener; import fr.inria.corese.core.next.impl.parser.antlr.NTriplesParser; import org.antlr.v4.runtime.ParserRuleContext; import org.antlr.v4.runtime.tree.TerminalNode; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesParserTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesParserTest.java index 9bc2a2335..85db450c1 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesParserTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesParserTest.java @@ -1,8 +1,9 @@ package fr.inria.corese.core.next.impl.io.parser.ntriples; -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.impl.exception.ParsingErrorException; +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.impl.exception.ParsingErrorException; +import fr.inria.corese.core.next.data.impl.io.parser.ntriples.NTriplesParser; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfa/RDFaParserTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfa/RDFaParserTest.java index 68ffd7b56..28595f4a4 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfa/RDFaParserTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfa/RDFaParserTest.java @@ -1,15 +1,16 @@ package fr.inria.corese.core.next.impl.io.parser.rdfa; -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.io.parser.RDFParser; -import fr.inria.corese.core.next.api.io.serializer.RDFSerializer; -import fr.inria.corese.core.next.impl.io.serialization.SerializerFactory; -import fr.inria.corese.core.next.impl.common.vocabulary.RDF; -import fr.inria.corese.core.next.impl.common.vocabulary.XSD; -import fr.inria.corese.core.next.impl.io.parser.ParserFactory; -import fr.inria.corese.core.next.impl.temp.CoreseAdaptedValueFactory; -import fr.inria.corese.core.next.impl.temp.CoreseModel; +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.io.parser.RDFParser; +import fr.inria.corese.core.next.data.io.serializer.RDFSerializer; +import fr.inria.corese.core.next.data.impl.io.parser.rdfa.RDFaParser; +import fr.inria.corese.core.next.data.impl.io.serialization.SerializerFactory; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF; +import fr.inria.corese.core.next.data.impl.common.vocabulary.XSD; +import fr.inria.corese.core.next.data.impl.io.parser.ParserFactory; +import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; +import fr.inria.corese.core.next.data.impl.temp.CoreseModel; import org.junit.jupiter.api.Test; import java.io.ByteArrayInputStream; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLCircularTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLCircularTest.java index 491ca3502..248206306 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLCircularTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLCircularTest.java @@ -1,14 +1,14 @@ package fr.inria.corese.core.next.impl.io.parser.rdfxml; -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.io.parser.RDFParser; -import fr.inria.corese.core.next.api.io.serializer.RDFSerializer; -import fr.inria.corese.core.next.impl.io.parser.ParserFactory; -import fr.inria.corese.core.next.impl.io.serialization.SerializerFactory; -import fr.inria.corese.core.next.impl.io.serialization.rdfxml.RDFXMLSerializerOptions; -import fr.inria.corese.core.next.impl.temp.CoreseAdaptedValueFactory; -import fr.inria.corese.core.next.impl.temp.CoreseModel; +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.io.parser.RDFParser; +import fr.inria.corese.core.next.data.io.serializer.RDFSerializer; +import fr.inria.corese.core.next.data.impl.io.parser.ParserFactory; +import fr.inria.corese.core.next.data.impl.io.serialization.SerializerFactory; +import fr.inria.corese.core.next.data.impl.io.serialization.rdfxml.RDFXMLSerializerOptions; +import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; +import fr.inria.corese.core.next.data.impl.temp.CoreseModel; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; @@ -36,7 +36,7 @@ class RDFXMLCircularTest { private ValueFactory valueFactory; - private fr.inria.corese.core.next.api.io.serializer.SerializerFactory serializerFactory; + private fr.inria.corese.core.next.data.io.serializer.SerializerFactory serializerFactory; private ParserFactory parserFactory; private RDFXMLSerializerOptions defaultConfig; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLParserTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLParserTest.java index 9367d24f9..950ebe6b5 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLParserTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLParserTest.java @@ -1,11 +1,12 @@ package fr.inria.corese.core.next.impl.io.parser.rdfxml; -import fr.inria.corese.core.next.api.Literal; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Value; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.impl.temp.CoreseAdaptedValueFactory; -import fr.inria.corese.core.next.impl.temp.CoreseModel; +import fr.inria.corese.core.next.data.api.Literal; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Value; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.impl.io.parser.rdfxml.RDFXMLParser; +import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; +import fr.inria.corese.core.next.data.impl.temp.CoreseModel; import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLStatementEmitterTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLStatementEmitterTest.java index f87cc472e..29f7b95a1 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLStatementEmitterTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLStatementEmitterTest.java @@ -1,10 +1,11 @@ package fr.inria.corese.core.next.impl.io.parser.rdfxml; -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.impl.common.literal.XSD; -import fr.inria.corese.core.next.impl.common.vocabulary.RDF; -import fr.inria.corese.core.next.impl.temp.CoreseAdaptedValueFactory; -import fr.inria.corese.core.next.impl.temp.CoreseModel; +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF; +import fr.inria.corese.core.next.data.impl.io.parser.rdfxml.RDFXMLStatementEmitter; +import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; +import fr.inria.corese.core.next.data.impl.temp.CoreseModel; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.xml.sax.helpers.AttributesImpl; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLUtilsTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLUtilsTest.java index 592ff3623..ce46cfeb2 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLUtilsTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLUtilsTest.java @@ -1,12 +1,13 @@ package fr.inria.corese.core.next.impl.io.parser.rdfxml; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.impl.common.literal.XSD; -import fr.inria.corese.core.next.impl.common.vocabulary.RDF; -import fr.inria.corese.core.next.impl.temp.CoreseAdaptedValueFactory; -import fr.inria.corese.core.next.impl.temp.CoreseModel; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF; +import fr.inria.corese.core.next.data.impl.io.parser.rdfxml.RDFXMLUtils; +import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; +import fr.inria.corese.core.next.data.impl.temp.CoreseModel; import org.junit.jupiter.api.Test; import org.xml.sax.helpers.AttributesImpl; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGCircularTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGCircularTest.java index 9cf5fdaa6..e58b22b7d 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGCircularTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGCircularTest.java @@ -8,19 +8,19 @@ import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; -import fr.inria.corese.core.next.api.BNode; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Literal; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.io.parser.RDFParser; -import fr.inria.corese.core.next.api.io.serializer.RDFSerializer; -import fr.inria.corese.core.next.impl.io.parser.ParserFactory; -import fr.inria.corese.core.next.impl.io.serialization.SerializerFactory; -import fr.inria.corese.core.next.impl.io.serialization.trig.TriGSerializerOptions; -import fr.inria.corese.core.next.impl.temp.CoreseAdaptedValueFactory; -import fr.inria.corese.core.next.impl.temp.CoreseModel; +import fr.inria.corese.core.next.data.api.BNode; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Literal; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.io.parser.RDFParser; +import fr.inria.corese.core.next.data.io.serializer.RDFSerializer; +import fr.inria.corese.core.next.data.impl.io.parser.ParserFactory; +import fr.inria.corese.core.next.data.impl.io.serialization.SerializerFactory; +import fr.inria.corese.core.next.data.impl.io.serialization.trig.TriGSerializerOptions; +import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; +import fr.inria.corese.core.next.data.impl.temp.CoreseModel; import static org.junit.jupiter.api.Assertions.*; @@ -37,7 +37,7 @@ class TriGCircularTest { private ValueFactory valueFactory; - private fr.inria.corese.core.next.api.io.serializer.SerializerFactory serializerFactory; + private fr.inria.corese.core.next.data.io.serializer.SerializerFactory serializerFactory; private ParserFactory parserFactory; private TriGSerializerOptions defaultConfig; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGListenerImplTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGListenerImplTest.java index 869f5ff5f..93955acfc 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGListenerImplTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGListenerImplTest.java @@ -1,11 +1,12 @@ package fr.inria.corese.core.next.impl.io.parser.trig; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.ValueFactory; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.impl.io.parser.trig.TriGListerner; import fr.inria.corese.core.next.impl.parser.antlr.TriGLexer; import fr.inria.corese.core.next.impl.parser.antlr.TriGParser; -import fr.inria.corese.core.next.impl.temp.CoreseAdaptedValueFactory; -import fr.inria.corese.core.next.impl.temp.CoreseModel; +import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; +import fr.inria.corese.core.next.data.impl.temp.CoreseModel; import org.antlr.v4.runtime.CharStream; import org.antlr.v4.runtime.CharStreams; import org.antlr.v4.runtime.CommonTokenStream; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGParserTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGParserTest.java index c9fa3c205..e0ebc5dc1 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGParserTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGParserTest.java @@ -1,12 +1,13 @@ package fr.inria.corese.core.next.impl.io.parser.trig; -import fr.inria.corese.core.next.api.Literal; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Value; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.api.io.parser.RDFParser; -import fr.inria.corese.core.next.impl.temp.CoreseAdaptedValueFactory; -import fr.inria.corese.core.next.impl.temp.CoreseModel; +import fr.inria.corese.core.next.data.api.Literal; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Value; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.io.parser.RDFParser; +import fr.inria.corese.core.next.data.impl.io.parser.trig.TriGParser; +import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; +import fr.inria.corese.core.next.data.impl.temp.CoreseModel; import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleCircularTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleCircularTest.java index ab59f1c80..2d755db51 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleCircularTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleCircularTest.java @@ -8,19 +8,19 @@ import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; -import fr.inria.corese.core.next.api.BNode; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Literal; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.io.parser.RDFParser; -import fr.inria.corese.core.next.api.io.serializer.RDFSerializer; -import fr.inria.corese.core.next.impl.io.parser.ParserFactory; -import fr.inria.corese.core.next.impl.io.serialization.SerializerFactory; -import fr.inria.corese.core.next.impl.io.serialization.turtle.TurtleSerializerOptions; -import fr.inria.corese.core.next.impl.temp.CoreseAdaptedValueFactory; -import fr.inria.corese.core.next.impl.temp.CoreseModel; +import fr.inria.corese.core.next.data.api.BNode; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Literal; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.io.parser.RDFParser; +import fr.inria.corese.core.next.data.io.serializer.RDFSerializer; +import fr.inria.corese.core.next.data.impl.io.parser.ParserFactory; +import fr.inria.corese.core.next.data.impl.io.serialization.SerializerFactory; +import fr.inria.corese.core.next.data.impl.io.serialization.turtle.TurtleSerializerOptions; +import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; +import fr.inria.corese.core.next.data.impl.temp.CoreseModel; import static org.junit.jupiter.api.Assertions.*; @@ -35,7 +35,7 @@ class TurtleCircularTest { private ValueFactory valueFactory; - private fr.inria.corese.core.next.api.io.serializer.SerializerFactory serializerFactory; + private fr.inria.corese.core.next.data.io.serializer.SerializerFactory serializerFactory; private ParserFactory parserFactory; private TurtleSerializerOptions defaultConfig; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleListenerTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleListenerTest.java index 689748c7d..e5174229f 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleListenerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleListenerTest.java @@ -1,11 +1,12 @@ package fr.inria.corese.core.next.impl.io.parser.turtle; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.ValueFactory; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.impl.io.parser.turtle.TurtleListener; import fr.inria.corese.core.next.impl.parser.antlr.TurtleLexer; import fr.inria.corese.core.next.impl.parser.antlr.TurtleParser; -import fr.inria.corese.core.next.impl.temp.CoreseAdaptedValueFactory; -import fr.inria.corese.core.next.impl.temp.CoreseModel; +import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; +import fr.inria.corese.core.next.data.impl.temp.CoreseModel; import org.antlr.v4.runtime.CharStream; import org.antlr.v4.runtime.CharStreams; import org.antlr.v4.runtime.CommonTokenStream; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleParserTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleParserTest.java index bac9a85c4..984b4444a 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleParserTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleParserTest.java @@ -1,12 +1,14 @@ package fr.inria.corese.core.next.impl.io.parser.turtle; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.api.io.parser.RDFParser; -import fr.inria.corese.core.next.impl.common.vocabulary.RDFS; -import fr.inria.corese.core.next.impl.temp.CoreseAdaptedValueFactory; -import fr.inria.corese.core.next.impl.temp.CoreseModel; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.io.parser.RDFParser; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDFS; +import fr.inria.corese.core.next.data.impl.io.parser.turtle.TurtleParser; +import fr.inria.corese.core.next.data.impl.io.parser.turtle.TurtleParserOptions; +import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; +import fr.inria.corese.core.next.data.impl.temp.CoreseModel; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/SerializerFactoryTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/SerializerFactoryTest.java index d23d6165d..5e5f2b3cb 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/SerializerFactoryTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/SerializerFactoryTest.java @@ -1,24 +1,23 @@ package fr.inria.corese.core.next.impl.io.serialization; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.api.io.serializer.RDFSerializer; -import fr.inria.corese.core.next.impl.exception.SerializationException; -import fr.inria.corese.core.next.impl.io.common.JSONLDOptions; -import fr.inria.corese.core.next.impl.io.serialization.canonical.RDFC10Serializer; -import fr.inria.corese.core.next.impl.io.serialization.canonical.RDFC10SerializerOptions; -import fr.inria.corese.core.next.impl.io.serialization.jsonld.JSONLDSerializer; -import fr.inria.corese.core.next.impl.io.serialization.nquads.NQuadsSerializer; -import fr.inria.corese.core.next.impl.io.serialization.nquads.NQuadsSerializerOptions; -import fr.inria.corese.core.next.impl.io.serialization.ntriples.NTriplesSerializer; -import fr.inria.corese.core.next.impl.io.serialization.ntriples.NTriplesSerializerOptions; -import fr.inria.corese.core.next.impl.io.serialization.rdfxml.RDFXMLSerializer; -import fr.inria.corese.core.next.impl.io.serialization.rdfxml.RDFXMLSerializerOptions; -import fr.inria.corese.core.next.impl.io.serialization.trig.TriGSerializer; -import fr.inria.corese.core.next.impl.io.serialization.trig.TriGSerializerOptions; -import fr.inria.corese.core.next.impl.io.serialization.turtle.TurtleSerializer; -import fr.inria.corese.core.next.impl.io.serialization.turtle.TurtleSerializerOptions; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.io.serializer.RDFSerializer; +import fr.inria.corese.core.next.data.impl.io.common.JSONLDOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.SerializerFactory; +import fr.inria.corese.core.next.data.impl.io.serialization.canonical.RDFC10Serializer; +import fr.inria.corese.core.next.data.impl.io.serialization.canonical.RDFC10SerializerOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.jsonld.JSONLDSerializer; +import fr.inria.corese.core.next.data.impl.io.serialization.nquads.NQuadsSerializer; +import fr.inria.corese.core.next.data.impl.io.serialization.nquads.NQuadsSerializerOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.ntriples.NTriplesSerializer; +import fr.inria.corese.core.next.data.impl.io.serialization.ntriples.NTriplesSerializerOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.rdfxml.RDFXMLSerializer; +import fr.inria.corese.core.next.data.impl.io.serialization.rdfxml.RDFXMLSerializerOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.trig.TriGSerializer; +import fr.inria.corese.core.next.data.impl.io.serialization.trig.TriGSerializerOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.turtle.TurtleSerializer; +import fr.inria.corese.core.next.data.impl.io.serialization.turtle.TurtleSerializerOptions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/TestStatementFactory.java b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/TestStatementFactory.java index 16daebc0c..d0c77ec1d 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/TestStatementFactory.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/TestStatementFactory.java @@ -1,11 +1,11 @@ package fr.inria.corese.core.next.impl.io.serialization; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Literal; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.api.Value; -import fr.inria.corese.core.next.impl.common.vocabulary.RDF; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Literal; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.api.Value; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF; import java.util.Optional; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/canonical/RDFC10SerializerOptionsTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/canonical/RDFC10SerializerOptionsTest.java index 59d8f9d03..d9525c6f9 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/canonical/RDFC10SerializerOptionsTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/canonical/RDFC10SerializerOptionsTest.java @@ -1,5 +1,6 @@ package fr.inria.corese.core.next.impl.io.serialization.canonical; +import fr.inria.corese.core.next.data.impl.io.serialization.canonical.RDFC10SerializerOptions; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/canonical/RDFC10SerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/canonical/RDFC10SerializerTest.java index a258dc44e..2f5ce18c0 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/canonical/RDFC10SerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/canonical/RDFC10SerializerTest.java @@ -1,14 +1,17 @@ package fr.inria.corese.core.next.impl.io.serialization.canonical; -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.api.base.io.RDFFormat; -import fr.inria.corese.core.next.api.io.parser.RDFParser; -import fr.inria.corese.core.next.api.io.serializer.RDFSerializer; -import fr.inria.corese.core.next.impl.exception.SerializationException; -import fr.inria.corese.core.next.impl.io.parser.ParserFactory; -import fr.inria.corese.core.next.impl.io.serialization.SerializerFactory; -import fr.inria.corese.core.next.impl.temp.CoreseAdaptedValueFactory; -import fr.inria.corese.core.next.impl.temp.CoreseModel; +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.api.base.io.RDFFormat; +import fr.inria.corese.core.next.data.impl.exception.SerializationException; +import fr.inria.corese.core.next.data.impl.io.parser.ParserFactory; +import fr.inria.corese.core.next.data.impl.io.serialization.SerializerFactory; +import fr.inria.corese.core.next.data.impl.io.serialization.canonical.RDFC10Canonicalizer; +import fr.inria.corese.core.next.data.impl.io.serialization.canonical.RDFC10Serializer; +import fr.inria.corese.core.next.data.impl.io.serialization.canonical.RDFC10SerializerOptions; +import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; +import fr.inria.corese.core.next.data.impl.temp.CoreseModel; +import fr.inria.corese.core.next.data.io.parser.RDFParser; +import fr.inria.corese.core.next.data.io.serializer.RDFSerializer; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/jsonld/JSONLDSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/jsonld/JSONLDSerializerTest.java index a22938244..9006f6c93 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/jsonld/JSONLDSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/jsonld/JSONLDSerializerTest.java @@ -1,11 +1,12 @@ package fr.inria.corese.core.next.impl.io.serialization.jsonld; import com.apicatalog.jsonld.json.JsonLdComparison; -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.api.io.serializer.RDFSerializer; -import fr.inria.corese.core.next.impl.io.common.JSONLDOptions; -import fr.inria.corese.core.next.impl.temp.CoreseAdaptedValueFactory; -import fr.inria.corese.core.next.impl.temp.CoreseModel; +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.io.serializer.RDFSerializer; +import fr.inria.corese.core.next.data.impl.io.common.JSONLDOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.jsonld.JSONLDSerializer; +import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; +import fr.inria.corese.core.next.data.impl.temp.CoreseModel; import jakarta.json.Json; import jakarta.json.JsonReader; import jakarta.json.JsonReaderFactory; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/nquads/NQuadsSerializerOptionsTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/nquads/NQuadsSerializerOptionsTest.java index b460a86dc..8222c70b3 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/nquads/NQuadsSerializerOptionsTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/nquads/NQuadsSerializerOptionsTest.java @@ -1,6 +1,7 @@ package fr.inria.corese.core.next.impl.io.serialization.nquads; -import fr.inria.corese.core.next.impl.io.serialization.option.LiteralDatatypePolicyEnum; +import fr.inria.corese.core.next.data.impl.io.serialization.nquads.NQuadsSerializerOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.option.LiteralDatatypePolicyEnum; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/nquads/NQuadsSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/nquads/NQuadsSerializerTest.java index e657521d5..d6821683e 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/nquads/NQuadsSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/nquads/NQuadsSerializerTest.java @@ -1,8 +1,10 @@ package fr.inria.corese.core.next.impl.io.serialization.nquads; -import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.impl.io.serialization.nquads.NQuadsSerializer; +import fr.inria.corese.core.next.data.impl.io.serialization.nquads.NQuadsSerializerOptions; import fr.inria.corese.core.next.impl.io.serialization.TestStatementFactory; -import fr.inria.corese.core.next.impl.exception.SerializationException; +import fr.inria.corese.core.next.data.impl.exception.SerializationException; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/ntriples/NTriplesSerializerOptionsTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/ntriples/NTriplesSerializerOptionsTest.java index 3d665d086..ef98ef535 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/ntriples/NTriplesSerializerOptionsTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/ntriples/NTriplesSerializerOptionsTest.java @@ -1,6 +1,7 @@ package fr.inria.corese.core.next.impl.io.serialization.ntriples; -import fr.inria.corese.core.next.impl.io.serialization.option.LiteralDatatypePolicyEnum; +import fr.inria.corese.core.next.data.impl.io.serialization.ntriples.NTriplesSerializerOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.option.LiteralDatatypePolicyEnum; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/ntriples/NTriplesSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/ntriples/NTriplesSerializerTest.java index 338593811..49bdb86f5 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/ntriples/NTriplesSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/ntriples/NTriplesSerializerTest.java @@ -1,8 +1,10 @@ package fr.inria.corese.core.next.impl.io.serialization.ntriples; -import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.impl.io.serialization.ntriples.NTriplesSerializer; +import fr.inria.corese.core.next.data.impl.io.serialization.ntriples.NTriplesSerializerOptions; import fr.inria.corese.core.next.impl.io.serialization.TestStatementFactory; -import fr.inria.corese.core.next.impl.exception.SerializationException; +import fr.inria.corese.core.next.data.impl.exception.SerializationException; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/rdfxml/RDFXMLSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/rdfxml/RDFXMLSerializerTest.java index e05250020..d5f9d73ce 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/rdfxml/RDFXMLSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/rdfxml/RDFXMLSerializerTest.java @@ -1,22 +1,21 @@ package fr.inria.corese.core.next.impl.io.serialization.rdfxml; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.api.io.IOOptions; -import fr.inria.corese.core.next.impl.common.prefix.PrefixHandler; -import fr.inria.corese.core.next.impl.common.vocabulary.XSD; -import fr.inria.corese.core.next.impl.exception.SerializationException; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.io.IOOptions; +import fr.inria.corese.core.next.data.impl.common.vocabulary.XSD; +import fr.inria.corese.core.next.data.impl.exception.SerializationException; +import fr.inria.corese.core.next.data.impl.io.serialization.rdfxml.RDFXMLSerializer; +import fr.inria.corese.core.next.data.impl.io.serialization.rdfxml.RDFXMLSerializerOptions; import fr.inria.corese.core.next.impl.io.serialization.TestStatementFactory; -import fr.inria.corese.core.next.impl.io.serialization.option.LiteralDatatypePolicyEnum; -import fr.inria.corese.core.next.impl.io.serialization.option.PrefixOrderingEnum; +import fr.inria.corese.core.next.data.impl.io.serialization.option.LiteralDatatypePolicyEnum; +import fr.inria.corese.core.next.data.impl.io.serialization.option.PrefixOrderingEnum; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.mockito.Mock; import org.mockito.MockitoAnnotations; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; import java.io.StringWriter; import java.util.stream.Stream; @@ -187,7 +186,7 @@ void shouldSerializeLiteralWithCustomDatatypeMinimalPolicy() throws Serializatio Statement stmt = factory.createStatement( factory.createIRI("http://example.org/data"), factory.createIRI("http://example.org/vocabulary/value"), - factory.createLiteral("123", fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdInteger.getIRI(), null) + factory.createLiteral("123", XSD.xsdInteger.getIRI(), null) ); when(mockModel.stream()).thenReturn(Stream.of(stmt)); diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/rdfxml/XmlConfigTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/rdfxml/XmlConfigTest.java index dbf9085f2..a6a507e11 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/rdfxml/XmlConfigTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/rdfxml/XmlConfigTest.java @@ -1,13 +1,14 @@ package fr.inria.corese.core.next.impl.io.serialization.rdfxml; -import fr.inria.corese.core.next.impl.common.prefix.PrefixHandler; -import fr.inria.corese.core.next.impl.common.vocabulary.OWL; -import fr.inria.corese.core.next.impl.common.vocabulary.RDF; -import fr.inria.corese.core.next.impl.common.vocabulary.RDFS; -import fr.inria.corese.core.next.impl.common.vocabulary.XSD; -import fr.inria.corese.core.next.impl.io.serialization.option.LiteralDatatypePolicyEnum; -import fr.inria.corese.core.next.impl.io.serialization.option.PrefixOrderingEnum; -import fr.inria.corese.core.next.impl.io.serialization.util.SerializationConstants; +import fr.inria.corese.core.next.data.impl.common.prefix.PrefixHandler; +import fr.inria.corese.core.next.data.impl.common.vocabulary.OWL; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDFS; +import fr.inria.corese.core.next.data.impl.common.vocabulary.XSD; +import fr.inria.corese.core.next.data.impl.io.serialization.option.LiteralDatatypePolicyEnum; +import fr.inria.corese.core.next.data.impl.io.serialization.option.PrefixOrderingEnum; +import fr.inria.corese.core.next.data.impl.io.serialization.rdfxml.RDFXMLSerializerOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.util.SerializationConstants; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/trig/TriGSerializerOptionsTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/trig/TriGSerializerOptionsTest.java index 4224a9dc2..a3fc664c2 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/trig/TriGSerializerOptionsTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/trig/TriGSerializerOptionsTest.java @@ -1,14 +1,15 @@ package fr.inria.corese.core.next.impl.io.serialization.trig; -import fr.inria.corese.core.next.impl.common.prefix.PrefixHandler; -import fr.inria.corese.core.next.impl.common.vocabulary.OWL; -import fr.inria.corese.core.next.impl.common.vocabulary.RDF; -import fr.inria.corese.core.next.impl.common.vocabulary.RDFS; -import fr.inria.corese.core.next.impl.common.vocabulary.XSD; -import fr.inria.corese.core.next.impl.io.serialization.option.BlankNodeStyleEnum; -import fr.inria.corese.core.next.impl.io.serialization.option.LiteralDatatypePolicyEnum; -import fr.inria.corese.core.next.impl.io.serialization.option.PrefixOrderingEnum; -import fr.inria.corese.core.next.impl.io.serialization.util.SerializationConstants; +import fr.inria.corese.core.next.data.impl.common.prefix.PrefixHandler; +import fr.inria.corese.core.next.data.impl.common.vocabulary.OWL; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDFS; +import fr.inria.corese.core.next.data.impl.common.vocabulary.XSD; +import fr.inria.corese.core.next.data.impl.io.serialization.option.BlankNodeStyleEnum; +import fr.inria.corese.core.next.data.impl.io.serialization.option.LiteralDatatypePolicyEnum; +import fr.inria.corese.core.next.data.impl.io.serialization.option.PrefixOrderingEnum; +import fr.inria.corese.core.next.data.impl.io.serialization.trig.TriGSerializerOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.util.SerializationConstants; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/trig/TriGSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/trig/TriGSerializerTest.java index fa5f04a65..2dfc6fddf 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/trig/TriGSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/trig/TriGSerializerTest.java @@ -1,13 +1,15 @@ package fr.inria.corese.core.next.impl.io.serialization.trig; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.impl.common.literal.RDF; -import fr.inria.corese.core.next.impl.common.literal.XSD; -import fr.inria.corese.core.next.impl.exception.SerializationException; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.exception.SerializationException; +import fr.inria.corese.core.next.data.impl.io.serialization.trig.TriGSerializer; +import fr.inria.corese.core.next.data.impl.io.serialization.trig.TriGSerializerOptions; import fr.inria.corese.core.next.impl.io.serialization.TestStatementFactory; -import fr.inria.corese.core.next.impl.io.serialization.option.LiteralDatatypePolicyEnum; +import fr.inria.corese.core.next.data.impl.io.serialization.option.LiteralDatatypePolicyEnum; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -88,7 +90,7 @@ void testRdfTypeShortcut() throws SerializationException { Statement mockStatement = factory.createStatement( factory.createIRI("http://example.org/ns/person1"), - fr.inria.corese.core.next.impl.common.vocabulary.RDF.type.getIRI(), + RDF.type.getIRI(), factory.createIRI("http://xmlns.com/foaf/0.1/Person"), null ); @@ -297,7 +299,7 @@ void testStrictModeInvalidLiteral() throws SerializationException { Statement mockStatement = factory.createStatement( factory.createIRI("http://example.org/s"), factory.createIRI("http://example.org/p"), - factory.createLiteral("invalid", RDF.LANGSTRING.getIRI(), null), + factory.createLiteral("invalid", fr.inria.corese.core.next.data.impl.common.literal.RDF.LANGSTRING.getIRI(), null), null ); diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/turtle/TurtleSerializerOptionsTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/turtle/TurtleSerializerOptionsTest.java index 8a96d7856..b547d9782 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/turtle/TurtleSerializerOptionsTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/turtle/TurtleSerializerOptionsTest.java @@ -1,14 +1,15 @@ package fr.inria.corese.core.next.impl.io.serialization.turtle; -import fr.inria.corese.core.next.impl.common.prefix.PrefixHandler; -import fr.inria.corese.core.next.impl.common.vocabulary.OWL; -import fr.inria.corese.core.next.impl.common.vocabulary.RDF; -import fr.inria.corese.core.next.impl.common.vocabulary.RDFS; -import fr.inria.corese.core.next.impl.common.vocabulary.XSD; -import fr.inria.corese.core.next.impl.io.serialization.option.BlankNodeStyleEnum; -import fr.inria.corese.core.next.impl.io.serialization.option.LiteralDatatypePolicyEnum; -import fr.inria.corese.core.next.impl.io.serialization.option.PrefixOrderingEnum; -import fr.inria.corese.core.next.impl.io.serialization.util.SerializationConstants; +import fr.inria.corese.core.next.data.impl.common.prefix.PrefixHandler; +import fr.inria.corese.core.next.data.impl.common.vocabulary.OWL; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDFS; +import fr.inria.corese.core.next.data.impl.common.vocabulary.XSD; +import fr.inria.corese.core.next.data.impl.io.serialization.option.BlankNodeStyleEnum; +import fr.inria.corese.core.next.data.impl.io.serialization.option.LiteralDatatypePolicyEnum; +import fr.inria.corese.core.next.data.impl.io.serialization.option.PrefixOrderingEnum; +import fr.inria.corese.core.next.data.impl.io.serialization.turtle.TurtleSerializerOptions; +import fr.inria.corese.core.next.data.impl.io.serialization.util.SerializationConstants; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/turtle/TurtleSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/turtle/TurtleSerializerTest.java index 4a33b006e..0b4268b7c 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/turtle/TurtleSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/io/serialization/turtle/TurtleSerializerTest.java @@ -1,16 +1,16 @@ package fr.inria.corese.core.next.impl.io.serialization.turtle; -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.impl.common.literal.RDF; -import fr.inria.corese.core.next.impl.common.literal.XSD; -import fr.inria.corese.core.next.impl.common.prefix.PrefixHandler; -import fr.inria.corese.core.next.impl.exception.SerializationException; -import fr.inria.corese.core.next.impl.io.parser.ParserFactory; +import fr.inria.corese.core.next.data.api.*; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.common.prefix.PrefixHandler; +import fr.inria.corese.core.next.data.impl.exception.SerializationException; +import fr.inria.corese.core.next.data.impl.io.serialization.turtle.TurtleSerializer; +import fr.inria.corese.core.next.data.impl.io.serialization.turtle.TurtleSerializerOptions; import fr.inria.corese.core.next.impl.io.serialization.TestStatementFactory; -import fr.inria.corese.core.next.impl.io.serialization.option.LiteralDatatypePolicyEnum; -import fr.inria.corese.core.next.impl.exception.SerializationException; -import fr.inria.corese.core.next.impl.temp.CoreseAdaptedValueFactory; -import fr.inria.corese.core.next.impl.temp.CoreseModel; +import fr.inria.corese.core.next.data.impl.io.serialization.option.LiteralDatatypePolicyEnum; +import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; +import fr.inria.corese.core.next.data.impl.temp.CoreseModel; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; @@ -91,7 +91,7 @@ void testRdfTypeShortcut() throws SerializationException { Statement mockStatement = factory.createStatement( factory.createIRI("http://example.org/ns/person1"), - fr.inria.corese.core.next.impl.common.vocabulary.RDF.type.getIRI(), + RDF.type.getIRI(), factory.createIRI("http://xmlns.com/foaf/0.1/Person"), null ); @@ -434,7 +434,7 @@ void testStrictModeInvalidLiteral() throws SerializationException { Statement mockStatement = factory.createStatement( factory.createIRI("http://example.org/s"), factory.createIRI("http://example.org/p"), - factory.createLiteral("invalid", RDF.LANGSTRING.getIRI(), null), + factory.createLiteral("invalid", fr.inria.corese.core.next.data.impl.common.literal.RDF.LANGSTRING.getIRI(), null), null ); diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseAdaptedValueFactoryTest.java b/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseAdaptedValueFactoryTest.java index c354ce00a..af3fe8858 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseAdaptedValueFactoryTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseAdaptedValueFactoryTest.java @@ -2,17 +2,21 @@ import java.time.Duration; +import fr.inria.corese.core.next.data.impl.common.vocabulary.XSD; +import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; +import fr.inria.corese.core.next.data.impl.temp.CoreseIRI; +import fr.inria.corese.core.next.data.impl.temp.CoreseNodeAdapter; +import fr.inria.corese.core.next.data.impl.temp.CoreseStatement; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Literal; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.model.ValueFactoryTest; -import fr.inria.corese.core.next.impl.common.literal.RDF; -import fr.inria.corese.core.next.impl.common.literal.XSD; -import fr.inria.corese.core.next.impl.temp.literal.CoreseLanguageTaggedStringLiteral; -import fr.inria.corese.core.next.impl.temp.literal.CoreseTyped; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Literal; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.model.ValueFactoryTest; +import fr.inria.corese.core.next.data.impl.common.literal.RDF; +import fr.inria.corese.core.next.data.impl.temp.literal.CoreseLanguageTaggedStringLiteral; +import fr.inria.corese.core.next.data.impl.temp.literal.CoreseTyped; import static org.junit.jupiter.api.Assertions.*; @@ -30,7 +34,7 @@ public class CoreseAdaptedValueFactoryTest extends ValueFactoryTest { public void setUp() { this.valueFactory = new CoreseAdaptedValueFactory(); stringTestValue = "String value"; - xsdStringIRI = XSD.STRING.getIRI(); + xsdStringIRI = fr.inria.corese.core.next.data.impl.common.literal.XSD.STRING.getIRI(); subject = new CoreseIRI("http://corese.com/subject"); predicate = new CoreseIRI("http://corese.com/predicate"); } @@ -52,7 +56,7 @@ public void testCreateLiteralWithLabel() { assertNotNull(literal); assertTrue(literal instanceof CoreseTyped); assertEquals(stringTestValue, literal.getLabel()); - assertEquals(XSD.STRING, literal.getCoreDatatype()); + assertEquals(fr.inria.corese.core.next.data.impl.common.literal.XSD.STRING, literal.getCoreDatatype()); } @Test @@ -77,34 +81,34 @@ public void testCreateLiteralWithDatatypeIRI() { assertNotNull(literal); assertTrue(literal instanceof CoreseTyped); assertEquals(stringTestValue, literal.getLabel()); - assertEquals(XSD.STRING, literal.getCoreDatatype()); + assertEquals(fr.inria.corese.core.next.data.impl.common.literal.XSD.STRING, literal.getCoreDatatype()); } @Test public void testCreateLiteralWithCoreDatatype() { // Test createLiteral with CoreDatatype (XSD.STRING) - Literal literal = valueFactory.createLiteral(stringTestValue, XSD.STRING); + Literal literal = valueFactory.createLiteral(stringTestValue, fr.inria.corese.core.next.data.impl.common.literal.XSD.STRING); assertNotNull(literal); assertTrue(literal instanceof CoreseTyped); assertEquals(stringTestValue, literal.getLabel()); - assertEquals(XSD.STRING, literal.getCoreDatatype()); + assertEquals(fr.inria.corese.core.next.data.impl.common.literal.XSD.STRING, literal.getCoreDatatype()); } @Test public void testCreateLiteralWithDatatypeIRIAndCoreDatatype() { // Test createLiteral with IRI datatype and CoreDatatype (XSD.STRING) - Literal literal = valueFactory.createLiteral(stringTestValue, xsdStringIRI, XSD.STRING); + Literal literal = valueFactory.createLiteral(stringTestValue, xsdStringIRI, fr.inria.corese.core.next.data.impl.common.literal.XSD.STRING); assertNotNull(literal); assertTrue(literal instanceof CoreseTyped); assertEquals(stringTestValue, literal.getLabel()); - assertEquals(XSD.STRING, literal.getCoreDatatype()); + assertEquals(fr.inria.corese.core.next.data.impl.common.literal.XSD.STRING, literal.getCoreDatatype()); } @Test public void testCreateStatementWithoutContext() { - Literal literal = valueFactory.createLiteral(stringTestValue, xsdStringIRI, XSD.STRING); + Literal literal = valueFactory.createLiteral(stringTestValue, xsdStringIRI, fr.inria.corese.core.next.data.impl.common.literal.XSD.STRING); CoreseStatement statement = (CoreseStatement) valueFactory.createStatement(subject, predicate, literal); assertNotNull(statement); assertEquals(subject, statement.getSubject()); @@ -115,7 +119,7 @@ public void testCreateStatementWithoutContext() { @Test public void testCreateStatementWithContext() { - Literal literal = valueFactory.createLiteral(stringTestValue, xsdStringIRI, XSD.STRING); + Literal literal = valueFactory.createLiteral(stringTestValue, xsdStringIRI, fr.inria.corese.core.next.data.impl.common.literal.XSD.STRING); CoreseStatement statement = (CoreseStatement) valueFactory.createStatement(subject, predicate, literal, context); @@ -140,7 +144,7 @@ public void testDateCreation() { Literal date = valueFactory.createLiteral(literalStringValue, xsdDate); assertNotNull(date); - assertEquals(fr.inria.corese.core.next.impl.common.vocabulary.XSD.xsdDate.getIRI().stringValue(), date.getDatatype().stringValue()); + assertEquals(XSD.xsdDate.getIRI().stringValue(), date.getDatatype().stringValue()); assertEquals(literalStringValue, date.getLabel()); assertInstanceOf(fr.inria.corese.core.sparql.datatype.CoreseDate.class, ((CoreseNodeAdapter) date).getCoreseNode()); } diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseIRITest.java b/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseIRITest.java index 4d0486718..d1e4f3c6e 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseIRITest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseIRITest.java @@ -3,11 +3,12 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertThrows; +import fr.inria.corese.core.next.data.impl.temp.CoreseIRI; import org.junit.jupiter.api.Test; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.IRITest; -import fr.inria.corese.core.next.impl.exception.IncorrectFormatException; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.IRITest; +import fr.inria.corese.core.next.data.impl.exception.IncorrectFormatException; public class CoreseIRITest extends IRITest { diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseModelTest.java b/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseModelTest.java index 04d2d381f..9bd80d32c 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseModelTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseModelTest.java @@ -3,12 +3,16 @@ import fr.inria.corese.core.Graph; import fr.inria.corese.core.kgram.api.core.Edge; import fr.inria.corese.core.kgram.api.core.Node; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.Namespace; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Statement; -import fr.inria.corese.core.next.impl.common.vocabulary.RDF; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Model; +import fr.inria.corese.core.next.data.api.Namespace; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF; +import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; +import fr.inria.corese.core.next.data.impl.temp.CoreseIRI; +import fr.inria.corese.core.next.data.impl.temp.CoreseModel; +import fr.inria.corese.core.next.data.impl.temp.CoreseValueConverter; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseStatementTest.java b/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseStatementTest.java index 34c78ea11..59c299470 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseStatementTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseStatementTest.java @@ -4,10 +4,12 @@ import fr.inria.corese.core.edge.EdgeImpl; import fr.inria.corese.core.kgram.api.core.Edge; import fr.inria.corese.core.kgram.api.core.Node; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Resource; -import fr.inria.corese.core.next.api.Value; -import fr.inria.corese.core.next.impl.temp.literal.CoreseInteger; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Resource; +import fr.inria.corese.core.next.data.api.Value; +import fr.inria.corese.core.next.data.impl.temp.CoreseIRI; +import fr.inria.corese.core.next.data.impl.temp.CoreseStatement; +import fr.inria.corese.core.next.data.impl.temp.literal.CoreseInteger; import fr.inria.corese.core.sparql.datatype.DatatypeMap; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/AbstractCoreseNumberTest.java b/src/test/java/fr/inria/corese/core/next/impl/temp/literal/AbstractCoreseNumberTest.java index d81186bd2..3d3cc251c 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/AbstractCoreseNumberTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/temp/literal/AbstractCoreseNumberTest.java @@ -5,6 +5,7 @@ import java.math.BigInteger; +import fr.inria.corese.core.next.data.impl.temp.literal.AbstractCoreseNumber; import org.junit.jupiter.api.Test; public abstract class AbstractCoreseNumberTest { diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseBNodeTest.java b/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseBNodeTest.java index 1b2058d83..c9016a51d 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseBNodeTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseBNodeTest.java @@ -3,6 +3,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; +import fr.inria.corese.core.next.data.impl.temp.literal.CoreseBNode; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseBooleanTest.java b/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseBooleanTest.java index 7f28c38c1..7fa09dd34 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseBooleanTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseBooleanTest.java @@ -1,6 +1,7 @@ package fr.inria.corese.core.next.impl.temp.literal; -import fr.inria.corese.core.next.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.temp.literal.CoreseBoolean; import fr.inria.corese.core.sparql.api.IDatatype; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDateTest.java b/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDateTest.java index 34c6a1fb4..9340a83cc 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDateTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDateTest.java @@ -1,6 +1,7 @@ package fr.inria.corese.core.next.impl.temp.literal; -import fr.inria.corese.core.next.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.temp.literal.CoreseDate; import org.junit.jupiter.api.Test; import javax.xml.datatype.DatatypeFactory; diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDatetimeTest.java b/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDatetimeTest.java index e7860bc0b..6f5f8b059 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDatetimeTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDatetimeTest.java @@ -1,6 +1,7 @@ package fr.inria.corese.core.next.impl.temp.literal; -import fr.inria.corese.core.next.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.temp.literal.CoreseDatetime; import org.junit.jupiter.api.Test; import javax.xml.datatype.DatatypeFactory; diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDecimalTest.java b/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDecimalTest.java index 22f14385b..4e9dda104 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDecimalTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDecimalTest.java @@ -1,6 +1,8 @@ package fr.inria.corese.core.next.impl.temp.literal; -import fr.inria.corese.core.next.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.temp.literal.AbstractCoreseNumber; +import fr.inria.corese.core.next.data.impl.temp.literal.CoreseDecimal; import fr.inria.corese.core.sparql.datatype.CoreseNumber; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseIntegerTest.java b/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseIntegerTest.java index 52e8326fe..44ef3c5e2 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseIntegerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseIntegerTest.java @@ -4,9 +4,11 @@ import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertTrue; +import fr.inria.corese.core.next.data.impl.temp.literal.AbstractCoreseNumber; +import fr.inria.corese.core.next.data.impl.temp.literal.CoreseInteger; import org.junit.jupiter.api.Test; -import fr.inria.corese.core.next.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; import fr.inria.corese.core.sparql.datatype.CoreseNumber; public class CoreseIntegerTest extends AbstractCoreseNumberTest { diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseLanguageTaggedStringTest.java b/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseLanguageTaggedStringTest.java index a53605803..b0057034c 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseLanguageTaggedStringTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseLanguageTaggedStringTest.java @@ -1,6 +1,7 @@ package fr.inria.corese.core.next.impl.temp.literal; -import fr.inria.corese.core.next.impl.common.literal.RDF; +import fr.inria.corese.core.next.data.impl.common.literal.RDF; +import fr.inria.corese.core.next.data.impl.temp.literal.CoreseLanguageTaggedStringLiteral; import fr.inria.corese.core.sparql.api.IDatatype; import fr.inria.corese.core.sparql.datatype.CoreseLiteral; import org.junit.jupiter.api.BeforeEach; diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseTypedTest.java b/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseTypedTest.java index f2fc2d23f..189a08f74 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseTypedTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseTypedTest.java @@ -1,11 +1,12 @@ package fr.inria.corese.core.next.impl.temp.literal; -import fr.inria.corese.core.next.impl.common.literal.XSD; -import fr.inria.corese.core.next.impl.exception.IncorrectOperationException; -import fr.inria.corese.core.next.api.IRI; -import fr.inria.corese.core.next.api.Literal; -import fr.inria.corese.core.next.api.literal.CoreDatatype; -import fr.inria.corese.core.next.impl.temp.CoreseIRI; +import fr.inria.corese.core.next.data.impl.common.literal.XSD; +import fr.inria.corese.core.next.data.impl.exception.IncorrectOperationException; +import fr.inria.corese.core.next.data.api.IRI; +import fr.inria.corese.core.next.data.api.Literal; +import fr.inria.corese.core.next.data.api.literal.CoreDatatype; +import fr.inria.corese.core.next.data.impl.temp.CoreseIRI; +import fr.inria.corese.core.next.data.impl.temp.literal.CoreseTyped; import fr.inria.corese.core.sparql.api.IDatatype; import fr.inria.corese.core.sparql.datatype.CoreseString; import org.junit.jupiter.api.BeforeEach; diff --git a/src/test/java/fr/inria/corese/core/next/kgram/adapter/BindingAdapterTest.java b/src/test/java/fr/inria/corese/core/next/kgram/adapter/BindingAdapterTest.java index 5d5135545..be4ae2a50 100644 --- a/src/test/java/fr/inria/corese/core/next/kgram/adapter/BindingAdapterTest.java +++ b/src/test/java/fr/inria/corese/core/next/kgram/adapter/BindingAdapterTest.java @@ -1,7 +1,9 @@ package fr.inria.corese.core.next.kgram.adapter; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.core.Mappings; +import fr.inria.corese.core.next.query.kgram.adapter.BindingAdapter; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.core.Mappings; +import fr.inria.corese.core.next.query.kgram.core.Exp; import fr.inria.corese.core.sparql.api.IDatatype; import fr.inria.corese.core.sparql.triple.function.term.Binding; import org.junit.jupiter.api.BeforeEach; @@ -168,8 +170,8 @@ class VisitTests { @Test @DisplayName("Should visit with next kgram types") void testVisitNextKgramTypes() { - fr.inria.corese.core.next.kgram.core.Exp mockExp = - mock(fr.inria.corese.core.next.kgram.core.Exp.class); + Exp mockExp = + mock(Exp.class); Mappings mockMappings1 = mock(Mappings.class); Mappings mockMappings2 = mock(Mappings.class); @@ -197,8 +199,8 @@ void testVisitLegacyKgramTypes() { @Test @DisplayName("Should handle visit with null parameters") void testVisitWithNullParameters() { - fr.inria.corese.core.next.kgram.core.Exp mockExp = - mock(fr.inria.corese.core.next.kgram.core.Exp.class); + Exp mockExp = + mock(Exp.class); assertDoesNotThrow(() -> adapter.visit(mockExp, null, null, null), "Should not throw when visiting with null parameters"); diff --git a/src/test/java/fr/inria/corese/core/next/kgram/adapter/DatatypeAdapterTest.java b/src/test/java/fr/inria/corese/core/next/kgram/adapter/DatatypeAdapterTest.java index 2fa11454b..ae6a4bb11 100644 --- a/src/test/java/fr/inria/corese/core/next/kgram/adapter/DatatypeAdapterTest.java +++ b/src/test/java/fr/inria/corese/core/next/kgram/adapter/DatatypeAdapterTest.java @@ -1,6 +1,7 @@ package fr.inria.corese.core.next.kgram.adapter; -import fr.inria.corese.core.next.kgram.api.core.DatatypeValue; +import fr.inria.corese.core.next.query.kgram.adapter.DatatypeAdapter; +import fr.inria.corese.core.next.query.kgram.api.core.DatatypeValue; import fr.inria.corese.core.sparql.api.IDatatype; import fr.inria.corese.core.sparql.exceptions.CoreseDatatypeException; import org.junit.jupiter.api.BeforeEach; diff --git a/src/test/java/fr/inria/corese/core/next/kgram/core/EvalTest.java b/src/test/java/fr/inria/corese/core/next/kgram/core/EvalTest.java index 646eb567c..f09b055d9 100644 --- a/src/test/java/fr/inria/corese/core/next/kgram/core/EvalTest.java +++ b/src/test/java/fr/inria/corese/core/next/kgram/core/EvalTest.java @@ -1,9 +1,12 @@ package fr.inria.corese.core.next.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.BindingContext; -import fr.inria.corese.core.next.kgram.api.query.*; -import fr.inria.corese.core.next.kgram.event.EventManager; -import fr.inria.corese.core.next.kgram.event.ResultListener; +import fr.inria.corese.core.next.query.kgram.api.core.BindingContext; +import fr.inria.corese.core.next.query.kgram.api.query.*; +import fr.inria.corese.core.next.query.kgram.core.Eval; +import fr.inria.corese.core.next.query.kgram.core.Mappings; +import fr.inria.corese.core.next.query.kgram.core.Memory; +import fr.inria.corese.core.next.query.kgram.event.EventManager; +import fr.inria.corese.core.next.query.kgram.event.ResultListener; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Nested; diff --git a/src/test/java/fr/inria/corese/core/next/kgram/core/ExpTest.java b/src/test/java/fr/inria/corese/core/next/kgram/core/ExpTest.java index e8b031373..420894a25 100644 --- a/src/test/java/fr/inria/corese/core/next/kgram/core/ExpTest.java +++ b/src/test/java/fr/inria/corese/core/next/kgram/core/ExpTest.java @@ -1,7 +1,10 @@ package fr.inria.corese.core.next.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.*; -import fr.inria.corese.core.next.kgram.api.query.Producer; +import fr.inria.corese.core.next.query.kgram.api.core.*; +import fr.inria.corese.core.next.query.kgram.api.query.Producer; +import fr.inria.corese.core.next.query.kgram.core.Exp; +import fr.inria.corese.core.next.query.kgram.core.Mappings; +import fr.inria.corese.core.next.query.kgram.core.Stack; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Nested; diff --git a/src/test/java/fr/inria/corese/core/next/kgram/core/MappingTest.java b/src/test/java/fr/inria/corese/core/next/kgram/core/MappingTest.java index d8b1af9b3..f2a8c9dde 100644 --- a/src/test/java/fr/inria/corese/core/next/kgram/core/MappingTest.java +++ b/src/test/java/fr/inria/corese/core/next/kgram/core/MappingTest.java @@ -1,7 +1,8 @@ package fr.inria.corese.core.next.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.Edge; -import fr.inria.corese.core.next.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.core.Edge; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.core.Mapping; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Nested; diff --git a/src/test/java/fr/inria/corese/core/next/kgram/core/MappingsTest.java b/src/test/java/fr/inria/corese/core/next/kgram/core/MappingsTest.java index 894f268e2..3a98bc5ed 100644 --- a/src/test/java/fr/inria/corese/core/next/kgram/core/MappingsTest.java +++ b/src/test/java/fr/inria/corese/core/next/kgram/core/MappingsTest.java @@ -1,7 +1,11 @@ package fr.inria.corese.core.next.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.Edge; -import fr.inria.corese.core.next.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.core.Edge; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.core.Eval; +import fr.inria.corese.core.next.query.kgram.core.Mapping; +import fr.inria.corese.core.next.query.kgram.core.Mappings; +import fr.inria.corese.core.next.query.kgram.core.Query; import fr.inria.corese.core.sparql.api.IDatatype; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; diff --git a/src/test/java/fr/inria/corese/core/next/kgram/core/MemoryTest.java b/src/test/java/fr/inria/corese/core/next/kgram/core/MemoryTest.java index b5449b0ec..7a5b6851c 100644 --- a/src/test/java/fr/inria/corese/core/next/kgram/core/MemoryTest.java +++ b/src/test/java/fr/inria/corese/core/next/kgram/core/MemoryTest.java @@ -1,11 +1,12 @@ package fr.inria.corese.core.next.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.BindingContext; -import fr.inria.corese.core.next.kgram.api.core.ExpType; -import fr.inria.corese.core.next.kgram.api.core.Node; -import fr.inria.corese.core.next.kgram.api.query.Evaluator; -import fr.inria.corese.core.next.kgram.api.query.Matcher; -import fr.inria.corese.core.next.kgram.api.query.ProcessVisitor; +import fr.inria.corese.core.next.query.kgram.api.core.BindingContext; +import fr.inria.corese.core.next.query.kgram.api.core.ExpType; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.query.Evaluator; +import fr.inria.corese.core.next.query.kgram.api.query.Matcher; +import fr.inria.corese.core.next.query.kgram.api.query.ProcessVisitor; +import fr.inria.corese.core.next.query.kgram.core.*; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Nested; diff --git a/src/test/java/fr/inria/corese/core/next/kgram/core/QueryTest.java b/src/test/java/fr/inria/corese/core/next/kgram/core/QueryTest.java index 4a3b5050a..0030d872d 100644 --- a/src/test/java/fr/inria/corese/core/next/kgram/core/QueryTest.java +++ b/src/test/java/fr/inria/corese/core/next/kgram/core/QueryTest.java @@ -1,8 +1,10 @@ package fr.inria.corese.core.next.kgram.core; -import fr.inria.corese.core.next.kgram.api.core.ExpType; -import fr.inria.corese.core.next.kgram.api.core.Filter; -import fr.inria.corese.core.next.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.api.core.ExpType; +import fr.inria.corese.core.next.query.kgram.api.core.Filter; +import fr.inria.corese.core.next.query.kgram.api.core.Node; +import fr.inria.corese.core.next.query.kgram.core.Exp; +import fr.inria.corese.core.next.query.kgram.core.Query; import fr.inria.corese.core.sparql.triple.parser.ASTExtension; import fr.inria.corese.core.sparql.triple.parser.ASTQuery; import org.junit.jupiter.api.BeforeEach; From 699836ff1b4048dc887c37117f0995df47a53e28 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Wed, 4 Feb 2026 16:10:55 +0100 Subject: [PATCH 8/9] Refactor DataManager architecture new Model --- .../inria/corese/core/next/api/query/GraphQuery.java | 10 ---------- .../core/next/{ => data}/api/query/BooleanQuery.java | 4 ++-- .../corese/core/next/data/api/query/GraphQuery.java | 10 ++++++++++ .../core/next/{ => data}/api/query/Operation.java | 8 ++++---- .../corese/core/next/{ => data}/api/query/Query.java | 10 ++++++---- .../next/{ => data}/api/query/QueryLanguage.java | 6 +++--- .../core/next/{ => data}/api/query/Transformer.java | 4 ++-- .../core/next/{ => data}/api/query/TupleQuery.java | 6 +++--- .../core/next/{ => data}/api/query/Update.java | 6 +++--- .../next/{ => data}/api/query/dataset/Dataset.java | 2 +- .../query/exception/QueryEvaluationException.java | 2 +- .../api/query/exception/QueryException.java | 5 +++-- .../api/query/exception/QuerySyntaxException.java | 2 +- .../api/query/exception/QueryTimeoutException.java | 2 +- .../api/query/exception/RepositoryException.java | 9 ++++++--- .../{ => data}/api/query/repository/Repository.java | 6 +++--- .../api/query/repository/RepositoryConnection.java | 12 ++++++------ .../next/{ => data}/api/query/result/Binding.java | 6 +++--- .../next/{ => data}/api/query/result/BindingSet.java | 7 ++++--- .../api/query/result/GraphQueryResult.java | 9 +++++---- .../api/query/result/TupleQueryResult.java | 8 +++++--- .../next/data/impl/exception/SparqlException.java | 4 ++-- .../next/impl/query/CoreseQueryArtifactAdapter.java | 4 ---- .../corese/core/next/impl/query/ast/AskQueryAst.java | 4 ---- .../core/next/impl/query/ast/ConstructQueryAst.java | 4 ---- .../core/next/impl/query/ast/DescribeQueryAst.java | 4 ---- .../corese/core/next/impl/query/ast/QueryAst.java | 4 ---- .../core/next/impl/query/ast/SelectQueryAst.java | 4 ---- .../impl/query/bridge/CoreseAstQueryBuilder.java | 4 ---- .../next/impl/query/bridge/CoresePatternBuilder.java | 4 ---- .../next/impl/query/bridge/CoreseTermAdapter.java | 4 ---- .../core/next/impl/query/parser/SparqlListener.java | 4 ---- .../core/next/impl/query/parser/SparqlOptions.java | 4 ---- .../core/next/impl/query/result/CoreseBinding.java | 4 ---- .../next/impl/query/result/CoreseBindingSet.java | 4 ---- .../impl/query/result/CoreseGraphQueryResult.java | 4 ---- .../impl/query/result/CoreseTupleQueryResult.java | 4 ---- .../core/next/impl/query/wrapper/CoreseBinding.java | 4 ---- .../next/impl/query/wrapper/CoreseBindingSet.java | 4 ---- .../impl/query/wrapper/CoreseGraphQueryResult.java | 4 ---- .../impl/query/wrapper/CoreseTupleQueryResult.java | 4 ---- .../query/sparql/CoreseQueryArtifactAdapter.java | 4 ++++ .../core/next/query/sparql/ast/AskQueryAst.java | 4 ++++ .../next/query/sparql/ast/ConstructQueryAst.java | 4 ++++ .../core/next/query/sparql/ast/DescribeQueryAst.java | 4 ++++ .../corese/core/next/query/sparql/ast/QueryAst.java | 4 ++++ .../core/next/query/sparql/ast/SelectQueryAst.java | 4 ++++ .../query/sparql/bridge/CoreseAstQueryBuilder.java | 4 ++++ .../query/sparql/bridge/CoresePatternBuilder.java | 4 ++++ .../next/query/sparql/bridge/CoreseTermAdapter.java | 4 ++++ .../sparql}/parser/SparqlAstBuilder.java | 2 +- .../next/query/sparql/parser/SparqlListener.java | 4 ++++ .../core/next/query/sparql/parser/SparqlOptions.java | 4 ++++ .../query => query/sparql}/parser/SparqlParser.java | 2 +- .../core/next/query/sparql/result/CoreseBinding.java | 4 ++++ .../next/query/sparql/result/CoreseBindingSet.java | 4 ++++ .../query/sparql/result/CoreseGraphQueryResult.java | 4 ++++ .../query/sparql/result/CoreseTupleQueryResult.java | 4 ++++ .../next/query/sparql/wrapper/CoreseBinding.java | 4 ++++ .../next/query/sparql/wrapper/CoreseBindingSet.java | 4 ++++ .../query/sparql/wrapper/CoreseGraphQueryResult.java | 4 ++++ .../query/sparql/wrapper/CoreseTupleQueryResult.java | 4 ++++ 62 files changed, 152 insertions(+), 142 deletions(-) delete mode 100644 src/main/java/fr/inria/corese/core/next/api/query/GraphQuery.java rename src/main/java/fr/inria/corese/core/next/{ => data}/api/query/BooleanQuery.java (74%) create mode 100644 src/main/java/fr/inria/corese/core/next/data/api/query/GraphQuery.java rename src/main/java/fr/inria/corese/core/next/{ => data}/api/query/Operation.java (91%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/query/Query.java (80%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/query/QueryLanguage.java (83%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/query/Transformer.java (93%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/query/TupleQuery.java (70%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/query/Update.java (76%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/query/dataset/Dataset.java (97%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/query/exception/QueryEvaluationException.java (93%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/query/exception/QueryException.java (84%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/query/exception/QuerySyntaxException.java (98%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/query/exception/QueryTimeoutException.java (97%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/query/exception/RepositoryException.java (71%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/query/repository/Repository.java (90%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/query/repository/RepositoryConnection.java (92%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/query/result/Binding.java (85%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/query/result/BindingSet.java (86%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/query/result/GraphQueryResult.java (92%) rename src/main/java/fr/inria/corese/core/next/{ => data}/api/query/result/TupleQueryResult.java (94%) delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/query/CoreseQueryArtifactAdapter.java delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/query/ast/AskQueryAst.java delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/query/ast/ConstructQueryAst.java delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/query/ast/DescribeQueryAst.java delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/query/ast/QueryAst.java delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/query/ast/SelectQueryAst.java delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/query/bridge/CoreseAstQueryBuilder.java delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/query/bridge/CoresePatternBuilder.java delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/query/bridge/CoreseTermAdapter.java delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/query/parser/SparqlListener.java delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/query/parser/SparqlOptions.java delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/query/result/CoreseBinding.java delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/query/result/CoreseBindingSet.java delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/query/result/CoreseGraphQueryResult.java delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/query/result/CoreseTupleQueryResult.java delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/query/wrapper/CoreseBinding.java delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/query/wrapper/CoreseBindingSet.java delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/query/wrapper/CoreseGraphQueryResult.java delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/query/wrapper/CoreseTupleQueryResult.java create mode 100644 src/main/java/fr/inria/corese/core/next/query/sparql/CoreseQueryArtifactAdapter.java create mode 100644 src/main/java/fr/inria/corese/core/next/query/sparql/ast/AskQueryAst.java create mode 100644 src/main/java/fr/inria/corese/core/next/query/sparql/ast/ConstructQueryAst.java create mode 100644 src/main/java/fr/inria/corese/core/next/query/sparql/ast/DescribeQueryAst.java create mode 100644 src/main/java/fr/inria/corese/core/next/query/sparql/ast/QueryAst.java create mode 100644 src/main/java/fr/inria/corese/core/next/query/sparql/ast/SelectQueryAst.java create mode 100644 src/main/java/fr/inria/corese/core/next/query/sparql/bridge/CoreseAstQueryBuilder.java create mode 100644 src/main/java/fr/inria/corese/core/next/query/sparql/bridge/CoresePatternBuilder.java create mode 100644 src/main/java/fr/inria/corese/core/next/query/sparql/bridge/CoreseTermAdapter.java rename src/main/java/fr/inria/corese/core/next/{impl/query => query/sparql}/parser/SparqlAstBuilder.java (58%) create mode 100644 src/main/java/fr/inria/corese/core/next/query/sparql/parser/SparqlListener.java create mode 100644 src/main/java/fr/inria/corese/core/next/query/sparql/parser/SparqlOptions.java rename src/main/java/fr/inria/corese/core/next/{impl/query => query/sparql}/parser/SparqlParser.java (73%) create mode 100644 src/main/java/fr/inria/corese/core/next/query/sparql/result/CoreseBinding.java create mode 100644 src/main/java/fr/inria/corese/core/next/query/sparql/result/CoreseBindingSet.java create mode 100644 src/main/java/fr/inria/corese/core/next/query/sparql/result/CoreseGraphQueryResult.java create mode 100644 src/main/java/fr/inria/corese/core/next/query/sparql/result/CoreseTupleQueryResult.java create mode 100644 src/main/java/fr/inria/corese/core/next/query/sparql/wrapper/CoreseBinding.java create mode 100644 src/main/java/fr/inria/corese/core/next/query/sparql/wrapper/CoreseBindingSet.java create mode 100644 src/main/java/fr/inria/corese/core/next/query/sparql/wrapper/CoreseGraphQueryResult.java create mode 100644 src/main/java/fr/inria/corese/core/next/query/sparql/wrapper/CoreseTupleQueryResult.java diff --git a/src/main/java/fr/inria/corese/core/next/api/query/GraphQuery.java b/src/main/java/fr/inria/corese/core/next/api/query/GraphQuery.java deleted file mode 100644 index 39b48899c..000000000 --- a/src/main/java/fr/inria/corese/core/next/api/query/GraphQuery.java +++ /dev/null @@ -1,10 +0,0 @@ -package fr.inria.corese.core.next.api.query; - -import fr.inria.corese.core.next.api.query.exception.QueryEvaluationException; -import fr.inria.corese.core.next.api.query.result.GraphQueryResult; - -public interface GraphQuery extends Query { - - @Override - GraphQueryResult evaluate() throws QueryEvaluationException; -} diff --git a/src/main/java/fr/inria/corese/core/next/api/query/BooleanQuery.java b/src/main/java/fr/inria/corese/core/next/data/api/query/BooleanQuery.java similarity index 74% rename from src/main/java/fr/inria/corese/core/next/api/query/BooleanQuery.java rename to src/main/java/fr/inria/corese/core/next/data/api/query/BooleanQuery.java index 7f364fbf2..52ba72dc7 100644 --- a/src/main/java/fr/inria/corese/core/next/api/query/BooleanQuery.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/query/BooleanQuery.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.api.query; +package fr.inria.corese.core.next.data.api.query; -import fr.inria.corese.core.next.api.query.exception.QueryEvaluationException; +import fr.inria.corese.core.next.data.api.query.exception.QueryEvaluationException; public interface BooleanQuery extends Query { /** diff --git a/src/main/java/fr/inria/corese/core/next/data/api/query/GraphQuery.java b/src/main/java/fr/inria/corese/core/next/data/api/query/GraphQuery.java new file mode 100644 index 000000000..975bec992 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/data/api/query/GraphQuery.java @@ -0,0 +1,10 @@ +package fr.inria.corese.core.next.data.api.query; + +import fr.inria.corese.core.next.data.api.query.exception.QueryEvaluationException; +import fr.inria.corese.core.next.data.api.query.result.GraphQueryResult; + +public interface GraphQuery extends Query { + + @Override + GraphQueryResult evaluate() throws QueryEvaluationException; +} diff --git a/src/main/java/fr/inria/corese/core/next/api/query/Operation.java b/src/main/java/fr/inria/corese/core/next/data/api/query/Operation.java similarity index 91% rename from src/main/java/fr/inria/corese/core/next/api/query/Operation.java rename to src/main/java/fr/inria/corese/core/next/data/api/query/Operation.java index 83e84c97d..68b2d91cb 100644 --- a/src/main/java/fr/inria/corese/core/next/api/query/Operation.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/query/Operation.java @@ -1,8 +1,8 @@ -package fr.inria.corese.core.next.api.query; +package fr.inria.corese.core.next.data.api.query; -import fr.inria.corese.core.next.api.Value; -import fr.inria.corese.core.next.api.query.dataset.Dataset; -import fr.inria.corese.core.next.api.query.result.BindingSet; +import fr.inria.corese.core.next.data.api.Value; +import fr.inria.corese.core.next.data.api.query.dataset.Dataset; +import fr.inria.corese.core.next.data.api.query.result.BindingSet; /** * A generic SPARQL operation (query or update) on a Corese repository. diff --git a/src/main/java/fr/inria/corese/core/next/api/query/Query.java b/src/main/java/fr/inria/corese/core/next/data/api/query/Query.java similarity index 80% rename from src/main/java/fr/inria/corese/core/next/api/query/Query.java rename to src/main/java/fr/inria/corese/core/next/data/api/query/Query.java index 268e876b1..e21045fa5 100644 --- a/src/main/java/fr/inria/corese/core/next/api/query/Query.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/query/Query.java @@ -1,6 +1,8 @@ -package fr.inria.corese.core.next.api.query; +package fr.inria.corese.core.next.data.api.query; -import fr.inria.corese.core.next.api.query.exception.QueryEvaluationException; +import fr.inria.corese.core.next.data.api.query.exception.QueryEvaluationException; +import fr.inria.corese.core.next.data.api.query.result.GraphQueryResult; +import fr.inria.corese.core.next.data.api.query.result.TupleQueryResult; /** * A query on a repository that can be formulated in one of the supported query languages (for example SPARQL). @@ -56,8 +58,8 @@ enum QueryType { /** * Evaluates the query against the dataset. * - * @return The result type expected: {@link fr.inria.corese.core.next.api.query.result.TupleQueryResult} - * for SELECT queries, {@link fr.inria.corese.core.next.api.query.result.GraphQueryResult} + * @return The result type expected: {@link TupleQueryResult} + * for SELECT queries, {@link GraphQueryResult} * for CONSTRUCT/DESCRIBE queries, or {@link Boolean} for ASK queries * @throws QueryEvaluationException if an error occurs during query evaluation */ diff --git a/src/main/java/fr/inria/corese/core/next/api/query/QueryLanguage.java b/src/main/java/fr/inria/corese/core/next/data/api/query/QueryLanguage.java similarity index 83% rename from src/main/java/fr/inria/corese/core/next/api/query/QueryLanguage.java rename to src/main/java/fr/inria/corese/core/next/data/api/query/QueryLanguage.java index 8fcdc2932..fad70f6ce 100644 --- a/src/main/java/fr/inria/corese/core/next/api/query/QueryLanguage.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/query/QueryLanguage.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.api.query; +package fr.inria.corese.core.next.data.api.query; -import fr.inria.corese.core.next.api.query.repository.RepositoryConnection; +import fr.inria.corese.core.next.data.api.query.repository.RepositoryConnection; /** * Enumeration of query languages supported by the Corese engine. @@ -12,7 +12,7 @@ * * * @see RepositoryConnection - * @see fr.inria.corese.core.next.api.query.Query + * @see Query */ public enum QueryLanguage { diff --git a/src/main/java/fr/inria/corese/core/next/api/query/Transformer.java b/src/main/java/fr/inria/corese/core/next/data/api/query/Transformer.java similarity index 93% rename from src/main/java/fr/inria/corese/core/next/api/query/Transformer.java rename to src/main/java/fr/inria/corese/core/next/data/api/query/Transformer.java index c3f35e563..51ef069b9 100644 --- a/src/main/java/fr/inria/corese/core/next/api/query/Transformer.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/query/Transformer.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.api.query; +package fr.inria.corese.core.next.data.api.query; -import fr.inria.corese.core.next.api.query.exception.QuerySyntaxException; +import fr.inria.corese.core.next.data.api.query.exception.QuerySyntaxException; /** * Compiles SPARQL query and update strings into executable query objects. diff --git a/src/main/java/fr/inria/corese/core/next/api/query/TupleQuery.java b/src/main/java/fr/inria/corese/core/next/data/api/query/TupleQuery.java similarity index 70% rename from src/main/java/fr/inria/corese/core/next/api/query/TupleQuery.java rename to src/main/java/fr/inria/corese/core/next/data/api/query/TupleQuery.java index ea46f59d4..b476090b7 100644 --- a/src/main/java/fr/inria/corese/core/next/api/query/TupleQuery.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/query/TupleQuery.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.api.query; +package fr.inria.corese.core.next.data.api.query; -import fr.inria.corese.core.next.api.query.exception.QueryEvaluationException; -import fr.inria.corese.core.next.api.query.result.TupleQueryResult; +import fr.inria.corese.core.next.data.api.query.exception.QueryEvaluationException; +import fr.inria.corese.core.next.data.api.query.result.TupleQueryResult; /** * Compiled SPARQL query corresponding to a SELECT query diff --git a/src/main/java/fr/inria/corese/core/next/api/query/Update.java b/src/main/java/fr/inria/corese/core/next/data/api/query/Update.java similarity index 76% rename from src/main/java/fr/inria/corese/core/next/api/query/Update.java rename to src/main/java/fr/inria/corese/core/next/data/api/query/Update.java index 24fee8c0b..12d0745aa 100644 --- a/src/main/java/fr/inria/corese/core/next/api/query/Update.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/query/Update.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.api.query; +package fr.inria.corese.core.next.data.api.query; -import fr.inria.corese.core.next.api.Value; -import fr.inria.corese.core.next.api.query.exception.QueryEvaluationException; +import fr.inria.corese.core.next.data.api.Value; +import fr.inria.corese.core.next.data.api.query.exception.QueryEvaluationException; /** * Represents a prepared SPARQL UPDATE operation. diff --git a/src/main/java/fr/inria/corese/core/next/api/query/dataset/Dataset.java b/src/main/java/fr/inria/corese/core/next/data/api/query/dataset/Dataset.java similarity index 97% rename from src/main/java/fr/inria/corese/core/next/api/query/dataset/Dataset.java rename to src/main/java/fr/inria/corese/core/next/data/api/query/dataset/Dataset.java index 38de039fc..6b6daca21 100644 --- a/src/main/java/fr/inria/corese/core/next/api/query/dataset/Dataset.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/query/dataset/Dataset.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api.query.dataset; +package fr.inria.corese.core.next.data.api.query.dataset; import java.util.Set; diff --git a/src/main/java/fr/inria/corese/core/next/api/query/exception/QueryEvaluationException.java b/src/main/java/fr/inria/corese/core/next/data/api/query/exception/QueryEvaluationException.java similarity index 93% rename from src/main/java/fr/inria/corese/core/next/api/query/exception/QueryEvaluationException.java rename to src/main/java/fr/inria/corese/core/next/data/api/query/exception/QueryEvaluationException.java index 9e716f625..af77f2a41 100644 --- a/src/main/java/fr/inria/corese/core/next/api/query/exception/QueryEvaluationException.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/query/exception/QueryEvaluationException.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api.query.exception; +package fr.inria.corese.core.next.data.api.query.exception; /** * Thrown when a syntactically valid query fails during evaluation (execution). diff --git a/src/main/java/fr/inria/corese/core/next/api/query/exception/QueryException.java b/src/main/java/fr/inria/corese/core/next/data/api/query/exception/QueryException.java similarity index 84% rename from src/main/java/fr/inria/corese/core/next/api/query/exception/QueryException.java rename to src/main/java/fr/inria/corese/core/next/data/api/query/exception/QueryException.java index ca9f92786..b83acd9b2 100644 --- a/src/main/java/fr/inria/corese/core/next/api/query/exception/QueryException.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/query/exception/QueryException.java @@ -1,6 +1,7 @@ -package fr.inria.corese.core.next.api.query.exception; +package fr.inria.corese.core.next.data.api.query.exception; -import fr.inria.corese.core.next.api.base.exception.CoreseException; + +import fr.inria.corese.core.next.data.api.base.exception.CoreseException; /** * Base exception for all query-related errors in the Corese query API. diff --git a/src/main/java/fr/inria/corese/core/next/api/query/exception/QuerySyntaxException.java b/src/main/java/fr/inria/corese/core/next/data/api/query/exception/QuerySyntaxException.java similarity index 98% rename from src/main/java/fr/inria/corese/core/next/api/query/exception/QuerySyntaxException.java rename to src/main/java/fr/inria/corese/core/next/data/api/query/exception/QuerySyntaxException.java index 28dd3549d..19712b6f1 100644 --- a/src/main/java/fr/inria/corese/core/next/api/query/exception/QuerySyntaxException.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/query/exception/QuerySyntaxException.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api.query.exception; +package fr.inria.corese.core.next.data.api.query.exception; /** * Thrown when a SPARQL query or update string contains invalid syntax. diff --git a/src/main/java/fr/inria/corese/core/next/api/query/exception/QueryTimeoutException.java b/src/main/java/fr/inria/corese/core/next/data/api/query/exception/QueryTimeoutException.java similarity index 97% rename from src/main/java/fr/inria/corese/core/next/api/query/exception/QueryTimeoutException.java rename to src/main/java/fr/inria/corese/core/next/data/api/query/exception/QueryTimeoutException.java index dbc6f4674..5fb4d2eed 100644 --- a/src/main/java/fr/inria/corese/core/next/api/query/exception/QueryTimeoutException.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/query/exception/QueryTimeoutException.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.api.query.exception; +package fr.inria.corese.core.next.data.api.query.exception; /** * Thrown when a query evaluation exceeds its configured timeout limit. diff --git a/src/main/java/fr/inria/corese/core/next/api/query/exception/RepositoryException.java b/src/main/java/fr/inria/corese/core/next/data/api/query/exception/RepositoryException.java similarity index 71% rename from src/main/java/fr/inria/corese/core/next/api/query/exception/RepositoryException.java rename to src/main/java/fr/inria/corese/core/next/data/api/query/exception/RepositoryException.java index 2d360eea8..4edc33324 100644 --- a/src/main/java/fr/inria/corese/core/next/api/query/exception/RepositoryException.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/query/exception/RepositoryException.java @@ -1,8 +1,11 @@ -package fr.inria.corese.core.next.api.query.exception; +package fr.inria.corese.core.next.data.api.query.exception; + +import fr.inria.corese.core.next.data.api.query.repository.Repository; +import fr.inria.corese.core.next.data.api.query.repository.RepositoryConnection; /** - * Thrown when an operation on a {@link fr.inria.corese.core.next.api.query.repository.Repository} - * or {@link fr.inria.corese.core.next.api.query.repository.RepositoryConnection} fails. + * Thrown when an operation on a {@link Repository} + * or {@link RepositoryConnection} fails. */ public class RepositoryException extends QueryException { diff --git a/src/main/java/fr/inria/corese/core/next/api/query/repository/Repository.java b/src/main/java/fr/inria/corese/core/next/data/api/query/repository/Repository.java similarity index 90% rename from src/main/java/fr/inria/corese/core/next/api/query/repository/Repository.java rename to src/main/java/fr/inria/corese/core/next/data/api/query/repository/Repository.java index 9d7cc0d13..377bc1f51 100644 --- a/src/main/java/fr/inria/corese/core/next/api/query/repository/Repository.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/query/repository/Repository.java @@ -1,7 +1,7 @@ -package fr.inria.corese.core.next.api.query.repository; +package fr.inria.corese.core.next.data.api.query.repository; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.api.query.exception.RepositoryException; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.api.query.exception.RepositoryException; import java.io.File; diff --git a/src/main/java/fr/inria/corese/core/next/api/query/repository/RepositoryConnection.java b/src/main/java/fr/inria/corese/core/next/data/api/query/repository/RepositoryConnection.java similarity index 92% rename from src/main/java/fr/inria/corese/core/next/api/query/repository/RepositoryConnection.java rename to src/main/java/fr/inria/corese/core/next/data/api/query/repository/RepositoryConnection.java index 114b6d29b..122f10e71 100644 --- a/src/main/java/fr/inria/corese/core/next/api/query/repository/RepositoryConnection.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/query/repository/RepositoryConnection.java @@ -1,10 +1,10 @@ -package fr.inria.corese.core.next.api.query.repository; +package fr.inria.corese.core.next.data.api.query.repository; -import fr.inria.corese.core.next.api.ValueFactory; -import fr.inria.corese.core.next.api.query.*; -import fr.inria.corese.core.next.api.query.dataset.Dataset; -import fr.inria.corese.core.next.api.query.exception.QuerySyntaxException; -import fr.inria.corese.core.next.api.query.exception.RepositoryException; +import fr.inria.corese.core.next.data.api.ValueFactory; +import fr.inria.corese.core.next.data.api.query.*; +import fr.inria.corese.core.next.data.api.query.dataset.Dataset; +import fr.inria.corese.core.next.data.api.query.exception.QuerySyntaxException; +import fr.inria.corese.core.next.data.api.query.exception.RepositoryException; /** * A connection to a Corese {@link Repository}, providing access to query diff --git a/src/main/java/fr/inria/corese/core/next/api/query/result/Binding.java b/src/main/java/fr/inria/corese/core/next/data/api/query/result/Binding.java similarity index 85% rename from src/main/java/fr/inria/corese/core/next/api/query/result/Binding.java rename to src/main/java/fr/inria/corese/core/next/data/api/query/result/Binding.java index ae9df39e7..4b68290b5 100644 --- a/src/main/java/fr/inria/corese/core/next/api/query/result/Binding.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/query/result/Binding.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.api.query.result; +package fr.inria.corese.core.next.data.api.query.result; -import fr.inria.corese.core.next.api.Value; +import fr.inria.corese.core.next.data.api.Value; /** * Represents a single variable-to-value association in a SPARQL solution. @@ -13,7 +13,7 @@ * * * @see BindingSet - * @see fr.inria.corese.core.next.api.Value + * @see fr.inria.corese.core.next.data.api.Value */ public interface Binding { diff --git a/src/main/java/fr/inria/corese/core/next/api/query/result/BindingSet.java b/src/main/java/fr/inria/corese/core/next/data/api/query/result/BindingSet.java similarity index 86% rename from src/main/java/fr/inria/corese/core/next/api/query/result/BindingSet.java rename to src/main/java/fr/inria/corese/core/next/data/api/query/result/BindingSet.java index a78decd47..803893d13 100644 --- a/src/main/java/fr/inria/corese/core/next/api/query/result/BindingSet.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/query/result/BindingSet.java @@ -1,6 +1,7 @@ -package fr.inria.corese.core.next.api.query.result; +package fr.inria.corese.core.next.data.api.query.result; -import fr.inria.corese.core.next.api.Value; +import fr.inria.corese.core.next.data.api.Value; +import fr.inria.corese.core.next.data.api.query.TupleQuery; import java.util.Set; @@ -15,7 +16,7 @@ * * * @see Binding - * @see fr.inria.corese.core.next.api.query.TupleQuery + * @see TupleQuery */ public interface BindingSet extends Iterable { diff --git a/src/main/java/fr/inria/corese/core/next/api/query/result/GraphQueryResult.java b/src/main/java/fr/inria/corese/core/next/data/api/query/result/GraphQueryResult.java similarity index 92% rename from src/main/java/fr/inria/corese/core/next/api/query/result/GraphQueryResult.java rename to src/main/java/fr/inria/corese/core/next/data/api/query/result/GraphQueryResult.java index b542b0a32..493c10304 100644 --- a/src/main/java/fr/inria/corese/core/next/api/query/result/GraphQueryResult.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/query/result/GraphQueryResult.java @@ -1,6 +1,7 @@ -package fr.inria.corese.core.next.api.query.result; +package fr.inria.corese.core.next.data.api.query.result; -import fr.inria.corese.core.next.api.Statement; +import fr.inria.corese.core.next.data.api.Statement; +import fr.inria.corese.core.next.data.api.query.GraphQuery; import java.io.Closeable; import java.util.*; @@ -11,8 +12,8 @@ * Represents the result of evaluating a SPARQL CONSTRUCT or DESCRIBE query. * * @see Statement - * @see fr.inria.corese.core.next.api.query.GraphQuery - * @see fr.inria.corese.core.next.api.query.GraphQuery#evaluate() + * @see GraphQuery + * @see GraphQuery#evaluate() */ public interface GraphQueryResult extends Closeable, Iterable { diff --git a/src/main/java/fr/inria/corese/core/next/api/query/result/TupleQueryResult.java b/src/main/java/fr/inria/corese/core/next/data/api/query/result/TupleQueryResult.java similarity index 94% rename from src/main/java/fr/inria/corese/core/next/api/query/result/TupleQueryResult.java rename to src/main/java/fr/inria/corese/core/next/data/api/query/result/TupleQueryResult.java index 0efb8b407..ab5592605 100644 --- a/src/main/java/fr/inria/corese/core/next/api/query/result/TupleQueryResult.java +++ b/src/main/java/fr/inria/corese/core/next/data/api/query/result/TupleQueryResult.java @@ -1,4 +1,6 @@ -package fr.inria.corese.core.next.api.query.result; +package fr.inria.corese.core.next.data.api.query.result; + +import fr.inria.corese.core.next.data.api.query.TupleQuery; import java.io.Closeable; import java.util.*; @@ -16,8 +18,8 @@ * *

Implementations are not required to be thread-safe.

* - * @see fr.inria.corese.core.next.api.query.TupleQuery - * @see fr.inria.corese.core.next.api.query.TupleQuery#evaluate() + * @see TupleQuery + * @see TupleQuery#evaluate() */ public interface TupleQueryResult extends Closeable, Iterable { diff --git a/src/main/java/fr/inria/corese/core/next/data/impl/exception/SparqlException.java b/src/main/java/fr/inria/corese/core/next/data/impl/exception/SparqlException.java index 03ecddc89..9534f4d1e 100644 --- a/src/main/java/fr/inria/corese/core/next/data/impl/exception/SparqlException.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/exception/SparqlException.java @@ -1,6 +1,6 @@ -package fr.inria.corese.core.next.impl.exception; +package fr.inria.corese.core.next.data.impl.exception; -import fr.inria.corese.core.next.api.base.exception.CoreseException; +import fr.inria.corese.core.next.data.api.base.exception.CoreseException; public class SparqlException extends CoreseException { public SparqlException() { } diff --git a/src/main/java/fr/inria/corese/core/next/impl/query/CoreseQueryArtifactAdapter.java b/src/main/java/fr/inria/corese/core/next/impl/query/CoreseQueryArtifactAdapter.java deleted file mode 100644 index 443f0b0d1..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/query/CoreseQueryArtifactAdapter.java +++ /dev/null @@ -1,4 +0,0 @@ -package fr.inria.corese.core.next.impl.query; - -public class CoreseQueryArtifactAdapter { -} diff --git a/src/main/java/fr/inria/corese/core/next/impl/query/ast/AskQueryAst.java b/src/main/java/fr/inria/corese/core/next/impl/query/ast/AskQueryAst.java deleted file mode 100644 index 1b58fbdf5..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/query/ast/AskQueryAst.java +++ /dev/null @@ -1,4 +0,0 @@ -package fr.inria.corese.core.next.impl.query.ast; - -public class AskQueryAst { -} diff --git a/src/main/java/fr/inria/corese/core/next/impl/query/ast/ConstructQueryAst.java b/src/main/java/fr/inria/corese/core/next/impl/query/ast/ConstructQueryAst.java deleted file mode 100644 index 99df48172..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/query/ast/ConstructQueryAst.java +++ /dev/null @@ -1,4 +0,0 @@ -package fr.inria.corese.core.next.impl.query.ast; - -public class ConstructQueryAst { -} diff --git a/src/main/java/fr/inria/corese/core/next/impl/query/ast/DescribeQueryAst.java b/src/main/java/fr/inria/corese/core/next/impl/query/ast/DescribeQueryAst.java deleted file mode 100644 index 690143cde..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/query/ast/DescribeQueryAst.java +++ /dev/null @@ -1,4 +0,0 @@ -package fr.inria.corese.core.next.impl.query.ast; - -public class DescribeQueryAst { -} diff --git a/src/main/java/fr/inria/corese/core/next/impl/query/ast/QueryAst.java b/src/main/java/fr/inria/corese/core/next/impl/query/ast/QueryAst.java deleted file mode 100644 index 5f23a063f..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/query/ast/QueryAst.java +++ /dev/null @@ -1,4 +0,0 @@ -package fr.inria.corese.core.next.impl.query.ast; - -public class QueryAst { -} diff --git a/src/main/java/fr/inria/corese/core/next/impl/query/ast/SelectQueryAst.java b/src/main/java/fr/inria/corese/core/next/impl/query/ast/SelectQueryAst.java deleted file mode 100644 index 6c7c5a554..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/query/ast/SelectQueryAst.java +++ /dev/null @@ -1,4 +0,0 @@ -package fr.inria.corese.core.next.impl.query.ast; - -public class SelectQueryAst { -} diff --git a/src/main/java/fr/inria/corese/core/next/impl/query/bridge/CoreseAstQueryBuilder.java b/src/main/java/fr/inria/corese/core/next/impl/query/bridge/CoreseAstQueryBuilder.java deleted file mode 100644 index 40589a407..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/query/bridge/CoreseAstQueryBuilder.java +++ /dev/null @@ -1,4 +0,0 @@ -package fr.inria.corese.core.next.impl.query.bridge; - -public class CoreseAstQueryBuilder { -} diff --git a/src/main/java/fr/inria/corese/core/next/impl/query/bridge/CoresePatternBuilder.java b/src/main/java/fr/inria/corese/core/next/impl/query/bridge/CoresePatternBuilder.java deleted file mode 100644 index da66b2395..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/query/bridge/CoresePatternBuilder.java +++ /dev/null @@ -1,4 +0,0 @@ -package fr.inria.corese.core.next.impl.query.bridge; - -public class CoresePatternBuilder { -} diff --git a/src/main/java/fr/inria/corese/core/next/impl/query/bridge/CoreseTermAdapter.java b/src/main/java/fr/inria/corese/core/next/impl/query/bridge/CoreseTermAdapter.java deleted file mode 100644 index 62f63cf0c..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/query/bridge/CoreseTermAdapter.java +++ /dev/null @@ -1,4 +0,0 @@ -package fr.inria.corese.core.next.impl.query.bridge; - -public class CoreseTermAdapter { -} diff --git a/src/main/java/fr/inria/corese/core/next/impl/query/parser/SparqlListener.java b/src/main/java/fr/inria/corese/core/next/impl/query/parser/SparqlListener.java deleted file mode 100644 index f15ac2883..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/query/parser/SparqlListener.java +++ /dev/null @@ -1,4 +0,0 @@ -package fr.inria.corese.core.next.impl.query.parser; - -public class SparqlListener { -} diff --git a/src/main/java/fr/inria/corese/core/next/impl/query/parser/SparqlOptions.java b/src/main/java/fr/inria/corese/core/next/impl/query/parser/SparqlOptions.java deleted file mode 100644 index f2f41a3dd..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/query/parser/SparqlOptions.java +++ /dev/null @@ -1,4 +0,0 @@ -package fr.inria.corese.core.next.impl.query.parser; - -public class SparqlOptions { -} diff --git a/src/main/java/fr/inria/corese/core/next/impl/query/result/CoreseBinding.java b/src/main/java/fr/inria/corese/core/next/impl/query/result/CoreseBinding.java deleted file mode 100644 index e0a58c2fe..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/query/result/CoreseBinding.java +++ /dev/null @@ -1,4 +0,0 @@ -package fr.inria.corese.core.next.impl.query.result; - -public class CoreseBinding { -} diff --git a/src/main/java/fr/inria/corese/core/next/impl/query/result/CoreseBindingSet.java b/src/main/java/fr/inria/corese/core/next/impl/query/result/CoreseBindingSet.java deleted file mode 100644 index 676d95bd8..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/query/result/CoreseBindingSet.java +++ /dev/null @@ -1,4 +0,0 @@ -package fr.inria.corese.core.next.impl.query.result; - -public class CoreseBindingSet { -} diff --git a/src/main/java/fr/inria/corese/core/next/impl/query/result/CoreseGraphQueryResult.java b/src/main/java/fr/inria/corese/core/next/impl/query/result/CoreseGraphQueryResult.java deleted file mode 100644 index 00ebd1c8d..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/query/result/CoreseGraphQueryResult.java +++ /dev/null @@ -1,4 +0,0 @@ -package fr.inria.corese.core.next.impl.query.result; - -public class CoreseGraphQueryResult { -} diff --git a/src/main/java/fr/inria/corese/core/next/impl/query/result/CoreseTupleQueryResult.java b/src/main/java/fr/inria/corese/core/next/impl/query/result/CoreseTupleQueryResult.java deleted file mode 100644 index aad17a107..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/query/result/CoreseTupleQueryResult.java +++ /dev/null @@ -1,4 +0,0 @@ -package fr.inria.corese.core.next.impl.query.result; - -public class CoreseTupleQueryResult { -} diff --git a/src/main/java/fr/inria/corese/core/next/impl/query/wrapper/CoreseBinding.java b/src/main/java/fr/inria/corese/core/next/impl/query/wrapper/CoreseBinding.java deleted file mode 100644 index de2f834e5..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/query/wrapper/CoreseBinding.java +++ /dev/null @@ -1,4 +0,0 @@ -package fr.inria.corese.core.next.impl.query.wrapper; - -public class CoreseBinding { -} diff --git a/src/main/java/fr/inria/corese/core/next/impl/query/wrapper/CoreseBindingSet.java b/src/main/java/fr/inria/corese/core/next/impl/query/wrapper/CoreseBindingSet.java deleted file mode 100644 index 3b1544d3b..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/query/wrapper/CoreseBindingSet.java +++ /dev/null @@ -1,4 +0,0 @@ -package fr.inria.corese.core.next.impl.query.wrapper; - -public class CoreseBindingSet { -} diff --git a/src/main/java/fr/inria/corese/core/next/impl/query/wrapper/CoreseGraphQueryResult.java b/src/main/java/fr/inria/corese/core/next/impl/query/wrapper/CoreseGraphQueryResult.java deleted file mode 100644 index 5f34424c9..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/query/wrapper/CoreseGraphQueryResult.java +++ /dev/null @@ -1,4 +0,0 @@ -package fr.inria.corese.core.next.impl.query.wrapper; - -public class CoreseGraphQueryResult { -} diff --git a/src/main/java/fr/inria/corese/core/next/impl/query/wrapper/CoreseTupleQueryResult.java b/src/main/java/fr/inria/corese/core/next/impl/query/wrapper/CoreseTupleQueryResult.java deleted file mode 100644 index effec9341..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/query/wrapper/CoreseTupleQueryResult.java +++ /dev/null @@ -1,4 +0,0 @@ -package fr.inria.corese.core.next.impl.query.wrapper; - -public class CoreseTupleQueryResult { -} diff --git a/src/main/java/fr/inria/corese/core/next/query/sparql/CoreseQueryArtifactAdapter.java b/src/main/java/fr/inria/corese/core/next/query/sparql/CoreseQueryArtifactAdapter.java new file mode 100644 index 000000000..08eef78f4 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/query/sparql/CoreseQueryArtifactAdapter.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.query.sparql; + +public class CoreseQueryArtifactAdapter { +} diff --git a/src/main/java/fr/inria/corese/core/next/query/sparql/ast/AskQueryAst.java b/src/main/java/fr/inria/corese/core/next/query/sparql/ast/AskQueryAst.java new file mode 100644 index 000000000..b928873ca --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/query/sparql/ast/AskQueryAst.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.query.sparql.ast; + +public class AskQueryAst { +} diff --git a/src/main/java/fr/inria/corese/core/next/query/sparql/ast/ConstructQueryAst.java b/src/main/java/fr/inria/corese/core/next/query/sparql/ast/ConstructQueryAst.java new file mode 100644 index 000000000..44873d0a7 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/query/sparql/ast/ConstructQueryAst.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.query.sparql.ast; + +public class ConstructQueryAst { +} diff --git a/src/main/java/fr/inria/corese/core/next/query/sparql/ast/DescribeQueryAst.java b/src/main/java/fr/inria/corese/core/next/query/sparql/ast/DescribeQueryAst.java new file mode 100644 index 000000000..52c8a2618 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/query/sparql/ast/DescribeQueryAst.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.query.sparql.ast; + +public class DescribeQueryAst { +} diff --git a/src/main/java/fr/inria/corese/core/next/query/sparql/ast/QueryAst.java b/src/main/java/fr/inria/corese/core/next/query/sparql/ast/QueryAst.java new file mode 100644 index 000000000..acce37195 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/query/sparql/ast/QueryAst.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.query.sparql.ast; + +public class QueryAst { +} diff --git a/src/main/java/fr/inria/corese/core/next/query/sparql/ast/SelectQueryAst.java b/src/main/java/fr/inria/corese/core/next/query/sparql/ast/SelectQueryAst.java new file mode 100644 index 000000000..6c939c5c5 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/query/sparql/ast/SelectQueryAst.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.query.sparql.ast; + +public class SelectQueryAst { +} diff --git a/src/main/java/fr/inria/corese/core/next/query/sparql/bridge/CoreseAstQueryBuilder.java b/src/main/java/fr/inria/corese/core/next/query/sparql/bridge/CoreseAstQueryBuilder.java new file mode 100644 index 000000000..57d8feb06 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/query/sparql/bridge/CoreseAstQueryBuilder.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.query.sparql.bridge; + +public class CoreseAstQueryBuilder { +} diff --git a/src/main/java/fr/inria/corese/core/next/query/sparql/bridge/CoresePatternBuilder.java b/src/main/java/fr/inria/corese/core/next/query/sparql/bridge/CoresePatternBuilder.java new file mode 100644 index 000000000..651ee62a6 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/query/sparql/bridge/CoresePatternBuilder.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.query.sparql.bridge; + +public class CoresePatternBuilder { +} diff --git a/src/main/java/fr/inria/corese/core/next/query/sparql/bridge/CoreseTermAdapter.java b/src/main/java/fr/inria/corese/core/next/query/sparql/bridge/CoreseTermAdapter.java new file mode 100644 index 000000000..8e92a17d9 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/query/sparql/bridge/CoreseTermAdapter.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.query.sparql.bridge; + +public class CoreseTermAdapter { +} diff --git a/src/main/java/fr/inria/corese/core/next/impl/query/parser/SparqlAstBuilder.java b/src/main/java/fr/inria/corese/core/next/query/sparql/parser/SparqlAstBuilder.java similarity index 58% rename from src/main/java/fr/inria/corese/core/next/impl/query/parser/SparqlAstBuilder.java rename to src/main/java/fr/inria/corese/core/next/query/sparql/parser/SparqlAstBuilder.java index 4626c249c..d1e2906f5 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/query/parser/SparqlAstBuilder.java +++ b/src/main/java/fr/inria/corese/core/next/query/sparql/parser/SparqlAstBuilder.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.query.parser; +package fr.inria.corese.core.next.query.sparql.parser; public class SparqlAstBuilder { diff --git a/src/main/java/fr/inria/corese/core/next/query/sparql/parser/SparqlListener.java b/src/main/java/fr/inria/corese/core/next/query/sparql/parser/SparqlListener.java new file mode 100644 index 000000000..802f0b263 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/query/sparql/parser/SparqlListener.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.query.sparql.parser; + +public class SparqlListener { +} diff --git a/src/main/java/fr/inria/corese/core/next/query/sparql/parser/SparqlOptions.java b/src/main/java/fr/inria/corese/core/next/query/sparql/parser/SparqlOptions.java new file mode 100644 index 000000000..71330a618 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/query/sparql/parser/SparqlOptions.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.query.sparql.parser; + +public class SparqlOptions { +} diff --git a/src/main/java/fr/inria/corese/core/next/impl/query/parser/SparqlParser.java b/src/main/java/fr/inria/corese/core/next/query/sparql/parser/SparqlParser.java similarity index 73% rename from src/main/java/fr/inria/corese/core/next/impl/query/parser/SparqlParser.java rename to src/main/java/fr/inria/corese/core/next/query/sparql/parser/SparqlParser.java index 1bfe35e6c..9e0df7d94 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/query/parser/SparqlParser.java +++ b/src/main/java/fr/inria/corese/core/next/query/sparql/parser/SparqlParser.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.query.parser; +package fr.inria.corese.core.next.query.sparql.parser; public class SparqlParser { diff --git a/src/main/java/fr/inria/corese/core/next/query/sparql/result/CoreseBinding.java b/src/main/java/fr/inria/corese/core/next/query/sparql/result/CoreseBinding.java new file mode 100644 index 000000000..c23ac300b --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/query/sparql/result/CoreseBinding.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.query.sparql.result; + +public class CoreseBinding { +} diff --git a/src/main/java/fr/inria/corese/core/next/query/sparql/result/CoreseBindingSet.java b/src/main/java/fr/inria/corese/core/next/query/sparql/result/CoreseBindingSet.java new file mode 100644 index 000000000..df9fb8a65 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/query/sparql/result/CoreseBindingSet.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.query.sparql.result; + +public class CoreseBindingSet { +} diff --git a/src/main/java/fr/inria/corese/core/next/query/sparql/result/CoreseGraphQueryResult.java b/src/main/java/fr/inria/corese/core/next/query/sparql/result/CoreseGraphQueryResult.java new file mode 100644 index 000000000..47491c870 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/query/sparql/result/CoreseGraphQueryResult.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.query.sparql.result; + +public class CoreseGraphQueryResult { +} diff --git a/src/main/java/fr/inria/corese/core/next/query/sparql/result/CoreseTupleQueryResult.java b/src/main/java/fr/inria/corese/core/next/query/sparql/result/CoreseTupleQueryResult.java new file mode 100644 index 000000000..88bf564cd --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/query/sparql/result/CoreseTupleQueryResult.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.query.sparql.result; + +public class CoreseTupleQueryResult { +} diff --git a/src/main/java/fr/inria/corese/core/next/query/sparql/wrapper/CoreseBinding.java b/src/main/java/fr/inria/corese/core/next/query/sparql/wrapper/CoreseBinding.java new file mode 100644 index 000000000..1e1cff07b --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/query/sparql/wrapper/CoreseBinding.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.query.sparql.wrapper; + +public class CoreseBinding { +} diff --git a/src/main/java/fr/inria/corese/core/next/query/sparql/wrapper/CoreseBindingSet.java b/src/main/java/fr/inria/corese/core/next/query/sparql/wrapper/CoreseBindingSet.java new file mode 100644 index 000000000..3c0990220 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/query/sparql/wrapper/CoreseBindingSet.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.query.sparql.wrapper; + +public class CoreseBindingSet { +} diff --git a/src/main/java/fr/inria/corese/core/next/query/sparql/wrapper/CoreseGraphQueryResult.java b/src/main/java/fr/inria/corese/core/next/query/sparql/wrapper/CoreseGraphQueryResult.java new file mode 100644 index 000000000..143bb6789 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/query/sparql/wrapper/CoreseGraphQueryResult.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.query.sparql.wrapper; + +public class CoreseGraphQueryResult { +} diff --git a/src/main/java/fr/inria/corese/core/next/query/sparql/wrapper/CoreseTupleQueryResult.java b/src/main/java/fr/inria/corese/core/next/query/sparql/wrapper/CoreseTupleQueryResult.java new file mode 100644 index 000000000..f406b61a3 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/query/sparql/wrapper/CoreseTupleQueryResult.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.query.sparql.wrapper; + +public class CoreseTupleQueryResult { +} From 71c80bc5d04ccb4d71da7d733071b59764b95e05 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Thu, 5 Feb 2026 13:35:45 +0100 Subject: [PATCH 9/9] Refactor DataManager architecture new Model --- .../data/impl/io/parser/nquads/NQuadsListener.java | 10 +++++----- .../io/serialization/canonical/RDFC10Serializer.java | 2 +- .../core/next/{ => data}/impl/common/BasicIRITest.java | 2 +- .../impl/common/literal/BasicDurationTest.java | 2 +- .../impl/common/prefix/PrefixHandlerTest.java | 2 +- .../next/{ => data}/impl/common/util/IRIUtilsTest.java | 2 +- .../next/{ => data}/impl/config/CoreConfigTest.java | 2 +- .../next/{ => data}/impl/io/CircularJSONLDIOTest.java | 2 +- .../{ => data}/impl/io/option/JSONLDOptionsTest.java | 2 +- .../{ => data}/impl/io/parser/ParserFactoryTest.java | 2 +- .../impl/io/parser/jsonld/JSONLDCircularTest.java | 2 +- .../impl/io/parser/jsonld/JSONLDParserTest.java | 2 +- .../impl/io/parser/nquads/NQuadsCircularTest.java | 2 +- .../impl/io/parser/nquads/NQuadsListenerTest.java | 2 +- .../impl/io/parser/nquads/NQuadsParserTest.java | 2 +- .../impl/io/parser/ntriples/NTriplesCircularTest.java | 2 +- .../impl/io/parser/ntriples/NTriplesListenerTest.java | 2 +- .../impl/io/parser/ntriples/NTriplesParserTest.java | 2 +- .../{ => data}/impl/io/parser/rdfa/RDFaParserTest.java | 3 +-- .../impl/io/parser/rdfxml/RDFXMLCircularTest.java | 2 +- .../impl/io/parser/rdfxml/RDFXMLParserTest.java | 3 +-- .../io/parser/rdfxml/RDFXMLStatementEmitterTest.java | 2 +- .../impl/io/parser/rdfxml/RDFXMLUtilsTest.java | 2 +- .../impl/io/parser/trig/TriGCircularTest.java | 2 +- .../impl/io/parser/trig/TriGListenerImplTest.java | 2 +- .../{ => data}/impl/io/parser/trig/TriGParserTest.java | 3 +-- .../impl/io/parser/turtle/TurtleCircularTest.java | 2 +- .../impl/io/parser/turtle/TurtleListenerTest.java | 3 +-- .../impl/io/parser/turtle/TurtleParserTest.java | 4 +--- .../impl/io/serialization/SerializerFactoryTest.java | 2 +- .../impl/io/serialization/TestStatementFactory.java | 2 +- .../canonical/RDFC10SerializerOptionsTest.java | 2 +- .../serialization/canonical/RDFC10SerializerTest.java | 2 +- .../io/serialization/jsonld/JSONLDSerializerTest.java | 2 +- .../nquads/NQuadsSerializerOptionsTest.java | 2 +- .../io/serialization/nquads/NQuadsSerializerTest.java | 6 ++---- .../ntriples/NTriplesSerializerOptionsTest.java | 2 +- .../serialization/ntriples/NTriplesSerializerTest.java | 6 ++---- .../io/serialization/rdfxml/RDFXMLSerializerTest.java | 6 ++---- .../impl/io/serialization/rdfxml/XmlConfigTest.java | 2 +- .../serialization/trig/TriGSerializerOptionsTest.java | 2 +- .../impl/io/serialization/trig/TriGSerializerTest.java | 6 ++---- .../turtle/TurtleSerializerOptionsTest.java | 2 +- .../io/serialization/turtle/TurtleSerializerTest.java | 6 ++---- .../impl/temp/CoreseAdaptedValueFactoryTest.java | 2 +- .../core/next/{ => data}/impl/temp/CoreseIRITest.java | 2 +- .../next/{ => data}/impl/temp/CoreseModelTest.java | 2 +- .../next/{ => data}/impl/temp/CoreseStatementTest.java | 2 +- .../impl/temp/literal/AbstractCoreseNumberTest.java | 2 +- .../{ => data}/impl/temp/literal/CoreseBNodeTest.java | 2 +- .../impl/temp/literal/CoreseBooleanTest.java | 2 +- .../{ => data}/impl/temp/literal/CoreseDateTest.java | 2 +- .../impl/temp/literal/CoreseDatetimeTest.java | 2 +- .../impl/temp/literal/CoreseDecimalTest.java | 4 +--- .../impl/temp/literal/CoreseIntegerTest.java | 4 +--- .../temp/literal/CoreseLanguageTaggedStringTest.java | 2 +- .../{ => data}/impl/temp/literal/CoreseTypedTest.java | 2 +- 57 files changed, 66 insertions(+), 86 deletions(-) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/common/BasicIRITest.java (89%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/common/literal/BasicDurationTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/common/prefix/PrefixHandlerTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/common/util/IRIUtilsTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/config/CoreConfigTest.java (85%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/CircularJSONLDIOTest.java (91%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/option/JSONLDOptionsTest.java (98%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/ParserFactoryTest.java (98%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/jsonld/JSONLDCircularTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/jsonld/JSONLDParserTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/nquads/NQuadsCircularTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/nquads/NQuadsListenerTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/nquads/NQuadsParserTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/ntriples/NTriplesCircularTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/ntriples/NTriplesListenerTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/ntriples/NTriplesParserTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/rdfa/RDFaParserTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/rdfxml/RDFXMLCircularTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/rdfxml/RDFXMLParserTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/rdfxml/RDFXMLStatementEmitterTest.java (98%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/rdfxml/RDFXMLUtilsTest.java (98%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/trig/TriGCircularTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/trig/TriGListenerImplTest.java (98%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/trig/TriGParserTest.java (97%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/turtle/TurtleCircularTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/turtle/TurtleListenerTest.java (97%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/parser/turtle/TurtleParserTest.java (96%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/SerializerFactoryTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/TestStatementFactory.java (98%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/canonical/RDFC10SerializerOptionsTest.java (97%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/canonical/RDFC10SerializerTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/jsonld/JSONLDSerializerTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/nquads/NQuadsSerializerOptionsTest.java (98%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/nquads/NQuadsSerializerTest.java (97%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/ntriples/NTriplesSerializerOptionsTest.java (98%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/ntriples/NTriplesSerializerTest.java (97%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/rdfxml/RDFXMLSerializerTest.java (98%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/rdfxml/XmlConfigTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/trig/TriGSerializerOptionsTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/trig/TriGSerializerTest.java (98%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/turtle/TurtleSerializerOptionsTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/io/serialization/turtle/TurtleSerializerTest.java (98%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/temp/CoreseAdaptedValueFactoryTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/temp/CoreseIRITest.java (98%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/temp/CoreseModelTest.java (99%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/temp/CoreseStatementTest.java (98%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/temp/literal/AbstractCoreseNumberTest.java (97%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/temp/literal/CoreseBNodeTest.java (96%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/temp/literal/CoreseBooleanTest.java (97%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/temp/literal/CoreseDateTest.java (97%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/temp/literal/CoreseDatetimeTest.java (98%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/temp/literal/CoreseDecimalTest.java (88%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/temp/literal/CoreseIntegerTest.java (85%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/temp/literal/CoreseLanguageTaggedStringTest.java (98%) rename src/test/java/fr/inria/corese/core/next/{ => data}/impl/temp/literal/CoreseTypedTest.java (98%) diff --git a/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/nquads/NQuadsListener.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/nquads/NQuadsListener.java index 61cffd8f1..afea1c882 100644 --- a/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/nquads/NQuadsListener.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/parser/nquads/NQuadsListener.java @@ -76,7 +76,7 @@ public void exitStatement(NQuadsParser.StatementContext ctx) { /** * Extracts a resource (IRI or Blank Node) from the subject context. */ - public Resource extractSubject(NQuadsParser.SubjectContext ctx) { + protected Resource extractSubject(NQuadsParser.SubjectContext ctx) { if (ctx.IRIREF() != null) { String iri = abstractNTriplesQuadsListener.unescapeUri(stripAngles(ctx.IRIREF().getText())); return factory.createIRI(iri); @@ -92,7 +92,7 @@ public Resource extractSubject(NQuadsParser.SubjectContext ctx) { /** * Extracts a predicate (IRI) from the predicate context. */ - public IRI extractPredicate(NQuadsParser.PredicateContext ctx) { + protected IRI extractPredicate(NQuadsParser.PredicateContext ctx) { if (ctx.IRIREF() != null) { String iri = abstractNTriplesQuadsListener.unescapeUri(stripAngles(ctx.IRIREF().getText())); return factory.createIRI(iri); @@ -103,7 +103,7 @@ public IRI extractPredicate(NQuadsParser.PredicateContext ctx) { /** * Extracts a value (IRI, Blank Node, or Literal) from the object context. */ - public Value extractObject(NQuadsParser.ObjectContext ctx) { + protected Value extractObject(NQuadsParser.ObjectContext ctx) { if (ctx.IRIREF() != null) { String iri = abstractNTriplesQuadsListener.unescapeUri(stripAngles(ctx.IRIREF().getText())); return factory.createIRI(iri); @@ -122,7 +122,7 @@ public Value extractObject(NQuadsParser.ObjectContext ctx) { /** * Extracts a graph (IRI or Blank Node) from the graph label context. */ - public Resource extractGraph(NQuadsParser.GraphLabelContext ctx) { + protected Resource extractGraph(NQuadsParser.GraphLabelContext ctx) { if (ctx.IRIREF() != null) { String iri = abstractNTriplesQuadsListener.unescapeUri(stripAngles(ctx.IRIREF().getText())); return factory.createIRI(iri); @@ -192,7 +192,7 @@ protected void validateBlankNodeLabel(String label) { * @deprecated Use helper.unescapeLiteral instead */ @Deprecated - public String unescapeLiteral(String literalText) { + protected String unescapeLiteral(String literalText) { return abstractNTriplesQuadsListener.unescapeLiteral(literalText); } diff --git a/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/canonical/RDFC10Serializer.java b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/canonical/RDFC10Serializer.java index 464d00624..b8f610629 100644 --- a/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/canonical/RDFC10Serializer.java +++ b/src/main/java/fr/inria/corese/core/next/data/impl/io/serialization/canonical/RDFC10Serializer.java @@ -77,7 +77,7 @@ public void write(Writer writer) { * @throws IOException if an I/O error occurs. */ @Override - public void writeContext(Writer writer, Statement stmt) throws IOException { + protected void writeContext(Writer writer, Statement stmt) throws IOException { Resource context = stmt.getContext(); if (context != null) { writer.write(SerializationConstants.SPACE); diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/BasicIRITest.java b/src/test/java/fr/inria/corese/core/next/data/impl/common/BasicIRITest.java similarity index 89% rename from src/test/java/fr/inria/corese/core/next/impl/common/BasicIRITest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/common/BasicIRITest.java index a6cdb6f0b..65d87a1f1 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/BasicIRITest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/common/BasicIRITest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.common; +package fr.inria.corese.core.next.data.impl.common; import fr.inria.corese.core.next.data.api.IRI; import fr.inria.corese.core.next.data.api.IRITest; diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/literal/BasicDurationTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/common/literal/BasicDurationTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/common/literal/BasicDurationTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/common/literal/BasicDurationTest.java index c35717ab1..4d39e1f9a 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/literal/BasicDurationTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/common/literal/BasicDurationTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.common.literal; +package fr.inria.corese.core.next.data.impl.common.literal; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/prefix/PrefixHandlerTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/common/prefix/PrefixHandlerTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/common/prefix/PrefixHandlerTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/common/prefix/PrefixHandlerTest.java index 5a736049d..1cb3d0afb 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/prefix/PrefixHandlerTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/common/prefix/PrefixHandlerTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.common.prefix; +package fr.inria.corese.core.next.data.impl.common.prefix; import fr.inria.corese.core.next.data.impl.common.prefix.PrefixHandler; import org.junit.jupiter.api.BeforeEach; diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/util/IRIUtilsTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/common/util/IRIUtilsTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/common/util/IRIUtilsTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/common/util/IRIUtilsTest.java index 380b7126a..59041d4a8 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/util/IRIUtilsTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/common/util/IRIUtilsTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.common.util; +package fr.inria.corese.core.next.data.impl.common.util; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; diff --git a/src/test/java/fr/inria/corese/core/next/impl/config/CoreConfigTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/config/CoreConfigTest.java similarity index 85% rename from src/test/java/fr/inria/corese/core/next/impl/config/CoreConfigTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/config/CoreConfigTest.java index ab5f521bc..221987958 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/config/CoreConfigTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/config/CoreConfigTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.config; +package fr.inria.corese.core.next.data.impl.config; import static org.junit.jupiter.api.Assertions.assertEquals; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/CircularJSONLDIOTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/CircularJSONLDIOTest.java similarity index 91% rename from src/test/java/fr/inria/corese/core/next/impl/io/CircularJSONLDIOTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/CircularJSONLDIOTest.java index 5aa7c5305..627aa9ca9 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/CircularJSONLDIOTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/CircularJSONLDIOTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io; +package fr.inria.corese.core.next.data.impl.io; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/option/JSONLDOptionsTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/option/JSONLDOptionsTest.java similarity index 98% rename from src/test/java/fr/inria/corese/core/next/impl/io/option/JSONLDOptionsTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/option/JSONLDOptionsTest.java index 73d77a542..171b093c4 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/option/JSONLDOptionsTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/option/JSONLDOptionsTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.option; +package fr.inria.corese.core.next.data.impl.io.option; import com.apicatalog.jsonld.JsonLdVersion; import fr.inria.corese.core.next.data.impl.io.common.JSONLDOptions; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/ParserFactoryTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/ParserFactoryTest.java similarity index 98% rename from src/test/java/fr/inria/corese/core/next/impl/io/parser/ParserFactoryTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/parser/ParserFactoryTest.java index 06ceb7491..81ecf3cf2 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/ParserFactoryTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/ParserFactoryTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.parser; +package fr.inria.corese.core.next.data.impl.io.parser; import fr.inria.corese.core.next.data.api.Model; import fr.inria.corese.core.next.data.api.ValueFactory; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/jsonld/JSONLDCircularTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/jsonld/JSONLDCircularTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/io/parser/jsonld/JSONLDCircularTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/parser/jsonld/JSONLDCircularTest.java index fcef3ed93..9e452c9ed 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/jsonld/JSONLDCircularTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/jsonld/JSONLDCircularTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.parser.jsonld; +package fr.inria.corese.core.next.data.impl.io.parser.jsonld; import fr.inria.corese.core.next.data.api.*; import fr.inria.corese.core.next.data.api.base.io.RDFFormat; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/jsonld/JSONLDParserTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/jsonld/JSONLDParserTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/io/parser/jsonld/JSONLDParserTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/parser/jsonld/JSONLDParserTest.java index 725ce6ee0..1e2ba5d8d 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/jsonld/JSONLDParserTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/jsonld/JSONLDParserTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.parser.jsonld; +package fr.inria.corese.core.next.data.impl.io.parser.jsonld; import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertEquals; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsCircularTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/nquads/NQuadsCircularTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsCircularTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/parser/nquads/NQuadsCircularTest.java index 719db3a36..16598241a 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsCircularTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/nquads/NQuadsCircularTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.parser.nquads; +package fr.inria.corese.core.next.data.impl.io.parser.nquads; import fr.inria.corese.core.next.data.api.*; import fr.inria.corese.core.next.data.api.base.io.RDFFormat; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsListenerTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/nquads/NQuadsListenerTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsListenerTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/parser/nquads/NQuadsListenerTest.java index 99761eb22..69645d713 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsListenerTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/nquads/NQuadsListenerTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.parser.nquads; +package fr.inria.corese.core.next.data.impl.io.parser.nquads; import fr.inria.corese.core.next.data.api.*; import fr.inria.corese.core.next.data.io.IOOptions; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsParserTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/nquads/NQuadsParserTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsParserTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/parser/nquads/NQuadsParserTest.java index 96a61d24e..0ceb4f0c7 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/nquads/NQuadsParserTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/nquads/NQuadsParserTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.parser.nquads; +package fr.inria.corese.core.next.data.impl.io.parser.nquads; import fr.inria.corese.core.next.data.api.*; import fr.inria.corese.core.next.data.api.base.io.RDFFormat; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesCircularTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/ntriples/NTriplesCircularTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesCircularTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/parser/ntriples/NTriplesCircularTest.java index 0aa2ba2c0..0818c42fc 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesCircularTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/ntriples/NTriplesCircularTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.parser.ntriples; +package fr.inria.corese.core.next.data.impl.io.parser.ntriples; import fr.inria.corese.core.next.data.api.*; import fr.inria.corese.core.next.data.api.base.io.RDFFormat; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesListenerTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/ntriples/NTriplesListenerTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesListenerTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/parser/ntriples/NTriplesListenerTest.java index 221aefc79..1d5b31a64 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesListenerTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/ntriples/NTriplesListenerTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.parser.ntriples; +package fr.inria.corese.core.next.data.impl.io.parser.ntriples; import fr.inria.corese.core.next.data.api.*; import fr.inria.corese.core.next.data.io.IOOptions; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesParserTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/ntriples/NTriplesParserTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesParserTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/parser/ntriples/NTriplesParserTest.java index 85db450c1..a81039f54 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/ntriples/NTriplesParserTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/ntriples/NTriplesParserTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.parser.ntriples; +package fr.inria.corese.core.next.data.impl.io.parser.ntriples; import fr.inria.corese.core.next.data.api.*; import fr.inria.corese.core.next.data.api.base.io.RDFFormat; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfa/RDFaParserTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/RDFaParserTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfa/RDFaParserTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/RDFaParserTest.java index 28595f4a4..daa4439d6 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfa/RDFaParserTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/rdfa/RDFaParserTest.java @@ -1,10 +1,9 @@ -package fr.inria.corese.core.next.impl.io.parser.rdfa; +package fr.inria.corese.core.next.data.impl.io.parser.rdfa; import fr.inria.corese.core.next.data.api.*; import fr.inria.corese.core.next.data.api.base.io.RDFFormat; import fr.inria.corese.core.next.data.io.parser.RDFParser; import fr.inria.corese.core.next.data.io.serializer.RDFSerializer; -import fr.inria.corese.core.next.data.impl.io.parser.rdfa.RDFaParser; import fr.inria.corese.core.next.data.impl.io.serialization.SerializerFactory; import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF; import fr.inria.corese.core.next.data.impl.common.vocabulary.XSD; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLCircularTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLCircularTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLCircularTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLCircularTest.java index 248206306..e8c28ca35 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLCircularTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLCircularTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.parser.rdfxml; +package fr.inria.corese.core.next.data.impl.io.parser.rdfxml; import fr.inria.corese.core.next.data.api.*; import fr.inria.corese.core.next.data.api.base.io.RDFFormat; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLParserTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLParserTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLParserTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLParserTest.java index 950ebe6b5..9299a8da9 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLParserTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLParserTest.java @@ -1,10 +1,9 @@ -package fr.inria.corese.core.next.impl.io.parser.rdfxml; +package fr.inria.corese.core.next.data.impl.io.parser.rdfxml; import fr.inria.corese.core.next.data.api.Literal; import fr.inria.corese.core.next.data.api.Model; import fr.inria.corese.core.next.data.api.Value; import fr.inria.corese.core.next.data.api.ValueFactory; -import fr.inria.corese.core.next.data.impl.io.parser.rdfxml.RDFXMLParser; import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; import fr.inria.corese.core.next.data.impl.temp.CoreseModel; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLStatementEmitterTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLStatementEmitterTest.java similarity index 98% rename from src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLStatementEmitterTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLStatementEmitterTest.java index 29f7b95a1..3f8707048 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLStatementEmitterTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLStatementEmitterTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.parser.rdfxml; +package fr.inria.corese.core.next.data.impl.io.parser.rdfxml; import fr.inria.corese.core.next.data.api.*; import fr.inria.corese.core.next.data.impl.common.literal.XSD; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLUtilsTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLUtilsTest.java similarity index 98% rename from src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLUtilsTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLUtilsTest.java index ce46cfeb2..5f733d73d 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/rdfxml/RDFXMLUtilsTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/rdfxml/RDFXMLUtilsTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.parser.rdfxml; +package fr.inria.corese.core.next.data.impl.io.parser.rdfxml; import fr.inria.corese.core.next.data.api.Model; import fr.inria.corese.core.next.data.api.Resource; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGCircularTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/trig/TriGCircularTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGCircularTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/parser/trig/TriGCircularTest.java index e58b22b7d..34cfaf82a 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGCircularTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/trig/TriGCircularTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.parser.trig; +package fr.inria.corese.core.next.data.impl.io.parser.trig; import java.io.ByteArrayInputStream; import java.io.StringWriter; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGListenerImplTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/trig/TriGListenerImplTest.java similarity index 98% rename from src/test/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGListenerImplTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/parser/trig/TriGListenerImplTest.java index 93955acfc..e13c76185 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGListenerImplTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/trig/TriGListenerImplTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.parser.trig; +package fr.inria.corese.core.next.data.impl.io.parser.trig; import fr.inria.corese.core.next.data.api.Model; import fr.inria.corese.core.next.data.api.ValueFactory; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGParserTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/trig/TriGParserTest.java similarity index 97% rename from src/test/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGParserTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/parser/trig/TriGParserTest.java index e0ebc5dc1..4060e1bd4 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/trig/TriGParserTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/trig/TriGParserTest.java @@ -1,11 +1,10 @@ -package fr.inria.corese.core.next.impl.io.parser.trig; +package fr.inria.corese.core.next.data.impl.io.parser.trig; import fr.inria.corese.core.next.data.api.Literal; import fr.inria.corese.core.next.data.api.Model; import fr.inria.corese.core.next.data.api.Value; import fr.inria.corese.core.next.data.api.ValueFactory; import fr.inria.corese.core.next.data.io.parser.RDFParser; -import fr.inria.corese.core.next.data.impl.io.parser.trig.TriGParser; import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; import fr.inria.corese.core.next.data.impl.temp.CoreseModel; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleCircularTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/turtle/TurtleCircularTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleCircularTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/parser/turtle/TurtleCircularTest.java index 2d755db51..836ad09c6 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleCircularTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/turtle/TurtleCircularTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.parser.turtle; +package fr.inria.corese.core.next.data.impl.io.parser.turtle; import java.io.ByteArrayInputStream; import java.io.StringWriter; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleListenerTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/turtle/TurtleListenerTest.java similarity index 97% rename from src/test/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleListenerTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/parser/turtle/TurtleListenerTest.java index e5174229f..8f1c19fd3 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleListenerTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/turtle/TurtleListenerTest.java @@ -1,8 +1,7 @@ -package fr.inria.corese.core.next.impl.io.parser.turtle; +package fr.inria.corese.core.next.data.impl.io.parser.turtle; import fr.inria.corese.core.next.data.api.Model; import fr.inria.corese.core.next.data.api.ValueFactory; -import fr.inria.corese.core.next.data.impl.io.parser.turtle.TurtleListener; import fr.inria.corese.core.next.impl.parser.antlr.TurtleLexer; import fr.inria.corese.core.next.impl.parser.antlr.TurtleParser; import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleParserTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/turtle/TurtleParserTest.java similarity index 96% rename from src/test/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleParserTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/parser/turtle/TurtleParserTest.java index 984b4444a..956d4a738 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/parser/turtle/TurtleParserTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/parser/turtle/TurtleParserTest.java @@ -1,12 +1,10 @@ -package fr.inria.corese.core.next.impl.io.parser.turtle; +package fr.inria.corese.core.next.data.impl.io.parser.turtle; import fr.inria.corese.core.next.data.api.Model; import fr.inria.corese.core.next.data.api.Statement; import fr.inria.corese.core.next.data.api.ValueFactory; import fr.inria.corese.core.next.data.io.parser.RDFParser; import fr.inria.corese.core.next.data.impl.common.vocabulary.RDFS; -import fr.inria.corese.core.next.data.impl.io.parser.turtle.TurtleParser; -import fr.inria.corese.core.next.data.impl.io.parser.turtle.TurtleParserOptions; import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; import fr.inria.corese.core.next.data.impl.temp.CoreseModel; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/SerializerFactoryTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/SerializerFactoryTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/io/serialization/SerializerFactoryTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/SerializerFactoryTest.java index 5e5f2b3cb..f75cda61a 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/SerializerFactoryTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/SerializerFactoryTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.serialization; +package fr.inria.corese.core.next.data.impl.io.serialization; import fr.inria.corese.core.next.data.api.Model; import fr.inria.corese.core.next.data.api.base.io.RDFFormat; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/TestStatementFactory.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/TestStatementFactory.java similarity index 98% rename from src/test/java/fr/inria/corese/core/next/impl/io/serialization/TestStatementFactory.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/TestStatementFactory.java index d0c77ec1d..2a10fb79a 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/TestStatementFactory.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/TestStatementFactory.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.serialization; +package fr.inria.corese.core.next.data.impl.io.serialization; import fr.inria.corese.core.next.data.api.IRI; import fr.inria.corese.core.next.data.api.Literal; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/canonical/RDFC10SerializerOptionsTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/canonical/RDFC10SerializerOptionsTest.java similarity index 97% rename from src/test/java/fr/inria/corese/core/next/impl/io/serialization/canonical/RDFC10SerializerOptionsTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/canonical/RDFC10SerializerOptionsTest.java index d9525c6f9..0e1ee26a7 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/canonical/RDFC10SerializerOptionsTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/canonical/RDFC10SerializerOptionsTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.serialization.canonical; +package fr.inria.corese.core.next.data.impl.io.serialization.canonical; import fr.inria.corese.core.next.data.impl.io.serialization.canonical.RDFC10SerializerOptions; import org.junit.jupiter.api.DisplayName; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/canonical/RDFC10SerializerTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/canonical/RDFC10SerializerTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/io/serialization/canonical/RDFC10SerializerTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/canonical/RDFC10SerializerTest.java index 2f5ce18c0..b34285e39 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/canonical/RDFC10SerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/canonical/RDFC10SerializerTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.serialization.canonical; +package fr.inria.corese.core.next.data.impl.io.serialization.canonical; import fr.inria.corese.core.next.data.api.*; import fr.inria.corese.core.next.data.api.base.io.RDFFormat; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/jsonld/JSONLDSerializerTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/jsonld/JSONLDSerializerTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/io/serialization/jsonld/JSONLDSerializerTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/jsonld/JSONLDSerializerTest.java index 9006f6c93..a7c976260 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/jsonld/JSONLDSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/jsonld/JSONLDSerializerTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.serialization.jsonld; +package fr.inria.corese.core.next.data.impl.io.serialization.jsonld; import com.apicatalog.jsonld.json.JsonLdComparison; import fr.inria.corese.core.next.data.api.*; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/nquads/NQuadsSerializerOptionsTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/nquads/NQuadsSerializerOptionsTest.java similarity index 98% rename from src/test/java/fr/inria/corese/core/next/impl/io/serialization/nquads/NQuadsSerializerOptionsTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/nquads/NQuadsSerializerOptionsTest.java index 8222c70b3..a797fc235 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/nquads/NQuadsSerializerOptionsTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/nquads/NQuadsSerializerOptionsTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.serialization.nquads; +package fr.inria.corese.core.next.data.impl.io.serialization.nquads; import fr.inria.corese.core.next.data.impl.io.serialization.nquads.NQuadsSerializerOptions; import fr.inria.corese.core.next.data.impl.io.serialization.option.LiteralDatatypePolicyEnum; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/nquads/NQuadsSerializerTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/nquads/NQuadsSerializerTest.java similarity index 97% rename from src/test/java/fr/inria/corese/core/next/impl/io/serialization/nquads/NQuadsSerializerTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/nquads/NQuadsSerializerTest.java index d6821683e..9f502f6ac 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/nquads/NQuadsSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/nquads/NQuadsSerializerTest.java @@ -1,9 +1,7 @@ -package fr.inria.corese.core.next.impl.io.serialization.nquads; +package fr.inria.corese.core.next.data.impl.io.serialization.nquads; import fr.inria.corese.core.next.data.api.*; -import fr.inria.corese.core.next.data.impl.io.serialization.nquads.NQuadsSerializer; -import fr.inria.corese.core.next.data.impl.io.serialization.nquads.NQuadsSerializerOptions; -import fr.inria.corese.core.next.impl.io.serialization.TestStatementFactory; +import fr.inria.corese.core.next.data.impl.io.serialization.TestStatementFactory; import fr.inria.corese.core.next.data.impl.exception.SerializationException; import org.junit.jupiter.api.BeforeEach; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/ntriples/NTriplesSerializerOptionsTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/ntriples/NTriplesSerializerOptionsTest.java similarity index 98% rename from src/test/java/fr/inria/corese/core/next/impl/io/serialization/ntriples/NTriplesSerializerOptionsTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/ntriples/NTriplesSerializerOptionsTest.java index ef98ef535..83f8b1f5b 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/ntriples/NTriplesSerializerOptionsTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/ntriples/NTriplesSerializerOptionsTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.serialization.ntriples; +package fr.inria.corese.core.next.data.impl.io.serialization.ntriples; import fr.inria.corese.core.next.data.impl.io.serialization.ntriples.NTriplesSerializerOptions; import fr.inria.corese.core.next.data.impl.io.serialization.option.LiteralDatatypePolicyEnum; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/ntriples/NTriplesSerializerTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/ntriples/NTriplesSerializerTest.java similarity index 97% rename from src/test/java/fr/inria/corese/core/next/impl/io/serialization/ntriples/NTriplesSerializerTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/ntriples/NTriplesSerializerTest.java index 49bdb86f5..a913bef73 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/ntriples/NTriplesSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/ntriples/NTriplesSerializerTest.java @@ -1,9 +1,7 @@ -package fr.inria.corese.core.next.impl.io.serialization.ntriples; +package fr.inria.corese.core.next.data.impl.io.serialization.ntriples; import fr.inria.corese.core.next.data.api.*; -import fr.inria.corese.core.next.data.impl.io.serialization.ntriples.NTriplesSerializer; -import fr.inria.corese.core.next.data.impl.io.serialization.ntriples.NTriplesSerializerOptions; -import fr.inria.corese.core.next.impl.io.serialization.TestStatementFactory; +import fr.inria.corese.core.next.data.impl.io.serialization.TestStatementFactory; import fr.inria.corese.core.next.data.impl.exception.SerializationException; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/rdfxml/RDFXMLSerializerTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/rdfxml/RDFXMLSerializerTest.java similarity index 98% rename from src/test/java/fr/inria/corese/core/next/impl/io/serialization/rdfxml/RDFXMLSerializerTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/rdfxml/RDFXMLSerializerTest.java index d5f9d73ce..99d3398e1 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/rdfxml/RDFXMLSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/rdfxml/RDFXMLSerializerTest.java @@ -1,13 +1,11 @@ -package fr.inria.corese.core.next.impl.io.serialization.rdfxml; +package fr.inria.corese.core.next.data.impl.io.serialization.rdfxml; import fr.inria.corese.core.next.data.api.Model; import fr.inria.corese.core.next.data.api.Statement; import fr.inria.corese.core.next.data.io.IOOptions; import fr.inria.corese.core.next.data.impl.common.vocabulary.XSD; import fr.inria.corese.core.next.data.impl.exception.SerializationException; -import fr.inria.corese.core.next.data.impl.io.serialization.rdfxml.RDFXMLSerializer; -import fr.inria.corese.core.next.data.impl.io.serialization.rdfxml.RDFXMLSerializerOptions; -import fr.inria.corese.core.next.impl.io.serialization.TestStatementFactory; +import fr.inria.corese.core.next.data.impl.io.serialization.TestStatementFactory; import fr.inria.corese.core.next.data.impl.io.serialization.option.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.data.impl.io.serialization.option.PrefixOrderingEnum; import org.junit.jupiter.api.AfterEach; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/rdfxml/XmlConfigTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/rdfxml/XmlConfigTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/io/serialization/rdfxml/XmlConfigTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/rdfxml/XmlConfigTest.java index a6a507e11..6baa4f879 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/rdfxml/XmlConfigTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/rdfxml/XmlConfigTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.serialization.rdfxml; +package fr.inria.corese.core.next.data.impl.io.serialization.rdfxml; import fr.inria.corese.core.next.data.impl.common.prefix.PrefixHandler; import fr.inria.corese.core.next.data.impl.common.vocabulary.OWL; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/trig/TriGSerializerOptionsTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/trig/TriGSerializerOptionsTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/io/serialization/trig/TriGSerializerOptionsTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/trig/TriGSerializerOptionsTest.java index a3fc664c2..da2825c72 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/trig/TriGSerializerOptionsTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/trig/TriGSerializerOptionsTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.serialization.trig; +package fr.inria.corese.core.next.data.impl.io.serialization.trig; import fr.inria.corese.core.next.data.impl.common.prefix.PrefixHandler; import fr.inria.corese.core.next.data.impl.common.vocabulary.OWL; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/trig/TriGSerializerTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/trig/TriGSerializerTest.java similarity index 98% rename from src/test/java/fr/inria/corese/core/next/impl/io/serialization/trig/TriGSerializerTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/trig/TriGSerializerTest.java index 2dfc6fddf..f7a951763 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/trig/TriGSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/trig/TriGSerializerTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.serialization.trig; +package fr.inria.corese.core.next.data.impl.io.serialization.trig; import fr.inria.corese.core.next.data.api.IRI; import fr.inria.corese.core.next.data.api.Model; @@ -6,9 +6,7 @@ import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF; import fr.inria.corese.core.next.data.impl.common.literal.XSD; import fr.inria.corese.core.next.data.impl.exception.SerializationException; -import fr.inria.corese.core.next.data.impl.io.serialization.trig.TriGSerializer; -import fr.inria.corese.core.next.data.impl.io.serialization.trig.TriGSerializerOptions; -import fr.inria.corese.core.next.impl.io.serialization.TestStatementFactory; +import fr.inria.corese.core.next.data.impl.io.serialization.TestStatementFactory; import fr.inria.corese.core.next.data.impl.io.serialization.option.LiteralDatatypePolicyEnum; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/turtle/TurtleSerializerOptionsTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/turtle/TurtleSerializerOptionsTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/io/serialization/turtle/TurtleSerializerOptionsTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/turtle/TurtleSerializerOptionsTest.java index b547d9782..9aa03d2cd 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/turtle/TurtleSerializerOptionsTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/turtle/TurtleSerializerOptionsTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.io.serialization.turtle; +package fr.inria.corese.core.next.data.impl.io.serialization.turtle; import fr.inria.corese.core.next.data.impl.common.prefix.PrefixHandler; import fr.inria.corese.core.next.data.impl.common.vocabulary.OWL; diff --git a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/turtle/TurtleSerializerTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/turtle/TurtleSerializerTest.java similarity index 98% rename from src/test/java/fr/inria/corese/core/next/impl/io/serialization/turtle/TurtleSerializerTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/turtle/TurtleSerializerTest.java index 0b4268b7c..cf3cff000 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/io/serialization/turtle/TurtleSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/io/serialization/turtle/TurtleSerializerTest.java @@ -1,13 +1,11 @@ -package fr.inria.corese.core.next.impl.io.serialization.turtle; +package fr.inria.corese.core.next.data.impl.io.serialization.turtle; import fr.inria.corese.core.next.data.api.*; import fr.inria.corese.core.next.data.impl.common.vocabulary.RDF; import fr.inria.corese.core.next.data.impl.common.literal.XSD; import fr.inria.corese.core.next.data.impl.common.prefix.PrefixHandler; import fr.inria.corese.core.next.data.impl.exception.SerializationException; -import fr.inria.corese.core.next.data.impl.io.serialization.turtle.TurtleSerializer; -import fr.inria.corese.core.next.data.impl.io.serialization.turtle.TurtleSerializerOptions; -import fr.inria.corese.core.next.impl.io.serialization.TestStatementFactory; +import fr.inria.corese.core.next.data.impl.io.serialization.TestStatementFactory; import fr.inria.corese.core.next.data.impl.io.serialization.option.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.data.impl.temp.CoreseAdaptedValueFactory; import fr.inria.corese.core.next.data.impl.temp.CoreseModel; diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseAdaptedValueFactoryTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/temp/CoreseAdaptedValueFactoryTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/temp/CoreseAdaptedValueFactoryTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/temp/CoreseAdaptedValueFactoryTest.java index af3fe8858..c2649e51c 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseAdaptedValueFactoryTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/temp/CoreseAdaptedValueFactoryTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.temp; +package fr.inria.corese.core.next.data.impl.temp; import java.time.Duration; diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseIRITest.java b/src/test/java/fr/inria/corese/core/next/data/impl/temp/CoreseIRITest.java similarity index 98% rename from src/test/java/fr/inria/corese/core/next/impl/temp/CoreseIRITest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/temp/CoreseIRITest.java index d1e4f3c6e..156d4f8ee 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseIRITest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/temp/CoreseIRITest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.temp; +package fr.inria.corese.core.next.data.impl.temp; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertThrows; diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseModelTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/temp/CoreseModelTest.java similarity index 99% rename from src/test/java/fr/inria/corese/core/next/impl/temp/CoreseModelTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/temp/CoreseModelTest.java index 9bd80d32c..307823042 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseModelTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/temp/CoreseModelTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.temp; +package fr.inria.corese.core.next.data.impl.temp; import fr.inria.corese.core.Graph; import fr.inria.corese.core.kgram.api.core.Edge; diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseStatementTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/temp/CoreseStatementTest.java similarity index 98% rename from src/test/java/fr/inria/corese/core/next/impl/temp/CoreseStatementTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/temp/CoreseStatementTest.java index 59c299470..2ccd27980 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/CoreseStatementTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/temp/CoreseStatementTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.temp; +package fr.inria.corese.core.next.data.impl.temp; import fr.inria.corese.core.NodeImpl; import fr.inria.corese.core.edge.EdgeImpl; diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/AbstractCoreseNumberTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/AbstractCoreseNumberTest.java similarity index 97% rename from src/test/java/fr/inria/corese/core/next/impl/temp/literal/AbstractCoreseNumberTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/AbstractCoreseNumberTest.java index 3d3cc251c..68bd1175f 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/AbstractCoreseNumberTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/AbstractCoreseNumberTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.temp.literal; +package fr.inria.corese.core.next.data.impl.temp.literal; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseBNodeTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseBNodeTest.java similarity index 96% rename from src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseBNodeTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseBNodeTest.java index c9016a51d..9ee453cf7 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseBNodeTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseBNodeTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.temp.literal; +package fr.inria.corese.core.next.data.impl.temp.literal; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseBooleanTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseBooleanTest.java similarity index 97% rename from src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseBooleanTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseBooleanTest.java index 7fa09dd34..1aea91ea9 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseBooleanTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseBooleanTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.temp.literal; +package fr.inria.corese.core.next.data.impl.temp.literal; import fr.inria.corese.core.next.data.impl.common.literal.XSD; import fr.inria.corese.core.next.data.impl.temp.literal.CoreseBoolean; diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDateTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDateTest.java similarity index 97% rename from src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDateTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDateTest.java index 9340a83cc..1d41f5de7 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDateTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDateTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.temp.literal; +package fr.inria.corese.core.next.data.impl.temp.literal; import fr.inria.corese.core.next.data.impl.common.literal.XSD; import fr.inria.corese.core.next.data.impl.temp.literal.CoreseDate; diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDatetimeTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDatetimeTest.java similarity index 98% rename from src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDatetimeTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDatetimeTest.java index 6f5f8b059..bad8f64d6 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDatetimeTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDatetimeTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.temp.literal; +package fr.inria.corese.core.next.data.impl.temp.literal; import fr.inria.corese.core.next.data.impl.common.literal.XSD; import fr.inria.corese.core.next.data.impl.temp.literal.CoreseDatetime; diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDecimalTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDecimalTest.java similarity index 88% rename from src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDecimalTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDecimalTest.java index 4e9dda104..bd75cb40a 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseDecimalTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseDecimalTest.java @@ -1,8 +1,6 @@ -package fr.inria.corese.core.next.impl.temp.literal; +package fr.inria.corese.core.next.data.impl.temp.literal; import fr.inria.corese.core.next.data.impl.common.literal.XSD; -import fr.inria.corese.core.next.data.impl.temp.literal.AbstractCoreseNumber; -import fr.inria.corese.core.next.data.impl.temp.literal.CoreseDecimal; import fr.inria.corese.core.sparql.datatype.CoreseNumber; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseIntegerTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseIntegerTest.java similarity index 85% rename from src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseIntegerTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseIntegerTest.java index 44ef3c5e2..e5b2219a4 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseIntegerTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseIntegerTest.java @@ -1,11 +1,9 @@ -package fr.inria.corese.core.next.impl.temp.literal; +package fr.inria.corese.core.next.data.impl.temp.literal; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertTrue; -import fr.inria.corese.core.next.data.impl.temp.literal.AbstractCoreseNumber; -import fr.inria.corese.core.next.data.impl.temp.literal.CoreseInteger; import org.junit.jupiter.api.Test; import fr.inria.corese.core.next.data.impl.common.literal.XSD; diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseLanguageTaggedStringTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseLanguageTaggedStringTest.java similarity index 98% rename from src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseLanguageTaggedStringTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseLanguageTaggedStringTest.java index b0057034c..7e674591e 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseLanguageTaggedStringTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseLanguageTaggedStringTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.temp.literal; +package fr.inria.corese.core.next.data.impl.temp.literal; import fr.inria.corese.core.next.data.impl.common.literal.RDF; import fr.inria.corese.core.next.data.impl.temp.literal.CoreseLanguageTaggedStringLiteral; diff --git a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseTypedTest.java b/src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseTypedTest.java similarity index 98% rename from src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseTypedTest.java rename to src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseTypedTest.java index 189a08f74..37b0b3183 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/temp/literal/CoreseTypedTest.java +++ b/src/test/java/fr/inria/corese/core/next/data/impl/temp/literal/CoreseTypedTest.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.temp.literal; +package fr.inria.corese.core.next.data.impl.temp.literal; import fr.inria.corese.core.next.data.impl.common.literal.XSD; import fr.inria.corese.core.next.data.impl.exception.IncorrectOperationException;