Made it possible to have two repositories with the same class/entity

Author: JohannesRabauer

spring-data-eclipse-store/src/main/java/software/xdev/spring/data/eclipse/store/repository/EclipseStoreStorage.java

@@ -21,8 +21,6 @@
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.function.Consumer;
-import java.util.function.Supplier;
 
 import org.eclipse.serializer.persistence.binary.jdk17.java.util.BinaryHandlerImmutableCollectionsList12;
 import org.eclipse.serializer.persistence.binary.jdk17.java.util.BinaryHandlerImmutableCollectionsSet12;
@@ -37,6 +35,7 @@
 import software.xdev.spring.data.eclipse.store.exceptions.AlreadyRegisteredException;
 import software.xdev.spring.data.eclipse.store.repository.config.EclipseStoreClientConfiguration;
 import software.xdev.spring.data.eclipse.store.repository.config.EclipseStoreStorageFoundationProvider;
+import software.xdev.spring.data.eclipse.store.repository.support.SimpleEclipseStoreRepository;
 import software.xdev.spring.data.eclipse.store.repository.support.concurrency.ReadWriteLock;
 import software.xdev.spring.data.eclipse.store.repository.support.concurrency.ReentrantJavaReadWriteLock;
 import software.xdev.spring.data.eclipse.store.repository.support.copier.id.IdSetter;
@@ -48,8 +47,8 @@ public class EclipseStoreStorage
 	implements EntityListProvider, IdSetterProvider, PersistableChecker, ObjectSwizzling
 {
 	private static final Logger LOG = LoggerFactory.getLogger(EclipseStoreStorage.class);
-	private final Map<Class<?>, String> entityClassToRepositoryName = new HashMap<>();
-	private final Map<Class<?>, IdSetter<?>> entityClassToIdSetter = new ConcurrentHashMap<>();
+	private final Map<Class<?>, SimpleEclipseStoreRepository<?, ?>> entityClassToRepository = new HashMap<>();
+	private final Map<Class<?>, IdSetter<?>> idSetters = new ConcurrentHashMap<>();
 	private final EclipseStoreStorageFoundationProvider foundationProvider;
 	private EntitySetCollector entitySetCollector;
 	private PersistableChecker persistenceChecker;
@@ -98,58 +97,56 @@ private synchronized void ensureEntitiesInRoot()
 		}
 	}
 
+	public <T> SimpleEclipseStoreRepository<T, ?> getRepository(final Class<T> entityClass)
+	{
+		return (SimpleEclipseStoreRepository<T, ?>)this.entityClassToRepository.get(entityClass);
+	}
+	
 	private void initRoot()
 	{
 		if(LOG.isDebugEnabled())
 		{
 			LOG.debug("Initializing entity lists...");
 		}
 		this.repositorySynchronizer =
-			new SimpleRepositorySynchronizer(this.entityClassToRepositoryName, this.root);
+			new SimpleRepositorySynchronizer(this.root);
 		boolean entityListMustGetStored = false;
-		for(final String entityName : this.entityClassToRepositoryName.values())
+		for(final Class<?> entityClass : this.entityClassToRepository.keySet())
 		{
-			if(!this.root.getEntityLists().containsKey(entityName))
+			if(this.root.getEntityList(entityClass) == null)
 			{
-				this.root.getEntityLists().put(entityName, new IdentitySet<>());
+				this.root.createNewEntityList(entityClass);
 				entityListMustGetStored = true;
 			}
 		}
 		if(entityListMustGetStored)
 		{
 			this.storageManager.store(this.root.getEntityLists());
 		}
-		this.entitySetCollector = new EntitySetCollector(this.root.getEntityLists(), this.entityClassToRepositoryName);
+		this.entitySetCollector =
+			new EntitySetCollector(this.root::getEntityList, this.entityClassToRepository.keySet());
 		if(LOG.isDebugEnabled())
 		{
 			LOG.debug("Done initializing entity lists.");
 		}
 	}
 
-	public <T> void registerEntity(final Class<T> classToRegister)
-	{
-		this.readWriteLock.write(
-			() -> {
-				final String entityName = this.getEntityName(classToRegister);
-				if(this.entityClassToRepositoryName.containsKey(classToRegister))
-				{
-					throw new AlreadyRegisteredException(entityName);
-				}
-				this.entityClassToRepositoryName.put(classToRegister, entityName);
-				
-				// If the storage is running and a new entity is registered, we need to stop the storage to restart
-				// again with the registered entity.
-				if(this.storageManager != null)
-				{
-					this.stop();
-				}
-			}
-		);
-	}
-	
-	private <T> String getEntityName(final Class<T> classToRegister)
+	public synchronized <T> void registerEntity(
+		final Class<T> classToRegister,
+		final SimpleEclipseStoreRepository<T, ?> repository)
 	{
-		return classToRegister.getName();
+		if(this.entityClassToRepository.containsKey(classToRegister))
+		{
+			throw new AlreadyRegisteredException(classToRegister.getSimpleName());
+		}
+		this.entityClassToRepository.put(classToRegister, repository);
+		
+		// If the storage is running and a new entity is registered, we need to stop the storage to restart
+		// again with the registered entity.
+		if(this.storageManager != null)
+		{
+			this.stop();
+		}
 	}
 
 	@SuppressWarnings("unchecked")
@@ -158,7 +155,7 @@ public <T> IdentitySet<T> getEntityList(final Class<T> clazz)
 	{
 		this.ensureEntitiesInRoot();
 		return this.readWriteLock.read(
-			() -> (IdentitySet<T>)this.root.getEntityLists().get(this.getEntityName(clazz))
+			() -> this.root.getEntityList(clazz)
 		);
 	}
 
@@ -170,8 +167,7 @@ public <T> long getEntityCount(final Class<T> clazz)
 		return this.readWriteLock.read(
 			() ->
 			{
-				final IdentitySet<T> entityList =
-					(IdentitySet<T>)this.root.getEntityLists().get(this.getEntityName(clazz));
+				final IdentitySet<T> entityList = this.root.getEntityList(clazz);
 				return entityList == null ? 0 : entityList.size();
 			}
 		);
@@ -260,9 +256,9 @@ public <T> void deleteAll(final Class<T> clazz)
 		this.readWriteLock.write(
 			() ->
 			{
-				final IdentitySet<?> entities = this.root.getEntityLists().get(this.getEntityName(clazz));
+				final IdentitySet<T> entities = this.root.getEntityList(clazz);
 				final int oldSize = entities.size();
-				final List<?> entitiesToRemove = entities.stream().toList();
+				final List<T> entitiesToRemove = entities.stream().toList();
 				final List<IdentitySet<Object>> entityLists =
 					this.entitySetCollector.getRelatedIdentitySets(clazz);
 				entityLists.forEach(entityList ->
@@ -321,7 +317,7 @@ public synchronized void stop()
 					this.storageManager = null;
 					this.root = null;
 					this.registry.reset();
-					this.entityClassToIdSetter.clear();
+					this.idSetters.clear();
 					LOG.info("Stopped storage.");
 				}
 				else
@@ -337,22 +333,29 @@ public synchronized void stop()
 	public <T> IdSetter<T> ensureIdSetter(final Class<T> domainClass)
 	{
 		this.ensureEntitiesInRoot();
-		return (IdSetter<T>)this.entityClassToIdSetter.computeIfAbsent(
+		return (IdSetter<T>)this.idSetters.computeIfAbsent(
 			domainClass,
-			clazz -> {
-				final String entityName = this.getEntityName(domainClass);
-				final Consumer<Object> idSetter =
-					id ->
-						this.readWriteLock.write(
-							() ->
-							{
-								this.root.getLastIds().put(entityName, id);
-								this.storageManager.store(this.root.getLastIds());
-							}
-						);
-				final Supplier<Object> idGetter =
-					() -> this.readWriteLock.read(() -> this.root.getLastIds().get(entityName));
-				return IdSetter.createIdSetter(domainClass, idSetter, idGetter);
+			clazz ->
+				IdSetter.createIdSetter(
+					clazz,
+					id -> this.setLastId(clazz, id),
+					() -> this.getLastId(clazz)
+				)
+		);
+	}
+	
+	public Object getLastId(final Class<?> entityClass)
+	{
+		return this.readWriteLock.read(() -> this.root.getLastId(entityClass));
+	}
+	
+	public void setLastId(final Class<?> entityClass, final Object lastId)
+	{
+		this.readWriteLock.write(
+			() ->
+			{
+				this.root.setLastId(entityClass, lastId);
+				this.storageManager.store(this.root.getLastIds());
 			}
 		);
 	}

spring-data-eclipse-store/src/main/java/software/xdev/spring/data/eclipse/store/repository/EntitySetCollector.java

@@ -19,6 +19,8 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -32,32 +34,32 @@ public class EntitySetCollector
 	private final Map<Class<?>, List<IdentitySet<? super Object>>> childClassToParentSets = new HashMap<>();
 
 	public EntitySetCollector(
-		final Map<String, IdentitySet<Object>> entityLists,
-		final Map<Class<?>, String> entityClassToRepositoryName)
+		final Function<Class<?>, IdentitySet<?>> entityLists,
+		final Set<Class<?>> entityClasses)
 	{
-		this.buildParentClassList(entityLists, entityClassToRepositoryName);
+		this.buildParentClassList(entityLists, entityClasses);
 	}
 
 	private void buildParentClassList(
-		final Map<String, IdentitySet<Object>> entityLists,
-		final Map<Class<?>, String> entityClassToRepositoryName
+		final Function<Class<?>, IdentitySet<?>> entityLists,
+		final Set<Class<?>> entityClasses
 	)
 	{
 		if(LOG.isDebugEnabled())
 		{
 			LOG.debug("Initializing parent class list...");
 		}
-		for(final Map.Entry<Class<?>, String> possibleParentEntry : entityClassToRepositoryName.entrySet())
+		for(final Class<?> possibleParentEntry : entityClasses)
 		{
-			for(final Map.Entry<Class<?>, String> possibleChildEntry : entityClassToRepositoryName.entrySet())
+			for(final Class<?> possibleChildEntry : entityClasses)
 			{
 				this.childClassToParentSets.putIfAbsent(
-					possibleChildEntry.getKey(), new ArrayList<>()
+					possibleChildEntry, new ArrayList<>()
 				);
-				if(possibleParentEntry.getKey().isAssignableFrom(possibleChildEntry.getKey()))
+				if(possibleParentEntry.isAssignableFrom(possibleChildEntry))
 				{
-					this.childClassToParentSets.get(possibleChildEntry.getKey())
-						.add(entityLists.get(entityClassToRepositoryName.get(possibleParentEntry.getKey())));
+					this.childClassToParentSets.get(possibleChildEntry)
+						.add((IdentitySet<? super Object>)entityLists.apply(possibleParentEntry));
 				}
 			}
 		}

spring-data-eclipse-store/src/main/java/software/xdev/spring/data/eclipse/store/repository/Root.java

@@ -40,6 +40,30 @@ public Map<String, IdentitySet<Object>> getEntityLists()
 		return this.entityLists;
 	}
 
+	public <T> IdentitySet<T> getEntityList(final Class<T> entityClass)
+	{
+		return (IdentitySet<T>)this.entityLists.get(this.getEntityName(entityClass));
+	}
+	
+	public <T> void createNewEntityList(final Class<T> entityClass)
+	{
+		this.entityLists.put(this.getEntityName(entityClass), new IdentitySet<>());
+	}
+	
+	private <T> String getEntityName(final Class<T> classToRegister)
+	{
+		return classToRegister.getName();
+	}
+	
+	public Object getLastId(final Class<?> entityClass)
+	{
+		return this.getLastIds().get(this.getEntityName(entityClass));
+	}
+	
+	public void setLastId(final Class<?> entityClass, final Object lastId)
+	{
+		this.getLastIds().put(this.getEntityName(entityClass), lastId);
+	}
 	public Map<String, Object> getLastIds()
 	{
 		return this.lastIds;

spring-data-eclipse-store/src/main/java/software/xdev/spring/data/eclipse/store/repository/support/EclipseStoreRepositoryFactory.java

@@ -88,6 +88,13 @@ private <T> WorkingCopier<T> createWorkingCopier(
 	@Nonnull
 	protected Object getTargetRepository(@Nonnull final RepositoryInformation metadata)
 	{
+		final SimpleEclipseStoreRepository<?, ?> existingRepository =
+			this.storage.getRepository(metadata.getDomainType());
+		if(existingRepository != null)
+		{
+			return existingRepository;
+		}
+		
 		return this.getTargetRepositoryViaReflection(
 			metadata,
 			this.storage,

spring-data-eclipse-store/src/main/java/software/xdev/spring/data/eclipse/store/repository/support/SimpleEclipseStoreRepository.java

@@ -82,7 +82,7 @@ public SimpleEclipseStoreRepository(
 	{
 		this.storage = storage;
 		this.domainClass = domainClass;
-		this.storage.registerEntity(domainClass);
+		this.storage.registerEntity(domainClass, this);
 		this.copier = copier;
 		this.transactionManager = transactionManager;
 	}

spring-data-eclipse-store/src/main/java/software/xdev/spring/data/eclipse/store/repository/support/reposyncer/SimpleRepositorySynchronizer.java

@@ -18,7 +18,6 @@
 import java.lang.reflect.Modifier;
 import java.util.Collection;
 import java.util.HashSet;
-import java.util.Map;
 
 import org.eclipse.serializer.util.traversing.ObjectGraphTraverser;
 import org.slf4j.Logger;
@@ -31,16 +30,12 @@
 public class SimpleRepositorySynchronizer implements RepositorySynchronizer
 {
 	private static final Logger LOG = LoggerFactory.getLogger(SimpleRepositorySynchronizer.class);
-	private final Map<Class<?>, String> entityWithRepositoryNamesAndClasses;
 	private final Root root;
 	private final HashSet<IdentitySet<Object>> listsToStore;
 	private final ObjectGraphTraverser buildObjectGraphTraverser;
 
-	public SimpleRepositorySynchronizer(
-		final Map<Class<?>, String> entityWithRepositoryNamesAndClasses,
-		final Root root)
+	public SimpleRepositorySynchronizer(final Root root)
 	{
-		this.entityWithRepositoryNamesAndClasses = entityWithRepositoryNamesAndClasses;
 		this.root = root;
 		this.listsToStore = new HashSet<>();
 
@@ -54,13 +49,11 @@ public SimpleRepositorySynchronizer(
 					{
 						return;
 					}
-					final Class<?> objectInGraphClass = objectInGraph.getClass();
-					final String objectInGraphClassname =
-						this.entityWithRepositoryNamesAndClasses.get(objectInGraphClass);
-					if(objectInGraphClassname != null)
+					final Class<Object> objectInGraphClass = (Class<Object>)objectInGraph.getClass();
+					final IdentitySet<Object> entityListForCurrentObject = this.root.getEntityList(objectInGraphClass);
+					if(entityListForCurrentObject != null)
 					{
-						final IdentitySet<Object> entityListForCurrentObject =
-							this.root.getEntityLists().get(objectInGraphClassname);
+						
 						if(!entityListForCurrentObject.contains(objectInGraph))
 						{
 							entityListForCurrentObject.add(objectInGraph);

spring-data-eclipse-store/src/test/java/software/xdev/spring/data/eclipse/store/integration/shared/repositories/immutables/CustomerWithFinalIdRepository.java renamed to spring-data-eclipse-store/src/test/java/software/xdev/spring/data/eclipse/store/integration/isolated/tests/duplicated/repositories/DaoFirstRepository.java

@@ -13,11 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package software.xdev.spring.data.eclipse.store.integration.shared.repositories.immutables;
+package software.xdev.spring.data.eclipse.store.integration.isolated.tests.duplicated.repositories;
 
 import org.springframework.data.repository.CrudRepository;
 
 
-public interface CustomerWithFinalIdRepository extends CrudRepository<CustomerWithFinalId, Integer>
+public interface DaoFirstRepository
+	extends CrudRepository<DaoObject, Integer>
 {
 }