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

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