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