package org.simantics.objmap.graph.impl;
-import gnu.trove.map.hash.THashMap;
-
import java.util.AbstractSet;
import java.util.ArrayList;
import java.util.Collection;
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;
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
}
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);
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>() {
class DomainToRange implements IForwardMapping<Domain, Range> {
- ReadGraph g;
-
- public DomainToRange(ReadGraph g) {
- this.g = g;
+ public DomainToRange() {
}
@Override
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;
}
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) {
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;
}
@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;
@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;
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))
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) {