bundles/org.simantics.db.common/src/org/simantics/db/common/utils/ListUtils.java

   1 package org.simantics.db.common.utils;\r
   2 \r
   3 import java.util.ArrayList;\r
   4 import java.util.List;\r
   5 import java.util.Set;\r
   6 \r
   7 import org.simantics.db.ReadGraph;\r
   8 import org.simantics.db.Resource;\r
   9 import org.simantics.db.WriteGraph;\r
  10 import org.simantics.db.WriteOnlyGraph;\r
  11 import org.simantics.db.exception.DatabaseException;\r
  12 import org.simantics.layer0.Layer0;\r
  13 \r
  14 public class ListUtils {\r
  15 \r
  16     /**\r
  17      * Inserts {@code elements} between list nodes \r
  18      * {@code before} and {@code after}.\r
  19      */\r
  20     private static void insertBetween(\r
  21             WriteGraph g, Layer0 L0, Resource list,\r
  22             Resource before, Resource after, \r
  23             Iterable<Resource> elements) throws DatabaseException {\r
  24         for(Resource item : elements) {\r
  25             Resource cur = g.newResource();\r
  26             g.claim(cur, L0.InstanceOf, null, L0.List_Entry);\r
  27             g.claim(cur, L0.IsOwnedBy, L0.IsComposedOf, list);\r
  28             g.claim(before, L0.List_Next, L0.List_Previous, cur);\r
  29             g.claim(cur, L0.List_Element, item);\r
  30             before = cur;\r
  31         }  \r
  32         g.claim(before, L0.List_Next, L0.List_Previous, after);\r
  33     }\r
  34 \r
  35     private static void insertBetween(\r
  36             WriteGraph g, Layer0 L0, Resource list, \r
  37             Resource before, Resource after, \r
  38             Resource[] elements) throws DatabaseException {\r
  39         for(Resource item : elements) {\r
  40             Resource cur = g.newResource();\r
  41             g.claim(cur, L0.InstanceOf, null, L0.List_Entry);\r
  42             g.claim(cur, L0.IsOwnedBy, L0.IsComposedOf, list);\r
  43             g.claim(before, L0.List_Next, L0.List_Previous, cur);\r
  44             g.claim(cur, L0.List_Element, item);\r
  45             before = cur;\r
  46         }  \r
  47         g.claim(before, L0.List_Next, L0.List_Previous, after);\r
  48     }\r
  49     \r
  50     /**\r
  51      * Creates a list containing the givens {@code elements}.\r
  52      */\r
  53     public static Resource create(WriteGraph g, Iterable<Resource> elements) throws DatabaseException {\r
  54         Layer0 L0 = Layer0.getInstance(g);\r
  55         \r
  56         Resource list = g.newResource();\r
  57         g.claim(list, L0.InstanceOf, L0.List);\r
  58         \r
  59         insertBetween(g, L0, list, list, list, elements);\r
  60         return list;\r
  61     }\r
  62 \r
  63     /**\r
  64      * Creates a list containing the givens {@code elements}.\r
  65      */\r
  66     public static Resource create(WriteGraph g, Resource type, Iterable<Resource> elements) throws DatabaseException {\r
  67         Layer0 L0 = Layer0.getInstance(g);\r
  68         \r
  69         Resource list = g.newResource();\r
  70         g.claim(list, L0.InstanceOf, null, type);\r
  71         \r
  72         insertBetween(g, L0, list, list, list, elements);\r
  73         return list;\r
  74     }\r
  75 \r
  76     public static Resource create(WriteGraph g, Resource type, Resource ... elements) throws DatabaseException {\r
  77         Layer0 L0 = Layer0.getInstance(g);\r
  78         \r
  79         Resource list = g.newResource();\r
  80         g.claim(list, L0.InstanceOf, null, type);\r
  81         \r
  82         insertBetween(g, L0, list, list, list, elements);\r
  83         return list;\r
  84     }\r
  85     \r
  86     /**\r
  87      * Inserts given {@code elements} into the front of the list.\r
  88      */\r
  89     public static void insertFront(WriteGraph g, Resource list, Iterable<Resource> elements) throws DatabaseException {\r
  90         if (!elements.iterator().hasNext())\r
  91             return;\r
  92         Layer0 L0 = Layer0.getInstance(g);\r
  93         \r
  94         Resource first = g.getSingleObject(list, L0.List_Next);        \r
  95         g.deny(list, L0.List_Next, L0.List_Previous, first);        \r
  96         insertBetween(g, L0, list, list, first, elements);\r
  97     }\r
  98     \r
  99     public static void createExisting(WriteOnlyGraph g, Resource list, Iterable<Resource> elements) throws DatabaseException {\r
 100     \r
 101         Layer0 L0 = g.getService(Layer0.class);\r
 102         Resource before = list;\r
 103         for(Resource item : elements) {\r
 104             Resource cur = g.newResource();\r
 105             g.claim(cur, L0.InstanceOf, null, L0.List_Entry);\r
 106             g.claim(cur, L0.IsOwnedBy, L0.IsComposedOf, list);\r
 107             g.claim(before, L0.List_Next, L0.List_Previous, cur);\r
 108             g.claim(cur, L0.List_Element, null, item);\r
 109             before = cur;\r
 110         }  \r
 111         g.claim(before, L0.List_Next, L0.List_Previous, list);\r
 112         \r
 113     }\r
 114     \r
 115     /**\r
 116      * Inserts given {@code elements} into the back of the list.\r
 117      */\r
 118     public static void insertBack(WriteGraph g, Resource list, Iterable<Resource> elements) throws DatabaseException {\r
 119         if (!elements.iterator().hasNext())\r
 120             return;\r
 121         Layer0 L0 = Layer0.getInstance(g);\r
 122         \r
 123         Resource last = g.getSingleObject(list, L0.List_Previous);        \r
 124         g.deny(last, L0.List_Next, L0.List_Previous, list);        \r
 125         insertBetween(g, L0, list, last, list, elements);\r
 126     }\r
 127     \r
 128     /**\r
 129      * Replaces a given element in the a given list\r
 130      * @param g WriteGraph\r
 131      * @param list List resource\r
 132      * @param element Element to be replaced\r
 133      * @param replacement Resource that replaces element\r
 134      * @return true if successful replacement, false otherwise\r
 135      * @throws DatabaseException\r
 136      */\r
 137     public static boolean replace(WriteGraph g, Resource list, Resource element, Resource replacement) throws DatabaseException {\r
 138         if(list == null || element == null || replacement == null)\r
 139             return false;\r
 140         \r
 141         Layer0 L0 = Layer0.getInstance(g);\r
 142 \r
 143         Resource node = getNode(g, list, element);\r
 144         if(node != null) {\r
 145             g.deny(node, L0.List_Element);\r
 146             g.claim(node, L0.List_Element, replacement);\r
 147             return true;\r
 148         } else {\r
 149             return false;\r
 150         }\r
 151     }\r
 152     \r
 153     private static void toList(ReadGraph g, List<Resource> result, Resource list) throws DatabaseException {\r
 154         \r
 155         Layer0 L0 = Layer0.getInstance(g);\r
 156         \r
 157         Resource cur = g.getSingleObject(list, L0.List_Next);\r
 158         while(!cur.equals(list)) {\r
 159             Resource el = g.getPossibleObject(cur, L0.List_Element);\r
 160             if(el != null)\r
 161                 result.add(el);\r
 162             cur = g.getSingleObject(cur, L0.List_Next);\r
 163         }\r
 164         \r
 165     }\r
 166     \r
 167     /**\r
 168      * Converts a list in the graph to a Java List.\r
 169      */\r
 170     public static List<Resource> toList(ReadGraph g, Resource list) throws DatabaseException {\r
 171         ArrayList<Resource> result = new ArrayList<Resource>();\r
 172         toList(g, result, list);\r
 173         return result;\r
 174     }\r
 175 \r
 176     public static List<Resource> toPossibleList(ReadGraph g, Resource list) throws DatabaseException {\r
 177         try {\r
 178                 return toList(g, list);\r
 179         } catch (DatabaseException e) {\r
 180                 return null;\r
 181         }\r
 182     }\r
 183 \r
 184     /**\r
 185      * Removes an element from a list. Returns true if actually removed something.\r
 186      */\r
 187     public static boolean removeElement(WriteGraph g, Resource list, Resource element) throws DatabaseException {\r
 188         Layer0 L0 = Layer0.getInstance(g);\r
 189         Resource prev = list;\r
 190         Resource cur = g.getSingleObject(list, L0.List_Next);\r
 191         while(!cur.equals(list)) {\r
 192             Resource el = g.getPossibleObject(cur, L0.List_Element);\r
 193             Resource next = g.getSingleObject(cur, L0.List_Next);\r
 194             if(element.equals(el)) {                \r
 195                 g.deny(cur);\r
 196                 g.claim(prev, L0.List_Next, next);\r
 197                 return true;\r
 198             }\r
 199             prev = cur;\r
 200             cur = next;\r
 201         }\r
 202         return false;\r
 203     }\r
 204     \r
 205     /**\r
 206      * Removes an elements from a list. Returns true if actually removed something.\r
 207      */\r
 208     public static boolean removeElements(WriteGraph g, Resource list, Set<Resource> elements) throws DatabaseException {\r
 209         Layer0 L0 = Layer0.getInstance(g);\r
 210         Resource prev = list;\r
 211         Resource cur = g.getSingleObject(list, L0.List_Next);\r
 212         boolean removed = false;\r
 213         while(!cur.equals(list)) {\r
 214             Resource el = g.getPossibleObject(cur, L0.List_Element);\r
 215             Resource next = g.getSingleObject(cur, L0.List_Next);\r
 216             if(elements.contains(el)) {                \r
 217                 g.deny(cur);\r
 218                 g.claim(prev, L0.List_Next, next);\r
 219                 removed = true;\r
 220             }\r
 221             else\r
 222                 prev = cur;\r
 223             cur = next;\r
 224         }\r
 225         return removed;\r
 226     }\r
 227     \r
 228     private static void getListNodes(ReadGraph g, List<Resource> result, Resource list) throws DatabaseException {\r
 229         \r
 230         Layer0 L0 = Layer0.getInstance(g);\r
 231         \r
 232         Resource cur = g.getSingleObject(list, L0.List_Next);\r
 233         while(!cur.equals(list)) {\r
 234             result.add(cur);\r
 235             cur = g.getSingleObject(cur, L0.List_Next);\r
 236         }\r
 237         \r
 238     }\r
 239     \r
 240     public static List<Resource> getListNodes(ReadGraph g, Resource list) throws DatabaseException {\r
 241         ArrayList<Resource> result = new ArrayList<Resource>();\r
 242         getListNodes(g, result, list);\r
 243         return result;\r
 244     }\r
 245     \r
 246     public static Resource getNode(ReadGraph g, Resource list, Resource element) throws DatabaseException {\r
 247         Layer0 L0 = Layer0.getInstance(g);\r
 248         \r
 249         Resource cur = g.getSingleObject(list, L0.List_Next);\r
 250         while(!cur.equals(list)) {\r
 251             Resource el = g.getPossibleObject(cur, L0.List_Element);\r
 252             if(element.equals(el))\r
 253                 return cur;\r
 254             cur = g.getSingleObject(cur, L0.List_Next);\r
 255         }\r
 256         return null;\r
 257     }     \r
 258     \r
 259     public static boolean swapWithPrevious(WriteGraph g, Resource list, Resource element) throws DatabaseException {\r
 260         Resource node = getNode(g, list, element);\r
 261         if(node == null)\r
 262             return false;\r
 263         Layer0 L0 = Layer0.getInstance(g);\r
 264         Resource prev = g.getSingleObject(node, L0.List_Previous);\r
 265         if(list.equals(prev))\r
 266             return false;\r
 267         swap(g, node, prev);\r
 268         return true;\r
 269     }\r
 270     \r
 271     public static boolean swapWithNext(WriteGraph g, Resource list, Resource element) throws DatabaseException {\r
 272         Resource node = getNode(g, list, element);\r
 273         if(node == null)\r
 274             return false;\r
 275         Layer0 L0 = Layer0.getInstance(g);\r
 276         Resource next = g.getSingleObject(node, L0.List_Next);\r
 277         if(list.equals(next))\r
 278             return false;\r
 279         swap(g, node, next);\r
 280         return true;\r
 281     }\r
 282 \r
 283     private static void swap(WriteGraph g, Resource a, Resource b) throws DatabaseException {\r
 284         Layer0 L0 = Layer0.getInstance(g);\r
 285         Resource ea = g.getPossibleObject(a, L0.List_Element);\r
 286         Resource eb = g.getPossibleObject(b, L0.List_Element);\r
 287         \r
 288         g.deny(a, L0.List_Element);\r
 289         g.deny(b, L0.List_Element);\r
 290         \r
 291         if(eb != null)\r
 292             g.claim(a, L0.List_Element, eb);\r
 293         if(ea != null)\r
 294             g.claim(b, L0.List_Element, ea);\r
 295     }\r
 296 \r
 297     \r
 298 }\r