org.simantics.interop.mapping/src/org/simantics/interop/mapping/SplittingWriteGraph.java

   1 package org.simantics.interop.mapping;\r
   2 \r
   3 import java.util.Collection;\r
   4 import java.util.Set;\r
   5 import java.util.TreeMap;\r
   6 \r
   7 import org.simantics.databoard.accessor.Accessor;\r
   8 import org.simantics.databoard.binding.Binding;\r
   9 import org.simantics.databoard.type.Datatype;\r
  10 import org.simantics.databoard.util.binary.RandomAccessBinary;\r
  11 import org.simantics.db.Metadata;\r
  12 import org.simantics.db.ReadGraph;\r
  13 import org.simantics.db.Resource;\r
  14 import org.simantics.db.Session;\r
  15 import org.simantics.db.Statement;\r
  16 import org.simantics.db.VirtualGraph;\r
  17 import org.simantics.db.WriteGraph;\r
  18 import org.simantics.db.common.request.ReadRequest;\r
  19 import org.simantics.db.common.request.WriteRequest;\r
  20 import org.simantics.db.common.request.WriteResultRequest;\r
  21 import org.simantics.db.exception.AdaptionException;\r
  22 import org.simantics.db.exception.AssumptionException;\r
  23 import org.simantics.db.exception.BindingException;\r
  24 import org.simantics.db.exception.DatabaseException;\r
  25 import org.simantics.db.exception.DoesNotContainValueException;\r
  26 import org.simantics.db.exception.ManyObjectsForFunctionalRelationException;\r
  27 import org.simantics.db.exception.NoInverseException;\r
  28 import org.simantics.db.exception.NoSingleResultException;\r
  29 import org.simantics.db.exception.ResourceNotFoundException;\r
  30 import org.simantics.db.exception.ServiceException;\r
  31 import org.simantics.db.exception.ServiceNotFoundException;\r
  32 import org.simantics.db.exception.ValidationException;\r
  33 import org.simantics.db.procedure.AsyncListener;\r
  34 import org.simantics.db.procedure.AsyncMultiListener;\r
  35 import org.simantics.db.procedure.AsyncMultiProcedure;\r
  36 import org.simantics.db.procedure.AsyncProcedure;\r
  37 import org.simantics.db.procedure.AsyncSetListener;\r
  38 import org.simantics.db.procedure.Listener;\r
  39 import org.simantics.db.procedure.MultiListener;\r
  40 import org.simantics.db.procedure.MultiProcedure;\r
  41 import org.simantics.db.procedure.Procedure;\r
  42 import org.simantics.db.procedure.SetListener;\r
  43 import org.simantics.db.procedure.SyncListener;\r
  44 import org.simantics.db.procedure.SyncMultiListener;\r
  45 import org.simantics.db.procedure.SyncMultiProcedure;\r
  46 import org.simantics.db.procedure.SyncProcedure;\r
  47 import org.simantics.db.procedure.SyncSetListener;\r
  48 import org.simantics.db.request.AsyncMultiRead;\r
  49 import org.simantics.db.request.AsyncRead;\r
  50 import org.simantics.db.request.DelayedWrite;\r
  51 import org.simantics.db.request.DelayedWriteResult;\r
  52 import org.simantics.db.request.ExternalRead;\r
  53 import org.simantics.db.request.MultiRead;\r
  54 import org.simantics.db.request.Read;\r
  55 import org.simantics.db.request.ReadInterface;\r
  56 import org.simantics.db.request.Write;\r
  57 import org.simantics.db.request.WriteInterface;\r
  58 import org.simantics.db.request.WriteOnly;\r
  59 import org.simantics.db.request.WriteOnlyResult;\r
  60 import org.simantics.db.request.WriteResult;\r
  61 import org.simantics.db.request.WriteTraits;\r
  62 import org.simantics.scl.types.Type;\r
  63 import org.simantics.utils.datastructures.Callback;\r
  64 \r
  65 /**\r
  66  * This is insane.\r
  67  * \r
  68  * @author Marko Luukkainen <marko.luukkainen@vtt.fi>\r
  69  *\r
  70  */\r
  71 public class SplittingWriteGraph implements WriteGraph {\r
  72         \r
  73         protected Session session;\r
  74         \r
  75         \r
  76         @Override\r
  77         public <T> T getRelatedValue2(final Resource subject, final Resource relation)\r
  78                         throws DatabaseException {\r
  79                 return session.syncRequest(new Read<T>() {\r
  80                         @Override\r
  81                         public T perform(ReadGraph graph) throws DatabaseException {\r
  82                                 return graph.getRelatedValue2(subject, relation);\r
  83                         }\r
  84                 });\r
  85                 \r
  86         }\r
  87         \r
  88         @Override\r
  89         public <T> T getRelatedValue2(final Resource subject, final Resource relation, final Binding binding) throws DatabaseException {\r
  90                 return session.syncRequest(new Read<T>() {\r
  91                         @Override\r
  92                         public T perform(ReadGraph graph) throws DatabaseException {\r
  93                                 return graph.getRelatedValue2(subject, relation, binding);\r
  94                         }\r
  95                 });\r
  96         }\r
  97         \r
  98         @Override\r
  99         public <T> T getRelatedValue2(final Resource subject, final Resource relation, final Object context) throws DatabaseException {\r
 100                 return session.syncRequest(new Read<T>() {\r
 101                         @Override\r
 102                         public T perform(ReadGraph graph) throws DatabaseException {\r
 103                                 return graph.getRelatedValue2(subject, relation, context);\r
 104                         }\r
 105                 });\r
 106         }\r
 107         \r
 108         @Override\r
 109         public <T> T getRelatedValue2(final Resource subject, final Resource relation, final Object context, final Binding binding) throws DatabaseException {\r
 110                 return session.syncRequest(new Read<T>() {\r
 111                         @Override\r
 112                         public T perform(ReadGraph graph) throws DatabaseException {\r
 113                                 return graph.getRelatedValue2(subject, relation, context, binding);\r
 114                         }\r
 115                 });\r
 116         }\r
 117         \r
 118         @Override\r
 119         public <T> T getPossibleRelatedValue2(final Resource subject, final Resource relation)\r
 120                         throws DatabaseException {\r
 121                 return session.syncRequest(new Read<T>() {\r
 122                         @Override\r
 123                         public T perform(ReadGraph graph) throws DatabaseException {\r
 124                                 return graph.getPossibleRelatedValue2(subject, relation);\r
 125                         }\r
 126                 });\r
 127         }\r
 128         \r
 129         @Override\r
 130         public <T> T getPossibleRelatedValue2(final Resource subject, final Resource relation, final Binding binding) throws DatabaseException {\r
 131                 return session.syncRequest(new Read<T>() {\r
 132                         @Override\r
 133                         public T perform(ReadGraph graph) throws DatabaseException {\r
 134                                 return graph.getPossibleRelatedValue2(subject, relation, binding);\r
 135                         }\r
 136                 });\r
 137         }\r
 138         \r
 139         @Override\r
 140         public <T> T getPossibleRelatedValue2(final Resource subject, final Resource relation, final Object context) throws DatabaseException {\r
 141                 return session.syncRequest(new Read<T>() {\r
 142                         @Override\r
 143                         public T perform(ReadGraph graph) throws DatabaseException {\r
 144                                 return graph.getPossibleRelatedValue2(subject, relation, context);\r
 145                         }\r
 146                 });\r
 147         }\r
 148         \r
 149         @Override\r
 150         public <T> T getPossibleRelatedValue2(final Resource subject, final Resource relation, final Object context, final Binding binding) throws DatabaseException {\r
 151                 return session.syncRequest(new Read<T>() {\r
 152                         @Override\r
 153                         public T perform(ReadGraph graph) throws DatabaseException {\r
 154                                 return graph.getPossibleRelatedValue2(subject, relation, context, binding);\r
 155                         }\r
 156                 });\r
 157         }\r
 158         \r
 159         @Override\r
 160         public <T> void async(final ReadInterface<T> r, final AsyncListener<T> procedure) {\r
 161                 session.async(r, procedure);\r
 162                 \r
 163         }\r
 164         \r
 165         @Override\r
 166         public <T> void async(final ReadInterface<T> r, final AsyncProcedure<T> procedure) {\r
 167                 session.async(r, procedure);\r
 168         }\r
 169         \r
 170         @Override\r
 171         public <T> void async(final ReadInterface<T> r, final Listener<T> procedure) {\r
 172                 session.async(r, procedure);\r
 173         }\r
 174         \r
 175         @Override\r
 176         public <T> void async(final ReadInterface<T> r, final Procedure<T> procedure) {\r
 177                 session.async(r, procedure);\r
 178         }\r
 179         \r
 180         @Override\r
 181         public <T> void async(final ReadInterface<T> r, final SyncListener<T> procedure) {\r
 182                 session.async(r, procedure);\r
 183         }\r
 184         \r
 185         @Override\r
 186         public <T> void async(final ReadInterface<T> r, final SyncProcedure<T> procedure) {\r
 187                 session.async(r, procedure);\r
 188         }\r
 189         \r
 190         @Override\r
 191         public <T> void async(final WriteInterface<T> r) {\r
 192                 session.async(r);\r
 193         }\r
 194         \r
 195         @Override\r
 196         public <T> void async(final WriteInterface<T> r, final Procedure<T> procedure) {\r
 197                 session.async(r, procedure);\r
 198         }\r
 199         \r
 200         @Override\r
 201         public <T> T sync(final ReadInterface<T> r) throws DatabaseException {\r
 202                 return session.sync(r);\r
 203         }\r
 204         \r
 205         @Override\r
 206         public <T> T sync(final WriteInterface<T> r) throws DatabaseException {\r
 207                 return session.sync(r);\r
 208         }\r
 209         \r
 210         @Override\r
 211         public Resource getRootLibrary() {\r
 212                 try {\r
 213                         return session.syncRequest(new Read<Resource>() {\r
 214                                 \r
 215                                 @Override\r
 216                                 public Resource perform(ReadGraph graph) throws DatabaseException {\r
 217                                         return graph.getRootLibrary();\r
 218                                 }\r
 219                         });\r
 220                 } catch (DatabaseException e) {\r
 221                         return null;\r
 222                 }\r
 223         }\r
 224         \r
 225         \r
 226         @Override\r
 227         public void clearUndoList(final WriteTraits writeTraits) {\r
 228                 throw new RuntimeException("Not supported.");\r
 229         }\r
 230         \r
 231         @Override\r
 232         public void combineWithPrevious(WriteTraits writeTraits) {\r
 233                 throw new RuntimeException("Not supported.");\r
 234         }\r
 235         \r
 236         @Override\r
 237         public TreeMap<String, byte[]> getMetadata() {\r
 238                 try {\r
 239                         return session.syncRequest(new WriteResultRequest<TreeMap<String, byte[]>>() {\r
 240                                 \r
 241                                 @Override\r
 242                                 public TreeMap<String, byte[]> perform(WriteGraph graph) throws DatabaseException {\r
 243                                         return graph.getMetadata();\r
 244                                 }\r
 245                         });\r
 246                 } catch (DatabaseException e) {\r
 247                         return null;\r
 248                 }\r
 249         }\r
 250         \r
 251         @Override\r
 252         public <T extends Metadata> T getMetadata(final Class<T> clazz)\r
 253                         throws ServiceException {\r
 254                 try {\r
 255                         return session.syncRequest(new WriteResultRequest<T>() {\r
 256                                 \r
 257                                 @Override\r
 258                                 public T perform(WriteGraph graph) throws DatabaseException {\r
 259                                         return graph.getMetadata(clazz);\r
 260                                 }\r
 261                         });\r
 262                 } catch (DatabaseException e) {\r
 263                         throw new ServiceException(e);\r
 264                 }\r
 265         }\r
 266         \r
 267         @Override\r
 268         public Type getRelatedValueType(final Resource subject, final Resource relation)\r
 269                         throws DatabaseException {\r
 270 \r
 271                 return session.syncRequest(new Read<Type>() {\r
 272                         \r
 273                         @Override\r
 274                         public Type perform(ReadGraph graph) throws DatabaseException {\r
 275                                 return graph.getRelatedValueType(subject, relation);\r
 276                         }\r
 277                 });\r
 278                 \r
 279         }\r
 280         \r
 281         @Override\r
 282         public void deny(final Resource subject, final Resource predicate, final Resource inverse, final Resource object, final VirtualGraph vgraph) throws ServiceException {\r
 283                 try {\r
 284                         session.syncRequest(new WriteRequest() {\r
 285                                 \r
 286                                 @Override\r
 287                                 public void perform(WriteGraph graph) throws DatabaseException {\r
 288                                         graph.deny(subject, predicate, inverse, object, vgraph);\r
 289                                         \r
 290                                 }\r
 291                         });\r
 292                 } catch (DatabaseException e) {\r
 293                         throw new ServiceException(e);\r
 294                 }\r
 295         }\r
 296         \r
 297         \r
 298         \r
 299         \r
 300         @Override\r
 301         public <T> T adaptRelated(final Resource resource, final Resource relation,\r
 302                         final Class<T> clazz) throws AdaptionException, NoSingleResultException,\r
 303                         ValidationException, ServiceException {\r
 304                 try {\r
 305                         return session.syncRequest(new Read<T>() {\r
 306                                 \r
 307                                 @Override\r
 308                                 public T perform(ReadGraph graph) throws DatabaseException {\r
 309                                         return graph.adaptRelated(resource, relation, clazz);\r
 310                                 }\r
 311                         });\r
 312                 } catch (DatabaseException e) {\r
 313                         throw new ServiceException(e);\r
 314                 }\r
 315         }\r
 316         \r
 317         @Override\r
 318         public <T> T getPossibleRelatedAdapter(final Resource resource,\r
 319                         final Resource relation, final Class<T> clazz) throws ValidationException,\r
 320                         ServiceException {\r
 321                 try {\r
 322                         return session.syncRequest(new Read<T>() {\r
 323                                 \r
 324                                 @Override\r
 325                                 public T perform(ReadGraph graph) throws DatabaseException {\r
 326                                         return graph.getPossibleRelatedAdapter(resource, relation, clazz);\r
 327                                 }\r
 328                         });\r
 329                 } catch (DatabaseException e) {\r
 330                         throw new ValidationException(e);\r
 331                 }\r
 332         }\r
 333         \r
 334         @Override\r
 335         public void inc() {\r
 336                 throw new RuntimeException("Not supported.");\r
 337         }\r
 338         \r
 339         @Override\r
 340         public void dec() {\r
 341                 throw new RuntimeException("Not supported.");\r
 342         }\r
 343         \r
 344         @Override\r
 345         public Collection<Resource> getObjects(final Resource subject, final Resource relation) throws ServiceException \r
 346                         {\r
 347                 try {\r
 348                         return session.syncRequest(new Read<Collection<Resource>>() {\r
 349                                 \r
 350                                 @Override\r
 351                                 public Collection<Resource> perform(ReadGraph graph) throws DatabaseException {\r
 352                                         return graph.getObjects(subject, relation);\r
 353                                 }\r
 354                         });\r
 355                 } catch (DatabaseException e) {\r
 356                         throw new ServiceException(e);\r
 357                 }\r
 358                 \r
 359         }\r
 360         \r
 361         @Override\r
 362         public <T extends Accessor> T newLiteral(final Resource resource,\r
 363         final Resource predicate, final Datatype datatype, final Object initialValue)\r
 364         throws DatabaseException {\r
 365                 return session.syncRequest(new WriteResultRequest<T>() {\r
 366                         \r
 367                         @Override\r
 368                         public T perform(WriteGraph graph) throws DatabaseException {\r
 369                                 return graph.newLiteral(resource, predicate, datatype, initialValue);\r
 370                         }\r
 371                 });\r
 372         }\r
 373 \r
 374     @Override\r
 375     public RandomAccessBinary newLiteral4RandomAccessBinary\r
 376     (final Resource resource, final Resource predicate, final Datatype datatype, final Object initialvalue)\r
 377     throws DatabaseException {\r
 378         return session.syncRequest(new WriteResultRequest<RandomAccessBinary>() {\r
 379             @Override\r
 380             public RandomAccessBinary perform(WriteGraph graph) throws DatabaseException {\r
 381                 return graph.newLiteral4RandomAccessBinary(resource, predicate, datatype, initialvalue);\r
 382             }\r
 383         });\r
 384     }\r
 385 \r
 386         public <T, C> T adaptContextual(final Resource resource, final  C context, final java.lang.Class<C> contextClass, final java.lang.Class<T> clazz) throws AdaptionException ,NoSingleResultException ,ValidationException ,ServiceException {\r
 387                 try {\r
 388                         return session.syncRequest(new Read<T>() {\r
 389                                 \r
 390                                 @Override\r
 391                                 public T perform(ReadGraph graph) throws DatabaseException {\r
 392                                         return graph.adaptContextual(resource, context, contextClass, clazz);\r
 393                                 }\r
 394                         });\r
 395                 } catch (DatabaseException e) {\r
 396                         throw new ServiceException(e);\r
 397                 }\r
 398                 \r
 399         };\r
 400         \r
 401         public <T, C> T getPossibleContextualAdapter(final Resource resource, final C context, final java.lang.Class<C> contextClass, final java.lang.Class<T> clazz) throws ValidationException ,ServiceException {\r
 402                 try {\r
 403                         return session.syncRequest(new Read<T>() {\r
 404                                 \r
 405                                 @Override\r
 406                                 public T perform(ReadGraph graph) throws DatabaseException {\r
 407                                         return graph.getPossibleContextualAdapter(resource, context, contextClass, clazz);\r
 408                                 }\r
 409                         });\r
 410                 } catch (DatabaseException e) {\r
 411                         throw new ServiceException(e);\r
 412                 }\r
 413         };\r
 414         \r
 415         \r
 416         public SplittingWriteGraph(Session session) {\r
 417                 this.session = session;\r
 418         }\r
 419         \r
 420         @Override\r
 421         public Resource newResource() throws ServiceException {\r
 422                 try {\r
 423                         return session.syncRequest(new WriteResultRequest<Resource>() {\r
 424                                 \r
 425                                 @Override\r
 426                                 public Resource perform(WriteGraph graph) throws DatabaseException {\r
 427                                         return graph.newResource();\r
 428                                 }\r
 429                         });\r
 430                 } catch (DatabaseException e) {\r
 431                         throw new ServiceException(e);\r
 432                 }\r
 433                  \r
 434         }\r
 435         \r
 436         @Override\r
 437         public Resource newResource(final long clusterId) throws ServiceException {\r
 438                 try {\r
 439                         return session.syncRequest(new WriteResultRequest<Resource>() {\r
 440                                 \r
 441                                 @Override\r
 442                                 public Resource perform(WriteGraph graph) throws DatabaseException {\r
 443                                         return graph.newResource(clusterId);\r
 444                                 }\r
 445                         });\r
 446                 } catch (DatabaseException e) {\r
 447                         throw new ServiceException(e);\r
 448                 }\r
 449         }\r
 450         \r
 451         @Override\r
 452         public <T> T adapt(final Resource resource, final Class<T> clazz)\r
 453                         throws AdaptionException, ValidationException, ServiceException {\r
 454                 try {\r
 455                         return session.syncRequest(new Read<T>() {\r
 456                                 \r
 457                                 @Override\r
 458                                 public T perform(ReadGraph graph) throws DatabaseException {\r
 459                                         return graph.adapt(resource, clazz);\r
 460                                 }\r
 461                         });\r
 462                 } catch (DatabaseException e) {\r
 463                         throw new ServiceException(e);\r
 464                 }\r
 465         }\r
 466         \r
 467         @Override\r
 468         public <T> T adaptUnique(final Resource resource, final Class<T> clazz)\r
 469                         throws AdaptionException, ValidationException, ServiceException {\r
 470                 try {\r
 471                         return session.syncRequest(new Read<T>() {\r
 472                                 \r
 473                                 @Override\r
 474                                 public T perform(ReadGraph graph) throws DatabaseException {\r
 475                                         return graph.adaptUnique(resource, clazz);\r
 476                                 }\r
 477                         });\r
 478                 } catch (DatabaseException e) {\r
 479                         throw new ServiceException(e);\r
 480                 }\r
 481         }\r
 482         \r
 483         @Override\r
 484         public void addLiteral(final Resource resource, final Resource predicate,\r
 485                         final Resource inverse, final Object value, final Binding binding)\r
 486                         throws BindingException,\r
 487                         ManyObjectsForFunctionalRelationException, ServiceException {\r
 488                 try {\r
 489                         session.syncRequest(new WriteRequest() {\r
 490                                 \r
 491                                 @Override\r
 492                                 public void perform(WriteGraph graph) throws DatabaseException {\r
 493                                         graph.addLiteral(resource, predicate, inverse, value, binding);\r
 494                                         \r
 495                                 }\r
 496                         });\r
 497                 } catch (DatabaseException e) {\r
 498                         throw new ServiceException(e);\r
 499                 }\r
 500         }\r
 501         \r
 502         @Override\r
 503         public void addLiteral(final Resource resource, final Resource predicate,\r
 504                         final Resource inverse, final Resource type, final Object value, final Binding binding)\r
 505                         throws BindingException,\r
 506                         ManyObjectsForFunctionalRelationException, ServiceException {\r
 507                 try {\r
 508                         session.syncRequest(new WriteRequest() {\r
 509                                 \r
 510                                 @Override\r
 511                                 public void perform(WriteGraph graph) throws DatabaseException {\r
 512                                         graph.addLiteral(resource, predicate, inverse, type, value, binding);\r
 513                                         \r
 514                                 }\r
 515                         });\r
 516                 } catch (DatabaseException e) {\r
 517                         throw new ServiceException(e);\r
 518                 }\r
 519         }\r
 520         \r
 521         @Override\r
 522         public <T> void addMetadata(Metadata data) throws ServiceException {\r
 523                 throw new RuntimeException("Not supported.");\r
 524         }\r
 525         \r
 526         @Override\r
 527         @Deprecated\r
 528         public void addValue(final Resource resource, final Resource predicate,\r
 529                         final Resource inverse, final Resource type, final Object value, final Binding binding)\r
 530                         throws BindingException,\r
 531                         ManyObjectsForFunctionalRelationException, ServiceException {\r
 532                 try {\r
 533                         session.syncRequest(new WriteRequest() {\r
 534                                 \r
 535                                 @Override\r
 536                                 public void perform(WriteGraph graph) throws DatabaseException {\r
 537                                         graph.addValue(resource, predicate, inverse, type, value, binding);\r
 538                                         \r
 539                                 }\r
 540                         });\r
 541                 } catch (DatabaseException e) {\r
 542                         throw new ServiceException(e);\r
 543                 }\r
 544         }\r
 545         \r
 546         @Override\r
 547         public <T> void asyncRequest(final AsyncMultiRead<T> request) {\r
 548                 session.asyncRequest(request);\r
 549         }\r
 550         \r
 551         @Override\r
 552         public <T> void asyncRequest(AsyncMultiRead<T> request,\r
 553                         AsyncMultiListener<T> procedure) {\r
 554                 session.asyncRequest(request,procedure);\r
 555         }\r
 556         \r
 557         @Override\r
 558         public <T> void asyncRequest(AsyncMultiRead<T> request,\r
 559                         AsyncMultiProcedure<T> procedure) {\r
 560                 session.asyncRequest(request,procedure);\r
 561         }\r
 562         \r
 563         @Override\r
 564         public <T> void asyncRequest(AsyncMultiRead<T> request,\r
 565                         MultiListener<T> procedure) {\r
 566                 session.asyncRequest(request,procedure);\r
 567         }\r
 568         \r
 569         @Override\r
 570         public <T> void asyncRequest(AsyncMultiRead<T> request,\r
 571                         MultiProcedure<T> procedure) {\r
 572                 session.asyncRequest(request,procedure);\r
 573         }\r
 574         \r
 575         @Override\r
 576         public <T> void asyncRequest(AsyncMultiRead<T> request,\r
 577                         SyncMultiListener<T> procedure) {\r
 578                 session.asyncRequest(request,procedure);\r
 579         }\r
 580         \r
 581         @Override\r
 582         public <T> void asyncRequest(AsyncMultiRead<T> request,\r
 583                         SyncMultiProcedure<T> procedure) {\r
 584                 session.asyncRequest(request,procedure);        \r
 585         }\r
 586         \r
 587         @Override\r
 588         public <T> void asyncRequest(AsyncRead<T> request) {\r
 589                 session.asyncRequest(request);  \r
 590         }\r
 591         \r
 592         @Override\r
 593         public <T> void asyncRequest(AsyncRead<T> request,\r
 594                         AsyncListener<T> procedure) {\r
 595                 session.asyncRequest(request,procedure);        \r
 596         }\r
 597         \r
 598         @Override\r
 599         public <T> void asyncRequest(AsyncRead<T> request,\r
 600                         AsyncProcedure<T> procedure) {\r
 601                 session.asyncRequest(request,procedure);        \r
 602         }\r
 603         \r
 604         @Override\r
 605         public <T> void asyncRequest(AsyncRead<T> request, Listener<T> procedure) {\r
 606                 session.asyncRequest(request,procedure);        \r
 607         }\r
 608         \r
 609         @Override\r
 610         public <T> void asyncRequest(AsyncRead<T> request,\r
 611                         Procedure<T> procedure) {\r
 612                 session.asyncRequest(request,procedure);        \r
 613         }\r
 614         \r
 615         @Override\r
 616         public <T> void asyncRequest(AsyncRead<T> request,\r
 617                         SyncListener<T> procedure) {\r
 618                 session.asyncRequest(request,procedure);        \r
 619         }\r
 620         \r
 621         @Override\r
 622         public <T> void asyncRequest(AsyncRead<T> request,\r
 623                         SyncProcedure<T> procedure) {\r
 624                 session.asyncRequest(request,procedure);        \r
 625         }\r
 626         \r
 627         @Override\r
 628         public void asyncRequest(DelayedWrite request) {\r
 629                 session.asyncRequest(request);  \r
 630         }\r
 631         \r
 632         @Override\r
 633         public void asyncRequest(DelayedWrite request,\r
 634                         Callback<DatabaseException> callback) {\r
 635                 session.asyncRequest(request,callback); \r
 636         }\r
 637         \r
 638         @Override\r
 639         public <T> void asyncRequest(DelayedWriteResult<T> r,\r
 640                         Procedure<T> procedure) {\r
 641                 session.asyncRequest(r,procedure);      \r
 642         }\r
 643         \r
 644         @Override\r
 645         public <T> void asyncRequest(ExternalRead<T> request) {\r
 646                 session.asyncRequest(request);  \r
 647         }\r
 648         \r
 649         @Override\r
 650         public <T> void asyncRequest(ExternalRead<T> request,\r
 651                         Listener<T> procedure) {\r
 652                 session.asyncRequest(request,procedure);\r
 653         }       \r
 654         \r
 655         @Override\r
 656         public <T> void asyncRequest(ExternalRead<T> request,\r
 657                         Procedure<T> procedure) {\r
 658                 session.asyncRequest(request,procedure);\r
 659         }\r
 660         \r
 661         @Override\r
 662         public <T> void asyncRequest(MultiRead<T> request) {\r
 663                 session.asyncRequest(request);  \r
 664         }\r
 665         \r
 666         @Override\r
 667         public <T> void asyncRequest(MultiRead<T> request,\r
 668                         AsyncMultiListener<T> procedure) {\r
 669                 session.asyncRequest(request,procedure);        \r
 670         }\r
 671         \r
 672         @Override\r
 673         public <T> void asyncRequest(MultiRead<T> request,\r
 674                         AsyncMultiProcedure<T> procedure) {\r
 675                 session.asyncRequest(request,procedure);        \r
 676         }\r
 677         \r
 678         @Override\r
 679         public <T> void asyncRequest(MultiRead<T> request,\r
 680                         MultiListener<T> procedure) {\r
 681                 session.asyncRequest(request,procedure);        \r
 682         }\r
 683         \r
 684         @Override\r
 685         public <T> void asyncRequest(MultiRead<T> request,\r
 686                         MultiProcedure<T> procedure) {\r
 687                 session.asyncRequest(request,procedure);        \r
 688         }\r
 689         \r
 690         @Override\r
 691         public <T> void asyncRequest(MultiRead<T> request,\r
 692                         SyncMultiListener<T> procedure) {\r
 693                 session.asyncRequest(request,procedure);        \r
 694         }\r
 695         \r
 696         @Override\r
 697         public <T> void asyncRequest(MultiRead<T> request,\r
 698                         SyncMultiProcedure<T> procedure) {\r
 699                 session.asyncRequest(request,procedure);        \r
 700         }\r
 701         \r
 702         @Override\r
 703         public <T> void asyncRequest(Read<T> request) {\r
 704                 session.asyncRequest(request);  \r
 705         }\r
 706         \r
 707         @Override\r
 708         public <T> void asyncRequest(Read<T> request, AsyncListener<T> procedure) {\r
 709                 session.asyncRequest(request,procedure);        \r
 710         }\r
 711         \r
 712         @Override\r
 713         public <T> void asyncRequest(Read<T> request,\r
 714                         AsyncProcedure<T> procedure) {\r
 715                 session.asyncRequest(request,procedure);        \r
 716         }\r
 717         \r
 718         @Override\r
 719         public <T> void asyncRequest(Read<T> request, Listener<T> procedure) {\r
 720                 session.asyncRequest(request,procedure);        \r
 721         }\r
 722         \r
 723         @Override\r
 724         public <T> void asyncRequest(Read<T> request, Procedure<T> procedure) {\r
 725                 session.asyncRequest(request,procedure);        \r
 726         }\r
 727         \r
 728         @Override\r
 729         public <T> void asyncRequest(Read<T> request, SyncListener<T> procedure) {\r
 730                 session.asyncRequest(request,procedure);        \r
 731         }\r
 732         \r
 733         @Override\r
 734         public <T> void asyncRequest(Read<T> request, SyncProcedure<T> procedure) {\r
 735                 session.asyncRequest(request,procedure);        \r
 736         }\r
 737         \r
 738         @Override\r
 739         public void asyncRequest(Write request) {\r
 740                 session.asyncRequest(request);  \r
 741         }\r
 742         \r
 743         @Override\r
 744         public void asyncRequest(Write request,\r
 745                         Callback<DatabaseException> callback) {\r
 746                 session.asyncRequest(request, callback);        \r
 747         }\r
 748         \r
 749         @Override\r
 750         public void asyncRequest(WriteOnly r) {\r
 751                 session.asyncRequest(r);        \r
 752         }\r
 753         \r
 754         @Override\r
 755         public void asyncRequest(WriteOnly r,\r
 756                         Callback<DatabaseException> callback) {\r
 757                 session.asyncRequest(r,callback);       \r
 758         }\r
 759         \r
 760         @Override\r
 761         public <T> void asyncRequest(WriteOnlyResult<T> r,\r
 762                         Procedure<T> procedure) {\r
 763                 session.asyncRequest(r,procedure);      \r
 764         }\r
 765         \r
 766         @Override\r
 767         public <T> void asyncRequest(WriteResult<T> r, Procedure<T> procedure) {\r
 768                 session.asyncRequest(r,procedure);      \r
 769         }\r
 770         \r
 771         \r
 772         \r
 773         @Override\r
 774         public void claim(final Resource subject, final Resource predicate,\r
 775                         final Resource inverse, final Resource object) throws ServiceException {\r
 776                 try {\r
 777                         session.syncRequest(new WriteRequest() {\r
 778                                 \r
 779                                 @Override\r
 780                                 public void perform(WriteGraph graph) throws DatabaseException {\r
 781                                         graph.claim(subject, predicate, inverse, object);\r
 782                                 }\r
 783                         });\r
 784                 } catch (DatabaseException e) {\r
 785                         throw new ServiceException(e);\r
 786                 }\r
 787         }\r
 788         \r
 789         @Override\r
 790         public void claim(final Resource subject, final Resource predicate, final Resource object)\r
 791                         throws ServiceException {\r
 792                 try {\r
 793                         session.syncRequest(new WriteRequest() {\r
 794                                 \r
 795                                 @Override\r
 796                                 public void perform(WriteGraph graph) throws DatabaseException {\r
 797                                         graph.claim(subject, predicate, object);\r
 798                                 }\r
 799                         });\r
 800                 } catch (DatabaseException e) {\r
 801                         throw new ServiceException(e);\r
 802                 }\r
 803         }\r
 804         \r
 805 \r
 806         @Override\r
 807         public void claimLiteral(final Resource resource, final Resource predicate,\r
 808                         final Object value) throws ManyObjectsForFunctionalRelationException,\r
 809                         ServiceException {\r
 810                 try {\r
 811                         session.syncRequest(new WriteRequest() {\r
 812                                 \r
 813                                 @Override\r
 814                                 public void perform(WriteGraph graph) throws DatabaseException {\r
 815                                         graph.claimLiteral(resource, predicate, value);\r
 816                                 }\r
 817                         });\r
 818                 } catch (DatabaseException e) {\r
 819                         throw new ServiceException(e);\r
 820                 }\r
 821                 \r
 822         }\r
 823         \r
 824         @Override\r
 825         public void claimLiteral(final Resource resource, final Resource predicate,\r
 826                         final Object value, final Binding binding) throws BindingException,\r
 827                         ManyObjectsForFunctionalRelationException, ServiceException {\r
 828                 try {\r
 829                         session.syncRequest(new WriteRequest() {\r
 830                                 \r
 831                                 @Override\r
 832                                 public void perform(WriteGraph graph) throws DatabaseException {\r
 833                                         graph.claimLiteral(resource, predicate, value, binding);\r
 834                                 }\r
 835                         });\r
 836                 } catch (DatabaseException e) {\r
 837                         throw new ServiceException(e);\r
 838                 }\r
 839                 \r
 840         }\r
 841         \r
 842         @Override\r
 843         public void claimLiteral(final Resource resource, final Resource predicate,\r
 844                         final Resource inverse, final Resource type, final Object value)\r
 845                         throws BindingException,\r
 846                         ManyObjectsForFunctionalRelationException, ServiceException {\r
 847                 try {\r
 848                         session.syncRequest(new WriteRequest() {\r
 849                                 \r
 850                                 @Override\r
 851                                 public void perform(WriteGraph graph) throws DatabaseException {\r
 852                                         graph.claimLiteral(resource, predicate, inverse, type, value);\r
 853                                 }\r
 854                         });\r
 855                 } catch (DatabaseException e) {\r
 856                         throw new ServiceException(e);\r
 857                 }\r
 858                 \r
 859         }\r
 860         \r
 861         @Override\r
 862         public void claimLiteral(final Resource resource, final Resource predicate,\r
 863                         final Resource inverse, final Resource type, final Object value, final Binding binding)\r
 864                         throws BindingException,\r
 865                         ManyObjectsForFunctionalRelationException, ServiceException {\r
 866                 try {\r
 867                         session.syncRequest(new WriteRequest() {\r
 868                                 \r
 869                                 @Override\r
 870                                 public void perform(WriteGraph graph) throws DatabaseException {\r
 871                                         graph.claimLiteral(resource, predicate, inverse, type, value, binding);\r
 872                                 }\r
 873                         });\r
 874                 } catch (DatabaseException e) {\r
 875                         throw new ServiceException(e);\r
 876                 }\r
 877                 \r
 878         }\r
 879         \r
 880         @Override\r
 881         public void claimLiteral(final Resource resource, final Resource predicate,\r
 882                         final Resource type, final Object value) throws BindingException,\r
 883                         ManyObjectsForFunctionalRelationException, ServiceException {\r
 884                 try {\r
 885                         session.syncRequest(new WriteRequest() {\r
 886                                 \r
 887                                 @Override\r
 888                                 public void perform(WriteGraph graph) throws DatabaseException {\r
 889                                         graph.claimLiteral(resource, predicate, type, value);\r
 890                                 }\r
 891                         });\r
 892                 } catch (DatabaseException e) {\r
 893                         throw new ServiceException(e);\r
 894                 }\r
 895                 \r
 896         }\r
 897         \r
 898         @Override\r
 899         public void claimLiteral(final Resource resource, final Resource predicate,\r
 900                         final Resource type, final Object value, final Binding binding)\r
 901                         throws BindingException,\r
 902                         ManyObjectsForFunctionalRelationException, ServiceException {\r
 903                 try {\r
 904                         session.syncRequest(new WriteRequest() {\r
 905                                 \r
 906                                 @Override\r
 907                                 public void perform(WriteGraph graph) throws DatabaseException {\r
 908                                         graph.claimLiteral(resource, predicate, type, value, binding);\r
 909                                 }\r
 910                         });\r
 911                 } catch (DatabaseException e) {\r
 912                         throw new ServiceException(e);\r
 913                 }\r
 914                 \r
 915         }\r
 916         \r
 917         @Override\r
 918         public void claimValue(final Resource resource, final Object value)\r
 919                         throws ServiceException {\r
 920                 try {\r
 921                         session.syncRequest(new WriteRequest() {\r
 922                                 \r
 923                                 @Override\r
 924                                 public void perform(WriteGraph graph) throws DatabaseException {\r
 925                                         graph.claimValue(resource, value);\r
 926                                 }\r
 927                         });\r
 928                 } catch (DatabaseException e) {\r
 929                         throw new ServiceException(e);\r
 930                 }\r
 931                 \r
 932         }\r
 933         \r
 934         @Override\r
 935         public void claimValue(final Resource resource, final Object value, final Binding binding)\r
 936                         throws ServiceException {\r
 937                 try {\r
 938                         session.syncRequest(new WriteRequest() {\r
 939                                 \r
 940                                 @Override\r
 941                                 public void perform(WriteGraph graph) throws DatabaseException {\r
 942                                         graph.claimValue(resource, value, binding);     \r
 943                                 }\r
 944                         });\r
 945                 } catch (DatabaseException e) {\r
 946                         throw new ServiceException(e);\r
 947                 }\r
 948                 \r
 949         }\r
 950         \r
 951         @SuppressWarnings("deprecation")\r
 952         @Override\r
 953         public void claimValue(final Resource resource, final Resource predicate,\r
 954                         final Object value) throws ManyObjectsForFunctionalRelationException,\r
 955                         ServiceException {\r
 956                 try {\r
 957                         session.syncRequest(new WriteRequest() {\r
 958                                 \r
 959                                 @Override\r
 960                                 public void perform(WriteGraph graph) throws DatabaseException {\r
 961                                         graph.claimValue(resource, predicate, value);   \r
 962                                 }\r
 963                         });\r
 964                 } catch (DatabaseException e) {\r
 965                         throw new ServiceException(e);\r
 966                 }\r
 967                 \r
 968         }\r
 969         \r
 970         @SuppressWarnings("deprecation")\r
 971         @Override\r
 972         public void claimValue(final Resource resource, final Resource predicate,\r
 973                         final Object value, final Binding binding) throws BindingException,\r
 974                         ManyObjectsForFunctionalRelationException, ServiceException {\r
 975                 try {\r
 976                         session.syncRequest(new WriteRequest() {\r
 977                                 \r
 978                                 @Override\r
 979                                 public void perform(WriteGraph graph) throws DatabaseException {\r
 980                                         graph.claimValue(resource, predicate, value, binding);\r
 981                                 }\r
 982                         });\r
 983                 } catch (DatabaseException e) {\r
 984                         throw new ServiceException(e);\r
 985                 }\r
 986                 \r
 987         }\r
 988         \r
 989         @SuppressWarnings("deprecation")\r
 990         @Override\r
 991         public void claimValue(final Resource resource, final Resource predicate,\r
 992                         final Resource inverse, final Resource type, final Object value, final Binding binding)\r
 993                         throws BindingException,\r
 994                         ManyObjectsForFunctionalRelationException, ServiceException {\r
 995                 try {\r
 996                         session.syncRequest(new WriteRequest() {\r
 997                                 \r
 998                                 @Override\r
 999                                 public void perform(WriteGraph graph) throws DatabaseException {\r
1000                                         graph.claimValue(resource, predicate, inverse, type, value, binding);\r
1001                                 }\r
1002                         });\r
1003                 } catch (DatabaseException e) {\r
1004                         throw new ServiceException(e);\r
1005                 }\r
1006                 \r
1007         }\r
1008         \r
1009         @Override\r
1010         public void deny(final Resource subject) throws ServiceException {\r
1011                 try {\r
1012                         session.syncRequest(new WriteRequest() {\r
1013                                 \r
1014                                 @Override\r
1015                                 public void perform(WriteGraph graph) throws DatabaseException {\r
1016                                         graph.deny(subject);\r
1017                                 }\r
1018                         });\r
1019                 } catch (DatabaseException e) {\r
1020                         throw new ServiceException(e);\r
1021                 }\r
1022                 \r
1023         }\r
1024         \r
1025         @Override\r
1026         public void deny(final Resource subject, final Resource predicate)\r
1027                         throws ServiceException {\r
1028                 try {\r
1029                         session.syncRequest(new WriteRequest() {\r
1030                                 \r
1031                                 @Override\r
1032                                 public void perform(WriteGraph graph) throws DatabaseException {\r
1033                                         graph.deny(subject, predicate);\r
1034                                 }\r
1035                         });\r
1036                 } catch (DatabaseException e) {\r
1037                         throw new ServiceException(e);\r
1038                 }\r
1039                 \r
1040         }\r
1041         \r
1042         @Override\r
1043         public void deny(final Resource subject, final Resource predicate,\r
1044                         final Resource inverse, final Resource object) throws ServiceException {\r
1045                 try {\r
1046                         session.syncRequest(new WriteRequest() {\r
1047                                 \r
1048                                 @Override\r
1049                                 public void perform(WriteGraph graph) throws DatabaseException {\r
1050                                         graph.deny(subject, predicate, inverse, object);\r
1051                                 }\r
1052                         });\r
1053                 } catch (DatabaseException e) {\r
1054                         throw new ServiceException(e);\r
1055                 }\r
1056                 \r
1057         }\r
1058         \r
1059         @Override\r
1060         public void deny(final Resource subject, final Resource predicate, final Resource object)\r
1061                         throws ServiceException {\r
1062                 try {\r
1063                         session.syncRequest(new WriteRequest() {\r
1064                                 \r
1065                                 @Override\r
1066                                 public void perform(WriteGraph graph) throws DatabaseException {\r
1067                                         graph.deny(subject, predicate, object);\r
1068                                 }\r
1069                         });\r
1070                 } catch (DatabaseException e) {\r
1071                         throw new ServiceException(e);\r
1072                 }\r
1073                 \r
1074         }\r
1075         \r
1076         @Override\r
1077         public void deny(final Statement statement) throws ServiceException {\r
1078                 try {\r
1079                         session.syncRequest(new WriteRequest() {\r
1080                                 \r
1081                                 @Override\r
1082                                 public void perform(WriteGraph graph) throws DatabaseException {\r
1083                                         graph.deny(statement);\r
1084                                 }\r
1085                         });\r
1086                 } catch (DatabaseException e) {\r
1087                         throw new ServiceException(e);\r
1088                 }\r
1089                 \r
1090         }\r
1091         \r
1092 \r
1093         @Override\r
1094         public void denyStatement(final Resource subject, final Resource predicate,\r
1095                         final Resource object) throws ServiceException {\r
1096                 try {\r
1097                         session.syncRequest(new WriteRequest() {\r
1098                                 \r
1099                                 @Override\r
1100                                 public void perform(WriteGraph graph) throws DatabaseException {\r
1101                                         graph.denyStatement(subject, predicate, object);\r
1102                                 }\r
1103                         });\r
1104                 } catch (DatabaseException e) {\r
1105                         throw new ServiceException(e);\r
1106                 }\r
1107                 \r
1108         }\r
1109         \r
1110         @Override\r
1111         public void denyValue(final Resource resource) throws ServiceException {\r
1112                 try {\r
1113                         session.syncRequest(new WriteRequest() {\r
1114                                 \r
1115                                 @Override\r
1116                                 public void perform(WriteGraph graph) throws DatabaseException {\r
1117                                         graph.denyValue(resource);\r
1118                                 }\r
1119                         });\r
1120                 } catch (DatabaseException e) {\r
1121                         throw new ServiceException(e);\r
1122                 }\r
1123                 \r
1124         }\r
1125         \r
1126         @Override\r
1127         public void denyValue(final Resource resource, final Resource predicate)\r
1128                         throws ManyObjectsForFunctionalRelationException,\r
1129                         ServiceException {\r
1130                 try {\r
1131                         session.syncRequest(new WriteRequest() {\r
1132                                 \r
1133                                 @Override\r
1134                                 public void perform(WriteGraph graph) throws DatabaseException {\r
1135                                         graph.denyValue(resource, predicate);\r
1136                                 }\r
1137                         });\r
1138                 } catch (DatabaseException e) {\r
1139                         throw new ServiceException(e);\r
1140                 }\r
1141         }\r
1142         \r
1143         @Override\r
1144         public void flushCluster() throws ServiceException {\r
1145                 try {\r
1146                         session.syncRequest(new WriteRequest() {\r
1147                                 \r
1148                                 @Override\r
1149                                 public void perform(WriteGraph graph) throws DatabaseException {\r
1150                                         graph.flushCluster();\r
1151                                         \r
1152                                 }\r
1153                         });\r
1154                 } catch (DatabaseException e) {\r
1155                         throw new ServiceException(e);\r
1156                 }\r
1157                 \r
1158         }\r
1159         \r
1160         @Override\r
1161         public void flushCluster(final Resource r) throws ServiceException {\r
1162                 try {\r
1163                         session.syncRequest(new WriteRequest() {\r
1164                                 \r
1165                                 @Override\r
1166                                 public void perform(WriteGraph graph) throws DatabaseException {\r
1167                                         graph.flushCluster(r);\r
1168                                         \r
1169                                 }\r
1170                         });\r
1171                 } catch (DatabaseException e) {\r
1172                         throw new ServiceException(e);\r
1173                 }\r
1174         }\r
1175         \r
1176         @Override\r
1177         public <T> void forAdapted(final Resource resource, final Class<T> clazz,\r
1178                         final AsyncListener<T> procedure) {\r
1179                 try {\r
1180                         session.syncRequest(new ReadRequest() {\r
1181                                 \r
1182                                 @Override\r
1183                                 public void run(ReadGraph graph) throws DatabaseException {\r
1184                                         graph.forAdapted(resource, clazz, procedure);\r
1185                                 }\r
1186                         });\r
1187                 } catch (DatabaseException e) {\r
1188                         \r
1189                 }\r
1190                 \r
1191         }\r
1192         \r
1193         @Override\r
1194         public <T> void forAdapted(final Resource resource, final Class<T> clazz,\r
1195                         final AsyncProcedure<T> procedure) {\r
1196                 try {\r
1197                         session.syncRequest(new ReadRequest() {\r
1198                                 \r
1199                                 @Override\r
1200                                 public void run(ReadGraph graph) throws DatabaseException {\r
1201                                         graph.forAdapted(resource, clazz, procedure);\r
1202                                 }\r
1203                         });\r
1204                 } catch (DatabaseException e) {\r
1205                         \r
1206                 }\r
1207         }\r
1208         \r
1209         @Override\r
1210         public <T> void forAdapted(final Resource resource, final Class<T> clazz,\r
1211                         final Listener<T> procedure) {\r
1212                 try {\r
1213                         session.syncRequest(new ReadRequest() {\r
1214                                 \r
1215                                 @Override\r
1216                                 public void run(ReadGraph graph) throws DatabaseException {\r
1217                                         graph.forAdapted(resource, clazz, procedure);\r
1218                                 }\r
1219                         });\r
1220                 } catch (DatabaseException e) {\r
1221                         \r
1222                 }\r
1223         }\r
1224         \r
1225         @Override\r
1226         public <T> void forAdapted(final Resource resource, final Class<T> clazz,\r
1227                         final Procedure<T> procedure) {\r
1228                 try {\r
1229                         session.syncRequest(new ReadRequest() {\r
1230                                 \r
1231                                 @Override\r
1232                                 public void run(ReadGraph graph) throws DatabaseException {\r
1233                                         graph.forAdapted(resource, clazz, procedure);\r
1234                                 }\r
1235                         });\r
1236                 } catch (DatabaseException e) {\r
1237                         \r
1238                 }\r
1239                 \r
1240         }\r
1241         \r
1242         @Override\r
1243         public <T> void forAdapted(final Resource resource, final Class<T> clazz,\r
1244                         final SyncListener<T> procedure) {\r
1245                 try {\r
1246                         session.syncRequest(new ReadRequest() {\r
1247                                 \r
1248                                 @Override\r
1249                                 public void run(ReadGraph graph) throws DatabaseException {\r
1250                                         graph.forAdapted(resource, clazz, procedure);\r
1251                                 }\r
1252                         });\r
1253                 } catch (DatabaseException e) {\r
1254                         \r
1255                 }\r
1256                 \r
1257         }\r
1258         \r
1259         @Override\r
1260         public <T> void forAdapted(final Resource resource, final Class<T> clazz,\r
1261                         final SyncProcedure<T> procedure) {\r
1262                 try {\r
1263                         session.syncRequest(new ReadRequest() {\r
1264                                 \r
1265                                 @Override\r
1266                                 public void run(ReadGraph graph) throws DatabaseException {\r
1267                                         graph.forAdapted(resource, clazz, procedure);\r
1268                                 }\r
1269                         });\r
1270                 } catch (DatabaseException e) {\r
1271                         \r
1272                 }\r
1273         }\r
1274         \r
1275         @Override\r
1276         public void forAssertedObjectSet(final Resource subject, final Resource relation,\r
1277                         final AsyncSetListener<Resource> procedure) {\r
1278                 try {\r
1279                         session.syncRequest(new ReadRequest() {\r
1280                                 \r
1281                                 @Override\r
1282                                 public void run(ReadGraph graph) throws DatabaseException {\r
1283                                         graph.forAssertedObjectSet(subject, relation, procedure);\r
1284                                 }\r
1285                         });\r
1286                 } catch (DatabaseException e) {\r
1287                         \r
1288                 }\r
1289                 \r
1290         }\r
1291         \r
1292         @Override\r
1293         public void forAssertedObjectSet(final Resource subject, final Resource relation,\r
1294                         final SetListener<Resource> procedure) {\r
1295                 try {\r
1296                         session.syncRequest(new ReadRequest() {\r
1297                                 \r
1298                                 @Override\r
1299                                 public void run(ReadGraph graph) throws DatabaseException {\r
1300                                         graph.forAssertedObjectSet(subject, relation, procedure);\r
1301                                 }\r
1302                         });\r
1303                 } catch (DatabaseException e) {\r
1304                         \r
1305                 }\r
1306         }\r
1307         \r
1308         @Override\r
1309         public void forAssertedObjectSet(final Resource subject, final Resource relation,\r
1310                         final SyncSetListener<Resource> procedure) {\r
1311                 try {\r
1312                         session.syncRequest(new ReadRequest() {\r
1313                                 \r
1314                                 @Override\r
1315                                 public void run(ReadGraph graph) throws DatabaseException {\r
1316                                         graph.forAssertedObjectSet(subject, relation, procedure);\r
1317                                 }\r
1318                         });\r
1319                 } catch (DatabaseException e) {\r
1320                         \r
1321                 }\r
1322         }\r
1323         \r
1324         @Override\r
1325         public void forAssertedStatementSet(final Resource subject,\r
1326                         final Resource relation, final AsyncSetListener<Statement> procedure) {\r
1327                 try {\r
1328                         session.syncRequest(new ReadRequest() {\r
1329                                 \r
1330                                 @Override\r
1331                                 public void run(ReadGraph graph) throws DatabaseException {\r
1332                                         graph.forAssertedStatementSet(subject, relation, procedure);\r
1333                                 }\r
1334                         });\r
1335                 } catch (DatabaseException e) {\r
1336                         \r
1337                 }\r
1338         }\r
1339         \r
1340         @Override\r
1341         public void forAssertedStatementSet(final Resource subject,\r
1342                         final Resource relation, final SetListener<Statement> procedure) {\r
1343                 try {\r
1344                         session.syncRequest(new ReadRequest() {\r
1345                                 \r
1346                                 @Override\r
1347                                 public void run(ReadGraph graph) throws DatabaseException {\r
1348                                         graph.forAssertedStatementSet(subject, relation, procedure);\r
1349                                 }\r
1350                         });\r
1351                 } catch (DatabaseException e) {\r
1352                         \r
1353                 }\r
1354         }\r
1355         \r
1356         @Override\r
1357         public void forAssertedStatementSet(final Resource subject,\r
1358                         final Resource relation, final SyncSetListener<Statement> procedure) {\r
1359                 try {\r
1360                         session.syncRequest(new ReadRequest() {\r
1361                                 \r
1362                                 @Override\r
1363                                 public void run(ReadGraph graph) throws DatabaseException {\r
1364                                         graph.forAssertedStatementSet(subject, relation, procedure);\r
1365                                 }\r
1366                         });\r
1367                 } catch (DatabaseException e) {\r
1368                         \r
1369                 }\r
1370         }\r
1371         \r
1372         @Override\r
1373         public void forBuiltin(final String id, final AsyncListener<Resource> procedure) {\r
1374                 try {\r
1375                         session.syncRequest(new ReadRequest() {\r
1376                                 \r
1377                                 @Override\r
1378                                 public void run(ReadGraph graph) throws DatabaseException {\r
1379                                         graph.forBuiltin(id, procedure);\r
1380                                 }\r
1381                         });\r
1382                 } catch (DatabaseException e) {\r
1383                         \r
1384                 }\r
1385                 \r
1386         }\r
1387         \r
1388         @Override\r
1389         public void forBuiltin(final String id, final Listener<Resource> procedure) {\r
1390                 try {\r
1391                         session.syncRequest(new ReadRequest() {\r
1392                                 \r
1393                                 @Override\r
1394                                 public void run(ReadGraph graph) throws DatabaseException {\r
1395                                         graph.forBuiltin(id, procedure);\r
1396                                 }\r
1397                         });\r
1398                 } catch (DatabaseException e) {\r
1399                         \r
1400                 }\r
1401         }\r
1402         \r
1403         @Override\r
1404         public void forBuiltin(final String id, final AsyncProcedure<Resource> procedure) {\r
1405                 try {\r
1406                         session.syncRequest(new ReadRequest() {\r
1407                                 \r
1408                                 @Override\r
1409                                 public void run(ReadGraph graph) throws DatabaseException {\r
1410                                         graph.forBuiltin(id, procedure);\r
1411                                 }\r
1412                         });\r
1413                 } catch (DatabaseException e) {\r
1414                         \r
1415                 }\r
1416         }\r
1417         \r
1418         @Override\r
1419         public void forBuiltin(final String id, final Procedure<Resource> procedure) {\r
1420                 try {\r
1421                         session.syncRequest(new ReadRequest() {\r
1422                                 \r
1423                                 @Override\r
1424                                 public void run(ReadGraph graph) throws DatabaseException {\r
1425                                         graph.forBuiltin(id, procedure);\r
1426                                 }\r
1427                         });\r
1428                 } catch (DatabaseException e) {\r
1429                         \r
1430                 }\r
1431         }\r
1432         \r
1433         @Override\r
1434         public void forBuiltin(final String id, final SyncListener<Resource> procedure) {\r
1435                 try {\r
1436                         session.syncRequest(new ReadRequest() {\r
1437                                 \r
1438                                 @Override\r
1439                                 public void run(ReadGraph graph) throws DatabaseException {\r
1440                                         graph.forBuiltin(id, procedure);\r
1441                                 }\r
1442                         });\r
1443                 } catch (DatabaseException e) {\r
1444                         \r
1445                 }\r
1446         }\r
1447         \r
1448         @Override\r
1449         public void forBuiltin(final String id, final SyncProcedure<Resource> procedure) {\r
1450                 try {\r
1451                         session.syncRequest(new ReadRequest() {\r
1452                                 \r
1453                                 @Override\r
1454                                 public void run(ReadGraph graph) throws DatabaseException {\r
1455                                         graph.forBuiltin(id, procedure);\r
1456                                 }\r
1457                         });\r
1458                 } catch (DatabaseException e) {\r
1459                         \r
1460                 }\r
1461         }\r
1462         \r
1463         @Override\r
1464         public void forDirectSuperrelations(final Resource subject,\r
1465                         final AsyncMultiProcedure<Resource> procedure) {\r
1466                 try {\r
1467                         session.syncRequest(new ReadRequest() {\r
1468                                 \r
1469                                 @Override\r
1470                                 public void run(ReadGraph graph) throws DatabaseException {\r
1471                                         graph.forDirectSuperrelations(subject, procedure);\r
1472                                 }\r
1473                         });\r
1474                 } catch (DatabaseException e) {\r
1475                         \r
1476                 }\r
1477         }\r
1478         \r
1479         @Override\r
1480         public void forEachAssertedObject(final Resource subject, final Resource relation,\r
1481                         final AsyncMultiProcedure<Resource> procedure) {\r
1482                 try {\r
1483                         session.syncRequest(new ReadRequest() {\r
1484                                 \r
1485                                 @Override\r
1486                                 public void run(ReadGraph graph) throws DatabaseException {\r
1487                                         graph.forEachAssertedObject(subject, relation, procedure);\r
1488                                 }\r
1489                         });\r
1490                 } catch (DatabaseException e) {\r
1491                                 \r
1492                 }\r
1493         }\r
1494         \r
1495         @Override\r
1496         public void forEachAssertedObject(final Resource subject, final Resource relation,\r
1497                         final MultiProcedure<Resource> procedure) {\r
1498                 try {\r
1499                         session.syncRequest(new ReadRequest() {\r
1500                                 \r
1501                                 @Override\r
1502                                 public void run(ReadGraph graph) throws DatabaseException {\r
1503                                         graph.forEachAssertedObject(subject, relation, procedure);      \r
1504                                 }\r
1505                         });\r
1506                 } catch (DatabaseException e) {\r
1507                                 \r
1508                 }\r
1509         }\r
1510         \r
1511         @Override\r
1512         public void forEachAssertedObject(final Resource subject, final Resource relation,\r
1513                         final SyncMultiProcedure<Resource> procedure) {\r
1514                 try {\r
1515                         session.syncRequest(new ReadRequest() {\r
1516                                 \r
1517                                 @Override\r
1518                                 public void run(ReadGraph graph) throws DatabaseException {\r
1519                                         graph.forEachAssertedObject(subject, relation, procedure);      \r
1520                                 }\r
1521                         });\r
1522                 } catch (DatabaseException e) {\r
1523                                 \r
1524                 }\r
1525         }\r
1526         \r
1527         @Override\r
1528         public void forEachAssertedStatement(final Resource subject,\r
1529                         final Resource relation, final AsyncMultiProcedure<Statement> procedure) {\r
1530                 try {\r
1531                         session.syncRequest(new ReadRequest() {\r
1532                                 \r
1533                                 @Override\r
1534                                 public void run(ReadGraph graph) throws DatabaseException {\r
1535                                         graph.forEachAssertedStatement(subject, relation, procedure);\r
1536                                 }\r
1537                         });\r
1538                 } catch (DatabaseException e) {\r
1539                                 \r
1540                 }\r
1541         }\r
1542         \r
1543         @Override\r
1544         public void forEachAssertedStatement(final Resource subject,\r
1545                         final Resource relation, final MultiProcedure<Statement> procedure) {\r
1546                 try {\r
1547                         session.syncRequest(new ReadRequest() {\r
1548                                 \r
1549                                 @Override\r
1550                                 public void run(ReadGraph graph) throws DatabaseException {\r
1551                                         graph.forEachAssertedStatement(subject, relation, procedure);\r
1552                                 }\r
1553                         });\r
1554                 } catch (DatabaseException e) {\r
1555                                 \r
1556                 }\r
1557         }\r
1558         \r
1559         @Override\r
1560         public void forEachAssertedStatement(final Resource subject,\r
1561                         final Resource relation, final SyncMultiProcedure<Statement> procedure) {\r
1562                 try {\r
1563                         session.syncRequest(new ReadRequest() {\r
1564                                 \r
1565                                 @Override\r
1566                                 public void run(ReadGraph graph) throws DatabaseException {\r
1567                                         graph.forEachAssertedStatement(subject, relation, procedure);\r
1568                                 }\r
1569                         });\r
1570                 } catch (DatabaseException e) {\r
1571                                 \r
1572                 }\r
1573         }\r
1574         \r
1575 //      @Override\r
1576 //      public void forEachDirectObject(final Resource subject, final Resource relation,\r
1577 //                      final AsyncMultiProcedure<Resource> procedure) {\r
1578 //              try {\r
1579 //                      session.syncRequest(new ReadRequest() {\r
1580 //                              \r
1581 //                              @Override\r
1582 //                              public void run(ReadGraph graph) throws DatabaseException {\r
1583 //                                      graph.forEachDirectObject(subject, relation, procedure);\r
1584 //                              }\r
1585 //                      });\r
1586 //              } catch (DatabaseException e) {\r
1587 //                              \r
1588 //              }\r
1589 //      }\r
1590 //      \r
1591 //      @Override\r
1592 //      public void forEachDirectObject(final Resource subject, final Resource relation,\r
1593 //                      final MultiProcedure<Resource> procedure) {\r
1594 //              try {\r
1595 //                      session.syncRequest(new ReadRequest() {\r
1596 //                              \r
1597 //                              @Override\r
1598 //                              public void run(ReadGraph graph) throws DatabaseException {\r
1599 //                                      graph.forEachDirectObject(subject, relation, procedure);\r
1600 //                              }\r
1601 //                      });\r
1602 //              } catch (DatabaseException e) {\r
1603 //                              \r
1604 //              }\r
1605 //      }\r
1606 //      \r
1607 //      @Override\r
1608 //      public void forEachDirectObject(final Resource subject, final Resource relation,\r
1609 //                      final SyncMultiProcedure<Resource> procedure) {\r
1610 //              try {\r
1611 //                      session.syncRequest(new ReadRequest() {\r
1612 //                              \r
1613 //                              @Override\r
1614 //                              public void run(ReadGraph graph) throws DatabaseException {\r
1615 //                                      graph.forEachDirectObject(subject, relation, procedure);\r
1616 //                              }\r
1617 //                      });\r
1618 //              } catch (DatabaseException e) {\r
1619 //                              \r
1620 //              }\r
1621 //      }\r
1622         \r
1623         @Override\r
1624         public void forEachDirectPredicate(final Resource subject,\r
1625                         final AsyncMultiProcedure<Resource> procedure) {\r
1626                 try {\r
1627                         session.syncRequest(new ReadRequest() {\r
1628                                 \r
1629                                 @Override\r
1630                                 public void run(ReadGraph graph) throws DatabaseException {\r
1631                                         graph.forEachDirectPredicate(subject, procedure);\r
1632                                 }\r
1633                         });\r
1634                 } catch (DatabaseException e) {\r
1635                                 \r
1636                 }\r
1637         }\r
1638         \r
1639         @Override\r
1640         public void forEachDirectPredicate(final Resource subject,\r
1641                         final MultiProcedure<Resource> procedure) {\r
1642                 try {\r
1643                         session.syncRequest(new ReadRequest() {\r
1644                                 \r
1645                                 @Override\r
1646                                 public void run(ReadGraph graph) throws DatabaseException {\r
1647                                         graph.forEachDirectPredicate(subject, procedure);\r
1648                                 }\r
1649                         });\r
1650                 } catch (DatabaseException e) {\r
1651                                 \r
1652                 }\r
1653         }\r
1654         \r
1655         @Override\r
1656         public void forEachDirectPredicate(final Resource subject,\r
1657                         final SyncMultiProcedure<Resource> procedure) {\r
1658                 try {\r
1659                         session.syncRequest(new ReadRequest() {\r
1660                                 \r
1661                                 @Override\r
1662                                 public void run(ReadGraph graph) throws DatabaseException {\r
1663                                         graph.forEachDirectPredicate(subject, procedure);\r
1664                                 }\r
1665                         });\r
1666                 } catch (DatabaseException e) {\r
1667                                 \r
1668                 }\r
1669         }\r
1670         \r
1671         @Override\r
1672         public void forEachObject(final Resource subject, final Resource relation,\r
1673                         final AsyncMultiProcedure<Resource> procedure) {\r
1674                 try {\r
1675                         session.syncRequest(new ReadRequest() {\r
1676                                 \r
1677                                 @Override\r
1678                                 public void run(ReadGraph graph) throws DatabaseException {\r
1679                                         graph.forEachObject(subject, relation, procedure);\r
1680                                 }\r
1681                         });\r
1682                 } catch (DatabaseException e) {\r
1683                                 \r
1684                 }\r
1685         }\r
1686         \r
1687         @Override\r
1688         public void forEachObject(final Resource subject, final Resource relation,\r
1689                         final MultiProcedure<Resource> procedure) {\r
1690                 try {\r
1691                         session.syncRequest(new ReadRequest() {\r
1692                                 \r
1693                                 @Override\r
1694                                 public void run(ReadGraph graph) throws DatabaseException {\r
1695                                         graph.forEachObject(subject, relation, procedure);\r
1696                                 }\r
1697                         });\r
1698                 } catch (DatabaseException e) {\r
1699                                 \r
1700                 }\r
1701         }\r
1702         \r
1703         @Override\r
1704         public void forEachObject(final Resource subject, final Resource relation,\r
1705                         final SyncMultiProcedure<Resource> procedure) {\r
1706                 try {\r
1707                         session.syncRequest(new ReadRequest() {\r
1708                                 \r
1709                                 @Override\r
1710                                 public void run(ReadGraph graph) throws DatabaseException {\r
1711                                         graph.forEachObject(subject, relation, procedure);\r
1712                                 }\r
1713                         });\r
1714                 } catch (DatabaseException e) {\r
1715                                 \r
1716                 }\r
1717         }\r
1718         \r
1719         @Override\r
1720         public void forEachPredicate(final Resource subject,\r
1721                         final AsyncMultiProcedure<Resource> procedure) {\r
1722                 try {\r
1723                         session.syncRequest(new ReadRequest() {\r
1724                                 \r
1725                                 @Override\r
1726                                 public void run(ReadGraph graph) throws DatabaseException {\r
1727                                         graph.forEachPredicate(subject, procedure);\r
1728                                 }\r
1729                         });\r
1730                 } catch (DatabaseException e) {\r
1731                                 \r
1732                 }\r
1733         }\r
1734         \r
1735         @Override\r
1736         public void forEachPredicate(final Resource subject,\r
1737                         final MultiProcedure<Resource> procedure) {\r
1738                 try {\r
1739                         session.syncRequest(new ReadRequest() {\r
1740                                 \r
1741                                 @Override\r
1742                                 public void run(ReadGraph graph) throws DatabaseException {\r
1743                                         graph.forEachPredicate(subject, procedure);\r
1744                                 }\r
1745                         });\r
1746                 } catch (DatabaseException e) {\r
1747                                 \r
1748                 }\r
1749         }\r
1750         \r
1751         @Override\r
1752         public void forEachPredicate(final Resource subject,\r
1753                         final SyncMultiProcedure<Resource> procedure) {\r
1754                 try {\r
1755                         session.syncRequest(new ReadRequest() {\r
1756                                 \r
1757                                 @Override\r
1758                                 public void run(ReadGraph graph) throws DatabaseException {\r
1759                                         graph.forEachPredicate(subject, procedure);\r
1760                                 }\r
1761                         });\r
1762                 } catch (DatabaseException e) {\r
1763                                 \r
1764                 }\r
1765         }\r
1766         \r
1767         @Override\r
1768         public void forEachPrincipalType(final Resource subject,\r
1769                         final AsyncMultiProcedure<Resource> procedure) {\r
1770                 try {\r
1771                         session.syncRequest(new ReadRequest() {\r
1772                                 \r
1773                                 @Override\r
1774                                 public void run(ReadGraph graph) throws DatabaseException {\r
1775                                         graph.forEachPrincipalType(subject, procedure);\r
1776                                 }\r
1777                         });\r
1778                 } catch (DatabaseException e) {\r
1779                                 \r
1780                 }\r
1781         }\r
1782         \r
1783         @Override\r
1784         public void forEachPrincipalType(final Resource subject,\r
1785                         final MultiProcedure<Resource> procedure) {\r
1786                 try {\r
1787                         session.syncRequest(new ReadRequest() {\r
1788                                 \r
1789                                 @Override\r
1790                                 public void run(ReadGraph graph) throws DatabaseException {\r
1791                                         graph.forEachPrincipalType(subject, procedure);\r
1792                                 }\r
1793                         });\r
1794                 } catch (DatabaseException e) {\r
1795                                 \r
1796                 }\r
1797         }\r
1798         \r
1799         @Override\r
1800         public void forEachPrincipalType(final Resource subject,\r
1801                         final SyncMultiProcedure<Resource> procedure) {\r
1802                 try {\r
1803                         session.syncRequest(new ReadRequest() {\r
1804                                 \r
1805                                 @Override\r
1806                                 public void run(ReadGraph graph) throws DatabaseException {\r
1807                                         graph.forEachPrincipalType(subject, procedure);\r
1808                                 }\r
1809                         });\r
1810                 } catch (DatabaseException e) {\r
1811                                 \r
1812                 }\r
1813         }\r
1814         \r
1815         @Override\r
1816         public void forEachStatement(final Resource subject, final Resource relation,\r
1817                         final AsyncMultiProcedure<Statement> procedure) {\r
1818                 try {\r
1819                         session.syncRequest(new ReadRequest() {\r
1820                                 \r
1821                                 @Override\r
1822                                 public void run(ReadGraph graph) throws DatabaseException {\r
1823                                         graph.forEachStatement(subject, relation, procedure);\r
1824                                 }\r
1825                         });\r
1826                 } catch (DatabaseException e) {\r
1827                                 \r
1828                 }\r
1829         }\r
1830         \r
1831         @Override\r
1832         public void forEachStatement(final Resource subject, final Resource relation,\r
1833                         final MultiProcedure<Statement> procedure) {\r
1834                 try {\r
1835                         session.syncRequest(new ReadRequest() {\r
1836                                 \r
1837                                 @Override\r
1838                                 public void run(ReadGraph graph) throws DatabaseException {\r
1839                                         graph.forEachStatement(subject, relation, procedure);\r
1840                                 }\r
1841                         });\r
1842                 } catch (DatabaseException e) {\r
1843                                 \r
1844                 }\r
1845         }\r
1846         \r
1847         @Override\r
1848         public void forEachStatement(final Resource subject, final Resource relation,\r
1849                         final SyncMultiProcedure<Statement> procedure) {\r
1850                 try {\r
1851                         session.syncRequest(new ReadRequest() {\r
1852                                 \r
1853                                 @Override\r
1854                                 public void run(ReadGraph graph) throws DatabaseException {\r
1855                                         graph.forEachStatement(subject, relation, procedure);\r
1856                                 }\r
1857                         });\r
1858                 } catch (DatabaseException e) {\r
1859                                 \r
1860                 }\r
1861         }\r
1862         \r
1863         @Override\r
1864         public void forHasStatement(final Resource subject,\r
1865                         final AsyncListener<Boolean> procedure) {\r
1866                 try {\r
1867                         session.syncRequest(new ReadRequest() {\r
1868                                 \r
1869                                 @Override\r
1870                                 public void run(ReadGraph graph) throws DatabaseException {\r
1871                 graph.forHasStatement(subject, procedure);\r
1872                                 }\r
1873                         });\r
1874                 } catch (DatabaseException e) {\r
1875                                 \r
1876                 }\r
1877         }\r
1878         \r
1879         @Override\r
1880         public void forHasStatement(final Resource subject,\r
1881                         final AsyncProcedure<Boolean> procedure) {\r
1882                 try {\r
1883                         session.syncRequest(new ReadRequest() {\r
1884                                 \r
1885                                 @Override\r
1886                                 public void run(ReadGraph graph) throws DatabaseException {\r
1887                 graph.forHasStatement(subject, procedure);      \r
1888                                 }\r
1889                         });\r
1890                 } catch (DatabaseException e) {\r
1891                                 \r
1892                 }\r
1893         }\r
1894         \r
1895         @Override\r
1896         public void forHasStatement(final Resource subject,\r
1897                         final Listener<Boolean> procedure) {\r
1898                 try {\r
1899                         session.syncRequest(new ReadRequest() {\r
1900                                 \r
1901                                 @Override\r
1902                                 public void run(ReadGraph graph) throws DatabaseException {\r
1903                 graph.forHasStatement(subject, procedure);      \r
1904                                 }\r
1905                         });\r
1906                 } catch (DatabaseException e) {\r
1907                                 \r
1908                 }\r
1909         }\r
1910         \r
1911         @Override\r
1912         public void forHasStatement(final Resource subject,\r
1913                         final Procedure<Boolean> procedure) {\r
1914                 try {\r
1915                         session.syncRequest(new ReadRequest() {\r
1916                                 \r
1917                                 @Override\r
1918                                 public void run(ReadGraph graph) throws DatabaseException {\r
1919                 graph.forHasStatement(subject, procedure);\r
1920                                 }\r
1921                         });\r
1922                 } catch (DatabaseException e) {\r
1923                                 \r
1924                 }\r
1925                 \r
1926         }\r
1927         \r
1928         @Override\r
1929         public void forHasStatement(final Resource subject, final Resource relation,\r
1930                         final AsyncListener<Boolean> procedure) {\r
1931                 try {\r
1932                         session.syncRequest(new ReadRequest() {\r
1933                                 \r
1934                                 @Override\r
1935                                 public void run(ReadGraph graph) throws DatabaseException {\r
1936                 graph.forHasStatement(subject, relation, procedure);    \r
1937                                 }\r
1938                         });\r
1939                 } catch (DatabaseException e) {\r
1940                                 \r
1941                 }\r
1942         }\r
1943         \r
1944         @Override\r
1945         public void forHasStatement(final Resource subject, final Resource relation,\r
1946                         final AsyncProcedure<Boolean> procedure) {\r
1947                 try {\r
1948                         session.syncRequest(new ReadRequest() {\r
1949                                 \r
1950                                 @Override\r
1951                                 public void run(ReadGraph graph) throws DatabaseException {\r
1952                 graph.forHasStatement(subject, relation, procedure);\r
1953                                 }\r
1954                         });\r
1955                 } catch (DatabaseException e) {\r
1956                                 \r
1957                 }\r
1958         }\r
1959         \r
1960         @Override\r
1961         public void forHasStatement(final Resource subject, final Resource relation,\r
1962                         final Listener<Boolean> procedure) {\r
1963                 try {\r
1964                         session.syncRequest(new ReadRequest() {\r
1965                                 \r
1966                                 @Override\r
1967                                 public void run(ReadGraph graph) throws DatabaseException {\r
1968                 graph.forHasStatement(subject, relation, procedure);\r
1969                                 }\r
1970                         });\r
1971                 } catch (DatabaseException e) {\r
1972                                 \r
1973                 }\r
1974         }\r
1975         \r
1976         @Override\r
1977         public void forHasStatement(final Resource subject, final Resource relation,\r
1978                         final Procedure<Boolean> procedure) {\r
1979                 try {\r
1980                         session.syncRequest(new ReadRequest() {\r
1981                                 \r
1982                                 @Override\r
1983                                 public void run(ReadGraph graph) throws DatabaseException {\r
1984                 graph.forHasStatement(subject, relation, procedure);    \r
1985                                 }\r
1986                         });\r
1987                 } catch (DatabaseException e) {\r
1988                                 \r
1989                 }\r
1990         }\r
1991         \r
1992         @Override\r
1993         public void forHasStatement(final Resource subject, final Resource relation,\r
1994                         final Resource object, final AsyncListener<Boolean> procedure) {\r
1995                 try {\r
1996                         session.syncRequest(new ReadRequest() {\r
1997                                 \r
1998                                 @Override\r
1999                                 public void run(ReadGraph graph) throws DatabaseException {\r
2000                 graph.forHasStatement(subject, relation, object, procedure);\r
2001                                 }\r
2002                         });\r
2003                 } catch (DatabaseException e) {\r
2004                                 \r
2005                 }\r
2006         }\r
2007         \r
2008         @Override\r
2009         public void forHasStatement(final Resource subject, final Resource relation,\r
2010                         final Resource object, final AsyncProcedure<Boolean> procedure) {\r
2011                 try {\r
2012                         session.syncRequest(new ReadRequest() {\r
2013                                 \r
2014                                 @Override\r
2015                                 public void run(ReadGraph graph) throws DatabaseException {\r
2016                 graph.forHasStatement(subject, relation, object, procedure);\r
2017                                 }\r
2018                         });\r
2019                 } catch (DatabaseException e) {\r
2020                                 \r
2021                 }\r
2022         }\r
2023         \r
2024         @Override\r
2025         public void forHasStatement(final Resource subject, final Resource relation,\r
2026                         final Resource object, final Listener<Boolean> procedure) {\r
2027                 try {\r
2028                         session.syncRequest(new ReadRequest() {\r
2029                                 \r
2030                                 @Override\r
2031                                 public void run(ReadGraph graph) throws DatabaseException {\r
2032                 graph.forHasStatement(subject, relation, object, procedure);    \r
2033                                 }\r
2034                         });\r
2035                 } catch (DatabaseException e) {\r
2036                                 \r
2037                 }\r
2038         }\r
2039         \r
2040         @Override\r
2041         public void forHasStatement(final Resource subject, final Resource relation,\r
2042                         final Resource object, final Procedure<Boolean> procedure) {\r
2043                 try {\r
2044                         session.syncRequest(new ReadRequest() {\r
2045                                 \r
2046                                 @Override\r
2047                                 public void run(ReadGraph graph) throws DatabaseException {\r
2048                 graph.forHasStatement(subject, relation, object, procedure);    \r
2049                                 }\r
2050                         });\r
2051                 } catch (DatabaseException e) {\r
2052                                 \r
2053                 }\r
2054         }\r
2055         \r
2056         @Override\r
2057         public void forHasStatement(final Resource subject, final Resource relation,\r
2058                         final Resource object, final SyncListener<Boolean> procedure) {\r
2059                 try {\r
2060                         session.syncRequest(new ReadRequest() {\r
2061                                 \r
2062                                 @Override\r
2063                                 public void run(ReadGraph graph) throws DatabaseException {\r
2064                 graph.forHasStatement(subject, relation, object, procedure);    \r
2065                                 }\r
2066                         });\r
2067                 } catch (DatabaseException e) {\r
2068                                 \r
2069                 }\r
2070         }\r
2071         \r
2072         @Override\r
2073         public void forHasStatement(final Resource subject, final Resource relation,\r
2074                         final Resource object, final SyncProcedure<Boolean> procedure) {\r
2075                 try {\r
2076                         session.syncRequest(new ReadRequest() {\r
2077                                 \r
2078                                 @Override\r
2079                                 public void run(ReadGraph graph) throws DatabaseException {\r
2080                 graph.forHasStatement(subject, relation, object, procedure);    \r
2081                                 }\r
2082                         });\r
2083                 } catch (DatabaseException e) {\r
2084                                 \r
2085                 }\r
2086         }\r
2087         \r
2088         @Override\r
2089         public void forHasStatement(final Resource subject, final Resource relation,\r
2090                         final SyncListener<Boolean> procedure) {\r
2091                 try {\r
2092                         session.syncRequest(new ReadRequest() {\r
2093                                 \r
2094                                 @Override\r
2095                                 public void run(ReadGraph graph) throws DatabaseException {\r
2096                 graph.forHasStatement(subject, relation,  procedure);   \r
2097                                 }\r
2098                         });\r
2099                 } catch (DatabaseException e) {\r
2100                                 \r
2101                 }\r
2102         }\r
2103         \r
2104         @Override\r
2105         public void forHasStatement(final Resource subject, final Resource relation,\r
2106                         final SyncProcedure<Boolean> procedure) {\r
2107                 try {\r
2108                         session.syncRequest(new ReadRequest() {\r
2109                                 \r
2110                                 @Override\r
2111                                 public void run(ReadGraph graph) throws DatabaseException {\r
2112                 graph.forHasStatement(subject, relation, procedure);\r
2113                                 }\r
2114                         });\r
2115                 } catch (DatabaseException e) {\r
2116                                 \r
2117                 }\r
2118         }\r
2119         \r
2120         @Override\r
2121         public void forHasStatement(final Resource subject,\r
2122                         final SyncListener<Boolean> procedure) {\r
2123                 try {\r
2124                         session.syncRequest(new ReadRequest() {\r
2125                                 \r
2126                                 @Override\r
2127                                 public void run(ReadGraph graph) throws DatabaseException {\r
2128                 graph.forHasStatement(subject,  procedure);     \r
2129                                 }\r
2130                         });\r
2131                 } catch (DatabaseException e) {\r
2132                                 \r
2133                 }\r
2134         }\r
2135         \r
2136         @Override\r
2137         public void forHasStatement(final Resource subject,\r
2138                         final SyncProcedure<Boolean> procedure) {\r
2139                 try {\r
2140                         session.syncRequest(new ReadRequest() {\r
2141                                 \r
2142                                 @Override\r
2143                                 public void run(ReadGraph graph) throws DatabaseException {\r
2144                 graph.forHasStatement(subject,  procedure);     \r
2145                                 }\r
2146                         });\r
2147                 } catch (DatabaseException e) {\r
2148                                 \r
2149                 }\r
2150         }\r
2151         \r
2152         @Override\r
2153         public void forHasValue(final Resource subject,\r
2154                         final AsyncListener<Boolean> procedure) {\r
2155                 try {\r
2156                         session.syncRequest(new ReadRequest() {\r
2157                                 \r
2158                                 @Override\r
2159                                 public void run(ReadGraph graph) throws DatabaseException {\r
2160                 graph.forHasValue(subject, procedure);\r
2161                                 }\r
2162                         });\r
2163                 } catch (DatabaseException e) {\r
2164                                 \r
2165                 }\r
2166         }\r
2167         \r
2168         @Override\r
2169         public void forHasValue(final Resource subject,\r
2170                         final AsyncProcedure<Boolean> procedure) {\r
2171                 try {\r
2172                         session.syncRequest(new ReadRequest() {\r
2173                                 \r
2174                                 @Override\r
2175                                 public void run(ReadGraph graph) throws DatabaseException {\r
2176                 graph.forHasValue(subject, procedure);  \r
2177                                 }\r
2178                         });\r
2179                 } catch (DatabaseException e) {\r
2180                                 \r
2181                 }\r
2182         }\r
2183         \r
2184         @Override\r
2185         public void forHasValue(final Resource subject, final Listener<Boolean> procedure) {\r
2186                 try {\r
2187                         session.syncRequest(new ReadRequest() {\r
2188                                 \r
2189                                 @Override\r
2190                                 public void run(ReadGraph graph) throws DatabaseException {\r
2191                 graph.forHasValue(subject, procedure);  \r
2192                                 }\r
2193                         });\r
2194                 } catch (DatabaseException e) {\r
2195                                 \r
2196                 }\r
2197         }\r
2198         \r
2199         @Override\r
2200         public void forHasValue(final Resource subject, final Procedure<Boolean> procedure) {\r
2201                 try {\r
2202                         session.syncRequest(new ReadRequest() {\r
2203                                 \r
2204                                 @Override\r
2205                                 public void run(ReadGraph graph) throws DatabaseException {\r
2206                 graph.forHasValue(subject, procedure);  \r
2207                                 }\r
2208                         });\r
2209                 } catch (DatabaseException e) {\r
2210                                 \r
2211                 }\r
2212         }\r
2213         \r
2214         @Override\r
2215         public void forHasValue(final Resource subject,\r
2216                         final SyncListener<Boolean> procedure) {\r
2217                 try {\r
2218                         session.syncRequest(new ReadRequest() {\r
2219                                 \r
2220                                 @Override\r
2221                                 public void run(ReadGraph graph) throws DatabaseException {\r
2222                 graph.forHasValue(subject, procedure);  \r
2223                                 }\r
2224                         });\r
2225                 } catch (DatabaseException e) {\r
2226                                 \r
2227                 }\r
2228         }\r
2229         \r
2230         @Override\r
2231         public void forHasValue(final Resource subject,\r
2232                         final SyncProcedure<Boolean> procedure) {\r
2233                 try {\r
2234                         session.syncRequest(new ReadRequest() {\r
2235                                 \r
2236                                 @Override\r
2237                                 public void run(ReadGraph graph) throws DatabaseException {\r
2238                 graph.forHasValue(subject, procedure);  \r
2239                                 }\r
2240                         });\r
2241                 } catch (DatabaseException e) {\r
2242                                 \r
2243                 }\r
2244         }\r
2245         \r
2246         @Override\r
2247         public void forInverse(final Resource relation,\r
2248                         final AsyncListener<Resource> procedure) {\r
2249                 try {\r
2250                         session.syncRequest(new ReadRequest() {\r
2251                                 \r
2252                                 @Override\r
2253                                 public void run(ReadGraph graph) throws DatabaseException {\r
2254                 graph.forInverse(relation, procedure);\r
2255                                 }\r
2256                         });\r
2257                 } catch (DatabaseException e) {\r
2258                                 \r
2259                 }\r
2260         }\r
2261 \r
2262         @Override\r
2263         public <T> T getService(Class<T> api) throws ServiceNotFoundException {\r
2264                 return session.getService(api);\r
2265         }\r
2266 \r
2267         @Override\r
2268         public <T> T peekService(Class<T> api) {\r
2269                 return session.peekService(api);\r
2270         }\r
2271 \r
2272         @Override\r
2273         public boolean hasService(Class<?> api) {\r
2274                 return session.hasService(api);\r
2275         }\r
2276 \r
2277         @Override\r
2278         public <T> void registerService(Class<T> api, T service) {\r
2279                 session.registerService(api, service);\r
2280         }\r
2281 \r
2282         @Override\r
2283         public String getURI(final Resource resource)\r
2284                         throws ValidationException,\r
2285                         ServiceException, AssumptionException {\r
2286                 try {\r
2287                         return session.syncRequest(new Read<String>() {\r
2288                                 \r
2289                                 @Override\r
2290                                 public String perform(ReadGraph graph) throws DatabaseException {\r
2291                                         return graph.getURI(resource);\r
2292                                 }\r
2293                         });\r
2294                 } catch (DatabaseException e) {\r
2295                         throw new ServiceException(e);\r
2296                 }\r
2297                 \r
2298         }\r
2299 \r
2300         @Override\r
2301         public String getPossibleURI(final Resource resource)\r
2302                         throws ValidationException,\r
2303                         ServiceException {\r
2304                 try {\r
2305                         return session.syncRequest(new Read<String>() {\r
2306                                 \r
2307                                 @Override\r
2308                                 public String perform(ReadGraph graph) throws DatabaseException {\r
2309                                         return graph.getPossibleURI(resource);\r
2310                                 }\r
2311                         });\r
2312                 } catch (DatabaseException e) {\r
2313                         throw new ServiceException(e);\r
2314                 }\r
2315         }\r
2316 \r
2317         @Override\r
2318         public Resource getResource(final String uri)\r
2319                         throws ResourceNotFoundException, ValidationException,\r
2320                         ServiceException {\r
2321                 try {\r
2322                         return session.syncRequest(new Read<Resource>() {\r
2323                                 \r
2324                                 @Override\r
2325                                 public Resource perform(ReadGraph graph) throws DatabaseException {\r
2326                                         return graph.getResource(uri);\r
2327                                 }\r
2328                         });\r
2329                 } catch (DatabaseException e) {\r
2330                         throw new ServiceException(e);\r
2331                 }\r
2332         }\r
2333 \r
2334         @Override\r
2335         public Resource getPossibleResource(final String uri)\r
2336                         throws ResourceNotFoundException, ValidationException,\r
2337                         ServiceException {\r
2338                 try {\r
2339                         return session.syncRequest(new Read<Resource>() {\r
2340                                 \r
2341                                 @Override\r
2342                                 public Resource perform(ReadGraph graph) throws DatabaseException {\r
2343                                         return graph.getPossibleResource(uri);\r
2344                                 }\r
2345                         });\r
2346                 } catch (DatabaseException e) {\r
2347                         throw new ServiceException(e);\r
2348                 }\r
2349         }\r
2350 \r
2351         @Override\r
2352         public Collection<Statement> getStatements(final Resource subject,\r
2353                         final Resource relation)\r
2354                         throws ManyObjectsForFunctionalRelationException,\r
2355                         ServiceException {\r
2356                 try {\r
2357                         return session.syncRequest(new Read<Collection<Statement>>() {\r
2358                                 \r
2359                                 @Override\r
2360                                 public Collection<Statement> perform(ReadGraph graph) throws DatabaseException {\r
2361                                         return graph.getStatements(subject, relation);\r
2362                                 }\r
2363                         });\r
2364                 } catch (DatabaseException e) {\r
2365                         throw new ServiceException(e);\r
2366                 }\r
2367         }\r
2368 \r
2369         @Override\r
2370         public Collection<Statement> getAssertedStatements(final Resource subject,\r
2371                         final Resource relation)\r
2372                         throws ManyObjectsForFunctionalRelationException,\r
2373                         ServiceException {\r
2374                 try {\r
2375                         return session.syncRequest(new Read<Collection<Statement>>() {\r
2376                                 \r
2377                                 @Override\r
2378                                 public Collection<Statement> perform(ReadGraph graph) throws DatabaseException {\r
2379                                         return graph.getAssertedStatements(subject, relation);\r
2380                                 }\r
2381                         });\r
2382                 } catch (DatabaseException e) {\r
2383                         throw new ServiceException(e);\r
2384                 }\r
2385         }\r
2386 \r
2387         @Override\r
2388         public Collection<Resource> getPredicates(final Resource subject)\r
2389                         throws ServiceException {\r
2390                 try {\r
2391                         return session.syncRequest(new Read<Collection<Resource>>() {\r
2392                                 \r
2393                                 @Override\r
2394                                 public Collection<Resource> perform(ReadGraph graph) throws DatabaseException {\r
2395                                         return graph.getPredicates(subject);\r
2396                                 }\r
2397                         });\r
2398                 } catch (DatabaseException e) {\r
2399                         throw new ServiceException(e);\r
2400                 }\r
2401         }\r
2402 \r
2403         @Override\r
2404         public Collection<Resource> getPrincipalTypes(final Resource subject)\r
2405                         throws ServiceException {\r
2406                 try {\r
2407                         return session.syncRequest(new Read<Collection<Resource>>() {\r
2408                                 \r
2409                                 @Override\r
2410                                 public Collection<Resource> perform(ReadGraph graph) throws DatabaseException {\r
2411                                         return graph.getPrincipalTypes(subject);\r
2412                                 }\r
2413                         });\r
2414                 } catch (DatabaseException e) {\r
2415                         throw new ServiceException(e);\r
2416                 }\r
2417         }\r
2418 \r
2419         @Override\r
2420         public Set<Resource> getTypes(final Resource subject) throws ServiceException {\r
2421                 try {\r
2422                         return session.syncRequest(new Read<Set<Resource>>() {\r
2423                                 \r
2424                                 @Override\r
2425                                 public Set<Resource> perform(ReadGraph graph) throws DatabaseException {\r
2426                                         return graph.getTypes(subject);\r
2427                                 }\r
2428                         });\r
2429                 } catch (DatabaseException e) {\r
2430                         throw new ServiceException(e);\r
2431                 }\r
2432         }\r
2433 \r
2434         @Override\r
2435         public Set<Resource> getSupertypes(final Resource subject)\r
2436                         throws ServiceException {\r
2437                 try {\r
2438                         return session.syncRequest(new Read<Set<Resource>>() {\r
2439                                 \r
2440                                 @Override\r
2441                                 public Set<Resource> perform(ReadGraph graph) throws DatabaseException {\r
2442                 return graph.getSupertypes(subject);\r
2443                                 }\r
2444                         });\r
2445                 } catch (DatabaseException e) {\r
2446                         throw new ServiceException(e);\r
2447                 }\r
2448         }\r
2449 \r
2450         @Override\r
2451         public Set<Resource> getSuperrelations(final Resource subject)\r
2452                         throws ServiceException {\r
2453                 try {\r
2454                         return session.syncRequest(new Read<Set<Resource>>() {\r
2455                                 \r
2456                                 @Override\r
2457                                 public Set<Resource> perform(ReadGraph graph) throws DatabaseException {\r
2458                 return graph.getSuperrelations(subject);\r
2459                                 }\r
2460                         });\r
2461                 } catch (DatabaseException e) {\r
2462                         throw new ServiceException(e);\r
2463                 }\r
2464         }\r
2465 \r
2466 //      @Override\r
2467 //      public Collection<Resource> getObjects(final Resource subject,\r
2468 //                      Resource relation)\r
2469 //                      throws ManyObjectsForFunctionalRelationException,\r
2470 //                      ServiceException {\r
2471 //              return graph.getObjects(subject, relation);\r
2472 //      }\r
2473 \r
2474         @Override\r
2475         public Collection<Resource> getAssertedObjects(final Resource subject, final Resource relation)\r
2476                         throws ManyObjectsForFunctionalRelationException,\r
2477                         ServiceException {\r
2478                 try {\r
2479                         return session.syncRequest(new Read<Collection<Resource>>() {\r
2480                                 \r
2481                                 @Override\r
2482                                 public Collection<Resource> perform(ReadGraph graph) throws DatabaseException {\r
2483                 return graph.getAssertedObjects(subject, relation);\r
2484                                 }\r
2485                         });\r
2486                 } catch (DatabaseException e) {\r
2487                         throw new ServiceException(e);\r
2488                 }\r
2489         }\r
2490 \r
2491         @Override\r
2492         public Resource getInverse(final Resource relation)\r
2493                         throws NoInverseException,\r
2494                         ManyObjectsForFunctionalRelationException, ServiceException {\r
2495                 try {\r
2496                         return session.syncRequest(new Read<Resource>() {\r
2497                                 \r
2498                                 @Override\r
2499                                 public Resource perform(ReadGraph graph) throws DatabaseException {\r
2500                 return graph.getInverse(relation);\r
2501                                 }\r
2502                         });\r
2503                 } catch (DatabaseException e) {\r
2504                         throw new ServiceException(e);\r
2505                 }\r
2506         }\r
2507 \r
2508         @Override\r
2509         public Resource getSingleObject(final Resource subject, final Resource relation)\r
2510                         throws NoSingleResultException,\r
2511                         ManyObjectsForFunctionalRelationException, ServiceException {\r
2512                 try {\r
2513                         return session.syncRequest(new Read<Resource>() {\r
2514                                 \r
2515                                 @Override\r
2516                                 public Resource perform(ReadGraph graph) throws DatabaseException {\r
2517                 return graph.getSingleObject(subject, relation);\r
2518                                 }\r
2519                         });\r
2520                 } catch (DatabaseException e) {\r
2521                         throw new ServiceException(e);\r
2522                 }\r
2523         }\r
2524 \r
2525         @Override\r
2526         public Statement getSingleStatement(final Resource subject, final Resource relation)\r
2527                         throws NoSingleResultException,\r
2528                         ManyObjectsForFunctionalRelationException, ServiceException {\r
2529                 try {\r
2530                         return session.syncRequest(new Read<Statement>() {\r
2531                                 \r
2532                                 @Override\r
2533                                 public Statement perform(ReadGraph graph) throws DatabaseException {\r
2534                 return graph.getSingleStatement(subject, relation);\r
2535                                 }\r
2536                         });\r
2537                 } catch (DatabaseException e) {\r
2538                         throw new ServiceException(e);\r
2539                 }\r
2540         }\r
2541 \r
2542         @Override\r
2543         public Resource getSingleType(final Resource subject)\r
2544                         throws NoSingleResultException, ServiceException {\r
2545                 try {\r
2546                         return session.syncRequest(new Read<Resource>() {\r
2547                                 \r
2548                                 @Override\r
2549                                 public Resource perform(ReadGraph graph) throws DatabaseException {\r
2550                 return graph.getSingleType(subject);\r
2551                                 }\r
2552                         });\r
2553                 } catch (DatabaseException e) {\r
2554                         throw new ServiceException(e);\r
2555                 }\r
2556         }\r
2557 \r
2558         @Override\r
2559         public Resource getSingleType(final Resource subject, final Resource baseType)\r
2560                         throws NoSingleResultException, ServiceException {\r
2561                 try {\r
2562                         return session.syncRequest(new Read<Resource>() {\r
2563                                 \r
2564                                 @Override\r
2565                                 public Resource perform(ReadGraph graph) throws DatabaseException {\r
2566                 return graph.getSingleType(subject, baseType);\r
2567                                 }\r
2568                         });\r
2569                 } catch (DatabaseException e) {\r
2570                         throw new ServiceException(e);\r
2571                 }\r
2572         }\r
2573 \r
2574         @Override\r
2575         public <T> T getValue(final Resource subject)\r
2576                         throws DoesNotContainValueException, ServiceException {\r
2577                 try {\r
2578                         return session.syncRequest(new Read<T>() {\r
2579                                 \r
2580                                 @Override\r
2581                                 public T perform(ReadGraph graph) throws DatabaseException {\r
2582                 return graph.getValue(subject);\r
2583                                 }\r
2584                         });\r
2585                 } catch (DatabaseException e) {\r
2586                         throw new ServiceException(e);\r
2587                 }\r
2588         }\r
2589 \r
2590         @Override\r
2591         public <T> T getValue(final Resource subject, final Binding binding)\r
2592                         throws DoesNotContainValueException, BindingException,\r
2593                         ServiceException {\r
2594                 try {\r
2595                         return session.syncRequest(new Read<T>() {\r
2596                                 \r
2597                                 @Override\r
2598                                 public T perform(ReadGraph graph) throws DatabaseException {\r
2599                 return graph.getValue(subject, binding);\r
2600                                 }\r
2601                         });\r
2602                 } catch (DatabaseException e) {\r
2603                         throw new ServiceException(e);\r
2604                 }\r
2605         }\r
2606 \r
2607         @Override\r
2608         public <T> T getRelatedValue(final Resource subject, final Resource relation)\r
2609                         throws NoSingleResultException, DoesNotContainValueException,\r
2610                         ServiceException {\r
2611                 try {\r
2612                         return session.syncRequest(new Read<T>() {\r
2613                                 \r
2614                                 @Override\r
2615                                 public T perform(ReadGraph graph) throws DatabaseException {\r
2616                 return graph.getRelatedValue(subject, relation);\r
2617                                 }\r
2618                         });\r
2619                 } catch (DatabaseException e) {\r
2620                         throw new ServiceException(e);\r
2621                 }\r
2622         }\r
2623 \r
2624         @Override\r
2625         public <T> T getRelatedValue(final Resource subject, final Resource relation,\r
2626                         final Binding binding) throws NoSingleResultException,\r
2627                         DoesNotContainValueException, BindingException,\r
2628                         ServiceException {\r
2629                 try {\r
2630                         return session.syncRequest(new Read<T>() {\r
2631                                 \r
2632                                 @Override\r
2633                                 public T perform(ReadGraph graph) throws DatabaseException {\r
2634                 return graph.getRelatedValue(subject, relation, binding);\r
2635                                 }\r
2636                         });\r
2637                 } catch (DatabaseException e) {\r
2638                         throw new ServiceException(e);\r
2639                 }\r
2640         }\r
2641 \r
2642         @Override\r
2643         public Resource getPossibleInverse(final Resource relation)\r
2644                         throws ManyObjectsForFunctionalRelationException,\r
2645                         ServiceException {\r
2646                 try {\r
2647                         return session.syncRequest(new Read<Resource>() {\r
2648                                 \r
2649                                 @Override\r
2650                                 public Resource perform(ReadGraph graph) throws DatabaseException {\r
2651                 return graph.getPossibleInverse(relation);\r
2652                                 }\r
2653                         });\r
2654                 } catch (DatabaseException e) {\r
2655                         throw new ServiceException(e);\r
2656                 }\r
2657         }\r
2658 \r
2659         @Override\r
2660         public Resource getPossibleObject(final Resource subject, final Resource relation)\r
2661                         throws ManyObjectsForFunctionalRelationException,\r
2662                         ServiceException {\r
2663                 try {\r
2664                         return session.syncRequest(new Read<Resource>() {\r
2665                                 \r
2666                                 @Override\r
2667                                 public Resource perform(ReadGraph graph) throws DatabaseException {\r
2668                 return graph.getPossibleObject(subject, relation);\r
2669                                 }\r
2670                         });\r
2671                 } catch (DatabaseException e) {\r
2672                         throw new ServiceException(e);\r
2673                 }\r
2674         }\r
2675 \r
2676         @Override\r
2677         public Statement getPossibleStatement(final Resource subject,\r
2678                         final Resource relation)\r
2679                         throws ManyObjectsForFunctionalRelationException,\r
2680                         ServiceException {\r
2681                 try {\r
2682                         return session.syncRequest(new Read<Statement>() {\r
2683                                 \r
2684                                 @Override\r
2685                                 public Statement perform(ReadGraph graph) throws DatabaseException {\r
2686                 return graph.getPossibleStatement(subject, relation);\r
2687                                 }\r
2688                         });\r
2689                 } catch (DatabaseException e) {\r
2690                         throw new ServiceException(e);\r
2691                 }\r
2692         }\r
2693 \r
2694         @Override\r
2695         public Resource getPossibleType(final Resource subject, final Resource baseType)\r
2696                         throws ServiceException {\r
2697                 try {\r
2698                         return session.syncRequest(new Read<Resource>() {\r
2699                                 \r
2700                                 @Override\r
2701                                 public Resource perform(ReadGraph graph) throws DatabaseException {\r
2702                 return graph.getPossibleType(subject, baseType);\r
2703                                 }\r
2704                         });\r
2705                 } catch (DatabaseException e) {\r
2706                         throw new ServiceException(e);\r
2707                 }\r
2708         }\r
2709 \r
2710         @Override\r
2711         public <T> T getPossibleValue(final Resource subject) throws ServiceException {\r
2712                 try {\r
2713                         return session.syncRequest(new Read<T>() {\r
2714                                 \r
2715                                 @Override\r
2716                                 public T perform(ReadGraph graph) throws DatabaseException {\r
2717                 return graph.getPossibleValue(subject);\r
2718                                 }\r
2719                         });\r
2720                 } catch (DatabaseException e) {\r
2721                         throw new ServiceException(e);\r
2722                 }\r
2723         }\r
2724 \r
2725         @Override\r
2726         public <T> T getPossibleValue(final Resource subject, final Binding binding)\r
2727                         throws BindingException, ServiceException {\r
2728                 try {\r
2729                         return session.syncRequest(new Read<T>() {\r
2730                                 \r
2731                                 @Override\r
2732                                 public T perform(ReadGraph graph) throws DatabaseException {\r
2733                 return graph.getPossibleValue(subject, binding);\r
2734                                 }\r
2735                         });\r
2736                 } catch (DatabaseException e) {\r
2737                         throw new ServiceException(e);\r
2738                 }\r
2739         }\r
2740 \r
2741         @Override\r
2742         public <T> T getPossibleRelatedValue(final Resource subject, final Resource relation)\r
2743                         throws ManyObjectsForFunctionalRelationException,\r
2744                         ServiceException {\r
2745                 try {\r
2746                         return session.syncRequest(new Read<T>() {\r
2747                                 \r
2748                                 @Override\r
2749                                 public T perform(ReadGraph graph) throws DatabaseException {\r
2750                 return graph.getPossibleRelatedValue(subject, relation);\r
2751                                 }\r
2752                         });\r
2753                 } catch (DatabaseException e) {\r
2754                         throw new ServiceException(e);\r
2755                 }\r
2756         }\r
2757 \r
2758         @Override\r
2759         public <T> T getPossibleRelatedValue(final Resource subject,\r
2760                         final Resource relation, final Binding binding)\r
2761                         throws ManyObjectsForFunctionalRelationException,\r
2762                         BindingException, ServiceException {\r
2763                 try {\r
2764                         return session.syncRequest(new Read<T>() {\r
2765                                 \r
2766                                 @Override\r
2767                                 public T perform(ReadGraph graph) throws DatabaseException {\r
2768                 return graph.getPossibleRelatedValue(subject, relation, binding);\r
2769                                 }\r
2770                         });\r
2771                 } catch (DatabaseException e) {\r
2772                         throw new ServiceException(e);\r
2773                 }\r
2774         }\r
2775 \r
2776         @Override\r
2777         public <T> T getPossibleAdapter(final Resource resource, final Class<T> clazz)\r
2778                         throws ValidationException, ServiceException {\r
2779                 try {\r
2780                         return session.syncRequest(new Read<T>() {\r
2781                                 \r
2782                                 @Override\r
2783                                 public T perform(ReadGraph graph) throws DatabaseException {\r
2784                 return graph.getPossibleAdapter(resource, clazz);\r
2785                                 }\r
2786                         });\r
2787                 } catch (DatabaseException e) {\r
2788                         throw new ServiceException(e);\r
2789                 }\r
2790         }\r
2791 \r
2792         @Override\r
2793         public <T> T getPossibleUniqueAdapter(final Resource resource, final Class<T> clazz)\r
2794                         throws ValidationException, ServiceException {\r
2795                 try {\r
2796                         return session.syncRequest(new Read<T>() {\r
2797                                 \r
2798                                 @Override\r
2799                                 public T perform(ReadGraph graph) throws DatabaseException {\r
2800                 return graph.getPossibleUniqueAdapter(resource, clazz);\r
2801                                 }\r
2802                         });\r
2803                 } catch (DatabaseException e) {\r
2804                         throw new ServiceException(e);\r
2805                 }\r
2806         }\r
2807 \r
2808         @Override\r
2809         public boolean isInstanceOf(final Resource resource, final Resource type)\r
2810                         throws ServiceException {\r
2811                 try {\r
2812                         return session.syncRequest(new Read<Boolean>() {\r
2813                                 \r
2814                                 @Override\r
2815                                 public Boolean perform(ReadGraph graph) throws DatabaseException {\r
2816                                         return graph.isInstanceOf(resource, type);\r
2817                                 }\r
2818                         });\r
2819                 } catch (DatabaseException e) {\r
2820                         throw new ServiceException(e);\r
2821                 }\r
2822         }\r
2823 \r
2824         @Override\r
2825         public boolean isInheritedFrom(final Resource resource, final Resource type)\r
2826                         throws ServiceException {\r
2827                 try {\r
2828                         return session.syncRequest(new Read<Boolean>() {\r
2829                                 \r
2830                                 @Override\r
2831                                 public Boolean perform(ReadGraph graph) throws DatabaseException {\r
2832                 return graph.isInheritedFrom(resource, type);\r
2833                                 }\r
2834                         });\r
2835                 } catch (DatabaseException e) {\r
2836                         throw new ServiceException(e);\r
2837                 }\r
2838         }\r
2839 \r
2840         @Override\r
2841         public boolean isSubrelationOf(final Resource resource, final Resource relation)\r
2842                         throws ServiceException {\r
2843                 try {\r
2844                         return session.syncRequest(new Read<Boolean>() {\r
2845                                 \r
2846                                 @Override\r
2847                                 public Boolean perform(ReadGraph graph) throws DatabaseException {\r
2848                 return graph.isSubrelationOf(resource, relation);\r
2849                                 }\r
2850                         });\r
2851                 } catch (DatabaseException e) {\r
2852                         throw new ServiceException(e);\r
2853                 }\r
2854         }\r
2855 \r
2856         @Override\r
2857         public boolean hasStatement(final Resource subject) throws ServiceException {\r
2858                 try {\r
2859                         return session.syncRequest(new Read<Boolean>() {\r
2860                                 \r
2861                                 @Override\r
2862                                 public Boolean perform(ReadGraph graph) throws DatabaseException {\r
2863                 return graph.hasStatement(subject);\r
2864                                 }\r
2865                         });\r
2866                 } catch (DatabaseException e) {\r
2867                         throw new ServiceException(e);\r
2868                 }\r
2869         }\r
2870 \r
2871         @Override\r
2872         public boolean hasStatement(final Resource subject, final Resource relation)\r
2873                         throws ServiceException {\r
2874                 try {\r
2875                         return session.syncRequest(new Read<Boolean>() {\r
2876                                 \r
2877                                 @Override\r
2878                                 public Boolean perform(ReadGraph graph) throws DatabaseException {\r
2879                 return graph.hasStatement(subject, relation);\r
2880                                 }\r
2881                         });\r
2882                 } catch (DatabaseException e) {\r
2883                         throw new ServiceException(e);\r
2884                 }\r
2885         }\r
2886 \r
2887         @Override\r
2888         public boolean hasStatement(final Resource subject, final Resource relation,\r
2889                         final Resource object) throws ServiceException {\r
2890                 try {\r
2891                         return session.syncRequest(new Read<Boolean>() {\r
2892                                 \r
2893                                 @Override\r
2894                                 public Boolean perform(ReadGraph graph) throws DatabaseException {\r
2895                 return graph.hasStatement(subject, relation, object);\r
2896                                 }\r
2897                         });\r
2898                 } catch (DatabaseException e) {\r
2899                         throw new ServiceException(e);\r
2900                 }\r
2901         }\r
2902 \r
2903         @Override\r
2904         public boolean hasValue(final Resource subject) throws ServiceException {\r
2905                 try {\r
2906                         return session.syncRequest(new Read<Boolean>() {\r
2907                                 \r
2908                                 @Override\r
2909                                 public Boolean perform(ReadGraph graph) throws DatabaseException {\r
2910                 return graph.hasValue(subject);\r
2911                                 }\r
2912                         });\r
2913                 } catch (DatabaseException e) {\r
2914                         throw new ServiceException(e);\r
2915                 }\r
2916         }\r
2917 \r
2918         @Override\r
2919         public Datatype getDataType(final Resource subject) throws DatabaseException {\r
2920                 try {\r
2921                         return session.syncRequest(new Read<Datatype>() {\r
2922                                 \r
2923                                 @Override\r
2924                                 public Datatype perform(ReadGraph graph) throws DatabaseException {\r
2925                 return graph.getDataType(subject);\r
2926                                 }\r
2927                         });\r
2928                 } catch (DatabaseException e) {\r
2929                         throw new ServiceException(e);\r
2930                 }\r
2931         }\r
2932 \r
2933         @Override\r
2934         public <T extends Accessor> T getAccessor(final Resource subject)\r
2935                         throws DatabaseException {\r
2936                 try {\r
2937                         return session.syncRequest(new Read<T>() {\r
2938                                 \r
2939                                 @Override\r
2940                                 public T perform(ReadGraph graph) throws DatabaseException {\r
2941                 return graph.getAccessor(subject);\r
2942                                 }\r
2943                         });\r
2944                 } catch (DatabaseException e) {\r
2945                         throw new ServiceException(e);\r
2946                 }\r
2947         }\r
2948 \r
2949     @Override\r
2950     public RandomAccessBinary getRandomAccessBinary(final Resource subject)\r
2951     throws DatabaseException {\r
2952         try {\r
2953             return session.syncRequest(new Read<RandomAccessBinary>() {\r
2954                 @Override\r
2955                 public RandomAccessBinary perform(ReadGraph graph) throws DatabaseException {\r
2956                     return graph.getRandomAccessBinary(subject);\r
2957                 }\r
2958             });\r
2959         } catch (DatabaseException e) {\r
2960             throw new ServiceException(e);\r
2961         }\r
2962     }\r
2963 \r
2964     @Override\r
2965         public <T> T syncRequest(Read<T> request) throws DatabaseException {\r
2966                 return session.syncRequest(request);\r
2967         }\r
2968 \r
2969         @Override\r
2970         public <T> T syncRequest(Read<T> request, AsyncListener<T> procedure)\r
2971                         throws DatabaseException {\r
2972                 return session.syncRequest(request, procedure);\r
2973         }\r
2974 \r
2975         @Override\r
2976         public <T> T syncRequest(Read<T> request, SyncListener<T> procedure)\r
2977                         throws DatabaseException {\r
2978                 return session.syncRequest(request, procedure);\r
2979         }\r
2980 \r
2981         @Override\r
2982         public <T> T syncRequest(Read<T> request, Listener<T> procedure)\r
2983                         throws DatabaseException {\r
2984                 return session.syncRequest(request, procedure);\r
2985         }\r
2986 \r
2987         @Override\r
2988         public <T> T syncRequest(Read<T> request, AsyncProcedure<T> procedure)\r
2989                         throws DatabaseException {\r
2990                 return session.syncRequest(request, procedure);\r
2991         }\r
2992 \r
2993         @Override\r
2994         public <T> T syncRequest(Read<T> request, SyncProcedure<T> procedure)\r
2995                         throws DatabaseException {\r
2996                 return session.syncRequest(request, procedure);\r
2997         }\r
2998 \r
2999         @Override\r
3000         public <T> T syncRequest(Read<T> request, Procedure<T> procedure)\r
3001                         throws DatabaseException {\r
3002                 return session.syncRequest(request, procedure);\r
3003         }\r
3004 \r
3005         @Override\r
3006         public <T> T syncRequest(AsyncRead<T> request) throws DatabaseException {\r
3007                 return session.syncRequest(request);\r
3008         }\r
3009 \r
3010         @Override\r
3011         public <T> T syncRequest(AsyncRead<T> request,\r
3012                         AsyncListener<T> procedure) throws DatabaseException {\r
3013                 return session.syncRequest(request, procedure);\r
3014         }\r
3015 \r
3016         @Override\r
3017         public <T> T syncRequest(AsyncRead<T> request, SyncListener<T> procedure)\r
3018                         throws DatabaseException {\r
3019                 return session.syncRequest(request, procedure);\r
3020         }\r
3021 \r
3022         @Override\r
3023         public <T> T syncRequest(AsyncRead<T> request, Listener<T> procedure)\r
3024                         throws DatabaseException {\r
3025                 return session.syncRequest(request, procedure);\r
3026         }\r
3027 \r
3028         @Override\r
3029         public <T> T syncRequest(AsyncRead<T> request,\r
3030                         AsyncProcedure<T> procedure) throws DatabaseException {\r
3031                 return session.syncRequest(request, procedure);\r
3032         }\r
3033 \r
3034         @Override\r
3035         public <T> T syncRequest(AsyncRead<T> request,\r
3036                         SyncProcedure<T> procedure) throws DatabaseException {\r
3037                 return session.syncRequest(request, procedure);\r
3038         }\r
3039 \r
3040         @Override\r
3041         public <T> T syncRequest(AsyncRead<T> request, Procedure<T> procedure)\r
3042                         throws DatabaseException {\r
3043                 return session.syncRequest(request, procedure);\r
3044         }\r
3045 \r
3046         @Override\r
3047         public <T> Collection<T> syncRequest(MultiRead<T> request)\r
3048                         throws DatabaseException {\r
3049                 return session.syncRequest(request);\r
3050         }\r
3051 \r
3052         @Override\r
3053         public <T> Collection<T> syncRequest(MultiRead<T> request,\r
3054                         AsyncMultiListener<T> procedure) throws DatabaseException {\r
3055                 return session.syncRequest(request, procedure);\r
3056         }\r
3057 \r
3058         @Override\r
3059         public <T> Collection<T> syncRequest(MultiRead<T> request,\r
3060                         SyncMultiListener<T> procedure) throws DatabaseException {\r
3061                 return session.syncRequest(request, procedure);\r
3062         }\r
3063 \r
3064         @Override\r
3065         public <T> Collection<T> syncRequest(MultiRead<T> request,\r
3066                         MultiListener<T> procedure) throws DatabaseException {\r
3067                 return session.syncRequest(request, procedure);\r
3068         }\r
3069 \r
3070         @Override\r
3071         public <T> Collection<T> syncRequest(MultiRead<T> request,\r
3072                         AsyncMultiProcedure<T> procedure) throws DatabaseException {\r
3073                 return session.syncRequest(request, procedure);\r
3074         }\r
3075 \r
3076         @Override\r
3077         public <T> Collection<T> syncRequest(MultiRead<T> request,\r
3078                         SyncMultiProcedure<T> procedure) throws DatabaseException {\r
3079                 return session.syncRequest(request, procedure);\r
3080         }\r
3081 \r
3082         @Override\r
3083         public <T> Collection<T> syncRequest(MultiRead<T> request,\r
3084                         MultiProcedure<T> procedure) throws DatabaseException {\r
3085                 return session.syncRequest(request, procedure);\r
3086         }\r
3087 \r
3088         @Override\r
3089         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request)\r
3090                         throws DatabaseException {\r
3091                 return session.syncRequest(request);\r
3092         }\r
3093 \r
3094         @Override\r
3095         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,\r
3096                         AsyncMultiListener<T> procedure) throws DatabaseException {\r
3097                 return session.syncRequest(request, procedure);\r
3098         }\r
3099 \r
3100         @Override\r
3101         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,\r
3102                         SyncMultiListener<T> procedure) throws DatabaseException {\r
3103                 return session.syncRequest(request, procedure);\r
3104         }\r
3105 \r
3106         @Override\r
3107         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,\r
3108                         MultiListener<T> procedure) throws DatabaseException {\r
3109                 return session.syncRequest(request, procedure);\r
3110         }\r
3111 \r
3112         @Override\r
3113         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,\r
3114                         AsyncMultiProcedure<T> procedure) throws DatabaseException {\r
3115                 return session.syncRequest(request, procedure);\r
3116         }\r
3117 \r
3118         @Override\r
3119         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,\r
3120                         SyncMultiProcedure<T> procedure) throws DatabaseException {\r
3121                 return session.syncRequest(request, procedure);\r
3122         }\r
3123 \r
3124         @Override\r
3125         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,\r
3126                         MultiProcedure<T> procedure) throws DatabaseException {\r
3127                 return session.syncRequest(request, procedure);\r
3128         }\r
3129 \r
3130         @Override\r
3131         public <T> T syncRequest(ExternalRead<T> request)\r
3132                         throws DatabaseException {\r
3133                 return session.syncRequest(request);\r
3134         }\r
3135 \r
3136         @Override\r
3137         public <T> T syncRequest(ExternalRead<T> request, Listener<T> procedure)\r
3138                         throws DatabaseException {\r
3139                 return session.syncRequest(request, procedure);\r
3140         }\r
3141 \r
3142         @Override\r
3143         public <T> T syncRequest(ExternalRead<T> request, Procedure<T> procedure)\r
3144                         throws DatabaseException {\r
3145                 return session.syncRequest(request, procedure);\r
3146         }\r
3147 \r
3148         @Override\r
3149         public void syncRequest(Write request) throws DatabaseException {\r
3150                 session.syncRequest(request);\r
3151         }\r
3152 \r
3153         @Override\r
3154         public void syncRequest(DelayedWrite request) throws DatabaseException {\r
3155                 session.syncRequest(request);\r
3156         }\r
3157 \r
3158         @Override\r
3159         public void syncRequest(WriteOnly r) throws DatabaseException {\r
3160                 session.syncRequest(r);\r
3161         }\r
3162 \r
3163         @Override\r
3164         public <T> T syncRequest(WriteResult<T> request)\r
3165                         throws DatabaseException {\r
3166                 return session.syncRequest(request);\r
3167         }\r
3168 \r
3169         @Override\r
3170         public <T> T syncRequest(DelayedWriteResult<T> request)\r
3171                         throws DatabaseException {\r
3172                 return session.syncRequest(request);\r
3173         }\r
3174 \r
3175         @Override\r
3176         public <T> T syncRequest(WriteOnlyResult<T> r) throws DatabaseException {\r
3177                 return session.syncRequest(r);\r
3178         }\r
3179 \r
3180         @Override\r
3181         public void forURI(final Resource resource, final AsyncListener<String> procedure) {\r
3182                 try {\r
3183                         session.syncRequest(new ReadRequest() {\r
3184                                 \r
3185                                 @Override\r
3186                                 public void run(ReadGraph graph) throws DatabaseException {\r
3187                 graph.forURI(resource, procedure);\r
3188                                 }\r
3189                         });\r
3190                 } catch (DatabaseException e) {\r
3191                         \r
3192                 }\r
3193         }\r
3194 \r
3195         @Override\r
3196         public void forURI(final Resource resource, final SyncListener<String> procedure) {\r
3197                 try {\r
3198                         session.syncRequest(new ReadRequest() {\r
3199                                 \r
3200                                 @Override\r
3201                                 public void run(ReadGraph graph) throws DatabaseException {\r
3202                 graph.forURI(resource, procedure);\r
3203                                 }\r
3204                         });\r
3205                 } catch (DatabaseException e) {\r
3206                         \r
3207                 }\r
3208         }\r
3209 \r
3210         @Override\r
3211         public void forURI(final Resource resource, final Listener<String> procedure) {\r
3212                 try {\r
3213                         session.syncRequest(new ReadRequest() {\r
3214                                 \r
3215                                 @Override\r
3216                                 public void run(ReadGraph graph) throws DatabaseException {\r
3217                 graph.forURI(resource, procedure);\r
3218                                 }\r
3219                         });\r
3220                 } catch (DatabaseException e) {\r
3221                         \r
3222                 }\r
3223         }\r
3224 \r
3225         @Override\r
3226         public void forURI(final Resource resource, final AsyncProcedure<String> procedure) {\r
3227                 try {\r
3228                         session.syncRequest(new ReadRequest() {\r
3229                                 \r
3230                                 @Override\r
3231                                 public void run(ReadGraph graph) throws DatabaseException {\r
3232                 graph.forURI(resource, procedure);\r
3233                                 }\r
3234                         });\r
3235                 } catch (DatabaseException e) {\r
3236                         \r
3237                 }\r
3238         }\r
3239 \r
3240         @Override\r
3241         public void forURI(final Resource resource, final SyncProcedure<String> procedure) {\r
3242                 try {\r
3243                         session.syncRequest(new ReadRequest() {\r
3244                                 \r
3245                                 @Override\r
3246                                 public void run(ReadGraph graph) throws DatabaseException {\r
3247                 graph.forURI(resource, procedure);\r
3248                                 }\r
3249                         });\r
3250                 } catch (DatabaseException e) {\r
3251                         \r
3252                 }\r
3253         }\r
3254 \r
3255         @Override\r
3256         public void forURI(final Resource resource, final Procedure<String> procedure) {\r
3257                 try {\r
3258                         session.syncRequest(new ReadRequest() {\r
3259                                 \r
3260                                 @Override\r
3261                                 public void run(ReadGraph graph) throws DatabaseException {\r
3262                 graph.forURI(resource, procedure);\r
3263                                 }\r
3264                         });\r
3265                 } catch (DatabaseException e) {\r
3266                         \r
3267                 }\r
3268         }\r
3269 \r
3270         @Override\r
3271         public void forResource(final String id, final AsyncListener<Resource> procedure) {\r
3272                 try {\r
3273                         session.syncRequest(new ReadRequest() {\r
3274                                 \r
3275                                 @Override\r
3276                                 public void run(ReadGraph graph) throws DatabaseException {\r
3277                 graph.forResource(id, procedure);\r
3278                                 }\r
3279                         });\r
3280                 } catch (DatabaseException e) {\r
3281                         \r
3282                 }\r
3283         }\r
3284 \r
3285         @Override\r
3286         public void forResource(final String id, final SyncListener<Resource> procedure) {\r
3287                 try {\r
3288                         session.syncRequest(new ReadRequest() {\r
3289                                 \r
3290                                 @Override\r
3291                                 public void run(ReadGraph graph) throws DatabaseException {\r
3292                 graph.forResource(id, procedure);\r
3293                                 }\r
3294                         });\r
3295                 } catch (DatabaseException e) {\r
3296                         \r
3297                 }\r
3298         }\r
3299 \r
3300         @Override\r
3301         public void forResource(final String id, final Listener<Resource> procedure) {\r
3302                 try {\r
3303                         session.syncRequest(new ReadRequest() {\r
3304                                 \r
3305                                 @Override\r
3306                                 public void run(ReadGraph graph) throws DatabaseException {\r
3307                 graph.forResource(id, procedure);\r
3308                                 }\r
3309                         });\r
3310                 } catch (DatabaseException e) {\r
3311                         \r
3312                 }\r
3313         }\r
3314 \r
3315         @Override\r
3316         public void forResource(final String id, final AsyncProcedure<Resource> procedure) {\r
3317                 try {\r
3318                         session.syncRequest(new ReadRequest() {\r
3319                                 \r
3320                                 @Override\r
3321                                 public void run(ReadGraph graph) throws DatabaseException {\r
3322                 graph.forResource(id, procedure);\r
3323                                 }\r
3324                         });\r
3325                 } catch (DatabaseException e) {\r
3326                         \r
3327                 }\r
3328         }\r
3329 \r
3330         @Override\r
3331         public void forResource(final String id, final SyncProcedure<Resource> procedure) {\r
3332                 try {\r
3333                         session.syncRequest(new ReadRequest() {\r
3334                                 \r
3335                                 @Override\r
3336                                 public void run(ReadGraph graph) throws DatabaseException {\r
3337                 graph.forResource(id, procedure);\r
3338                                 }\r
3339                         });\r
3340                 } catch (DatabaseException e) {\r
3341                         \r
3342                 }\r
3343         }\r
3344 \r
3345         @Override\r
3346         public void forResource(final String id, final Procedure<Resource> procedure) {\r
3347                 try {\r
3348                         session.syncRequest(new ReadRequest() {\r
3349                                 \r
3350                                 @Override\r
3351                                 public void run(ReadGraph graph) throws DatabaseException {\r
3352                 graph.forResource(id, procedure);\r
3353                                 }\r
3354                         });\r
3355                 } catch (DatabaseException e) {\r
3356                         \r
3357                 }\r
3358         }\r
3359 \r
3360         @Override\r
3361         public void forStatementSet(final Resource subject, final Resource relation,\r
3362                         final AsyncSetListener<Statement> procedure) {\r
3363                 try {\r
3364                         session.syncRequest(new ReadRequest() {\r
3365                                 \r
3366                                 @Override\r
3367                                 public void run(ReadGraph graph) throws DatabaseException {\r
3368                 graph.forStatementSet(subject, relation, procedure);\r
3369                                 }\r
3370                         });\r
3371                 } catch (DatabaseException e) {\r
3372                         \r
3373                 }\r
3374         }\r
3375 \r
3376         @Override\r
3377         public void forStatementSet(final Resource subject, final Resource relation,\r
3378                         final SyncSetListener<Statement> procedure) {\r
3379                 \r
3380                 try {\r
3381                         session.syncRequest(new ReadRequest() {\r
3382                                 \r
3383                                 @Override\r
3384                                 public void run(ReadGraph graph) throws DatabaseException {\r
3385                                         graph.forStatementSet(subject, relation, procedure);\r
3386                                 }\r
3387                         });\r
3388                 } catch (DatabaseException e) {\r
3389                         \r
3390                 }\r
3391         }\r
3392 \r
3393         @Override\r
3394         public void forStatementSet(final Resource subject, final Resource relation,\r
3395                         final SetListener<Statement> procedure) {\r
3396                 try {\r
3397                         session.syncRequest(new ReadRequest() {\r
3398                                 \r
3399                                 @Override\r
3400                                 public void run(ReadGraph graph) throws DatabaseException {\r
3401                 graph.forStatementSet(subject, relation, procedure);\r
3402                                 }\r
3403                         });\r
3404                 } catch (DatabaseException e) {\r
3405                         \r
3406                 }\r
3407         }\r
3408 \r
3409         @Override\r
3410         public void forPredicateSet(final Resource subject,\r
3411                         final AsyncSetListener<Resource> procedure) {\r
3412                 try {\r
3413                         session.syncRequest(new ReadRequest() {\r
3414                                 \r
3415                                 @Override\r
3416                                 public void run(ReadGraph graph) throws DatabaseException {\r
3417                 graph.forPredicateSet(subject, procedure);\r
3418                                 }\r
3419                         });\r
3420                 } catch (DatabaseException e) {\r
3421                         \r
3422                 }\r
3423         }\r
3424 \r
3425         @Override\r
3426         public void forPredicateSet(final Resource subject,\r
3427                         final SyncSetListener<Resource> procedure) {\r
3428                 try {\r
3429                         session.syncRequest(new ReadRequest() {\r
3430                                 \r
3431                                 @Override\r
3432                                 public void run(ReadGraph graph) throws DatabaseException {\r
3433                 graph.forPredicateSet(subject, procedure);\r
3434                                 }\r
3435                         });\r
3436                 } catch (DatabaseException e) {\r
3437                         \r
3438                 }\r
3439         }\r
3440 \r
3441         @Override\r
3442         public void forPredicateSet(final Resource subject,\r
3443                         final SetListener<Resource> procedure) {\r
3444                 try {\r
3445                         session.syncRequest(new ReadRequest() {\r
3446                                 \r
3447                                 @Override\r
3448                                 public void run(ReadGraph graph) throws DatabaseException {\r
3449                 graph.forPredicateSet(subject, procedure);\r
3450                                 }\r
3451                         });\r
3452                 } catch (DatabaseException e) {\r
3453                         \r
3454                 }\r
3455         }\r
3456 \r
3457         @Override\r
3458         public void forPrincipalTypeSet(final Resource subject,\r
3459                         final AsyncSetListener<Resource> procedure) {\r
3460                 try {\r
3461                         session.syncRequest(new ReadRequest() {\r
3462                                 \r
3463                                 @Override\r
3464                                 public void run(ReadGraph graph) throws DatabaseException {\r
3465                 graph.forPrincipalTypeSet(subject, procedure);\r
3466                                 }\r
3467                         });\r
3468                 } catch (DatabaseException e) {\r
3469                         \r
3470                 }\r
3471         }\r
3472 \r
3473         @Override\r
3474         public void forPrincipalTypeSet(final Resource subject,\r
3475                         final SyncSetListener<Resource> procedure) {\r
3476                 try {\r
3477                         session.syncRequest(new ReadRequest() {\r
3478                                 \r
3479                                 @Override\r
3480                                 public void run(ReadGraph graph) throws DatabaseException {\r
3481                                         graph.forPrincipalTypeSet(subject, procedure);\r
3482                                 }\r
3483                         });\r
3484                 } catch (DatabaseException e) {\r
3485                         \r
3486                 }\r
3487         }\r
3488 \r
3489         @Override\r
3490         public void forPrincipalTypeSet(final Resource subject,\r
3491                         final SetListener<Resource> procedure) {\r
3492                 try {\r
3493                         session.syncRequest(new ReadRequest() {\r
3494                                 \r
3495                                 @Override\r
3496                                 public void run(ReadGraph graph) throws DatabaseException {\r
3497                 graph.forPrincipalTypeSet(subject, procedure);\r
3498                                 }\r
3499                         });\r
3500                 } catch (DatabaseException e) {\r
3501                         \r
3502                 }\r
3503         }\r
3504 \r
3505         @Override\r
3506         public void forTypes(final Resource subject,\r
3507                         final AsyncListener<Set<Resource>> procedure) {\r
3508                 try {\r
3509                         session.syncRequest(new ReadRequest() {\r
3510                                 \r
3511                                 @Override\r
3512                                 public void run(ReadGraph graph) throws DatabaseException {\r
3513                 graph.forTypes(subject, procedure);\r
3514                                 }\r
3515                         });\r
3516                 } catch (DatabaseException e) {\r
3517                         \r
3518                 }\r
3519         }\r
3520 \r
3521         @Override\r
3522         public void forTypes(final Resource subject,\r
3523                         final SyncListener<Set<Resource>> procedure) {\r
3524                 try {\r
3525                         session.syncRequest(new ReadRequest() {\r
3526                                 \r
3527                                 @Override\r
3528                                 public void run(ReadGraph graph) throws DatabaseException {\r
3529                 graph.forTypes(subject, procedure);\r
3530                                 }\r
3531                         });\r
3532                 } catch (DatabaseException e) {\r
3533                         \r
3534                 }\r
3535         }\r
3536 \r
3537         @Override\r
3538         public void forTypes(final Resource subject, final Listener<Set<Resource>> procedure) {\r
3539                 try {\r
3540                         session.syncRequest(new ReadRequest() {\r
3541                                 \r
3542                                 @Override\r
3543                                 public void run(ReadGraph graph) throws DatabaseException {\r
3544                 graph.forTypes(subject, procedure);             \r
3545                                 }\r
3546                         });\r
3547                 } catch (DatabaseException e) {\r
3548                         \r
3549                 }\r
3550         }\r
3551 \r
3552         @Override\r
3553         public void forTypes(final Resource subject,\r
3554                         final AsyncProcedure<Set<Resource>> procedure) {\r
3555                 try {\r
3556                         session.syncRequest(new ReadRequest() {\r
3557                                 \r
3558                                 @Override\r
3559                                 public void run(ReadGraph graph) throws DatabaseException {\r
3560                 graph.forTypes(subject, procedure);             \r
3561                                 }\r
3562                         });\r
3563                 } catch (DatabaseException e) {\r
3564                         \r
3565                 }\r
3566         }\r
3567 \r
3568         @Override\r
3569         public void forTypes(final Resource subject,\r
3570                         final SyncProcedure<Set<Resource>> procedure) {\r
3571                 try {\r
3572                         session.syncRequest(new ReadRequest() {\r
3573                                 \r
3574                                 @Override\r
3575                                 public void run(ReadGraph graph) throws DatabaseException {\r
3576                 graph.forTypes(subject, procedure);             \r
3577                                 }\r
3578                         });\r
3579                 } catch (DatabaseException e) {\r
3580                         \r
3581                 }\r
3582         }\r
3583 \r
3584         @Override\r
3585         public void forTypes(final Resource subject,\r
3586                         final Procedure<Set<Resource>> procedure) {\r
3587                 try {\r
3588                         session.syncRequest(new ReadRequest() {\r
3589                                 \r
3590                                 @Override\r
3591                                 public void run(ReadGraph graph) throws DatabaseException {\r
3592                 graph.forTypes(subject, procedure);     \r
3593                                 }\r
3594                         });\r
3595                 } catch (DatabaseException e) {\r
3596                         \r
3597                 }\r
3598         }\r
3599 \r
3600         @Override\r
3601         public void forSupertypes(final Resource subject,\r
3602                         final AsyncListener<Set<Resource>> procedure) {\r
3603                 try {\r
3604                         session.syncRequest(new ReadRequest() {\r
3605                                 \r
3606                                 @Override\r
3607                                 public void run(ReadGraph graph) throws DatabaseException {\r
3608                 graph.forSupertypes(subject, procedure);\r
3609                                 }\r
3610                         });\r
3611                 } catch (DatabaseException e) {\r
3612                         \r
3613                 }\r
3614         }\r
3615 \r
3616         @Override\r
3617         public void forSupertypes(final Resource subject,\r
3618                         final SyncListener<Set<Resource>> procedure) {\r
3619                 try {\r
3620                         session.syncRequest(new ReadRequest() {\r
3621                                 \r
3622                                 @Override\r
3623                                 public void run(ReadGraph graph) throws DatabaseException {\r
3624                 graph.forSupertypes(subject, procedure);\r
3625                                 }\r
3626                         });\r
3627                 } catch (DatabaseException e) {\r
3628                         \r
3629                 }\r
3630         }\r
3631 \r
3632         @Override\r
3633         public void forSupertypes(final Resource subject,\r
3634                         final Listener<Set<Resource>> procedure) {\r
3635                 try {\r
3636                         session.syncRequest(new ReadRequest() {\r
3637                                 \r
3638                                 @Override\r
3639                                 public void run(ReadGraph graph) throws DatabaseException {\r
3640                 graph.forSupertypes(subject, procedure);\r
3641                                 }\r
3642                         });\r
3643                 } catch (DatabaseException e) {\r
3644                         \r
3645                 }\r
3646         }\r
3647 \r
3648         @Override\r
3649         public void forSupertypes(final Resource subject,\r
3650                         final AsyncProcedure<Set<Resource>> procedure) {\r
3651                 try {\r
3652                         session.syncRequest(new ReadRequest() {\r
3653                                 \r
3654                                 @Override\r
3655                                 public void run(ReadGraph graph) throws DatabaseException {\r
3656                 graph.forSupertypes(subject, procedure);\r
3657                                 }\r
3658                         });\r
3659                 } catch (DatabaseException e) {\r
3660                         \r
3661                 }\r
3662         }\r
3663 \r
3664         @Override\r
3665         public void forSupertypes(final Resource subject,\r
3666                         final SyncProcedure<Set<Resource>> procedure) {\r
3667                 try {\r
3668                         session.syncRequest(new ReadRequest() {\r
3669                                 \r
3670                                 @Override\r
3671                                 public void run(ReadGraph graph) throws DatabaseException {\r
3672                 graph.forSupertypes(subject, procedure);\r
3673                                 }\r
3674                         });\r
3675                 } catch (DatabaseException e) {\r
3676                         \r
3677                 }\r
3678         }\r
3679 \r
3680         @Override\r
3681         public void forSupertypes(final Resource subject,\r
3682                         final Procedure<Set<Resource>> procedure) {\r
3683                 try {\r
3684                         session.syncRequest(new ReadRequest() {\r
3685                                 \r
3686                                 @Override\r
3687                                 public void run(ReadGraph graph) throws DatabaseException {\r
3688                 graph.forSupertypes(subject, procedure);\r
3689                                 }\r
3690                         });\r
3691                 } catch (DatabaseException e) {\r
3692                         \r
3693                 }\r
3694         }\r
3695 \r
3696         @Override\r
3697         public void forPossibleSuperrelation(final Resource subject,\r
3698                         final AsyncProcedure<Resource> procedure) {\r
3699                 try {\r
3700                         session.syncRequest(new ReadRequest() {\r
3701                                 \r
3702                                 @Override\r
3703                                 public void run(ReadGraph graph) throws DatabaseException {\r
3704                 graph.forPossibleSuperrelation(subject, procedure);     \r
3705                                 }\r
3706                         });\r
3707                 } catch (DatabaseException e) {\r
3708                         \r
3709                 }\r
3710         }\r
3711 \r
3712         @Override\r
3713         public void forSuperrelations(final Resource subject,\r
3714                         final AsyncListener<Set<Resource>> procedure) {\r
3715                 try {\r
3716                         session.syncRequest(new ReadRequest() {\r
3717                                 \r
3718                                 @Override\r
3719                                 public void run(ReadGraph graph) throws DatabaseException {\r
3720                 graph.forSuperrelations(subject, procedure);\r
3721                                 }\r
3722                         });\r
3723                 } catch (DatabaseException e) {\r
3724                         \r
3725                 }\r
3726         }\r
3727 \r
3728         @Override\r
3729         public void forSuperrelations(final Resource subject,\r
3730                         final SyncListener<Set<Resource>> procedure) {\r
3731                 try {\r
3732                         session.syncRequest(new ReadRequest() {\r
3733                                 \r
3734                                 @Override\r
3735                                 public void run(ReadGraph graph) throws DatabaseException {\r
3736                 graph.forSuperrelations(subject, procedure);\r
3737                                 }\r
3738                         });\r
3739                 } catch (DatabaseException e) {\r
3740                         \r
3741                 }\r
3742         }\r
3743 \r
3744         @Override\r
3745         public void forSuperrelations(final Resource subject,\r
3746                         final Listener<Set<Resource>> procedure) {\r
3747                 try {\r
3748                         session.syncRequest(new ReadRequest() {\r
3749                                 \r
3750                                 @Override\r
3751                                 public void run(ReadGraph graph) throws DatabaseException {\r
3752                 graph.forSuperrelations(subject, procedure);\r
3753                                 }\r
3754                         });\r
3755                 } catch (DatabaseException e) {\r
3756                         \r
3757                 }\r
3758         }\r
3759 \r
3760         @Override\r
3761         public void forSuperrelations(final Resource subject,\r
3762                         final AsyncProcedure<Set<Resource>> procedure) {\r
3763                 try {\r
3764                         session.syncRequest(new ReadRequest() {\r
3765                                 \r
3766                                 @Override\r
3767                                 public void run(ReadGraph graph) throws DatabaseException {\r
3768                 graph.forSuperrelations(subject, procedure);\r
3769                                 }\r
3770                         });\r
3771                 } catch (DatabaseException e) {\r
3772                         \r
3773                 }\r
3774         }\r
3775 \r
3776         @Override\r
3777         public void forSuperrelations(final Resource subject,\r
3778                         final SyncProcedure<Set<Resource>> procedure) {\r
3779                 try {\r
3780                         session.syncRequest(new ReadRequest() {\r
3781                                 \r
3782                                 @Override\r
3783                                 public void run(ReadGraph graph) throws DatabaseException {\r
3784                 graph.forSuperrelations(subject, procedure);\r
3785                                 }\r
3786                         });\r
3787                 } catch (DatabaseException e) {\r
3788                         \r
3789                 }\r
3790         }\r
3791 \r
3792         @Override\r
3793         public void forSuperrelations(final Resource subject,\r
3794                         final Procedure<Set<Resource>> procedure) {\r
3795                 try {\r
3796                         session.syncRequest(new ReadRequest() {\r
3797                                 \r
3798                                 @Override\r
3799                                 public void run(ReadGraph graph) throws DatabaseException {\r
3800                 graph.forSuperrelations(subject, procedure);\r
3801                                 }\r
3802                         });\r
3803                 } catch (DatabaseException e) {\r
3804                         \r
3805                 }\r
3806         }\r
3807 \r
3808         @Override\r
3809         public void forObjectSet(final Resource subject, final Resource relation,\r
3810                         final AsyncSetListener<Resource> procedure) {\r
3811                 try {\r
3812                         session.syncRequest(new ReadRequest() {\r
3813                                 \r
3814                                 @Override\r
3815                                 public void run(ReadGraph graph) throws DatabaseException {\r
3816                 graph.forObjectSet(subject, relation, procedure);\r
3817                                 }\r
3818                         });\r
3819                 } catch (DatabaseException e) {\r
3820                         \r
3821                 }\r
3822         }\r
3823 \r
3824         @Override\r
3825         public void forObjectSet(final Resource subject, final Resource relation,\r
3826                         final SyncSetListener<Resource> procedure) {\r
3827                 try {\r
3828                         session.syncRequest(new ReadRequest() {\r
3829                                 \r
3830                                 @Override\r
3831                                 public void run(ReadGraph graph) throws DatabaseException {\r
3832                 graph.forObjectSet(subject, relation, procedure);\r
3833                                 }\r
3834                         });\r
3835                 } catch (DatabaseException e) {\r
3836                         \r
3837                 }\r
3838         }\r
3839 \r
3840         @Override\r
3841         public void forObjectSet(final Resource subject, final Resource relation,\r
3842                         final SetListener<Resource> procedure) {\r
3843                 try {\r
3844                         session.syncRequest(new ReadRequest() {\r
3845                                 \r
3846                                 @Override\r
3847                                 public void run(ReadGraph graph) throws DatabaseException {\r
3848                 graph.forObjectSet(subject, relation, procedure);\r
3849                                 }\r
3850                         });\r
3851                 } catch (DatabaseException e) {\r
3852                         \r
3853                 }\r
3854         }\r
3855 \r
3856         @Override\r
3857         public void forInverse(final Resource relation,\r
3858                         final SyncListener<Resource> procedure) {\r
3859                 try {\r
3860                         session.syncRequest(new ReadRequest() {\r
3861                                 \r
3862                                 @Override\r
3863                                 public void run(ReadGraph graph) throws DatabaseException {\r
3864                 graph.forInverse(relation, procedure);\r
3865                                 }\r
3866                         });\r
3867                 } catch (DatabaseException e) {\r
3868                         \r
3869                 }\r
3870         }\r
3871 \r
3872         @Override\r
3873         public void forInverse(final Resource relation, final Listener<Resource> procedure) {\r
3874                 try {\r
3875                         session.syncRequest(new ReadRequest() {\r
3876                                 \r
3877                                 @Override\r
3878                                 public void run(ReadGraph graph) throws DatabaseException {\r
3879                 graph.forInverse(relation, procedure);\r
3880                                 }\r
3881                         });\r
3882                 } catch (DatabaseException e) {\r
3883                         \r
3884                 }\r
3885         }\r
3886 \r
3887         @Override\r
3888         public void forInverse(final Resource relation,\r
3889                         final AsyncProcedure<Resource> procedure) {\r
3890                 try {\r
3891                         session.syncRequest(new ReadRequest() {\r
3892                                 \r
3893                                 @Override\r
3894                                 public void run(ReadGraph graph) throws DatabaseException {\r
3895                 graph.forInverse(relation, procedure);\r
3896                                 }\r
3897                         });\r
3898                 } catch (DatabaseException e) {\r
3899                         \r
3900                 }\r
3901         }\r
3902 \r
3903         @Override\r
3904         public void forInverse(final Resource relation,\r
3905                         final SyncProcedure<Resource> procedure) {\r
3906                 try {\r
3907                         session.syncRequest(new ReadRequest() {\r
3908                                 \r
3909                                 @Override\r
3910                                 public void run(ReadGraph graph) throws DatabaseException {\r
3911                 graph.forInverse(relation, procedure);\r
3912                                 }\r
3913                         });\r
3914                 } catch (DatabaseException e) {\r
3915                         \r
3916                 }\r
3917         }\r
3918 \r
3919         @Override\r
3920         public void forInverse(final Resource relation, final Procedure<Resource> procedure) {\r
3921                 try {\r
3922                         session.syncRequest(new ReadRequest() {\r
3923                                 \r
3924                                 @Override\r
3925                                 public void run(ReadGraph graph) throws DatabaseException {\r
3926                 graph.forInverse(relation, procedure);\r
3927                                 }\r
3928                         });\r
3929                 } catch (DatabaseException e) {\r
3930                         \r
3931                 }\r
3932         }\r
3933 \r
3934         @Override\r
3935         public void forSingleObject(final Resource subject, final Resource relation,\r
3936                         final AsyncListener<Resource> procedure) {\r
3937                 try {\r
3938                         session.syncRequest(new ReadRequest() {\r
3939                                 \r
3940                                 @Override\r
3941                                 public void run(ReadGraph graph) throws DatabaseException {\r
3942                 graph.forSingleObject(subject, relation, procedure);\r
3943                                 }\r
3944                         });\r
3945                 } catch (DatabaseException e) {\r
3946                         \r
3947                 }\r
3948         }\r
3949 \r
3950         @Override\r
3951         public void forSingleObject(final Resource subject, final Resource relation,\r
3952                         final SyncListener<Resource> procedure) {\r
3953                 try {\r
3954                         session.syncRequest(new ReadRequest() {\r
3955                                 \r
3956                                 @Override\r
3957                                 public void run(ReadGraph graph) throws DatabaseException {\r
3958                 graph.forSingleObject(subject, relation, procedure);\r
3959                                 }\r
3960                         });\r
3961                 } catch (DatabaseException e) {\r
3962                         \r
3963                 }\r
3964         }\r
3965 \r
3966         @Override\r
3967         public void forSingleObject(final Resource subject, final Resource relation,\r
3968                         final Listener<Resource> procedure) {\r
3969                 try {\r
3970                         session.syncRequest(new ReadRequest() {\r
3971                                 \r
3972                                 @Override\r
3973                                 public void run(ReadGraph graph) throws DatabaseException {\r
3974                 graph.forSingleObject(subject, relation, procedure);            \r
3975                                 }\r
3976                         });\r
3977                 } catch (DatabaseException e) {\r
3978                         \r
3979                 }\r
3980         }\r
3981 \r
3982         @Override\r
3983         public void forSingleObject(final Resource subject, final Resource relation,\r
3984                         final AsyncProcedure<Resource> procedure) {\r
3985                 try {\r
3986                         session.syncRequest(new ReadRequest() {\r
3987                                 \r
3988                                 @Override\r
3989                                 public void run(ReadGraph graph) throws DatabaseException {\r
3990                 graph.forSingleObject(subject, relation, procedure);\r
3991                                 }\r
3992                         });\r
3993                 } catch (DatabaseException e) {\r
3994                         \r
3995                 }\r
3996         }\r
3997 \r
3998         @Override\r
3999         public void forSingleObject(final Resource subject, final Resource relation,\r
4000                         final SyncProcedure<Resource> procedure) {\r
4001                 try {\r
4002                         session.syncRequest(new ReadRequest() {\r
4003                                 \r
4004                                 @Override\r
4005                                 public void run(ReadGraph graph) throws DatabaseException {\r
4006                 graph.forSingleObject(subject, relation, procedure);\r
4007                                 }\r
4008                         });\r
4009                 } catch (DatabaseException e) {\r
4010                         \r
4011                 }\r
4012         }\r
4013 \r
4014         @Override\r
4015         public void forSingleObject(final Resource subject, final Resource relation,\r
4016                         final Procedure<Resource> procedure) {\r
4017                 try {\r
4018                         session.syncRequest(new ReadRequest() {\r
4019                                 \r
4020                                 @Override\r
4021                                 public void run(ReadGraph graph) throws DatabaseException {\r
4022                 graph.forSingleObject(subject, relation, procedure);\r
4023                                 }\r
4024                         });\r
4025                 } catch (DatabaseException e) {\r
4026                         \r
4027                 }\r
4028         }\r
4029 \r
4030         @Override\r
4031         public void forSingleStatement(final Resource subject, final Resource relation,\r
4032                         final AsyncListener<Statement> procedure) {\r
4033                 try {\r
4034                         session.syncRequest(new ReadRequest() {\r
4035                                 \r
4036                                 @Override\r
4037                                 public void run(ReadGraph graph) throws DatabaseException {\r
4038                 graph.forSingleStatement(subject, relation, procedure);\r
4039                                 }\r
4040                         });\r
4041                 } catch (DatabaseException e) {\r
4042                         \r
4043                 }\r
4044         }\r
4045 \r
4046         @Override\r
4047         public void forSingleStatement(final Resource subject, final Resource relation,\r
4048                         final SyncListener<Statement> procedure) {\r
4049                 try {\r
4050                         session.syncRequest(new ReadRequest() {\r
4051                                 \r
4052                                 @Override\r
4053                                 public void run(ReadGraph graph) throws DatabaseException {\r
4054                 graph.forSingleStatement(subject, relation, procedure);\r
4055                                 }\r
4056                         });\r
4057                 } catch (DatabaseException e) {\r
4058                         \r
4059                 }\r
4060         }\r
4061 \r
4062         @Override\r
4063         public void forSingleStatement(final Resource subject, final Resource relation,\r
4064                         final Listener<Statement> procedure) {\r
4065                 try {\r
4066                         session.syncRequest(new ReadRequest() {\r
4067                                 \r
4068                                 @Override\r
4069                                 public void run(ReadGraph graph) throws DatabaseException {\r
4070                                         graph.forSingleStatement(subject, relation, procedure);\r
4071                                 }\r
4072                         });\r
4073                 } catch (DatabaseException e) {\r
4074                         \r
4075                 }\r
4076                                 \r
4077         }\r
4078 \r
4079         @Override\r
4080         public void forSingleStatement(final Resource subject, final Resource relation,\r
4081                         final AsyncProcedure<Statement> procedure) {\r
4082                 try {\r
4083                         session.syncRequest(new ReadRequest() {\r
4084                                 \r
4085                                 @Override\r
4086                                 public void run(ReadGraph graph) throws DatabaseException {\r
4087                 graph.forSingleStatement(subject, relation, procedure);\r
4088                                 }\r
4089                         });\r
4090                 } catch (DatabaseException e) {\r
4091                         \r
4092                 }\r
4093         }\r
4094 \r
4095         @Override\r
4096         public void forSingleStatement(final Resource subject, final Resource relation,\r
4097                         final SyncProcedure<Statement> procedure) {\r
4098                 try {\r
4099                         session.syncRequest(new ReadRequest() {\r
4100                                 \r
4101                                 @Override\r
4102                                 public void run(ReadGraph graph) throws DatabaseException {\r
4103                 graph.forSingleStatement(subject, relation, procedure);\r
4104                                 }\r
4105                         });\r
4106                 } catch (DatabaseException e) {\r
4107                         \r
4108                 }\r
4109         }\r
4110 \r
4111         @Override\r
4112         public void forSingleStatement(final Resource subject, final Resource relation,\r
4113                         final Procedure<Statement> procedure) {\r
4114                 try {\r
4115                         session.syncRequest(new ReadRequest() {\r
4116                                 \r
4117                                 @Override\r
4118                                 public void run(ReadGraph graph) throws DatabaseException {\r
4119                 graph.forSingleStatement(subject, relation, procedure);\r
4120                                 }\r
4121                         });\r
4122                 } catch (DatabaseException e) {\r
4123                         \r
4124                 }\r
4125         }\r
4126 \r
4127         @Override\r
4128         public void forSingleType(final Resource subject,\r
4129                         final AsyncListener<Resource> procedure) {\r
4130                 try {\r
4131                         session.syncRequest(new ReadRequest() {\r
4132                                 \r
4133                                 @Override\r
4134                                 public void run(ReadGraph graph) throws DatabaseException {\r
4135                 graph.forSingleType(subject, procedure);\r
4136                                 }\r
4137                         });\r
4138                 } catch (DatabaseException e) {\r
4139                         \r
4140                 }\r
4141         }\r
4142 \r
4143         @Override\r
4144         public void forSingleType(final Resource subject,\r
4145                         final SyncListener<Resource> procedure) {\r
4146                 try {\r
4147                         session.syncRequest(new ReadRequest() {\r
4148                                 \r
4149                                 @Override\r
4150                                 public void run(ReadGraph graph) throws DatabaseException {\r
4151                 graph.forSingleType(subject, procedure);\r
4152                                 }\r
4153                         });\r
4154                 } catch (DatabaseException e) {\r
4155                         \r
4156                 }\r
4157         }\r
4158 \r
4159         @Override\r
4160         public void forSingleType(final Resource subject, final Listener<Resource> procedure) {\r
4161                 try {\r
4162                         session.syncRequest(new ReadRequest() {\r
4163                                 \r
4164                                 @Override\r
4165                                 public void run(ReadGraph graph) throws DatabaseException {\r
4166                 graph.forSingleType(subject, procedure);\r
4167                                 }\r
4168                         });\r
4169                 } catch (DatabaseException e) {\r
4170                         \r
4171                 }\r
4172         }\r
4173 \r
4174         @Override\r
4175         public void forSingleType(final Resource subject,\r
4176                         final AsyncProcedure<Resource> procedure) {\r
4177                 try {\r
4178                         session.syncRequest(new ReadRequest() {\r
4179                                 \r
4180                                 @Override\r
4181                                 public void run(ReadGraph graph) throws DatabaseException {\r
4182                 graph.forSingleType(subject, procedure);\r
4183                                 }\r
4184                         });\r
4185                 } catch (DatabaseException e) {\r
4186                         \r
4187                 }\r
4188         }\r
4189 \r
4190         @Override\r
4191         public void forSingleType(final Resource subject,\r
4192                         final SyncProcedure<Resource> procedure) {\r
4193                 try {\r
4194                         session.syncRequest(new ReadRequest() {\r
4195                                 \r
4196                                 @Override\r
4197                                 public void run(ReadGraph graph) throws DatabaseException {\r
4198                 graph.forSingleType(subject, procedure);\r
4199                                 }\r
4200                         });\r
4201                 } catch (DatabaseException e) {\r
4202                         \r
4203                 }\r
4204         }\r
4205 \r
4206         @Override\r
4207         public void forSingleType(final Resource subject,\r
4208                         final Procedure<Resource> procedure) {\r
4209                 try {\r
4210                         session.syncRequest(new ReadRequest() {\r
4211                                 \r
4212                                 @Override\r
4213                                 public void run(ReadGraph graph) throws DatabaseException {\r
4214                 graph.forSingleType(subject, procedure);\r
4215                                 }\r
4216                         });\r
4217                 } catch (DatabaseException e) {\r
4218                         \r
4219                 }\r
4220         }\r
4221 \r
4222         @Override\r
4223         public void forSingleType(final Resource subject, final Resource baseType,\r
4224                         final AsyncListener<Resource> procedure) {\r
4225                 try {\r
4226                         session.syncRequest(new ReadRequest() {\r
4227                                 \r
4228                                 @Override\r
4229                                 public void run(ReadGraph graph) throws DatabaseException {\r
4230                 graph.forSingleType(subject, baseType, procedure);\r
4231                                 }\r
4232                         });\r
4233                 } catch (DatabaseException e) {\r
4234                         \r
4235                 }\r
4236         }\r
4237 \r
4238         @Override\r
4239         public void forSingleType(final Resource subject, final Resource baseType,\r
4240                         final SyncListener<Resource> procedure) {\r
4241                 try {\r
4242                         session.syncRequest(new ReadRequest() {\r
4243                                 \r
4244                                 @Override\r
4245                                 public void run(ReadGraph graph) throws DatabaseException {\r
4246                 graph.forSingleType(subject, baseType, procedure);\r
4247                                 }\r
4248                         });\r
4249                 } catch (DatabaseException e) {\r
4250                         \r
4251                 }\r
4252         }\r
4253 \r
4254         @Override\r
4255         public void forSingleType(final Resource subject, final Resource baseType,\r
4256                         final Listener<Resource> procedure) {\r
4257                 try {\r
4258                         session.syncRequest(new ReadRequest() {\r
4259                                 \r
4260                                 @Override\r
4261                                 public void run(ReadGraph graph) throws DatabaseException {\r
4262                 graph.forSingleType(subject, baseType, procedure);\r
4263                                 }\r
4264                         });\r
4265                 } catch (DatabaseException e) {\r
4266                         \r
4267                 }\r
4268         }\r
4269 \r
4270         @Override\r
4271         public void forSingleType(final Resource subject, final Resource baseType,\r
4272                         final AsyncProcedure<Resource> procedure) {\r
4273                 try {\r
4274                         session.syncRequest(new ReadRequest() {\r
4275                                 \r
4276                                 @Override\r
4277                                 public void run(ReadGraph graph) throws DatabaseException {\r
4278                 graph.forSingleType(subject, baseType, procedure);\r
4279                                 }\r
4280                         });\r
4281                 } catch (DatabaseException e) {\r
4282                         \r
4283                 }\r
4284         }\r
4285 \r
4286         @Override\r
4287         public void forSingleType(final Resource subject, final Resource baseType,\r
4288                         final SyncProcedure<Resource> procedure) {\r
4289                 try {\r
4290                         session.syncRequest(new ReadRequest() {\r
4291                                 \r
4292                                 @Override\r
4293                                 public void run(ReadGraph graph) throws DatabaseException {\r
4294                 graph.forSingleType(subject, baseType, procedure);\r
4295                                 }\r
4296                         });\r
4297                 } catch (DatabaseException e) {\r
4298                         \r
4299                 }\r
4300         }\r
4301 \r
4302         @Override\r
4303         public void forSingleType(final Resource subject, final Resource baseType,\r
4304                         final Procedure<Resource> procedure) {\r
4305                 try {\r
4306                         session.syncRequest(new ReadRequest() {\r
4307                                 \r
4308                                 @Override\r
4309                                 public void run(ReadGraph graph) throws DatabaseException {\r
4310                 graph.forSingleType(subject, baseType, procedure);\r
4311                                 }\r
4312                         });\r
4313                 } catch (DatabaseException e) {\r
4314                         \r
4315                 }\r
4316         }\r
4317 \r
4318         @Override\r
4319         public <T> void forValue(final Resource subject, final AsyncListener<T> procedure) {\r
4320                 try {\r
4321                         session.syncRequest(new ReadRequest() {\r
4322                                 \r
4323                                 @Override\r
4324                                 public void run(ReadGraph graph) throws DatabaseException {\r
4325                 graph.forValue(subject, procedure);\r
4326                                 }\r
4327                         });\r
4328                 } catch (DatabaseException e) {\r
4329                         \r
4330                 }\r
4331         }\r
4332 \r
4333         @Override\r
4334         public <T> void forValue(final Resource subject, final SyncListener<T> procedure) {\r
4335                 try {\r
4336                         session.syncRequest(new ReadRequest() {\r
4337                                 \r
4338                                 @Override\r
4339                                 public void run(ReadGraph graph) throws DatabaseException {\r
4340                 graph.forValue(subject, procedure);\r
4341                                 }\r
4342                         });\r
4343                 } catch (DatabaseException e) {\r
4344                         \r
4345                 }\r
4346         }\r
4347 \r
4348         @Override\r
4349         public <T> void forValue(final Resource subject, final Listener<T> procedure) {\r
4350                 try {\r
4351                         session.syncRequest(new ReadRequest() {\r
4352                                 \r
4353                                 @Override\r
4354                                 public void run(ReadGraph graph) throws DatabaseException {\r
4355                 graph.forValue(subject, procedure);\r
4356                                 }\r
4357                         });\r
4358                 } catch (DatabaseException e) {\r
4359                         \r
4360                 }\r
4361         }\r
4362 \r
4363         @Override\r
4364         public <T> void forValue(final Resource subject, final AsyncProcedure<T> procedure) {\r
4365                 try {\r
4366                         session.syncRequest(new ReadRequest() {\r
4367                                 \r
4368                                 @Override\r
4369                                 public void run(ReadGraph graph) throws DatabaseException {\r
4370                 graph.forValue(subject, procedure);\r
4371                                 }\r
4372                         });\r
4373                 } catch (DatabaseException e) {\r
4374                         \r
4375                 }\r
4376         }\r
4377 \r
4378         @Override\r
4379         public <T> void forValue(final Resource subject, final SyncProcedure<T> procedure) {\r
4380                 try {\r
4381                         session.syncRequest(new ReadRequest() {\r
4382                                 \r
4383                                 @Override\r
4384                                 public void run(ReadGraph graph) throws DatabaseException {\r
4385                 graph.forValue(subject, procedure);\r
4386                                 }\r
4387                         });\r
4388                 } catch (DatabaseException e) {\r
4389                         \r
4390                 }\r
4391         }\r
4392 \r
4393         @Override\r
4394         public <T> void forValue(final Resource subject, final Procedure<T> procedure) {\r
4395                 try {\r
4396                         session.syncRequest(new ReadRequest() {\r
4397                                 \r
4398                                 @Override\r
4399                                 public void run(ReadGraph graph) throws DatabaseException {\r
4400                 graph.forValue(subject, procedure);\r
4401                                 }\r
4402                         });\r
4403                 } catch (DatabaseException e) {\r
4404                         \r
4405                 }\r
4406         }\r
4407 \r
4408         @Override\r
4409         public <T> void forValue(final Resource subject, final Binding binding,\r
4410                         final AsyncListener<T> procedure) {\r
4411                 try {\r
4412                         session.syncRequest(new ReadRequest() {\r
4413                                 \r
4414                                 @Override\r
4415                                 public void run(ReadGraph graph) throws DatabaseException {\r
4416                 graph.forValue(subject, binding, procedure);\r
4417                                 }\r
4418                         });\r
4419                 } catch (DatabaseException e) {\r
4420                         \r
4421                 }\r
4422         }\r
4423 \r
4424         @Override\r
4425         public <T> void forValue(final Resource subject, final Binding binding,\r
4426                         final SyncListener<T> procedure) {\r
4427                 try {\r
4428                         session.syncRequest(new ReadRequest() {\r
4429                                 \r
4430                                 @Override\r
4431                                 public void run(ReadGraph graph) throws DatabaseException {\r
4432                 graph.forValue(subject, binding, procedure);\r
4433                                 }\r
4434                         });\r
4435                 } catch (DatabaseException e) {\r
4436                         \r
4437                 }\r
4438         }\r
4439 \r
4440         @Override\r
4441         public <T> void forValue(final Resource subject, final Binding binding,\r
4442                         final Listener<T> procedure) {\r
4443                 try {\r
4444                         session.syncRequest(new ReadRequest() {\r
4445                                 \r
4446                                 @Override\r
4447                                 public void run(ReadGraph graph) throws DatabaseException {\r
4448                 graph.forValue(subject, binding, procedure);\r
4449                                 }\r
4450                         });\r
4451                 } catch (DatabaseException e) {\r
4452                         \r
4453                 }\r
4454         }\r
4455 \r
4456         @Override\r
4457         public <T> void forValue(final Resource subject, final Binding binding,\r
4458                         final AsyncProcedure<T> procedure) {\r
4459                 try {\r
4460                         session.syncRequest(new ReadRequest() {\r
4461                                 \r
4462                                 @Override\r
4463                                 public void run(ReadGraph graph) throws DatabaseException {\r
4464                 graph.forValue(subject, binding, procedure);\r
4465                                 }\r
4466                         });\r
4467                 } catch (DatabaseException e) {\r
4468                         \r
4469                 }\r
4470         }\r
4471 \r
4472         @Override\r
4473         public <T> void forValue(final Resource subject, final Binding binding,\r
4474                         final SyncProcedure<T> procedure) {\r
4475                 try {\r
4476                         session.syncRequest(new ReadRequest() {\r
4477                                 \r
4478                                 @Override\r
4479                                 public void run(ReadGraph graph) throws DatabaseException {\r
4480                 graph.forValue(subject, binding, procedure);\r
4481                                 }\r
4482                         });\r
4483                 } catch (DatabaseException e) {\r
4484                         \r
4485                 }\r
4486         }\r
4487 \r
4488         @Override\r
4489         public <T> void forValue(final Resource subject, final Binding binding,\r
4490                         final Procedure<T> procedure) {\r
4491                 try {\r
4492                         session.syncRequest(new ReadRequest() {\r
4493                                 \r
4494                                 @Override\r
4495                                 public void run(ReadGraph graph) throws DatabaseException {\r
4496                 graph.forValue(subject, binding, procedure);\r
4497                                 }\r
4498                         });\r
4499                 } catch (DatabaseException e) {\r
4500                         \r
4501                 }\r
4502         }\r
4503 \r
4504         @Override\r
4505         public <T> void forRelatedValue(final Resource subject, final Resource relation,\r
4506                         final AsyncListener<T> procedure) {\r
4507                 try {\r
4508                         session.syncRequest(new ReadRequest() {\r
4509                                 \r
4510                                 @Override\r
4511                                 public void run(ReadGraph graph) throws DatabaseException {\r
4512                 graph.forRelatedValue(subject, relation, procedure);\r
4513                                 }\r
4514                         });\r
4515                 } catch (DatabaseException e) {\r
4516                         \r
4517                 }\r
4518         }\r
4519 \r
4520         @Override\r
4521         public <T> void forRelatedValue(final Resource subject, final Resource relation,\r
4522                         final SyncListener<T> procedure) {\r
4523                 try {\r
4524                         session.syncRequest(new ReadRequest() {\r
4525                                 \r
4526                                 @Override\r
4527                                 public void run(ReadGraph graph) throws DatabaseException {\r
4528                 graph.forRelatedValue(subject, relation, procedure);\r
4529                                 }\r
4530                         });\r
4531                 } catch (DatabaseException e) {\r
4532                         \r
4533                 }\r
4534         }\r
4535 \r
4536         @Override\r
4537         public <T> void forRelatedValue(final Resource subject, final Resource relation,\r
4538                         final Listener<T> procedure) {\r
4539                 try {\r
4540                         session.syncRequest(new ReadRequest() {\r
4541                                 \r
4542                                 @Override\r
4543                                 public void run(ReadGraph graph) throws DatabaseException {\r
4544                 graph.forRelatedValue(subject, relation, procedure);\r
4545                                 }\r
4546                         });\r
4547                 } catch (DatabaseException e) {\r
4548                         \r
4549                 }\r
4550         }\r
4551 \r
4552         @Override\r
4553         public <T> void forRelatedValue(final Resource subject, final Resource relation,\r
4554                         final AsyncProcedure<T> procedure) {\r
4555                 try {\r
4556                         session.syncRequest(new ReadRequest() {\r
4557                                 \r
4558                                 @Override\r
4559                                 public void run(ReadGraph graph) throws DatabaseException {\r
4560                 graph.forRelatedValue(subject, relation, procedure);\r
4561                                 }\r
4562                         });\r
4563                 } catch (DatabaseException e) {\r
4564                         \r
4565                 }\r
4566         }\r
4567 \r
4568         @Override\r
4569         public <T> void forRelatedValue(final Resource subject, final Resource relation,\r
4570                         final SyncProcedure<T> procedure) {\r
4571                 try {\r
4572                         session.syncRequest(new ReadRequest() {\r
4573                                 \r
4574                                 @Override\r
4575                                 public void run(ReadGraph graph) throws DatabaseException {\r
4576                 graph.forRelatedValue(subject, relation, procedure);\r
4577                                 }\r
4578                         });\r
4579                 } catch (DatabaseException e) {\r
4580                         \r
4581                 }\r
4582         }\r
4583 \r
4584         @Override\r
4585         public <T> void forRelatedValue(final Resource subject, final Resource relation,\r
4586                         final Procedure<T> procedure) {\r
4587                 try {\r
4588                         session.syncRequest(new ReadRequest() {\r
4589                                 \r
4590                                 @Override\r
4591                                 public void run(ReadGraph graph) throws DatabaseException {\r
4592                 graph.forRelatedValue(subject, relation, procedure);\r
4593                                 }\r
4594                         });\r
4595                 } catch (DatabaseException e) {\r
4596                         \r
4597                 }\r
4598         }\r
4599 \r
4600         @Override\r
4601         public <T> void forRelatedValue(final Resource subject, final Resource relation,\r
4602                         final Binding binding, final AsyncListener<T> procedure) {\r
4603                 try {\r
4604                         session.syncRequest(new ReadRequest() {\r
4605                                 \r
4606                                 @Override\r
4607                                 public void run(ReadGraph graph) throws DatabaseException {\r
4608                 graph.forRelatedValue(subject, relation, binding, procedure);\r
4609                                 }\r
4610                         });\r
4611                 } catch (DatabaseException e) {\r
4612                         \r
4613                 }\r
4614         }\r
4615 \r
4616         @Override\r
4617         public <T> void forRelatedValue(final Resource subject, final Resource relation,\r
4618                         final Binding binding, final SyncListener<T> procedure) {\r
4619                 try {\r
4620                         session.syncRequest(new ReadRequest() {\r
4621                                 \r
4622                                 @Override\r
4623                                 public void run(ReadGraph graph) throws DatabaseException {\r
4624                 graph.forRelatedValue(subject, relation, binding, procedure);\r
4625                                 }\r
4626                         });\r
4627                 } catch (DatabaseException e) {\r
4628                         \r
4629                 }\r
4630         }\r
4631 \r
4632         @Override\r
4633         public <T> void forRelatedValue(final Resource subject, final Resource relation,\r
4634                         final Binding binding, final Listener<T> procedure) {\r
4635                 try {\r
4636                         session.syncRequest(new ReadRequest() {\r
4637                                 \r
4638                                 @Override\r
4639                                 public void run(ReadGraph graph) throws DatabaseException {\r
4640                 graph.forRelatedValue(subject, relation, binding, procedure);\r
4641                                 }\r
4642                         });\r
4643                 } catch (DatabaseException e) {\r
4644                         \r
4645                 }\r
4646         }\r
4647 \r
4648         @Override\r
4649         public <T> void forRelatedValue(final Resource subject, final Resource relation,\r
4650                         final Binding binding, final AsyncProcedure<T> procedure) {\r
4651                 try {\r
4652                         session.syncRequest(new ReadRequest() {\r
4653                                 \r
4654                                 @Override\r
4655                                 public void run(ReadGraph graph) throws DatabaseException {\r
4656                 graph.forRelatedValue(subject, relation, binding, procedure);\r
4657                                 }\r
4658                         });\r
4659                 } catch (DatabaseException e) {\r
4660                         \r
4661                 }\r
4662         }\r
4663 \r
4664         @Override\r
4665         public <T> void forRelatedValue(final Resource subject, final Resource relation,\r
4666                         final Binding binding, final SyncProcedure<T> procedure) {\r
4667                 try {\r
4668                         session.syncRequest(new ReadRequest() {\r
4669                                 \r
4670                                 @Override\r
4671                                 public void run(ReadGraph graph) throws DatabaseException {\r
4672                 graph.forRelatedValue(subject, relation, binding, procedure);\r
4673                                 }\r
4674                         });\r
4675                 } catch (DatabaseException e) {\r
4676                         \r
4677                 }\r
4678         }\r
4679 \r
4680         @Override\r
4681         public <T> void forRelatedValue(final Resource subject, final Resource relation,\r
4682                         final Binding binding, final Procedure<T> procedure) {\r
4683                 try {\r
4684                         session.syncRequest(new ReadRequest() {\r
4685                                 \r
4686                                 @Override\r
4687                                 public void run(ReadGraph graph) throws DatabaseException {\r
4688                 graph.forRelatedValue(subject, relation, binding, procedure);\r
4689                                 }\r
4690                         });\r
4691                 } catch (DatabaseException e) {\r
4692                         \r
4693                 }\r
4694         }\r
4695 \r
4696         @Override\r
4697         public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,\r
4698                         final AsyncListener<T> procedure) {\r
4699                 try {\r
4700                         session.syncRequest(new ReadRequest() {\r
4701                                 \r
4702                                 @Override\r
4703                                 public void run(ReadGraph graph) throws DatabaseException {\r
4704                 graph.forUniqueAdapted(resource, clazz, procedure);\r
4705                                 }\r
4706                         });\r
4707                 } catch (DatabaseException e) {\r
4708                         \r
4709                 }\r
4710         }\r
4711 \r
4712         @Override\r
4713         public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,\r
4714                         final SyncListener<T> procedure) {\r
4715                 try {\r
4716                         session.syncRequest(new ReadRequest() {\r
4717                                 \r
4718                                 @Override\r
4719                                 public void run(ReadGraph graph) throws DatabaseException {\r
4720                 graph.forUniqueAdapted(resource, clazz, procedure);\r
4721                                 }\r
4722                         });\r
4723                 } catch (DatabaseException e) {\r
4724                         \r
4725                 }\r
4726         }\r
4727 \r
4728         @Override\r
4729         public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,\r
4730                         final Listener<T> procedure) {\r
4731                 try {\r
4732                         session.syncRequest(new ReadRequest() {\r
4733                                 \r
4734                                 @Override\r
4735                                 public void run(ReadGraph graph) throws DatabaseException {\r
4736                 graph.forUniqueAdapted(resource, clazz, procedure);\r
4737                                 }\r
4738                         });\r
4739                 } catch (DatabaseException e) {\r
4740                         \r
4741                 }\r
4742         }\r
4743 \r
4744         @Override\r
4745         public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,\r
4746                         final AsyncProcedure<T> procedure) {\r
4747                 try {\r
4748                         session.syncRequest(new ReadRequest() {\r
4749                                 \r
4750                                 @Override\r
4751                                 public void run(ReadGraph graph) throws DatabaseException {\r
4752                 graph.forUniqueAdapted(resource, clazz, procedure);\r
4753                                 }\r
4754                         });\r
4755                 } catch (DatabaseException e) {\r
4756                         \r
4757                 }\r
4758         }\r
4759 \r
4760         @Override\r
4761         public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,\r
4762                         final SyncProcedure<T> procedure) {\r
4763                 try {\r
4764                         session.syncRequest(new ReadRequest() {\r
4765                                 \r
4766                                 @Override\r
4767                                 public void run(ReadGraph graph) throws DatabaseException {\r
4768                 graph.forUniqueAdapted(resource, clazz, procedure);\r
4769                                 }\r
4770                         });\r
4771                 } catch (DatabaseException e) {\r
4772                         \r
4773                 }\r
4774         }\r
4775 \r
4776         @Override\r
4777         public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,\r
4778                         final Procedure<T> procedure) {\r
4779                 try {\r
4780                         session.syncRequest(new ReadRequest() {\r
4781                                 \r
4782                                 @Override\r
4783                                 public void run(ReadGraph graph) throws DatabaseException {\r
4784                 graph.forUniqueAdapted(resource, clazz, procedure);\r
4785                                 }\r
4786                         });\r
4787                 } catch (DatabaseException e) {\r
4788                         \r
4789                 }\r
4790         }\r
4791 \r
4792         @Override\r
4793         public void forPossibleInverse(final Resource relation,\r
4794                         final AsyncListener<Resource> procedure) {\r
4795                 try {\r
4796                         session.syncRequest(new ReadRequest() {\r
4797                                 \r
4798                                 @Override\r
4799                                 public void run(ReadGraph graph) throws DatabaseException {\r
4800                 graph.forPossibleInverse(relation, procedure);\r
4801                                 }\r
4802                         });\r
4803                 } catch (DatabaseException e) {\r
4804                         \r
4805                 }\r
4806         }\r
4807 \r
4808         @Override\r
4809         public void forPossibleInverse(final Resource relation,\r
4810                         final SyncListener<Resource> procedure) {\r
4811                 try {\r
4812                         session.syncRequest(new ReadRequest() {\r
4813                                 \r
4814                                 @Override\r
4815                                 public void run(ReadGraph graph) throws DatabaseException {\r
4816                 graph.forPossibleInverse(relation, procedure);\r
4817                                 }\r
4818                         });\r
4819                 } catch (DatabaseException e) {\r
4820                         \r
4821                 }\r
4822         }\r
4823 \r
4824         @Override\r
4825         public void forPossibleInverse(final Resource relation,\r
4826                         final Listener<Resource> procedure) {\r
4827                 try {\r
4828                         session.syncRequest(new ReadRequest() {\r
4829                                 \r
4830                                 @Override\r
4831                                 public void run(ReadGraph graph) throws DatabaseException {\r
4832                 graph.forPossibleInverse(relation, procedure);\r
4833                                 }\r
4834                         });\r
4835                 } catch (DatabaseException e) {\r
4836                         \r
4837                 }\r
4838         }\r
4839 \r
4840         @Override\r
4841         public void forPossibleInverse(final Resource relation,\r
4842                         final AsyncProcedure<Resource> procedure) {\r
4843                 try {\r
4844                         session.syncRequest(new ReadRequest() {\r
4845                                 \r
4846                                 @Override\r
4847                                 public void run(ReadGraph graph) throws DatabaseException {\r
4848                 graph.forPossibleInverse(relation, procedure);\r
4849                                 }\r
4850                         });\r
4851                 } catch (DatabaseException e) {\r
4852                         \r
4853                 }\r
4854         }\r
4855 \r
4856         @Override\r
4857         public void forPossibleInverse(final Resource relation,\r
4858                         final SyncProcedure<Resource> procedure) {\r
4859                 try {\r
4860                         session.syncRequest(new ReadRequest() {\r
4861                                 \r
4862                                 @Override\r
4863                                 public void run(ReadGraph graph) throws DatabaseException {\r
4864                 graph.forPossibleInverse(relation, procedure);\r
4865                                 }\r
4866                         });\r
4867                 } catch (DatabaseException e) {\r
4868                         \r
4869                 }\r
4870         }\r
4871 \r
4872         @Override\r
4873         public void forPossibleInverse(final Resource relation,\r
4874                         final Procedure<Resource> procedure) {\r
4875                 try {\r
4876                         session.syncRequest(new ReadRequest() {\r
4877                                 \r
4878                                 @Override\r
4879                                 public void run(ReadGraph graph) throws DatabaseException {\r
4880                 graph.forPossibleInverse(relation, procedure);\r
4881                                 }\r
4882                         });\r
4883                 } catch (DatabaseException e) {\r
4884                         \r
4885                 }\r
4886         }\r
4887 \r
4888         @Override\r
4889         public void forPossibleObject(final Resource subject, final Resource relation,\r
4890                         final AsyncListener<Resource> procedure) {\r
4891                 try {\r
4892                         session.syncRequest(new ReadRequest() {\r
4893                                 \r
4894                                 @Override\r
4895                                 public void run(ReadGraph graph) throws DatabaseException {\r
4896                 graph.forPossibleObject(subject, relation, procedure);\r
4897                                 }\r
4898                         });\r
4899                 } catch (DatabaseException e) {\r
4900                         \r
4901                 }\r
4902         }\r
4903 \r
4904         @Override\r
4905         public void forPossibleObject(final Resource subject, final Resource relation,\r
4906                         final SyncListener<Resource> procedure) {\r
4907                 try {\r
4908                         session.syncRequest(new ReadRequest() {\r
4909                                 \r
4910                                 @Override\r
4911                                 public void run(ReadGraph graph) throws DatabaseException {\r
4912                 graph.forPossibleObject(subject, relation, procedure);\r
4913                                 }\r
4914                         });\r
4915                 } catch (DatabaseException e) {\r
4916                         \r
4917                 }\r
4918         }\r
4919 \r
4920         @Override\r
4921         public void forPossibleObject(final Resource subject, final Resource relation,\r
4922                         final Listener<Resource> procedure) {\r
4923                 try {\r
4924                         session.syncRequest(new ReadRequest() {\r
4925                                 \r
4926                                 @Override\r
4927                                 public void run(ReadGraph graph) throws DatabaseException {\r
4928                 graph.forPossibleObject(subject, relation, procedure);\r
4929                                 }\r
4930                         });\r
4931                 } catch (DatabaseException e) {\r
4932                         \r
4933                 }\r
4934         }\r
4935 \r
4936         @Override\r
4937         public void forPossibleObject(final Resource subject, final Resource relation,\r
4938                         final AsyncProcedure<Resource> procedure) {\r
4939                 try {\r
4940                         session.syncRequest(new ReadRequest() {\r
4941                                 \r
4942                                 @Override\r
4943                                 public void run(ReadGraph graph) throws DatabaseException {\r
4944                 graph.forPossibleObject(subject, relation, procedure);\r
4945                                 }\r
4946                         });\r
4947                 } catch (DatabaseException e) {\r
4948                         \r
4949                 }\r
4950         }\r
4951 \r
4952         @Override\r
4953         public void forPossibleObject(final Resource subject, final Resource relation,\r
4954                         final SyncProcedure<Resource> procedure) {\r
4955                 try {\r
4956                         session.syncRequest(new ReadRequest() {\r
4957                                 \r
4958                                 @Override\r
4959                                 public void run(ReadGraph graph) throws DatabaseException {\r
4960                 graph.forPossibleObject(subject, relation, procedure);\r
4961                                 }\r
4962                         });\r
4963                 } catch (DatabaseException e) {\r
4964                         \r
4965                 }\r
4966         }\r
4967 \r
4968         @Override\r
4969         public void forPossibleObject(final Resource subject, final Resource relation,\r
4970                         final Procedure<Resource> procedure) {\r
4971                 try {\r
4972                         session.syncRequest(new ReadRequest() {\r
4973                                 \r
4974                                 @Override\r
4975                                 public void run(ReadGraph graph) throws DatabaseException {\r
4976                 graph.forPossibleObject(subject, relation, procedure);\r
4977                                 }\r
4978                         });\r
4979                 } catch (DatabaseException e) {\r
4980                         \r
4981                 }\r
4982         }\r
4983 \r
4984         @Override\r
4985         public void forPossibleStatement(final Resource subject, final Resource relation,\r
4986                         final AsyncListener<Statement> procedure) {\r
4987                 try {\r
4988                         session.syncRequest(new ReadRequest() {\r
4989                                 \r
4990                                 @Override\r
4991                                 public void run(ReadGraph graph) throws DatabaseException {\r
4992                 graph.forPossibleStatement(subject, relation, procedure);\r
4993                                 }\r
4994                         });\r
4995                 } catch (DatabaseException e) {\r
4996                         \r
4997                 }\r
4998         }\r
4999 \r
5000         @Override\r
5001         public void forPossibleStatement(final Resource subject, final Resource relation,\r
5002                         final SyncListener<Statement> procedure) {\r
5003                 try {\r
5004                         session.syncRequest(new ReadRequest() {\r
5005                                 \r
5006                                 @Override\r
5007                                 public void run(ReadGraph graph) throws DatabaseException {\r
5008                 graph.forPossibleStatement(subject, relation, procedure);\r
5009                                 }\r
5010                         });\r
5011                 } catch (DatabaseException e) {\r
5012                         \r
5013                 }\r
5014         }\r
5015 \r
5016         @Override\r
5017         public void forPossibleStatement(final Resource subject, final Resource relation,\r
5018                         final Listener<Statement> procedure) {\r
5019                 try {\r
5020                         session.syncRequest(new ReadRequest() {\r
5021                                 \r
5022                                 @Override\r
5023                                 public void run(ReadGraph graph) throws DatabaseException {\r
5024                 graph.forPossibleStatement(subject, relation, procedure);\r
5025                                 }\r
5026                         });\r
5027                 } catch (DatabaseException e) {\r
5028                         \r
5029                 }\r
5030         }\r
5031 \r
5032         @Override\r
5033         public void forPossibleStatement(final Resource subject, final Resource relation,\r
5034                         final AsyncProcedure<Statement> procedure) {\r
5035                 try {\r
5036                         session.syncRequest(new ReadRequest() {\r
5037                                 \r
5038                                 @Override\r
5039                                 public void run(ReadGraph graph) throws DatabaseException {\r
5040                 graph.forPossibleStatement(subject, relation, procedure);\r
5041                                 }\r
5042                         });\r
5043                 } catch (DatabaseException e) {\r
5044                         \r
5045                 }\r
5046         }\r
5047 \r
5048         @Override\r
5049         public void forPossibleStatement(final Resource subject, final Resource relation,\r
5050                         final SyncProcedure<Statement> procedure) {\r
5051                 try {\r
5052                         session.syncRequest(new ReadRequest() {\r
5053                                 \r
5054                                 @Override\r
5055                                 public void run(ReadGraph graph) throws DatabaseException {\r
5056                 graph.forPossibleStatement(subject, relation, procedure);\r
5057                                 }\r
5058                         });\r
5059                 } catch (DatabaseException e) {\r
5060                         \r
5061                 }\r
5062         }\r
5063 \r
5064         @Override\r
5065         public void forPossibleStatement(final Resource subject, final Resource relation,\r
5066                         final Procedure<Statement> procedure) {\r
5067                 try {\r
5068                         session.syncRequest(new ReadRequest() {\r
5069                                 \r
5070                                 @Override\r
5071                                 public void run(ReadGraph graph) throws DatabaseException {\r
5072                 graph.forPossibleStatement(subject, relation, procedure);\r
5073                                 }\r
5074                         });\r
5075                 } catch (DatabaseException e) {\r
5076                         \r
5077                 }\r
5078         }\r
5079 \r
5080         @Override\r
5081         public void forPossibleType(final Resource subject, final Resource baseType,\r
5082                         final AsyncListener<Resource> procedure) {\r
5083                 try {\r
5084                         session.syncRequest(new ReadRequest() {\r
5085                                 \r
5086                                 @Override\r
5087                                 public void run(ReadGraph graph) throws DatabaseException {\r
5088                 graph.forPossibleType(subject, baseType, procedure);\r
5089                                 }\r
5090                         });\r
5091                 } catch (DatabaseException e) {\r
5092                         \r
5093                 }\r
5094         }\r
5095 \r
5096         @Override\r
5097         public void forPossibleType(final Resource subject, final Resource baseType,\r
5098                         final SyncListener<Resource> procedure) {\r
5099                 try {\r
5100                         session.syncRequest(new ReadRequest() {\r
5101                                 \r
5102                                 @Override\r
5103                                 public void run(ReadGraph graph) throws DatabaseException {\r
5104                 graph.forPossibleType(subject, baseType, procedure);\r
5105                                 }\r
5106                         });\r
5107                 } catch (DatabaseException e) {\r
5108                         \r
5109                 }\r
5110         }\r
5111 \r
5112         @Override\r
5113         public void forPossibleType(final Resource subject, final Resource baseType,\r
5114                         final Listener<Resource> procedure) {\r
5115                 try {\r
5116                         session.syncRequest(new ReadRequest() {\r
5117                                 \r
5118                                 @Override\r
5119                                 public void run(ReadGraph graph) throws DatabaseException {\r
5120                 graph.forPossibleType(subject, baseType, procedure);\r
5121                                 }\r
5122                         });\r
5123                 } catch (DatabaseException e) {\r
5124                         \r
5125                 }\r
5126         }\r
5127 \r
5128         @Override\r
5129         public void forPossibleType(final Resource subject, final Resource baseType,\r
5130                         final AsyncProcedure<Resource> procedure) {\r
5131                 try {\r
5132                         session.syncRequest(new ReadRequest() {\r
5133                                 \r
5134                                 @Override\r
5135                                 public void run(ReadGraph graph) throws DatabaseException {\r
5136                 graph.forPossibleType(subject, baseType, procedure);\r
5137                                 }\r
5138                         });\r
5139                 } catch (DatabaseException e) {\r
5140                         \r
5141                 }\r
5142         }\r
5143 \r
5144         @Override\r
5145         public void forPossibleType(final Resource subject, final Resource baseType,\r
5146                         final SyncProcedure<Resource> procedure) {\r
5147                 try {\r
5148                         session.syncRequest(new ReadRequest() {\r
5149                                 \r
5150                                 @Override\r
5151                                 public void run(ReadGraph graph) throws DatabaseException {\r
5152                 graph.forPossibleType(subject, baseType, procedure);\r
5153                                 }\r
5154                         });\r
5155                 } catch (DatabaseException e) {\r
5156                         \r
5157                 }\r
5158         }\r
5159 \r
5160         @Override\r
5161         public void forPossibleType(final Resource subject, final Resource baseType,\r
5162                         final Procedure<Resource> procedure) {\r
5163                 try {\r
5164                         session.syncRequest(new ReadRequest() {\r
5165                                 \r
5166                                 @Override\r
5167                                 public void run(ReadGraph graph) throws DatabaseException {\r
5168                 graph.forPossibleType(subject, baseType, procedure);\r
5169                                 }\r
5170                         });\r
5171                 } catch (DatabaseException e) {\r
5172                         \r
5173                 }\r
5174         }\r
5175 \r
5176         @Override\r
5177         public <T> void forPossibleValue(final Resource subject,\r
5178                         final AsyncListener<T> procedure) {\r
5179                 try {\r
5180                         session.syncRequest(new ReadRequest() {\r
5181                                 \r
5182                                 @Override\r
5183                                 public void run(ReadGraph graph) throws DatabaseException {\r
5184                 graph.forPossibleValue(subject, procedure);\r
5185                                 }\r
5186                         });\r
5187                 } catch (DatabaseException e) {\r
5188                         \r
5189                 }\r
5190         }\r
5191 \r
5192         @Override\r
5193         public <T> void forPossibleValue(final Resource subject,\r
5194                         final SyncListener<T> procedure) {\r
5195                 try {\r
5196                         session.syncRequest(new ReadRequest() {\r
5197                                 \r
5198                                 @Override\r
5199                                 public void run(ReadGraph graph) throws DatabaseException {\r
5200                 graph.forPossibleValue(subject, procedure);\r
5201                                 }\r
5202                         });\r
5203                 } catch (DatabaseException e) {\r
5204                         \r
5205                 }\r
5206         }\r
5207 \r
5208         @Override\r
5209         public <T> void forPossibleValue(final Resource subject, final Listener<T> procedure) {\r
5210                 try {\r
5211                         session.syncRequest(new ReadRequest() {\r
5212                                 \r
5213                                 @Override\r
5214                                 public void run(ReadGraph graph) throws DatabaseException {\r
5215                 graph.forPossibleValue(subject, procedure);\r
5216                                 }\r
5217                         });\r
5218                 } catch (DatabaseException e) {\r
5219                         \r
5220                 }\r
5221         }\r
5222 \r
5223         @Override\r
5224         public <T> void forPossibleValue(final Resource subject,\r
5225                         final AsyncProcedure<T> procedure) {\r
5226                 try {\r
5227                         session.syncRequest(new ReadRequest() {\r
5228                                 \r
5229                                 @Override\r
5230                                 public void run(ReadGraph graph) throws DatabaseException {\r
5231                 graph.forPossibleValue(subject, procedure);\r
5232                                 }\r
5233                         });\r
5234                 } catch (DatabaseException e) {\r
5235                         \r
5236                 }\r
5237         }\r
5238 \r
5239         @Override\r
5240         public <T> void forPossibleValue(final Resource subject,\r
5241                         final SyncProcedure<T> procedure) {\r
5242                 try {\r
5243                         session.syncRequest(new ReadRequest() {\r
5244                                 \r
5245                                 @Override\r
5246                                 public void run(ReadGraph graph) throws DatabaseException {\r
5247                 graph.forPossibleValue(subject, procedure);\r
5248                                 }\r
5249                         });\r
5250                 } catch (DatabaseException e) {\r
5251                         \r
5252                 }\r
5253         }\r
5254 \r
5255         @Override\r
5256         public <T> void forPossibleValue(final Resource subject,\r
5257                         final Procedure<T> procedure) {\r
5258                 try {\r
5259                         session.syncRequest(new ReadRequest() {\r
5260                                 \r
5261                                 @Override\r
5262                                 public void run(ReadGraph graph) throws DatabaseException {\r
5263                 graph.forPossibleValue(subject, procedure);\r
5264                                 }\r
5265                         });\r
5266                 } catch (DatabaseException e) {\r
5267                         \r
5268                 }\r
5269         }\r
5270 \r
5271         @Override\r
5272         public <T> void forPossibleValue(final Resource subject, final Binding binding,\r
5273                         final AsyncListener<T> procedure) {\r
5274                 try {\r
5275                         session.syncRequest(new ReadRequest() {\r
5276                                 \r
5277                                 @Override\r
5278                                 public void run(ReadGraph graph) throws DatabaseException {\r
5279                 graph.forPossibleValue(subject, procedure);\r
5280                                 }\r
5281                         });\r
5282                 } catch (DatabaseException e) {\r
5283                         \r
5284                 }\r
5285         }\r
5286 \r
5287         @Override\r
5288         public <T> void forPossibleValue(final Resource subject, final Binding binding,\r
5289                         final SyncListener<T> procedure) {\r
5290                 try {\r
5291                         session.syncRequest(new ReadRequest() {\r
5292                                 \r
5293                                 @Override\r
5294                                 public void run(ReadGraph graph) throws DatabaseException {\r
5295                 graph.forPossibleValue(subject, procedure);\r
5296                                 }\r
5297                         });\r
5298                 } catch (DatabaseException e) {\r
5299                         \r
5300                 }\r
5301         }\r
5302 \r
5303         @Override\r
5304         public <T> void forPossibleValue(final Resource subject, final Binding binding,\r
5305                         final Listener<T> procedure) {\r
5306                 try {\r
5307                         session.syncRequest(new ReadRequest() {\r
5308                                 \r
5309                                 @Override\r
5310                                 public void run(ReadGraph graph) throws DatabaseException {\r
5311                 graph.forPossibleValue(subject, procedure);\r
5312                                 }\r
5313                         });\r
5314                 } catch (DatabaseException e) {\r
5315                         \r
5316                 }\r
5317         }\r
5318 \r
5319         @Override\r
5320         public <T> void forPossibleValue(final Resource subject, final Binding binding,\r
5321                         final AsyncProcedure<T> procedure) {\r
5322                 try {\r
5323                         session.syncRequest(new ReadRequest() {\r
5324                                 \r
5325                                 @Override\r
5326                                 public void run(ReadGraph graph) throws DatabaseException {\r
5327                 graph.forPossibleValue(subject, procedure);\r
5328                                 }\r
5329                         });\r
5330                 } catch (DatabaseException e) {\r
5331                         \r
5332                 }\r
5333         }\r
5334 \r
5335         @Override\r
5336         public <T> void forPossibleValue(final Resource subject, final Binding binding,\r
5337                         final SyncProcedure<T> procedure) {\r
5338                 try {\r
5339                         session.syncRequest(new ReadRequest() {\r
5340                                 \r
5341                                 @Override\r
5342                                 public void run(ReadGraph graph) throws DatabaseException {\r
5343                 graph.forPossibleValue(subject, procedure);\r
5344                                 }\r
5345                         });\r
5346                 } catch (DatabaseException e) {\r
5347                         \r
5348                 }\r
5349         }\r
5350 \r
5351         @Override\r
5352         public <T> void forPossibleValue(final Resource subject, final Binding binding,\r
5353                         final Procedure<T> procedure) {\r
5354                 try {\r
5355                         session.syncRequest(new ReadRequest() {\r
5356                                 \r
5357                                 @Override\r
5358                                 public void run(ReadGraph graph) throws DatabaseException {\r
5359                 graph.forPossibleValue(subject, procedure);\r
5360                                 }\r
5361                         });\r
5362                 } catch (DatabaseException e) {\r
5363                         \r
5364                 }\r
5365         }\r
5366 \r
5367         @Override\r
5368         public <T> void forPossibleRelatedValue(final Resource subject,\r
5369                         final Resource relation, final AsyncListener<T> procedure) {\r
5370                 try {\r
5371                         session.syncRequest(new ReadRequest() {\r
5372                                 \r
5373                                 @Override\r
5374                                 public void run(ReadGraph graph) throws DatabaseException {\r
5375                 graph.forPossibleRelatedValue(subject, relation, procedure);\r
5376                                 }\r
5377                         });\r
5378                 } catch (DatabaseException e) {\r
5379                         \r
5380                 }\r
5381         }\r
5382 \r
5383         @Override\r
5384         public <T> void forPossibleRelatedValue(final Resource subject,\r
5385                         final Resource relation, final SyncListener<T> procedure) {\r
5386                 try {\r
5387                         session.syncRequest(new ReadRequest() {\r
5388                                 \r
5389                                 @Override\r
5390                                 public void run(ReadGraph graph) throws DatabaseException {\r
5391                 graph.forPossibleRelatedValue(subject, relation, procedure);\r
5392                                 }\r
5393                         });\r
5394                 } catch (DatabaseException e) {\r
5395                         \r
5396                 }\r
5397         }\r
5398 \r
5399         @Override\r
5400         public <T> void forPossibleRelatedValue(final Resource subject,\r
5401                         final Resource relation, final Listener<T> procedure) {\r
5402                 try {\r
5403                         session.syncRequest(new ReadRequest() {\r
5404                                 \r
5405                                 @Override\r
5406                                 public void run(ReadGraph graph) throws DatabaseException {\r
5407                 graph.forPossibleRelatedValue(subject, relation, procedure);\r
5408                                 }\r
5409                         });\r
5410                 } catch (DatabaseException e) {\r
5411                         \r
5412                 }\r
5413         }\r
5414 \r
5415         @Override\r
5416         public <T> void forPossibleRelatedValue(final Resource subject,\r
5417                         final Resource relation, final AsyncProcedure<T> procedure) {\r
5418                 try {\r
5419                         session.syncRequest(new ReadRequest() {\r
5420                                 \r
5421                                 @Override\r
5422                                 public void run(ReadGraph graph) throws DatabaseException {\r
5423                 graph.forPossibleRelatedValue(subject, relation, procedure);\r
5424                                 }\r
5425                         });\r
5426                 } catch (DatabaseException e) {\r
5427                         \r
5428                 }\r
5429         }\r
5430 \r
5431         @Override\r
5432         public <T> void forPossibleRelatedValue(final Resource subject,\r
5433                         final Resource relation, final SyncProcedure<T> procedure) {\r
5434                 try {\r
5435                         session.syncRequest(new ReadRequest() {\r
5436                                 \r
5437                                 @Override\r
5438                                 public void run(ReadGraph graph) throws DatabaseException {\r
5439                 graph.forPossibleRelatedValue(subject, relation, procedure);\r
5440                                 }\r
5441                         });\r
5442                 } catch (DatabaseException e) {\r
5443                         \r
5444                 }\r
5445         }\r
5446 \r
5447         @Override\r
5448         public <T> void forPossibleRelatedValue(final Resource subject,\r
5449                         final Resource relation, final Procedure<T> procedure) {\r
5450                 try {\r
5451                         session.syncRequest(new ReadRequest() {\r
5452                                 \r
5453                                 @Override\r
5454                                 public void run(ReadGraph graph) throws DatabaseException {\r
5455                 graph.forPossibleRelatedValue(subject, relation, procedure);\r
5456                                 }\r
5457                         });\r
5458                 } catch (DatabaseException e) {\r
5459                         \r
5460                 }\r
5461         }\r
5462 \r
5463         @Override\r
5464         public <T> void forPossibleRelatedValue(final Resource subject,\r
5465                         final Resource relation, final Binding binding, final AsyncListener<T> procedure) {\r
5466                 try {\r
5467                         session.syncRequest(new ReadRequest() {\r
5468                                 \r
5469                                 @Override\r
5470                                 public void run(ReadGraph graph) throws DatabaseException {\r
5471                 graph.forPossibleRelatedValue(subject, relation, binding, procedure);\r
5472                                 }\r
5473                         });\r
5474                 } catch (DatabaseException e) {\r
5475                         \r
5476                 }\r
5477         }\r
5478 \r
5479         @Override\r
5480         public <T> void forPossibleRelatedValue(final Resource subject,\r
5481                         final Resource relation, final Binding binding, final SyncListener<T> procedure) {\r
5482                 try {\r
5483                         session.syncRequest(new ReadRequest() {\r
5484                                 \r
5485                                 @Override\r
5486                                 public void run(ReadGraph graph) throws DatabaseException {\r
5487                 graph.forPossibleRelatedValue(subject, relation, procedure);\r
5488                                 }\r
5489                         });\r
5490                 } catch (DatabaseException e) {\r
5491                         \r
5492                 }\r
5493         }\r
5494 \r
5495         @Override\r
5496         public <T> void forPossibleRelatedValue(final Resource subject,\r
5497                         final Resource relation, final Binding binding, final Listener<T> procedure) {\r
5498                 try {\r
5499                         session.syncRequest(new ReadRequest() {\r
5500                                 \r
5501                                 @Override\r
5502                                 public void run(ReadGraph graph) throws DatabaseException {\r
5503                 graph.forPossibleRelatedValue(subject, relation, binding, procedure);\r
5504                                 }\r
5505                         });\r
5506                 } catch (DatabaseException e) {\r
5507                         \r
5508                 }\r
5509         }\r
5510 \r
5511         @Override\r
5512         public <T> void forPossibleRelatedValue(final Resource subject,\r
5513                         final Resource relation, final Binding binding, final AsyncProcedure<T> procedure) {\r
5514                 try {\r
5515                         session.syncRequest(new ReadRequest() {\r
5516                                 \r
5517                                 @Override\r
5518                                 public void run(ReadGraph graph) throws DatabaseException {\r
5519                 graph.forPossibleRelatedValue(subject, relation, binding, procedure);\r
5520                                 }\r
5521                         });\r
5522                 } catch (DatabaseException e) {\r
5523                         \r
5524                 }\r
5525         }\r
5526 \r
5527         @Override\r
5528         public <T> void forPossibleRelatedValue(final Resource subject,\r
5529                         final Resource relation, final Binding binding, final SyncProcedure<T> procedure) {\r
5530                 try {\r
5531                         session.syncRequest(new ReadRequest() {\r
5532                                 \r
5533                                 @Override\r
5534                                 public void run(ReadGraph graph) throws DatabaseException {\r
5535                 graph.forPossibleRelatedValue(subject, relation, binding, procedure);\r
5536                                 }\r
5537                         });\r
5538                 } catch (DatabaseException e) {\r
5539                         \r
5540                 }\r
5541         }\r
5542 \r
5543         @Override\r
5544         public <T> void forPossibleRelatedValue(final Resource subject,\r
5545                         final Resource relation, final Binding binding, final Procedure<T> procedure) {\r
5546                 try {\r
5547                         session.syncRequest(new ReadRequest() {\r
5548                                 \r
5549                                 @Override\r
5550                                 public void run(ReadGraph graph) throws DatabaseException {\r
5551                 graph.forPossibleRelatedValue(subject, relation, binding, procedure);\r
5552                                 }\r
5553                         });\r
5554                 } catch (DatabaseException e) {\r
5555                         \r
5556                 }\r
5557         }\r
5558 \r
5559         @Override\r
5560         public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,\r
5561                         final AsyncListener<T> procedure) {\r
5562                 try {\r
5563                         session.syncRequest(new ReadRequest() {\r
5564                                 \r
5565                                 @Override\r
5566                                 public void run(ReadGraph graph) throws DatabaseException {\r
5567                 graph.forPossibleAdapted(resource, clazz, procedure);\r
5568                                 }\r
5569                         });\r
5570                 } catch (DatabaseException e) {\r
5571                         \r
5572                 }\r
5573         }\r
5574 \r
5575         @Override\r
5576         public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,\r
5577                         final SyncListener<T> procedure) {\r
5578                 try {\r
5579                         session.syncRequest(new ReadRequest() {\r
5580                                 \r
5581                                 @Override\r
5582                                 public void run(ReadGraph graph) throws DatabaseException {\r
5583                 graph.forPossibleAdapted(resource, clazz, procedure);\r
5584                                 }\r
5585                         });\r
5586                 } catch (DatabaseException e) {\r
5587                         \r
5588                 }\r
5589         }\r
5590 \r
5591         @Override\r
5592         public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,\r
5593                         final Listener<T> procedure) {\r
5594                 try {\r
5595                         session.syncRequest(new ReadRequest() {\r
5596                                 \r
5597                                 @Override\r
5598                                 public void run(ReadGraph graph) throws DatabaseException {\r
5599                 graph.forPossibleAdapted(resource, clazz, procedure);\r
5600                                 }\r
5601                         });\r
5602                 } catch (DatabaseException e) {\r
5603                         \r
5604                 }\r
5605         }\r
5606 \r
5607         @Override\r
5608         public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,\r
5609                         final AsyncProcedure<T> procedure) {\r
5610                 try {\r
5611                         session.syncRequest(new ReadRequest() {\r
5612                                 \r
5613                                 @Override\r
5614                                 public void run(ReadGraph graph) throws DatabaseException {\r
5615                 graph.forPossibleAdapted(resource, clazz, procedure);\r
5616                                 }\r
5617                         });\r
5618                 } catch (DatabaseException e) {\r
5619                         \r
5620                 }\r
5621         }\r
5622 \r
5623         @Override\r
5624         public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,\r
5625                         final SyncProcedure<T> procedure) {\r
5626                 try {\r
5627                         session.syncRequest(new ReadRequest() {\r
5628                                 \r
5629                                 @Override\r
5630                                 public void run(ReadGraph graph) throws DatabaseException {\r
5631                 graph.forPossibleAdapted(resource, clazz, procedure);\r
5632                                 }\r
5633                         });\r
5634                 } catch (DatabaseException e) {\r
5635                         \r
5636                 }\r
5637         }\r
5638 \r
5639         @Override\r
5640         public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,\r
5641                         final Procedure<T> procedure) {\r
5642                 try {\r
5643                         session.syncRequest(new ReadRequest() {\r
5644                                 \r
5645                                 @Override\r
5646                                 public void run(ReadGraph graph) throws DatabaseException {\r
5647                 graph.forPossibleAdapted(resource, clazz, procedure);\r
5648                                 }\r
5649                         });\r
5650                 } catch (DatabaseException e) {\r
5651                         \r
5652                 }\r
5653         }\r
5654 \r
5655         @Override\r
5656         public <T> void forPossibleUniqueAdapted(final Resource resource,\r
5657                         final Class<T> clazz, final AsyncListener<T> procedure) {\r
5658                 try {\r
5659                         session.syncRequest(new ReadRequest() {\r
5660                                 \r
5661                                 @Override\r
5662                                 public void run(ReadGraph graph) throws DatabaseException {\r
5663                 graph.forPossibleUniqueAdapted(resource, clazz, procedure);\r
5664                                 }\r
5665                         });\r
5666                 } catch (DatabaseException e) {\r
5667                         \r
5668                 }\r
5669         }\r
5670 \r
5671         @Override\r
5672         public <T> void forPossibleUniqueAdapted(final Resource resource,\r
5673                         final Class<T> clazz, final SyncListener<T> procedure) {\r
5674                 try {\r
5675                         session.syncRequest(new ReadRequest() {\r
5676                                 \r
5677                                 @Override\r
5678                                 public void run(ReadGraph graph) throws DatabaseException {\r
5679                 graph.forPossibleUniqueAdapted(resource, clazz, procedure);\r
5680                                 }\r
5681                         });\r
5682                 } catch (DatabaseException e) {\r
5683                         \r
5684                 }\r
5685         }\r
5686 \r
5687         @Override\r
5688         public <T> void forPossibleUniqueAdapted(final Resource resource,\r
5689                         final Class<T> clazz, final Listener<T> procedure) {\r
5690                 try {\r
5691                         session.syncRequest(new ReadRequest() {\r
5692                                 \r
5693                                 @Override\r
5694                                 public void run(ReadGraph graph) throws DatabaseException {\r
5695                 graph.forPossibleUniqueAdapted(resource, clazz, procedure);\r
5696                                 }\r
5697                         });\r
5698                 } catch (DatabaseException e) {\r
5699                         \r
5700                 }\r
5701         }\r
5702 \r
5703         @Override\r
5704         public <T> void forPossibleUniqueAdapted(final Resource resource,\r
5705                         final Class<T> clazz, final AsyncProcedure<T> procedure) {\r
5706                 try {\r
5707                         session.syncRequest(new ReadRequest() {\r
5708                                 \r
5709                                 @Override\r
5710                                 public void run(ReadGraph graph) throws DatabaseException {\r
5711                 graph.forPossibleUniqueAdapted(resource, clazz, procedure);\r
5712                                 }\r
5713                         });\r
5714                 } catch (DatabaseException e) {\r
5715                         \r
5716                 }\r
5717         }\r
5718 \r
5719         @Override\r
5720         public <T> void forPossibleUniqueAdapted(final Resource resource,\r
5721                         final Class<T> clazz, final SyncProcedure<T> procedure) {\r
5722                 try {\r
5723                         session.syncRequest(new ReadRequest() {\r
5724                                 \r
5725                                 @Override\r
5726                                 public void run(ReadGraph graph) throws DatabaseException {\r
5727                 graph.forPossibleUniqueAdapted(resource, clazz, procedure);\r
5728                                 }\r
5729                         });\r
5730                 } catch (DatabaseException e) {\r
5731                         \r
5732                 }\r
5733         }\r
5734 \r
5735         @Override\r
5736         public <T> void forPossibleUniqueAdapted(final Resource resource,\r
5737                         final Class<T> clazz, final Procedure<T> procedure) {\r
5738                 try {\r
5739                         session.syncRequest(new ReadRequest() {\r
5740                                 \r
5741                                 @Override\r
5742                                 public void run(ReadGraph graph) throws DatabaseException {\r
5743                 graph.forPossibleUniqueAdapted(resource, clazz, procedure);\r
5744                                 }\r
5745                         });\r
5746                 } catch (DatabaseException e) {\r
5747                         \r
5748                 }\r
5749         }\r
5750 \r
5751         @Override\r
5752         public void forIsInstanceOf(final Resource resource, final Resource type,\r
5753                         final AsyncListener<Boolean> procedure) {\r
5754                 try {\r
5755                         session.syncRequest(new ReadRequest() {\r
5756                                 \r
5757                                 @Override\r
5758                                 public void run(ReadGraph graph) throws DatabaseException {\r
5759                 graph.forIsInstanceOf(resource, type, procedure);\r
5760                                 }\r
5761                         });\r
5762                 } catch (DatabaseException e) {\r
5763                         \r
5764                 }\r
5765         }\r
5766 \r
5767         @Override\r
5768         public void forIsInstanceOf(final Resource resource, final Resource type,\r
5769                         final SyncListener<Boolean> procedure) {\r
5770                 try {\r
5771                         session.syncRequest(new ReadRequest() {\r
5772                                 \r
5773                                 @Override\r
5774                                 public void run(ReadGraph graph) throws DatabaseException {\r
5775                 graph.forIsInstanceOf(resource, type, procedure);\r
5776                                 }\r
5777                         });\r
5778                 } catch (DatabaseException e) {\r
5779                         \r
5780                 }\r
5781         }\r
5782 \r
5783         @Override\r
5784         public void forIsInstanceOf(final Resource resource, final Resource type,\r
5785                         final Listener<Boolean> procedure) {\r
5786                 try {\r
5787                         session.syncRequest(new ReadRequest() {\r
5788                                 \r
5789                                 @Override\r
5790                                 public void run(ReadGraph graph) throws DatabaseException {\r
5791                 graph.forIsInstanceOf(resource, type, procedure);\r
5792                                 }\r
5793                         });\r
5794                 } catch (DatabaseException e) {\r
5795                         \r
5796                 }\r
5797         }\r
5798 \r
5799         @Override\r
5800         public void forIsInstanceOf(final Resource resource, final Resource type,\r
5801                         final AsyncProcedure<Boolean> procedure) {\r
5802                 try {\r
5803                         session.syncRequest(new ReadRequest() {\r
5804                                 \r
5805                                 @Override\r
5806                                 public void run(ReadGraph graph) throws DatabaseException {\r
5807                 graph.forIsInstanceOf(resource, type, procedure);\r
5808                                 }\r
5809                         });\r
5810                 } catch (DatabaseException e) {\r
5811                         \r
5812                 }\r
5813         }\r
5814 \r
5815         @Override\r
5816         public void forIsInstanceOf(final Resource resource, final Resource type,\r
5817                         final SyncProcedure<Boolean> procedure) {\r
5818                 try {\r
5819                         session.syncRequest(new ReadRequest() {\r
5820                                 \r
5821                                 @Override\r
5822                                 public void run(ReadGraph graph) throws DatabaseException {\r
5823                 graph.forIsInstanceOf(resource, type, procedure);\r
5824                                 }\r
5825                         });\r
5826                 } catch (DatabaseException e) {\r
5827                         \r
5828                 }\r
5829         }\r
5830 \r
5831         @Override\r
5832         public void forIsInstanceOf(final Resource resource, final Resource type,\r
5833                         final Procedure<Boolean> procedure) {\r
5834                 try {\r
5835                         session.syncRequest(new ReadRequest() {\r
5836                                 \r
5837                                 @Override\r
5838                                 public void run(ReadGraph graph) throws DatabaseException {\r
5839                 graph.forIsInstanceOf(resource, type, procedure);\r
5840                                 }\r
5841                         });\r
5842                 } catch (DatabaseException e) {\r
5843                         \r
5844                 }\r
5845         }\r
5846 \r
5847         @Override\r
5848         public void forIsInheritedFrom(final Resource resource, final Resource type,\r
5849                         final AsyncListener<Boolean> procedure) {\r
5850                 try {\r
5851                         session.syncRequest(new ReadRequest() {\r
5852                                 \r
5853                                 @Override\r
5854                                 public void run(ReadGraph graph) throws DatabaseException {\r
5855                 graph.forIsInheritedFrom(resource, type, procedure);\r
5856                                 }\r
5857                         });\r
5858                 } catch (DatabaseException e) {\r
5859                         \r
5860                 }\r
5861         }\r
5862 \r
5863         @Override\r
5864         public void forIsInheritedFrom(final Resource resource, final Resource type,\r
5865                         final SyncListener<Boolean> procedure) {\r
5866                 try {\r
5867                         session.syncRequest(new ReadRequest() {\r
5868                                 \r
5869                                 @Override\r
5870                                 public void run(ReadGraph graph) throws DatabaseException {\r
5871                 graph.forIsInheritedFrom(resource, type, procedure);\r
5872                                 }\r
5873                         });\r
5874                 } catch (DatabaseException e) {\r
5875                         \r
5876                 }\r
5877         }\r
5878 \r
5879         @Override\r
5880         public void forIsInheritedFrom(final Resource resource, final Resource type,\r
5881                         final Listener<Boolean> procedure) {\r
5882                 try {\r
5883                         session.syncRequest(new ReadRequest() {\r
5884                                 \r
5885                                 @Override\r
5886                                 public void run(ReadGraph graph) throws DatabaseException {\r
5887                 graph.forIsInheritedFrom(resource, type, procedure);\r
5888                                 }\r
5889                         });\r
5890                 } catch (DatabaseException e) {\r
5891                         \r
5892                 }\r
5893         }\r
5894 \r
5895         @Override\r
5896         public void forIsInheritedFrom(final Resource resource, final Resource type,\r
5897                         final AsyncProcedure<Boolean> procedure) {\r
5898                 try {\r
5899                         session.syncRequest(new ReadRequest() {\r
5900                                 \r
5901                                 @Override\r
5902                                 public void run(ReadGraph graph) throws DatabaseException {\r
5903                 graph.forIsInheritedFrom(resource, type, procedure);\r
5904                                 }\r
5905                         });\r
5906                 } catch (DatabaseException e) {\r
5907                         \r
5908                 }\r
5909         }\r
5910 \r
5911         @Override\r
5912         public void forIsInheritedFrom(final Resource resource, final Resource type,\r
5913                         final SyncProcedure<Boolean> procedure) {\r
5914                 try {\r
5915                         session.syncRequest(new ReadRequest() {\r
5916                                 \r
5917                                 @Override\r
5918                                 public void run(ReadGraph graph) throws DatabaseException {\r
5919                 graph.forIsInheritedFrom(resource, type, procedure);\r
5920                                 }\r
5921                         });\r
5922                 } catch (DatabaseException e) {\r
5923                         \r
5924                 }\r
5925         }\r
5926 \r
5927         @Override\r
5928         public void forIsInheritedFrom(final Resource resource, final Resource type,\r
5929                         final Procedure<Boolean> procedure) {\r
5930                 try {\r
5931                         session.syncRequest(new ReadRequest() {\r
5932                                 \r
5933                                 @Override\r
5934                                 public void run(ReadGraph graph) throws DatabaseException {\r
5935                 graph.forIsInheritedFrom(resource, type, procedure);\r
5936                                 }\r
5937                         });\r
5938                 } catch (DatabaseException e) {\r
5939                         \r
5940                 }\r
5941         }\r
5942 \r
5943         @Override\r
5944         public void forIsSubrelationOf(final Resource resource, final Resource relation,\r
5945                         final AsyncListener<Boolean> procedure) {\r
5946                 try {\r
5947                         session.syncRequest(new ReadRequest() {\r
5948                                 \r
5949                                 @Override\r
5950                                 public void run(ReadGraph graph) throws DatabaseException {\r
5951                 graph.forIsSubrelationOf(resource, relation, procedure);\r
5952                                 }\r
5953                         });\r
5954                 } catch (DatabaseException e) {\r
5955                         \r
5956                 }\r
5957         }\r
5958 \r
5959         @Override\r
5960         public void forIsSubrelationOf(final Resource resource, final Resource relation,\r
5961                         final SyncListener<Boolean> procedure) {\r
5962                 try {\r
5963                         session.syncRequest(new ReadRequest() {\r
5964                                 \r
5965                                 @Override\r
5966                                 public void run(ReadGraph graph) throws DatabaseException {\r
5967                 graph.forIsSubrelationOf(resource, relation, procedure);\r
5968                                 }\r
5969                         });\r
5970                 } catch (DatabaseException e) {\r
5971                         \r
5972                 }\r
5973         }\r
5974 \r
5975         @Override\r
5976         public void forIsSubrelationOf(final Resource resource, final Resource relation,\r
5977                         final Listener<Boolean> procedure) {\r
5978                 try {\r
5979                         session.syncRequest(new ReadRequest() {\r
5980                                 \r
5981                                 @Override\r
5982                                 public void run(ReadGraph graph) throws DatabaseException {\r
5983                 graph.forIsSubrelationOf(resource, relation, procedure);\r
5984                                 }\r
5985                         });\r
5986                 } catch (DatabaseException e) {\r
5987                         \r
5988                 }\r
5989         }\r
5990 \r
5991         @Override\r
5992         public void forIsSubrelationOf(final Resource resource, final Resource relation,\r
5993                         final AsyncProcedure<Boolean> procedure) {\r
5994                 try {\r
5995                         session.syncRequest(new ReadRequest() {\r
5996                                 \r
5997                                 @Override\r
5998                                 public void run(ReadGraph graph) throws DatabaseException {\r
5999                 graph.forIsSubrelationOf(resource, relation, procedure);\r
6000                                 }\r
6001                         });\r
6002                 } catch (DatabaseException e) {\r
6003                         \r
6004                 }\r
6005         }\r
6006 \r
6007         @Override\r
6008         public void forIsSubrelationOf(final Resource resource, final Resource relation,\r
6009                         final SyncProcedure<Boolean> procedure) {\r
6010                 try {\r
6011                         session.syncRequest(new ReadRequest() {\r
6012                                 \r
6013                                 @Override\r
6014                                 public void run(ReadGraph graph) throws DatabaseException {\r
6015                 graph.forIsSubrelationOf(resource, relation, procedure);\r
6016                                 }\r
6017                         });\r
6018                 } catch (DatabaseException e) {\r
6019                         \r
6020                 }\r
6021         }\r
6022 \r
6023         @Override\r
6024         public void forIsSubrelationOf(final Resource resource, final Resource relation,\r
6025                         final Procedure<Boolean> procedure) {\r
6026                 try {\r
6027                         session.syncRequest(new ReadRequest() {\r
6028                                 \r
6029                                 @Override\r
6030                                 public void run(ReadGraph graph) throws DatabaseException {\r
6031                 graph.forIsSubrelationOf(resource, relation, procedure);\r
6032                                 }\r
6033                         });\r
6034                 } catch (DatabaseException e) {\r
6035                         \r
6036                 }\r
6037         }\r
6038 \r
6039         @Override\r
6040         public void forOrderedSet(final Resource subject,\r
6041                         final AsyncMultiListener<Resource> procedure) {\r
6042                 try {\r
6043                         session.syncRequest(new ReadRequest() {\r
6044                                 \r
6045                                 @Override\r
6046                                 public void run(ReadGraph graph) throws DatabaseException {\r
6047                 graph.forOrderedSet(subject, procedure);\r
6048                                 }\r
6049                         });\r
6050                 } catch (DatabaseException e) {\r
6051                         \r
6052                 }\r
6053         }\r
6054 \r
6055         @Override\r
6056         public void forOrderedSet(final Resource subject,\r
6057                         final SyncMultiListener<Resource> procedure) {\r
6058                 try {\r
6059                         session.syncRequest(new ReadRequest() {\r
6060                                 \r
6061                                 @Override\r
6062                                 public void run(ReadGraph graph) throws DatabaseException {\r
6063                 graph.forOrderedSet(subject, procedure);\r
6064                                 }\r
6065                         });\r
6066                 } catch (DatabaseException e) {\r
6067                         \r
6068                 }\r
6069         }\r
6070 \r
6071         @Override\r
6072         public void forOrderedSet(final Resource subject,\r
6073                         final MultiListener<Resource> procedure) {\r
6074                 try {\r
6075                         session.syncRequest(new ReadRequest() {\r
6076                                 \r
6077                                 @Override\r
6078                                 public void run(ReadGraph graph) throws DatabaseException {\r
6079                 graph.forOrderedSet(subject, procedure);\r
6080                                 }\r
6081                         });\r
6082                 } catch (DatabaseException e) {\r
6083                         \r
6084                 }\r
6085         }\r
6086 \r
6087         @Override\r
6088         public void forOrderedSet(final Resource subject,\r
6089                         final AsyncMultiProcedure<Resource> procedure) {\r
6090                 try {\r
6091                         session.syncRequest(new ReadRequest() {\r
6092                                 \r
6093                                 @Override\r
6094                                 public void run(ReadGraph graph) throws DatabaseException {\r
6095                 graph.forOrderedSet(subject, procedure);\r
6096                                 }\r
6097                         });\r
6098                 } catch (DatabaseException e) {\r
6099                         \r
6100                 }\r
6101         }\r
6102 \r
6103         @Override\r
6104         public void forOrderedSet(final Resource subject,\r
6105                         final SyncMultiProcedure<Resource> procedure) {\r
6106                 \r
6107                 try {\r
6108                         session.syncRequest(new ReadRequest() {\r
6109                                 \r
6110                                 @Override\r
6111                                 public void run(ReadGraph graph) throws DatabaseException {\r
6112                                         graph.forOrderedSet(subject, procedure);\r
6113                                 }\r
6114                         });\r
6115                 } catch (DatabaseException e) {\r
6116                         \r
6117                 }\r
6118         }\r
6119 \r
6120         @Override\r
6121         public void forOrderedSet(final Resource subject,\r
6122                         final MultiProcedure<Resource> procedure) {\r
6123                 try {\r
6124                         session.syncRequest(new ReadRequest() {\r
6125                                 \r
6126                                 @Override\r
6127                                 public void run(ReadGraph graph) throws DatabaseException {\r
6128                 graph.forOrderedSet(subject, procedure);\r
6129                                 }\r
6130                         });\r
6131                 } catch (DatabaseException e) {\r
6132                         \r
6133                 }\r
6134         }\r
6135 \r
6136         @Override\r
6137         public int thread() {\r
6138                 return -1;\r
6139         }\r
6140 \r
6141         @Override\r
6142         public Session getSession() {\r
6143                 return session;\r
6144         }\r
6145 \r
6146         @Override\r
6147         public Resource getBuiltin(final String id) throws ResourceNotFoundException,\r
6148                         ServiceException {\r
6149                 try {\r
6150                         return session.syncRequest(new Read<Resource>() {\r
6151                                 \r
6152                                 @Override\r
6153                                 public Resource perform(ReadGraph graph) throws DatabaseException {\r
6154                                         return graph.getBuiltin(id);\r
6155                                 }\r
6156                                 });\r
6157                         } catch (DatabaseException e) {\r
6158                                 throw new ServiceException(e);\r
6159                         }\r
6160         }\r
6161         \r
6162         @Override\r
6163         public VirtualGraph getProvider() {\r
6164                 return null;\r
6165         }\r
6166 \r
6167 }\r