X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=bundles%2Forg.simantics.objmap2%2Fsrc%2Forg%2Fsimantics%2Fobjmap%2Fgraph%2Fimpl%2FMapping.java;fp=bundles%2Forg.simantics.objmap2%2Fsrc%2Forg%2Fsimantics%2Fobjmap%2Fgraph%2Fimpl%2FMapping.java;h=ee1eb2e0b4bcdd48662a5a319d9d1e0d54f9d671;hb=969bd23cab98a79ca9101af33334000879fb60c5;hp=0000000000000000000000000000000000000000;hpb=866dba5cd5a3929bbeae85991796acb212338a08;p=simantics%2Fplatform.git

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
new file mode 100644
index 000000000..ee1eb2e0b
--- /dev/null
+++ b/bundles/org.simantics.objmap2/src/org/simantics/objmap/graph/impl/Mapping.java
@@ -0,0 +1,476 @@
+/*******************************************************************************
+ * Copyright (c) 2007, 2013 Association for Decentralized Information Management
+ * in Industry THTH ry.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     VTT Technical Research Centre of Finland - initial API and implementation
+ *******************************************************************************/
+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.Iterator;
+import java.util.List;
+import java.util.Set;
+
+import org.apache.log4j.Logger;
+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.IMapping;
+import org.simantics.objmap.graph.IMappingListener;
+import org.simantics.objmap.graph.schema.ILinkType;
+import org.simantics.objmap.graph.schema.IMappingSchema;
+
+/**
+ * An implementation of IMapping. The class should not be created
+ * directly but using methods in Mappings.
+ * @see org.simantics.objmap.graph.Mappings
+ * @author Hannu Niemistö
+ */
+public class Mapping<Domain, Range> implements IMapping<Domain, Range> {
+
+	static Logger LOGGER = Logger.getLogger("org.simantics.objmap");
+	
+	
+	IMappingSchema<Domain, Range> schema;
+	
+	THashMap<Domain, Link<Domain,Range>> domain = new THashMap<Domain, Link<Domain,Range>>();
+	THashMap<Range, Link<Domain,Range>> range = new THashMap<Range, Link<Domain,Range>>();
+	ArrayList<IMappingListener> listeners = new ArrayList<IMappingListener>();
+
+	ArrayList<Link<Domain,Range>> modifiedDomainLinks = new ArrayList<Link<Domain,Range>>();
+	ArrayList<Link<Domain,Range>> modifiedRangeLinks = new ArrayList<Link<Domain,Range>>();
+
+	boolean disposed = false;
+	
+	boolean listensDomain; 
+	
+	public Mapping(IMappingSchema<Domain, Range> schema, boolean listensDomain) {
+		this.schema = schema;
+		this.listensDomain = listensDomain;
+	}
+	
+	private void removeLink(Link<Domain,Range> link) {
+		if(link.domainModified)
+			modifiedDomainLinks.remove(link);
+		if(link.rangeModified)
+			modifiedRangeLinks.remove(link);
+		link.removed = true;
+	}
+	
+	private void createDomain(WriteGraph g, Link<Domain,Range> link) throws MappingException {
+	    LOGGER.info("        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);
+		
+        // TODO Should we do this only if the mapping is listening?
+        domainModified(link);
+	}
+	
+	private void createRange(ReadGraph g, Link<Domain,Range> link) throws MappingException {
+		ILinkType<Domain,Range> type = schema.linkTypeOfDomainElement(g, link.domainElement);		
+		Range rangeElement = type.createRangeElement(g, link.domainElement);
+		
+		link.type = type;
+		link.rangeElement = rangeElement;
+		range.put(rangeElement, link);
+		type.createRange(g, new DomainToRange(g), link.domainElement, rangeElement);
+	}
+	
+	Set<Domain> domainSet = new AbstractSet<Domain>() {
+
+		public boolean add(Domain e) {
+			if(domain.containsKey(e))
+				return false;
+			Link<Domain,Range> link = new Link<Domain,Range>(null, e, null);
+			domain.put(e, link);
+			modifiedDomainLinks.add(link);
+			return true;
+		}
+		
+		public boolean contains(Object o) {
+			return domain.contains(o);
+		}
+		
+		public boolean remove(Object o) {
+			Link<Domain,Range> link = domain.remove(o);			
+			if(link == null)
+				return false;
+			removeLink(link);
+			if(link.rangeElement != null)
+				range.remove(link.rangeElement);
+			return true;	
+		}
+		
+		@Override
+		public Iterator<Domain> iterator() {
+		    // FIXME does not implement Iterator.remove correctly
+			return domain.keySet().iterator();
+		}
+
+		@Override
+		public int size() {
+			return domain.size();
+		}
+		
+	};
+	
+	Set<Range> rangeSet = new AbstractSet<Range>() {
+
+		public boolean add(Range e) {
+			if(range.containsKey(e))
+				return false;
+			Link<Domain,Range> link = new Link<Domain,Range>(null, null, e);
+			range.put(e, link);
+			modifiedRangeLinks.add(link);
+			return true;
+		}
+		
+		public boolean contains(Object o) {
+			return range.contains(o);
+		}
+		
+		public boolean remove(Object o) {
+			Link<Domain,Range> link = range.remove(o);			
+			if(link == null)
+				return false;
+			removeLink(link);
+			if(link.domainElement != null)
+				domain.remove(link.domainElement);
+			return true;
+		}
+		
+		@Override
+		public Iterator<Range> iterator() {
+		    // FIXME does not implement Iterator.remove correctly
+			return range.keySet().iterator();
+		}
+
+		@Override
+		public int size() {
+			return range.size();
+		}
+		
+	};
+	
+	class DomainToRange implements IForwardMapping<Domain, Range> {
+
+		ReadGraph g;
+		
+		public DomainToRange(ReadGraph g) {
+			this.g = g;
+		}
+
+		@Override
+		public Range get(Domain element)  {
+			Link<Domain,Range> link = domain.get(element);
+			if (link != null)
+				return link.rangeElement;
+			return null;
+			
+		}
+		
+		@Override
+		public Range map(ReadGraph graph, Domain element)
+				throws MappingException {
+			Link<Domain,Range> link = domain.get(element);
+			if(link == null) {
+			    link = new Link<Domain,Range>(null, element, null);
+	            link.domainModified = true;
+	            modifiedDomainLinks.add(link);
+			    domain.put(element, link);           
+			    createRange(g, link);	
+			}
+			else if(link.type == null) 
+				createRange(g, link);
+            return link.rangeElement;
+		}
+		
+		@Override
+		public Set<Domain> getDomain() {
+			return domain.keySet();
+		}
+		
+	};
+	
+	class RangeToDomain extends DomainToRange implements IBackwardMapping<Domain, Range> {
+
+		WriteGraph g;
+		
+		public RangeToDomain(WriteGraph g) {
+			super(g);
+			this.g = g;
+		}
+		@Override
+		public Domain inverseGet(Range element) {
+			
+			Link<Domain,Range> link = range.get(element);
+			if(link != null)
+				return link.domainElement;
+			return null;
+		}
+		
+		@Override
+		public Domain inverseMap(WriteGraph graph, Range element)
+				throws MappingException {
+			Link<Domain,Range> link = range.get(element);
+			if(link == null) {
+			    link = new Link<Domain,Range>(null, null, element);
+			    link.rangeModified = true;
+                modifiedRangeLinks.add(link);
+			    range.put(element, link);
+			    createDomain(g, link);				
+			}
+			else if(link.type == null)
+				createDomain(g, link);
+			return link.domainElement;
+		}
+		
+		
+		@Override
+		public Set<Range> getRange() {
+			return range.keySet();
+		}
+	};
+	
+	@Override
+	public Set<Domain> getDomain() {
+		return domainSet;
+	}
+	
+	@Override
+	public Set<Range> getRange() {
+		return rangeSet;
+	}
+	
+	
+	@Override
+	public synchronized Collection<Domain> updateDomain(WriteGraph g) throws MappingException {
+	    LOGGER.info("Mapping.updateDomain");
+		RangeToDomain map = new RangeToDomain(g);
+		ArrayList<Domain> updated = new ArrayList<Domain>();
+		while(!modifiedRangeLinks.isEmpty()) {
+		    LOGGER.info("    modifiedRangeLinks.size() = " + modifiedRangeLinks.size());
+		    
+			Link<Domain,Range> link = modifiedRangeLinks.remove(modifiedRangeLinks.size()-1);
+			link.rangeModified = false;
+			/*if(link.domainModified) {
+				link.domainModified = false;
+				modifiedDomainLinks.remove(link);
+			}*/
+			
+			if(link.type == null) {
+				createDomain(g, link);
+			}
+			
+			if(link.type.updateDomain(g, map, link.domainElement, link.rangeElement))
+				updated.add(link.domainElement);
+		}	
+		if (listensDomain)
+			updateRange(g); //FIXME: without this listening would stop. 
+		return updated;
+	}
+	
+	@Override
+	public synchronized Collection<Range> updateRange(ReadGraph g) throws MappingException {
+	    LOGGER.info("Mapping.updateRange");
+		DomainToRange map = new DomainToRange(g);
+		ArrayList<Range> updated = new ArrayList<Range>();
+		while(!modifiedDomainLinks.isEmpty()) {		    
+		    LOGGER.info("    modifiedDomainLinks.size() = " + modifiedDomainLinks.size());
+		    
+			Link<Domain,Range> link = modifiedDomainLinks.remove(modifiedDomainLinks.size()-1);
+			link.domainModified = false;
+			/*if(link.rangeModified) {
+				link.rangeModified = false;
+				modifiedRangeLinks.remove(link);
+			}*/
+			
+			if(link.type == null) {
+				createRange(g, link);
+			}
+			
+			if(listensDomain) {
+			    RangeUpdateRequest<Domain,Range> request = new RangeUpdateRequest<Domain,Range>(link, map, this);
+			    try {
+                    g.syncRequest(request, request);
+                } catch (DatabaseException e) {
+                    throw new MappingException(e);
+                }
+			    // TODO check if really modified
+			    updated.add(link.rangeElement);
+			}
+			else
+			    if(link.type.updateRange(g, map, link.domainElement, link.rangeElement))
+			    	updated.add(link.rangeElement);
+		}	
+		return updated;
+	}
+
+	@Override
+	public Range get(Domain domainElement) {
+		Link<Domain,Range> link = domain.get(domainElement);
+		if(link == null)
+			return null;
+		return link.rangeElement;
+	}
+
+	@Override
+	public Domain inverseGet(Range rangeElement) {
+		Link<Domain,Range> link = range.get(rangeElement);
+		if(link == null)
+			return null;
+		return link.domainElement;
+	}
+
+	@Override
+	public Domain inverseMap(WriteGraph g, Range rangeElement) throws MappingException {
+		getRange().add(rangeElement);
+		updateDomain(g);
+		return inverseGet(rangeElement);
+	}
+
+	@Override
+	public Range map(ReadGraph g, Domain domainElement) throws MappingException {
+		getDomain().add(domainElement);
+		updateRange(g);
+		return get(domainElement);
+	}
+
+	void domainModified(Link<Domain,Range> link) {
+	    if(!link.domainModified) {	        
+	        synchronized(modifiedDomainLinks) {
+	            LOGGER.info("        domainModified for " + link.rangeElement);
+                link.domainModified = true;
+                modifiedDomainLinks.add(link);
+                if(modifiedDomainLinks.size() == 1) {
+                    for(IMappingListener listener : listeners)
+                        listener.domainModified();
+                }
+	        }
+        }
+	}
+	
+	@Override
+	public void domainModified(Domain domainElement) {
+		Link<Domain,Range> link = domain.get(domainElement);
+		if(link != null)
+		    domainModified(link);
+	}
+
+	void rangeModified(Link<Domain,Range> link) {
+	    if(!link.rangeModified) {
+	        synchronized(modifiedRangeLinks) {
+                link.rangeModified = true;
+                modifiedRangeLinks.add(link);
+                if(modifiedRangeLinks.size() == 1) {
+                    for(IMappingListener listener : listeners)
+                        listener.rangeModified();
+                }
+	        }
+        }
+	}
+	
+	@Override
+	public void rangeModified(Range rangeElement) {
+		Link<Domain,Range> link = range.get(rangeElement);
+		if(link != null)
+		    rangeModified(link);
+	}
+
+	@Override
+	public boolean isDomainModified() {
+		return !modifiedDomainLinks.isEmpty();
+	}
+
+	@Override
+	public boolean isRangeModified() {
+		return !modifiedRangeLinks.isEmpty();
+	}
+	
+	@Override
+	public Collection<Domain> getDomainModified() {
+		List<Domain> list = new ArrayList<Domain>(modifiedDomainLinks.size());
+		for (Link<Domain, Range> link : modifiedDomainLinks)
+			list.add(link.domainElement);
+		return list;
+				
+	}
+	
+	@Override
+	public Collection<Range> getRangeModified() {
+		List<Range> list = new ArrayList<Range>(modifiedRangeLinks.size());
+		for (Link<Domain, Range> link : modifiedRangeLinks)
+			list.add(link.rangeElement);
+		return list;
+	}
+
+	@Override
+	public void addMappingListener(IMappingListener listener) {
+		listeners.add(listener);
+	}
+
+	@Override
+	public void removeMappingListener(IMappingListener listener) {
+		listeners.remove(listener);		
+	}
+
+	@Override
+	public Collection<Domain> getConflictingDomainElements() {
+		ArrayList<Domain> result = new ArrayList<Domain>();
+		if(modifiedDomainLinks.size() < modifiedRangeLinks.size()) {
+			for(Link<Domain,Range> link : modifiedDomainLinks)
+				if(link.rangeModified)
+					result.add(link.domainElement);
+		}
+		else {
+			for(Link<Domain,Range> link : modifiedRangeLinks)
+				if(link.domainModified)
+					result.add(link.domainElement);
+		}
+		return result;
+	}
+
+	@Override
+	public Collection<Range> getConflictingRangeElements() {
+		ArrayList<Range> result = new ArrayList<Range>();
+		if(modifiedDomainLinks.size() < modifiedRangeLinks.size()) {
+			for(Link<Domain,Range> link : modifiedDomainLinks)
+				if(link.rangeModified)
+					result.add(link.rangeElement);
+		}
+		else {
+			for(Link<Domain,Range> link : modifiedRangeLinks)
+				if(link.domainModified)
+					result.add(link.rangeElement);
+		}
+		return result;
+	}
+
+    @Override
+    public void dispose() {
+        disposed = true;
+    }
+    
+    public boolean isDisposed() {
+        return disposed;
+    }
+	
+}