bundles/org.simantics.db.procore/src/fi/vtt/simantics/procore/internal/CollectionSupportImpl.java

   1 package fi.vtt.simantics.procore.internal;\r
   2 \r
   3 import java.lang.reflect.Array;\r
   4 import java.util.ArrayList;\r
   5 import java.util.Collection;\r
   6 import java.util.Collections;\r
   7 import java.util.Comparator;\r
   8 import java.util.HashSet;\r
   9 import java.util.Iterator;\r
  10 import java.util.List;\r
  11 import java.util.ListIterator;\r
  12 import java.util.Map;\r
  13 import java.util.Set;\r
  14 \r
  15 import org.simantics.db.ReadGraph;\r
  16 import org.simantics.db.Resource;\r
  17 import org.simantics.db.Statement;\r
  18 import org.simantics.db.exception.ResourceNotFoundException;\r
  19 import org.simantics.db.impl.ResourceImpl;\r
  20 import org.simantics.db.impl.graph.ReadGraphImpl;\r
  21 import org.simantics.db.impl.query.IntSet;\r
  22 import org.simantics.db.service.CollectionSupport;\r
  23 import org.simantics.utils.datastructures.Callback;\r
  24 \r
  25 import gnu.trove.impl.Constants;\r
  26 import gnu.trove.iterator.TIntIterator;\r
  27 import gnu.trove.list.array.TIntArrayList;\r
  28 import gnu.trove.map.hash.TIntIntHashMap;\r
  29 import gnu.trove.map.hash.TIntObjectHashMap;\r
  30 import gnu.trove.map.hash.TObjectIntHashMap;\r
  31 import gnu.trove.procedure.TIntObjectProcedure;\r
  32 import gnu.trove.procedure.TIntProcedure;\r
  33 import gnu.trove.procedure.TObjectIntProcedure;\r
  34 import gnu.trove.procedure.TObjectProcedure;\r
  35 import gnu.trove.set.hash.TIntHashSet;\r
  36 \r
  37 public class CollectionSupportImpl implements CollectionSupport {\r
  38         \r
  39         final private SessionImplSocket session;\r
  40         \r
  41         CollectionSupportImpl(SessionImplSocket session) {\r
  42                 this.session = session;\r
  43         }\r
  44         \r
  45         static final class IntResourceMap {\r
  46         \r
  47                 final private SessionImplSocket session;\r
  48                 final private TIntIntHashMap backend = new TIntIntHashMap(Constants.DEFAULT_CAPACITY, Constants.DEFAULT_LOAD_FACTOR, -1, 0);\r
  49                 \r
  50                 IntResourceMap(SessionImplSocket session) {\r
  51                         this.session = session;\r
  52                 }\r
  53                 \r
  54                 public int size() {\r
  55                         return backend.size();\r
  56                 }\r
  57                 \r
  58                 public boolean isEmpty() {\r
  59                         return backend.isEmpty();\r
  60                 }\r
  61                 \r
  62                 public boolean containsKey(int key) {\r
  63                         return backend.containsKey(key);\r
  64                 }\r
  65                 \r
  66                 public boolean containsValue(int value) {\r
  67                         return backend.containsValue(value);\r
  68                 }\r
  69                 \r
  70                 public Resource get(int key) {\r
  71                         try {\r
  72                                 return session.getResourceByKey(backend.get(key));\r
  73                         } catch (ResourceNotFoundException e) {\r
  74                                 e.printStackTrace();\r
  75                         }\r
  76                         return null;\r
  77                 }\r
  78                 \r
  79                 public Resource put(int key, Resource value) {\r
  80                         ResourceImpl impl = (ResourceImpl) value;\r
  81                         int i = backend.put(key, impl.id);\r
  82                         if (i == 0)\r
  83                                 return null;\r
  84                         else\r
  85                                 try {\r
  86                                         return session.getResourceByKey(i);\r
  87                                 } catch (ResourceNotFoundException e) {\r
  88                                         e.printStackTrace();\r
  89                                 }\r
  90                         return null;\r
  91                 }\r
  92                 \r
  93                 public Resource remove(int key) {\r
  94                         throw new UnsupportedOperationException("remove not supported");\r
  95                 }\r
  96 \r
  97                 @Override\r
  98                 public int hashCode() {\r
  99                         return backend.hashCode();\r
 100                 }\r
 101 \r
 102                 @Override\r
 103                 public boolean equals(Object obj) {\r
 104                         if (this == obj)\r
 105                                 return true;\r
 106                         if (obj == null)\r
 107                                 return false;\r
 108                         if (getClass() != obj.getClass())\r
 109                                 return false;\r
 110                         IntResourceMap other = (IntResourceMap) obj;\r
 111                         return session == other.session && backend.equals(other.backend);\r
 112                 }\r
 113         }\r
 114         \r
 115         public IntResourceMap createIntResourceMap() {\r
 116                 return new IntResourceMap(session);\r
 117         }\r
 118 \r
 119         static final class ObjectResourceMap<T> implements Map<T, Resource> {\r
 120                 \r
 121                 final private SessionImplSocket session;\r
 122                 final private TObjectIntHashMap<T> backend;\r
 123                 \r
 124                 ObjectResourceMap(SessionImplSocket session) {\r
 125                         this.session = session;\r
 126                         backend = new TObjectIntHashMap<T>(Constants.DEFAULT_CAPACITY, Constants.DEFAULT_LOAD_FACTOR, 0);\r
 127                 }\r
 128 \r
 129                 ObjectResourceMap(SessionImplSocket session, int capacity) {\r
 130                         this.session = session;\r
 131                         backend = new TObjectIntHashMap<T>(capacity, Constants.DEFAULT_LOAD_FACTOR, 0);\r
 132                 }\r
 133                 \r
 134                 @Override\r
 135                 public int size() {\r
 136                         return backend.size();\r
 137                 }\r
 138                 @Override\r
 139                 public boolean isEmpty() {\r
 140                         return backend.isEmpty();\r
 141                 }\r
 142                 \r
 143                 @Override\r
 144                 public boolean containsKey(Object key) {\r
 145                         return backend.contains(key);\r
 146                 }\r
 147                 \r
 148                 @Override\r
 149                 public boolean containsValue(Object value) {\r
 150                         ResourceImpl impl = (ResourceImpl) value;\r
 151                         return backend.containsValue(impl.id);\r
 152                 }\r
 153                 \r
 154                 @Override\r
 155                 public Resource get(Object key) {\r
 156                         try {\r
 157                                 int result = backend.get(key);\r
 158                                 if (result == 0)\r
 159                                         return null;\r
 160                                 return session.getResourceByKey(result);\r
 161                         } catch (ResourceNotFoundException e) {\r
 162                                 e.printStackTrace();\r
 163                         }\r
 164                         return null;\r
 165                 }\r
 166                 \r
 167                 @Override\r
 168                 public Resource put(T key, Resource value) {\r
 169                         ResourceImpl impl = (ResourceImpl) value;\r
 170                         int i = backend.put(key, impl.id);\r
 171                         if (i == 0)\r
 172                                 return null;\r
 173                         else\r
 174                                 try {\r
 175                                         return session.getResourceByKey(i);\r
 176                                 } catch (ResourceNotFoundException e) {\r
 177                                         e.printStackTrace();\r
 178                                 }\r
 179                         return null;\r
 180                 }\r
 181                 \r
 182                 @Override\r
 183                 public Resource remove(Object key) {\r
 184                         throw new UnsupportedOperationException("remove not supported, structure is immutable");\r
 185                 }\r
 186                 \r
 187                 @Override\r
 188                 public void putAll(Map<? extends T, ? extends Resource> map) {\r
 189                         @SuppressWarnings("unchecked")\r
 190                         ObjectResourceMap<T> other = (ObjectResourceMap<T>) map;\r
 191                         other.backend.forEachEntry(new TObjectIntProcedure<T>() {\r
 192 \r
 193                                 @Override\r
 194                                 public boolean execute(T a, int b) {\r
 195                                         backend.put(a, b);\r
 196                                         return true;\r
 197                                 }\r
 198                         });\r
 199                 }\r
 200                 \r
 201                 @Override\r
 202                 public void clear() {\r
 203                         throw new UnsupportedOperationException("clear not supported, structure is immutable");\r
 204                 }\r
 205                 \r
 206                 @Override\r
 207                 public Set<T> keySet() {\r
 208                         final Set<T> result = new HashSet<T>();\r
 209                         backend.forEach(new TObjectProcedure<T>() {\r
 210 \r
 211                                 @Override\r
 212                                 public boolean execute(T object) {\r
 213                                         result.add(object);\r
 214                                         return true;\r
 215                                 }\r
 216                         });\r
 217                         return result;\r
 218                 }\r
 219                 \r
 220                 @Override\r
 221                 public Collection<Resource> values() {\r
 222                         ArrayList<Resource> result = new ArrayList<Resource>();\r
 223                         for (int key : backend.values()) {\r
 224                                 try {\r
 225                                         result.add(session.getResourceByKey(key));\r
 226                                 } catch (ResourceNotFoundException e) {\r
 227                                         e.printStackTrace();\r
 228                                 }\r
 229                         }\r
 230                         return result;\r
 231                 }\r
 232                 \r
 233                 @Override\r
 234                 public Set<java.util.Map.Entry<T, Resource>> entrySet() {\r
 235                         final HashSet<java.util.Map.Entry<T, Resource>> result = new HashSet<java.util.Map.Entry<T, Resource>>();\r
 236                         backend.forEachEntry(new TObjectIntProcedure<T>() {\r
 237 \r
 238                                 @Override\r
 239                                 public boolean execute(final T a, final int b) {\r
 240                                         return result.add(new Map.Entry<T, Resource>() {\r
 241 \r
 242                                                 @Override\r
 243                                                 public T getKey() {\r
 244                                                         return a;\r
 245                                                 }\r
 246 \r
 247                                                 @Override\r
 248                                                 public Resource getValue() {\r
 249                                                         return new ResourceImpl(session.resourceSupport, b);\r
 250                                                 }\r
 251 \r
 252                                                 @Override\r
 253                                                 public Resource setValue(Resource value) {\r
 254                                                         throw new UnsupportedOperationException("Map.Entry.setValue not supported, structure is immutable");\r
 255                                                 }\r
 256                                                 \r
 257                                         });\r
 258                                 }\r
 259                         });\r
 260                         return result;\r
 261                 }\r
 262 \r
 263                 @Override\r
 264                 public int hashCode() {\r
 265                         return backend.hashCode();\r
 266                 }\r
 267 \r
 268                 @Override\r
 269                 public boolean equals(Object obj) {\r
 270                         if (this == obj)\r
 271                                 return true;\r
 272                         if (obj == null)\r
 273                                 return false;\r
 274                         if (getClass() != obj.getClass())\r
 275                                 return false;\r
 276                         ObjectResourceMap<?> other = (ObjectResourceMap<?>) obj;\r
 277                         return session == other.session && backend.equals(other.backend);\r
 278                 }\r
 279 \r
 280         }\r
 281         \r
 282         @SuppressWarnings("unchecked")\r
 283         @Override\r
 284         public <T, I> T createObjectResourceMap(Class<I> clazz) {\r
 285                 return (T)new ObjectResourceMap<I>(session);\r
 286         }\r
 287 \r
 288         @SuppressWarnings("unchecked")\r
 289         @Override\r
 290         public <T, I> T createObjectResourceMap(Class<I> clazz, int capacity) {\r
 291                 return (T)new ObjectResourceMap<I>(session, capacity);\r
 292         }\r
 293 \r
 294     static final class ResourceMap<T> implements org.simantics.db.ResourceMap<T> {\r
 295         \r
 296         final private SessionImplSocket session;\r
 297         final private TIntObjectHashMap<T> backend = new TIntObjectHashMap<T>();\r
 298 \r
 299         ResourceMap(SessionImplSocket session) {\r
 300                 this.session = session;\r
 301         }\r
 302         \r
 303                 @Override\r
 304                 public void clear() {\r
 305                         throw new UnsupportedOperationException("Not implemented");\r
 306                 }\r
 307 \r
 308                 @Override\r
 309                 public boolean containsKey(Object resource) {\r
 310                         ResourceImpl impl = (ResourceImpl)resource;\r
 311                         return backend.containsKey(impl.id);\r
 312                 }\r
 313 \r
 314                 @SuppressWarnings("unchecked")\r
 315                 @Override\r
 316                 public boolean containsValue(Object value) {\r
 317                         return backend.containsValue((T)value);\r
 318                 }\r
 319 \r
 320                 @Override\r
 321                 public Set<java.util.Map.Entry<Resource, T>> entrySet() {\r
 322                         final HashSet<java.util.Map.Entry<Resource, T>> result = new HashSet<java.util.Map.Entry<Resource, T>>();\r
 323                         backend.forEachEntry(new TIntObjectProcedure<T>() {\r
 324 \r
 325                                 @Override\r
 326                                 public boolean execute(final int a, final T b) {\r
 327                                         result.add(new Map.Entry<Resource, T>() {\r
 328 \r
 329                                                 @Override\r
 330                                                 public Resource getKey() {\r
 331                                                         return new ResourceImpl(session.resourceSupport, a);\r
 332                                                 }\r
 333 \r
 334                                                 @Override\r
 335                                                 public T getValue() {\r
 336                                                         return b;\r
 337                                                 }\r
 338 \r
 339                                                 @Override\r
 340                                                 public T setValue(T arg0) {\r
 341                                                         throw new UnsupportedOperationException("Not supported");\r
 342                                                 }\r
 343                                                 \r
 344                                         });\r
 345                                         return true;\r
 346                                 }\r
 347                                 \r
 348                         });\r
 349                         return result;\r
 350                 }\r
 351 \r
 352                 @Override\r
 353                 public T get(Object resource) {\r
 354                         ResourceImpl impl = (ResourceImpl)resource;\r
 355                         return backend.get(impl.id);\r
 356                 }\r
 357 \r
 358                 @Override\r
 359                 public boolean isEmpty() {\r
 360                         return backend.isEmpty();\r
 361                 }\r
 362 \r
 363                 public class CallbackEntry<E> implements ResourceMapEntry<E> {\r
 364                         \r
 365                         int id;\r
 366                         E value;\r
 367                         \r
 368                         @Override\r
 369                         public Resource getKey() {\r
 370                                 return new ResourceImpl(session.resourceSupport, id);\r
 371                         }\r
 372 \r
 373                         @Override\r
 374                         public E getValue() {\r
 375                                 return value;\r
 376                         }\r
 377                         \r
 378                 }\r
 379                 \r
 380                 @Override\r
 381                 public void iterateEntries(final Callback<ResourceMapEntry<T>> callback) {\r
 382                         final CallbackEntry<T> entry = new CallbackEntry<T>();\r
 383                         backend.forEach(new TIntProcedure() {\r
 384                                 \r
 385                                 @Override\r
 386                                 public boolean execute(int value) {\r
 387                                         entry.id = value;\r
 388                                         entry.value = backend.get(value);\r
 389                                         callback.run(entry);\r
 390                                         return true;\r
 391                                 }\r
 392                         });\r
 393                 }\r
 394                 \r
 395                 @Override\r
 396                 public Set<Resource> keySet() {\r
 397                         final ResourceSet result = new ResourceSet(session);\r
 398                         backend.forEach(new TIntProcedure() {\r
 399                                 \r
 400                                 @Override\r
 401                                 public boolean execute(int value) {\r
 402                                         result.add(value);\r
 403                                         return true;\r
 404                                 }\r
 405                         });\r
 406                         return result;\r
 407                 }\r
 408 \r
 409                 @Override\r
 410                 public T put(Resource resource, T value) {\r
 411                         ResourceImpl impl = (ResourceImpl)resource;\r
 412                         return backend.put(impl.id, value);\r
 413                 }\r
 414 \r
 415                 @Override\r
 416                 public void putAll(Map<? extends Resource, ? extends T> map) {\r
 417                         @SuppressWarnings("unchecked")\r
 418                         ResourceMap<T> other = (ResourceMap<T>)map;\r
 419                         other.backend.forEachEntry(new TIntObjectProcedure<T>() {\r
 420 \r
 421                                 @Override\r
 422                                 public boolean execute(int a, T b) {\r
 423                                         backend.put(a, b);\r
 424                                         return true;\r
 425                                 }\r
 426                                 \r
 427                         });\r
 428                 }\r
 429 \r
 430                 @Override\r
 431                 public T remove(Object arg0) {\r
 432                         throw new UnsupportedOperationException("Not implemented");\r
 433                 }\r
 434 \r
 435                 @Override\r
 436                 public int size() {\r
 437                         return backend.size();\r
 438                 }\r
 439 \r
 440                 @SuppressWarnings("unchecked")\r
 441                 @Override\r
 442                 public Collection<T> values() {\r
 443                         ArrayList<T> result = new ArrayList<T>();\r
 444                         for(Object o : backend.values()) result.add((T)o);\r
 445                         return result;\r
 446                 }\r
 447 \r
 448                 @Override\r
 449                 public int hashCode() {\r
 450                         return backend.hashCode();\r
 451                 }\r
 452 \r
 453                 @Override\r
 454                 public boolean equals(Object obj) {\r
 455                         if (this == obj)\r
 456                                 return true;\r
 457                         if (obj == null)\r
 458                                 return false;\r
 459                         if (getClass() != obj.getClass())\r
 460                                 return false;\r
 461                         ResourceMap<?> other = (ResourceMap<?>) obj;\r
 462                         return session == other.session && backend.equals(other.backend);\r
 463                 }\r
 464         \r
 465     }\r
 466     \r
 467         @SuppressWarnings("unchecked")\r
 468         @Override\r
 469         public <T, I> T createMap(Class<I> clazz) {\r
 470                 return (T)new ResourceMap<I>(session);\r
 471         }\r
 472 \r
 473     static final class ResourceSet implements Set<Resource> {\r
 474         \r
 475         final private SessionImplSocket session;\r
 476         final private TIntHashSet backend;\r
 477 \r
 478         ResourceSet(SessionImplSocket session) {\r
 479                 this.session = session;\r
 480                 backend = new TIntHashSet();\r
 481         }\r
 482         \r
 483         ResourceSet(SessionImplSocket session, int capacity) {\r
 484                 this.session = session;\r
 485                 backend = new TIntHashSet(capacity);\r
 486         }\r
 487 \r
 488         @Override\r
 489                 public void clear() {\r
 490                         backend.clear();\r
 491                 }\r
 492 \r
 493                 @Override\r
 494                 public int size() {\r
 495                         return backend.size();\r
 496                 }\r
 497 \r
 498                 @Override\r
 499                 public boolean add(Resource resource) {\r
 500                         ResourceImpl impl = (ResourceImpl)resource;\r
 501                         return backend.add(impl.id);\r
 502                 }\r
 503                 \r
 504                 boolean add(int id) {\r
 505                         return backend.add(id);\r
 506                 }\r
 507 \r
 508                 @Override\r
 509                 public boolean addAll(Collection<? extends Resource> rs) {\r
 510                         boolean result = true;\r
 511                         for(Resource r : rs) result &= add(r);\r
 512                         return result;\r
 513                 }\r
 514 \r
 515                 @Override\r
 516                 public boolean contains(Object resource) {\r
 517                         ResourceImpl impl = (ResourceImpl)resource;\r
 518                         return backend.contains(impl.id);\r
 519                 }\r
 520 \r
 521                 @Override\r
 522                 public boolean containsAll(Collection<?> rs) {\r
 523                         boolean result = true;\r
 524                         for(Object r : rs) result &= contains(r);\r
 525                         return result;\r
 526                 }\r
 527 \r
 528                 @Override\r
 529                 public boolean isEmpty() {\r
 530                         return backend.isEmpty();\r
 531                 }\r
 532 \r
 533                 @Override\r
 534                 public Iterator<Resource> iterator() {\r
 535                         return new Iterator<Resource>() {\r
 536 \r
 537                                 TIntIterator it = backend.iterator();\r
 538                                 \r
 539                                 @Override\r
 540                                 public boolean hasNext() {\r
 541                                         return it.hasNext();\r
 542                                 }\r
 543 \r
 544                                 @Override\r
 545                                 public Resource next() {\r
 546                                         return new ResourceImpl(session.resourceSupport, it.next());\r
 547                                 }\r
 548 \r
 549                                 @Override\r
 550                                 public void remove() {\r
 551                                         it.remove();\r
 552                                 }\r
 553                                 \r
 554                         };\r
 555                 }\r
 556 \r
 557                 @Override\r
 558                 public boolean remove(Object resource) {\r
 559                         ResourceImpl impl = (ResourceImpl)resource;\r
 560                         return backend.remove(impl.id);\r
 561                 }\r
 562 \r
 563                 @Override\r
 564                 public boolean removeAll(Collection<?> rs) {\r
 565                         boolean result = true;\r
 566                         for(Object r : rs) result &= remove(r);\r
 567                         return result;\r
 568                 }\r
 569 \r
 570                 @Override\r
 571                 public boolean retainAll(Collection<?> arg0) {\r
 572                         throw new UnsupportedOperationException("Not implemented");\r
 573                 }\r
 574 \r
 575                 @Override\r
 576                 public Object[] toArray() {\r
 577                         throw new UnsupportedOperationException("Not implemented");\r
 578                 }\r
 579 \r
 580                 @SuppressWarnings("unchecked")\r
 581                 @Override\r
 582                 public <T> T[] toArray(T[] arg0) {\r
 583                         final T[] result = (T[])Array.newInstance(arg0.getClass().getComponentType(), backend.size());\r
 584                         backend.forEach(new TIntProcedure() {\r
 585                                 \r
 586                                 int index = 0;\r
 587                                 \r
 588                                 @Override\r
 589                                 public boolean execute(int value) {\r
 590                                         result[index++] = (T)new ResourceImpl(session.resourceSupport, value);\r
 591                                         return true;\r
 592                                 }\r
 593                         });\r
 594                         return result;\r
 595                 }\r
 596 \r
 597                 @Override\r
 598                 public int hashCode() {\r
 599                         return backend.hashCode();\r
 600                 }\r
 601 \r
 602                 @Override\r
 603                 public boolean equals(Object obj) {\r
 604                         if (this == obj)\r
 605                                 return true;\r
 606                         if (obj == null)\r
 607                                 return false;\r
 608                         if (getClass() != obj.getClass())\r
 609                                 return false;\r
 610                         ResourceSet other = (ResourceSet) obj;\r
 611                         return session == other.session && backend.equals(other.backend);\r
 612                 }\r
 613         \r
 614     }\r
 615         \r
 616         @Override\r
 617         public Set<Resource> createSet() {\r
 618                 return new ResourceSet(session);\r
 619         }\r
 620         \r
 621         @Override\r
 622         public Set<Resource> createSet(int capacity) {\r
 623                 return new ResourceSet(session, capacity);\r
 624         }\r
 625 \r
 626         static final class ResourceList implements List<Resource> {\r
 627         \r
 628         final private SessionImplSocket session;\r
 629         final private TIntArrayList backend;\r
 630 \r
 631         ResourceList(SessionImplSocket session) {\r
 632                 this.session = session;\r
 633                 this.backend = new TIntArrayList();\r
 634         }\r
 635 \r
 636         ResourceList(SessionImplSocket session, Collection<Resource> rs) {\r
 637                 this.session = session;\r
 638                 this.backend = new TIntArrayList(rs.size());\r
 639                 addAll(rs);\r
 640         }\r
 641 \r
 642                 @Override\r
 643                 public void clear() {\r
 644                         throw new UnsupportedOperationException("Not implemented");\r
 645                 }\r
 646 \r
 647                 @Override\r
 648                 public int size() {\r
 649                         return backend.size();\r
 650                 }\r
 651 \r
 652                 @Override\r
 653                 public boolean add(Resource resource) {\r
 654                         if(resource == null) {\r
 655                                 backend.add(0);\r
 656                         } else {\r
 657                                 ResourceImpl impl = (ResourceImpl)resource;\r
 658                                 backend.add(impl.id);\r
 659                         }\r
 660                         return true;\r
 661                 }\r
 662 \r
 663                 @Override\r
 664                 public boolean addAll(Collection<? extends Resource> rs) {\r
 665                         if(rs instanceof ResourceList) {\r
 666                                 ResourceList rl = (ResourceList)rs;\r
 667                                 backend.addAll(rl.backend);\r
 668                                 return !rl.isEmpty();\r
 669                         }\r
 670                         boolean result = true;\r
 671                         for(Resource r : rs) result &= add(r);\r
 672                         return result;\r
 673                 }\r
 674 \r
 675                 @Override\r
 676                 public boolean contains(Object resource) {\r
 677                         ResourceImpl impl = (ResourceImpl)resource;\r
 678                         return backend.contains(impl.id);\r
 679                 }\r
 680 \r
 681                 @Override\r
 682                 public boolean containsAll(Collection<?> rs) {\r
 683                         boolean result = true;\r
 684                         for(Object r : rs) result &= contains(r);\r
 685                         return result;\r
 686                 }\r
 687 \r
 688                 @Override\r
 689                 public boolean isEmpty() {\r
 690                         return backend.isEmpty();\r
 691                 }\r
 692 \r
 693                 @Override\r
 694                 public Iterator<Resource> iterator() {\r
 695                         return new Iterator<Resource>() {\r
 696                                 \r
 697                                 int index = backend.size();\r
 698                                 \r
 699                                 @Override\r
 700                                 public boolean hasNext() {\r
 701                                         return index > 0; \r
 702                                 }\r
 703 \r
 704                                 @Override\r
 705                                 public Resource next() {\r
 706                                         return new ResourceImpl(session.resourceSupport, backend.getQuick(--index));\r
 707                                 }\r
 708 \r
 709                                 @Override\r
 710                                 public void remove() {\r
 711                                         throw new UnsupportedOperationException("Not supported");\r
 712                                 }\r
 713                                 \r
 714                         };\r
 715                 }\r
 716 \r
 717                 @Override\r
 718                 public boolean remove(Object resource) {\r
 719                         if(!(resource instanceof ResourceImpl)) return false;\r
 720                         ResourceImpl impl = (ResourceImpl)resource;\r
 721                         return backend.remove(impl.id);\r
 722                 }\r
 723 \r
 724                 @Override\r
 725                 public boolean removeAll(Collection<?> rs) {\r
 726                         boolean modified = false;\r
 727                         for(Object o : rs)\r
 728                                 modified |= remove(o);\r
 729                         return modified;\r
 730                 }\r
 731 \r
 732                 @Override\r
 733                 public boolean retainAll(Collection<?> arg0) {\r
 734                         throw new UnsupportedOperationException("Not implemented");\r
 735                 }\r
 736 \r
 737                 @Override\r
 738                 public Object[] toArray() {\r
 739                         return toArray(new Object[backend.size()]);\r
 740                 }\r
 741 \r
 742                 @SuppressWarnings("unchecked")\r
 743                 @Override\r
 744                 public <T> T[] toArray(T[] arg0) {\r
 745                         final T[] result = (T[])Array.newInstance(arg0.getClass().getComponentType(), backend.size());\r
 746                         backend.forEach(new TIntProcedure() {\r
 747                                 \r
 748                                 int index = 0;\r
 749                                 \r
 750                                 @Override\r
 751                                 public boolean execute(int value) {\r
 752                                         result[index++] = (T)new ResourceImpl(session.resourceSupport, value);\r
 753                                         return true;\r
 754                                 }\r
 755                         });\r
 756                         return result;\r
 757                 }\r
 758                 \r
 759                 void sort() {\r
 760                         backend.sort();\r
 761                 }\r
 762 \r
 763                 @Override\r
 764                 public boolean addAll(int index, Collection<? extends Resource> rs) {\r
 765                         if(rs.isEmpty()) return false;\r
 766                         int i = index;\r
 767                         for(Resource r : rs) {\r
 768                                 add(i++, r);\r
 769                         }\r
 770                         return true;\r
 771                 }\r
 772 \r
 773                 @Override\r
 774                 public Resource get(int index) {\r
 775                         int id = backend.get(index);\r
 776                         if(id == 0) return null;\r
 777                         return new ResourceImpl(session.resourceSupport, id);\r
 778                 }\r
 779 \r
 780                 @Override\r
 781                 public Resource set(int index, Resource resource) {\r
 782                         ResourceImpl impl = (ResourceImpl)resource;\r
 783                         int old = backend.set(index, impl.id);\r
 784                         if(old == 0) return null;\r
 785                         return new ResourceImpl(session.resourceSupport, old);\r
 786                 }\r
 787 \r
 788                 @Override\r
 789                 public void add(int index, Resource resource) {\r
 790                         ResourceImpl impl = (ResourceImpl)resource;\r
 791                         backend.insert(index, impl.id);\r
 792                 }\r
 793 \r
 794                 @Override\r
 795                 public Resource remove(int index) {\r
 796                         int id = backend.removeAt(index);\r
 797                         return new ResourceImpl(session.resourceSupport, id);\r
 798                 }\r
 799 \r
 800                 @Override\r
 801                 public int indexOf(Object o) {\r
 802                         if(!(o instanceof ResourceImpl)) return -1;\r
 803                         ResourceImpl impl = (ResourceImpl)o;\r
 804                         return backend.indexOf(impl.id);\r
 805                 }\r
 806 \r
 807                 @Override\r
 808                 public int lastIndexOf(Object o) {\r
 809                         if(!(o instanceof ResourceImpl)) return -1;\r
 810                         ResourceImpl impl = (ResourceImpl)o;\r
 811                         return backend.lastIndexOf(impl.id);\r
 812                 }\r
 813 \r
 814                 @Override\r
 815                 public ListIterator<Resource> listIterator() {\r
 816                         throw new UnsupportedOperationException("Not implemented");\r
 817                 }\r
 818 \r
 819                 @Override\r
 820                 public ListIterator<Resource> listIterator(int index) {\r
 821                         throw new UnsupportedOperationException("Not implemented");\r
 822                 }\r
 823 \r
 824                 @Override\r
 825                 public List<Resource> subList(int fromIndex, int toIndex) {\r
 826                         ResourceList result = new ResourceList(session);\r
 827                         for(int i=fromIndex;i<toIndex;i++)\r
 828                                 result.add(get(i));\r
 829                         return result;\r
 830                 }\r
 831 \r
 832                 @Override\r
 833                 public int hashCode() {\r
 834                         return backend.hashCode();\r
 835                 }\r
 836 \r
 837                 @Override\r
 838                 public boolean equals(Object obj) {\r
 839                         if (this == obj)\r
 840                                 return true;\r
 841                         if (obj == null)\r
 842                                 return false;\r
 843                         if (getClass() != obj.getClass())\r
 844                                 return false;\r
 845                         ResourceList other = (ResourceList) obj;\r
 846                         return session == other.session && backend.equals(other.backend);\r
 847                 }\r
 848 \r
 849     }\r
 850 \r
 851         @Override\r
 852         public List<Resource> createList() {\r
 853                 return new ResourceList(session);\r
 854         }\r
 855 \r
 856     static final class StatementList implements Collection<Statement> {\r
 857         \r
 858         final private SessionImplSocket session;\r
 859         final private TIntArrayList backend = new TIntArrayList();\r
 860 \r
 861         StatementList(SessionImplSocket session) {\r
 862                 this.session = session;\r
 863         }\r
 864         \r
 865                 @Override\r
 866                 public void clear() {\r
 867                         throw new UnsupportedOperationException("Not implemented");\r
 868                 }\r
 869 \r
 870                 @Override\r
 871                 public int size() {\r
 872                         return backend.size() / 3;\r
 873                 }\r
 874 \r
 875                 @Override\r
 876                 public boolean add(Statement stm) {\r
 877                         ResourceImpl s = (ResourceImpl)stm.getSubject();\r
 878                         ResourceImpl p = (ResourceImpl)stm.getPredicate();\r
 879                         ResourceImpl o = (ResourceImpl)stm.getObject();\r
 880                         backend.add(s.id);\r
 881                         backend.add(p.id);\r
 882                         backend.add(o.id);\r
 883                         return true;\r
 884                 }\r
 885 \r
 886                 @Override\r
 887                 public boolean addAll(Collection<? extends Statement> rs) {\r
 888                         boolean result = true;\r
 889                         for(Statement r : rs) result &= add(r);\r
 890                         return result;\r
 891                 }\r
 892 \r
 893                 @Override\r
 894                 public boolean contains(Object statement) {\r
 895                         throw new UnsupportedOperationException("Not implemented");\r
 896                 }\r
 897 \r
 898                 @Override\r
 899                 public boolean containsAll(Collection<?> rs) {\r
 900                         throw new UnsupportedOperationException("Not implemented");\r
 901                 }\r
 902 \r
 903                 @Override\r
 904                 public boolean isEmpty() {\r
 905                         return backend.isEmpty();\r
 906                 }\r
 907 \r
 908                 @Override\r
 909                 public Iterator<Statement> iterator() {\r
 910                         return new Iterator<Statement>() {\r
 911 \r
 912                                 int index = 0;\r
 913                                 int max = backend.size();\r
 914                                 \r
 915                                 @Override\r
 916                                 public boolean hasNext() {\r
 917                                         return index < max; \r
 918                                 }\r
 919 \r
 920                                 @Override\r
 921                                 public Statement next() {\r
 922                                         return new DirectStatementImpl(session.resourceSupport, backend.getQuick(index++), backend.getQuick(index++), backend.getQuick(index++));\r
 923                                 }\r
 924 \r
 925                                 @Override\r
 926                                 public void remove() {\r
 927                                         throw new UnsupportedOperationException("Not supported");\r
 928                                 }\r
 929                                 \r
 930                         };\r
 931                 }\r
 932 \r
 933                 @Override\r
 934                 public boolean remove(Object resource) {\r
 935                         throw new UnsupportedOperationException("Not implemented");\r
 936                 }\r
 937 \r
 938                 @Override\r
 939                 public boolean removeAll(Collection<?> rs) {\r
 940                         throw new UnsupportedOperationException("Not implemented");\r
 941                 }\r
 942 \r
 943                 @Override\r
 944                 public boolean retainAll(Collection<?> arg0) {\r
 945                         throw new UnsupportedOperationException("Not implemented");\r
 946                 }\r
 947 \r
 948                 @Override\r
 949                 public Object[] toArray() {\r
 950                         throw new UnsupportedOperationException("Not implemented");\r
 951                 }\r
 952 \r
 953                 @SuppressWarnings("unchecked")\r
 954                 @Override\r
 955                 public <T> T[] toArray(T[] arg0) {\r
 956                         final T[] result = (T[])Array.newInstance(arg0.getClass().getComponentType(), backend.size());\r
 957                         backend.forEach(new TIntProcedure() {\r
 958                                 \r
 959                                 int index = 0;\r
 960                                 \r
 961                                 @Override\r
 962                                 public boolean execute(int value) {\r
 963                                         result[index++] = (T)new ResourceImpl(session.resourceSupport, value);\r
 964                                         return true;\r
 965                                 }\r
 966                         });\r
 967                         return result;\r
 968                 }\r
 969 \r
 970                 @Override\r
 971                 public int hashCode() {\r
 972                         return backend.hashCode();\r
 973                 }\r
 974 \r
 975                 @Override\r
 976                 public boolean equals(Object obj) {\r
 977                         if (this == obj)\r
 978                                 return true;\r
 979                         if (obj == null)\r
 980                                 return false;\r
 981                         if (getClass() != obj.getClass())\r
 982                                 return false;\r
 983                         StatementList other = (StatementList) obj;\r
 984                         return session == other.session && backend.equals(other.backend);\r
 985                 }\r
 986         \r
 987     }\r
 988 \r
 989         @Override\r
 990         public Collection<Statement> createStatementList() {\r
 991                 return new StatementList(session);\r
 992         }\r
 993 \r
 994         private static Comparator<Resource> RESOURCE_COMPARATOR = new Comparator<Resource>() {\r
 995                 @Override\r
 996                 public int compare(Resource o1, Resource o2) {\r
 997                         ResourceImpl r1 = (ResourceImpl)o1;\r
 998                         ResourceImpl r2 = (ResourceImpl)o2;\r
 999                         return compare(r1.id, r2.id);\r
1000                 }\r
1001 \r
1002                 private int compare(int x, int y) {\r
1003                         return (x < y) ? -1 : ((x == y) ? 0 : 1);\r
1004                 }\r
1005         };\r
1006 \r
1007         @Override\r
1008         public void sort(List<Resource> list) {\r
1009                 if(list instanceof ResourceList) {\r
1010                         ((ResourceList) list).sort();\r
1011                 } else {\r
1012                         Collections.sort(list, RESOURCE_COMPARATOR);\r
1013                 }\r
1014         }\r
1015         \r
1016         @Override\r
1017         public List<Resource> asSortedList(Collection<Resource> rs) {\r
1018                 ResourceList result = new ResourceList(session, rs);\r
1019                 result.sort();\r
1020                 return result;\r
1021         }\r
1022         \r
1023         @Override\r
1024         public org.simantics.db.ResourceSet getResourceSet(ReadGraph graph, Collection<Resource> resources) {\r
1025             if(resources instanceof ResourceSet) return (org.simantics.db.ResourceSet)resources;\r
1026             org.simantics.db.ResourceSet result = new IntSet(((ReadGraphImpl)graph).processor.querySupport);\r
1027             for(Resource r : resources) result.add(r);\r
1028             return result;\r
1029         }\r
1030 \r
1031     @Override\r
1032     public org.simantics.db.ResourceSet getResourceSet(ReadGraph graph, Resource ... rs) {\r
1033         org.simantics.db.ResourceSet result = new IntSet(((ReadGraphImpl)graph).processor.querySupport);\r
1034         for(Resource r : rs) result.add(r);\r
1035         return result;\r
1036     }\r
1037         \r
1038 }\r