org.simantics.interop.mapping/src/org/simantics/interop/mapping/WriteGraphProxy.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.Resource;\r
  13 import org.simantics.db.Session;\r
  14 import org.simantics.db.Statement;\r
  15 import org.simantics.db.VirtualGraph;\r
  16 import org.simantics.db.WriteGraph;\r
  17 import org.simantics.db.exception.AdaptionException;\r
  18 import org.simantics.db.exception.AssumptionException;\r
  19 import org.simantics.db.exception.BindingException;\r
  20 import org.simantics.db.exception.DatabaseException;\r
  21 import org.simantics.db.exception.DoesNotContainValueException;\r
  22 import org.simantics.db.exception.ManyObjectsForFunctionalRelationException;\r
  23 import org.simantics.db.exception.NoInverseException;\r
  24 import org.simantics.db.exception.NoSingleResultException;\r
  25 import org.simantics.db.exception.ResourceNotFoundException;\r
  26 import org.simantics.db.exception.ServiceException;\r
  27 import org.simantics.db.exception.ServiceNotFoundException;\r
  28 import org.simantics.db.exception.ValidationException;\r
  29 import org.simantics.db.procedure.AsyncListener;\r
  30 import org.simantics.db.procedure.AsyncMultiListener;\r
  31 import org.simantics.db.procedure.AsyncMultiProcedure;\r
  32 import org.simantics.db.procedure.AsyncProcedure;\r
  33 import org.simantics.db.procedure.AsyncSetListener;\r
  34 import org.simantics.db.procedure.Listener;\r
  35 import org.simantics.db.procedure.MultiListener;\r
  36 import org.simantics.db.procedure.MultiProcedure;\r
  37 import org.simantics.db.procedure.Procedure;\r
  38 import org.simantics.db.procedure.SetListener;\r
  39 import org.simantics.db.procedure.SyncListener;\r
  40 import org.simantics.db.procedure.SyncMultiListener;\r
  41 import org.simantics.db.procedure.SyncMultiProcedure;\r
  42 import org.simantics.db.procedure.SyncProcedure;\r
  43 import org.simantics.db.procedure.SyncSetListener;\r
  44 import org.simantics.db.request.AsyncMultiRead;\r
  45 import org.simantics.db.request.AsyncRead;\r
  46 import org.simantics.db.request.DelayedWrite;\r
  47 import org.simantics.db.request.DelayedWriteResult;\r
  48 import org.simantics.db.request.ExternalRead;\r
  49 import org.simantics.db.request.MultiRead;\r
  50 import org.simantics.db.request.Read;\r
  51 import org.simantics.db.request.ReadInterface;\r
  52 import org.simantics.db.request.Write;\r
  53 import org.simantics.db.request.WriteInterface;\r
  54 import org.simantics.db.request.WriteOnly;\r
  55 import org.simantics.db.request.WriteOnlyResult;\r
  56 import org.simantics.db.request.WriteResult;\r
  57 import org.simantics.db.request.WriteTraits;\r
  58 import org.simantics.scl.types.Type;\r
  59 import org.simantics.utils.datastructures.Callback;\r
  60 \r
  61 /**\r
  62  * \r
  63  * @author Marko Luukkainen <marko.luukkainen@vtt.fi>\r
  64  *\r
  65  */\r
  66 public class WriteGraphProxy implements WriteGraph {\r
  67         \r
  68         protected WriteGraph graph;\r
  69         \r
  70         \r
  71         @Override\r
  72         public <T> T getRelatedValue2(Resource subject, Resource relation)\r
  73                         throws DatabaseException {\r
  74                 return graph.getRelatedValue2(subject, relation);\r
  75         }\r
  76         \r
  77         @Override\r
  78         public <T> T getRelatedValue2(Resource subject, Resource relation,\r
  79                         Binding binding) throws DatabaseException {\r
  80                 return graph.getRelatedValue2(subject, relation, binding);\r
  81         }\r
  82         \r
  83         @Override\r
  84         public <T> T getRelatedValue2(Resource subject, Resource relation,\r
  85                         Object context) throws DatabaseException {\r
  86                 return graph.getRelatedValue2(subject, relation, context);\r
  87         }\r
  88         \r
  89         @Override\r
  90         public <T> T getRelatedValue2(Resource subject, Resource relation,\r
  91                         Object context, Binding binding) throws DatabaseException {\r
  92                 return graph.getRelatedValue2(subject, relation, context, binding);\r
  93         }\r
  94         \r
  95         @Override\r
  96         public <T> T getPossibleRelatedValue2(Resource subject, Resource relation)\r
  97                         throws DatabaseException {\r
  98                 return graph.getPossibleRelatedValue2(subject, relation);\r
  99         }\r
 100         \r
 101         @Override\r
 102         public <T> T getPossibleRelatedValue2(Resource subject, Resource relation,\r
 103                         Binding binding) throws DatabaseException {\r
 104                 return graph.getPossibleRelatedValue2(subject, relation, binding);\r
 105         }\r
 106         \r
 107         @Override\r
 108         public <T> T getPossibleRelatedValue2(Resource subject, Resource relation,\r
 109                         Object context) throws DatabaseException {\r
 110                 return graph.getPossibleRelatedValue2(subject, relation, context);\r
 111         }\r
 112         \r
 113         @Override\r
 114         public <T> T getPossibleRelatedValue2(Resource subject, Resource relation,\r
 115                         Object context, Binding binding) throws DatabaseException {\r
 116                 return getPossibleRelatedValue2(subject, relation, context, binding);\r
 117         }\r
 118         \r
 119         @Override\r
 120         public <T> void async(ReadInterface<T> r, AsyncListener<T> procedure) {\r
 121                 graph.async(r,procedure);\r
 122         }\r
 123         \r
 124         @Override\r
 125         public <T> void async(ReadInterface<T> r, AsyncProcedure<T> procedure) {\r
 126                 graph.async(r, procedure);\r
 127         }\r
 128         \r
 129         @Override\r
 130         public <T> void async(ReadInterface<T> r, Listener<T> procedure) {\r
 131                 graph.async(r, procedure);\r
 132         }\r
 133         \r
 134         @Override\r
 135         public <T> void async(ReadInterface<T> r, Procedure<T> procedure) {\r
 136                 graph.async(r, procedure);\r
 137         }\r
 138         \r
 139         @Override\r
 140         public <T> void async(ReadInterface<T> r, SyncListener<T> procedure) {\r
 141                 graph.async(r, procedure);\r
 142         }\r
 143         \r
 144         @Override\r
 145         public <T> void async(ReadInterface<T> r, SyncProcedure<T> procedure) {\r
 146                 graph.async(r, procedure);\r
 147         }\r
 148         \r
 149         @Override\r
 150         public <T> void async(WriteInterface<T> r) {\r
 151                 graph.async(r);\r
 152         }\r
 153         \r
 154         @Override\r
 155         public <T> void async(WriteInterface<T> r, Procedure<T> procedure) {\r
 156                 graph.async(r, procedure);\r
 157         }\r
 158         \r
 159         @Override\r
 160         public <T> T sync(ReadInterface<T> r) throws DatabaseException {\r
 161                 return graph.sync(r);\r
 162         }\r
 163         \r
 164         @Override\r
 165         public <T> T sync(WriteInterface<T> r) throws DatabaseException {\r
 166                 return graph.sync(r);\r
 167         }\r
 168         \r
 169         @Override\r
 170         public Resource getRootLibrary() {\r
 171                 return graph.getRootLibrary();\r
 172         }\r
 173         \r
 174         \r
 175         @Override\r
 176         public void clearUndoList(WriteTraits writeTraits) {\r
 177                 graph.clearUndoList(writeTraits);\r
 178         }\r
 179         \r
 180         @Override\r
 181         public void combineWithPrevious(WriteTraits writeTraits) {\r
 182                 graph.combineWithPrevious(writeTraits);\r
 183         }\r
 184         \r
 185         @Override\r
 186         public TreeMap<String, byte[]> getMetadata() {\r
 187                 return graph.getMetadata();\r
 188         }\r
 189         \r
 190         @Override\r
 191         public <T extends Metadata> T getMetadata(Class<T> clazz)\r
 192                         throws ServiceException {\r
 193                 return graph.getMetadata(clazz);\r
 194         }\r
 195         \r
 196         @Override\r
 197         public Type getRelatedValueType(Resource subject, Resource relation)\r
 198                         throws DatabaseException {\r
 199                 return graph.getRelatedValueType(subject, relation);\r
 200         }\r
 201         \r
 202         @Override\r
 203         public void deny(Resource subject, Resource predicate, Resource inverse,\r
 204                         Resource object, VirtualGraph graph) throws ServiceException {\r
 205                 this.graph.deny(subject, predicate, inverse, object, graph);\r
 206         }\r
 207         \r
 208         \r
 209         \r
 210         \r
 211         @Override\r
 212         public <T> T adaptRelated(Resource resource, Resource relation,\r
 213                         Class<T> clazz) throws AdaptionException, NoSingleResultException,\r
 214                         ValidationException, ServiceException {\r
 215                 return graph.adaptRelated(resource, relation, clazz);\r
 216         }\r
 217         \r
 218         @Override\r
 219         public <T> T getPossibleRelatedAdapter(Resource resource,\r
 220                         Resource relation, Class<T> clazz) throws ValidationException,\r
 221                         ServiceException {\r
 222                 return graph.getPossibleRelatedAdapter(resource, relation, clazz);\r
 223         }\r
 224         \r
 225         @Override\r
 226         public void inc() {\r
 227                 graph.inc();\r
 228         }\r
 229         \r
 230         @Override\r
 231         public void dec() {\r
 232                 graph.dec();\r
 233         }\r
 234         \r
 235         @Override\r
 236         public Collection<Resource> getObjects(Resource subject, Resource relation) throws ServiceException \r
 237                         {\r
 238                 return graph.getObjects(subject, relation);\r
 239         }\r
 240         \r
 241         @Override\r
 242         public <T extends Accessor> T newLiteral(Resource resource,\r
 243         Resource predicate, Datatype datatype, Object initialValue)\r
 244         throws DatabaseException {\r
 245                 return graph.newLiteral(resource, predicate, datatype, initialValue);\r
 246         }\r
 247 \r
 248         @Override\r
 249         public RandomAccessBinary createRandomAccessBinary(Resource resource,\r
 250                         Resource predicate, Datatype datatype, Object initialValue)\r
 251                         throws DatabaseException {\r
 252                 return graph.createRandomAccessBinary(resource, predicate, datatype, initialValue);\r
 253         }\r
 254         \r
 255         @Override\r
 256         public RandomAccessBinary createRandomAccessBinary(Resource resource,\r
 257                         Datatype datatype, Object initialValue) throws DatabaseException {\r
 258                 return graph.createRandomAccessBinary(resource, datatype, initialValue);\r
 259         }\r
 260         \r
 261 //      @Override\r
 262 //      public void claimFile(Resource resource, Object content, Binding binding)\r
 263 //                      throws DatabaseException {\r
 264 //              graph.claimFile(resource, content, binding);\r
 265 //      }\r
 266 //      \r
 267 //      @Override\r
 268 //      public void denyFile(Resource resource) throws DatabaseException {\r
 269 //              graph.denyFile(resource);\r
 270 //      }\r
 271         \r
 272         public <T, C> T adaptContextual(Resource resource, C context, java.lang.Class<C> contextClass, java.lang.Class<T> clazz) throws AdaptionException ,NoSingleResultException ,ValidationException ,ServiceException {\r
 273                 return graph.adaptContextual(resource, context, contextClass, clazz);\r
 274         };\r
 275         \r
 276         public <T, C> T getPossibleContextualAdapter(Resource resource, C context, java.lang.Class<C> contextClass, java.lang.Class<T> clazz) throws ValidationException ,ServiceException {\r
 277                 return graph.getPossibleContextualAdapter(resource, context, contextClass, clazz);\r
 278         };\r
 279         \r
 280         \r
 281         public WriteGraphProxy(WriteGraph graph) {\r
 282                 this.graph = graph;\r
 283         }\r
 284         \r
 285         @Override\r
 286         public Resource newResource() throws ServiceException {\r
 287                 return graph.newResource();\r
 288         }\r
 289         \r
 290         @Override\r
 291         public Resource newResource(long clusterId) throws ServiceException {\r
 292                 return graph.newResource(clusterId);\r
 293         }\r
 294 \r
 295     @Override\r
 296     public Resource newResource(Resource clusterSet) throws ServiceException {\r
 297         return graph.newResource(clusterSet);\r
 298     }\r
 299 \r
 300     @Override\r
 301     public void newClusterSet(Resource clusterSet) throws ServiceException {\r
 302         graph.newClusterSet(clusterSet);\r
 303     }\r
 304     \r
 305 \r
 306     public Resource setClusterSet4NewResource(Resource clusterSet) throws ServiceException {\r
 307         return graph.setClusterSet4NewResource(clusterSet);\r
 308     }\r
 309 \r
 310     @Override\r
 311         public <T> T adapt(Resource resource, Class<T> clazz)\r
 312                         throws AdaptionException, ValidationException, ServiceException {\r
 313                 return graph.adapt(resource, clazz);\r
 314         }\r
 315         \r
 316         @Override\r
 317         public <T> T adaptUnique(Resource resource, Class<T> clazz)\r
 318                         throws AdaptionException, ValidationException, ServiceException {\r
 319                 return adaptUnique(resource, clazz);\r
 320         }\r
 321         \r
 322         @Override\r
 323         public void addLiteral(Resource resource, Resource predicate,\r
 324                         Resource inverse, Object value, Binding binding)\r
 325                         throws BindingException,\r
 326                         ManyObjectsForFunctionalRelationException, ServiceException {\r
 327                 graph.addLiteral(resource, predicate, inverse, value, binding);\r
 328         }\r
 329         \r
 330         @Override\r
 331         public void addLiteral(Resource resource, Resource predicate,\r
 332                         Resource inverse, Resource type, Object value, Binding binding)\r
 333                         throws BindingException,\r
 334                         ManyObjectsForFunctionalRelationException, ServiceException {\r
 335                 graph.addLiteral(resource, predicate, inverse, type, value, binding);\r
 336         }\r
 337         \r
 338         @Override\r
 339         public <T> void addMetadata(Metadata data) throws ServiceException {\r
 340                 graph.addMetadata(data);\r
 341         }\r
 342         \r
 343         @SuppressWarnings("deprecation")\r
 344         @Override\r
 345         public void addValue(Resource resource, Resource predicate,\r
 346                         Resource inverse, Resource type, Object value, Binding binding)\r
 347                         throws BindingException,\r
 348                         ManyObjectsForFunctionalRelationException, ServiceException {\r
 349                 graph.addValue(resource, predicate, inverse, type, value, binding);\r
 350         }\r
 351         \r
 352         @Override\r
 353         public <T> void asyncRequest(AsyncMultiRead<T> request) {\r
 354                 graph.asyncRequest(request);\r
 355         }\r
 356         \r
 357         @Override\r
 358         public <T> void asyncRequest(AsyncMultiRead<T> request,\r
 359                         AsyncMultiListener<T> procedure) {\r
 360                 graph.asyncRequest(request,procedure);\r
 361         }\r
 362         \r
 363         @Override\r
 364         public <T> void asyncRequest(AsyncMultiRead<T> request,\r
 365                         AsyncMultiProcedure<T> procedure) {\r
 366                 graph.asyncRequest(request,procedure);\r
 367         }\r
 368         \r
 369         @Override\r
 370         public <T> void asyncRequest(AsyncMultiRead<T> request,\r
 371                         MultiListener<T> procedure) {\r
 372                 graph.asyncRequest(request,procedure);\r
 373         }\r
 374         \r
 375         @Override\r
 376         public <T> void asyncRequest(AsyncMultiRead<T> request,\r
 377                         MultiProcedure<T> procedure) {\r
 378                 graph.asyncRequest(request,procedure);\r
 379         }\r
 380         \r
 381         @Override\r
 382         public <T> void asyncRequest(AsyncMultiRead<T> request,\r
 383                         SyncMultiListener<T> procedure) {\r
 384                 graph.asyncRequest(request,procedure);\r
 385         }\r
 386         \r
 387         @Override\r
 388         public <T> void asyncRequest(AsyncMultiRead<T> request,\r
 389                         SyncMultiProcedure<T> procedure) {\r
 390                 graph.asyncRequest(request,procedure);  \r
 391         }\r
 392         \r
 393         @Override\r
 394         public <T> void asyncRequest(AsyncRead<T> request) {\r
 395                 graph.asyncRequest(request);    \r
 396         }\r
 397         \r
 398         @Override\r
 399         public <T> void asyncRequest(AsyncRead<T> request,\r
 400                         AsyncListener<T> procedure) {\r
 401                 graph.asyncRequest(request,procedure);  \r
 402         }\r
 403         \r
 404         @Override\r
 405         public <T> void asyncRequest(AsyncRead<T> request,\r
 406                         AsyncProcedure<T> procedure) {\r
 407                 graph.asyncRequest(request,procedure);  \r
 408         }\r
 409         \r
 410         @Override\r
 411         public <T> void asyncRequest(AsyncRead<T> request, Listener<T> procedure) {\r
 412                 graph.asyncRequest(request,procedure);  \r
 413         }\r
 414         \r
 415         @Override\r
 416         public <T> void asyncRequest(AsyncRead<T> request,\r
 417                         Procedure<T> procedure) {\r
 418                 graph.asyncRequest(request,procedure);  \r
 419         }\r
 420         \r
 421         @Override\r
 422         public <T> void asyncRequest(AsyncRead<T> request,\r
 423                         SyncListener<T> procedure) {\r
 424                 graph.asyncRequest(request,procedure);  \r
 425         }\r
 426         \r
 427         @Override\r
 428         public <T> void asyncRequest(AsyncRead<T> request,\r
 429                         SyncProcedure<T> procedure) {\r
 430                 graph.asyncRequest(request,procedure);  \r
 431         }\r
 432         \r
 433         @Override\r
 434         public void asyncRequest(DelayedWrite request) {\r
 435                 graph.asyncRequest(request);    \r
 436         }\r
 437         \r
 438         @Override\r
 439         public void asyncRequest(DelayedWrite request,\r
 440                         Callback<DatabaseException> callback) {\r
 441                 graph.asyncRequest(request,callback);   \r
 442         }\r
 443         \r
 444         @Override\r
 445         public <T> void asyncRequest(DelayedWriteResult<T> r,\r
 446                         Procedure<T> procedure) {\r
 447                 graph.asyncRequest(r,procedure);        \r
 448         }\r
 449         \r
 450         @Override\r
 451         public <T> void asyncRequest(ExternalRead<T> request) {\r
 452                 graph.asyncRequest(request);    \r
 453         }\r
 454         \r
 455         @Override\r
 456         public <T> void asyncRequest(ExternalRead<T> request,\r
 457                         Listener<T> procedure) {\r
 458                 graph.asyncRequest(request,procedure);\r
 459         }       \r
 460         \r
 461         @Override\r
 462         public <T> void asyncRequest(ExternalRead<T> request,\r
 463                         Procedure<T> procedure) {\r
 464                 graph.asyncRequest(request,procedure);\r
 465         }\r
 466         \r
 467         @Override\r
 468         public <T> void asyncRequest(MultiRead<T> request) {\r
 469                 graph.asyncRequest(request);    \r
 470         }\r
 471         \r
 472         @Override\r
 473         public <T> void asyncRequest(MultiRead<T> request,\r
 474                         AsyncMultiListener<T> procedure) {\r
 475                 graph.asyncRequest(request,procedure);  \r
 476         }\r
 477         \r
 478         @Override\r
 479         public <T> void asyncRequest(MultiRead<T> request,\r
 480                         AsyncMultiProcedure<T> procedure) {\r
 481                 graph.asyncRequest(request,procedure);  \r
 482         }\r
 483         \r
 484         @Override\r
 485         public <T> void asyncRequest(MultiRead<T> request,\r
 486                         MultiListener<T> procedure) {\r
 487                 graph.asyncRequest(request,procedure);  \r
 488         }\r
 489         \r
 490         @Override\r
 491         public <T> void asyncRequest(MultiRead<T> request,\r
 492                         MultiProcedure<T> procedure) {\r
 493                 graph.asyncRequest(request,procedure);  \r
 494         }\r
 495         \r
 496         @Override\r
 497         public <T> void asyncRequest(MultiRead<T> request,\r
 498                         SyncMultiListener<T> procedure) {\r
 499                 graph.asyncRequest(request,procedure);  \r
 500         }\r
 501         \r
 502         @Override\r
 503         public <T> void asyncRequest(MultiRead<T> request,\r
 504                         SyncMultiProcedure<T> procedure) {\r
 505                 graph.asyncRequest(request,procedure);  \r
 506         }\r
 507         \r
 508         @Override\r
 509         public <T> void asyncRequest(Read<T> request) {\r
 510                 graph.asyncRequest(request);    \r
 511         }\r
 512         \r
 513         @Override\r
 514         public <T> void asyncRequest(Read<T> request, AsyncListener<T> procedure) {\r
 515                 graph.asyncRequest(request,procedure);  \r
 516         }\r
 517         \r
 518         @Override\r
 519         public <T> void asyncRequest(Read<T> request,\r
 520                         AsyncProcedure<T> procedure) {\r
 521                 graph.asyncRequest(request,procedure);  \r
 522         }\r
 523         \r
 524         @Override\r
 525         public <T> void asyncRequest(Read<T> request, Listener<T> procedure) {\r
 526                 graph.asyncRequest(request,procedure);  \r
 527         }\r
 528         \r
 529         @Override\r
 530         public <T> void asyncRequest(Read<T> request, Procedure<T> procedure) {\r
 531                 graph.asyncRequest(request,procedure);  \r
 532         }\r
 533         \r
 534         @Override\r
 535         public <T> void asyncRequest(Read<T> request, SyncListener<T> procedure) {\r
 536                 graph.asyncRequest(request,procedure);  \r
 537         }\r
 538         \r
 539         @Override\r
 540         public <T> void asyncRequest(Read<T> request, SyncProcedure<T> procedure) {\r
 541                 graph.asyncRequest(request,procedure);  \r
 542         }\r
 543         \r
 544         @Override\r
 545         public void asyncRequest(Write request) {\r
 546                 graph.asyncRequest(request);    \r
 547         }\r
 548         \r
 549         @Override\r
 550         public void asyncRequest(Write request,\r
 551                         Callback<DatabaseException> callback) {\r
 552                 graph.asyncRequest(request, callback);  \r
 553         }\r
 554         \r
 555         @Override\r
 556         public void asyncRequest(WriteOnly r) {\r
 557                 graph.asyncRequest(r);  \r
 558         }\r
 559         \r
 560         @Override\r
 561         public void asyncRequest(WriteOnly r,\r
 562                         Callback<DatabaseException> callback) {\r
 563                 graph.asyncRequest(r,callback); \r
 564         }\r
 565         \r
 566         @Override\r
 567         public <T> void asyncRequest(WriteOnlyResult<T> r,\r
 568                         Procedure<T> procedure) {\r
 569                 graph.asyncRequest(r,procedure);        \r
 570         }\r
 571         \r
 572         @Override\r
 573         public <T> void asyncRequest(WriteResult<T> r, Procedure<T> procedure) {\r
 574                 graph.asyncRequest(r,procedure);        \r
 575         }\r
 576         \r
 577         \r
 578         \r
 579         @Override\r
 580         public void claim(Resource subject, Resource predicate,\r
 581                         Resource inverse, Resource object) throws ServiceException {\r
 582                 graph.claim(subject, predicate, inverse, object);\r
 583         }\r
 584         \r
 585         @Override\r
 586         public void claim(Resource subject, Resource predicate, Resource object)\r
 587                         throws ServiceException {\r
 588                 graph.claim(subject, predicate, object);\r
 589         }\r
 590         \r
 591 \r
 592         @Override\r
 593         public void claimLiteral(Resource resource, Resource predicate,\r
 594                         Object value) throws ManyObjectsForFunctionalRelationException,\r
 595                         ServiceException {\r
 596                 graph.claimLiteral(resource, predicate, value);\r
 597         }\r
 598         \r
 599         @Override\r
 600         public void claimLiteral(Resource resource, Resource predicate,\r
 601                         Object value, Binding binding) throws BindingException,\r
 602                         ManyObjectsForFunctionalRelationException, ServiceException {\r
 603                 graph.claimLiteral(resource, predicate, value, binding);\r
 604         }\r
 605         \r
 606         @Override\r
 607         public void claimLiteral(Resource resource, Resource predicate,\r
 608                         Resource inverse, Resource type, Object value)\r
 609                         throws BindingException,\r
 610                         ManyObjectsForFunctionalRelationException, ServiceException {\r
 611                 graph.claimLiteral(resource, predicate, inverse, type, value);\r
 612         }\r
 613         \r
 614         @Override\r
 615         public void claimLiteral(Resource resource, Resource predicate,\r
 616                         Resource inverse, Resource type, Object value, Binding binding)\r
 617                         throws BindingException,\r
 618                         ManyObjectsForFunctionalRelationException, ServiceException {\r
 619                 graph.claimLiteral(resource, predicate, inverse, type, value, binding);\r
 620         }\r
 621         \r
 622         @Override\r
 623         public void claimLiteral(Resource resource, Resource predicate,\r
 624                         Resource type, Object value) throws BindingException,\r
 625                         ManyObjectsForFunctionalRelationException, ServiceException {\r
 626                 graph.claimLiteral(resource, predicate, type, value);\r
 627         }\r
 628         \r
 629         @Override\r
 630         public void claimLiteral(Resource resource, Resource predicate,\r
 631                         Resource type, Object value, Binding binding)\r
 632                         throws BindingException,\r
 633                         ManyObjectsForFunctionalRelationException, ServiceException {\r
 634                 graph.claimLiteral(resource, predicate, type, value, binding);\r
 635         }\r
 636         \r
 637         @Override\r
 638         public void claimValue(Resource resource, Object value)\r
 639                         throws ServiceException {\r
 640                 graph.claimValue(resource, value);\r
 641         }\r
 642         \r
 643         @Override\r
 644         public void claimValue(Resource resource, Object value, Binding binding)\r
 645                         throws ServiceException {\r
 646                 graph.claimValue(resource, value, binding);     \r
 647         }\r
 648         \r
 649         @SuppressWarnings("deprecation")\r
 650         @Override\r
 651         public void claimValue(Resource resource, Resource predicate,\r
 652                         Object value) throws ManyObjectsForFunctionalRelationException,\r
 653                         ServiceException {\r
 654                 graph.claimValue(resource, predicate, value);   \r
 655         }\r
 656         \r
 657         @SuppressWarnings("deprecation")\r
 658         @Override\r
 659         public void claimValue(Resource resource, Resource predicate,\r
 660                         Object value, Binding binding) throws BindingException,\r
 661                         ManyObjectsForFunctionalRelationException, ServiceException {\r
 662                 graph.claimValue(resource, predicate, value, binding);\r
 663         }\r
 664         \r
 665         @SuppressWarnings("deprecation")\r
 666         @Override\r
 667         public void claimValue(Resource resource, Resource predicate,\r
 668                         Resource inverse, Resource type, Object value, Binding binding)\r
 669                         throws BindingException,\r
 670                         ManyObjectsForFunctionalRelationException, ServiceException {\r
 671                 graph.claimValue(resource, predicate, inverse, type, value, binding);\r
 672         }\r
 673         \r
 674         @Override\r
 675         public void deny(Resource subject) throws ServiceException {\r
 676                 graph.deny(subject);\r
 677         }\r
 678         \r
 679         @Override\r
 680         public void deny(Resource subject, Resource predicate)\r
 681                         throws ServiceException {\r
 682                 graph.deny(subject, predicate);\r
 683         }\r
 684         \r
 685         @Override\r
 686         public void deny(Resource subject, Resource predicate,\r
 687                         Resource inverse, Resource object) throws ServiceException {\r
 688                 graph.deny(subject, predicate, inverse, object);\r
 689         }\r
 690         \r
 691         @Override\r
 692         public void deny(Resource subject, Resource predicate, Resource object)\r
 693                         throws ServiceException {\r
 694                 graph.deny(subject, predicate, object);\r
 695         }\r
 696         \r
 697         @Override\r
 698         public void deny(Statement statement) throws ServiceException {\r
 699                 graph.deny(statement);\r
 700         }\r
 701         \r
 702 \r
 703         @Override\r
 704         public void denyStatement(Resource subject, Resource predicate,\r
 705                         Resource object) throws ServiceException {\r
 706                 graph.denyStatement(subject, predicate, object);\r
 707         }\r
 708         \r
 709         @Override\r
 710         public void denyValue(Resource resource) throws ServiceException {\r
 711                 graph.denyValue(resource);\r
 712         }\r
 713         \r
 714         @Override\r
 715         public void denyValue(Resource resource, Resource predicate)\r
 716                         throws ManyObjectsForFunctionalRelationException,\r
 717                         ServiceException {\r
 718                 graph.denyValue(resource, predicate);\r
 719         }\r
 720         \r
 721         @Override\r
 722         public void flushCluster() throws ServiceException {\r
 723                 graph.flushCluster();\r
 724         }\r
 725         \r
 726         @Override\r
 727         public void flushCluster(Resource r) throws ServiceException {\r
 728                 graph.flushCluster(r);\r
 729         }\r
 730         \r
 731         @Override\r
 732         public <T> void forAdapted(Resource resource, Class<T> clazz,\r
 733                         AsyncListener<T> procedure) {\r
 734                 graph.forAdapted(resource, clazz, procedure);\r
 735         }\r
 736         \r
 737         @Override\r
 738         public <T> void forAdapted(Resource resource, Class<T> clazz,\r
 739                         AsyncProcedure<T> procedure) {\r
 740                 graph.forAdapted(resource, clazz, procedure);\r
 741         }\r
 742         \r
 743         @Override\r
 744         public <T> void forAdapted(Resource resource, Class<T> clazz,\r
 745                         Listener<T> procedure) {\r
 746                 graph.forAdapted(resource, clazz, procedure);\r
 747         }\r
 748         \r
 749         @Override\r
 750         public <T> void forAdapted(Resource resource, Class<T> clazz,\r
 751                         Procedure<T> procedure) {\r
 752                 graph.forAdapted(resource, clazz, procedure);\r
 753         }\r
 754         \r
 755         @Override\r
 756         public <T> void forAdapted(Resource resource, Class<T> clazz,\r
 757                         SyncListener<T> procedure) {\r
 758                 graph.forAdapted(resource, clazz, procedure);\r
 759         }\r
 760         \r
 761         @Override\r
 762         public <T> void forAdapted(Resource resource, Class<T> clazz,\r
 763                         SyncProcedure<T> procedure) {\r
 764                 graph.forAdapted(resource, clazz, procedure);\r
 765         }\r
 766         \r
 767         @Override\r
 768         public void forAssertedObjectSet(Resource subject, Resource relation,\r
 769                         AsyncSetListener<Resource> procedure) {\r
 770                 graph.forAssertedObjectSet(subject, relation, procedure);\r
 771         }\r
 772         \r
 773         @Override\r
 774         public void forAssertedObjectSet(Resource subject, Resource relation,\r
 775                         SetListener<Resource> procedure) {\r
 776                 graph.forAssertedObjectSet(subject, relation, procedure);\r
 777         }\r
 778         \r
 779         @Override\r
 780         public void forAssertedObjectSet(Resource subject, Resource relation,\r
 781                         SyncSetListener<Resource> procedure) {\r
 782                 graph.forAssertedObjectSet(subject, relation, procedure);\r
 783         }\r
 784         \r
 785         @Override\r
 786         public void forAssertedStatementSet(Resource subject,\r
 787                         Resource relation, AsyncSetListener<Statement> procedure) {\r
 788                 graph.forAssertedStatementSet(subject, relation, procedure);\r
 789         }\r
 790         \r
 791         @Override\r
 792         public void forAssertedStatementSet(Resource subject,\r
 793                         Resource relation, SetListener<Statement> procedure) {\r
 794                 graph.forAssertedStatementSet(subject, relation, procedure);\r
 795         }\r
 796         \r
 797         @Override\r
 798         public void forAssertedStatementSet(Resource subject,\r
 799                         Resource relation, SyncSetListener<Statement> procedure) {\r
 800                 graph.forAssertedStatementSet(subject, relation, procedure);\r
 801         }\r
 802         \r
 803         @Override\r
 804         public void forBuiltin(String id, AsyncListener<Resource> procedure) {\r
 805                 graph.forBuiltin(id, procedure);\r
 806         }\r
 807         \r
 808         @Override\r
 809         public void forBuiltin(String id, Listener<Resource> procedure) {\r
 810                 graph.forBuiltin(id, procedure);\r
 811         }\r
 812         \r
 813         @Override\r
 814         public void forBuiltin(String id, AsyncProcedure<Resource> procedure) {\r
 815                 graph.forBuiltin(id, procedure);\r
 816         }\r
 817         \r
 818         @Override\r
 819         public void forBuiltin(String id, Procedure<Resource> procedure) {\r
 820                 graph.forBuiltin(id, procedure);\r
 821         }\r
 822         \r
 823         @Override\r
 824         public void forBuiltin(String id, SyncListener<Resource> procedure) {\r
 825                 graph.forBuiltin(id, procedure);\r
 826         }\r
 827         \r
 828         @Override\r
 829         public void forBuiltin(String id, SyncProcedure<Resource> procedure) {\r
 830                 graph.forBuiltin(id, procedure);\r
 831         }\r
 832         \r
 833         @Override\r
 834         public void forDirectSuperrelations(Resource subject,\r
 835                         AsyncMultiProcedure<Resource> procedure) {\r
 836                 graph.forDirectSuperrelations(subject, procedure);\r
 837         }\r
 838         \r
 839         @Override\r
 840         public void forEachAssertedObject(Resource subject, Resource relation,\r
 841                         AsyncMultiProcedure<Resource> procedure) {\r
 842                 graph.forEachAssertedObject(subject, relation, procedure);\r
 843         }\r
 844         \r
 845         @Override\r
 846         public void forEachAssertedObject(Resource subject, Resource relation,\r
 847                         MultiProcedure<Resource> procedure) {\r
 848                 graph.forEachAssertedObject(subject, relation, procedure);      \r
 849         }\r
 850         \r
 851         @Override\r
 852         public void forEachAssertedObject(Resource subject, Resource relation,\r
 853                         SyncMultiProcedure<Resource> procedure) {\r
 854                 graph.forEachAssertedObject(subject, relation, procedure);      \r
 855         }\r
 856         \r
 857         @Override\r
 858         public void forEachAssertedStatement(Resource subject,\r
 859                         Resource relation, AsyncMultiProcedure<Statement> procedure) {\r
 860                 graph.forEachAssertedStatement(subject, relation, procedure);\r
 861         }\r
 862         \r
 863         @Override\r
 864         public void forEachAssertedStatement(Resource subject,\r
 865                         Resource relation, MultiProcedure<Statement> procedure) {\r
 866                 graph.forEachAssertedStatement(subject, relation, procedure);\r
 867         }\r
 868         \r
 869         @Override\r
 870         public void forEachAssertedStatement(Resource subject,\r
 871                         Resource relation, SyncMultiProcedure<Statement> procedure) {\r
 872                 graph.forEachAssertedStatement(subject, relation, procedure);\r
 873         }\r
 874         \r
 875 //      @Override\r
 876 //      public void forEachDirectObject(Resource subject, Resource relation,\r
 877 //                      AsyncMultiProcedure<Resource> procedure) {\r
 878 //              graph.forEachDirectObject(subject, relation, procedure);\r
 879 //      }\r
 880 //      \r
 881 //      @Override\r
 882 //      public void forEachDirectObject(Resource subject, Resource relation,\r
 883 //                      MultiProcedure<Resource> procedure) {\r
 884 //              graph.forEachDirectObject(subject, relation, procedure);\r
 885 //      }\r
 886 //      \r
 887 //      @Override\r
 888 //      public void forEachDirectObject(Resource subject, Resource relation,\r
 889 //                      SyncMultiProcedure<Resource> procedure) {\r
 890 //              graph.forEachDirectObject(subject, relation, procedure);\r
 891 //      }\r
 892         \r
 893         @Override\r
 894         public void forEachDirectPredicate(Resource subject,\r
 895                         AsyncMultiProcedure<Resource> procedure) {\r
 896                 graph.forEachDirectPredicate(subject, procedure);\r
 897         }\r
 898         \r
 899         @Override\r
 900         public void forEachDirectPredicate(Resource subject,\r
 901                         MultiProcedure<Resource> procedure) {\r
 902                 graph.forEachDirectPredicate(subject, procedure);\r
 903         }\r
 904         \r
 905         @Override\r
 906         public void forEachDirectPredicate(Resource subject,\r
 907                         SyncMultiProcedure<Resource> procedure) {\r
 908                 graph.forEachDirectPredicate(subject, procedure);\r
 909         }\r
 910         \r
 911         @Override\r
 912         public void forEachObject(Resource subject, Resource relation,\r
 913                         AsyncMultiProcedure<Resource> procedure) {\r
 914                 graph.forEachObject(subject, relation, procedure);\r
 915         }\r
 916         \r
 917         @Override\r
 918         public void forEachObject(Resource subject, Resource relation,\r
 919                         MultiProcedure<Resource> procedure) {\r
 920                 graph.forEachObject(subject, relation, procedure);\r
 921         }\r
 922         \r
 923         @Override\r
 924         public void forEachObject(Resource subject, Resource relation,\r
 925                         SyncMultiProcedure<Resource> procedure) {\r
 926                 graph.forEachObject(subject, relation, procedure);\r
 927         }\r
 928         \r
 929         @Override\r
 930         public void forEachPredicate(Resource subject,\r
 931                         AsyncMultiProcedure<Resource> procedure) {\r
 932                 graph.forEachPredicate(subject, procedure);\r
 933         }\r
 934         \r
 935         @Override\r
 936         public void forEachPredicate(Resource subject,\r
 937                         MultiProcedure<Resource> procedure) {\r
 938                 graph.forEachPredicate(subject, procedure);\r
 939         }\r
 940         \r
 941         @Override\r
 942         public void forEachPredicate(Resource subject,\r
 943                         SyncMultiProcedure<Resource> procedure) {\r
 944                 graph.forEachPredicate(subject, procedure);\r
 945         }\r
 946         \r
 947         @Override\r
 948         public void forEachPrincipalType(Resource subject,\r
 949                         AsyncMultiProcedure<Resource> procedure) {\r
 950                 graph.forEachPrincipalType(subject, procedure);\r
 951         }\r
 952         \r
 953         @Override\r
 954         public void forEachPrincipalType(Resource subject,\r
 955                         MultiProcedure<Resource> procedure) {\r
 956                 graph.forEachPrincipalType(subject, procedure);\r
 957         }\r
 958         \r
 959         @Override\r
 960         public void forEachPrincipalType(Resource subject,\r
 961                         SyncMultiProcedure<Resource> procedure) {\r
 962                 graph.forEachPrincipalType(subject, procedure);\r
 963         }\r
 964         \r
 965         @Override\r
 966         public void forEachStatement(Resource subject, Resource relation,\r
 967                         AsyncMultiProcedure<Statement> procedure) {\r
 968                 graph.forEachStatement(subject, relation, procedure);\r
 969         }\r
 970         \r
 971         @Override\r
 972         public void forEachStatement(Resource subject, Resource relation,\r
 973                         MultiProcedure<Statement> procedure) {\r
 974                 graph.forEachStatement(subject, relation, procedure);\r
 975         }\r
 976         \r
 977         @Override\r
 978         public void forEachStatement(Resource subject, Resource relation,\r
 979                         SyncMultiProcedure<Statement> procedure) {\r
 980                 graph.forEachStatement(subject, relation, procedure);\r
 981         }\r
 982         \r
 983         @Override\r
 984         public void forHasStatement(Resource subject,\r
 985                         AsyncListener<Boolean> procedure) {\r
 986                 graph.forHasStatement(subject, procedure);\r
 987         }\r
 988         \r
 989         @Override\r
 990         public void forHasStatement(Resource subject,\r
 991                         AsyncProcedure<Boolean> procedure) {\r
 992                 graph.forHasStatement(subject, procedure);      \r
 993         }\r
 994         \r
 995         @Override\r
 996         public void forHasStatement(Resource subject,\r
 997                         Listener<Boolean> procedure) {\r
 998                 graph.forHasStatement(subject, procedure);      \r
 999         }\r
1000         \r
1001         @Override\r
1002         public void forHasStatement(Resource subject,\r
1003                         Procedure<Boolean> procedure) {\r
1004                 graph.forHasStatement(subject, procedure);\r
1005         }\r
1006         \r
1007         @Override\r
1008         public void forHasStatement(Resource subject, Resource relation,\r
1009                         AsyncListener<Boolean> procedure) {\r
1010                 graph.forHasStatement(subject, relation, procedure);    \r
1011         }\r
1012         \r
1013         @Override\r
1014         public void forHasStatement(Resource subject, Resource relation,\r
1015                         AsyncProcedure<Boolean> procedure) {\r
1016                 graph.forHasStatement(subject, relation, procedure);\r
1017         }\r
1018         \r
1019         @Override\r
1020         public void forHasStatement(Resource subject, Resource relation,\r
1021                         Listener<Boolean> procedure) {\r
1022                 graph.forHasStatement(subject, relation, procedure);\r
1023         }\r
1024         \r
1025         @Override\r
1026         public void forHasStatement(Resource subject, Resource relation,\r
1027                         Procedure<Boolean> procedure) {\r
1028                 graph.forHasStatement(subject, relation, procedure);    \r
1029         }\r
1030         \r
1031         @Override\r
1032         public void forHasStatement(Resource subject, Resource relation,\r
1033                         Resource object, AsyncListener<Boolean> procedure) {\r
1034                 graph.forHasStatement(subject, relation, object, procedure);\r
1035         }\r
1036         \r
1037         @Override\r
1038         public void forHasStatement(Resource subject, Resource relation,\r
1039                         Resource object, AsyncProcedure<Boolean> procedure) {\r
1040                 graph.forHasStatement(subject, relation, object, procedure);    \r
1041         }\r
1042         \r
1043         @Override\r
1044         public void forHasStatement(Resource subject, Resource relation,\r
1045                         Resource object, Listener<Boolean> procedure) {\r
1046                 graph.forHasStatement(subject, relation, object, procedure);    \r
1047         }\r
1048         \r
1049         @Override\r
1050         public void forHasStatement(Resource subject, Resource relation,\r
1051                         Resource object, Procedure<Boolean> procedure) {\r
1052                 graph.forHasStatement(subject, relation, object, procedure);    \r
1053         }\r
1054         \r
1055         @Override\r
1056         public void forHasStatement(Resource subject, Resource relation,\r
1057                         Resource object, SyncListener<Boolean> procedure) {\r
1058                 graph.forHasStatement(subject, relation, object, procedure);    \r
1059         }\r
1060         \r
1061         @Override\r
1062         public void forHasStatement(Resource subject, Resource relation,\r
1063                         Resource object, SyncProcedure<Boolean> procedure) {\r
1064                 graph.forHasStatement(subject, relation, object, procedure);    \r
1065         }\r
1066         \r
1067         @Override\r
1068         public void forHasStatement(Resource subject, Resource relation,\r
1069                         SyncListener<Boolean> procedure) {\r
1070                 graph.forHasStatement(subject, relation,  procedure);   \r
1071         }\r
1072         \r
1073         @Override\r
1074         public void forHasStatement(Resource subject, Resource relation,\r
1075                         SyncProcedure<Boolean> procedure) {\r
1076                 graph.forHasStatement(subject, relation, procedure);    \r
1077         }\r
1078         \r
1079         @Override\r
1080         public void forHasStatement(Resource subject,\r
1081                         SyncListener<Boolean> procedure) {\r
1082                 graph.forHasStatement(subject,  procedure);     \r
1083         }\r
1084         \r
1085         @Override\r
1086         public void forHasStatement(Resource subject,\r
1087                         SyncProcedure<Boolean> procedure) {\r
1088                 graph.forHasStatement(subject,  procedure);     \r
1089         }\r
1090         \r
1091         @Override\r
1092         public void forHasValue(Resource subject,\r
1093                         AsyncListener<Boolean> procedure) {\r
1094                 graph.forHasValue(subject, procedure);\r
1095         }\r
1096         \r
1097         @Override\r
1098         public void forHasValue(Resource subject,\r
1099                         AsyncProcedure<Boolean> procedure) {\r
1100                 graph.forHasValue(subject, procedure);  \r
1101         }\r
1102         \r
1103         @Override\r
1104         public void forHasValue(Resource subject, Listener<Boolean> procedure) {\r
1105                 graph.forHasValue(subject, procedure);  \r
1106         }\r
1107         \r
1108         @Override\r
1109         public void forHasValue(Resource subject, Procedure<Boolean> procedure) {\r
1110                 graph.forHasValue(subject, procedure);  \r
1111         }\r
1112         \r
1113         @Override\r
1114         public void forHasValue(Resource subject,\r
1115                         SyncListener<Boolean> procedure) {\r
1116                 graph.forHasValue(subject, procedure);  \r
1117         }\r
1118         \r
1119         @Override\r
1120         public void forHasValue(Resource subject,\r
1121                         SyncProcedure<Boolean> procedure) {\r
1122                 graph.forHasValue(subject, procedure);  \r
1123         }\r
1124         \r
1125         @Override\r
1126         public void forInverse(Resource relation,\r
1127                         AsyncListener<Resource> procedure) {\r
1128                 graph.forInverse(relation, procedure);\r
1129         }\r
1130 \r
1131         @Override\r
1132         public <T> T getService(Class<T> api) throws ServiceNotFoundException {\r
1133                 return graph.getService(api);\r
1134         }\r
1135 \r
1136         @Override\r
1137         public <T> T peekService(Class<T> api) {\r
1138                 return graph.peekService(api);\r
1139         }\r
1140 \r
1141         @Override\r
1142         public boolean hasService(Class<?> api) {\r
1143                 return graph.hasService(api);\r
1144         }\r
1145 \r
1146         @Override\r
1147         public <T> void registerService(Class<T> api, T service) {\r
1148                 graph.registerService(api, service);\r
1149         }\r
1150 \r
1151         @Override\r
1152         public String getURI(Resource resource)\r
1153                         throws ValidationException,\r
1154                         ServiceException, AssumptionException {\r
1155                 return graph.getURI(resource);\r
1156         }\r
1157 \r
1158         @Override\r
1159         public String getPossibleURI(Resource resource)\r
1160                         throws ValidationException,\r
1161                         ServiceException {\r
1162                 return graph.getPossibleURI(resource);\r
1163         }\r
1164 \r
1165         @Override\r
1166         public Resource getResource(String uri)\r
1167                         throws ResourceNotFoundException, ValidationException,\r
1168                         ServiceException {\r
1169                 return graph.getResource(uri);\r
1170         }\r
1171 \r
1172         @Override\r
1173         public Resource getPossibleResource(String uri)\r
1174                         throws ResourceNotFoundException, ValidationException,\r
1175                         ServiceException {\r
1176                 return graph.getPossibleResource(uri);\r
1177         }\r
1178 \r
1179         @Override\r
1180         public Collection<Statement> getStatements(Resource subject,\r
1181                         Resource relation)\r
1182                         throws ManyObjectsForFunctionalRelationException,\r
1183                         ServiceException {\r
1184                 return graph.getStatements(subject, relation);\r
1185         }\r
1186 \r
1187         @Override\r
1188         public Collection<Statement> getAssertedStatements(Resource subject,\r
1189                         Resource relation)\r
1190                         throws ManyObjectsForFunctionalRelationException,\r
1191                         ServiceException {\r
1192                 return graph.getAssertedStatements(subject, relation);\r
1193         }\r
1194 \r
1195         @Override\r
1196         public Collection<Resource> getPredicates(Resource subject)\r
1197                         throws ServiceException {\r
1198                 return graph.getPredicates(subject);\r
1199         }\r
1200 \r
1201         @Override\r
1202         public Collection<Resource> getPrincipalTypes(Resource subject)\r
1203                         throws ServiceException {\r
1204                 return graph.getPrincipalTypes(subject);\r
1205         }\r
1206 \r
1207         @Override\r
1208         public Set<Resource> getTypes(Resource subject) throws ServiceException {\r
1209                 return graph.getTypes(subject);\r
1210         }\r
1211 \r
1212         @Override\r
1213         public Set<Resource> getSupertypes(Resource subject)\r
1214                         throws ServiceException {\r
1215                 return graph.getSupertypes(subject);\r
1216         }\r
1217 \r
1218         @Override\r
1219         public Set<Resource> getSuperrelations(Resource subject)\r
1220                         throws ServiceException {\r
1221                 return graph.getSuperrelations(subject);\r
1222         }\r
1223 \r
1224         @Override\r
1225         public Resource getPossibleSuperrelation(Resource subject)\r
1226                         throws ServiceException {\r
1227                 return graph.getPossibleSuperrelation(subject);\r
1228         }\r
1229 \r
1230 //      @Override\r
1231 //      public Collection<Resource> getObjects(Resource subject,\r
1232 //                      Resource relation)\r
1233 //                      throws ManyObjectsForFunctionalRelationException,\r
1234 //                      ServiceException {\r
1235 //              return graph.getObjects(subject, relation);\r
1236 //      }\r
1237 \r
1238         @Override\r
1239         public Collection<Resource> getAssertedObjects(Resource subject,\r
1240                         Resource relation)\r
1241                         throws ManyObjectsForFunctionalRelationException,\r
1242                         ServiceException {\r
1243                 return graph.getAssertedObjects(subject, relation);\r
1244         }\r
1245 \r
1246         @Override\r
1247         public Resource getInverse(Resource relation)\r
1248                         throws NoInverseException,\r
1249                         ManyObjectsForFunctionalRelationException, ServiceException {\r
1250                 return graph.getInverse(relation);\r
1251         }\r
1252 \r
1253         @Override\r
1254         public Resource getSingleObject(Resource subject, Resource relation)\r
1255                         throws NoSingleResultException,\r
1256                         ManyObjectsForFunctionalRelationException, ServiceException {\r
1257                 return graph.getSingleObject(subject, relation);\r
1258         }\r
1259 \r
1260         @Override\r
1261         public Statement getSingleStatement(Resource subject, Resource relation)\r
1262                         throws NoSingleResultException,\r
1263                         ManyObjectsForFunctionalRelationException, ServiceException {\r
1264                 return graph.getSingleStatement(subject, relation);\r
1265         }\r
1266 \r
1267         @Override\r
1268         public Resource getSingleType(Resource subject)\r
1269                         throws NoSingleResultException, ServiceException {\r
1270                 return graph.getSingleType(subject);\r
1271         }\r
1272 \r
1273         @Override\r
1274         public Resource getSingleType(Resource subject, Resource baseType)\r
1275                         throws NoSingleResultException, ServiceException {\r
1276                 return graph.getSingleType(subject, baseType);\r
1277         }\r
1278 \r
1279         @Override\r
1280         public <T> T getValue(Resource subject)\r
1281                         throws DoesNotContainValueException, ServiceException {\r
1282                 return graph.getValue(subject);\r
1283         }\r
1284 \r
1285         @Override\r
1286         public <T> T getValue(Resource subject, Binding binding)\r
1287                         throws DoesNotContainValueException, BindingException,\r
1288                         ServiceException {\r
1289                 return graph.getValue(subject, binding);\r
1290         }\r
1291 \r
1292         @Override\r
1293         public <T> T getRelatedValue(Resource subject, Resource relation)\r
1294                         throws NoSingleResultException, DoesNotContainValueException,\r
1295                         ServiceException {\r
1296                 return graph.getRelatedValue(subject, relation);\r
1297         }\r
1298 \r
1299         @Override\r
1300         public <T> T getRelatedValue(Resource subject, Resource relation,\r
1301                         Binding binding) throws NoSingleResultException,\r
1302                         DoesNotContainValueException, BindingException,\r
1303                         ServiceException {\r
1304                 return graph.getRelatedValue(subject, relation, binding);\r
1305         }\r
1306 \r
1307         @Override\r
1308         public Resource getPossibleInverse(Resource relation)\r
1309                         throws ManyObjectsForFunctionalRelationException,\r
1310                         ServiceException {\r
1311                 return graph.getPossibleInverse(relation);\r
1312         }\r
1313 \r
1314         @Override\r
1315         public Resource getPossibleObject(Resource subject, Resource relation)\r
1316                         throws ManyObjectsForFunctionalRelationException,\r
1317                         ServiceException {\r
1318                 return graph.getPossibleObject(subject, relation);\r
1319         }\r
1320 \r
1321         @Override\r
1322         public Statement getPossibleStatement(Resource subject,\r
1323                         Resource relation)\r
1324                         throws ManyObjectsForFunctionalRelationException,\r
1325                         ServiceException {\r
1326                 return graph.getPossibleStatement(subject, relation);\r
1327         }\r
1328 \r
1329         @Override\r
1330         public Resource getPossibleType(Resource subject, Resource baseType)\r
1331                         throws ServiceException {\r
1332                 return graph.getPossibleType(subject, baseType);\r
1333         }\r
1334 \r
1335         @Override\r
1336         public <T> T getPossibleValue(Resource subject) throws ServiceException {\r
1337                 return graph.getPossibleValue(subject);\r
1338         }\r
1339 \r
1340         @Override\r
1341         public <T> T getPossibleValue(Resource subject, Binding binding)\r
1342                         throws BindingException, ServiceException {\r
1343                 return graph.getPossibleValue(subject, binding);\r
1344         }\r
1345 \r
1346         @Override\r
1347         public <T> T getPossibleRelatedValue(Resource subject, Resource relation)\r
1348                         throws ManyObjectsForFunctionalRelationException,\r
1349                         ServiceException {\r
1350                 return graph.getPossibleRelatedValue(subject, relation);\r
1351         }\r
1352 \r
1353         @Override\r
1354         public <T> T getPossibleRelatedValue(Resource subject,\r
1355                         Resource relation, Binding binding)\r
1356                         throws ManyObjectsForFunctionalRelationException,\r
1357                         BindingException, ServiceException {\r
1358                 return graph.getPossibleRelatedValue(subject, relation, binding);\r
1359         }\r
1360 \r
1361         @Override\r
1362         public <T> T getPossibleAdapter(Resource resource, Class<T> clazz)\r
1363                         throws ValidationException, ServiceException {\r
1364                 return graph.getPossibleAdapter(resource, clazz);\r
1365         }\r
1366 \r
1367         @Override\r
1368         public <T> T getPossibleUniqueAdapter(Resource resource, Class<T> clazz)\r
1369                         throws ValidationException, ServiceException {\r
1370                 return graph.getPossibleUniqueAdapter(resource, clazz);\r
1371         }\r
1372 \r
1373         @Override\r
1374         public boolean isInstanceOf(Resource resource, Resource type)\r
1375                         throws ServiceException {\r
1376                 return graph.isInstanceOf(resource, type);\r
1377         }\r
1378 \r
1379         @Override\r
1380         public boolean isInheritedFrom(Resource resource, Resource type)\r
1381                         throws ServiceException {\r
1382                 return graph.isInheritedFrom(resource, type);\r
1383         }\r
1384 \r
1385         @Override\r
1386         public boolean isSubrelationOf(Resource resource, Resource relation)\r
1387                         throws ServiceException {\r
1388                 return graph.isSubrelationOf(resource, relation);\r
1389         }\r
1390 \r
1391         @Override\r
1392         public boolean hasStatement(Resource subject) throws ServiceException {\r
1393                 return graph.hasStatement(subject);\r
1394         }\r
1395 \r
1396         @Override\r
1397         public boolean hasStatement(Resource subject, Resource relation)\r
1398                         throws ServiceException {\r
1399                 return graph.hasStatement(subject, relation);\r
1400         }\r
1401 \r
1402         @Override\r
1403         public boolean hasStatement(Resource subject, Resource relation,\r
1404                         Resource object) throws ServiceException {\r
1405                 return graph.hasStatement(subject, relation, object);\r
1406         }\r
1407 \r
1408         @Override\r
1409         public boolean hasValue(Resource subject) throws ServiceException {\r
1410                 return graph.hasValue(subject);\r
1411         }\r
1412 \r
1413         @Override\r
1414         public Datatype getDataType(Resource subject) throws DatabaseException {\r
1415                 return graph.getDataType(subject);\r
1416         }\r
1417 \r
1418         @Override\r
1419         public <T extends Accessor> T getAccessor(Resource subject)\r
1420                         throws DatabaseException {\r
1421                 return graph.getAccessor(subject);\r
1422         }\r
1423 \r
1424     @Override\r
1425     public RandomAccessBinary getRandomAccessBinary(Resource subject)\r
1426             throws DatabaseException {\r
1427         return graph.getRandomAccessBinary(subject);\r
1428     }\r
1429 \r
1430         @Override\r
1431         public <T> T syncRequest(Read<T> request) throws DatabaseException {\r
1432                 return graph.syncRequest(request);\r
1433         }\r
1434 \r
1435         @Override\r
1436         public <T> T syncRequest(Read<T> request, AsyncListener<T> procedure)\r
1437                         throws DatabaseException {\r
1438                 return graph.syncRequest(request, procedure);\r
1439         }\r
1440 \r
1441         @Override\r
1442         public <T> T syncRequest(Read<T> request, SyncListener<T> procedure)\r
1443                         throws DatabaseException {\r
1444                 return graph.syncRequest(request, procedure);\r
1445         }\r
1446 \r
1447         @Override\r
1448         public <T> T syncRequest(Read<T> request, Listener<T> procedure)\r
1449                         throws DatabaseException {\r
1450                 return graph.syncRequest(request, procedure);\r
1451         }\r
1452 \r
1453         @Override\r
1454         public <T> T syncRequest(Read<T> request, AsyncProcedure<T> procedure)\r
1455                         throws DatabaseException {\r
1456                 return graph.syncRequest(request, procedure);\r
1457         }\r
1458 \r
1459         @Override\r
1460         public <T> T syncRequest(Read<T> request, SyncProcedure<T> procedure)\r
1461                         throws DatabaseException {\r
1462                 return graph.syncRequest(request, procedure);\r
1463         }\r
1464 \r
1465         @Override\r
1466         public <T> T syncRequest(Read<T> request, Procedure<T> procedure)\r
1467                         throws DatabaseException {\r
1468                 return graph.syncRequest(request, procedure);\r
1469         }\r
1470 \r
1471         @Override\r
1472         public <T> T syncRequest(AsyncRead<T> request) throws DatabaseException {\r
1473                 return graph.syncRequest(request);\r
1474         }\r
1475 \r
1476         @Override\r
1477         public <T> T syncRequest(AsyncRead<T> request,\r
1478                         AsyncListener<T> procedure) throws DatabaseException {\r
1479                 return graph.syncRequest(request, procedure);\r
1480         }\r
1481 \r
1482         @Override\r
1483         public <T> T syncRequest(AsyncRead<T> request, SyncListener<T> procedure)\r
1484                         throws DatabaseException {\r
1485                 return graph.syncRequest(request, procedure);\r
1486         }\r
1487 \r
1488         @Override\r
1489         public <T> T syncRequest(AsyncRead<T> request, Listener<T> procedure)\r
1490                         throws DatabaseException {\r
1491                 return graph.syncRequest(request, procedure);\r
1492         }\r
1493 \r
1494         @Override\r
1495         public <T> T syncRequest(AsyncRead<T> request,\r
1496                         AsyncProcedure<T> procedure) throws DatabaseException {\r
1497                 return graph.syncRequest(request, procedure);\r
1498         }\r
1499 \r
1500         @Override\r
1501         public <T> T syncRequest(AsyncRead<T> request,\r
1502                         SyncProcedure<T> procedure) throws DatabaseException {\r
1503                 return graph.syncRequest(request, procedure);\r
1504         }\r
1505 \r
1506         @Override\r
1507         public <T> T syncRequest(AsyncRead<T> request, Procedure<T> procedure)\r
1508                         throws DatabaseException {\r
1509                 return graph.syncRequest(request, procedure);\r
1510         }\r
1511 \r
1512         @Override\r
1513         public <T> Collection<T> syncRequest(MultiRead<T> request)\r
1514                         throws DatabaseException {\r
1515                 return graph.syncRequest(request);\r
1516         }\r
1517 \r
1518         @Override\r
1519         public <T> Collection<T> syncRequest(MultiRead<T> request,\r
1520                         AsyncMultiListener<T> procedure) throws DatabaseException {\r
1521                 return graph.syncRequest(request, procedure);\r
1522         }\r
1523 \r
1524         @Override\r
1525         public <T> Collection<T> syncRequest(MultiRead<T> request,\r
1526                         SyncMultiListener<T> procedure) throws DatabaseException {\r
1527                 return graph.syncRequest(request, procedure);\r
1528         }\r
1529 \r
1530         @Override\r
1531         public <T> Collection<T> syncRequest(MultiRead<T> request,\r
1532                         MultiListener<T> procedure) throws DatabaseException {\r
1533                 return graph.syncRequest(request, procedure);\r
1534         }\r
1535 \r
1536         @Override\r
1537         public <T> Collection<T> syncRequest(MultiRead<T> request,\r
1538                         AsyncMultiProcedure<T> procedure) throws DatabaseException {\r
1539                 return graph.syncRequest(request, procedure);\r
1540         }\r
1541 \r
1542         @Override\r
1543         public <T> Collection<T> syncRequest(MultiRead<T> request,\r
1544                         SyncMultiProcedure<T> procedure) throws DatabaseException {\r
1545                 return graph.syncRequest(request, procedure);\r
1546         }\r
1547 \r
1548         @Override\r
1549         public <T> Collection<T> syncRequest(MultiRead<T> request,\r
1550                         MultiProcedure<T> procedure) throws DatabaseException {\r
1551                 return graph.syncRequest(request, procedure);\r
1552         }\r
1553 \r
1554         @Override\r
1555         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request)\r
1556                         throws DatabaseException {\r
1557                 return graph.syncRequest(request);\r
1558         }\r
1559 \r
1560         @Override\r
1561         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,\r
1562                         AsyncMultiListener<T> procedure) throws DatabaseException {\r
1563                 return graph.syncRequest(request, procedure);\r
1564         }\r
1565 \r
1566         @Override\r
1567         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,\r
1568                         SyncMultiListener<T> procedure) throws DatabaseException {\r
1569                 return graph.syncRequest(request, procedure);\r
1570         }\r
1571 \r
1572         @Override\r
1573         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,\r
1574                         MultiListener<T> procedure) throws DatabaseException {\r
1575                 return graph.syncRequest(request, procedure);\r
1576         }\r
1577 \r
1578         @Override\r
1579         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,\r
1580                         AsyncMultiProcedure<T> procedure) throws DatabaseException {\r
1581                 return graph.syncRequest(request, procedure);\r
1582         }\r
1583 \r
1584         @Override\r
1585         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,\r
1586                         SyncMultiProcedure<T> procedure) throws DatabaseException {\r
1587                 return graph.syncRequest(request, procedure);\r
1588         }\r
1589 \r
1590         @Override\r
1591         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,\r
1592                         MultiProcedure<T> procedure) throws DatabaseException {\r
1593                 return graph.syncRequest(request, procedure);\r
1594         }\r
1595 \r
1596         @Override\r
1597         public <T> T syncRequest(ExternalRead<T> request)\r
1598                         throws DatabaseException {\r
1599                 return graph.syncRequest(request);\r
1600         }\r
1601 \r
1602         @Override\r
1603         public <T> T syncRequest(ExternalRead<T> request, Listener<T> procedure)\r
1604                         throws DatabaseException {\r
1605                 return graph.syncRequest(request, procedure);\r
1606         }\r
1607 \r
1608         @Override\r
1609         public <T> T syncRequest(ExternalRead<T> request, Procedure<T> procedure)\r
1610                         throws DatabaseException {\r
1611                 return graph.syncRequest(request, procedure);\r
1612         }\r
1613 \r
1614         @Override\r
1615         public void syncRequest(Write request) throws DatabaseException {\r
1616                 graph.syncRequest(request);\r
1617         }\r
1618 \r
1619         @Override\r
1620         public void syncRequest(DelayedWrite request) throws DatabaseException {\r
1621                 graph.syncRequest(request);\r
1622         }\r
1623 \r
1624         @Override\r
1625         public void syncRequest(WriteOnly r) throws DatabaseException {\r
1626                 graph.syncRequest(r);\r
1627         }\r
1628 \r
1629         @Override\r
1630         public <T> T syncRequest(WriteResult<T> request)\r
1631                         throws DatabaseException {\r
1632                 return graph.syncRequest(request);\r
1633         }\r
1634 \r
1635         @Override\r
1636         public <T> T syncRequest(DelayedWriteResult<T> request)\r
1637                         throws DatabaseException {\r
1638                 return graph.syncRequest(request);\r
1639         }\r
1640 \r
1641         @Override\r
1642         public <T> T syncRequest(WriteOnlyResult<T> r) throws DatabaseException {\r
1643                 return graph.syncRequest(r);\r
1644         }\r
1645 \r
1646         @Override\r
1647         public void forURI(Resource resource, AsyncListener<String> procedure) {\r
1648                 graph.forURI(resource, procedure);\r
1649         }\r
1650 \r
1651         @Override\r
1652         public void forURI(Resource resource, SyncListener<String> procedure) {\r
1653                 graph.forURI(resource, procedure);\r
1654         }\r
1655 \r
1656         @Override\r
1657         public void forURI(Resource resource, Listener<String> procedure) {\r
1658                 graph.forURI(resource, procedure);\r
1659         }\r
1660 \r
1661         @Override\r
1662         public void forURI(Resource resource, AsyncProcedure<String> procedure) {\r
1663                 graph.forURI(resource, procedure);\r
1664         }\r
1665 \r
1666         @Override\r
1667         public void forURI(Resource resource, SyncProcedure<String> procedure) {\r
1668                 graph.forURI(resource, procedure);\r
1669         }\r
1670 \r
1671         @Override\r
1672         public void forURI(Resource resource, Procedure<String> procedure) {\r
1673                 graph.forURI(resource, procedure);\r
1674         }\r
1675 \r
1676         @Override\r
1677         public void forResource(String id, AsyncListener<Resource> procedure) {\r
1678                 graph.forResource(id, procedure);\r
1679         }\r
1680 \r
1681         @Override\r
1682         public void forResource(String id, SyncListener<Resource> procedure) {\r
1683                 graph.forResource(id, procedure);\r
1684         }\r
1685 \r
1686         @Override\r
1687         public void forResource(String id, Listener<Resource> procedure) {\r
1688                 graph.forResource(id, procedure);\r
1689         }\r
1690 \r
1691         @Override\r
1692         public void forResource(String id, AsyncProcedure<Resource> procedure) {\r
1693                 graph.forResource(id, procedure);\r
1694         }\r
1695 \r
1696         @Override\r
1697         public void forResource(String id, SyncProcedure<Resource> procedure) {\r
1698                 graph.forResource(id, procedure);\r
1699         }\r
1700 \r
1701         @Override\r
1702         public void forResource(String id, Procedure<Resource> procedure) {\r
1703                 graph.forResource(id, procedure);\r
1704         }\r
1705 \r
1706         @Override\r
1707         public void forStatementSet(Resource subject, Resource relation,\r
1708                         AsyncSetListener<Statement> procedure) {\r
1709                 graph.forStatementSet(subject, relation, procedure);\r
1710         }\r
1711 \r
1712         @Override\r
1713         public void forStatementSet(Resource subject, Resource relation,\r
1714                         SyncSetListener<Statement> procedure) {\r
1715                 graph.forStatementSet(subject, relation, procedure);\r
1716         }\r
1717 \r
1718         @Override\r
1719         public void forStatementSet(Resource subject, Resource relation,\r
1720                         SetListener<Statement> procedure) {\r
1721                 graph.forStatementSet(subject, relation, procedure);\r
1722         }\r
1723 \r
1724         @Override\r
1725         public void forPredicateSet(Resource subject,\r
1726                         AsyncSetListener<Resource> procedure) {\r
1727                 graph.forPredicateSet(subject, procedure);\r
1728         }\r
1729 \r
1730         @Override\r
1731         public void forPredicateSet(Resource subject,\r
1732                         SyncSetListener<Resource> procedure) {\r
1733                 graph.forPredicateSet(subject, procedure);\r
1734         }\r
1735 \r
1736         @Override\r
1737         public void forPredicateSet(Resource subject,\r
1738                         SetListener<Resource> procedure) {\r
1739                 graph.forPredicateSet(subject, procedure);\r
1740         }\r
1741 \r
1742         @Override\r
1743         public void forPrincipalTypeSet(Resource subject,\r
1744                         AsyncSetListener<Resource> procedure) {\r
1745                 graph.forPrincipalTypeSet(subject, procedure);\r
1746         }\r
1747 \r
1748         @Override\r
1749         public void forPrincipalTypeSet(Resource subject,\r
1750                         SyncSetListener<Resource> procedure) {\r
1751                 graph.forPrincipalTypeSet(subject, procedure);\r
1752         }\r
1753 \r
1754         @Override\r
1755         public void forPrincipalTypeSet(Resource subject,\r
1756                         SetListener<Resource> procedure) {\r
1757                 graph.forPrincipalTypeSet(subject, procedure);\r
1758         }\r
1759 \r
1760         @Override\r
1761         public void forTypes(Resource subject,\r
1762                         AsyncListener<Set<Resource>> procedure) {\r
1763                 graph.forTypes(subject, procedure);\r
1764         }\r
1765 \r
1766         @Override\r
1767         public void forTypes(Resource subject,\r
1768                         SyncListener<Set<Resource>> procedure) {\r
1769                 graph.forTypes(subject, procedure);\r
1770         }\r
1771 \r
1772         @Override\r
1773         public void forTypes(Resource subject, Listener<Set<Resource>> procedure) {\r
1774                 graph.forTypes(subject, procedure);             \r
1775         }\r
1776 \r
1777         @Override\r
1778         public void forTypes(Resource subject,\r
1779                         AsyncProcedure<Set<Resource>> procedure) {\r
1780                 graph.forTypes(subject, procedure);             \r
1781         }\r
1782 \r
1783         @Override\r
1784         public void forTypes(Resource subject,\r
1785                         SyncProcedure<Set<Resource>> procedure) {\r
1786                 graph.forTypes(subject, procedure);             \r
1787         }\r
1788 \r
1789         @Override\r
1790         public void forTypes(Resource subject,\r
1791                         Procedure<Set<Resource>> procedure) {\r
1792                 graph.forTypes(subject, procedure);             \r
1793         }\r
1794 \r
1795         @Override\r
1796         public void forSupertypes(Resource subject,\r
1797                         AsyncListener<Set<Resource>> procedure) {\r
1798                 graph.forSupertypes(subject, procedure);                \r
1799         }\r
1800 \r
1801         @Override\r
1802         public void forSupertypes(Resource subject,\r
1803                         SyncListener<Set<Resource>> procedure) {\r
1804                 graph.forSupertypes(subject, procedure);\r
1805         }\r
1806 \r
1807         @Override\r
1808         public void forSupertypes(Resource subject,\r
1809                         Listener<Set<Resource>> procedure) {\r
1810                 graph.forSupertypes(subject, procedure);\r
1811         }\r
1812 \r
1813         @Override\r
1814         public void forSupertypes(Resource subject,\r
1815                         AsyncProcedure<Set<Resource>> procedure) {\r
1816                 graph.forSupertypes(subject, procedure);\r
1817         }\r
1818 \r
1819         @Override\r
1820         public void forSupertypes(Resource subject,\r
1821                         SyncProcedure<Set<Resource>> procedure) {\r
1822                 graph.forSupertypes(subject, procedure);\r
1823         }\r
1824 \r
1825         @Override\r
1826         public void forSupertypes(Resource subject,\r
1827                         Procedure<Set<Resource>> procedure) {\r
1828                 graph.forSupertypes(subject, procedure);\r
1829         }\r
1830 \r
1831         @Override\r
1832         public void forPossibleSuperrelation(Resource subject,\r
1833                         AsyncProcedure<Resource> procedure) {\r
1834                 graph.forPossibleSuperrelation(subject, procedure);             \r
1835         }\r
1836 \r
1837         @Override\r
1838         public void forSuperrelations(Resource subject,\r
1839                         AsyncListener<Set<Resource>> procedure) {\r
1840                 graph.forSuperrelations(subject, procedure);\r
1841         }\r
1842 \r
1843         @Override\r
1844         public void forSuperrelations(Resource subject,\r
1845                         SyncListener<Set<Resource>> procedure) {\r
1846                 graph.forSuperrelations(subject, procedure);\r
1847         }\r
1848 \r
1849         @Override\r
1850         public void forSuperrelations(Resource subject,\r
1851                         Listener<Set<Resource>> procedure) {\r
1852                 graph.forSuperrelations(subject, procedure);\r
1853         }\r
1854 \r
1855         @Override\r
1856         public void forSuperrelations(Resource subject,\r
1857                         AsyncProcedure<Set<Resource>> procedure) {\r
1858                 graph.forSuperrelations(subject, procedure);\r
1859         }\r
1860 \r
1861         @Override\r
1862         public void forSuperrelations(Resource subject,\r
1863                         SyncProcedure<Set<Resource>> procedure) {\r
1864                 graph.forSuperrelations(subject, procedure);\r
1865         }\r
1866 \r
1867         @Override\r
1868         public void forSuperrelations(Resource subject,\r
1869                         Procedure<Set<Resource>> procedure) {\r
1870                 graph.forSuperrelations(subject, procedure);\r
1871         }\r
1872 \r
1873         @Override\r
1874         public void forObjectSet(Resource subject, Resource relation,\r
1875                         AsyncSetListener<Resource> procedure) {\r
1876                 graph.forObjectSet(subject, relation, procedure);\r
1877         }\r
1878 \r
1879         @Override\r
1880         public void forObjectSet(Resource subject, Resource relation,\r
1881                         SyncSetListener<Resource> procedure) {\r
1882                 graph.forObjectSet(subject, relation, procedure);\r
1883         }\r
1884 \r
1885         @Override\r
1886         public void forObjectSet(Resource subject, Resource relation,\r
1887                         SetListener<Resource> procedure) {\r
1888                 graph.forObjectSet(subject, relation, procedure);\r
1889         }\r
1890 \r
1891         @Override\r
1892         public void forInverse(Resource relation,\r
1893                         SyncListener<Resource> procedure) {\r
1894                 graph.forInverse(relation, procedure);\r
1895         }\r
1896 \r
1897         @Override\r
1898         public void forInverse(Resource relation, Listener<Resource> procedure) {\r
1899                 graph.forInverse(relation, procedure);\r
1900         }\r
1901 \r
1902         @Override\r
1903         public void forInverse(Resource relation,\r
1904                         AsyncProcedure<Resource> procedure) {\r
1905                 graph.forInverse(relation, procedure);\r
1906         }\r
1907 \r
1908         @Override\r
1909         public void forInverse(Resource relation,\r
1910                         SyncProcedure<Resource> procedure) {\r
1911                 graph.forInverse(relation, procedure);\r
1912         }\r
1913 \r
1914         @Override\r
1915         public void forInverse(Resource relation, Procedure<Resource> procedure) {\r
1916                 graph.forInverse(relation, procedure);\r
1917         }\r
1918 \r
1919         @Override\r
1920         public void forSingleObject(Resource subject, Resource relation,\r
1921                         AsyncListener<Resource> procedure) {\r
1922                 graph.forSingleObject(subject, relation, procedure);\r
1923         }\r
1924 \r
1925         @Override\r
1926         public void forSingleObject(Resource subject, Resource relation,\r
1927                         SyncListener<Resource> procedure) {\r
1928                 graph.forSingleObject(subject, relation, procedure);\r
1929         }\r
1930 \r
1931         @Override\r
1932         public void forSingleObject(Resource subject, Resource relation,\r
1933                         Listener<Resource> procedure) {\r
1934                 graph.forSingleObject(subject, relation, procedure);            \r
1935         }\r
1936 \r
1937         @Override\r
1938         public void forSingleObject(Resource subject, Resource relation,\r
1939                         AsyncProcedure<Resource> procedure) {\r
1940                 graph.forSingleObject(subject, relation, procedure);            \r
1941         }\r
1942 \r
1943         @Override\r
1944         public void forSingleObject(Resource subject, Resource relation,\r
1945                         SyncProcedure<Resource> procedure) {\r
1946                 graph.forSingleObject(subject, relation, procedure);\r
1947         }\r
1948 \r
1949         @Override\r
1950         public void forSingleObject(Resource subject, Resource relation,\r
1951                         Procedure<Resource> procedure) {\r
1952                 graph.forSingleObject(subject, relation, procedure);\r
1953         }\r
1954 \r
1955         @Override\r
1956         public void forSingleStatement(Resource subject, Resource relation,\r
1957                         AsyncListener<Statement> procedure) {\r
1958                 graph.forSingleStatement(subject, relation, procedure);\r
1959         }\r
1960 \r
1961         @Override\r
1962         public void forSingleStatement(Resource subject, Resource relation,\r
1963                         SyncListener<Statement> procedure) {\r
1964                 graph.forSingleStatement(subject, relation, procedure);\r
1965         }\r
1966 \r
1967         @Override\r
1968         public void forSingleStatement(Resource subject, Resource relation,\r
1969                         Listener<Statement> procedure) {\r
1970                 graph.forSingleStatement(subject, relation, procedure);\r
1971         }\r
1972 \r
1973         @Override\r
1974         public void forSingleStatement(Resource subject, Resource relation,\r
1975                         AsyncProcedure<Statement> procedure) {\r
1976                 graph.forSingleStatement(subject, relation, procedure);\r
1977         }\r
1978 \r
1979         @Override\r
1980         public void forSingleStatement(Resource subject, Resource relation,\r
1981                         SyncProcedure<Statement> procedure) {\r
1982                 graph.forSingleStatement(subject, relation, procedure);\r
1983         }\r
1984 \r
1985         @Override\r
1986         public void forSingleStatement(Resource subject, Resource relation,\r
1987                         Procedure<Statement> procedure) {\r
1988                 graph.forSingleStatement(subject, relation, procedure);\r
1989         }\r
1990 \r
1991         @Override\r
1992         public void forSingleType(Resource subject,\r
1993                         AsyncListener<Resource> procedure) {\r
1994                 graph.forSingleType(subject, procedure);\r
1995         }\r
1996 \r
1997         @Override\r
1998         public void forSingleType(Resource subject,\r
1999                         SyncListener<Resource> procedure) {\r
2000                 graph.forSingleType(subject, procedure);\r
2001         }\r
2002 \r
2003         @Override\r
2004         public void forSingleType(Resource subject, Listener<Resource> procedure) {\r
2005                 graph.forSingleType(subject, procedure);\r
2006         }\r
2007 \r
2008         @Override\r
2009         public void forSingleType(Resource subject,\r
2010                         AsyncProcedure<Resource> procedure) {\r
2011                 graph.forSingleType(subject, procedure);\r
2012         }\r
2013 \r
2014         @Override\r
2015         public void forSingleType(Resource subject,\r
2016                         SyncProcedure<Resource> procedure) {\r
2017                 graph.forSingleType(subject, procedure);\r
2018         }\r
2019 \r
2020         @Override\r
2021         public void forSingleType(Resource subject,\r
2022                         Procedure<Resource> procedure) {\r
2023                 graph.forSingleType(subject, procedure);\r
2024         }\r
2025 \r
2026         @Override\r
2027         public void forSingleType(Resource subject, Resource baseType,\r
2028                         AsyncListener<Resource> procedure) {\r
2029                 graph.forSingleType(subject, baseType, procedure);\r
2030         }\r
2031 \r
2032         @Override\r
2033         public void forSingleType(Resource subject, Resource baseType,\r
2034                         SyncListener<Resource> procedure) {\r
2035                 graph.forSingleType(subject, baseType, procedure);\r
2036         }\r
2037 \r
2038         @Override\r
2039         public void forSingleType(Resource subject, Resource baseType,\r
2040                         Listener<Resource> procedure) {\r
2041                 graph.forSingleType(subject, baseType, procedure);\r
2042         }\r
2043 \r
2044         @Override\r
2045         public void forSingleType(Resource subject, Resource baseType,\r
2046                         AsyncProcedure<Resource> procedure) {\r
2047                 graph.forSingleType(subject, baseType, procedure);\r
2048         }\r
2049 \r
2050         @Override\r
2051         public void forSingleType(Resource subject, Resource baseType,\r
2052                         SyncProcedure<Resource> procedure) {\r
2053                 graph.forSingleType(subject, baseType, procedure);\r
2054         }\r
2055 \r
2056         @Override\r
2057         public void forSingleType(Resource subject, Resource baseType,\r
2058                         Procedure<Resource> procedure) {\r
2059                 graph.forSingleType(subject, baseType, procedure);\r
2060         }\r
2061 \r
2062         @Override\r
2063         public <T> void forValue(Resource subject, AsyncListener<T> procedure) {\r
2064                 graph.forValue(subject, procedure);\r
2065         }\r
2066 \r
2067         @Override\r
2068         public <T> void forValue(Resource subject, SyncListener<T> procedure) {\r
2069                 graph.forValue(subject, procedure);\r
2070         }\r
2071 \r
2072         @Override\r
2073         public <T> void forValue(Resource subject, Listener<T> procedure) {\r
2074                 graph.forValue(subject, procedure);\r
2075         }\r
2076 \r
2077         @Override\r
2078         public <T> void forValue(Resource subject, AsyncProcedure<T> procedure) {\r
2079                 graph.forValue(subject, procedure);\r
2080         }\r
2081 \r
2082         @Override\r
2083         public <T> void forValue(Resource subject, SyncProcedure<T> procedure) {\r
2084                 graph.forValue(subject, procedure);\r
2085         }\r
2086 \r
2087         @Override\r
2088         public <T> void forValue(Resource subject, Procedure<T> procedure) {\r
2089                 graph.forValue(subject, procedure);\r
2090         }\r
2091 \r
2092         @Override\r
2093         public <T> void forValue(Resource subject, Binding binding,\r
2094                         AsyncListener<T> procedure) {\r
2095                 graph.forValue(subject, binding, procedure);\r
2096         }\r
2097 \r
2098         @Override\r
2099         public <T> void forValue(Resource subject, Binding binding,\r
2100                         SyncListener<T> procedure) {\r
2101                 graph.forValue(subject, binding, procedure);\r
2102         }\r
2103 \r
2104         @Override\r
2105         public <T> void forValue(Resource subject, Binding binding,\r
2106                         Listener<T> procedure) {\r
2107                 graph.forValue(subject, binding, procedure);\r
2108         }\r
2109 \r
2110         @Override\r
2111         public <T> void forValue(Resource subject, Binding binding,\r
2112                         AsyncProcedure<T> procedure) {\r
2113                 graph.forValue(subject, binding, procedure);\r
2114         }\r
2115 \r
2116         @Override\r
2117         public <T> void forValue(Resource subject, Binding binding,\r
2118                         SyncProcedure<T> procedure) {\r
2119                 graph.forValue(subject, binding, procedure);\r
2120         }\r
2121 \r
2122         @Override\r
2123         public <T> void forValue(Resource subject, Binding binding,\r
2124                         Procedure<T> procedure) {\r
2125                 graph.forValue(subject, binding, procedure);\r
2126         }\r
2127 \r
2128         @Override\r
2129         public <T> void forRelatedValue(Resource subject, Resource relation,\r
2130                         AsyncListener<T> procedure) {\r
2131                 graph.forRelatedValue(subject, relation, procedure);\r
2132         }\r
2133 \r
2134         @Override\r
2135         public <T> void forRelatedValue(Resource subject, Resource relation,\r
2136                         SyncListener<T> procedure) {\r
2137                 graph.forRelatedValue(subject, relation, procedure);\r
2138         }\r
2139 \r
2140         @Override\r
2141         public <T> void forRelatedValue(Resource subject, Resource relation,\r
2142                         Listener<T> procedure) {\r
2143                 graph.forRelatedValue(subject, relation, procedure);\r
2144         }\r
2145 \r
2146         @Override\r
2147         public <T> void forRelatedValue(Resource subject, Resource relation,\r
2148                         AsyncProcedure<T> procedure) {\r
2149                 graph.forRelatedValue(subject, relation, procedure);\r
2150         }\r
2151 \r
2152         @Override\r
2153         public <T> void forRelatedValue(Resource subject, Resource relation,\r
2154                         SyncProcedure<T> procedure) {\r
2155                 graph.forRelatedValue(subject, relation, procedure);\r
2156         }\r
2157 \r
2158         @Override\r
2159         public <T> void forRelatedValue(Resource subject, Resource relation,\r
2160                         Procedure<T> procedure) {\r
2161                 graph.forRelatedValue(subject, relation, procedure);\r
2162         }\r
2163 \r
2164         @Override\r
2165         public <T> void forRelatedValue(Resource subject, Resource relation,\r
2166                         Binding binding, AsyncListener<T> procedure) {\r
2167                 graph.forRelatedValue(subject, relation, binding, procedure);\r
2168         }\r
2169 \r
2170         @Override\r
2171         public <T> void forRelatedValue(Resource subject, Resource relation,\r
2172                         Binding binding, SyncListener<T> procedure) {\r
2173                 graph.forRelatedValue(subject, relation, binding, procedure);\r
2174         }\r
2175 \r
2176         @Override\r
2177         public <T> void forRelatedValue(Resource subject, Resource relation,\r
2178                         Binding binding, Listener<T> procedure) {\r
2179                 graph.forRelatedValue(subject, relation, binding, procedure);\r
2180         }\r
2181 \r
2182         @Override\r
2183         public <T> void forRelatedValue(Resource subject, Resource relation,\r
2184                         Binding binding, AsyncProcedure<T> procedure) {\r
2185                 graph.forRelatedValue(subject, relation, binding, procedure);\r
2186         }\r
2187 \r
2188         @Override\r
2189         public <T> void forRelatedValue(Resource subject, Resource relation,\r
2190                         Binding binding, SyncProcedure<T> procedure) {\r
2191                 graph.forRelatedValue(subject, relation, binding, procedure);\r
2192         }\r
2193 \r
2194         @Override\r
2195         public <T> void forRelatedValue(Resource subject, Resource relation,\r
2196                         Binding binding, Procedure<T> procedure) {\r
2197                 graph.forRelatedValue(subject, relation, binding, procedure);\r
2198         }\r
2199 \r
2200         @Override\r
2201         public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,\r
2202                         AsyncListener<T> procedure) {\r
2203                 graph.forUniqueAdapted(resource, clazz, procedure);\r
2204         }\r
2205 \r
2206         @Override\r
2207         public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,\r
2208                         SyncListener<T> procedure) {\r
2209                 graph.forUniqueAdapted(resource, clazz, procedure);\r
2210         }\r
2211 \r
2212         @Override\r
2213         public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,\r
2214                         Listener<T> procedure) {\r
2215                 graph.forUniqueAdapted(resource, clazz, procedure);\r
2216         }\r
2217 \r
2218         @Override\r
2219         public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,\r
2220                         AsyncProcedure<T> procedure) {\r
2221                 graph.forUniqueAdapted(resource, clazz, procedure);\r
2222         }\r
2223 \r
2224         @Override\r
2225         public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,\r
2226                         SyncProcedure<T> procedure) {\r
2227                 graph.forUniqueAdapted(resource, clazz, procedure);\r
2228         }\r
2229 \r
2230         @Override\r
2231         public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,\r
2232                         Procedure<T> procedure) {\r
2233                 graph.forUniqueAdapted(resource, clazz, procedure);\r
2234         }\r
2235 \r
2236         @Override\r
2237         public void forPossibleInverse(Resource relation,\r
2238                         AsyncListener<Resource> procedure) {\r
2239                 graph.forPossibleInverse(relation, procedure);\r
2240         }\r
2241 \r
2242         @Override\r
2243         public void forPossibleInverse(Resource relation,\r
2244                         SyncListener<Resource> procedure) {\r
2245                 graph.forPossibleInverse(relation, procedure);\r
2246         }\r
2247 \r
2248         @Override\r
2249         public void forPossibleInverse(Resource relation,\r
2250                         Listener<Resource> procedure) {\r
2251                 graph.forPossibleInverse(relation, procedure);\r
2252         }\r
2253 \r
2254         @Override\r
2255         public void forPossibleInverse(Resource relation,\r
2256                         AsyncProcedure<Resource> procedure) {\r
2257                 graph.forPossibleInverse(relation, procedure);\r
2258         }\r
2259 \r
2260         @Override\r
2261         public void forPossibleInverse(Resource relation,\r
2262                         SyncProcedure<Resource> procedure) {\r
2263                 graph.forPossibleInverse(relation, procedure);\r
2264         }\r
2265 \r
2266         @Override\r
2267         public void forPossibleInverse(Resource relation,\r
2268                         Procedure<Resource> procedure) {\r
2269                 graph.forPossibleInverse(relation, procedure);\r
2270         }\r
2271 \r
2272         @Override\r
2273         public void forPossibleObject(Resource subject, Resource relation,\r
2274                         AsyncListener<Resource> procedure) {\r
2275                 graph.forPossibleObject(subject, relation, procedure);\r
2276         }\r
2277 \r
2278         @Override\r
2279         public void forPossibleObject(Resource subject, Resource relation,\r
2280                         SyncListener<Resource> procedure) {\r
2281                 graph.forPossibleObject(subject, relation, procedure);\r
2282         }\r
2283 \r
2284         @Override\r
2285         public void forPossibleObject(Resource subject, Resource relation,\r
2286                         Listener<Resource> procedure) {\r
2287                 graph.forPossibleObject(subject, relation, procedure);\r
2288         }\r
2289 \r
2290         @Override\r
2291         public void forPossibleObject(Resource subject, Resource relation,\r
2292                         AsyncProcedure<Resource> procedure) {\r
2293                 graph.forPossibleObject(subject, relation, procedure);\r
2294         }\r
2295 \r
2296         @Override\r
2297         public void forPossibleObject(Resource subject, Resource relation,\r
2298                         SyncProcedure<Resource> procedure) {\r
2299                 graph.forPossibleObject(subject, relation, procedure);\r
2300         }\r
2301 \r
2302         @Override\r
2303         public void forPossibleObject(Resource subject, Resource relation,\r
2304                         Procedure<Resource> procedure) {\r
2305                 graph.forPossibleObject(subject, relation, procedure);\r
2306         }\r
2307 \r
2308         @Override\r
2309         public void forPossibleStatement(Resource subject, Resource relation,\r
2310                         AsyncListener<Statement> procedure) {\r
2311                 graph.forPossibleStatement(subject, relation, procedure);\r
2312         }\r
2313 \r
2314         @Override\r
2315         public void forPossibleStatement(Resource subject, Resource relation,\r
2316                         SyncListener<Statement> procedure) {\r
2317                 graph.forPossibleStatement(subject, relation, procedure);\r
2318         }\r
2319 \r
2320         @Override\r
2321         public void forPossibleStatement(Resource subject, Resource relation,\r
2322                         Listener<Statement> procedure) {\r
2323                 graph.forPossibleStatement(subject, relation, procedure);\r
2324         }\r
2325 \r
2326         @Override\r
2327         public void forPossibleStatement(Resource subject, Resource relation,\r
2328                         AsyncProcedure<Statement> procedure) {\r
2329                 graph.forPossibleStatement(subject, relation, procedure);\r
2330         }\r
2331 \r
2332         @Override\r
2333         public void forPossibleStatement(Resource subject, Resource relation,\r
2334                         SyncProcedure<Statement> procedure) {\r
2335                 graph.forPossibleStatement(subject, relation, procedure);\r
2336         }\r
2337 \r
2338         @Override\r
2339         public void forPossibleStatement(Resource subject, Resource relation,\r
2340                         Procedure<Statement> procedure) {\r
2341                 graph.forPossibleStatement(subject, relation, procedure);\r
2342         }\r
2343 \r
2344         @Override\r
2345         public void forPossibleType(Resource subject, Resource baseType,\r
2346                         AsyncListener<Resource> procedure) {\r
2347                 graph.forPossibleType(subject, baseType, procedure);\r
2348         }\r
2349 \r
2350         @Override\r
2351         public void forPossibleType(Resource subject, Resource baseType,\r
2352                         SyncListener<Resource> procedure) {\r
2353                 graph.forPossibleType(subject, baseType, procedure);\r
2354         }\r
2355 \r
2356         @Override\r
2357         public void forPossibleType(Resource subject, Resource baseType,\r
2358                         Listener<Resource> procedure) {\r
2359                 graph.forPossibleType(subject, baseType, procedure);\r
2360         }\r
2361 \r
2362         @Override\r
2363         public void forPossibleType(Resource subject, Resource baseType,\r
2364                         AsyncProcedure<Resource> procedure) {\r
2365                 graph.forPossibleType(subject, baseType, procedure);\r
2366         }\r
2367 \r
2368         @Override\r
2369         public void forPossibleType(Resource subject, Resource baseType,\r
2370                         SyncProcedure<Resource> procedure) {\r
2371                 graph.forPossibleType(subject, baseType, procedure);\r
2372         }\r
2373 \r
2374         @Override\r
2375         public void forPossibleType(Resource subject, Resource baseType,\r
2376                         Procedure<Resource> procedure) {\r
2377                 graph.forPossibleType(subject, baseType, procedure);\r
2378         }\r
2379 \r
2380         @Override\r
2381         public <T> void forPossibleValue(Resource subject,\r
2382                         AsyncListener<T> procedure) {\r
2383                 graph.forPossibleValue(subject, procedure);\r
2384         }\r
2385 \r
2386         @Override\r
2387         public <T> void forPossibleValue(Resource subject,\r
2388                         SyncListener<T> procedure) {\r
2389                 graph.forPossibleValue(subject, procedure);\r
2390         }\r
2391 \r
2392         @Override\r
2393         public <T> void forPossibleValue(Resource subject, Listener<T> procedure) {\r
2394                 graph.forPossibleValue(subject, procedure);\r
2395         }\r
2396 \r
2397         @Override\r
2398         public <T> void forPossibleValue(Resource subject,\r
2399                         AsyncProcedure<T> procedure) {\r
2400                 graph.forPossibleValue(subject, procedure);\r
2401         }\r
2402 \r
2403         @Override\r
2404         public <T> void forPossibleValue(Resource subject,\r
2405                         SyncProcedure<T> procedure) {\r
2406                 graph.forPossibleValue(subject, procedure);\r
2407         }\r
2408 \r
2409         @Override\r
2410         public <T> void forPossibleValue(Resource subject,\r
2411                         Procedure<T> procedure) {\r
2412                 graph.forPossibleValue(subject, procedure);\r
2413         }\r
2414 \r
2415         @Override\r
2416         public <T> void forPossibleValue(Resource subject, Binding binding,\r
2417                         AsyncListener<T> procedure) {\r
2418                 graph.forPossibleValue(subject, procedure);\r
2419         }\r
2420 \r
2421         @Override\r
2422         public <T> void forPossibleValue(Resource subject, Binding binding,\r
2423                         SyncListener<T> procedure) {\r
2424                 graph.forPossibleValue(subject, procedure);\r
2425         }\r
2426 \r
2427         @Override\r
2428         public <T> void forPossibleValue(Resource subject, Binding binding,\r
2429                         Listener<T> procedure) {\r
2430                 graph.forPossibleValue(subject, procedure);\r
2431         }\r
2432 \r
2433         @Override\r
2434         public <T> void forPossibleValue(Resource subject, Binding binding,\r
2435                         AsyncProcedure<T> procedure) {\r
2436                 graph.forPossibleValue(subject, procedure);\r
2437         }\r
2438 \r
2439         @Override\r
2440         public <T> void forPossibleValue(Resource subject, Binding binding,\r
2441                         SyncProcedure<T> procedure) {\r
2442                 graph.forPossibleValue(subject, procedure);\r
2443         }\r
2444 \r
2445         @Override\r
2446         public <T> void forPossibleValue(Resource subject, Binding binding,\r
2447                         Procedure<T> procedure) {\r
2448                 graph.forPossibleValue(subject, procedure);\r
2449         }\r
2450 \r
2451         @Override\r
2452         public <T> void forPossibleRelatedValue(Resource subject,\r
2453                         Resource relation, AsyncListener<T> procedure) {\r
2454                 graph.forPossibleRelatedValue(subject, relation, procedure);\r
2455         }\r
2456 \r
2457         @Override\r
2458         public <T> void forPossibleRelatedValue(Resource subject,\r
2459                         Resource relation, SyncListener<T> procedure) {\r
2460                 graph.forPossibleRelatedValue(subject, relation, procedure);\r
2461         }\r
2462 \r
2463         @Override\r
2464         public <T> void forPossibleRelatedValue(Resource subject,\r
2465                         Resource relation, Listener<T> procedure) {\r
2466                 graph.forPossibleRelatedValue(subject, relation, procedure);\r
2467         }\r
2468 \r
2469         @Override\r
2470         public <T> void forPossibleRelatedValue(Resource subject,\r
2471                         Resource relation, AsyncProcedure<T> procedure) {\r
2472                 graph.forPossibleRelatedValue(subject, relation, procedure);\r
2473         }\r
2474 \r
2475         @Override\r
2476         public <T> void forPossibleRelatedValue(Resource subject,\r
2477                         Resource relation, SyncProcedure<T> procedure) {\r
2478                 graph.forPossibleRelatedValue(subject, relation, procedure);\r
2479         }\r
2480 \r
2481         @Override\r
2482         public <T> void forPossibleRelatedValue(Resource subject,\r
2483                         Resource relation, Procedure<T> procedure) {\r
2484                 graph.forPossibleRelatedValue(subject, relation, procedure);\r
2485         }\r
2486 \r
2487         @Override\r
2488         public <T> void forPossibleRelatedValue(Resource subject,\r
2489                         Resource relation, Binding binding, AsyncListener<T> procedure) {\r
2490                 graph.forPossibleRelatedValue(subject, relation, binding, procedure);\r
2491         }\r
2492 \r
2493         @Override\r
2494         public <T> void forPossibleRelatedValue(Resource subject,\r
2495                         Resource relation, Binding binding, SyncListener<T> procedure) {\r
2496                 graph.forPossibleRelatedValue(subject, relation, procedure);\r
2497         }\r
2498 \r
2499         @Override\r
2500         public <T> void forPossibleRelatedValue(Resource subject,\r
2501                         Resource relation, Binding binding, Listener<T> procedure) {\r
2502                 graph.forPossibleRelatedValue(subject, relation, binding, procedure);\r
2503         }\r
2504 \r
2505         @Override\r
2506         public <T> void forPossibleRelatedValue(Resource subject,\r
2507                         Resource relation, Binding binding, AsyncProcedure<T> procedure) {\r
2508                 graph.forPossibleRelatedValue(subject, relation, binding, procedure);\r
2509         }\r
2510 \r
2511         @Override\r
2512         public <T> void forPossibleRelatedValue(Resource subject,\r
2513                         Resource relation, Binding binding, SyncProcedure<T> procedure) {\r
2514                 graph.forPossibleRelatedValue(subject, relation, binding, procedure);\r
2515         }\r
2516 \r
2517         @Override\r
2518         public <T> void forPossibleRelatedValue(Resource subject,\r
2519                         Resource relation, Binding binding, Procedure<T> procedure) {\r
2520                 graph.forPossibleRelatedValue(subject, relation, binding, procedure);\r
2521         }\r
2522 \r
2523         @Override\r
2524         public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,\r
2525                         AsyncListener<T> procedure) {\r
2526                 graph.forPossibleAdapted(resource, clazz, procedure);\r
2527         }\r
2528 \r
2529         @Override\r
2530         public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,\r
2531                         SyncListener<T> procedure) {\r
2532                 graph.forPossibleAdapted(resource, clazz, procedure);\r
2533         }\r
2534 \r
2535         @Override\r
2536         public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,\r
2537                         Listener<T> procedure) {\r
2538                 graph.forPossibleAdapted(resource, clazz, procedure);\r
2539         }\r
2540 \r
2541         @Override\r
2542         public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,\r
2543                         AsyncProcedure<T> procedure) {\r
2544                 graph.forPossibleAdapted(resource, clazz, procedure);\r
2545         }\r
2546 \r
2547         @Override\r
2548         public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,\r
2549                         SyncProcedure<T> procedure) {\r
2550                 graph.forPossibleAdapted(resource, clazz, procedure);\r
2551         }\r
2552 \r
2553         @Override\r
2554         public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,\r
2555                         Procedure<T> procedure) {\r
2556                 graph.forPossibleAdapted(resource, clazz, procedure);\r
2557         }\r
2558 \r
2559         @Override\r
2560         public <T> void forPossibleUniqueAdapted(Resource resource,\r
2561                         Class<T> clazz, AsyncListener<T> procedure) {\r
2562                 graph.forPossibleUniqueAdapted(resource, clazz, procedure);\r
2563         }\r
2564 \r
2565         @Override\r
2566         public <T> void forPossibleUniqueAdapted(Resource resource,\r
2567                         Class<T> clazz, SyncListener<T> procedure) {\r
2568                 graph.forPossibleUniqueAdapted(resource, clazz, procedure);\r
2569         }\r
2570 \r
2571         @Override\r
2572         public <T> void forPossibleUniqueAdapted(Resource resource,\r
2573                         Class<T> clazz, Listener<T> procedure) {\r
2574                 graph.forPossibleUniqueAdapted(resource, clazz, procedure);\r
2575         }\r
2576 \r
2577         @Override\r
2578         public <T> void forPossibleUniqueAdapted(Resource resource,\r
2579                         Class<T> clazz, AsyncProcedure<T> procedure) {\r
2580                 graph.forPossibleUniqueAdapted(resource, clazz, procedure);\r
2581         }\r
2582 \r
2583         @Override\r
2584         public <T> void forPossibleUniqueAdapted(Resource resource,\r
2585                         Class<T> clazz, SyncProcedure<T> procedure) {\r
2586                 graph.forPossibleUniqueAdapted(resource, clazz, procedure);\r
2587         }\r
2588 \r
2589         @Override\r
2590         public <T> void forPossibleUniqueAdapted(Resource resource,\r
2591                         Class<T> clazz, Procedure<T> procedure) {\r
2592                 graph.forPossibleUniqueAdapted(resource, clazz, procedure);\r
2593         }\r
2594 \r
2595         @Override\r
2596         public void forIsInstanceOf(Resource resource, Resource type,\r
2597                         AsyncListener<Boolean> procedure) {\r
2598                 graph.forIsInstanceOf(resource, type, procedure);\r
2599         }\r
2600 \r
2601         @Override\r
2602         public void forIsInstanceOf(Resource resource, Resource type,\r
2603                         SyncListener<Boolean> procedure) {\r
2604                 graph.forIsInstanceOf(resource, type, procedure);\r
2605         }\r
2606 \r
2607         @Override\r
2608         public void forIsInstanceOf(Resource resource, Resource type,\r
2609                         Listener<Boolean> procedure) {\r
2610                 graph.forIsInstanceOf(resource, type, procedure);\r
2611         }\r
2612 \r
2613         @Override\r
2614         public void forIsInstanceOf(Resource resource, Resource type,\r
2615                         AsyncProcedure<Boolean> procedure) {\r
2616                 graph.forIsInstanceOf(resource, type, procedure);\r
2617         }\r
2618 \r
2619         @Override\r
2620         public void forIsInstanceOf(Resource resource, Resource type,\r
2621                         SyncProcedure<Boolean> procedure) {\r
2622                 graph.forIsInstanceOf(resource, type, procedure);\r
2623         }\r
2624 \r
2625         @Override\r
2626         public void forIsInstanceOf(Resource resource, Resource type,\r
2627                         Procedure<Boolean> procedure) {\r
2628                 graph.forIsInstanceOf(resource, type, procedure);\r
2629         }\r
2630 \r
2631         @Override\r
2632         public void forIsInheritedFrom(Resource resource, Resource type,\r
2633                         AsyncListener<Boolean> procedure) {\r
2634                 graph.forIsInheritedFrom(resource, type, procedure);\r
2635         }\r
2636 \r
2637         @Override\r
2638         public void forIsInheritedFrom(Resource resource, Resource type,\r
2639                         SyncListener<Boolean> procedure) {\r
2640                 graph.forIsInheritedFrom(resource, type, procedure);\r
2641         }\r
2642 \r
2643         @Override\r
2644         public void forIsInheritedFrom(Resource resource, Resource type,\r
2645                         Listener<Boolean> procedure) {\r
2646                 graph.forIsInheritedFrom(resource, type, procedure);\r
2647         }\r
2648 \r
2649         @Override\r
2650         public void forIsInheritedFrom(Resource resource, Resource type,\r
2651                         AsyncProcedure<Boolean> procedure) {\r
2652                 graph.forIsInheritedFrom(resource, type, procedure);\r
2653         }\r
2654 \r
2655         @Override\r
2656         public void forIsInheritedFrom(Resource resource, Resource type,\r
2657                         SyncProcedure<Boolean> procedure) {\r
2658                 graph.forIsInheritedFrom(resource, type, procedure);\r
2659         }\r
2660 \r
2661         @Override\r
2662         public void forIsInheritedFrom(Resource resource, Resource type,\r
2663                         Procedure<Boolean> procedure) {\r
2664                 graph.forIsInheritedFrom(resource, type, procedure);\r
2665         }\r
2666 \r
2667         @Override\r
2668         public void forIsSubrelationOf(Resource resource, Resource relation,\r
2669                         AsyncListener<Boolean> procedure) {\r
2670                 graph.forIsSubrelationOf(resource, relation, procedure);\r
2671         }\r
2672 \r
2673         @Override\r
2674         public void forIsSubrelationOf(Resource resource, Resource relation,\r
2675                         SyncListener<Boolean> procedure) {\r
2676                 graph.forIsSubrelationOf(resource, relation, procedure);\r
2677         }\r
2678 \r
2679         @Override\r
2680         public void forIsSubrelationOf(Resource resource, Resource relation,\r
2681                         Listener<Boolean> procedure) {\r
2682                 graph.forIsSubrelationOf(resource, relation, procedure);\r
2683         }\r
2684 \r
2685         @Override\r
2686         public void forIsSubrelationOf(Resource resource, Resource relation,\r
2687                         AsyncProcedure<Boolean> procedure) {\r
2688                 graph.forIsSubrelationOf(resource, relation, procedure);\r
2689         }\r
2690 \r
2691         @Override\r
2692         public void forIsSubrelationOf(Resource resource, Resource relation,\r
2693                         SyncProcedure<Boolean> procedure) {\r
2694                 graph.forIsSubrelationOf(resource, relation, procedure);\r
2695         }\r
2696 \r
2697         @Override\r
2698         public void forIsSubrelationOf(Resource resource, Resource relation,\r
2699                         Procedure<Boolean> procedure) {\r
2700                 graph.forIsSubrelationOf(resource, relation, procedure);\r
2701         }\r
2702 \r
2703         @Override\r
2704         public void forOrderedSet(Resource subject,\r
2705                         AsyncMultiListener<Resource> procedure) {\r
2706                 graph.forOrderedSet(subject, procedure);\r
2707         }\r
2708 \r
2709         @Override\r
2710         public void forOrderedSet(Resource subject,\r
2711                         SyncMultiListener<Resource> procedure) {\r
2712                 graph.forOrderedSet(subject, procedure);\r
2713         }\r
2714 \r
2715         @Override\r
2716         public void forOrderedSet(Resource subject,\r
2717                         MultiListener<Resource> procedure) {\r
2718                 graph.forOrderedSet(subject, procedure);\r
2719         }\r
2720 \r
2721         @Override\r
2722         public void forOrderedSet(Resource subject,\r
2723                         AsyncMultiProcedure<Resource> procedure) {\r
2724                 graph.forOrderedSet(subject, procedure);\r
2725         }\r
2726 \r
2727         @Override\r
2728         public void forOrderedSet(Resource subject,\r
2729                         SyncMultiProcedure<Resource> procedure) {\r
2730                 graph.forOrderedSet(subject, procedure);\r
2731         }\r
2732 \r
2733         @Override\r
2734         public void forOrderedSet(Resource subject,\r
2735                         MultiProcedure<Resource> procedure) {\r
2736                 graph.forOrderedSet(subject, procedure);\r
2737         }\r
2738 \r
2739         @Override\r
2740         public int thread() {\r
2741                 return graph.thread();\r
2742         }\r
2743 \r
2744         @Override\r
2745         public Session getSession() {\r
2746                 return graph.getSession();\r
2747         }\r
2748 \r
2749         @Override\r
2750         public Resource getBuiltin(String id) throws ResourceNotFoundException,\r
2751                         ServiceException {\r
2752                 return graph.getBuiltin(id);\r
2753         }\r
2754         \r
2755         @Override\r
2756         public VirtualGraph getProvider() {\r
2757                 return graph.getProvider();\r
2758         }\r
2759 \r
2760         @Override\r
2761         public boolean isImmutable(Resource resource) throws DatabaseException {\r
2762                 return graph.isImmutable(resource);\r
2763         }\r
2764 \r
2765     @Override\r
2766     public <T> T getValue2(Resource subject, Object context) throws DatabaseException {\r
2767         return graph.getValue2(subject, context);\r
2768     }\r
2769 \r
2770     @Override\r
2771     public <T> T getPossibleValue2(Resource subject, Object context) throws DatabaseException {\r
2772         return graph.getPossibleValue2(subject, context);\r
2773     }\r
2774 \r
2775     @Override\r
2776     public <T> T getValue2(Resource subject, Object context, Binding binding) throws DatabaseException {\r
2777         return graph.getValue2(subject, context, binding);\r
2778     }\r
2779 \r
2780     @Override\r
2781     public <T> T getPossibleValue2(Resource subject, Object context, Binding binding) throws DatabaseException {\r
2782         return graph.getPossibleValue2(subject, context, binding);\r
2783     }\r
2784 \r
2785 }\r