bundles/org.simantics.diagram/src/org/simantics/diagram/handler/ElementAssortment.java

   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
   8  *\r
   9  * Contributors:\r
  10  *     VTT Technical Research Centre of Finland - initial API and implementation\r
  11  *******************************************************************************/\r
  12 package org.simantics.diagram.handler;\r
  13 \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
  20 \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
  31 \r
  32 /**\r
  33  * @author Tuukka Lehtonen\r
  34  */\r
  35 public class ElementAssortment implements IElementAssortment {\r
  36 \r
  37     public Set<IElement>        all;\r
  38 \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
  49 \r
  50     EnumSet<ElementType>        contents;\r
  51 \r
  52     /**\r
  53      * @param set all the elements to initially sort out. This object assumes\r
  54      *        ownership of the set.\r
  55      */\r
  56     public ElementAssortment(Set<IElement> set) {\r
  57         if (set == null)\r
  58             throw new IllegalArgumentException("null element set");\r
  59         this.all = new HashSet<IElement>(set);\r
  60         sort(set);\r
  61     }\r
  62 \r
  63     private void sort(Set<IElement> set) {\r
  64         EnumSet<ElementType> es = EnumSet.noneOf(ElementType.class);\r
  65         contents = es;\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
  76             if (nc != null) {\r
  77                 noncopyables.add(el);\r
  78                 es.add(ElementType.NonCopyable);\r
  79                 // Don't count inherently non-copyables in "all" elements.\r
  80                 all.remove(el);\r
  81             } else if (mh != null) {\r
  82                 monitors.add(el);\r
  83                 es.add(ElementType.Monitor);\r
  84             } else if (re != null) {\r
  85                 references.add(el);\r
  86                 es.add(ElementType.Reference);\r
  87             } else if (fh != null) {\r
  88                 flags.add(el);\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
  97                 nodes.add(el);\r
  98                 nodeList.add(el);\r
  99                 es.add(ElementType.Node);\r
 100             } else if (bh != null) {\r
 101                 edges.add(el);\r
 102                 es.add(ElementType.Edge);\r
 103             } else {\r
 104                 others.add(el);\r
 105                 es.add(ElementType.Other);\r
 106             }\r
 107         }\r
 108     }\r
 109 \r
 110     public Set<IElement> getAll() {\r
 111         return new HashSet<IElement>(all);\r
 112     }\r
 113 \r
 114     public boolean contains(ElementType et) {\r
 115         return contents.contains(et);\r
 116     }\r
 117 \r
 118     public boolean contains(Collection<ElementType> ets) {\r
 119         return contents.containsAll(ets);\r
 120     }\r
 121 \r
 122     public boolean containsAny(Collection<ElementType> ets) {\r
 123         for (ElementType et : ets)\r
 124             if (contents.contains(et))\r
 125                 return true;\r
 126         return false;\r
 127     }\r
 128 \r
 129     @Override\r
 130     public int count(ElementType et) {\r
 131         switch (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
 141             default: return 0;\r
 142         }\r
 143     }\r
 144 \r
 145     boolean add(ElementType et) {\r
 146         return contents.add(et);\r
 147     }\r
 148 \r
 149     boolean remove(ElementType et) {\r
 150         return contents.remove(et);\r
 151     }\r
 152 \r
 153     private boolean addType(Set<IElement> set, IElement e, ElementType et) {\r
 154         if (all.add(e)) {\r
 155             boolean ret = set.add(e);\r
 156             if (ret)\r
 157                 contents.add(et);\r
 158             return ret;\r
 159         }\r
 160         return false;\r
 161     }\r
 162 \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
 166             if (set.isEmpty())\r
 167                 contents.remove(et);\r
 168             return ret;\r
 169         }\r
 170         return false;\r
 171     }\r
 172 \r
 173     private int removeAllType(Set<IElement> set, Collection<IElement> es, ElementType et) {\r
 174         int result = 0;\r
 175         for (IElement e : es)\r
 176             if (removeType(set, e, et))\r
 177                 ++result;\r
 178         return result;\r
 179     }\r
 180 \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
 185         return ret;\r
 186     }\r
 187 \r
 188     public int clear(ElementType et) {\r
 189         switch (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
 199             default: return 0;\r
 200         }\r
 201     }\r
 202 \r
 203     public boolean add(ElementType et, IElement e) {\r
 204         switch (et) {\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
 215         }\r
 216     }\r
 217 \r
 218     boolean remove(ElementType et, IElement e) {\r
 219         switch (et) {\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
 230         }\r
 231     }\r
 232 \r
 233     public int removeAll(ElementType et, Collection<IElement> es) {\r
 234         if (es.isEmpty())\r
 235            return 0;\r
 236         switch (et) {\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
 246             default: return 0;\r
 247         }\r
 248     }\r
 249 \r
 250     @Override\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
 256         b.append("\n");\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
 267     }\r
 268 \r
 269     public boolean isEmpty() {\r
 270         return all.isEmpty();\r
 271     }\r
 272 \r
 273 }\r