1 /*******************************************************************************
\r
2 * Copyright (c) 2007, 2010 Association for Decentralized Information Management
\r
3 * in Industry THTH ry.
\r
4 * All rights reserved. This program and the accompanying materials
\r
5 * are made available under the terms of the Eclipse Public License v1.0
\r
6 * which accompanies this distribution, and is available at
\r
7 * http://www.eclipse.org/legal/epl-v10.html
\r
10 * VTT Technical Research Centre of Finland - initial API and implementation
\r
11 *******************************************************************************/
\r
12 package org.simantics.diagram.handler;
\r
14 import java.util.ArrayList;
\r
15 import java.util.Collection;
\r
16 import java.util.EnumSet;
\r
17 import java.util.HashSet;
\r
18 import java.util.List;
\r
19 import java.util.Set;
\r
21 import org.simantics.g2d.connection.handler.ConnectionHandler;
\r
22 import org.simantics.g2d.element.ElementClass;
\r
23 import org.simantics.g2d.element.IElement;
\r
24 import org.simantics.g2d.element.handler.BendsHandler;
\r
25 import org.simantics.g2d.element.handler.TerminalTopology;
\r
26 import org.simantics.g2d.elementclass.BranchPoint;
\r
27 import org.simantics.g2d.elementclass.FlagHandler;
\r
28 import org.simantics.g2d.elementclass.MonitorHandler;
\r
29 import org.simantics.g2d.elementclass.NonCopyable;
\r
30 import org.simantics.g2d.elementclass.ReferenceElement;
\r
33 * @author Tuukka Lehtonen
\r
35 public class ElementAssortment implements IElementAssortment {
\r
37 public Set<IElement> all;
\r
39 public final List<IElement> nodeList = new ArrayList<IElement>();
\r
40 public final Set<IElement> nodes = new HashSet<IElement>();
\r
41 public final Set<IElement> connections = new HashSet<IElement>();
\r
42 public final Set<IElement> edges = new HashSet<IElement>();
\r
43 public final Set<IElement> branchPoints = new HashSet<IElement>();
\r
44 public final Set<IElement> flags = new HashSet<IElement>();
\r
45 public final Set<IElement> references = new HashSet<IElement>();
\r
46 public final Set<IElement> monitors = new HashSet<IElement>();
\r
47 public final Set<IElement> others = new HashSet<IElement>();
\r
48 public final Set<IElement> noncopyables = new HashSet<IElement>();
\r
50 EnumSet<ElementType> contents;
\r
53 * @param set all the elements to initially sort out. This object assumes
\r
54 * ownership of the set.
\r
56 public ElementAssortment(Set<IElement> set) {
\r
58 throw new IllegalArgumentException("null element set");
\r
59 this.all = new HashSet<IElement>(set);
\r
63 private void sort(Set<IElement> set) {
\r
64 EnumSet<ElementType> es = EnumSet.noneOf(ElementType.class);
\r
66 for (IElement el : set) {
\r
67 ElementClass ec = el.getElementClass();
\r
68 NonCopyable nc = ec.getAtMostOneItemOfClass(NonCopyable.class);
\r
69 ReferenceElement re = ec.getAtMostOneItemOfClass(ReferenceElement.class);
\r
70 MonitorHandler mh = ec.getAtMostOneItemOfClass(MonitorHandler.class);
\r
71 FlagHandler fh = ec.getAtMostOneItemOfClass(FlagHandler.class);
\r
72 TerminalTopology tt = ec.getAtMostOneItemOfClass(TerminalTopology.class);
\r
73 BendsHandler bh = ec.getAtMostOneItemOfClass(BendsHandler.class);
\r
74 BranchPoint bp = ec.getAtMostOneItemOfClass(BranchPoint.class);
\r
75 ConnectionHandler ch = ec.getAtMostOneItemOfClass(ConnectionHandler.class);
\r
77 noncopyables.add(el);
\r
78 es.add(ElementType.NonCopyable);
\r
79 // Don't count inherently non-copyables in "all" elements.
\r
81 } else if (mh != null) {
\r
83 es.add(ElementType.Monitor);
\r
84 } else if (re != null) {
\r
86 es.add(ElementType.Reference);
\r
87 } else if (fh != null) {
\r
89 es.add(ElementType.Flag);
\r
90 } else if (ch != null) {
\r
91 connections.add(el);
\r
92 es.add(ElementType.Connection);
\r
93 } else if (bp != null) {
\r
94 branchPoints.add(el);
\r
95 es.add(ElementType.BranchPoint);
\r
96 } else if (tt != null) {
\r
99 es.add(ElementType.Node);
\r
100 } else if (bh != null) {
\r
102 es.add(ElementType.Edge);
\r
105 es.add(ElementType.Other);
\r
110 public Set<IElement> getAll() {
\r
111 return new HashSet<IElement>(all);
\r
114 public boolean contains(ElementType et) {
\r
115 return contents.contains(et);
\r
118 public boolean contains(Collection<ElementType> ets) {
\r
119 return contents.containsAll(ets);
\r
122 public boolean containsAny(Collection<ElementType> ets) {
\r
123 for (ElementType et : ets)
\r
124 if (contents.contains(et))
\r
130 public int count(ElementType et) {
\r
132 case BranchPoint: return branchPoints.size();
\r
133 case Connection: return connections.size();
\r
134 case Edge: return edges.size();
\r
135 case Flag: return flags.size();
\r
136 case Monitor: return monitors.size();
\r
137 case Reference: return references.size();
\r
138 case Node: return nodes.size();
\r
139 case Other: return others.size();
\r
140 case NonCopyable: return noncopyables.size();
\r
145 boolean add(ElementType et) {
\r
146 return contents.add(et);
\r
149 boolean remove(ElementType et) {
\r
150 return contents.remove(et);
\r
153 private boolean addType(Set<IElement> set, IElement e, ElementType et) {
\r
155 boolean ret = set.add(e);
\r
163 private boolean removeType(Set<IElement> set, IElement e, ElementType et) {
\r
164 if (all.remove(e)) {
\r
165 boolean ret = set.remove(e);
\r
167 contents.remove(et);
\r
173 private int removeAllType(Set<IElement> set, Collection<IElement> es, ElementType et) {
\r
175 for (IElement e : es)
\r
176 if (removeType(set, e, et))
\r
181 private int clearType(Set<IElement> set, ElementType et) {
\r
182 int ret = set.size();
\r
183 all.removeAll(set);
\r
184 contents.remove(et);
\r
188 public int clear(ElementType et) {
\r
190 case BranchPoint: return clearType(branchPoints, et);
\r
191 case Connection: return clearType(connections, et);
\r
192 case Edge: return clearType(edges, et);
\r
193 case Flag: return clearType(flags, et);
\r
194 case Monitor: return clearType(monitors, et);
\r
195 case Reference: return clearType(references, et);
\r
196 case Node: return clearType(nodes, et);
\r
197 case Other: return clearType(others, et);
\r
198 case NonCopyable: return clearType(noncopyables, et);
\r
203 public boolean add(ElementType et, IElement e) {
\r
205 case BranchPoint: return addType(branchPoints, e, et);
\r
206 case Connection: return addType(connections, e, et);
\r
207 case Edge: return addType(edges, e, et);
\r
208 case Flag: return addType(flags, e, et);
\r
209 case Monitor: return addType(monitors, e, et);
\r
210 case Reference: return addType(references, e, et);
\r
211 case Node: return addType(nodes, e, et);
\r
212 case Other: return addType(others, e, et);
\r
213 case NonCopyable: return addType(noncopyables, e, et);
\r
214 default: return false;
\r
218 boolean remove(ElementType et, IElement e) {
\r
220 case BranchPoint: return removeType(branchPoints, e, et);
\r
221 case Connection: return removeType(connections, e, et);
\r
222 case Edge: return removeType(edges, e, et);
\r
223 case Flag: return removeType(flags, e, et);
\r
224 case Monitor: return removeType(monitors, e, et);
\r
225 case Reference: return removeType(references, e, et);
\r
226 case Node: return removeType(nodes, e, et);
\r
227 case Other: return removeType(others, e, et);
\r
228 case NonCopyable: return removeType(noncopyables, e, et);
\r
229 default: return false;
\r
233 public int removeAll(ElementType et, Collection<IElement> es) {
\r
237 case BranchPoint: return removeAllType(branchPoints, es, et);
\r
238 case Connection: return removeAllType(connections, es, et);
\r
239 case Edge: return removeAllType(edges, es, et);
\r
240 case Flag: return removeAllType(flags, es, et);
\r
241 case Monitor: return removeAllType(monitors, es, et);
\r
242 case Reference: return removeAllType(references, es, et);
\r
243 case Node: return removeAllType(nodes, es, et);
\r
244 case Other: return removeAllType(others, es, et);
\r
245 case NonCopyable: return removeAllType(noncopyables, es, et);
\r
251 public String toString() {
\r
252 StringBuilder b = new StringBuilder();
\r
253 b.append("ElementAssortment:\n");
\r
254 b.append("\t CONTAINS: ");
\r
255 b.append(contents);
\r
257 for(IElement e : nodes) b.append("\t-node " + e + "\n");
\r
258 for(IElement e : connections) b.append("\t-connection " + e + "\n");
\r
259 for(IElement e : edges) b.append("\t-edge " + e + "\n");
\r
260 for(IElement e : branchPoints) b.append("\t-branch " + e + "\n");
\r
261 for(IElement e : flags) b.append("\t-flag " + e + "\n");
\r
262 for(IElement e : references) b.append("\t-reference " + e + "\n");
\r
263 for(IElement e : monitors) b.append("\t-monitor " + e + "\n");
\r
264 for(IElement e : others) b.append("\t-other " + e + "\n");
\r
265 for(IElement e : noncopyables) b.append("\t-non-copyable " + e + "\n");
\r
266 return b.toString();
\r
269 public boolean isEmpty() {
\r
270 return all.isEmpty();
\r