Thread safety changes in objmap2

[simantics/platform.git] / bundles / org.simantics.objmap2 / src / org / simantics / objmap / graph / impl / Mapping.java

diff --git a/bundles/org.simantics.objmap2/src/org/simantics/objmap/graph/impl/Mapping.java b/bundles/org.simantics.objmap2/src/org/simantics/objmap/graph/impl/Mapping.java
index 9f048f7752b1a900a1730eae5242d53519d21a8b..4820dae016b44c358fe52206d876f25a66b42fe3 100644 (file)
--- a/bundles/org.simantics.objmap2/src/org/simantics/objmap/graph/impl/Mapping.java
+++ b/bundles/org.simantics.objmap2/src/org/simantics/objmap/graph/impl/Mapping.java
@@ -12,8 +12,6 @@
 package org.simantics.objmap.graph.impl;
 
 
-import gnu.trove.map.hash.THashMap;
-
 import java.util.AbstractSet;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -21,12 +19,9 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 import org.simantics.db.ReadGraph;
 import org.simantics.db.WriteGraph;
 import org.simantics.db.exception.DatabaseException;
-
 import org.simantics.objmap.backward.IBackwardMapping;
 import org.simantics.objmap.exceptions.MappingException;
 import org.simantics.objmap.forward.IForwardMapping;
@@ -34,6 +29,10 @@ import org.simantics.objmap.graph.IMapping;
 import org.simantics.objmap.graph.IMappingListener;
 import org.simantics.objmap.graph.schema.ILinkType;
 import org.simantics.objmap.graph.schema.IMappingSchema;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import gnu.trove.map.hash.THashMap;
 
 /**
  * An implementation of IMapping. The class should not be created
@@ -73,13 +72,13 @@ public class Mapping<Domain, Range> implements IMapping<Domain, Range> {
        }
        
        private void createDomain(WriteGraph g, Link<Domain,Range> link) throws MappingException {
-           LOGGER.info("        createDomain for " + link.rangeElement);
+           LOGGER.trace("        createDomain for " + link.rangeElement);
                ILinkType<Domain,Range> type = schema.linkTypeOfRangeElement(link.rangeElement);
                Domain domainElement = type.createDomainElement(g, link.rangeElement);
                link.type = type;
                link.domainElement = domainElement;
                domain.put(domainElement, link);
-               type.createDomain(g, new RangeToDomain(g), domainElement, link.rangeElement);
+               type.createDomain(g, new RangeToDomain(), domainElement, link.rangeElement);
                
         // TODO Should we do this only if the mapping is listening?
         domainModified(link);
@@ -92,7 +91,7 @@ public class Mapping<Domain, Range> implements IMapping<Domain, Range> {
                link.type = type;
                link.rangeElement = rangeElement;
                range.put(rangeElement, link);
-               type.createRange(g, new DomainToRange(g), link.domainElement, rangeElement);
+               type.createRange(g, new DomainToRange(), link.domainElement, rangeElement);
        }
        
        Set<Domain> domainSet = new AbstractSet<Domain>() {
@@ -173,10 +172,7 @@ public class Mapping<Domain, Range> implements IMapping<Domain, Range> {
        
        class DomainToRange implements IForwardMapping<Domain, Range> {
 
-               ReadGraph g;
-               
-               public DomainToRange(ReadGraph g) {
-                       this.g = g;
+               public DomainToRange() {
                }
 
                @Override
@@ -197,10 +193,10 @@ public class Mapping<Domain, Range> implements IMapping<Domain, Range> {
                    link.domainModified = true;
                    modifiedDomainLinks.add(link);
                            domain.put(element, link);           
-                           createRange(g, link);       
+                           createRange(graph, link);   
                        }
                        else if(link.type == null) 
-                               createRange(g, link);
+                               createRange(graph, link);
             return link.rangeElement;
                }
                
@@ -213,12 +209,10 @@ public class Mapping<Domain, Range> implements IMapping<Domain, Range> {
        
        class RangeToDomain extends DomainToRange implements IBackwardMapping<Domain, Range> {
 
-               WriteGraph g;
-               
-               public RangeToDomain(WriteGraph g) {
-                       super(g);
-                       this.g = g;
+               public RangeToDomain() {
+                       super();
                }
+               
                @Override
                public Domain inverseGet(Range element) {
                        
@@ -237,10 +231,10 @@ public class Mapping<Domain, Range> implements IMapping<Domain, Range> {
                            link.rangeModified = true;
                 modifiedRangeLinks.add(link);
                            range.put(element, link);
-                           createDomain(g, link);                              
+                           createDomain(graph, link);                          
                        }
                        else if(link.type == null)
-                               createDomain(g, link);
+                               createDomain(graph, link);
                        return link.domainElement;
                }
                
@@ -264,11 +258,11 @@ public class Mapping<Domain, Range> implements IMapping<Domain, Range> {
        
        @Override
        public synchronized Collection<Domain> updateDomain(WriteGraph g) throws MappingException {
-           LOGGER.info("Mapping.updateDomain");
-               RangeToDomain map = new RangeToDomain(g);
+           LOGGER.trace("Mapping.updateDomain");
+               RangeToDomain map = new RangeToDomain();
                ArrayList<Domain> updated = new ArrayList<Domain>();
                while(!modifiedRangeLinks.isEmpty()) {
-                   LOGGER.info("    modifiedRangeLinks.size() = " + modifiedRangeLinks.size());
+                   LOGGER.trace("    modifiedRangeLinks.size() = " + modifiedRangeLinks.size());
                    
                        Link<Domain,Range> link = modifiedRangeLinks.remove(modifiedRangeLinks.size()-1);
                        link.rangeModified = false;
@@ -280,9 +274,10 @@ public class Mapping<Domain, Range> implements IMapping<Domain, Range> {
                        if(link.type == null) {
                                createDomain(g, link);
                        }
-                       
-                       if(link.type.updateDomain(g, map, link.domainElement, link.rangeElement))
-                               updated.add(link.domainElement);
+                       else {
+                               if(link.type.updateDomain(g, map, link.domainElement, link.rangeElement))
+                                       updated.add(link.domainElement);
+                       }
                }       
                if (listensDomain)
                        updateRange(g); //FIXME: without this listening would stop. 
@@ -291,11 +286,11 @@ public class Mapping<Domain, Range> implements IMapping<Domain, Range> {
        
        @Override
        public synchronized Collection<Range> updateRange(ReadGraph g) throws MappingException {
-           LOGGER.info("Mapping.updateRange");
-               DomainToRange map = new DomainToRange(g);
+           LOGGER.trace("Mapping.updateRange");
+               DomainToRange map = new DomainToRange();
                ArrayList<Range> updated = new ArrayList<Range>();
                while(!modifiedDomainLinks.isEmpty()) {             
-                   LOGGER.info("    modifiedDomainLinks.size() = " + modifiedDomainLinks.size());
+                   LOGGER.trace("    modifiedDomainLinks.size() = " + modifiedDomainLinks.size());
                    
                        Link<Domain,Range> link = modifiedDomainLinks.remove(modifiedDomainLinks.size()-1);
                        link.domainModified = false;
@@ -310,13 +305,15 @@ public class Mapping<Domain, Range> implements IMapping<Domain, Range> {
                        
                        if(listensDomain) {
                            RangeUpdateRequest<Domain,Range> request = new RangeUpdateRequest<Domain,Range>(link, map, this);
+                           boolean changes;
                            try {
-                    g.syncRequest(request, request);
+                               changes = g.syncRequest(request, request) > 0;
                 } catch (DatabaseException e) {
                     throw new MappingException(e);
                 }
-                           // TODO check if really modified
-                           updated.add(link.rangeElement);
+                           
+                           if (changes)
+                               updated.add(link.rangeElement);
                        }
                        else
                            if(link.type.updateRange(g, map, link.domainElement, link.rangeElement))
@@ -358,7 +355,7 @@ public class Mapping<Domain, Range> implements IMapping<Domain, Range> {
        void domainModified(Link<Domain,Range> link) {
            if(!link.domainModified) {          
                synchronized(modifiedDomainLinks) {
-                   LOGGER.info("        domainModified for " + link.rangeElement);
+                   LOGGER.trace("        domainModified for " + link.rangeElement);
                 link.domainModified = true;
                 modifiedDomainLinks.add(link);
                 if(modifiedDomainLinks.size() == 1) {