1717
1818import java .util .Collection ;
1919import java .util .HashSet ;
20+ import java .util .Objects ;
2021import java .util .Set ;
2122import java .util .concurrent .locks .Lock ;
2223import java .util .concurrent .locks .ReentrantReadWriteLock ;
@@ -48,7 +49,7 @@ public enum ProcessState {
4849 /**
4950 * The set of already processed relationships.
5051 */
51- private final Set <RelationshipDescription > processedRelationshipDescriptions = new HashSet <>();
52+ private final Set <RelationshipDescriptionWithSourceId > processedRelationshipDescriptions = new HashSet <>();
5253
5354 /**
5455 * The set of already processed related objects.
@@ -64,11 +65,11 @@ public NestedRelationshipProcessingStateMachine(Object initialObject) {
6465 * @param valuesToStore Check whether all the values in the collection have been processed
6566 * @return The state of things processed
6667 */
67- public ProcessState getStateOf (RelationshipDescription relationshipDescription , @ Nullable Collection <?> valuesToStore ) {
68+ public ProcessState getStateOf (Object fromId , RelationshipDescription relationshipDescription , @ Nullable Collection <?> valuesToStore ) {
6869
6970 try {
7071 read .lock ();
71- boolean hasProcessedRelationship = hasProcessed ( relationshipDescription );
72+ boolean hasProcessedRelationship = hasProcessedRelationship ( fromId , relationshipDescription );
7273 boolean hasProcessedAllValues = hasProcessedAllOf (valuesToStore );
7374 if (hasProcessedRelationship && hasProcessedAllValues ) {
7475 return ProcessState .PROCESSED_BOTH ;
@@ -85,38 +86,97 @@ public ProcessState getStateOf(RelationshipDescription relationshipDescription,
8586 }
8687 }
8788
89+ /**
90+ * Combination of relationship description and fromId to differentiate between `equals`-wise equal relationship
91+ * descriptions by their source identifier. This is needed because sometimes the very same relationship definition
92+ * can get processed for different objects of the same entity.
93+ * One could say that this is a Tuple but it has a nicer name.
94+ */
95+ private static class RelationshipDescriptionWithSourceId {
96+ private final Object id ;
97+ private final RelationshipDescription relationshipDescription ;
98+
99+ RelationshipDescriptionWithSourceId (Object id , RelationshipDescription relationshipDescription ) {
100+ this .id = id ;
101+ this .relationshipDescription = relationshipDescription ;
102+ }
103+
104+ @ Override
105+ public boolean equals (Object o ) {
106+ if (this == o ) {
107+ return true ;
108+ }
109+ if (o == null || getClass () != o .getClass ()) {
110+ return false ;
111+ }
112+ RelationshipDescriptionWithSourceId that = (RelationshipDescriptionWithSourceId ) o ;
113+ return id .equals (that .id ) && relationshipDescription .equals (that .relationshipDescription );
114+ }
115+
116+ @ Override
117+ public int hashCode () {
118+ return Objects .hash (id , relationshipDescription );
119+ }
120+ }
121+
88122 /**
89123 * Marks the passed objects as processed
90124 *
91125 * @param relationshipDescription To be marked as processed
92- * @param valuesToStore If not {@literal null}, all non-null values will be marked as processed
93126 */
94- public void markAsProcessed ( RelationshipDescription relationshipDescription , @ Nullable Collection <?> valuesToStore ) {
127+ public void markRelationshipAsProcessed ( Object fromId , RelationshipDescription relationshipDescription ) {
95128
96129 try {
97130 write .lock ();
98- this .processedRelationshipDescriptions .add (relationshipDescription );
99- if (valuesToStore != null ) {
100- valuesToStore .stream ().filter (v -> v != null ).forEach (processedObjects ::add );
101- }
131+ this .processedRelationshipDescriptions .add (new RelationshipDescriptionWithSourceId (fromId , relationshipDescription ));
102132 } finally {
103133 write .unlock ();
104134 }
105135 }
136+ /**
137+ * Marks the passed objects as processed
138+ *
139+ * @param valueToStore If not {@literal null}, all non-null values will be marked as processed
140+ */
141+ public void markValueAsProcessed (Object valueToStore ) {
106142
107- private boolean hasProcessedAllOf (@ Nullable Collection <?> valuesToStore ) {
108- // there can be null elements in the unified collection of values to store.
109- if (valuesToStore == null ) {
110- return false ;
143+ try {
144+ write .lock ();
145+ this .processedObjects .add (valueToStore );
146+ } finally {
147+ write .unlock ();
111148 }
112- return processedObjects .containsAll (valuesToStore );
113149 }
114150
115- private boolean hasProcessed (RelationshipDescription relationshipDescription ) {
151+ /**
152+ * Checks if the value has already been processed.
153+ *
154+ * @param value the object that should be looked for in the registry.
155+ * @return processed yes (true) / no (false)
156+ */
157+ public boolean hasProcessedValue (Object value ) {
158+ return processedObjects .contains (value );
159+ }
116160
161+ /**
162+ * Checks if the relationship has already been processed.
163+ *
164+ * @param relationshipDescription the relationship that should be looked for in the registry.
165+ * @return processed yes (true) / no (false)
166+ */
167+ public boolean hasProcessedRelationship (Object fromId , @ Nullable RelationshipDescription relationshipDescription ) {
117168 if (relationshipDescription != null ) {
118- return processedRelationshipDescriptions .contains (relationshipDescription );
169+ return processedRelationshipDescriptions .contains (new RelationshipDescriptionWithSourceId ( fromId , relationshipDescription ) );
119170 }
120171 return false ;
121172 }
173+
174+ private boolean hasProcessedAllOf (@ Nullable Collection <?> valuesToStore ) {
175+ // there can be null elements in the unified collection of values to store.
176+ if (valuesToStore == null ) {
177+ return false ;
178+ }
179+ return processedObjects .containsAll (valuesToStore );
180+ }
181+
122182}
0 commit comments