Simple Lazy working quite well. More complex lazies are not implemented yet.

Author: JohannesRabauer

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

@@ -22,30 +22,40 @@
 import org.eclipse.serializer.reference.Swizzling;
 
 
+/**
+ * This is the Lazy-Wrapper a user of the Spring-Data-Eclipse-Store-Library should use. Please <b>do not use the
+ * {@link Lazy}-Wrapper!</b> Because SDES is making working copies of the stored data, the {@link Lazy} does not work as
+ * expected. Instead, use this Wrapper. It brings the same functionality as the native {@link Lazy}-Wrapper but works
+ * with working copies.
+ */
 public interface SpringDataEclipseStoreLazy<T> extends Lazy<T>
 {
 	static <T> SpringDataEclipseStoreLazy.Default<T> build(final T objectToWrapInLazy)
 	{
 		return new Default<>(objectToWrapInLazy);
 	}
 
-	static SpringDataEclipseStoreLazy.Default<?> buildOnlyForStorage(final long objectId)
-	{
-		return new Default<>(objectId);
-	}
+	SpringDataEclipseStoreLazy<T> copy();
 
 	long objectId();
 
+	/**
+	 * This class is very complex and its various membervariables all have their reason to exist. This code is very
+	 * difficult to read due to its the functionality explained in the {@link SpringDataEclipseStoreLazyBinaryHandler}.
+	 *
+	 * @param <T>
+	 */
 	class Default<T> implements SpringDataEclipseStoreLazy<T>
 	{
+		private T objectToBeWrapped;
 		private Lazy<T> wrappedLazy;
 		private long objectId = Swizzling.notFoundId();
 		private transient ObjectSwizzling loader;
 		private transient boolean isStored = false;
 
 		private Default(final T wrappedObject)
 		{
-			this.wrappedLazy = Lazy.Reference(wrappedObject);
+			this.objectToBeWrapped = wrappedObject;
 		}
 
 		private Default(final long objectId, final ObjectSwizzling loader)
@@ -54,11 +64,6 @@ private Default(final long objectId, final ObjectSwizzling loader)
 			this.loader = loader;
 		}
 
-		private Default(final long objectId)
-		{
-			this.objectId = objectId;
-		}
-		
 		private Lazy<T> ensureLazy()
 		{
 			if(this.wrappedLazy == null)
@@ -80,6 +85,10 @@ public static final Class<SpringDataEclipseStoreLazy.Default<?>> genericType()
 		@Override
 		public T get()
 		{
+			if(this.objectToBeWrapped != null)
+			{
+				return this.objectToBeWrapped;
+			}
 			return this.ensureLazy().get();
 		}
 
@@ -116,6 +125,10 @@ void setStored()
 		@Override
 		public boolean isLoaded()
 		{
+			if(this.objectToBeWrapped != null)
+			{
+				return true;
+			}
 			if(this.wrappedLazy == null)
 			{
 				return false;
@@ -148,5 +161,24 @@ public long objectId()
 			}
 			return this.objectId;
 		}
+		
+		void setWrappedLazy(final Lazy<T> wrappedLazy)
+		{
+			this.wrappedLazy = wrappedLazy;
+		}
+		
+		public T getObjectToBeWrapped()
+		{
+			return this.objectToBeWrapped;
+		}
+		
+		@Override
+		public SpringDataEclipseStoreLazy<T> copy()
+		{
+			return new SpringDataEclipseStoreLazy.Default(
+				this.objectId,
+				this.loader
+			);
+		}
 	}
 }

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

@@ -18,8 +18,10 @@
 import java.lang.reflect.Constructor;
 import java.util.Objects;
 
+import org.eclipse.serializer.memory.XMemory;
 import org.eclipse.serializer.persistence.binary.types.AbstractBinaryHandlerCustom;
 import org.eclipse.serializer.persistence.binary.types.Binary;
+import org.eclipse.serializer.persistence.binary.types.BinaryTypeHandler;
 import org.eclipse.serializer.persistence.types.PersistenceLoadHandler;
 import org.eclipse.serializer.persistence.types.PersistenceReferenceLoader;
 import org.eclipse.serializer.persistence.types.PersistenceStoreHandler;
@@ -29,67 +31,115 @@
 
 
 /**
- * Copied from
- * {@link org.eclipse.serializer.persistence.binary.org.eclipse.serializer.reference.BinaryHandlerLazyDefault}.
+ * This is a complicated one. First off: this handler should only be used for WorkingCopies (see
+ * {@link software.xdev.spring.data.eclipse.store.repository.support.copier.copier.EclipseSerializerRegisteringCopier})!
+ * <p>
+ *     First case:<br/>
+ *     The user creates a {@link SpringDataEclipseStoreLazy} and puts a object in it.
+ *     This object is stored as with a default {@link BinaryTypeHandler}. But when it gets loaded,
+ *     it <b>does not</b> load as the stored object, but it gets wrapped in a {@link Lazy#Reference(Object)}.
+ * </p>
+ * <p>
+ *     Second case:<br/>
+ *     The actual lazy object gets loaded from the actual storage. In this case the {@link ObjectSwizzling} is
+ *     important! It's the actual {@link ObjectSwizzling} from the storage (not from the
+ * {@link software.xdev.spring.data.eclipse.store.repository.support.copier.copier.EclipseSerializerRegisteringCopier}).
+ *     This means, the {@link SpringDataEclipseStoreLazy} holds the objectId of the original lazy in the original
+ *     storage.
+ *     Therefore if {@link SpringDataEclipseStoreLazy#get()} is called a new working copy of the lazy from the
+ *     storage is loaded.
+ * </p>
  */
 public final class SpringDataEclipseStoreLazyBinaryHandler
 	extends AbstractBinaryHandlerCustom<SpringDataEclipseStoreLazy.Default<?>>
 {
 	@SuppressWarnings("rawtypes")
-	static final Constructor<SpringDataEclipseStoreLazy.Default> CONSTRUCTOR = XReflect.setAccessible(
+	static final Constructor<SpringDataEclipseStoreLazy.Default> CONSTRUCTOR_SURROGATE_LAZY = XReflect.setAccessible(
 		XReflect.getDeclaredConstructor(
 			SpringDataEclipseStoreLazy.Default.class,
 			long.class,
 			ObjectSwizzling.class
 		)
 	);
 
-	private final ObjectSwizzling objectSwizzling;
+	public static final int OFFSET_UNWRAPPED_OBJECT = 8;
+	public static final int OFFSET_LAZY = 0;
 
-	public SpringDataEclipseStoreLazyBinaryHandler(final ObjectSwizzling objectSwizzling)
+	private final ObjectSwizzling originalStoreLoader;
+	
+	public SpringDataEclipseStoreLazyBinaryHandler(final ObjectSwizzling originalStoreLoader)
 	{
 		super(
 			SpringDataEclipseStoreLazy.Default.genericType(),
 			CustomFields(
-				CustomField(Object.class, "subject")
+				CustomField(Object.class, "lazySubject"),
+				CustomField(Object.class, "unwrappedSubject")
 			)
 		);
-		this.objectSwizzling = Objects.requireNonNull(objectSwizzling);
+		this.originalStoreLoader = Objects.requireNonNull(originalStoreLoader);
 	}
 
 	@Override
-	public final void store(
+	public void store(
 		final Binary data,
 		final SpringDataEclipseStoreLazy.Default<?> instance,
 		final long objectId,
 		final PersistenceStoreHandler<Binary> handler
 	)
 	{
-		final long referenceOid = instance.objectId();
-		data.storeEntityHeader(Binary.referenceBinaryLength(1), this.typeId(), objectId);
-		data.store_long(referenceOid);
+		data.storeEntityHeader(Binary.referenceBinaryLength(2), this.typeId(), objectId);
+		if(instance.getObjectToBeWrapped() != null)
+		{
+			// Store unwrapped Object
+			final long newObjectId = handler.applyEager(instance.getObjectToBeWrapped());
+			data.store_long(OFFSET_UNWRAPPED_OBJECT, newObjectId);
+		}
+		else
+		{
+			// Store only reference to lazy
+			data.store_long(OFFSET_LAZY, instance.objectId());
+		}
 		instance.setStored();
 	}
 
 	@SuppressWarnings("unchecked")
 	@Override
-	public final SpringDataEclipseStoreLazy.Default<?> create(final Binary data, final PersistenceLoadHandler handler)
+	public SpringDataEclipseStoreLazy.Default<?> create(final Binary data, final PersistenceLoadHandler handler)
 	{
-		final long objectId = data.read_long(0);
+		final long objectIdOfLazy = data.read_long(OFFSET_LAZY);
+		final long objectIdOfUnwrappedObject = data.read_long(OFFSET_UNWRAPPED_OBJECT);
 
-		return Lazy.register(
-			XReflect.invoke(CONSTRUCTOR, objectId, this.objectSwizzling)
-		);
+		if(objectIdOfUnwrappedObject == 0)
+		{
+			return Lazy.register(
+				XReflect.invoke(CONSTRUCTOR_SURROGATE_LAZY, objectIdOfLazy, this.originalStoreLoader)
+			);
+		}
+		return XMemory.instantiateBlank(SpringDataEclipseStoreLazy.Default.class);
 	}
 
 	@Override
-	public final void updateState(
+	public void updateState(
 		final Binary data,
 		final SpringDataEclipseStoreLazy.Default<?> instance,
 		final PersistenceLoadHandler handler
 	)
 	{
-		// no-op
+		this.updateStateT(data, instance, handler);
+	}
+	
+	private <T> void updateStateT(
+		final Binary data,
+		final SpringDataEclipseStoreLazy.Default<T> instance,
+		final PersistenceLoadHandler handler
+	)
+	{
+		final long objectIdOfUnwrappedObject = data.read_long(OFFSET_UNWRAPPED_OBJECT);
+		
+		if(objectIdOfUnwrappedObject != 0)
+		{
+			instance.setWrappedLazy(Lazy.Reference((T)handler.lookupObject(objectIdOfUnwrappedObject)));
+		}
 	}
 
 	@Override
@@ -122,10 +172,15 @@ public final boolean hasVaryingPersistedLengthInstances()
 
 	@Override
 	public final void iterateLoadableReferences(
-		final Binary offset,
+		final Binary data,
 		final PersistenceReferenceLoader iterator
 	)
 	{
-		// the lazy reference is not naturally loadable, but special-handled by this handler
+		final long objectIdOfUnwrappedObject = data.read_long(OFFSET_UNWRAPPED_OBJECT);
+		
+		if(objectIdOfUnwrappedObject != 0)
+		{
+			iterator.acceptObjectId(objectIdOfUnwrappedObject);
+		}
 	}
 }

spring-data-eclipse-store/src/main/java/software/xdev/spring/data/eclipse/store/repository/support/copier/working/RecursiveWorkingCopier.java

@@ -330,7 +330,7 @@ private <E> SpringDataEclipseStoreLazy<E> createNewLazy(
 			{
 				// This lazy should never be used again!
 				// It is though of as a temporary copy to merge back into the original-storage-data.
-				return (SpringDataEclipseStoreLazy<E>)SpringDataEclipseStoreLazy.buildOnlyForStorage(oldLazy.objectId());
+				return oldLazy.copy();
 			}
 	}
 

spring-data-eclipse-store/src/test/java/software/xdev/spring/data/eclipse/store/integration/isolated/tests/lazy/ComplexLazyObject.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright © 2023 XDEV Software (https://xdev.software)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package software.xdev.spring.data.eclipse.store.integration.isolated.tests.lazy;
+
+import java.util.List;
+
+import org.eclipse.serializer.reference.Lazy;
+
+
+public class ComplexLazyObject
+{
+	private Lazy<SimpleObject> simpleObject;
+	private List<Lazy<List<String>>> listOfLazyListOfString;
+	
+	public ComplexLazyObject(
+		final Lazy<SimpleObject> simpleObject,
+		final List<Lazy<List<String>>> listOfLazyListOfString)
+	{
+		this.simpleObject = simpleObject;
+		this.listOfLazyListOfString = listOfLazyListOfString;
+	}
+	
+	public Lazy<SimpleObject> getSimpleObject()
+	{
+		return this.simpleObject;
+	}
+	
+	public void setSimpleObject(final Lazy<SimpleObject> simpleObject)
+	{
+		this.simpleObject = simpleObject;
+	}
+	
+	public List<Lazy<List<String>>> getListOfLazyListOfString()
+	{
+		return this.listOfLazyListOfString;
+	}
+	
+	public void setListOfLazyListOfString(final List<Lazy<List<String>>> listOfLazyListOfString)
+	{
+		this.listOfLazyListOfString = listOfLazyListOfString;
+	}
+}